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.