Функция — это действие. Каждая кнопка в любом приложении — это вызов функции. Нажала "отправить" — вызвалась функция отправки. Нажала "лайк" — вызвалась функция лайка.
Ты пишешь код, который выполняет конкретное действие, даёшь ему имя — и теперь можешь вызывать это действие откуда угодно, просто написав имя.
Аналогия: Кнопка "Отправить" в Telegram. Ты не знаешь, что происходит внутри, когда её нажимаешь. Ты просто нажимаешь — и сообщение отправляется. Внутри этой кнопки — функция. Она принимает текст и получателя, делает своё дело и возвращает результат (отправлено / ошибка).
# def = "я создаю функцию" (define = определить)
# "send_message" = имя действия
# (to, text) = что функция принимает на вход (параметры)
def send_message(to, text):
print(f"Сообщение для {to}: {text}")
# Вызываем — выполняем действие
send_message("Аня", "Привет!")
# → Сообщение для Аня: Привет!
send_message("Макс", "Когда встреча?")
# → Сообщение для Макс: Когда встреча?
# Одна функция, вызываем сколько угодно раз с разными данными
Параметры — это данные, которые ты передаёшь функции, чтобы она знала, с чем работать.
# Без параметров — функция делает одно и то же каждый раз
def say_hello():
print("Привет!")
say_hello() # → Привет!
say_hello() # → Привет! (всегда одинаково)
# С параметрами — функция работает с разными данными
def say_hello_to(name):
print(f"Привет, {name}!")
say_hello_to("Катя") # → Привет, Катя!
say_hello_to("Дима") # → Привет, Дима!
Аналогия: Uber. Действие одно — "заказать такси". Но каждый раз ты передаёшь разные параметры: откуда, куда, тип машины. Функция заказать_такси(откуда, куда) — одна, а результат зависит от того, что ты в неё передала.
Функция может не просто делать действие, а возвращать результат. Этот результат можно сохранить в переменную и использовать дальше.
# Функция считает скидку и ВОЗВРАЩАЕТ результат
def calculate_discount(price, percent):
discount = price * percent / 100
final_price = price - discount
return final_price
# return = "верни это значение тому, кто вызвал"
# Вызываем и сохраняем результат в переменную
new_price = calculate_discount(1000, 20)
print(f"Цена со скидкой: {new_price}")
# → Цена со скидкой: 800.0
# Можно вызвать с другими данными
vip_price = calculate_discount(5000, 50)
print(f"VIP цена: {vip_price}")
# → VIP цена: 2500.0
Разница между print и return:
# print — просто показывает текст на экране. Всё.
# return — отдаёт значение обратно в код, чтобы с ним можно было работать дальше.
def with_print(a, b):
print(a + b) # показал и забыл
def with_return(a, b):
return a + b # вернул значение
with_print(2, 3) # → 5 (на экране), но сохранить нельзя
result = with_return(2, 3) # ничего на экране, но result = 5
print(result * 10) # → 50 (можно использовать дальше)
Функции могут вызывать друг друга. Так строятся сложные программы — из простых действий.
# Маленькие действия
def get_greeting(name):
return f"Привет, {name}!"
def get_time():
return "10:00"
# Большое действие, использующее маленькие
def send_morning_message(name):
greeting = get_greeting(name)
time = get_time()
print(f"[{time}] {greeting}")
send_morning_message("Катя")
# → [10:00] Привет, Катя!
Аналогия: Заказ в приложении доставки. Когда ты нажимаешь "Заказать", внутри вызываются несколько функций по очереди: проверить_корзину() → списать_оплату() → найти_курьера() → отправить_уведомление(). Каждая делает своё дело, а вместе — полный заказ.
Можно задать параметру значение "на случай, если не передали":
def create_post(text, visibility="public"):
print(f"Пост: {text} [{visibility}]")
# visibility = "public" по умолчанию
# Если при вызове не указать — будет "public"
create_post("Доброе утро!")
# → Пост: Доброе утро! [public]
create_post("Личная заметка", "private")
# → Пост: Личная заметка [private]
def format_notification(notif_type, sender):
if notif_type == "like":
return f"Лайк от {sender}"
elif notif_type == "comment":
return f"Комментарий от {sender}"
elif notif_type == "follow":
return f"Подписка от {sender}"
else:
return f"Уведомление от {sender}"
def process_notifications(notifications):
for notif in notifications:
message = format_notification(notif["type"], notif["from"])
print(message)
# Данные
my_notifications = [
{"type": "like", "from": "Аня"},
{"type": "comment", "from": "Макс"},
{"type": "follow", "from": "Дима"},
]
# Одна строка — и всё работает
process_notifications(my_notifications)
# → Лайк от Аня
# → Комментарий от Макс
# → Подписка от Дима
Python уже имеет готовые функции. Ты их уже использовала:
# print() — вывести на экран
print("Привет")
# len() — узнать длину (количество элементов)
friends = ["Аня", "Макс", "Дима"]
print(len(friends)) # → 3
# type() — узнать тип данных
print(type(42)) # → <class 'int'>
# input() — спросить пользователя (ввод с клавиатуры)
name = input("Как тебя зовут? ")
print(f"Привет, {name}!")
# range() — создать последовательность чисел
for i in range(3):
print(i) # → 0, 1, 2
# int(), str(), float() — преобразовать тип
age_text = "25" # это строка
age_number = int("25") # теперь число, можно считать
print(age_number + 5) # → 30
Создай файл functions.py:
# Калькулятор доставки
def calculate_delivery(distance, is_express):
base_price = distance * 50
if is_express:
total = base_price * 2
else:
total = base_price
return total
def format_order(item, distance, is_express):
price = calculate_delivery(distance, is_express)
delivery_type = "экспресс" if is_express else "обычная"
return f"{item} | {delivery_type} доставка | {distance} км | {price} руб"
# Тестируем
print(format_order("Кроссовки", 5, False))
print(format_order("Телефон", 10, True))
print(format_order("Книга", 2, False))
Запусти: python3 functions.py
Задача 1: Напиши функцию double(n), которая принимает число и возвращает его удвоенным.
def double(n):
return n * 2
print(double(5)) # → 10
print(double(100)) # → 200
Задача 2: Напиши функцию is_adult(age), которая возвращает True если возраст >= 18, иначе False.
def is_adult(age):
return age >= 18
print(is_adult(25)) # → True
print(is_adult(14)) # → False
Задача 3: Напиши функцию greet(name, time="утро"), которая возвращает приветствие. Если время не передано — по умолчанию "утро".
def greet(name, time="утро"):
return f"Доброе {time}, {name}!"
print(greet("Катя")) # → Доброе утро, Катя!
print(greet("Катя", "вечер")) # → Доброе вечер, Катя!
Задача 4: Что выведет этот код и почему?
def add(a, b):
return a + b
result = add(3, 4)
print(result)
print(add("Привет, ", "мир!"))
7
Привет, мир!
Задача 5: Напиши функцию filter_adults(users), которая принимает список словарей с полями "name" и "age", и выводит только тех, кому >= 18.
def filter_adults(users):
for user in users:
if user["age"] >= 18:
print(f"{user['name']} — {user['age']} лет")
people = [
{"name": "Аня", "age": 22},
{"name": "Макс", "age": 16},
{"name": "Дима", "age": 30},
]
filter_adults(people)
# → Аня — 22 лет
# → Дима — 30 лет
| Термин | Что значит |
|---|---|
| Функция | Именованный блок кода, который можно вызывать многократно, как кнопка с действием |
| def | Ключевое слово Python для создания (определения) функции |
| Параметр (аргумент) | Входное значение, которое функция принимает при вызове для работы с ним |
| return | Команда, которая возвращает результат из функции обратно в вызывающий код |
| Вызов функции | Использование функции по имени с круглыми скобками, например greet("Аня") |
| Значение по умолчанию | Значение параметра, которое используется, если при вызове его не передали |
| Область видимости | Зона, в которой переменная «живёт» — внутри функции или снаружи |
| Встроенная функция | Функция, которая уже есть в Python и работает без импорта: print(), len(), type() |
| import | Команда для подключения модуля (библиотеки) с дополнительными функциями |
| Модуль | Файл с готовыми функциями, который можно подключить через import |
1. Функция — это именованный блок кода: один раз написал, вызываешь сколько угодно раз.
2. Создаётся через def имя(параметры): — двоеточие и отступ обязательны.
3. Параметры — входные данные функции, аргументы — конкретные значения при вызове.
4. return возвращает результат. Без return функция возвращает None.
5. Значения по умолчанию позволяют вызывать функцию без некоторых аргументов.
6. Переменные внутри функции не видны снаружи — это область видимости.
7. Python имеет десятки встроенных функций: print(), len(), type(), range(), input().
8. import подключает модули — файлы с готовыми функциями для любых задач.
9. Хорошая функция делает одну вещь и имеет понятное имя.
В следующем уроке — Python: работа с файлами. Научишься читать и записывать данные в файлы — это нужно для хранения настроек, логов и данных агента.