Słowniki: klucze i wartości

Witaj z powrotem.

W poprzedniej lekcji nauczyłeś się list.

Twoje programy nauczyły się przechowywać wiele wartości w jednej zmiennej.

Pisałeś rzeczy takie jak:

products = ["Keyboard", "Mouse", "Notebook"]

Bardzo dobrze.

Listy są użyteczne, kiedy potrzebujesz wielu wartości.

Ale czasem lista nie wystarcza.

Spójrz na to:

user = ["Anna", 25, "Rome"]

To działa.

Ale co to znaczy?

Anna to prawdopodobnie imię.
25 to prawdopodobnie wiek.
Rome to prawdopodobnie miasto.

Prawdopodobnie.

A “prawdopodobnie” nie jest dobrą strategią projektowania danych.

Ani życia.

Przeważnie.

Lepszym sposobem jest przechowywanie danych z nazwami.

Tak:

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

Teraz dane są jasne.

"name" wskazuje na "Anna".

"age" wskazuje na 25.

"city" wskazuje na "Rome".

To jest słownik.

Słowniki są bardzo ważne w Pythonie.

Bardzo użyteczne.

Bardzo częste.

Bardzo bliskie temu, jak działają prawdziwe dane w API, JSON, bazach danych, ustawieniach, użytkownikach, produktach, zamówieniach i wielu innych rzeczach.

Innymi słowy:

witaj w danych strukturalnych.

Bardzo elegancko.

Bardzo praktycznie.

Bardzo Python.

Czego się nauczysz

W tej lekcji nauczysz się:

• czym jest słownik;
• jak działają klucze i wartości;
• jak stworzyć słownik;
• jak odczytywać wartości przez klucz;
• jak aktualizować wartości;
• jak dodawać nowe pary klucz-wartość;
• jak usuwać elementy;
• jak używać in;
• jak używać get();
• jak przechodzić przez słowniki pętlami;
• jak przechodzić przez klucze i wartości;
• jak przechowywać słowniki wewnątrz list;
• jak przechowywać listy wewnątrz słowników;
• typowych błędów początkujących;
• jak budować małe programy oparte na słownikach.

Pod koniec tej lekcji twoje programy będą mogły pracować z danymi strukturalnymi.

To ogromny krok.

Bo prawdziwe aplikacje są pełne danych strukturalnych.

Użytkownicy mają imiona.

Produkty mają ceny.

Zamówienia mają sumy.

Zadania mają statusy.

Posty na blogu mają tytuły.

A każdy szef ma “jedną małą zmianę”.

Też strukturalną.

Też niebezpieczną.

Czym jest słownik?

Słownik przechowuje dane jako pary klucz-wartość.

Przykład:

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

Ten słownik ma trzy klucze:

name
age
city

I trzy wartości:

Anna
25
Rome

Klucz jest jak etykieta.

Wartość to dane.

Czyli:

"name": "Anna"

oznacza:

Klucz "name" ma wartość "Anna".

Słownik używa nawiasów klamrowych:

{}

Każdy element ma formę:

klucz: wartość

Elementy są oddzielone przecinkami.

Słownik jest jak mała karta informacyjna.

Bardzo uporządkowana.

Bardzo użyteczna.

Mniej tajemnicza niż user[1].

To jest postęp.

Twój pierwszy słownik

Utwórz plik:

dictionaries.py

Napisz:

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

print(user)

Uruchom:

python dictionaries.py

albo:

python3 dictionaries.py

Output:

{'name': 'Anna', 'age': 25, 'city': 'Rome'}

Python wyświetla cały słownik.

Zauważ:

nawiasy klamrowe
klucze
wartości
dwukropki
przecinki

To jest struktura słownika.

Może wyglądać trochę ciężej niż lista.

Ale jest dużo jaśniejsza dla danych strukturalnych.

Lista mówi:

Oto wartości.
Powodzenia.

Słownik mówi:

Oto wartości z etykietami.
Proszę bardzo.

Bardzo uprzejmie.

Bardzo Python.

Klucze i wartości

Spójrz jeszcze raz:

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

Klucze:

"name"
"age"
"city"

Wartości:

"Anna"
25
"Rome"

Każdy klucz wskazuje na jedną wartość.

Możesz myśleć o tym tak:

name -> Anna
age  -> 25
city -> Rome

Dlatego słowniki są świetne dla danych, które mają znaczenie.

Przykład produktu:

product = {
    "name": "Keyboard",
    "price": 70.00,
    "available": True
}

Teraz wiemy, co oznacza każda wartość.

Bez zgadywania.

Bez tajemniczych numerów indeksów.

Bez “czekaj, pozycja 2 była ceną czy miastem?”

Pięknie.

Odczytywanie wartości przez klucz

Aby odczytać wartość, użyj klucza w nawiasach kwadratowych.

Przykład:

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

print(user["name"])
print(user["age"])
print(user["city"])

Output:

Anna
25
Rome

To jest bardzo ważne.

W listach odczytujesz przez indeks:

products[0]

W słownikach odczytujesz przez klucz:

user["name"]

Klucz mówi Pythonowi, którą wartość chcesz.

Bardzo czytelne.

Bardzo użyteczne.

Bardzo “wreszcie kod sam się tłumaczy”.

Klucze muszą być dokładne

Klucze muszą pasować dokładnie.

Przykład:

user = {
    "name": "Anna",
    "age": 25
}

print(user["name"])

Output:

Anna

Ale to jest błędne:

print(user["Name"])

Python daje błąd:

KeyError

Dlaczego?

Bo "Name" i "name" to różne klucze.

Wielkie litery mają znaczenie.

Spacje mają znaczenie.

Wszystko ma znaczenie.

Python nie zgaduje.

Python nie jest twoją ciocią, która próbuje przypomnieć sobie twoje hasło.

Potrzebuje dokładnego klucza.

Bardzo surowo.

Bardzo użytecznie.

Czasem irytująco.

Aktualizowanie wartości

Możesz zmienić wartość, przypisując nową wartość do istniejącego klucza.

Przykład:

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

user["age"] = 26

print(user)

Output:

{'name': 'Anna', 'age': 26, 'city': 'Rome'}

Zmieniliśmy:

age z 25 na 26

To jest bardzo częste.

Przykład:

product = {
    "name": "Keyboard",
    "price": 70.00
}

product["price"] = 65.00

print(product)

Output:

{'name': 'Keyboard', 'price': 65.0}

Cena produktu się zmieniła.

Sklep jest szczęśliwy.

Klient jest szczęśliwy.

Księgowy jest podejrzliwy.

Normalnie.

Dodawanie nowych par klucz-wartość

Możesz dodać nową parę klucz-wartość, przypisując wartość do nowego klucza.

Przykład:

user = {
    "name": "Anna",
    "age": 25
}

user["city"] = "Rome"

print(user)

Output:

{'name': 'Anna', 'age': 25, 'city': 'Rome'}

Wcześniej słownik miał:

name
age

Potem ma też:

city

To jest użyteczne, kiedy budujesz dane krok po kroku.

Przykład:

product = {}

product["name"] = "Mouse"
product["price"] = 25.00
product["available"] = True

print(product)

Output:

{'name': 'Mouse', 'price': 25.0, 'available': True}

Pusty słownik zaczyna się tak:

product = {}

Potem możesz dodawać dane później.

Jak formularz.

Ale mniej irytujący.

Usuwanie elementów przez del

Możesz usunąć parę klucz-wartość przez del.

Przykład:

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

del user["city"]

print(user)

Output:

{'name': 'Anna', 'age': 25}

Klucz "city" i jego wartość zostały usunięte.

Ważne:

del user["city"]

usuwa całą parę klucz-wartość.

Nie tylko wartość.

Klucz też znika.

Bardzo bezpośrednio.

Bardzo mocno.

Używaj ostrożnie.

del nie pyta:

Czy na pewno?

Python ci ufa.

Odważnie.

Może zbyt odważnie.

Usuwanie elementów przez pop()

Możesz też usunąć element przez pop().

Przykład:

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

city = user.pop("city")

print(city)
print(user)

Output:

Rome
{'name': 'Anna', 'age': 25}

pop() usuwa element i zwraca usuniętą wartość.

Czyli:

city = user.pop("city")

oznacza:

Usuń "city" ze słownika i zapisz jego wartość w city.

To jest użyteczne, kiedy nadal potrzebujesz usuniętej wartości.

del usuwa.

pop() usuwa i zwraca.

Mała różnica.

Duża użyteczność.

Sprawdzanie, czy klucz istnieje

Użyj in, aby sprawdzić, czy klucz istnieje w słowniku.

Przykład:

user = {
    "name": "Anna",
    "age": 25
}

if "name" in user:
    print("Name exists.")
else:
    print("Name is missing.")

Output:

Name exists.

Ważne:

"name" in user

sprawdza klucze.

Nie wartości.

Przykład:

user = {
    "name": "Anna",
    "age": 25
}

print("Anna" in user)

Output:

False

Dlaczego?

Bo "Anna" jest wartością, nie kluczem.

Klucze to:

name
age

To częsta pomyłka początkujących.

Gdy używasz in ze słownikiem, Python domyślnie sprawdza klucze.

Bardzo ważne.

Wytatuuj to w mózgu debugowania.

Może nie dosłownie.

Unikanie KeyError przez get()

Jeśli odczytujesz brakujący klucz nawiasami kwadratowymi, Python daje KeyError.

Przykład:

user = {
    "name": "Anna",
    "age": 25
}

print(user["city"])

Błąd:

KeyError

Bo "city" nie istnieje.

Bezpieczniejszym sposobem jest get().

Przykład:

user = {
    "name": "Anna",
    "age": 25
}

print(user.get("city"))

Output:

None

None oznacza:

brak wartości

Możesz też podać wartość domyślną:

print(user.get("city", "Unknown"))

Output:

Unknown

To jest bardzo użyteczne.

get() pomaga unikać błędów, kiedy klucz może nie istnieć.

Bardzo praktyczne.

Bardzo realne.

Bo prawdziwe dane często są niekompletne.

Jak formularze.

I ludzie.

Nawiasy kwadratowe vs get()

Oba sposoby mogą odczytywać wartości.

Przykład:

user = {
    "name": "Anna"
}

print(user["name"])
print(user.get("name"))

Output:

Anna
Anna

Różnica:

user["city"]

daje błąd, jeśli "city" nie istnieje.

Ale:

user.get("city")

zwraca None.

A:

user.get("city", "Unknown")

zwraca "Unknown".

Prosta zasada:

Używaj [] kiedy klucz musi istnieć.
Używaj get() kiedy klucz może nie istnieć.

To nie jest tylko rada dla początkujących.

To prawdziwa rada programistyczna.

Taka, która ratuje cię przed bugami pojawiającymi się w piątek wieczorem.

Najgorszy gatunek.

Przechodzenie przez klucze słownika

Możesz przechodzić przez słownik pętlą.

Przykład:

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

for key in user:
    print(key)

Output:

name
age
city

Domyślnie przechodzenie przez słownik daje klucze.

To:

for key in user:

oznacza:

Dla każdego klucza w słowniku...

Potem możesz odczytać wartość:

for key in user:
    print(user[key])

Output:

Anna
25
Rome

Bardzo użyteczne.

Klucze otwierają drzwi.

Wartości są za drzwiami.

Słowniki to małe hotele.

Najwyraźniej.

Przechodzenie przez klucze i wartości

Ładniejszym sposobem jest .items().

Przykład:

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

for key, value in user.items():
    print(f"{key}: {value}")

Output:

name: Anna
age: 25
city: Rome

To jest bardzo częste.

.items() daje jednocześnie klucz i wartość.

Pętla:

for key, value in user.items():

oznacza:

Dla każdej pary klucz-wartość w słowniku...

To jeden z najważniejszych schematów ze słownikami.

Naucz się go dobrze.

Wróci.

Jak średniki w SQL.

Ale łagodniej.

Przechodzenie tylko przez wartości

Możesz użyć .values(), jeśli chcesz tylko wartości.

Przykład:

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

for value in user.values():
    print(value)

Output:

Anna
25
Rome

Możesz użyć .keys(), jeśli chcesz tylko klucze:

for key in user.keys():
    print(key)

Output:

name
age
city

Ale pamiętaj:

for key in user:

już przechodzi przez klucze.

Więc .keys() jest opcjonalne w większości przypadków.

Python daje wybory.

Wybory są miłe.

Dopóki nie jest ich za dużo.

Wtedy witaj w programowaniu.

Słownik z inputem użytkownika

Utwórz plik:

user_profile.py

Napisz:

user = {}

user["name"] = input("Name: ")
user["age"] = int(input("Age: "))
user["city"] = input("City: ")

print("User profile:")

for key, value in user.items():
    print(f"{key}: {value}")

Przykład:

Name: Anna
Age: 25
City: Rome

Output:

User profile:
name: Anna
age: 25
city: Rome

Ten program buduje słownik z inputu użytkownika.

Klucze są stałe.

Wartości pochodzą od użytkownika.

To jest bardzo bliskie prawdziwym formularzom.

Użytkownik wypełnia pola.

Program przechowuje dane strukturalne.

Bardzo realne.

Bardzo użyteczne.

Bardzo “to później może zostać web formem”.

Niebezpieczna myśl.

Słownik produktu

Stwórz słownik produktu:

product = {
    "name": "Keyboard",
    "price": 70.00,
    "available": True
}

print(f"Product: {product['name']}")
print(f"Price: {product['price']:.2f}")

if product["available"]:
    print("Available")
else:
    print("Not available")

Output:

Product: Keyboard
Price: 70.00
Available

To bardzo częsty pomysł.

Produkty mają:

name
price
availability

Użytkownicy mają:

name
email
age
city

Zadania mają:

title
status
priority

Słowniki są do tego idealne.

Nadają danym znaczenie.

Znaczenie jest dobre.

Bez znaczenia tylko patrzysz na liczby i masz nadzieję.

To nie jest inżynieria.

To astrologia z dodatkowymi krokami.

Listy słowników

Teraz robi się ciekawiej.

Możesz przechowywać słowniki wewnątrz listy.

Przykład:

products = [
    {"name": "Keyboard", "price": 70.00},
    {"name": "Mouse", "price": 25.00},
    {"name": "Notebook", "price": 5.50}
]

To jest lista.

Wewnątrz listy każdy element jest słownikiem.

To jest bardzo częste w prawdziwych aplikacjach.

Dlaczego?

Bo często masz wiele strukturalnych obiektów.

Wiele produktów.

Wielu użytkowników.

Wiele zamówień.

Wiele zadań.

Lista przechowuje wiele elementów.

Słownik opisuje każdy element.

Razem są potężne.

Bardzo potężne.

Bardzo normalne.

Bardzo bliskie JSON i API.

Backend się uśmiecha.

Przechodzenie przez listę słowników

Przykład:

products = [
    {"name": "Keyboard", "price": 70.00},
    {"name": "Mouse", "price": 25.00},
    {"name": "Notebook", "price": 5.50}
]

for product in products:
    print(f"{product['name']}: {product['price']:.2f}")

Output:

Keyboard: 70.00
Mouse: 25.00
Notebook: 5.50

Co się dzieje?

products to lista.
Każdy product to słownik.
Pętla bierze jeden słownik naraz.
Potem odczytujemy product["name"] i product["price"].

Ten schemat jest wszędzie.

Jeśli pracujesz z API, będziesz go widzieć ciągle.

Odpowiedź często wygląda jak:

lista słowników

Albo w języku JSON:

array obiektów

Ta sama idea.

Inne ubranie.

Obliczanie sumy z listy słowników

Możesz obliczyć sumę.

Przykład:

products = [
    {"name": "Keyboard", "price": 70.00},
    {"name": "Mouse", "price": 25.00},
    {"name": "Notebook", "price": 5.50}
]

total = 0

for product in products:
    total += product["price"]

print(f"Total: {total:.2f}")

Output:

Total: 100.50

To łączy:

lista
słownik
pętla
liczba
suma

Bardzo mocne.

Bardzo realistyczne.

Wiele prawdziwych systemów tak działa.

Koszyki.

Faktury.

Podsumowania zamówień.

Raporty.

A potem podatki.

Znowu.

Potwór podatkowy nigdy nie śpi.

Słowniki z listami w środku

Słownik może też zawierać listę.

Przykład:

course = {
    "title": "Python Course",
    "lessons": ["Variables", "Input", "Conditions", "Loops", "Lists"]
}

print(course["title"])

for lesson in course["lessons"]:
    print(f"- {lesson}")

Output:

Python Course
- Variables
- Input
- Conditions
- Loops
- Lists

Tutaj:

course["lessons"]

jest listą.

To jest bardzo użyteczne, kiedy jeden obiekt ma wiele powiązanych wartości.

Przykład:

użytkownik z wieloma umiejętnościami
kurs z wieloma lekcjami
zamówienie z wieloma produktami
post na blogu z wieloma tagami

Słowniki i listy świetnie ze sobą współpracują.

Jak pierogi i śmietana.

Ale z większą ilością nawiasów.

Zagnieżdżone słowniki

Słownik może zawierać inny słownik.

Przykład:

user = {
    "name": "Anna",
    "address": {
        "city": "Rome",
        "country": "Italy"
    }
}

print(user["name"])
print(user["address"]["city"])
print(user["address"]["country"])

Output:

Anna
Rome
Italy

To nazywa się dane zagnieżdżone.

Zagnieżdżone oznacza:

wewnątrz innej rzeczy

Tutaj:

user["address"]

jest innym słownikiem.

Potem:

user["address"]["city"]

bierze miasto ze słownika address.

Na początku wygląda trochę strasznie.

Ale to tylko:

otwórz user
otwórz address
odczytaj city

Jak otwieranie pudełek.

Proszę, nie wkładaj zbyt wielu pudełek w pudełka.

Tam mieszka szaleństwo.

I JSON.

Typowy błąd: klucze bez cudzysłowów

Źle:

user = {
    name: "Anna",
    age: 25
}

Python myśli, że name i age to nazwy zmiennych.

Ale one nie są zdefiniowane.

Poprawnie:

user = {
    "name": "Anna",
    "age": 25
}

Klucze tekstowe potrzebują cudzysłowów.

To bardzo częsty błąd początkujących.

Pamiętaj:

"name" to tekst
name to zmienna

Różne rzeczy.

Małe cudzysłowy.

Duża różnica.

Klasyczny dramat programowania.

Typowy błąd: używanie = zamiast :

Źle:

user = {
    "name" = "Anna",
    "age" = 25
}

Poprawnie:

user = {
    "name": "Anna",
    "age": 25
}

W słownikach używaj dwukropka:

"key": value

Nie znaku równości.

Znak równości służy do przypisania:

user = {}

Dwukropek służy do par klucz-wartość:

"name": "Anna"

Python jest bardzo konkretny.

Jak księgowy z zasadami składni.

Typowy błąd: brak przecinków

Źle:

user = {
    "name": "Anna"
    "age": 25
}

Poprawnie:

user = {
    "name": "Anna",
    "age": 25
}

Elementy słownika potrzebują przecinków między sobą.

Bez przecinków Python się gubi.

A kiedy Python się gubi, daje błędy.

Przynajmniej nie krzyczy.

Zwykle.

Typowy błąd: KeyError

Źle:

user = {
    "name": "Anna"
}

print(user["city"])

To daje:

KeyError

Bo "city" nie istnieje.

Bezpieczniej:

print(user.get("city", "Unknown"))

Output:

Unknown

Używaj get(), kiedy klucz może nie istnieć.

To bardzo ważne przy pracy z prawdziwymi danymi.

Prawdziwe dane często są niekompletne.

Bo ludzie wypełniają formularze.

A ludzie są kreatywni.

W złym sensie.

Typowy błąd: mylenie indeksów listy i kluczy słownika

Lista:

products = ["Keyboard", "Mouse"]

Odczyt przez indeks:

products[0]

Słownik:

product = {
    "name": "Keyboard",
    "price": 70.00
}

Odczyt przez klucz:

product["name"]

Nie pisz:

product[0]

Ten słownik tak nie działa.

Listy używają pozycji.

Słowniki używają kluczy.

Prosta zasada:

lista      indeks
słownik    klucz

Bardzo ważne.

Bardzo łatwe do pomylenia na początku.

Bardzo normalne.

Mini program: karta użytkownika

Utwórz plik:

user_card.py

Napisz:

user = {
    "name": input("Name: "),
    "age": int(input("Age: ")),
    "city": input("City: ")
}

print("----- User Card -----")
print(f"Name: {user['name']}")
print(f"Age: {user['age']}")
print(f"City: {user['city']}")

Przykład:

Name: Anna
Age: 25
City: Rome

Output:

----- User Card -----
Name: Anna
Age: 25
City: Rome

To jest proste, ale ważne.

Zbierasz dane.

Zapisujesz je w słowniku.

Wyświetlasz je ładnie.

To początek strukturalnych danych użytkownika.

Bardzo użyteczne.

Bardzo realne.

Mini program: product manager

Utwórz plik:

product_manager.py

Napisz:

product = {}

product["name"] = input("Product name: ")
product["price"] = float(input("Price: "))
product["available"] = input("Available? yes/no: ").lower() == "yes"

print("----- Product -----")
print(f"Name: {product['name']}")
print(f"Price: {product['price']:.2f}")

if product["available"]:
    print("Status: available")
else:
    print("Status: not available")

Przykład:

Product name: Keyboard
Price: 70
Available? yes/no: yes

Output:

----- Product -----
Name: Keyboard
Price: 70.00
Status: available

Ten program używa:

• pustego słownika;
• inputu;
• konwersji float;
• wyrażenia boolean;
• warunków;
• formatowanego outputu.

Bardzo dobra praktyka.

I tak, to zaczyna wyglądać jak dane produktu w sklepie.

Mały sklep.

Mały Python.

Duża przyszłość.

Mini program: lista produktów

Utwórz plik:

product_list_dictionaries.py

Napisz:

products = []

product_count = int(input("How many products? "))

for number in range(1, product_count + 1):
    print(f"Product {number}")

    product = {
        "name": input("Name: "),
        "price": float(input("Price: "))
    }

    products.append(product)

print("----- Products -----")

for product in products:
    print(f"{product['name']}: {product['price']:.2f}")

Przykład:

How many products? 2
Product 1
Name: Keyboard
Price: 70
Product 2
Name: Mouse
Price: 25

Output:

----- Products -----
Keyboard: 70.00
Mouse: 25.00

To jest mocne.

Budujesz listę słowników.

To bardzo realna struktura danych.

To nie jest tylko ćwiczenie dla początkujących.

Tak wiele prawdziwych programów organizuje dane.

Bardzo mocny krok.

Praktyka

Utwórz plik:

practice_dictionaries.py

Napisz program, który:

• tworzy pusty słownik o nazwie book;
• pyta użytkownika o tytuł;
• pyta użytkownika o autora;
• pyta użytkownika o rok;
• zapisuje wszystkie wartości w słowniku;
• wyświetla informacje o książce;
• sprawdza, czy rok jest przed 2000.

Przykładowe rozwiązanie:

book = {}

book["title"] = input("Title: ")
book["author"] = input("Author: ")
book["year"] = int(input("Year: "))

print("----- Book -----")

for key, value in book.items():
    print(f"{key}: {value}")

if book["year"] < 2000:
    print("This book was published before 2000.")
else:
    print("This book was published in 2000 or later.")

Ten program łączy:

• słowniki;
• input;
• konwersję typu;
• pętlę przez .items();
• warunki.

Bardzo użyteczne.

Bardzo czyste.

Bardzo strukturalne.

Jak mały system biblioteczny.

Bez kar za spóźnienie.

Na razie.

Mini wyzwanie

Utwórz plik:

contact_book.py

Twój program powinien:

• zacząć od pustej listy contacts;
• wielokrotnie pokazywać menu;
• pozwalać użytkownikowi dodać kontakt;
• pozwalać użytkownikowi pokazać wszystkie kontakty;
• pozwalać użytkownikowi wyjść.

Każdy kontakt powinien być słownikiem z:

name
email
phone

Menu:

1. Add contact
2. Show contacts
q. Quit

Przykładowe rozwiązanie:

contacts = []

while True:
    print("----- Contact Book -----")
    print("1. Add contact")
    print("2. Show contacts")
    print("q. Quit")

    choice = input("Choose an option: ").lower()

    if choice == "1":
        contact = {
            "name": input("Name: "),
            "email": input("Email: "),
            "phone": input("Phone: ")
        }

        contacts.append(contact)
        print("Contact added.")
    elif choice == "2":
        if len(contacts) == 0:
            print("No contacts yet.")
        else:
            print("Contacts:")

            for contact in contacts:
                print("-----")
                print(f"Name: {contact['name']}")
                print(f"Email: {contact['email']}")
                print(f"Phone: {contact['phone']}")
    elif choice == "q":
        print("Goodbye.")
        break
    else:
        print("Unknown option.")

To prawdziwa mini aplikacja.

Używa:

• listy słowników;
• pętli menu;
• inputu;
• warunków;
• append();
• len();
• odczytu ze słownika;
• break.

To poważny projekt dla początkujących.

Mały, tak.

Ale poważny.

Książka kontaktów to realna logika software.

Nie tylko drukujesz już “Hello”.

Przechowujesz dane strukturalne.

Szacunek.

Bardzo Python-szacunek.

Extra challenge: wyszukiwanie kontaktów

Ulepsz contact_book.py.

Dodaj opcję menu:

3. Search contact

Zapytaj użytkownika o imię.

Potem wyszukaj kontakt po imieniu.

Przykładowy pomysł:

elif choice == "3":
    search_name = input("Name to search: ")

    found = False

    for contact in contacts:
        if contact["name"] == search_name:
            print("Contact found:")
            print(f"Name: {contact['name']}")
            print(f"Email: {contact['email']}")
            print(f"Phone: {contact['phone']}")
            found = True

    if not found:
        print("Contact not found.")

To dodaje:

• wyszukiwanie;
• flagę boolean;
• pętlę przez listę słowników;
• warunek wewnątrz pętli.

Bardzo użyteczne.

Bardzo realne.

Tak zaczyna się wiele małych systemów danych.

Dodaj dane.

Pokaż dane.

Szukaj danych.

Potem pewnego dnia ktoś mówi:

Can we save it to a database?

I PostgreSQL wchodzi do pokoju w okularach przeciwsłonecznych.

Checklist dla początkujących

Kiedy twój program ze słownikami nie działa, sprawdź:

Czy użyłem nawiasów klamrowych?
Czy użyłem "key": value?
Czy oddzieliłem elementy przecinkami?
Czy dałem tekstowe klucze w cudzysłowie?
Czy użyłem : wewnątrz słownika, a nie =?
Czy klucz istnieje?
Czy dobrze napisałem klucz?
Czy użyłem tych samych wielkich liter?
Czy powinienem użyć get() zamiast []?
Czy nie mylę indeksów listy z kluczami słownika?
Czy przechodzę przez klucze, wartości czy items?

Słowniki są potężne.

Ale nazwy kluczy muszą być dokładne.

Większość początkowych bugów ze słownikami pochodzi z:

złego klucza
brakującego klucza
brakujących cudzysłowów
brakującego przecinka
użycia = zamiast :

Dobra wiadomość:

te błędy są normalne.

Lepsza wiadomość:

z czasem łatwiej je zauważyć.

Zła wiadomość:

nadal będziesz je robić.

Witaj w programowaniu.

Podsumowanie

Dzisiaj nauczyłeś się:

• słowniki przechowują pary klucz-wartość;
• słowniki używają nawiasów klamrowych;
• klucze i wartości są oddzielone dwukropkami;
• elementy są oddzielone przecinkami;
• wartości odczytuje się przez klucze;
• klucze muszą pasować dokładnie;
• wartości można aktualizować;
• nowe pary klucz-wartość można dodawać;
• del usuwa element;
• pop() usuwa element i zwraca jego wartość;
• in sprawdza, czy klucz istnieje;
• get() bezpiecznie odczytuje wartości, kiedy klucz może nie istnieć;
• pętle mogą przechodzić przez klucze słownika;
• .items() daje klucze i wartości;
• .values() daje wartości;
• listy mogą zawierać słowniki;
• słowniki mogą zawierać listy;
• słowniki mogą zawierać inne słowniki;
• słowniki są bardzo użyteczne dla danych strukturalnych.

To ogromny krok.

Teraz twoje programy mogą przechowywać dane z sensem.

Nie tylko wartości.

Wartości z etykietami.

Wartości strukturalne.

Dane, które wyglądają jak dane prawdziwych aplikacji.

Użytkownicy.

Produkty.

Kontakty.

Książki.

Zadania.

Zamówienia.

Profile.

Jesteś coraz bliżej prawdziwego software.

Bardzo mocny postęp.

Bardzo Python.

Następna lekcja

W następnej lekcji nauczymy się funkcji.

Funkcje pozwalają ponownie używać kodu.

Zamiast pisać tę samą logikę znowu i znowu, stworzysz własne komendy.

Tak:

def greet_user(name):
    print(f"Hello, {name}!")

Potem możesz wywołać:

greet_user("Anna")
greet_user("Marco")
greet_user("Sofia")

Funkcje są jednym z największych kroków w programowaniu.

Pomagają organizować kod.

Zmniejszają powtórzenia.

Sprawiają, że programy są łatwiejsze do czytania.

I sprawiają, że kod mniej przypomina spaghetti.

Bardzo ważne.

Bardzo Python.

Bardzo następny poziom.