Szybki quiz – przypomnienie poprzedniej lekcji

Temat: input() i rzutowanie danych wejściowych

Pytanie 1. Co zostanie wyświetlone? (użytkownik wpisuje 4)

x = input("Podaj liczbę: ")
print(x * 3)

Pytanie 2. Znajdź błąd w kodzie.

wiek = input("Podaj wiek: ")
print(wiek + 1)

Pytanie 3. Co zostanie wyświetlone? (użytkownik wpisuje kolejno 19.99 i 3)

cena = float(input("Cena: "))
ile = int(input("Ilość: "))
print(f"Do zapłaty: {cena * ile:.2f} zł")

Pytanie 4. Co stanie się po wykonaniu tego fragmentu? (użytkownik wpisuje abc)

try:
    n = int(input("Liczba: "))
    print(n * 2)
except ValueError:
    print("Błąd!")

Pytanie 5. Co zostanie wyświetlone i jak zsumować te liczby? (użytkownik wpisuje 4 7 9)

dane = input("Liczby: ").split()
print(dane)

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 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 1 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 4, 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. 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 dwa zestawy liczb. Znajdź wszystkie możliwe operacje na zestawach (union, intersection, difference, symmetric difference) i wyświetl wyniki z opisami.
8. 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ę.
9. 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ę.

PODSUMOWANIE

W tej lekcji poznajesz cztery kolekcje, czyli typy przechowujące wiele wartości naraz.

Listy

• Indeksy zaczynają się od 0. Indeks -1 to ostatni element.
• Wycinek lst[a:b] obejmuje elementy od a do b, bez b.
• Dodawanie: append() na końcu, insert(indeks, wartość) w wybranym miejscu, extend() dodaje wiele elementów.
• Usuwanie: remove(wartość) działa po wartości, pop(indeks) po indeksie i zwraca usunięty element, del usuwa przez indeks lub wycinek, clear() czyści całą listę.
• sort() i reverse() zmieniają oryginalną listę, a copy() tworzy kopię.
• Lista może zawierać inną listę: lst[3][0] to pierwszy element listy zagnieżdżonej.

Słowniki

• Wartość pobierasz po kluczu: osoba["name"].
• Nowy klucz dodajesz przypisaniem: osoba["city"] = "Łódź". To samo przypisanie dla istniejącego klucza zmienia jego wartość.
• get(klucz, domyślna) nie zgłasza błędu, gdy klucza brak. Zapis osoba["brak"] zgłasza błąd.
• keys(), values() i items() zwracają odpowiednio klucze, wartości i pary.

Krotki

• Nie można zmienić elementu po utworzeniu (TypeError). Trzeba utworzyć nową krotkę.
• Krotka jednoelementowa wymaga przecinka: (5,). Zapis (5) to zwykła liczba int.
• Mają tylko dwie metody: count() i index().

Zestawy

• Duplikaty są usuwane automatycznie. set(lista) to sposób na usunięcie duplikatów z listy.
• remove() zgłasza błąd, gdy elementu brak. discard() nie zgłasza.
• Operacje: | suma, & przecięcie, - różnica, ^ różnica symetryczna.

Typowe pułapki

• Pomylenie remove() (po wartości) z pop() (po indeksie).
• Zapomnienie, że koniec wycinka nie wchodzi do wyniku.
• sort() zmienia listę i niczego nie zwraca, więc zapis lst = lst.sort() zapisze w lst wartość None.
• Krotka bez przecinka: (5) nie jest krotką.
• Pusty zestaw tworzy się przez set(). Zapis {} tworzy pusty słownik.

Minimum, które powinno wejść w pamięć

Jeżeli masz zapamiętać tylko kilka rzeczy z tej lekcji, zapamiętaj te:

1. Cztery nawiasy, cztery typy: [] lista, {"k": "v"} słownik, () krotka, {1, 2} zestaw.
2. Indeksy zaczynają się od 0, a -1 to ostatni element. Wycinek [a:b] nie zawiera elementu b.
3. Krotka jest niezmienna, a jednoelementowa musi mieć przecinek: (5,).
4. Zestaw nie ma duplikatów i indeksów. set(lista) usuwa duplikaty.
5. Słownik czyta się po kluczu. ["klucz"] zgłosi błąd, gdy klucza brak, a .get("klucz", domyślna) nie.
6. remove() usuwa po wartości, pop() po indeksie (i zwraca element).
7. append() dodaje jeden element na końcu, extend() wiele elementów, insert() w wybranym miejscu.
8. Operacje na zestawach: | suma, & przecięcie, - różnica, ^ różnica symetryczna.
9. Lista może zawierać listy i słowniki, a słownik może zawierać słowniki. Do zagnieżdżonych danych sięgasz po kolei: dane[1]["ocena"].

Ściągawka – najważniejsze polecenia i składnia

Lista

lst = [1, 2, 3]
lst[0]            # pierwszy        lst[-1]   # ostatni
lst[1:3]          # wycinek (bez indeksu 3)
lst[:2]  lst[2:]  lst[-3:]
lst[0] = 10       # zmiana elementu
lst[3][0]         # element listy zagnieżdżonej

Słownik

osoba = {"name": "Kama", "age": 30}
osoba["name"]                  # odczyt (błąd, gdy brak klucza)
osoba.get("city", "brak")      # odczyt bez błędu, z wartością domyślną
osoba["city"] = "Łódź"         # nowy klucz lub zmiana wartości
del osoba["age"]               # usunięcie klucza
osoba.keys()  osoba.values()  osoba.items()
osoba.pop("age")               # usuwa i zwraca wartość
osoba.update({"age": 31})      # aktualizacja wielu kluczy
osoba.clear()

Krotka

k = ("kot", "pies", "kot")
k[0]  k[-1]  k[1:3]            # jak w liście
k.count("kot")  k.index("pies")
t = (5,)                       # jednoelementowa: przecinek obowiązkowy
# k[0] = "ptak"                # TypeError

Zestaw

s = {1, 2, 3}
s.add(4)
s.remove(1)       # błąd, gdy brak elementu
s.discard(99)     # bez błędu
unikalne = set([1, 2, 2, 3])

A | B    A & B    A - B    A ^ B
A.union(B)  A.intersection(B)  A.difference(B)  A.symmetric_difference(B)

Zamiana typów kolekcji

set(lista)   list(krotka)   tuple(lista)

Quiz – sprawdź się

Pytanie 1. (teoria) Która kolekcja nie pozwala zmienić elementu po utworzeniu?

• A) lista
• B) słownik
• C) krotka
• D) zestaw

Pytanie 2. Co zostanie wyświetlone?

lst = ["a", "b", "c", "d", "e"]
print(lst[1:4])
print(lst[-2])
print(lst[:2])

Pytanie 3. Co zostanie wyświetlone?

lst = [1, 2, 3]
lst.append(4)
lst.insert(0, 9)
lst.pop()
print(lst)

Pytanie 4. Znajdź błąd w kodzie i napisz, jak go naprawić.

punkty = (10, 20, 30)
punkty[0] = 15

Pytanie 5. Jakie typy zostaną wyświetlone?

a = (7)
b = (7,)
print(type(a), type(b))

Pytanie 6. Co zostanie wyświetlone?

osoba = {"name": "Kama", "age": 30}
osoba["city"] = "Łódź"
osoba["age"] = 31
print(osoba["name"])
print(osoba.get("age"))
print(osoba.get("zawod", "brak"))

Pytanie 7. Dlaczego ten kod nie działa? Jak odczytać wartość bez błędu?

osoba = {"name": "Kama"}
print(osoba["age"])

Pytanie 8. Co zostanie wyświetlone?

A = {1, 2, 3, 4}
B = {3, 4, 5, 6}
print(A & B)
print(A - B)
print(A ^ B)

Pytanie 9. Uzupełnij kod tak, aby usunąć duplikaty z listy i wyświetlić wynik posortowany rosnąco.

liczby = [5, 3, 5, 1, 3, 9]
unikalne = ____(liczby)
unikalne = list(unikalne)
unikalne.____()
print(unikalne)

Pytanie 10. (wybór poprawnej składni) Który zapis usuwa z listy lst element o indeksie 1 i zwraca go?

• A) lst.remove(1)
• B) lst.pop(1)
• C) lst.clear(1)
• D) lst.del(1)

Pytanie 11. (zadanie praktyczne) Dana jest lista:

studenci = [
    {"imie": "Ola", "ocena": 5},
    {"imie": "Jan", "ocena": 3}
]

Napisz jedną instrukcję, która wyświetli ocenę Jana.

Pytanie 12. (zadanie praktyczne z input()) Napisz kod, który pobierze od użytkownika w jednej linii liczby oddzielone spacją (np. 4 7 9 2), zapisze je jako listę liczb całkowitych i wyświetli pierwszą oraz ostatnią z nich.

['b', 'c', 'd']
d
['a', 'b']

Kama
31
brak

{3, 4}
{1, 2}
{1, 2, 5, 6}

liczby = [int(x) for x in input("Podaj liczby: ").split()]
print(liczby[0], liczby[-1])