Kurs Python · Moduł 2: Struktury danych
Słowniki - Katalogowanie odkryć
W tej lekcji17
Witaj ponownie! Darwin tutaj z kolejną ważną lekcją.
W poprzedniej lekcji nauczyłeś/aś się list - uporządkowanych kolekcji jak szlaki ekspedycji. Ale czasem potrzebujesz czegoś więcej - sposobu na katalogowanie swoich odkryć z dodatkowymi informacjami. W dżungli każdy gatunek ma swoją kartę z danymi: siedlisko, wielkość, czy jest niebezpieczny. W Pythonie używamy do tego słowników (dictionaries).
Czym są słowniki?
Słownik to kolekcja par klucz: wartość. Wyobraź sobie katalog odkryć, gdzie każdy gatunek (klucz) ma swoją kartę z informacjami (wartość).
# Katalog gatunku - klucz to nazwa, wartość to szczegóły
species_info = {
"Python regius": "Pyton królewski, 1-2m, niegroźny",
"Panthera leo": "Lew, 2-3m, bardzo niebezpieczny",
"Loxodonta africana": "Słoń afrykański, 3-4m, spokojny"
}
# Bardziej złożony katalog
detailed_catalog = {
"Python regius": {
"nazwa_pl": "Pyton królewski",
"długość_m": 1.5,
"habitat": "jungle",
"niebezpieczny": False
},
"Panthera leo": {
"nazwa_pl": "Lew",
"długość_m": 2.5,
"habitat": "savanna",
"niebezpieczny": True
}
}Kluczowe cechy słowników:
- Pary klucz-wartość - każdy klucz prowadzi do wartości
- Zachowują kolejność dodawania (od Pythona 3.7), ale nie mają indeksów - wartość wyciągasz po kluczu
- Klucze muszą być unikalne i niemutowalne (string, int, tuple)
- Wartości mogą być dowolne - nawet inne słowniki!
- Mutowalne (mutable) - można je modyfikować
Tworzenie słowników
# Pusty słownik - czysty katalog
empty_catalog = {}
empty_dict = dict()
# Słownik z danymi
explorer_data = {
"imię": "Darwin",
"wiek": 35,
"zawód": "Badacz",
"odkrycia": 47
}
# Różne typy kluczy (ale najczęściej stringi)
mixed_keys = {
"name": "Python",
42: "Odpowiedź",
(10, 20): "Współrzędne"
}
# Zagnieżdżone słowniki
expedition = {
"lokalizacja": "Amazonia",
"zespół": {
"lider": "Darwin",
"liczba": 5
},
"ekwipunek": ["Lornetka", "Mapa", "GPS"]
}
# Konstruktor dict()
from_pairs = dict([("A", 1), ("B", 2), ("C", 3)])
with_kwargs = dict(name="Darwin", age=35, job="Explorer")Dostęp do wartości
species = {
"Python regius": "Pyton królewski",
"Panthera leo": "Lew",
"Loxodonta africana": "Słoń"
}
# Dostęp przez klucz (nawiasy kwadratowe)
python_name = species["Python regius"] # "Pyton królewski"
lion_name = species["Panthera leo"] # "Lew"
# KeyError jeśli klucz nie istnieje!
# wrong = species["Tyrannosaurus"] # KeyError!
# Bezpieczny dostęp - get()
python_name = species.get("Python regius") # "Pyton królewski"
trex = species.get("Tyrannosaurus") # None
trex = species.get("Tyrannosaurus", "Nie znaleziono") # "Nie znaleziono"
print(f"Pyton: {python_name}")get() vs []:
dict[key]- rzuca KeyError jeśli brak kluczadict.get(key)- zwraca None jeśli brak kluczadict.get(key, default)- zwraca default jeśli brak klucza
Dodawanie i modyfikowanie
catalog = {
"Python regius": {"długość": 1.5, "habitat": "jungle"}
}
# Dodawanie nowego wpisu
catalog["Panthera leo"] = {"długość": 2.5, "habitat": "savanna"}
# Modyfikowanie istniejącego
catalog["Python regius"]["długość"] = 1.8
# Dodawanie przez update() - słownik lub pary klucz-wartość
catalog.update({"Loxodonta africana": {"długość": 4.0, "habitat": "savanna"}})
catalog.update(discovered_by="Darwin", year=2024)
print(catalog)Usuwanie elementów
species = {
"Python": "Pyton",
"Leo": "Lew",
"Elephas": "Słoń",
"Giraffa": "Żyrafa"
}
# del - usuń przez klucz
del species["Giraffa"]
# pop() - usuń i zwróć wartość
leo_value = species.pop("Leo") # "Lew"
print(leo_value)
# pop() z defaultem (jeśli nie ma klucza)
dino = species.pop("T-Rex", "Nie znaleziono") # "Nie znaleziono"
# popitem() - usuń i zwróć OSTATNIĄ parę (Python 3.7+)
last_item = species.popitem() # ("Elephas", "Słoń")
# clear() - wyczyść cały słownik
species.clear()
print(species) # {}Sprawdzanie obecności klucza
catalog = {
"Python regius": "Pyton",
"Panthera leo": "Lew"
}
# in - sprawdź czy klucz istnieje
if "Python regius" in catalog:
print("Pyton jest w katalogu!")
if "T-Rex" not in catalog:
print("T-Rex nie ma w katalogu")
# Uwaga: 'in' sprawdza KLUCZE, nie wartości!
print("Pyton" in catalog) # False (to wartość, nie klucz!)Iteracja przez słownik
species = {
"Python regius": "Pyton królewski",
"Panthera leo": "Lew",
"Loxodonta africana": "Słoń afrykański"
}
# Iteracja przez klucze (default)
for species_name in species:
print(species_name)
# Jawnie przez klucze - keys()
for key in species.keys():
print(key)
# Iteracja przez wartości - values()
for name_pl in species.values():
print(name_pl)
# Iteracja przez pary klucz-wartość - items() (najczęściej!)
for species_name, name_pl in species.items():
print(f"{species_name}: {name_pl}")
# Enumerate dla numerowania
for i, (key, value) in enumerate(species.items(), start=1):
print(f"{i}. {key} -> {value}")Metody słowników
keys(), values(), items()
catalog = {
"Python": {"habitat": "jungle", "size": 1.5},
"Leo": {"habitat": "savanna", "size": 2.5}
}
# Wszystkie klucze
all_keys = catalog.keys() # dict_keys(['Python', 'Leo'])
keys_list = list(catalog.keys()) # Lista: ['Python', 'Leo']
# Wszystkie wartości
all_values = catalog.values() # dict_values([{...}, {...}])
# Wszystkie pary
all_items = catalog.items() # dict_items([('Python', {...}), ('Leo', {...})])
# Konwersja na listy
keys = list(catalog.keys())
values = list(catalog.values())
items = list(catalog.items())get() - bezpieczny dostęp
species = {"Python": "Pyton", "Leo": "Lew"}
# get(key) - None jeśli brak
result = species.get("Python") # "Pyton"
result = species.get("T-Rex") # None
# get(key, default) - własny default
result = species.get("T-Rex", "Nie znaleziono!") # "Nie znaleziono!"setdefault() - zwróć wartość LUB ustaw domyślną
catalog = {"Python": {"count": 5}}
# Jeśli klucz istnieje - zwróć wartość
python_data = catalog.setdefault("Python", {"count": 0})
print(python_data) # {'count': 5}
# Jeśli klucz NIE istnieje - dodaj z defaultem
leo_data = catalog.setdefault("Leo", {"count": 0})
print(leo_data) # {'count': 0}
print(catalog) # {'Python': {...}, 'Leo': {'count': 0}}update() - aktualizuj/scal słowniki
catalog1 = {"Python": "Pyton", "Leo": "Lew"}
catalog2 = {"Elephas": "Słoń", "Giraffa": "Żyrafa"}
new_data = {"Python": "Pyton królewski"} # Nadpisze
# Aktualizacja słownikiem
catalog1.update(catalog2)
print(catalog1) # {'Python': 'Pyton', 'Leo': 'Lew', 'Elephas': 'Słoń', 'Giraffa': 'Żyrafa'}
# Aktualizacja parami klucz=wartość
catalog1.update(discovered_by="Darwin", year=2024)copy() - kopiowanie słownika
# UWAGA - to NIE kopiuje!
original = {"A": 1, "B": 2}
reference = original # Ta sama referencja!
reference["A"] = 999
print(original) # {'A': 999, 'B': 2} - zmienione!
# Prawidłowe kopiowanie
original = {"A": 1, "B": 2}
copy1 = original.copy() # Płytka kopia
copy2 = dict(original) # Alternatywa
copy1["A"] = 999
print(original) # {'A': 1, 'B': 2} - bez zmian!
# Głęboka kopia (dla zagnieżdżonych słowników)
import copy
nested = {"team": {"leader": "Darwin", "size": 5}}
deep = copy.deepcopy(nested)
deep["team"]["leader"] = "Alex"
print(nested) # {'team': {'leader': 'Darwin', 'size': 5}} - bez zmian!Dictionary comprehensions
Podobnie jak list comprehensions, możesz tworzyć słowniki w jednej linii!
# Tradycyjny sposób
squares = {}
for x in range(1, 6):
squares[x] = x ** 2
# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
# Dict comprehension!
squares = {x: x ** 2 for x in range(1, 6)}
# {1: 1, 2: 4, 3: 9, 4: 16, 5: 25}
# Z warunkiem
even_squares = {x: x ** 2 for x in range(1, 11) if x % 2 == 0}
# {2: 4, 4: 16, 6: 36, 8: 64, 10: 100}
# Zamiana kluczy i wartości
species = {"Python": "Pyton", "Leo": "Lew"}
reversed_dict = {value: key for key, value in species.items()}
# {"Pyton": "Python", "Lew": "Leo"}
# Z dwóch list
names = ["Python", "Leo", "Elephas"]
polish_names = ["Pyton", "Lew", "Słoń"]
catalog = {name: pl_name for name, pl_name in zip(names, polish_names)}Zagnieżdżone słowniki
Słowniki mogą zawierać inne słowniki - idealne dla złożonych danych!
# Katalog ekspedycji ze szczegółami każdego gatunku
species_database = {
"Python regius": {
"nazwa_pl": "Pyton królewski",
"charakterystyka": {
"długość_m": 1.5,
"waga_kg": 2.5,
"siedlisko": "jungle"
},
"status": "discovered",
"odkrywca": "Darwin",
"data": "2024-01-15"
},
"Panthera leo": {
"nazwa_pl": "Lew",
"charakterystyka": {
"długość_m": 2.5,
"waga_kg": 190,
"siedlisko": "savanna"
},
"status": "observed",
"odkrywca": "Team B"
}
}
# Dostęp do zagnieżdżonych wartości
python_length = species_database["Python regius"]["charakterystyka"]["długość_m"]
print(f"Długość pytona: {python_length}m")
# Bezpieczny dostęp do głęboko zagnieżdżonych wartości
leo_weight = species_database.get("Panthera leo", {}).get("charakterystyka", {}).get("waga_kg", "Brak danych")
print(f"Waga lwa: {leo_weight}kg")Operacje na słownikach
# Długość (liczba par klucz-wartość)
species = {"Python": "Pyton", "Leo": "Lew", "Elephas": "Słoń"}
count = len(species) # 3
# Scalanie słowników (Python 3.9+)
dict1 = {"A": 1, "B": 2}
dict2 = {"C": 3, "D": 4}
merged = dict1 | dict2 # {'A': 1, 'B': 2, 'C': 3, 'D': 4}
# Scalanie z nadpisaniem (Python 3.9+)
dict1 = {"A": 1, "B": 2}
dict2 = {"B": 999, "C": 3}
merged = dict1 | dict2 # {'A': 1, 'B': 999, 'C': 3} - B nadpisane!
# Operator |= (modyfikuje pierwszy słownik)
dict1 |= dict2 # dict1 teraz zawiera scalone dane
# Min/Max kluczy
species = {"Python": 5, "Leo": 12, "Elephas": 3}
max_key = max(species) # "Python" (alfabetycznie)
max_value = max(species.values()) # 12
max_by_value = max(species, key=species.get) # "Leo" (największa wartość)Sortowanie słowników
species_count = {
"Python": 5,
"Leo": 12,
"Elephas": 3,
"Giraffa": 8
}
# Sortowanie po kluczach
sorted_by_key = dict(sorted(species_count.items()))
# {'Elephas': 3, 'Giraffa': 8, 'Leo': 12, 'Python': 5}
# Sortowanie po wartościach
sorted_by_value = dict(sorted(species_count.items(), key=lambda x: x[1]))
# {'Elephas': 3, 'Python': 5, 'Giraffa': 8, 'Leo': 12}
# Sortowanie malejąco po wartościach
sorted_desc = dict(sorted(species_count.items(), key=lambda x: x[1], reverse=True))
# {'Leo': 12, 'Giraffa': 8, 'Python': 5, 'Elephas': 3}Praktyczny przykład - System katalogowania
# System katalogowania odkrytych gatunków
species_catalog = {}
def add_species(name, name_pl, habitat, dangerous, notes=""):
"""Dodaj gatunek do katalogu"""
species_catalog[name] = {
"nazwa_pl": name_pl,
"habitat": habitat,
"niebezpieczny": dangerous,
"notatki": notes,
"data_odkrycia": "2024-11-24" # Przykładowa data
}
print(f"Dodano: {name}")
def show_catalog():
"""Wyświetl cały katalog"""
if not species_catalog:
print("Katalog jest pusty!")
return
print(f"\n=== KATALOG GATUNKÓW ({len(species_catalog)} wpisów) ===")
for name, data in species_catalog.items():
danger = "NIEBEZPIECZNY" if data["niebezpieczny"] else "Bezpieczny"
print(f"\n{name} ({data['nazwa_pl']})")
print(f" Siedlisko: {data['habitat']}")
print(f" Status: {danger}")
if data["notatki"]:
print(f" Notatki: {data['notatki']}")
def search_species(name):
"""Szukaj gatunku po nazwie"""
if name in species_catalog:
data = species_catalog[name]
print(f"\nZnaleziono: {name}")
print(f"Nazwa polska: {data['nazwa_pl']}")
print(f"Siedlisko: {data['habitat']}")
print(f"Niebezpieczny: {'Tak' if data['niebezpieczny'] else 'Nie'}")
else:
print(f"\nNie znaleziono: {name}")
def filter_by_habitat(habitat):
"""Filtruj gatunki po siedlisku"""
filtered = {name: data for name, data in species_catalog.items()
if data["habitat"] == habitat}
print(f"\nGatunki w siedlisku '{habitat}': {len(filtered)}")
for name in filtered:
print(f" - {name}")
# Użycie systemu
add_species("Python regius", "Pyton królewski", "jungle", False, "Spokojny gatunek")
add_species("Panthera leo", "Lew", "savanna", True, "Obserwować z daleka!")
add_species("Gorilla gorilla", "Goryl", "jungle", False)
show_catalog()
search_species("Python regius")
filter_by_habitat("jungle")Lista vs Słownik - kiedy użyć?
Użyj listy gdy:
- Kolejność jest ważna
- Potrzebujesz dostępu przez indeks numeryczny
- Możesz mieć duplikaty
- Prosty zbiór wartości
Użyj słownika gdy:
- Potrzebujesz szybkiego dostępu przez klucz
- Każdy element ma swoją unikalną etykietę
- Dane mają strukturę klucz-wartość
- Chcesz łatwo sprawdzić czy element istnieje
Zadanie praktyczne
W edytorze czeka rejestr ekspedycji safari_registry. Uzupełnij go:
- Dodaj klucz
"vehicle"z wartością"jeep" - Zmień
"budget_usd"na 20000 - Metodą
update()dodaj"species_found": 12i"photos_taken": 340 - Usuń klucz
"days_remaining"instrukcjądel
Kod do tej lekcji: main.py
# Dodawanie i aktualizacja wpisów w słowniku
safari_registry = {
"expedition_name": "Serengeti 2024",
"leader": "Darwin",
"team_size": 5
}
print("Początkowy rejestr:")
print(safari_registry)
# Dodawanie nowego klucza
safari_registry["location"] = "Tanzania"
safari_registry["budget_usd"] = 15000
# Aktualizacja istniejącego klucza
safari_registry["team_size"] = 7
print("\nPo zmianach:")
print(safari_registry)
# update() - aktualizuje wiele kluczy naraz
safari_registry.update({
"status": "aktywna",
"days_remaining": 14,
"leader": "Jane" # Nadpisuje istniejący
})
print("\nPo update():")
print(safari_registry)
# TODO: Dodaj klucz "vehicle" z wartością "jeep"
# TODO: Zmień "budget_usd" na 20000
# TODO: Użyj update(), aby dodać "species_found": 12 i "photos_taken": 340
# TODO: Usuń klucz "days_remaining", używając del
# del safari_registry["?"]
print("\nKońcowy rejestr:")
for key, value in safari_registry.items():
print(f" {key}: {value}")
Podsumowanie
W tej lekcji nauczyłeś/aś się:
- Czym są słowniki (pary klucz-wartość)
- Tworzenie i dostęp do słowników
- Dodawanie, modyfikowanie, usuwanie elementów
- Metod: keys(), values(), items(), get(), update(), setdefault()
- Dictionary comprehensions
- Zagnieżdżonych słowników
- Iteracji przez słowniki
- Sortowania i operacji na słownikach
Checkpoint
Przed przejściem dalej:
- Rozumiesz różnicę między listą a słownikiem
- Potrafisz użyć get() zamiast []
- Znasz items(), keys(), values()
- Potrafisz iterować przez słownik
- Umiesz tworzyć dict comprehensions
- Rozumiesz zagnieżdżone słowniki
W następnej lekcji Darwin pokaże Ci krotki i zbiory - niezmienne zapisy i rejestr unikalnych gatunków!
Hasła z dokumentacji w tej lekcji
Widzisz błąd w tej lekcji?
Sprawdź się
Odpowiedz na pytania z tej lekcji. Wybierz odpowiedź, a od razu zobaczysz, czy jest poprawna.
1. Słownik w Pythonie przechowuje:
2. Jak uzyskać wartość klucza 'name' ze słownika 'animal'?
3. Jaka jest zaleta dict.get('key') nad dict['key']?
4. Co zwraca dict.items()?
Zadania praktyczne w grze
- Klikanie w kolejności
Kliknij elementy w prawidłowej kolejności:
- Edytor kodu
Utwórz słownik 'tiger' z kluczami: name='Tygrys', weight=200, dangerous=True
- Edytor kodu
Wypisz nazwę zwierzęcia (wartość klucza 'name') ze słownika animal = {'name': 'Pyton', 'length': 5}
- Edytor kodu
Dodaj klucz 'habitat' z wartością 'Dżungla' do słownika animal = {'name': 'Pyton', 'length': 5}
- Układanie w pionie
Uporządkuj kroki budowania katalogu:
- Układanie w poziomie
Uporządkuj: animal = {'name': 'Tygrys'}
- Klikanie w kolejności
Kliknij w kolejności: print(animal['name'])
- Układanie w pionie
Uporządkuj: stwórz słownik, dodaj klucz, wypisz wszystkie klucze:
Zadania po tej lekcji
- PytanieCzym jest słownik?
- PytanieDostęp do wartości
- PytanieMetoda get()
- Kliknij w kolejnościBudowanie list comprehension
- PytanieIteracja po słowniku
- Zadanie z kodemTworzenie słownika
- Zadanie z kodemDostęp do danych
- Zadanie z kodemDodawanie do słownika
- Ułóż w kolejnościPraca ze słownikiem - pełny cykl
- Ułóż w kolejnościTworzenie słownika
- Kliknij w kolejnościDostęp do wartości
- Ułóż w kolejnościPraca ze słownikiem