Dictionaries: keys та values

Повертаємось до Python.

У попередній лекції ти вивчив lists.

Твої програми навчилися зберігати багато values в одній variable.

Ти писав щось таке:

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

Дуже добре.

Lists корисні, коли треба багато values.

Але іноді list недостатньо.

Подивись на це:

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

Це працює.

Але що це означає?

Anna — це, мабуть, name.
25 — це, мабуть, age.
Rome — це, мабуть, city.

Мабуть.

А “мабуть” — це не дуже хороша стратегія для data structure.

І для життя теж.

Переважно.

Краще зберігати data з назвами.

Ось так:

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

Тепер data зрозуміла.

"name" вказує на "Anna".

"age" вказує на 25.

"city" вказує на "Rome".

Це dictionary.

Dictionaries дуже важливі в Python.

Дуже корисні.

Дуже поширені.

Дуже близькі до того, як працюють real data в API, JSON, databases, settings, users, products, orders і багатьох інших речах.

Іншими словами:

ласкаво просимо у structured data.

Дуже fancy.

Дуже практично.

Дуже Python.

Що ти вивчиш

У цій лекції ти вивчиш:

• що таке dictionary;
• як працюють keys і values;
• як створити dictionary;
• як читати values через key;
• як оновлювати values;
• як додавати нові key-value pairs;
• як видаляти items;
• як використовувати in;
• як використовувати get();
• як проходити по dictionaries через loops;
• як проходити по keys і values;
• як зберігати dictionaries всередині lists;
• як зберігати lists всередині dictionaries;
• типові помилки початківців;
• як будувати маленькі dictionary-based програми.

До кінця цієї лекції твої програми зможуть працювати зі structured data.

Це величезний крок.

Бо real applications повні structured data.

Users мають names.

Products мають prices.

Orders мають totals.

Tasks мають statuses.

Blog posts мають titles.

І кожен boss має “одну маленьку зміну”.

Теж structured.

Теж небезпечну.

Що таке dictionary?

Dictionary зберігає data як key-value pairs.

Приклад:

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

Цей dictionary має три keys:

name
age
city

І три values:

Anna
25
Rome

Key — це як label.

Value — це data.

Тобто:

"name": "Anna"

означає:

Key "name" має value "Anna".

Dictionary використовує curly braces:

{}

Кожен item має форму:

key: value

Items розділяються commas.

Dictionary — це як маленька information card.

Дуже організована.

Дуже корисна.

І набагато менш загадкова, ніж user[1].

Це прогрес.

Твій перший dictionary

Створи файл:

dictionaries.py

Напиши:

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

print(user)

Запусти:

python dictionaries.py

або:

python3 dictionaries.py

Output:

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

Python виводить увесь dictionary.

Зверни увагу:

curly braces
keys
values
colons
commas

Це структура dictionary.

Він може виглядати трохи важчим, ніж list.

Але для structured data він набагато зрозуміліший.

List каже:

Ось values.
Удачі.

Dictionary каже:

Ось values з labels.
Будь ласка.

Дуже ввічливо.

Дуже Python.

Keys і values

Подивись ще раз:

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

Keys:

"name"
"age"
"city"

Values:

"Anna"
25
"Rome"

Кожен key вказує на один value.

Можна уявити це так:

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

Саме тому dictionaries чудово підходять для data, яка має meaning.

Приклад product:

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

Тепер ми знаємо, що означає кожен value.

Без вгадування.

Без загадкових index numbers.

Без “почекай, position 2 — це price чи city?”

Красиво.

Доступ до values через key

Щоб отримати value, використовуй key у square brackets.

Приклад:

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

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

Output:

Anna
25
Rome

Це дуже важливо.

У lists ти отримуєш value через index:

products[0]

У dictionaries ти отримуєш value через key:

user["name"]

Key каже Python, який value ти хочеш.

Дуже readable.

Дуже корисно.

Дуже “нарешті code пояснює сам себе”.

Dictionary keys мають бути точними

Keys мають збігатися точно.

Приклад:

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

print(user["name"])

Output:

Anna

Але це неправильно:

print(user["Name"])

Python дає error:

KeyError

Чому?

Бо "Name" і "name" — це різні keys.

Capital letters мають значення.

Spaces мають значення.

Все має значення.

Python не вгадує.

Python не твоя тітка, яка намагається згадати твій password.

Йому потрібен exact key.

Дуже строго.

Дуже корисно.

Іноді дратує.

Оновлення values

Можна змінити value, присвоївши новий value існуючому key.

Приклад:

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

user["age"] = 26

print(user)

Output:

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

Ми змінили:

age from 25 to 26

Це дуже поширено.

Приклад:

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

product["price"] = 65.00

print(product)

Output:

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

Product price змінився.

Shop happy.

Customer happy.

Accountant suspicious.

Нормально.

Додавання нових key-value pairs

Можна додати нову key-value pair, присвоївши value новому key.

Приклад:

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

user["city"] = "Rome"

print(user)

Output:

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

До цього dictionary мав:

name
age

Після цього він має ще:

city

Це корисно, коли ти будуєш data step by step.

Приклад:

product = {}

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

print(product)

Output:

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

Empty dictionary починається так:

product = {}

Потім можна додавати data пізніше.

Як form.

Але менш нервовий.

Видалення items через del

Можна видалити key-value pair через del.

Приклад:

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

del user["city"]

print(user)

Output:

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

Key "city" і його value були видалені.

Важливо:

del user["city"]

видаляє всю key-value pair.

Не тільки value.

Key також зникає.

Дуже прямо.

Дуже потужно.

Використовуй обережно.

del не питає:

Are you sure?

Python тобі довіряє.

Сміливо.

Можливо, занадто сміливо.

Видалення items через pop()

Можна також видалити item через pop().

Приклад:

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

city = user.pop("city")

print(city)
print(user)

Output:

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

pop() видаляє item і повертає removed value.

Тобто:

city = user.pop("city")

означає:

Видали "city" з dictionary і збережи його value у city.

Це корисно, коли removed value ще потрібен.

del видаляє.

pop() видаляє і повертає.

Маленька різниця.

Велика користь.

Перевірка, чи key існує

Використовуй in, щоб перевірити, чи key існує в dictionary.

Приклад:

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

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

Output:

Name exists.

Важливо:

"name" in user

перевіряє keys.

Не values.

Приклад:

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

print("Anna" in user)

Output:

False

Чому?

Бо "Anna" — це value, а не key.

Keys тут:

name
age

Це типова плутанина для початківців.

Коли використовуєш in з dictionary, Python за замовчуванням перевіряє keys.

Дуже важливо.

Витатуюй це в debugging brain.

Можливо, не literally.

Уникнення KeyError через get()

Якщо звернутися до missing key через square brackets, Python дає KeyError.

Приклад:

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

print(user["city"])

Error:

KeyError

Бо "city" не існує.

Безпечніший спосіб — get().

Приклад:

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

print(user.get("city"))

Output:

None

None означає:

No value

Можна також дати default value:

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

Output:

Unknown

Це дуже корисно.

get() допомагає уникати errors, коли key може бути missing.

Дуже практично.

Дуже real-world.

Бо real-world data часто incomplete.

Як forms.

І people.

Square brackets vs get()

Обидва способи можуть читати values.

Приклад:

user = {
    "name": "Anna"
}

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

Output:

Anna
Anna

Різниця:

user["city"]

дає error, якщо "city" не існує.

Але:

user.get("city")

повертає None.

А:

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

повертає "Unknown".

Просте правило:

Use [] when the key must exist.
Use get() when the key may be missing.

Це не тільки beginner advice.

Це real programming advice.

Те, що рятує від bugs, які з’являються в п’ятницю ввечері.

Найгірший вид.

Прохід по dictionary keys

Можна проходити по dictionary через loop.

Приклад:

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

for key in user:
    print(key)

Output:

name
age
city

За замовчуванням loop по dictionary дає keys.

Це:

for key in user:

означає:

For each key in the dictionary...

Потім можна отримати value:

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

Output:

Anna
25
Rome

Дуже корисно.

Keys відкривають doors.

Values за doors.

Dictionaries — маленькі hotels.

Apparently.

Прохід по keys і values

Кращий спосіб — використовувати .items().

Приклад:

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

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

Output:

name: Anna
age: 25
city: Rome

Це дуже поширено.

.items() дає і key, і value.

Loop:

for key, value in user.items():

означає:

For each key-value pair in the dictionary...

Це один із найважливіших dictionary patterns.

Вивчи його добре.

Він повернеться.

Як semicolons у SQL.

Але добріше.

Прохід тільки по values

Можна використовувати .values(), якщо потрібні тільки values.

Приклад:

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

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

Output:

Anna
25
Rome

Можна використовувати .keys(), якщо потрібні тільки keys:

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

Output:

name
age
city

Але пам’ятай:

for key in user:

вже проходить по keys.

Тому .keys() здебільшого optional.

Python дає choices.

Choices — це nice.

Поки їх не стає занадто багато.

Тоді welcome to programming.

Dictionary з user input

Створи файл:

user_profile.py

Напиши:

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}")

Приклад:

Name: Anna
Age: 25
City: Rome

Output:

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

Ця програма будує dictionary з user input.

Keys fixed.

Values приходять від user.

Це дуже близько до real forms.

User заповнює fields.

Program зберігає structured data.

Дуже реально.

Дуже корисно.

Дуже “це потім може стати web form”.

Небезпечна думка.

Product dictionary

Створи product dictionary:

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

Це дуже поширена ідея.

Products мають:

name
price
availability

Users мають:

name
email
age
city

Tasks мають:

title
status
priority

Dictionaries ідеальні для цього.

Вони дають meaning data.

Meaning — це добре.

Без meaning ти просто дивишся на numbers і сподіваєшся.

Це не engineering.

Це astrology з extra steps.

Lists of dictionaries

Тепер стає цікавіше.

Можна зберігати dictionaries всередині list.

Приклад:

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

Це list.

Всередині list кожен item — dictionary.

Це дуже поширено в real applications.

Чому?

Бо часто є багато structured objects.

Багато products.

Багато users.

Багато orders.

Багато tasks.

List зберігає many items.

Dictionary описує кожен item.

Разом вони powerful.

Дуже powerful.

Дуже normal.

Дуже близько до JSON і APIs.

Backend усміхається.

Прохід по list of dictionaries

Приклад:

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

Що відбувається?

products — це list.
Кожен product — це dictionary.
Loop бере один dictionary за раз.
Потім ми читаємо product["name"] і product["price"].

Цей pattern всюди.

Якщо працюєш з APIs, ти бачитимеш це постійно.

Response часто виглядає як:

list of dictionaries

Або мовою JSON:

array of objects

Та сама ідея.

Інший одяг.

Рахування total з list of dictionaries

Можна порахувати total.

Приклад:

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

Це поєднує:

list
dictionary
loop
number
total

Дуже сильно.

Дуже реалістично.

Багато real systems роблять саме так.

Shopping carts.

Invoices.

Order summaries.

Reports.

А потім taxes.

Знову.

Tax monster never sleeps.

Dictionaries з lists всередині

Dictionary може містити list.

Приклад:

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

Тут:

course["lessons"]

це list.

Це дуже корисно, коли один object має багато related values.

Приклад:

user with many skills
course with many lessons
order with many products
blog post with many tags

Dictionaries і lists працюють разом прекрасно.

Як борщ і сметана.

Але з більшою кількістю brackets.

Nested dictionaries

Dictionary може містити інший dictionary.

Приклад:

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

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

Output:

Anna
Rome
Italy

Це називається nested data.

Nested означає:

inside another thing

Тут:

user["address"]

це інший dictionary.

Потім:

user["address"]["city"]

отримує city всередині address dictionary.

Спочатку це виглядає трохи страшно.

Але це просто:

open user
open address
read city

Як відкривати коробки.

Будь ласка, не клади занадто багато коробок у коробки.

Там живе madness.

І JSON.

Типова помилка: missing quotes around keys

Неправильно:

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

Python думає, що name і age — це variable names.

Але вони не defined.

Правильно:

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

String keys потребують quotes.

Це дуже типова beginner mistake.

Пам’ятай:

"name" is text
name is a variable

Різні речі.

Tiny quotes.

Big difference.

Classic programming drama.

Типова помилка: використовувати = замість :

Неправильно:

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

Правильно:

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

У dictionaries використовуй colon:

"key": value

Не equals.

Equals sign потрібен для assignment:

user = {}

Colon потрібен для key-value pairs:

"name": "Anna"

Python дуже specific.

Як accountant із syntax rules.

Типова помилка: missing commas

Неправильно:

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

Правильно:

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

Dictionary items потребують commas між собою.

Без commas Python губиться.

А коли Python губиться, він дає errors.

Принаймні не кричить.

Зазвичай.

Типова помилка: KeyError

Неправильно:

user = {
    "name": "Anna"
}

print(user["city"])

Це дає:

KeyError

Бо "city" не існує.

Безпечніше:

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

Output:

Unknown

Використовуй get(), коли key може бути missing.

Це дуже важливо при роботі з real data.

Real data часто incomplete.

Бо humans fill forms.

А humans creative.

In bad ways.

Типова помилка: плутати list indexes і dictionary keys

List:

products = ["Keyboard", "Mouse"]

Access with index:

products[0]

Dictionary:

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

Access with key:

product["name"]

Не пиши:

product[0]

Цей dictionary так не працює.

Lists використовують positions.

Dictionaries використовують keys.

Просте правило:

list        index
dictionary  key

Дуже важливо.

Дуже легко переплутати на початку.

Дуже нормально.

Міні-програма: user card

Створи файл:

user_card.py

Напиши:

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']}")

Приклад:

Name: Anna
Age: 25
City: Rome

Output:

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

Це просто, але важливо.

Ти збираєш data.

Зберігаєш її в dictionary.

Виводиш її красиво.

Це початок structured user data.

Дуже корисно.

Дуже реально.

Міні-програма: product manager

Створи файл:

product_manager.py

Напиши:

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")

Приклад:

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

Output:

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

Ця програма використовує:

• empty dictionary;
• input;
• float conversion;
• boolean expression;
• conditions;
• formatted output.

Дуже хороша практика.

І так, це вже починає виглядати як product data у shop.

Small shop.

Small Python.

Big future.

Міні-програма: product list

Створи файл:

product_list_dictionaries.py

Напиши:

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}")

Приклад:

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

Output:

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

Це powerful.

Ти будуєш list of dictionaries.

Це дуже real data structure.

Це не просто beginner practice.

Саме так багато real programs організовують data.

Дуже сильний крок.

Практика

Створи файл:

practice_dictionaries.py

Напиши програму, яка:

• створює empty dictionary called book;
• питає user про title;
• питає user про author;
• питає user про year;
• зберігає всі values у dictionary;
• виводить book information;
• перевіряє, чи year before 2000.

Приклад рішення:

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.")

Ця програма поєднує:

• dictionaries;
• input;
• type conversion;
• loop через .items();
• conditions.

Дуже корисно.

Дуже clean.

Дуже structured.

Як маленька library system.

Без late fees.

Поки що.

Міні-завдання

Створи файл:

contact_book.py

Твоя програма має:

• почати з empty list called contacts;
• постійно показувати menu;
• дозволити user додати contact;
• дозволити user показати всі contacts;
• дозволити user вийти.

Кожен contact має бути dictionary з:

name
email
phone

Menu:

1. Add contact
2. Show contacts
q. Quit

Приклад рішення:

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.")

Це справжня mini application.

Вона використовує:

• list of dictionaries;
• menu loop;
• input;
• conditions;
• append();
• len();
• dictionary access;
• break.

Це серйозний beginner project.

Small, yes.

But serious.

Contact book — це real software logic.

Ти вже не просто друкуєш “Hello”.

Ти зберігаєш structured data.

Respect.

Very Python respect.

Extra challenge: search contacts

Покращ contact_book.py.

Додай menu option:

3. Search contact

Запитай user про name.

Потім шукай contacts by name.

Приклад ідеї:

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.")

Це додає:

• searching;
• boolean flag;
• loop through list of dictionaries;
• condition inside loop.

Дуже корисно.

Дуже реально.

Так починаються багато simple data systems.

Add data.

Show data.

Search data.

Потім одного дня хтось каже:

Can we save it to a database?

І PostgreSQL заходить у кімнату в сонцезахисних окулярах.

Checklist для початківців

Коли твоя dictionary-програма не працює, перевір:

Я використав curly braces?
Я використав "key": value?
Я розділив items commas?
Я поставив string keys у quotes?
Я використав : всередині dictionary, а не =?
Key існує?
Я написав key правильно?
Я використав ті самі capital letters?
Мені треба get() замість []?
Я не плутаю list indexes з dictionary keys?
Я проходжу по keys, values чи items?

Dictionaries powerful.

Але key names мають бути exact.

Більшість beginner dictionary bugs з’являються через:

wrong key
missing key
missing quotes
missing comma
using = instead of :

Good news:

ці errors нормальні.

Better news:

їх стає легше помічати.

Bad news:

ти все одно будеш їх робити.

Welcome to programming.

Підсумок

Сьогодні ти вивчив:

• dictionaries зберігають key-value pairs;
• dictionaries використовують curly braces;
• keys і values розділяються colons;
• items розділяються commas;
• values читаються через keys;
• keys мають збігатися точно;
• values можна оновлювати;
• нові key-value pairs можна додавати;
• del видаляє item;
• pop() видаляє item і повертає його value;
• in перевіряє, чи key існує;
• get() безпечно читає values, коли key може бути missing;
• loops можуть проходити по dictionary keys;
• .items() дає keys і values;
• .values() дає values;
• lists можуть містити dictionaries;
• dictionaries можуть містити lists;
• dictionaries можуть містити інші dictionaries;
• dictionaries дуже корисні для structured data.

Це величезний крок.

Тепер твої програми можуть зберігати meaningful data.

Не просто values.

Labeled values.

Structured values.

Data, яка схожа на data real applications.

Users.

Products.

Contacts.

Books.

Tasks.

Orders.

Profiles.

Ти дуже наблизився до real software.

Дуже сильний progress.

Дуже Python.

Наступна лекція

У наступній лекції ми вивчимо functions.

Functions дозволяють reuse code.

Замість того, щоб писати ту саму logic знову і знову, ти створиш свої own commands.

Ось так:

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

Потім можна викликати:

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

Functions — це один із найбільших кроків у programming.

Вони допомагають organize code.

Зменшують repetition.

Роблять programs easier to read.

І роблять code менш схожим на spaghetti.

Дуже важливо.

Дуже Python.

Дуже next level.