Listy – list []

Lista to uporządkowana, zmieniana kolekcja, która może przechowywać różne typy danych. Odpowiednik tablic dynamicznych z innych języków.

Tworzenie listy

# Lista z różnymi typami
lst = ["wartość1", 2, 1.22, ["lista w liście"], "Kama"]
print(lst)
print(type(lst))  # <class 'list'>

Indeksowanie list

Indeksy w Pythonie zaczynają się od 0.

lst = ["wartość1", 2, 1.22, ["lista w liście"], "Kama"]
#      [0]        [1] [2]   [3]                  [4]

# Dostęp do elementów
print(lst[0])  # wartość1
print(lst[1])  # 2
print(lst[4])  # Kama

# Lista w liście (lista zagnieżdżona)
print(lst[3])     # ["lista w liście"]
print(lst[3][0])  # lista w liście

Indeksowanie od końca

Ujemne indeksy liczą od końca listy.

lst = ["wartość1", 2, 1.22, ["lista w liście"], "Kama"]

print(lst[-1])  # Kama (ostatni element)
print(lst[-2])  # ["lista w liście"] (przedostatni)
print(lst[-5])  # wartość1 (pierwszy element)

Wycinki (slicing)

lst = ["a", "b", "c", "d", "e"]

# Fragment listy od indeksu do indeksu
print(lst[1:4])   # ["b", "c", "d"] (od 1 do 4, bez 4)

# Od początku do indeksu
print(lst[:3])    # ["a", "b", "c"]

# Od indeksu do końca
print(lst[2:])    # ["c", "d", "e"]

# Cała lista
print(lst[:])     # ["a", "b", "c", "d", "e"]

# Od końca
print(lst[-3:])   # ["c", "d", "e"] (ostatnie 3 elementy)

Modyfikacja listy

lst = ["wartość1", 2, 1.22, "Kama"]

# Zmiana pojedynczego elementu
lst[1] = 4
print(lst)  # ["wartość1", 4, 1.22, "Kama"]

# Zmiana wielu elementów
print(lst[1:3])        # [4, 1.22]
lst[1:3] = ['a', 'b', 'c']  # Zamieniamy 2 elementy na 3
print(lst)  # ["wartość1", 'a', 'b', 'c', "Kama"]

Dodawanie elementów

lst = ["a", "b", "c"]

# append() - dodaj na końcu
lst.append("d")
print(lst)  # ["a", "b", "c", "d"]

# insert() - wstaw na konkretnej pozycji
lst.insert(1, "x")  # Wstaw "x" na indeks 1
print(lst)  # ["a", "x", "b", "c", "d"]

# extend() - dodaj wiele elementów
lst.extend(["e", "f"])
print(lst)  # ["a", "x", "b", "c", "d", "e", "f"]

Usuwanie elementów

lst = ["a", "b", "c", "d", "e"]

# remove() - usuń po wartości
lst.remove("c")
print(lst)  # ["a", "b", "d", "e"]

# pop() - usuń i zwróć ostatni element
ostatni = lst.pop()
print(ostatni)  # "e"
print(lst)      # ["a", "b", "d"]

# pop(index) - usuń element na podanym indeksie
drugi = lst.pop(1)
print(drugi)  # "b"
print(lst)    # ["a", "d"]

# del - usuń przez indeks lub wycinek
del lst[0]
print(lst)  # ["d"]

# clear() - wyczyść całą listę
lst.clear()
print(lst)  # []

Operacje na listach

lst1 = [1, 2, 3]
lst2 = [4, 5, 6]

# Łączenie list
polaczona = lst1 + lst2
print(polaczona)  # [1, 2, 3, 4, 5, 6]

# Mnożenie listy
powtorzona = lst1 * 3
print(powtorzona)  # [1, 2, 3, 1, 2, 3, 1, 2, 3]

# Długość listy
print(len(lst1))  # 3

# Sprawdzanie czy element jest w liście
print(2 in lst1)  # True
print(10 in lst1) # False

Przydatne metody list

lst = [3, 1, 4, 1, 5, 9, 2]

# sort() - sortuj listę (modyfikuje oryginalną)
lst.sort()
print(lst)  # [1, 1, 2, 3, 4, 5, 9]

# reverse() - odwróć kolejność
lst.reverse()
print(lst)  # [9, 5, 4, 3, 2, 1, 1]

# count() - policz wystąpienia wartości
print(lst.count(1))  # 2

# index() - znajdź indeks pierwszego wystąpienia
print(lst.index(5))  # 1

# copy() - skopiuj listę
kopia = lst.copy()

Słowniki – dict {}

Słownik to nieuporządkowana kolekcja par klucz: wartość. Odpowiednik tablic asocjacyjnych z PHP lub Map z Javy.

Tworzenie słownika

# Podstawowy słownik
osoba = {
    "name": "Kama",
    "surname": "Kaczmarek",
    "mail": "kamakaczmarek@zse-zdwola.pl"
}

print(osoba)
print(type(osoba))  # <class 'dict'>

Dostęp do wartości

osoba = {
    "name": "Kama",
    "surname": "Kaczmarek",
    "age": 30
}

# Dostęp przez klucz
print(osoba["name"])     # Kama
print(osoba["surname"])  # Kaczmarek

# get() - bezpieczniejszy sposób (nie wyrzuca błędu)
print(osoba.get("name"))  # Kama
print(osoba.get("city"))  # None (klucz nie istnieje)
print(osoba.get("city", "Warszawa"))  # Warszawa (wartość domyślna)

Modyfikacja słownika

osoba = {
    "name": "Kama",
    "surname": "Kaczmarek"
}

# Dodawanie nowego klucza
osoba["employment"] = "teacher"
print(osoba)
# {'name': 'Kama', 'surname': 'Kaczmarek', 'employment': 'teacher'}

# Zmiana wartości
osoba["name"] = "Kamila"
print(osoba)

# Usuwanie klucza
del osoba["surname"]
print(osoba)
# {'name': 'Kamila', 'employment': 'teacher'}

Przydatne metody słowników

osoba = {
    "name": "Kama",
    "age": 30,
    "city": "Warsaw"
}

# keys() - wszystkie klucze
print(osoba.keys())  # dict_keys(['name', 'age', 'city'])

# values() - wszystkie wartości
print(osoba.values())  # dict_values(['Kama', 30, 'Warsaw'])

# items() - wszystkie pary klucz-wartość
print(osoba.items())
# dict_items([('name', 'Kama'), ('age', 30), ('city', 'Warsaw')])

# pop() - usuń i zwróć wartość
age = osoba.pop("age")
print(age)    # 30
print(osoba)  # {'name': 'Kama', 'city': 'Warsaw'}

# update() - zaktualizuj słownik
osoba.update({"age": 31, "country": "Poland"})
print(osoba)

# clear() - wyczyść słownik
osoba.clear()
print(osoba)  # {}

Krotki – tuple ()

Krotka to uporządkowana, niezmieniana (immutable) kolekcja. Podobna do listy, ale nie można jej modyfikować po utworzeniu.

Tworzenie krotki

# Krotka z różnymi typami
animals = ("kot", "pies", "koń", "modliszka", "kot",)
# Przecinek na końcu zapewnia że Python rozpozna to jako krotkę

print(animals)
print(type(animals))  # <class 'tuple'>

# Krotka jednoelementowa WYMAGA przecinka
jednoelement = (5,)
print(type(jednoelement))  # <class 'tuple'>

# Bez przecinka to NIE jest krotka
nie_krotka = (5)
print(type(nie_krotka))  # <class 'int'>

Dostęp do elementów krotki

animals = ("kot", "pies", "koń", "modliszka")

# Indeksowanie (jak lista)
print(animals[0])   # kot
print(animals[-1])  # modliszka

# Wycinki (jak lista)
print(animals[1:3])  # ("pies", "koń")

Krotki są niemutowalne

animals = ("kot", "pies", "koń")

# ŹLE - nie możesz zmieniać krotki
# animals[0] = "ptak"  # TypeError

# DOBRZE - musisz stworzyć nową krotkę
animals = ("ptak", "pies", "koń")

Dlaczego używać krotek?

• Szybsze niż listy
• Bezpieczniejsze – nie można przypadkowo zmienić
• Klucze w słownikach – krotki mogą być kluczami, listy nie

Metody krotek

Krotki mają tylko 2 metody (bo są niemutowalne).

animals = ("kot", "pies", "koń", "kot", "pies")

# count() - ile razy występuje wartość
print(animals.count("kot"))  # 2

# index() - indeks pierwszego wystąpienia
print(animals.index("koń"))  # 2

Zestawy – set {}

Zestaw to nieuporządkowana kolekcja unikalnych elementów. Kolejność nie jest gwarantowana.

Tworzenie zestawu

# Podstawowy zestaw
sets = {"wartość 1", "wartość 2", "wartość 3"}
print(sets)
print(type(sets))  # <class 'set'>

# UWAGA: Kolejność nie jest zachowana!
# Za każdym razem może być inna

Unikalne wartości

Zestawy automatycznie usuwają duplikaty.

# Duplikaty są ignorowane
sets = {"wartość 1", "wartość 2", "wartość 2", "wartość 3"}
print(sets)  # {"wartość 1", "wartość 2", "wartość 3"}

# Praktyczne zastosowanie - usuwanie duplikatów z listy
lista_z_duplikatami = [1, 2, 2, 3, 3, 3, 4]
unikalne = set(lista_z_duplikatami)
print(unikalne)  # {1, 2, 3, 4}

Operacje na zestawach

zestaw = {"a", "b", "c"}

# add() - dodaj element
zestaw.add("d")
print(zestaw)

# remove() - usuń element (błąd jeśli nie istnieje)
zestaw.remove("a")
print(zestaw)

# discard() - usuń element (bez błędu jeśli nie istnieje)
zestaw.discard("x")  # Nie ma "x", ale nie ma błędu

# clear() - wyczyść zestaw
zestaw.clear()
print(zestaw)  # set()

Operacje matematyczne na zestawach

A = {1, 2, 3, 4}
B = {3, 4, 5, 6}

# Suma (union)
print(A | B)  # {1, 2, 3, 4, 5, 6}
print(A.union(B))

# Przecięcie (intersection)
print(A & B)  # {3, 4}
print(A.intersection(B))

# Różnica
print(A - B)  # {1, 2} (w A ale nie w B)
print(A.difference(B))

# Różnica symetryczna (XOR)
print(A ^ B)  # {1, 2, 5, 6} (w A lub B, ale nie w obu)
print(A.symmetric_difference(B))

Ćwiczenia

Listy

1. Stwórz listę zawierającą nazwy 5 twoich ulubionych owoców. Wyświetl całą listę.
2. Z listy utworzonej w poprzednim zadaniu wyświetl pierwszy i ostatni element.
3. Stwórz listę liczb od 1 do 10. Wyświetl elementy od indeksu 3 do 7.
4. Stwórz pustą listę, dodaj do niej trzy elementy używając metody append(), a następnie wyświetl całą listę.
5. Stwórz listę [1, 2, 3, 4, 5] i zmień wartość trzeciego elementu na 10. Wyświetl zmodyfikowaną listę.
6. Stwórz listę z pięcioma liczbami. Usuń drugi element używając metody pop() i wyświetl usuniętą wartość oraz zmodyfikowaną listę.
7. Stwórz dwie listy: jedną z liczbami [1, 2, 3], drugą z liczbami [4, 5, 6]. Połącz je w jedną listę i wyświetl wynik.
8. Stwórz listę [„jabłko”, „banan”, „jabłko”, „gruszka”, „jabłko”]. Policz ile razy występuje „jabłko” używając odpowiedniej metody.
9. Stwórz listę [5, 2, 8, 1, 9] i posortuj ją rosnąco. Wyświetl posortowaną listę.
10. Stwórz listę z losowymi liczbami i użyj metody reverse() aby odwrócić kolejność elementów.

Słowniki

1. Stwórz słownik zawierający informacje o sobie: imię, nazwisko, wiek, miasto. Wyświetl cały słownik.
2. Z słownika utworzonego w poprzednim zadaniu wyświetl tylko wartość dla klucza „wiek”.
3. Dodaj do słownika z zadania 26 nowy klucz „zawód” z odpowiednią wartością.
4. Stwórz słownik z trzema parami klucz-wartość, a następnie usuń jeden klucz używając del.
5. Stwórz słownik książki zawierający: tytuł, autor, rok wydania, liczba stron. Wyświetl wszystkie klucze tego słownika używając metody keys().
6. Używając słownika z zadania 30, wyświetl wszystkie wartości używając metody values().
7. Stwórz słownik produktu (nazwa, cena, ilość). Zaktualizuj cenę używając metody update().
8. Stwórz słownik z trzema kluczami. Spróbuj pobrać wartość dla nieistniejącego klucza używając metody get() z wartością domyślną „Brak danych”.

Krotki

1. Stwórz krotkę zawierającą nazwy 4 pór roku. Wyświetl całą krotkę.
2. Z krotki utworzonej w poprzednim zadaniu wyświetl drugą porę roku (indeks 1).
3. Stwórz krotkę z liczbami (1, 2, 3, 4, 5). Spróbuj zmienić pierwszy element na 10. Opisz co się stało.
4. Stwórz krotkę („kot”, „pies”, „kot”, „papuga”, „kot”). Policz ile razy występuje „kot” używając odpowiedniej metody.
5. Stwórz krotkę jednoelementową zawierającą liczbę 5. Sprawdź jej typ używając type().
6. Stwórz dwie krotki i połącz je używając operatora +. Wyświetl wynik.
7. Znajdź indeks pierwszego wystąpienia wartości „zima” w krotce zawierającej pory roku.

Zestawy (sets)

1. Stwórz zestaw zawierający liczby: 1, 2, 3, 4, 5. Wyświetl zestaw.
2. Stwórz zestaw z duplikatami: {1, 2, 2, 3, 3, 3, 4}. Wyświetl go i zaobserwuj co się stało z duplikatami.
3. Stwórz listę z duplikatami [„a”, „b”, „a”, „c”, „b”] i przekształć ją w zestaw aby usunąć duplikaty.
4. Stwórz zestaw {1, 2, 3} i dodaj do niego liczbę 4 używając metody add().
5. Stwórz dwa zestawy: A = {1, 2, 3, 4} i B = {3, 4, 5, 6}. Znajdź ich sumę (union) używając operatora |.
6. Używając zestawów z zadania 45, znajdź ich przecięcie (intersection) używając operatora &.
7. Używając zestawów z zadania 45, znajdź różnicę A – B (elementy w A, których nie ma w B).
8. Stwórz zestaw {10, 20, 30} i usuń z niego element 20 używając metody discard().

Zadania złożone

1. Stwórz listę zawierającą różne typy danych: int, float, string, bool, None. Przejdź przez listę i wyświetl typ każdego elementu.
2. Stwórz słownik reprezentujący dane pracownika: imię, stanowisko, pensja (jako float), czy jest na etacie (bool). Wyświetl słownik i każdą wartość osobno z opisem.
3. Stwórz listę liczb od 1 do 20. Stwórz z niej trzy nowe listy: jedną z liczbami parzystymi, drugą z nieparzystymi, trzecią z liczbami większymi od 10.
4. Stwórz krotkę z trzema liczbami. Spróbuj przekształcić ją na listę, zmodyfikować pierwszy element, a następnie przekształcić z powrotem na krotkę. Wyświetl wynik końcowy.
5. Stwórz słownik z danymi 3 książek (każda książka to zagnieżdżony słownik z tytułem, autorem, rokiem). Wyświetl wszystkie tytuły książek.
6. Pobierz od użytkownika dwie liczby jako stringi (użyj input()), przekształć je na int, dodaj do siebie i wyświetl wynik.
7. Stwórz listę mieszanych typów danych. Używając rzutowania i metod, policz ile jest w niej: liczb całkowitych, stringów i wartości bool.
8. Stwórz dwa zestawy liczb. Znajdź wszystkie możliwe operacje na zestawach (union, intersection, difference, symmetric difference) i wyświetl wyniki z opisami.
9. Stwórz listę z 10 losowymi liczbami (mogą się powtarzać). Przekształć ją na zestaw, policz ile było unikalnych wartości, a następnie przekształć z powrotem na posortowaną listę.
10. Stwórz „bazę danych” studentów jako listę słowników. Każdy słownik to student z kluczami: imię, wiek, ocena. Stwórz minimum 3 studentów i wyświetl całą strukturę.