Основы программирования на Python

Введение в Python: установка среды, переменные и базовые типы данных

Добро пожаловать в курс «Основы программирования на Python». Это первая статья нашего путешествия в мир разработки. Сегодня мы не просто напишем первую программу, но и разберемся, как «думает» компьютер, когда выполняет ваш код, как установить необходимые инструменты и как хранить данные в памяти.

Python — это один из самых популярных языков программирования в мире. Его любят за простоту синтаксиса (правил написания кода), который напоминает обычный английский язык, и за невероятную мощь. На Python пишут веб-сайты, создают искусственный интеллект, анализируют данные, автоматизируют рутинные задачи и даже разрабатывают игры.

Что такое Python и как он работает?

Прежде чем мы начнем писать код, важно понять, что происходит «под капотом». Компьютер не понимает человеческий язык, он понимает только машинный код (нули и единицы). Python — это интерпретируемый язык высокого уровня. Это означает, что вам не нужно самостоятельно переводить команды в нули и единицы. За вас это делает специальная программа — интерпретатор.

Когда вы запускаете программу на Python, интерпретатор читает ваш код строку за строкой и сразу же выполняет его. Это отличает его от компилируемых языков (как C++), где весь код сначала превращается в отдельный исполняемый файл.

Установка среды разработки

Чтобы начать программировать, нам нужно установить интерпретатор Python на ваш компьютер.

Шаг 1: Загрузка

Перейдите на официальный сайт Python.org и скачайте последнюю версию для вашей операционной системы (Windows, macOS или Linux).

Шаг 2: Установка

Запустите скачанный файл.

ВАЖНО: В окне установки обязательно поставьте галочку напротив пункта Add Python to PATH (Добавить Python в PATH). Если этого не сделать, вы не сможете запускать Python из командной строки, и это вызовет множество проблем в будущем.

Шаг 3: Проверка

После установки откройте терминал (в Windows это командная строка cmd или PowerShell, в macOS/Linux — Terminal) и введите команду:

python --version

Если вы видите версию (например, Python 3.10.0), значит, всё прошло успешно.

Ваша первая программа: Hello, World!

Традиционно изучение любого языка начинается с вывода на экран фразы «Hello, World!». В Python это делается всего одной строкой. Мы будем использовать встроенную функцию print().

Откройте IDLE (простая среда разработки, которая устанавливается вместе с Python) или любой текстовый редактор, введите следующий код и запустите его:

print("Hello, World!")

Функция print() берет то, что находится внутри скобок, и выводит это в консоль. Обратите внимание, что текст мы заключили в кавычки. Это сообщает Python, что перед ним именно текст, а не команда.

Переменные: коробки для данных

Представьте, что вы переезжаете и упаковываете вещи в коробки. Чтобы не забыть, что где лежит, вы подписываете каждую коробку: «Книги», «Посуда», «Одежда». В программировании переменные — это и есть такие подписанные коробки, в которых хранятся данные.

Чтобы создать переменную, нужно придумать ей имя и присвоить значение с помощью знака равно =. В программировании этот знак означает не «равно» в математическом смысле, а «присвоить».

user_name = "Alex"
age = 25

Здесь мы создали две «коробки»:

1. Коробку с надписью user_name, в которую положили текст "Alex".
2. Коробку с надписью age, в которую положили число 25.

Правила именования переменных

Имя переменной (идентификатор) не может быть произвольным. Существуют строгие правила:

• Имя может состоять из букв (латиница), цифр и знака подчеркивания _.
• Имя не может начинаться с цифры.
• Нельзя использовать пробелы.
• Python чувствителен к регистру: age, Age и AGE — это три разные переменные.

В Python принято использовать стиль snake_case (змеиный регистр): все буквы строчные, а слова разделяются подчеркиванием.

Правильно	Неправильно	Почему неправильно
my_variable	my variable	Содержит пробел
user_id_2	2user	Начинается с цифры
total_sum	total-sum	Дефис запрещен (это знак вычитания)

Базовые типы данных

В коробки можно класть разные вещи. В переменную можно положить число, текст или даже список. Тип данных определяет, что именно хранится в переменной и что с этим можно делать. Рассмотрим четыре основных типа.

1. Целые числа (Integer / int)

Это числа без дробной части: 5, 100, -20, 0. С ними можно выполнять арифметические операции.

x = 10
y = -5

2. Числа с плавающей точкой (Float)

Это дробные числа. В программировании для разделения целой и дробной части используется точка, а не запятая.

pi = 3.14
weight = 72.5

Если вы напишете 72,5, Python воспримет это не как одно число, а как перечисление двух разных чисел.

3. Строки (String / str)

Строка — это последовательность символов. Любой текст в Python должен быть заключен в кавычки (одинарные ' или двойные ").

message = "Привет, мир!"
letter = 'A'
number_as_string = "100"  # Это тоже строка, не число!

Важно: Если вы заключите число в кавычки, для компьютера оно станет просто текстом. Вы не сможете прибавить к строке "100" число 5 математически.

4. Логический тип (Boolean / bool)

Этот тип данных может принимать только два значения: True (Истина) или False (Ложь). Они часто используются для проверки условий.

is_active = True
is_deleted = False

Обратите внимание, что True и False пишутся с большой буквы и без кавычек.

Динамическая типизация

Python — язык с динамической типизацией. Это значит, что вам не нужно заранее сообщать компьютеру, какой тип данных будет храниться в переменной. Python сам определит это в момент присваивания значения. Более того, вы можете изменить тип переменной в процессе работы программы.

a = 10      # Сейчас a — это число (int)
print(a)

a = "Hello" # Теперь a — это строка (str)
print(a)

Чтобы узнать, какой тип данных хранится в переменной прямо сейчас, можно использовать функцию type():

x = 3.14
print(type(x))
# Вывод: <class 'float'>

Ввод данных от пользователя

Программы становятся полезными, когда они взаимодействуют с пользователем. Для получения данных с клавиатуры используется функция input().

name = input("Введите ваше имя: ")
print("Привет, ", name)

Когда программа доходит до строчки с input(), она останавливается и ждет, пока пользователь введет текст и нажмет Enter. Введенный текст сохраняется в переменную name.

Критически важно: Функция input() всегда возвращает строку (str), даже если пользователь ввел цифры.

Рассмотрим пример:

a = input("Введите число: ") # Допустим, ввели 5
b = input("Введите число: ") # Допустим, ввели 10
print(a + b)

Результатом будет не 15, а 510. Почему? Потому что a и b — это строки "5" и "10". Знак + для строк означает склеивание (конкатенацию), а не сложение.

Преобразование типов

Чтобы работать с введенными данными как с числами, их нужно преобразовать (конвертировать). Для этого используются функции int() (в целое) и float() (в дробное).

Правильный код для сложения:

a_str = input("Введите первое число: ")
b_str = input("Введите второе число: ")

# Преобразуем строки в числа
a = int(a_str)
b = int(b_str)

print(a + b) # Теперь результат будет 15

Или короче:

a = int(input("Введите число: "))

Простейшая математика

Раз уж мы заговорили о числах, давайте посмотрим на базовые операции. Python отлично справляется с ролью калькулятора.

• Сложение: +
• Вычитание: -
• Умножение: *
• Деление: / (результат всегда float, даже если делится нацело)
• Целочисленное деление: // (отбрасывает дробную часть)
• Остаток от деления: %
• Возведение в степень: **

Пример математической формулы в коде. Допустим, мы хотим вычислить значение выражения:

$$y = 2x^2 + 5$$

где $y$ — искомое значение, $x$ — переменная, $2$ и $5$ — константы.

На Python это будет выглядеть так:

x = 3
y = 2 * (x ** 2) + 5
print(y)

Комментарии в коде

Хороший код должен быть понятен не только компьютеру, но и человеку. Иногда логика программы бывает сложной, и нужно оставить заметку для себя или коллег. Для этого используются комментарии.

В Python комментарий начинается с символа решетки #. Всё, что написано после этого символа в той же строке, игнорируется интерпретатором.

# Это комментарий, компьютер его не видит
print("А этот код выполнится")

score = 0 # Начальный счет игрока

Заключение

Сегодня мы заложили фундамент вашего обучения. Вы узнали, как установить Python, написали первую программу, научились создавать переменные и различать типы данных. Это базовые кирпичики, из которых строятся самые сложные системы — от простых скриптов до нейросетей.

В следующей статье мы углубимся в логику программирования и изучим условные операторы — инструменты, которые позволяют программе принимать решения.

Управление потоком выполнения: условные операторы и циклы

В предыдущей статье мы научились создавать переменные и работать с базовыми типами данных. Мы положили данные в «коробки», но пока наша программа умеет выполнять команды только последовательно, одну за другой, как поезд, идущий по единственному пути.

Однако реальная жизнь (и реальные программы) требуют гибкости. Что, если пользователь ввел неправильный пароль? Что, если нам нужно обработать тысячу фотографий, а не одну? Здесь на сцену выходит управление потоком выполнения (Control Flow).

Сегодня мы научим нашу программу принимать решения и повторять действия. Мы превратим наш «поезд» в умный автомобиль с навигатором.

Условные операторы: искусство выбора

В основе любой интеллектуальной системы лежит умение отвечать на вопрос «Если... то...». В Python за это отвечает оператор if (если).

Синтаксис и отступы

В большинстве языков программирования (C++, Java, JavaScript) блоки кода выделяются фигурными скобками {}. Python пошел своим путем. Здесь структуру кода определяют отступы (indentation). Это делает код чистым и читаемым, но требует внимательности.

Стандартный отступ в Python — это 4 пробела.

Рассмотрим простейший пример:

age = 20

if age >= 18:
    print("Доступ разрешен")
    print("Добро пожаловать!")

print("Эта строка выполнится в любом случае")

Обратите внимание на двоеточие : после условия. Оно обязательно. Все строки, которые имеют отступ после if, будут выполнены только если условие истинно (True). Как только отступ исчезает, блок условия заканчивается.

Ветвление: else и elif

Часто нам нужно не просто выполнить действие при успехе, но и предусмотреть альтернативный сценарий. Для этого используется else (иначе).

password = input("Введите пароль: ")

if password == "secret123":
    print("Пароль верный.")
else:
    print("Ошибка доступа.")

Если вариантов больше двух, на помощь приходит elif (сокращение от else if — иначе если).

score = 85

if score >= 90:
    print("Ваша оценка: A")
elif score >= 75:
    print("Ваша оценка: B")
elif score >= 50:
    print("Ваша оценка: C")
else:
    print("Вы не сдали экзамен.")

Python проверяет условия сверху вниз. Как только он находит первое истинное условие, он выполняет его блок и пропускает остальные проверки в этой конструкции.

Операторы сравнения

Чтобы задавать условия, нам нужны инструменты сравнения. Результатом работы этих операторов всегда является логический тип (bool: True или False).

Оператор	Описание	Пример (x=5, y=10)
==	Равно (не путать с =)	x == y -> False
!=	Не равно	x != y -> True
>	Больше	x > y -> False
<	Меньше	x < y -> True
>=	Больше или равно	x >= 5 -> True
<=	Меньше или равно	y <= 10 -> True

Важно: Самая частая ошибка новичков — использование одного знака равно = (присваивание) вместо двух == (сравнение) внутри условия if.

Логические операторы

Иногда нужно проверить несколько условий одновременно. Например, чтобы получить скидку, клиент должен быть старше 60 лет ИЛИ иметь карту лояльности.

• and (И): Истинно, только если оба условия истинны.
• or (ИЛИ): Истинно, если хотя бы одно условие истинно.
• not (НЕ): Инвертирует значение (меняет True на False и наоборот).

age = 25
has_ticket = True

if age >= 18 and has_ticket:
    print("Проходите в кинозал.")

Циклы: сила повторения

Представьте, что вам нужно вывести на экран числа от 1 до 100. Писать 100 раз print() — плохая идея. В программировании для повторения действий используются циклы.

Цикл while (Пока)

Цикл while выполняет блок кода до тех пор, пока условие остается истинным. Это похоже на повторяющийся if.

count = 1

while count <= 5:
    print("Попытка номер", count)
    count = count + 1  # Увеличиваем счетчик

print("Цикл завершен")

Опасность: Если вы забудете изменить переменную, участвующую в условии (в нашем случае count), условие всегда будет истинным, и программа уйдет в бесконечный цикл. Она зависнет, и ее придется останавливать принудительно.

Цикл for (Для)

Цикл for в Python устроен иначе, чем в старых языках программирования. Он предназначен для перебора последовательностей (например, букв в строке или элементов в списке).

name = "Python"

for letter in name:
    print(letter)

В этом примере переменная letter на каждой итерации (повторении) будет принимать значение следующей буквы из строки "Python".

Функция range()

Если нам нужно просто повторить действие $N$ раз или получить последовательность чисел, мы используем функцию range().

Синтаксис: range(start, stop, step)

• start: начало (по умолчанию 0)
• stop: конец (не включается!)
• step: шаг (по умолчанию 1)

# Выведет числа: 0, 1, 2, 3, 4
for i in range(5):
    print(i)

# Выведет числа: 2, 4, 6, 8
for i in range(2, 10, 2):
    print(i)

Математический пример: Сумма арифметической прогрессии

Давайте решим задачу. Нам нужно найти сумму всех чисел от 1 до 100. Мы можем сделать это циклом:

total_sum = 0
for i in range(1, 101): # 101 не включается, значит до 100
    total_sum = total_sum + i
print(total_sum)

Однако, в математике для этого существует формула суммы арифметической прогрессии:

$$S_n = \frac{n}{2}(a_1 + a_n)$$

Где:

• $S_n$ — сумма первых $n$ членов прогрессии.
• $n$ — количество суммируемых чисел (в нашем случае 100).
• $a_1$ — первый член последовательности (1).
• $a_n$ — последний член последовательности (100).

Если мы реализуем эту формулу, результат будет тем же, но программа выполнится быстрее, так как ей не нужно делать 100 повторений.

Управление внутри цикла: break и continue

Иногда нам нужно вмешаться в работу цикла прямо в процессе выполнения.

break (Прервать)

Команда break немедленно останавливает цикл и выходит из него, даже если условие продолжения все еще истинно.

while True:
    command = input("Введите 'exit' для выхода: ")
    if command == 'exit':
        break
    print("Вы ввели:", command)

continue (Продолжить)

Команда continue прерывает текущую итерацию и переходит к следующей. Код, написанный после continue внутри цикла, не выполнится для текущего шага.

# Вывод нечетных чисел от 1 до 9
for i in range(1, 10):
    if i % 2 == 0:      # Если число четное
        continue        # Пропускаем его
    print(i)

Вложенные конструкции

Вы можете вкладывать циклы в условия, условия в циклы и циклы в циклы. Главное — следить за отступами.

for i in range(1, 4):
    print("Внешний цикл, шаг:", i)
    for j in range(1, 4):
        print("    Внутренний цикл, шаг:", j)

В этом примере внутренний цикл полностью выполнится 3 раза — по одному разу для каждого шага внешнего цикла.

Заключение

Теперь ваша программа — это не просто линейный сценарий. Она умеет анализировать данные, принимать решения на основе условий и автоматизировать рутинные повторения. Условные операторы if и циклы for/while — это скелет логики любого алгоритма.

В следующей статье мы перейдем к структурированию кода и узнаем, как создавать собственные команды с помощью функций, чтобы не писать один и тот же код много раз.

Структуры данных: списки, кортежи, словари и множества

В прошлых статьях мы научились хранить одиночные данные в переменных: одно число, одну строку, одно значение True или False. Мы также научились управлять потоком программы с помощью циклов и условий. Но что, если нам нужно работать с сотней имен пользователей, тысячей товаров в магазине или базой данных температур за год?

Создавать тысячу переменных (item1, item2, item3...) — это тупиковый путь. Нам нужны контейнеры, способные хранить наборы данных. В Python такие контейнеры называются структурами данных. Сегодня мы разберем «большую четверку» встроенных структур: списки, кортежи, словари и множества.

Списки (Lists): Универсальные коробки

Список — это упорядоченная коллекция элементов, которую можно изменять. Это самая часто используемая структура данных в Python. Представьте список покупок, написанный на бумаге: у каждого пункта есть свой порядковый номер, и вы можете дописывать новые товары или вычеркивать купленные.

Создание списка

Списки создаются с помощью квадратных скобок []. Элементы внутри разделяются запятыми.

fruits = ["яблоко", "банан", "апельсин"]
numbers = [1, 5, 10, 42]
mixed = [1, "текст", True, 3.14] # В одном списке могут быть разные типы!

Индексация: Доступ к элементам

Самое важное правило программирования: счет начинается с нуля. Первый элемент списка имеет индекс 0, второй — 1, и так далее.

fruits = ["яблоко", "банан", "апельсин"]

print(fruits[0])  # Выведет: яблоко
print(fruits[1])  # Выведет: банан

Python также поддерживает отрицательную индексацию. Индекс -1 означает последний элемент, -2 — предпоследний.

print(fruits[-1]) # Выведет: апельсин

Изменение списков

Списки — это изменяемый (mutable) тип данных. Мы можем менять содержимое «на лету».

users = ["Alex", "Maria"]

# 1. Добавление элемента в конец
users.append("Ivan")
# Теперь users: ["Alex", "Maria", "Ivan"]

# 2. Изменение элемента по индексу
users[0] = "Alexander"
# Теперь users: ["Alexander", "Maria", "Ivan"]

# 3. Удаление элемента
users.remove("Maria")
# Теперь users: ["Alexander", "Ivan"]

Срезы (Slicing)

Иногда нам нужна только часть списка. Для этого используются срезы: список[старт:стоп:шаг].

nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(nums[0:5])  # [0, 1, 2, 3, 4] (элемент с индексом 5 не включается!)
print(nums[::2])  # [0, 2, 4, 6, 8] (каждый второй элемент)
print(nums[::-1]) # [9, 8, ..., 0] (список задом наперед)

Кортежи (Tuples): Защищенные списки

Кортеж — это брат-близнец списка, но с одним критическим отличием: он неизменяем (immutable). После создания кортежа вы не можете добавить, удалить или заменить в нем элементы.

Кортежи создаются с помощью круглых скобок ().

coordinates = (55.75, 37.61)
colors = ("red", "green", "blue")

Если вы попытаетесь сделать coordinates[0] = 10.0, Python выдаст ошибку.

Зачем нужны кортежи, если есть списки?

1. Защита данных: Если вы передаете в программу координаты GPS или настройки сервера, вы хотите быть уверены, что никто случайно их не изменит.
2. Скорость: Кортежи занимают меньше памяти и работают быстрее списков.

Словари (Dictionaries): Ключ к успеху

Списки удобны, когда данные упорядочены. Но что, если нам нужно найти телефон человека по его имени? Искать имя в списке, запоминать индекс и искать телефон по тому же индексу в другом списке — неудобно.

Здесь на помощь приходят словари. Это неупорядоченная коллекция пар «Ключ: Значение».

Создание и доступ

Словари создаются с помощью фигурных скобок {}.

phone_book = {
    "Alex": "8-900-111-22-33",
    "Maria": "8-900-555-66-77",
    "Emergency": "112"
}

Здесь "Alex" — это ключ, а номер телефона — значение. Чтобы получить значение, мы обращаемся к словарю по ключу (как в списке по индексу, только вместо числа — имя ключа).

print(phone_book["Maria"])
# Выведет: 8-900-555-66-77

Операции со словарями

car = {
    "brand": "Ford",
    "model": "Mustang",
    "year": 1964
}

# Добавление новой пары
car["color"] = "red"

# Изменение значения
car["year"] = 2023

# Безопасное получение (если ключа нет, вернет None, а не ошибку)
print(car.get("price"))

Множества (Sets): Уникальность превыше всего

Множество — это коллекция уникальных элементов. В множестве нет порядка (нельзя обратиться по индексу) и не может быть дубликатов.

Представьте мешок, в который вы кидаете цветные шарики. Если вы кинете туда красный шарик, а там уже есть такой же, второй просто исчезнет.

Создание множества

Используются фигурные скобки {}, как в словарях, но без двоеточий. Или функция set().

# Создаем множество с дубликатами
numbers = {1, 2, 2, 3, 3, 3, 4}
print(numbers)
# Выведет: {1, 2, 3, 4} — дубликаты удалены автоматически!

Математика множеств

Множества в Python основаны на математической теории множеств. Это позволяет легко находить пересечения и объединения.

Допустим, у нас есть два множества студентов:

group_a = {"Anna", "Bob", "Charlie"}
group_b = {"Bob", "David", "Anna", "Edward"}

Мы можем использовать формулу объединения множеств:

$$|A \cup B| = |A| + |B| - |A \cap B|$$

где $|A \cup B|$ — количество элементов в объединении (все уникальные студенты), $|A|$ и $|B|$ — количество студентов в каждой группе, а $|A \cap B|$ — количество студентов, которые есть в обеих группах одновременно (пересечение).

В Python это делается проще:

# Пересечение (кто есть и там, и там)
print(group_a.intersection(group_b))
# Вывод: {'Anna', 'Bob'}

# Разность (кто есть в A, но нет в B)
print(group_a.difference(group_b))
# Вывод: {'Charlie'}

Сводная таблица: Что выбрать?

Выбор правильной структуры данных — половина успеха программы.

Структура	Синтаксис	Упорядоченность	Изменяемость	Уникальность	Для чего использовать
Список	[1, 2]	Да	Да	Нет	Коллекции однотипных или разных данных, которые нужно менять
Кортеж	(1, 2)	Да	Нет	Нет	Координаты, настройки, данные, которые нельзя менять
Словарь	{"k": "v"}	Нет (до 3.7)*	Да	Ключи уникальны	Хранение данных пар "объект-свойство", базы данных
Множество	{1, 2}	Нет	Да	Да	Удаление дубликатов, математические операции

> Начиная с Python 3.7, словари сохраняют порядок вставки, но полагаться на это как на основной механизм не всегда стоит.

Вложенные структуры

Структуры данных можно вкладывать друг в друга. Это позволяет создавать сложные модели реального мира. Например, список словарей:

students = [
    {"name": "Alex", "scores": [85, 90, 88]},
    {"name": "Maria", "scores": [92, 95, 93]}
]

# Доступ к первой оценке Марии
print(students[1]["scores"][0])
# students[1] -> словарь Марии
# ["scores"] -> список оценок
# [0] -> первая оценка (92)

Заключение

Сегодня мы вооружились мощными инструментами. Списки позволяют нам работать с последовательностями, словари — мгновенно находить информацию, кортежи — защищать данные, а множества — убирать лишнее.

В следующей статье мы научимся упаковывать логику работы с этими данными в функции, чтобы наш код стал модульным и профессиональным.

Функции и модули: организация кода и повторное использование

В предыдущих статьях мы прошли большой путь: научились хранить данные в переменных, управлять потоком программы с помощью условий и циклов, а также организовывать информацию в списки и словари. Но по мере того как ваши программы становятся сложнее, вы можете заметить одну неприятную вещь: код начинает повторяться.

Представьте, что вы пишете программу для интернет-магазина. Вам нужно рассчитать налог на товар в корзине. Вы пишете формулу. Затем вам нужно рассчитать налог для стоимости доставки. Вы копируете формулу. Потом налог для скидочного купона. Снова копируете.

А что, если налоговая ставка изменится? Вам придется искать и исправлять этот код в трех (или тридцати) разных местах. Это нарушает главный принцип программирования: DRY (Don't Repeat Yourself — Не повторяйся).

Сегодня мы изучим инструменты, которые спасут вас от хаоса: функции и модули.

Что такое функция?

Функция — это именованный блок кода, который выполняет определенную задачу. Вы можете представить функцию как мини-программу внутри вашей основной программы. Вы «вызываете» её по имени, она делает свою работу и возвращает результат.

Лучшая аналогия для функции — это кухонный комбайн или мясорубка.

У функции есть:

1. Имя (чтобы мы могли к ней обратиться).
2. Аргументы (необязательно) — то, что мы кладем внутрь (мясо).
3. Тело функции — инструкции, что нужно сделать.
4. Возвращаемое значение (необязательно) — результат работы (фарш).

Создание функции

В Python функции создаются с помощью ключевого слова def (от английского define — определить).

def say_hello():
    print("Привет!")
    print("Я твоя первая функция.")

Когда интерпретатор видит этот код, он просто запоминает: «Ага, если меня попросят выполнить say_hello, я должен вывести эти две строки». Сама по себе эта конструкция ничего не выводит на экран.

Чтобы код заработал, функцию нужно вызвать:

# Вызов функции
say_hello()

Аргументы функции

Функция становится по-настоящему полезной, когда она может работать с разными данными. Данные передаются в скобках.

def greet(name):
    print("Привет, ", name)

greet("Алекс")
greet("Мария")

Здесь name — это переменная, которая существует только внутри функции. Когда мы вызываем greet("Алекс"), строка "Алекс" попадает в переменную name, и функция использует её.

Возвращаемое значение: return

До сих пор наши функции просто печатали текст на экран. Но в реальном программировании функции чаще всего должны вычислять что-то и отдавать результат обратно, чтобы программа могла использовать его дальше.

Для этого используется ключевое слово return.

Рассмотрим пример из геометрии. Нам нужно вычислить площадь круга. Математическая формула выглядит так:

$$S = \pi r^2$$

Где:

• $S$ — площадь круга (искомое значение).
• $\pi$ — математическая константа (примерно 3.14159).
• $r$ — радиус круга.

Реализуем это в коде:

def calculate_area(radius):
    pi = 3.14159
    area = pi * (radius ** 2)
    return area

# Теперь мы можем сохранить результат в переменную
my_circle_area = calculate_area(5)
print("Площадь круга:", my_circle_area)

Важно: После выполнения команды return функция немедленно прекращает работу и выходит. Любой код, написанный после return внутри функции, никогда не выполнится.

В чем разница между print и return?

Это самый частый вопрос новичков.

• print() — это крикнуть ответ в громкоговоритель. Все услышали, но записать и использовать в дальнейших расчетах это нельзя.
• return — это написать ответ на бумажке и передать её тому, кто задал вопрос. Эту бумажку можно положить в карман (переменную) и использовать позже.

Аргументы: позиционные и именованные

Представьте функцию, которая рассчитывает стоимость поездки на такси:

def taxi_price(distance, rate, discount):
    total = distance * rate - discount
    return total

Позиционные аргументы

Python ориентируется на порядок. Первое число попадет в distance, второе — в rate, третье — в discount.

price = taxi_price(10, 20, 50)

Если перепутать местами (например, taxi_price(20, 10, 50)), расчет будет неверным.

Именованные аргументы

Чтобы не запутаться, можно указывать имена аргументов явно:

price = taxi_price(rate=20, distance=10, discount=50)

В этом случае порядок не важен.

Значения по умолчанию

Часто некоторые параметры бывают стандартными. Например, скидка обычно равна 0. Мы можем указать это сразу при создании функции.

def taxi_price(distance, rate, discount=0):
    return distance * rate - discount

# Можно вызывать так (скидка будет 0):
print(taxi_price(10, 20))

# А можно так (скидка будет 100):
print(taxi_price(10, 20, 100))

Область видимости (Scope)

Переменные, созданные внутри функции, называются локальными. Они невидимы для остальной программы. Это как правило «Всё, что происходит в Вегасе, остается в Вегасе».

def secret_function():
    secret_code = 12345
    print(secret_code) # Внутри функции всё работает

secret_function()
# print(secret_code) # ОШИБКА! Программа не знает такой переменной

Это сделано специально, чтобы функции не мешали друг другу. Вы можете использовать переменную count в десяти разных функциях, и это будут десять разных переменных, которые ничего не знают друг о друге.

Модули: разделяй и властвуй

Когда кода становится очень много (тысячи строк), держать его в одном файле неудобно. Прокрутка файла превращается в мучение.

Python позволяет разбивать программу на несколько файлов. Каждый файл с кодом на Python (.py) называется модулем.

Представьте, что вы создали файл math_utils.py и написали туда свои функции для расчетов.

Теперь в основном файле main.py вы можете подключить их:

import math_utils

result = math_utils.calculate_area(10)

Стандартная библиотека

Вместе с Python устанавливается огромный набор готовых модулей. Это называется «Батарейки в комплекте» (Batteries Included). Вам не нужно писать функцию для извлечения квадратного корня или генерации случайного числа — они уже написаны профессионалами.

Примеры полезных модулей:

• math — сложные математические операции.
• random — генерация случайных чисел.
• datetime — работа с датой и временем.
• os — работа с файловой системой компьютера.

Пример использования модуля random:

import random

# Генерируем случайное число от 1 до 100
secret_number = random.randint(1, 100)
print("Выпало число:", secret_number)

# Выбираем случайный элемент из списка
fruits = ["яблоко", "банан", "груша"]
print("Сегодня я съем:", random.choice(fruits))

Импорт конкретных функций

Если вам не нужен весь модуль, а только одна функция, можно импортировать только её:

from math import sqrt

print(sqrt(25)) # Выведет 5.0

Обратите внимание: в этом случае нам не нужно писать название модуля перед функцией (не math.sqrt, а просто sqrt).

Заключение

Функции и модули — это кирпичики, из которых строятся большие проекты. Функции позволяют упаковать логику в удобные блоки, а модули помогают организовать эти блоки по файлам.

Теперь ваш код стал чище, понятнее и профессиональнее. Вы готовы к следующему большому шагу — изучению того, как программы могут работать с внешним миром: читать и записывать файлы. Об этом мы поговорим в следующей статье.

Основы объектно-ориентированного программирования и работа с файлами

До этого момента мы писали программы, используя функции и модули. Это отличный подход, который называется процедурным программированием. Мы разбивали задачу на шаги (процедуры) и выполняли их последовательно. Однако, когда программы становятся действительно большими и сложными — например, при создании игр, банковских систем или веб-сайтов — простого набора функций становится недостаточно.

Данные начинают «разбредаться» по всей программе, и становится трудно уследить, какая функция за какие переменные отвечает. Здесь на сцену выходит Объектно-Ориентированное Программирование (ООП). Это парадигма, которая позволяет моделировать реальный мир в коде, объединяя данные и поведение в единые сущности — объекты.

Кроме того, сегодня мы научимся сохранять результаты работы нашей программы на жесткий диск, изучив работу с файлами. Ведь программа, которая забывает всё после выключения, не очень полезна.

Что такое ООП? Классы и Объекты

В центре ООП стоят два понятия: Класс и Объект.

Чтобы понять разницу, представьте, что вы инженер на заводе по производству роботов.

1. Класс — это чертеж, схема или инструкция. В чертеже написано: «Робот должен иметь две руки, две ноги, серийный номер и уметь ходить». Сам чертеж ходить не умеет, это просто бумага.
2. Объект (или экземпляр класса) — это конкретный робот, собранный по этому чертежу. У него есть конкретный серийный номер (например, R2-D2), и он физически может ходить.

Создание первого класса

В Python классы создаются с помощью ключевого слова class. Имена классов принято писать с большой буквы (стиль CamelCase).

class Cat:
    pass

Мы создали простейший класс Cat. Пока он пустой (оператор pass ничего не делает, но нужен для синтаксиса). Теперь создадим объекты этого класса:

# Создаем двух конкретных котов
cat1 = Cat()
cat2 = Cat()

Атрибуты и метод init

Коты должны чем-то отличаться друг от друга. У них есть характеристики: имя, цвет, возраст. В ООП эти переменные внутри объекта называются атрибутами (или полями).

Чтобы задать атрибуты при создании объекта, используется специальный метод __init__. Это конструктор класса. Он запускается автоматически в момент создания нового объекта.

class Cat:
    def __init__(self, name, color):
        self.name = name    # Создаем атрибут name
        self.color = color  # Создаем атрибут color

# Теперь мы обязаны передать имя и цвет
my_cat = Cat("Барсик", "Рыжий")
neighbor_cat = Cat("Мурзик", "Черный")

print(my_cat.name)  # Выведет: Барсик
print(neighbor_cat.color) # Выведет: Черный

Загадочный self

Вы наверняка заметили слово self. Это ссылка на текущий объект.

Когда мы пишем self.name = name, мы говорим компьютеру: «Возьми значение переменной name, которое нам передали, и сохрани его внутрь этого конкретного кота».

Без self переменная name была бы просто временной переменной внутри функции, которая исчезла бы сразу после завершения работы конструктора.

Методы: поведение объектов

Коты не только имеют цвет, они умеют что-то делать: мяукать, спать, есть. Функции внутри класса называются методами.

class Cat:
    def __init__(self, name, color):
        self.name = name
        self.color = color

    def meow(self):
        print(f"{self.name} говорит: Мяу!")

    def sleep(self):
        print(f"{self.name} свернулся клубочком и уснул.")

my_cat = Cat("Барсик", "Рыжий")
my_cat.meow()  # Выведет: Барсик говорит: Мяу!

Обратите внимание: при вызове метода my_cat.meow() мы не передаем аргументов, хотя в определении написано def meow(self). Python автоматически передает сам объект my_cat в качестве аргумента self.

Практический пример: Геометрическая точка

Давайте создадим класс, который описывает точку на плоскости и умеет вычислять расстояние до другой точки. Это покажет, как ООП помогает структурировать математические задачи.

Расстояние между двумя точками $A(x_1, y_1)$ и $B(x_2, y_2)$ вычисляется по формуле Евклидова расстояния:

$$d = \sqrt{(x_2 - x_1)^2 + (y_2 - y_1)^2}$$

Где:

• $d$ — искомое расстояние (distance).
• $x_1, y_1$ — координаты первой точки.
• $x_2, y_2$ — координаты второй точки.
• $\sqrt{...}$ — операция извлечения квадратного корня.

Реализуем это в коде:

import math

class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

    def distance_to(self, other_point):
        # self - это первая точка (x1, y1)
        # other_point - это вторая точка (x2, y2)
        dx = other_point.x - self.x
        dy = other_point.y - self.y
        return math.sqrt(dx**2 + dy**2)

# Создаем точки
p1 = Point(0, 0)
p2 = Point(3, 4)

# Считаем расстояние
dist = p1.distance_to(p2)
print(dist) # Выведет 5.0

Наследование: не повторяй себя

Один из главных принципов ООП — Наследование. Представьте, что у нас есть класс Animal (Животное). У всех животных есть имя и возраст. Зачем писать это заново для Cat (Кошка) и Dog (Собака)?

Мы можем сказать, что Кошка наследуется от Животного.

class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print("Животное издает звук")

class Dog(Animal): # В скобках указываем родителя
    def speak(self):
        print("Гав!")

class Cat(Animal):
    def speak(self):
        print("Мяу!")

bobik = Dog("Бобик")
bobik.speak() # Выведет: Гав!
print(bobik.name) # Выведет: Бобик (атрибут унаследован от Animal)

Это позволяет писать код один раз и переиспользовать его многократно.

Работа с файлами

Теперь перейдем ко второй важной теме. Все переменные, которые мы создаем в программе, живут в оперативной памяти (RAM). Когда программа завершается или компьютер выключается, эти данные исчезают. Чтобы сохранить их, нам нужны файлы.

Чтение файлов

Для открытия файла используется встроенная функция open(). У неё есть два основных аргумента: имя файла и режим работы.

Основные режимы:

• 'r' (read) — только чтение (по умолчанию).
• 'w' (write) — запись (если файл существовал, он будет стерт!).
• 'a' (append) — дозапись (добавление данных в конец файла).

# Плохой способ (небезопасный)
file = open("example.txt", "r")
content = file.read()
print(content)
file.close() # Обязательно нужно закрывать файл!

Почему этот способ плохой? Если во время чтения произойдет ошибка, программа «упадет», и строка file.close() не выполнится. Файл останется «зависшим» в памяти, что может привести к проблемам.

Контекстный менеджер with

В Python есть идеальный способ работы с файлами — конструкция with. Она гарантирует, что файл будет закрыт автоматически, даже если произойдет ошибка.

# Хороший способ (безопасный)
with open("example.txt", "r") as file:
    content = file.read()
    print(content)
# Здесь файл уже закрыт автоматически

Методы чтения

1. read() — читает весь файл целиком в одну строку.
2. readline() — читает одну строку за раз.
3. readlines() — читает все строки и возвращает их в виде списка.

Запись в файл

Давайте запишем список наших покупок в файл.

shopping_list = ["Хлеб", "Молоко", "Яблоки"]

with open("shop.txt", "w") as f:
    for item in shopping_list:
        f.write(item + "\n") # \n нужен для переноса строки

Если мы запустим этот код, в папке с программой появится файл shop.txt. Если запустить код еще раз с другими товарами, старый файл будет полностью перезаписан. Если вы хотите добавить товары к существующему списку, используйте режим 'a'.

Объединяем ООП и файлы

Давайте создадим класс Logger, который будет записывать сообщения о работе программы в файл. Это классическая задача для программиста.

import datetime

class Logger:
    def __init__(self, filename):
        self.filename = filename

    def log(self, message):
        # Получаем текущее время
        current_time = datetime.datetime.now()

        # Формируем строку для записи
        log_entry = f"[{current_time}] {message}\n"

        # Открываем файл в режиме дозаписи ('a')
        with open(self.filename, "a") as f:
            f.write(log_entry)

# Использование
my_logger = Logger("program_log.txt")
my_logger.log("Программа запущена")
my_logger.log("Пользователь вошел в систему")
my_logger.log("Произошла ошибка соединения")

Теперь у нас есть объект my_logger, который скрывает внутри себя всю сложность работы с файлами и временем. В основной программе мы просто вызываем метод .log(), не думая о том, как именно это происходит. Это и есть сила инкапсуляции в ООП.

Заключение

Сегодня мы сделали огромный шаг вперед. Мы перешли от простого написания инструкций к проектированию архитектуры программы с помощью классов и объектов. Мы также научились сохранять данные, чтобы они пережили перезагрузку компьютера.

Объектно-ориентированное программирование — это обширная тема. Мы коснулись лишь верхушки айсберга, но понимание классов, объектов, атрибутов и методов — это фундамент, на котором строятся все современные приложения на Python.

В следующих уроках мы будем использовать эти знания для создания более сложных и полезных проектов.