Kurs Python · Moduł 2: Struktury danych

Słowniki - Katalogowanie odkryć

10 min czytania ·
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 klucza
  • dict.get(key) - zwraca None jeśli brak klucza
  • dict.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:

  1. Dodaj klucz "vehicle" z wartością "jeep"
  2. Zmień "budget_usd" na 20000
  3. Metodą update() dodaj "species_found": 12 i "photos_taken": 340
  4. 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. 1. Słownik w Pythonie przechowuje:

  2. 2. Jak uzyskać wartość klucza 'name' ze słownika 'animal'?

  3. 3. Jaka jest zaleta dict.get('key') nad dict['key']?

  4. 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:

  1. PytanieCzym jest słownik?
  2. PytanieDostęp do wartości
  3. PytanieMetoda get()
  4. Kliknij w kolejnościBudowanie list comprehension
  5. PytanieIteracja po słowniku
  6. Zadanie z kodemTworzenie słownika
  7. Zadanie z kodemDostęp do danych
  8. Zadanie z kodemDodawanie do słownika
  9. Ułóż w kolejnościPraca ze słownikiem - pełny cykl
  10. Ułóż w kolejnościTworzenie słownika
  11. Kliknij w kolejnościDostęp do wartości
  12. Ułóż w kolejnościPraca ze słownikiem

Przydatne artykuły