Python для начинающих: от синтаксиса до первых проектов

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

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

Почему именно Python?

Python — это язык, который читается почти как обычный английский текст. Он используется везде: от создания веб-сайтов (Instagram, Pinterest) до искусственного интеллекта (ChatGPT) и анализа данных. Главное преимущество для новичка — низкий порог входа. Вам не нужно думать об управлении памятью или сложных синтаксических конструкциях на старте.

Шаг 1. Установка окружения

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

1. Интерпретатор Python — программа, которая «читает» ваш код и выполняет его.
2. Редактор кода (IDE) — удобный блокнот с подсветкой ошибок и подсказками.

Установка Python

1. Перейдите на официальный сайт python.org.
2. Скачайте последнюю версию для вашей операционной системы (Windows или macOS).
3. ВАЖНО: При установке на Windows обязательно поставьте галочку напротив пункта Add Python to PATH. Если этого не сделать, компьютер не сможет найти Python через командную строку.

Выбор редактора кода

Для начала я рекомендую использовать VS Code (Visual Studio Code). Он бесплатный, легкий и самый популярный в мире. Альтернатива — PyCharm Community Edition (более мощный, но тяжелый).

Скачайте и установите VS Code. После установки откройте его, перейдите в раздел расширений (квадратик слева) и установите официальное расширение «Python» от Microsoft.

Шаг 2. Ваша первая программа

В программировании есть традиция: первая программа всегда должна выводить фразу «Hello, World!». Давайте не будем её нарушать.

1. Создайте на рабочем столе папку python_course.
2. Откройте эту папку в VS Code (File -> Open Folder).
3. Создайте новый файл с названием main.py. Расширение .py говорит компьютеру, что это файл с кодом Python.
4. Напишите в файле следующую строку:

print("Hello, World!")

Чтобы запустить программу, нажмите кнопку Play (зеленый треугольник) в углу редактора или откройте терминал внизу и напишите python main.py.

Если вы увидели внизу текст Hello, World!, поздравляю! Вы официально написали свою первую программу.

Разбор полетов

• print() — это функция. Команда компьютеру: «Напечатай то, что внутри скобок».
• "Hello, World!" — это строка (текст). В Python текст всегда должен быть обернут в кавычки (одинарные ' или двойные ").

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

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

В программировании переменная — это и есть такая подписанная коробка, в которой хранится какое-то значение.

Создание переменной

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

name = "Alex"
age = 25

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

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

Важно: Знак = в программировании — это не равенство, а присваивание. Мы говорим: «Возьми значение справа и положи его в переменную слева».

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

Чтобы ваш код был понятным и работал, соблюдайте правила:

• Имя переменной может содержать буквы, цифры и нижнее подчеркивание _.
• Имя не может начинаться с цифры (1name — ошибка).
• Не используйте пробелы. Вместо них используйте snake_case (змеиный регистр): my_favorite_color, а не my favorite color.
• Имя должно быть осмысленным. x = 10 — плохо (непонятно, что это). user_age = 10 — хорошо.

Шаг 4. Базовые типы данных

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

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

Это обычные числа без дробной части. Они могут быть положительными и отрицательными.

count = 10
year = 2023
temperature = -5

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

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

pi = 3.14
price = 99.99
weight = 75.5

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

Любой текст, заключенный в кавычки.

message = "Привет, мир!"
code = '12345'  # Это тоже строка, так как она в кавычках

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

Самый простой тип, который имеет всего два значения: Истина (True) или Ложь (False). Обратите внимание, что они пишутся с большой буквы.

is_active = True
is_deleted = False

Как узнать тип данных?

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

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

Шаг 5. Ввод и вывод данных

Мы уже умеем выводить данные с помощью print(). Теперь научимся получать данные от пользователя. Для этого используется функция input().

print("Как тебя зовут?")
name = input()
print("Привет,", name)

Можно сделать код короче, написав подсказку прямо внутри input():

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

Важный нюанс: Функция input() всегда возвращает строку (str). Даже если пользователь введет число 50, для программы это будет текст "50". Если вы захотите использовать это как число (например, для математики), вам нужно будет преобразовать тип вручную.

f-строки: магия форматирования

Чтобы красиво вставлять переменные внутрь текста, в современном Python используют f-строки (formatted strings). Ставится буква f перед кавычками, а переменные пишутся внутри фигурных скобок {}.

name = "Мария"
age = 22

# Без f-строк (неудобно)
print("Меня зовут " + name + ", мне " + str(age) + " года.")

# С f-строками (удобно и читаемо)
print(f"Меня зовут {name}, мне {age} года.")

Шаг 6. Комментарии

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

# Это комментарий, код его не видит
print("А это код") # Комментарий может быть и в конце строки

Практическое задание: «Анкета пользователя»

Давайте объединим все знания и напишем небольшую программу.

Задача: Создать программу, которая спрашивает имя, город и возраст пользователя, а затем выводит красивое приветствие.

Код решения:

# Запрашиваем данные
name = input("Введите ваше имя: ")
city = input("Из какого вы города? ")
age = input("Сколько вам лет? ")

# Выводим результат с помощью f-строки
print(f"Привет, {name}! Ты живешь в городе {city} и тебе {age} лет.")

Частые ошибки новичков

1. SyntaxError: EOL while scanning string literal — вы забыли закрыть кавычку в конце строки.
2. NameError: name 'x' is not defined — вы пытаетесь использовать переменную, которую еще не создали, или допустили опечатку в названии.
3. IndentationError — лишние пробелы в начале строки. В Python отступы очень важны, но пока пишите весь код прижатым к левому краю.

Заключение

Сегодня вы сделали огромный шаг: подготовили рабочее место, изучили переменные и типы данных. Это алфавит программирования. В следующей статье мы научимся учить программу принимать решения с помощью условных операторов if и else.

Что сделать до следующего урока:

1. Установите Python и VS Code.
2. Поэкспериментируйте с input() и print().
3. Попробуйте создать переменные разных типов и вывести их типы через type().

Управление потоком выполнения: условные операторы if-else и циклы for/while

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

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

Часть 1. Условные операторы: учим программу думать

В жизни мы постоянно принимаем решения: «Если на улице дождь, то я возьму зонт, иначе пойду в кепке». В Python эта логика реализуется с помощью операторов if (если), else (иначе) и elif (сокращение от else if — иначе если).

Простой if

Самая базовая проверка. Обратите внимание на двоеточие : в конце строки и отступ (обычно 4 пробела) на следующей строке.

age = 20

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

Важнейшее правило Python: Отступы (indentation) определяют блоки кода. Всё, что сдвинуто вправо после if, выполнится только если условие истинно. Если вы уберете отступ, Python выдаст ошибку IndentationError или выполнит код неправильно.

Конструкция if-else

Что делать, если условие ложно? Используем else.

temperature = 15

if temperature > 20:
    print("Надень футболку")
else:
    print("Лучше взять куртку")

Множественный выбор: elif

Иногда вариантов больше, чем два. Например, светофор.

color = "желтый"

if color == "зеленый":
    print("Можно ехать")
elif color == "желтый":
    print("Приготовься")
elif color == "красный":
    print("Стоп!")
else:
    print("Светофор сломан")

Программа проверяет условия сверху вниз. Как только она находит первое истинное (True), она выполняет его блок и пропускает остальные.

Часть 2. Операторы сравнения и логика

Чтобы писать условия, нужно уметь сравнивать значения. Вот основные инструменты:

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

Оператор	Значение	Пример
==	Равно (не путать с =)	5 == 5 (True)
!=	Не равно	5 != 3 (True)
>	Больше	10 > 2 (True)
<	Меньше	1 < 5 (True)
>=	Больше или равно	5 >= 5 (True)
<=	Меньше или равно	4 <= 5 (True)

Частая ошибка: Новички часто пишут if x = 5:. Это ошибка! Один знак = — это присваивание (положить значение в коробку), а два == — это сравнение.

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

Иногда нужно проверить сразу несколько условий. Для этого есть слова and, or и not.

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

age = 25
has_ticket = True

# Пустим, если есть билет И возраст больше 18
if has_ticket and age >= 18:
    print("Проходите")

# Пример с not
is_raining = False
if not is_raining:
    print("Зонт не нужен")

Часть 3. Циклы: автоматизация рутины

Представьте, что вам нужно вывести фразу «Я люблю Python» 100 раз. Копировать строку print 100 раз — плохая идея. Для этого существуют циклы.

Цикл while (Пока)

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

count = 1

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

Осторожно: Если вы забудете изменить переменную внутри цикла (например, уберете count = count + 1), условие всегда будет истинным, и программа зависнет в бесконечном цикле. Чтобы остановить такую программу, нажмите Ctrl+C в терминале.

Цикл for (Для каждого)

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

Функция range()

Чтобы повторить действие определенное количество раз, используют функцию range().

# Выведет числа от 0 до 4 (5 не включается!)
for i in range(5):
    print(f"i равно {i}")

У range() есть три режима:

1. range(5) — от 0 до 4.
2. range(1, 6) — от 1 до 5 (старт, стоп).
3. range(1, 10, 2) — от 1 до 9 с шагом 2 (1, 3, 5, 7, 9).

Перебор строки

Так как строка — это последовательность символов, мы можем разобрать её по буквам:

name = "Alex"
for letter in name:
    print(letter)
# Выведет:
# A
# l
# e
# x

Часть 4. Управление внутри цикла: break и continue

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

• break: Немедленно выходит из цикла.
• continue: Пропускает текущий шаг и переходит к следующему.

# Ищем число 3
for i in range(10):
    if i == 3:
        print("Нашли тройку! Останавливаемся.")
        break
    print(i)

Практическое задание: Игра «Угадай число»

Давайте объединим while, if-else, input и преобразование типов в одной мини-игре. Компьютер загадает число, а мы будем угадывать.

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

import random

secret_number = random.randint(1, 20) # Случайное число от 1 до 20
attempts = 0

print("Я загадал число от 1 до 20. Попробуй угадать!")

while True: # Бесконечный цикл, пока не сработает break
    user_input = input("Ваш вариант: ")
    guess = int(user_input) # Превращаем строку в число
    attempts = attempts + 1

    if guess == secret_number:
        print(f"Поздравляю! Вы угадали число {secret_number} с {attempts} попытки.")
        break # Победа, выходим из игры
    elif guess < secret_number:
        print("Мое число больше.")
    else:
        print("Мое число меньше.")

Создайте файл guess_game.py, вставьте туда этот код и попробуйте поиграть!

Частые ошибки и советы

1. IndentationError: Следите за пробелами. В VS Code нажатие Tab обычно ставит 4 пробела. Смешивать табы и пробелы в одном файле нельзя.
2. Синтаксис: Не забывайте двоеточие : после условий if, else, while, for.
3. Типы данных: Помните, что input() возвращает строку. Сравнивать строку "5" и число 5 нельзя, они не равны. Всегда используйте int() для преобразования, если работаете с числами.

Заключение

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

В следующей статье мы разберем Списки (Lists) — мощный инструмент для хранения множества данных в одной переменной, и научимся работать с ними в циклах еще эффективнее.

Домашнее задание для самопроверки:

1. Напишите программу, которая спрашивает пароль. Если пароль верный («1234»), пишет «Вход разрешен», иначе — «Неверный пароль».
2. Используя цикл for, выведите таблицу умножения на 5 (от 1 до 10).
3. Попробуйте улучшить игру «Угадай число», добавив ограничение на количество попыток (например, всего 5 жизней).

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

Приветствую вас в третьей части нашего курса! Мы уже научились хранить одиночные данные в переменных (как одну книгу в коробке) и управлять логикой программы. Но что, если данных становится много? Представьте, что вам нужно сохранить список покупок из 50 пунктов или базу данных всех сотрудников компании. Создавать 50 переменных item1, item2... item50 — это кошмар.

Сегодня мы изучим структуры данных. Это специальные контейнеры, которые позволяют удобно хранить, организовывать и обрабатывать большие объемы информации. Мы разберем «большую тройку» Python: Списки (Lists), Кортежи (Tuples) и Словари (Dictionaries).

Часть 1. Списки (Lists): Универсальный вагончик

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

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

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

# Пустой список
empty_list = []

# Список чисел
numbers = [1, 2, 3, 4, 5]

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

# Смешанный список (да, в Python так можно!)
mix = [1, "Alex", 3.14, True]

Индексация: Как достать данные?

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

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

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

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

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

Изменение списка

Списки — это изменяемый (mutable) тип данных. Вы можете менять содержимое вагонов прямо на ходу.

fruits[0] = "груша"
print(fruits)
# Вывод: ['груша', 'банан', 'апельсин']

Основные методы работы со списками

Списки — это объекты, у которых есть встроенные функции (методы). Вот самые полезные:

1. append(item): Добавляет элемент в конец списка.
2. insert(index, item): Вставляет элемент в конкретное место.
3. pop(index): Удаляет элемент по индексу и возвращает его (если индекс не указан, удаляет последний).
4. remove(value): Удаляет первый найденный элемент по значению.
5. len(list): Узнать длину списка (количество элементов).

shopping_list = ["хлеб", "молоко"]

shopping_list.append("яйца")
# Теперь: ['хлеб', 'молоко', 'яйца']

shopping_list.remove("хлеб")
# Теперь: ['молоко', 'яйца']

print(len(shopping_list))
# Вывод: 2

Срезы (Slicing)

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

• старт — индекс начала (включительно).
• стоп — индекс конца (не включительно).

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

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

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

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

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

coordinates = (10, 20)
colors = ("red", "green", "blue")

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

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

Попытка изменить кортеж приведет к ошибке:

point = (5, 10)
# point[0] = 7  <-- Это вызовет TypeError!

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

Если списки используют числовые индексы (0, 1, 2), то словари используют ключи. Это похоже на реальный бумажный словарь: вы ищете слово (ключ) и находите его определение (значение).

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

user = {
    "name": "Alex",
    "age": 25,
    "city": "Moscow",
    "is_student": True
}

Доступ к данным

Мы обращаемся к элементам по ключу, а не по номеру.

print(user["name"]) # Выведет: Alex
print(user["age"])  # Выведет: 25

Изменение и добавление

Словари изменяемы. Чтобы добавить новую запись или изменить старую, просто обратитесь к ключу и присвойте значение.

# Изменение значения
user["age"] = 26

# Добавление новой пары
user["email"] = "alex@example.com"

print(user)
# {'name': 'Alex', 'age': 26, 'city': 'Moscow', 'is_student': True, 'email': 'alex@example.com'}

Методы словарей

• .keys(): Возвращает список всех ключей.
• .values(): Возвращает список всех значений.
• .items(): Возвращает пары (ключ, значение).

Часть 4. Итерация по структурам данных

В прошлой статье мы изучили цикл for. Теперь мы можем использовать его на полную мощность.

Перебор списка

guests = ["Мария", "Иван", "Ольга"]

for guest in guests:
    print(f"Привет, {guest}!")

Перебор словаря

При переборе словаря цикл for по умолчанию идет по ключам. Чтобы получить и ключ, и значение, используйте .items().

product = {"название": "Ноутбук", "цена": 50000}

for key, value in product.items():
    print(f"{key}: {value}")
# Вывод:
# название: Ноутбук
# цена: 50000

Практическое задание: «Менеджер контактов»

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

Это называется вложенностью (nesting) — одна из самых мощных концепций.

Задача:

1. Создать пустой список контактов.
2. В цикле спрашивать пользователя, хочет ли он добавить контакт.
3. Если да — запрашивать имя и телефон, сохранять их в словарь, а словарь добавлять в список.
4. В конце вывести всех друзей.

Код решения:

contacts = [] # Список для хранения словарей

while True:
    command = input("Введите 'add' для добавления или 'stop' для выхода: ")

    if command == "stop":
        break

    if command == "add":
        name = input("Имя контакта: ")
        phone = input("Номер телефона: ")

        # Создаем словарь для одного человека
        person = {
            "name": name,
            "phone": phone
        }

        # Добавляем словарь в общий список
        contacts.append(person)
        print("Контакт добавлен!")

print("\n--- Ваш список контактов ---")
# Перебираем список словарей
for contact in contacts:
    print(f"Имя: {contact['name']}, Телефон: {contact['phone']}")

Частые ошибки новичков

1. IndexError: list index out of range Вы пытаетесь обратиться к элементу, которого нет. Например, в списке из 3 элементов ([0, 1, 2]) вы запрашиваете индекс 3.

2. KeyError Вы пытаетесь получить значение из словаря по ключу, которого не существует. Чтобы избежать этого, можно использовать метод .get(): user.get("address") вернет None, а не ошибку, если ключа нет.

3. Забытая запятая В списках и словарях элементы должны разделяться запятыми. Если пропустить запятую между строками, Python может склеить их или выдать ошибку синтаксиса.

Заключение

Поздравляю! Теперь в вашем арсенале есть мощные инструменты для работы с данными. Вы знаете:

• Как хранить последовательности в списках.
• Как защищать данные в кортежах.
• Как структурировать информацию в словарях.

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

Домашнее задание для самопроверки:

1. Создайте список из 5 любимых фильмов. С помощью срезов выведите первые 3.
2. Создайте словарь, описывающий ваш компьютер (процессор, память, видеокарта). Выведите каждое значение в цикле.
3. Попробуйте изменить программу «Менеджер контактов» так, чтобы она не позволяла добавлять контакты с одинаковыми именами.

Модульность кода: написание собственных функций и работа с библиотеками

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

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

Принцип DRY: Не повторяйся

В программировании есть золотое правило: DRY (Don't Repeat Yourself) — «Не повторяй себя». Если вы видите, что копируете один и тот же код дважды или трижды, это сигнал: пора создать функцию.

Часть 1. Что такое функция?

Функция — это именованный блок кода, который выполняет определенную задачу. Вы уже пользовались встроенными функциями Python: print(), input(), len(), type(). Теперь пришло время создавать свои собственные.

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

Анатомия функции

Чтобы создать (объявить) функцию, используется ключевое слово def (от английского define — определить).

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

# Основная программа
print("Начало программы")
say_hello()  # Вызов функции
print("Конец программы")

Важные моменты:

1. Объявление (def): Мы просто учим компьютер, что делать, когда мы скажем say_hello. Код внутри функции не выполняется сразу.
2. Вызов (()): Чтобы код сработал, функцию нужно «позвать» по имени с круглыми скобками.

Часть 2. Аргументы и параметры

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

def greet(name):
    print(f"Привет, {name}! Рад тебя видеть.")

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

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

Несколько аргументов

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

def introduce(name, age, city):
    print(f"Меня зовут {name}, мне {age}, я из города {city}.")

introduce("Иван", 25, "Москва")

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

Чтобы не запутаться в порядке (что идет первым: возраст или город?), можно указывать имена параметров при вызове:

introduce(city="Минск", name="Ольга", age=30)

Часть 3. Возврат значения: return vs print

Это самый сложный момент для новичков. В чем разница между print() и return?

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

Рассмотрим пример с математикой. Допустим, нам нужно вычислить площадь круга. Формула площади:

$$S = \pi r^2$$

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

# Плохой пример (с print)
def bad_square(number):
    result = number * number
    print(result)

# Хороший пример (с return)
def good_square(number):
    return number * number

# Использование
x = bad_square(5)
# На экране появится 25, но в переменную x запишется пустота (None)

y = good_square(5)
# На экране ничего не появится, но y теперь равно 25
print(f"Результат вычисления: {y}")

Правило: Если вы хотите использовать результат работы функции дальше в коде (складывать, сохранять в базу данных, передавать другой функции), используйте return.

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

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

def secret_function():
    secret_code = 12345
    print("Внутри функции:", secret_code)

secret_function()
# print(secret_code) # Ошибка! NameError: name 'secret_code' is not defined

Это сделано для безопасности. Вы можете называть переменные внутри функции как угодно (x, count, temp), не боясь, что они случайно сломают переменные с такими же именами в другой части программы.

Часть 5. Работа с библиотеками (Модули)

Python называют языком «с батарейками в комплекте» (batteries included). Это значит, что вместе с Python устанавливается огромный набор готовых модулей для решения стандартных задач: от математики до работы с интернетом.

Чтобы использовать модуль, его нужно импортировать командой import.

Модуль math

Этот модуль содержит расширенные математические функции.

import math

print(math.pi)       # Число Пи: 3.14159...
print(math.sqrt(16)) # Квадратный корень: 4.0
print(math.ceil(5.1)) # Округление вверх: 6

Модуль random

Мы уже встречали его. Он нужен для генерации случайных чисел.

import random

print(random.randint(1, 10))    # Случайное целое число
print(random.choice(['Орел', 'Решка'])) # Случайный выбор из списка

Модуль datetime

Работа с датой и временем.

import datetime

now = datetime.datetime.now()
print(f"Сейчас: {now}")
print(f"Текущий год: {now.year}")

Практическое задание: «Конвертер валют»

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

Задача:

1. Написать функцию для перевода рублей в доллары.
2. Написать функцию для перевода рублей в евро.
3. В основной части программы спросить у пользователя сумму и валюту.

Код решения:

# 1. Определяем функции
def rub_to_usd(amount):
    rate = 90.0 # Курс доллара (условный)
    return amount / rate

def rub_to_eur(amount):
    rate = 98.0 # Курс евро
    return amount / rate

# 2. Основная программа
print("--- Конвертер валют ---")
rubles = float(input("Введите сумму в рублях: "))
choice = input("В какую валюту перевести? (USD/EUR): ")

if choice == "USD":
    result = rub_to_usd(rubles)
    # Округляем до 2 знаков после запятой
    print(f"Вы получите: {round(result, 2)} $")
elif choice == "EUR":
    result = rub_to_eur(rubles)
    print(f"Вы получите: {round(result, 2)} €")
else:
    print("Неизвестная валюта")

Обратите внимание, как чисто выглядит основная часть программы. Мы спрятали математику внутрь функций rub_to_usd и rub_to_eur. Если завтра курс изменится, нам нужно будет поправить его только в одном месте внутри функции.

Советы по стилю (PEP 8)

В Python есть официальный свод правил оформления кода — PEP 8. Вот пара правил касательно функций:

1. Названия функций пишутся маленькими буквами через нижнее подчеркивание: calculate_tax, а не CalculateTax.
2. После определения функции нужно оставлять две пустые строки перед следующим кодом.
3. Старайтесь, чтобы одна функция делала только одно дело. Функция save_user_and_send_email — это плохой знак. Лучше разбить её на две.

Заключение

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

В следующей статье мы коснемся темы, которая пугает многих новичков, но на самом деле очень логична — Объектно-Ориентированное Программирование (ООП). Мы узнаем, как создавать свои собственные типы данных.

Домашнее задание для самопроверки:

1. Напишите функцию is_even(number), которая принимает число и возвращает True, если оно четное, и False, если нечетное. (Подсказка: используйте оператор остатка от деления %).
2. Изучите модуль time и функцию time.sleep(). Напишите программу «Таймер», которая ведет обратный отсчет от 5 до 0 с паузой в 1 секунду между числами.
3. Перепишите игру «Угадай число» из второго урока, вынеся логику генерации числа и проверки ответа в отдельные функции.

Продвинутые техники: работа с файлами, основы ООП и финальный проект

Поздравляю! Вы добрались до финишной прямой нашего курса. Мы прошли путь от установки Python до написания функций. Но до сих пор наши программы имели один существенный недостаток: у них была «короткая память». Как только вы закрывали программу, все данные — переменные, списки, словари — исчезали навсегда.

Сегодня мы это исправим. Мы научимся сохранять результаты работы в файлы, чтобы они оставались на диске даже после выключения компьютера. Затем мы познакомимся с Объектно-Ориентированным Программированием (ООП) — парадигмой, на которой построен весь современный софт. И в конце мы объединим все знания, чтобы создать финальный проект: полноценный менеджер задач.

Часть 1. Работа с файлами: долговременная память

Вся работа с файлами в Python сводится к трем этапам: открыть, сделать дело (прочитать или записать), закрыть. Если забыть закрыть файл, он может повредиться или занимать лишнюю память.

Чтение из файла

Представьте, что у нас есть файл notes.txt с текстом. Чтобы прочитать его, используется функция open().

Раньше программисты писали так:

file = open('notes.txt', 'r') # 'r' означает read (чтение)
content = file.read()
print(content)
file.close() # Обязательно закрыть!

Но это плохой стиль. Если программа сломается до строчки close(), файл останется «висеть» открытым. В современном Python используют конструкцию with. Она автоматически закрывает файл, даже если произошла ошибка.

# Правильный способ
with open('notes.txt', 'r', encoding='utf-8') as file:
    content = file.read()
    print(content)
# Здесь файл уже закрыт автоматически

Обратите внимание на encoding='utf-8'. Это важно для корректного отображения кириллицы (русских букв).

Запись в файл

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

• 'w' (write) — Перезапись. Удаляет всё старое содержимое и пишет новое.
• 'a' (append) — Добавление. Дописывает информацию в конец файла, сохраняя старое.

# Создадим список покупок
products = ["Хлеб", "Молоко", "Сыр"]

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

После выполнения этого кода рядом с вашей программой появится файл shopping_list.txt.

Часть 2. Основы ООП: Классы и Объекты

До этого момента мы писали код в процедурном стиле: просто набор команд и функций. Но когда программа становится огромной (как Windows или Instagram), управлять тысячами функций сложно. Тут на помощь приходит ООП.

Суть ООП проста: мы описываем объекты из реального мира в коде.

Класс vs Объект

Представьте, что вы архитектор.

1. Класс (Class) — это чертеж дома. На чертеже написано: «У дома должны быть стены, крыша и дверь». Сам чертеж — это не дом, в нем нельзя жить.
2. Объект (Object) — это конкретный дом, построенный по этому чертежу. По одному чертежу можно построить сотню домов.

Создаем свой первый класс

Давайте создадим класс Cat (Кошка). У каждой кошки есть имя и цвет (атрибуты), и она умеет мяукать (метод).

class Cat:
    # Магический метод __init__ запускается при создании объекта
    def __init__(self, name, color):
        self.name = name    # Запоминаем имя конкретной кошки
        self.color = color  # Запоминаем цвет

    # Метод (функция внутри класса)
    def meow(self):
        print(f"{self.name} говорит: Мяу!")

    def info(self):
        print(f"Это {self.color} кошка по имени {self.name}.")

Что такое self?

Вы заметили слово self? Это ссылка на самого себя. Когда мы создаем 10 разных кошек, каждая из них должна знать свое собственное имя. self.name означает «имя именно этого объекта».

Использование класса

# Строим объекты по чертежу
cat1 = Cat("Мурка", "белая")
cat2 = Cat("Барсик", "рыжий")

# Используем их
cat1.meow()  # Вывод: Мурка говорит: Мяу!
cat2.info()  # Вывод: Это рыжий кошка по имени Барсик.

Мы создали свой собственный тип данных! Теперь cat1 — это не строка и не число, это экземпляр класса Cat.

Часть 3. Финальный проект: «Умный список задач»

Пришло время объединить всё: переменные, циклы, условия, функции, файлы и классы. Мы напишем программу, которая позволяет добавлять задачи, отмечать их выполнение и сохранять всё в файл.

Шаг 1. Проектируем класс задачи

Каждая задача будет объектом. У нее будет текст и статус (выполнена или нет).

class Task:
    def __init__(self, text, is_done=False):
        self.text = text
        self.is_done = is_done

    def mark_done(self):
        self.is_done = True

    def __str__(self):
        # Красивый вывод задачи при печати
        status = "[x]" if self.is_done else "[ ]"
        return f"{status} {self.text}"

Шаг 2. Функции для работы с файлом

Нам нужно уметь сохранять список задач в файл и загружать его обратно.

FILENAME = "mytasks.txt"

def save_tasks(tasks):
    with open(FILENAME, 'w', encoding='utf-8') as f:
        for task in tasks:
            # Записываем: Текст задачи|Статус
            # str(task.is_done) превратит True/False в текст
            f.write(f"{task.text}|{str(task.is_done)}\n")

def load_tasks():
    tasks = []
    try:
        with open(FILENAME, 'r', encoding='utf-8') as f:
            for line in f:
                # Разделяем строку по символу |
                parts = line.strip().split('|')
                if len(parts) == 2:
                    text = parts[0]
                    # Превращаем строку 'True' обратно в булево значение
                    is_done = parts[1] == 'True'
                    tasks.append(Task(text, is_done))
    except FileNotFoundError:
        # Если файла нет (первый запуск), возвращаем пустой список
        return []
    return tasks

Шаг 3. Основной цикл программы

Теперь соберем всё вместе в меню.

def main():
    tasks = load_tasks() # Загружаем старые задачи
    print("Добро пожаловать в Task Manager!")

    while True:
        print("\n1. Показать задачи")
        print("2. Добавить задачу")
        print("3. Выполнить задачу")
        print("4. Выход и сохранение")

        choice = input("Выберите действие: ")

        if choice == "1":
            print("\n--- Ваши задачи ---")
            for index, task in enumerate(tasks):
                # enumerate дает и номер (index), и сам объект (task)
                print(f"{index + 1}. {task}")

        elif choice == "2":
            text = input("Введите задачу: ")
            tasks.append(Task(text))
            print("Добавлено!")

        elif choice == "3":
            num = int(input("Номер выполненной задачи: ")) - 1
            if 0 <= num < len(tasks):
                tasks[num].mark_done()
                print("Отлично! Задача выполнена.")
            else:
                print("Неверный номер.")

        elif choice == "4":
            save_tasks(tasks)
            print("Задачи сохранены. До свидания!")
            break

        else:
            print("Неизвестная команда.")

# Запуск программы
if __name__ == "__main__":
    main()

Создайте файл project.py, вставьте туда весь код (класс, функции и main) и запустите. Попробуйте добавить задачи, выйти из программы, а потом запустить её снова. Ваши задачи останутся на месте!

Заключение курса

Поздравляю! Вы прошли путь от «Hello, World!» до создания собственного приложения с базой данных (пусть и в текстовом файле) и объектной структурой.

Что вы теперь умеете:

1. Писать чистый и понятный код на Python.
2. Использовать переменные, циклы и условия для логики.
3. Организовывать данные в списки и словари.
4. Разбивать код на функции и классы.
5. Работать с файловой системой.

Куда двигаться дальше? Python огромен. Вот популярные направления:

• Веб-разработка: Изучите фреймворки Django или Flask.
• Анализ данных: Библиотеки Pandas и Matplotlib.
• Телеграм-боты: Библиотека aiogram.

Не останавливайтесь. Лучший способ учиться — придумывать себе задачи и решать их. Удачи в мире программирования!