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

📖 Теоретическая база

В Python существует несколько основных типов данных для работы с числами, логическими значениями и текстом:

Тип	Описание	Примеры значений
`int`	Целые числа	783, 0, -192
`float`	Числа с плавающей точкой	9.23, 0.0, -1.7e-6
`bool`	Логические значения	True, False
`str`	Строки (текст)	"Hello", 'Python', """многострочный"""

Особенности строк:

\n - перевод строки
\t - символ табуляции
\' - экранирование апострофа
"""текст""" - многострочные строки

Числа с плавающей точкой хранятся как приближенные значения! Будьте осторожны при сравнении.

💡 Практические примеры

Работа с целыми числами:

x = 42
y = -17
result = x + y  # 25

Числа с плавающей точкой:

pi = 3.14159
radius = 5.0
area = pi * radius ** 2  # 78.54

Логические значения:

is_student = True
is_teacher = False
result = is_student and not is_teacher  # True

Строки:

name = "Иван"
greeting = 'Привет, ' + name + '!'
multiline = """Это
многострочный
текст"""

🎯 Методические рекомендации

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

Особое внимание уделите правильному использованию кавычек в строках и экранированию специальных символов.

Задача: Создайте переменные разных типов и выведите их на экран. Какой тип будет у результата выражения 10 + 5.0?

x = 10
y = 5.0
result = x + y
print(result)       # 15.0
print(type(result)) # <class 'float'>

Ответ: Результат будет иметь тип float, так как при операции между int и float Python автоматически преобразует результат к float (более общему типу).

2 Контейнерные типы данных

📖 Теоретическая база

Контейнеры позволяют хранить несколько значений в одной переменной. В Python есть четыре основных контейнерных типа:

Тип	Изменяемый	Упорядоченный	Пример
`list` (список)	✓ Да	✓ Да	[1, 5, 9]
`tuple` (кортеж)	✗ Нет	✓ Да	(1, 5, 9)
`dict` (словарь)	✓ Да	✗ Нет	{1: "one", 2: "two"}
`set` (множество)	✓ Да	✗ Нет	{1, 9, 3, 0}

Особенности типов:

Список (list): упорядоченная коллекция, быстрый доступ по индексу, можно изменять
Кортеж (tuple): неизменяемая версия списка, используется для постоянных данных
Словарь (dict): соответствие ключ-значение, быстрый поиск по ключу
Множество (set): уникальные элементы, быстрая проверка вхождения

💡 Практические примеры

Списки (list):

numbers = [1, 5, 9]
mixed = ["текст", 11, 8.9]
empty = []

# Можно изменять
numbers[0] = 10  # [10, 5, 9]
numbers.append(15)  # [10, 5, 9, 15]

Кортежи (tuple):

coordinates = (10, 20)
single = (42,)  # Обратите внимание на запятую!
empty = ()

# Нельзя изменять
# coordinates[0] = 5  # ОШИБКА!

Словари (dict):

student = {
    "имя": "Анна",
    "возраст": 15,
    "класс": "9А"
}

# Доступ по ключу
print(student["имя"])  # Анна
student["возраст"] = 16  # изменение значения

Множества (set):

numbers = {1, 9, 3, 0, 1, 9}  # {0, 1, 3, 9} - дубликаты удалены
empty = set()  # пустое множество

# Операции с множествами
a = {1, 2, 3}
b = {3, 4, 5}
print(a | b)  # {1, 2, 3, 4, 5} - объединение
print(a & b)  # {3} - пересечение

Задача: Создайте список из 5 чисел, словарь с информацией о книге (название, автор, год) и множество из первых 10 простых чисел.

# Список
numbers = [2, 4, 6, 8, 10]

# Словарь
book = {
    "название": "Python для начинающих",
    "автор": "Иванов И.И.",
    "год": 2024
}

# Множество простых чисел
primes = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29}

print(f"Книга: {book['название']}")
print(f"Количество простых чисел: {len(primes)}")

3 Переменные и присваивание

📖 Теоретическая база

Переменная - это имя, связанное со значением в памяти компьютера. В Python переменные создаются при первом присваивании значения.

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

Начинается с буквы (a-z, A-Z) или подчеркивания (_)
Далее могут быть буквы, цифры (0-9) и подчеркивания
Регистр важен: name и Name - разные переменные
Нельзя использовать ключевые слова Python (if, for, while и т.д.)
Лучше избегать нелатинских букв

Типы присваивания:

Простое: x = 5
Множественное: x, y, z = 1, 2, 3
Цепное: x = y = z = 0
С операцией: x += 3 (эквивалентно x = x + 3)

💡 Практические примеры

Правильные имена переменных:

age = 15
student_name = "Иван"
x7 = 100
_temp = 42
BigNumber = 1000000

Неправильные имена:

# 7x = 10      # ОШИБКА: начинается с цифры
# my-var = 5   # ОШИБКА: дефис не допускается
# for = 10     # ОШИБКА: ключевое слово

Множественное присваивание:

# Присваивание нескольких значений одновременно
x, y, z = 10, 20, 30
print(x, y, z)  # 10 20 30

# Обмен значениями переменных
a, b = 5, 10
a, b = b, a  # Теперь a=10, b=5

Присваивание с операциями:

count = 10
count += 5   # count = count + 5, теперь count = 15
count -= 3   # count = count - 3, теперь count = 12
count *= 2   # count = count * 2, теперь count = 24
count //= 4  # count = count // 4, теперь count = 6

🎯 Методические рекомендации

Выбирайте осмысленные имена переменных, которые отражают их назначение. Вместо x используйте student_age или total_price.

Константы обычно пишут ЗАГЛАВНЫМИ_БУКВАМИ: MAX_SIZE = 100, PI = 3.14159

Задача: Создайте переменные для хранения информации о ученике: имя, возраст, средний балл. Увеличьте возраст на 1 и средний балл на 0.5.

student_name = "Мария"
age = 14
average_score = 4.5

print(f"До: {student_name}, {age} лет, средний балл {average_score}")

# Увеличиваем значения
age += 1
average_score += 0.5

print(f"После: {student_name}, {age} лет, средний балл {average_score}")

Вывод:
До: Мария, 14 лет, средний балл 4.5
После: Мария, 15 лет, средний балл 5.0

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

📖 Теоретическая база

Python позволяет преобразовывать данные из одного типа в другой с помощью встроенных функций:

Функция	Описание	Пример
`int(x)`	Преобразование в целое число	int("15") → 15
`float(x)`	Преобразование в число с плавающей точкой	float("3.14") → 3.14
`str(x)`	Преобразование в строку	str(42) → "42"
`bool(x)`	Преобразование в логическое значение	bool(0) → False
`list(x)`	Преобразование в список	list("abc") → ['a', 'b', 'c']
`tuple(x)`	Преобразование в кортеж	tuple([1, 2, 3]) → (1, 2, 3)
`set(x)`	Преобразование в множество	set([1, 1, 2]) → {1, 2}

При преобразовании float в int дробная часть отбрасывается (не округляется)! Для округления используйте round().

💡 Практические примеры

Преобразование строк в числа:

age_str = "15"
age = int(age_str)  # 15

price_str = "99.99"
price = float(price_str)  # 99.99

# С указанием системы счисления
binary = int("1010", 2)  # 10 (двоичная система)
hex_num = int("FF", 16)  # 255 (шестнадцатеричная)

Преобразование чисел в строки:

count = 42
message = "У вас " + str(count) + " сообщения"

# Или с помощью f-строк (лучше)
message = f"У вас {count} сообщения"

Преобразование в логический тип:

# False: 0, 0.0, "", [], (), {}, None
print(bool(0))      # False
print(bool(""))     # False
print(bool([]))     # False

# True: все остальное
print(bool(42))     # True
print(bool("Hi"))   # True
print(bool([1]))    # True

Работа со списками и множествами:

# Строка в список
text = "Python"
chars = list(text)  # ['P', 'y', 't', 'h', 'o', 'n']

# Список в множество (удаление дубликатов)
numbers = [1, 2, 2, 3, 3, 3]
unique = set(numbers)  # {1, 2, 3}

# Соединение строк из списка
words = ["Hello", "World"]
sentence = " ".join(words)  # "Hello World"

Задача: Пользователь вводит два числа в виде строк. Преобразуйте их в числа, вычислите сумму и среднее значение.

# Ввод данных (в реальной программе используйте input())
num1_str = "25"
num2_str = "35"

# Преобразование в числа
num1 = int(num1_str)
num2 = int(num2_str)

# Вычисления
total = num1 + num2
average = total / 2

# Вывод результата
print(f"Сумма: {total}")
print(f"Среднее: {average}")
# Вывод:
# Сумма: 60
# Среднее: 30.0

Важно: Обратите внимание, что результат деления - число с плавающей точкой (30.0), даже если оба числа целые!

5 Доступ к элементам последовательностей

📖 Теоретическая база

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

Индексация:

Положительные индексы: начинаются с 0 (первый элемент)
Отрицательные индексы: с конца, -1 (последний элемент)

lst = [11, 67, "abc", 3.14, 42, 1968]
#      0   1     2     3    4    5      (положительные)
#     -6  -5    -4    -3   -2   -1      (отрицательные)

Срезы (slicing):

Синтаксис: [начало:конец:шаг]

начало - индекс первого элемента (включительно)
конец - индекс последнего элемента (НЕ включительно)
шаг - интервал между элементами (по умолчанию 1)

💡 Практические примеры

Доступ по индексу:

lst = [11, 67, "abc", 3.14, 42, 1968]

print(lst[0])   # 11 (первый элемент)
print(lst[2])   # "abc"
print(lst[-1])  # 1968 (последний элемент)
print(lst[-2])  # 42 (предпоследний)

Срезы последовательностей:

lst = [11, 67, "abc", 3.14, 42, 1968]

# Основные срезы
print(lst[1:3])    # [67, "abc"] (элементы с 1 по 2)
print(lst[:3])     # [11, 67, "abc"] (первые 3)
print(lst[4:])     # [42, 1968] (с 4-го до конца)
print(lst[:-1])    # [11, 67, "abc", 3.14, 42] (все кроме последнего)

# С шагом
print(lst[::2])    # [11, "abc", 42] (каждый второй)
print(lst[1::2])   # [67, 3.14, 1968] (каждый второй, начиная с 1)
print(lst[::-1])   # [1968, 42, 3.14, "abc", 67, 11] (в обратном порядке)

# Копия списка
copy = lst[:]      # [11, 67, "abc", 3.14, 42, 1968]

Работа со строками:

text = "Python"

print(text[0])      # 'P' (первая буква)
print(text[-1])     # 'n' (последняя буква)
print(text[0:2])    # 'Py' (первые две буквы)
print(text[2:])     # 'thon' (с третьей до конца)
print(text[::-1])   # 'nohtyP' (строка наоборот)

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

lst = [1, 2, 3, 4, 5]

# Изменение элемента
lst[0] = 10         # [10, 2, 3, 4, 5]

# Изменение среза
lst[1:4] = [20, 30, 40]  # [10, 20, 30, 40, 5]

# Удаление элементов
del lst[0]          # [20, 30, 40, 5]
del lst[1:3]        # [20, 5]

🎯 Методические рекомендации

Важно понимать разницу между индексацией и срезами. Индексация возвращает один элемент, срез - новую последовательность.

Помните: правая граница среза НЕ включается! lst[1:3] вернет элементы с индексами 1 и 2, но не 3.

Задача: Дан список оценок студента. Получите первые 3 оценки, последние 2 оценки, и все оценки через одну.

grades = [5, 4, 5, 3, 4, 5, 4, 5]

first_three = grades[:3]      # [5, 4, 5]
last_two = grades[-2:]        # [4, 5]
every_second = grades[::2]    # [5, 5, 4, 4]

print(f"Первые 3 оценки: {first_three}")
print(f"Последние 2 оценки: {last_two}")
print(f"Каждая вторая оценка: {every_second}")

# Средний балл
average = sum(grades) / len(grades)
print(f"Средний балл: {average:.2f}")  # 4.38

6 Условный оператор (if-elif-else)

📖 Теоретическая база

Условный оператор позволяет выполнять разные блоки кода в зависимости от условий.

Структура условного оператора:

if условие1:
    # блок выполняется, если условие1 истинно
    инструкция1
elif условие2:
    # блок выполняется, если условие2 истинно
    инструкция2
else:
    # блок выполняется во всех остальных случаях
    инструкция3

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

Оператор	Значение	Пример
`==`	Равно	x == 5
`!=`	Не равно	x != 0
`<`	Меньше	x < 10
`>`	Больше	x > 0
`<=`	Меньше или равно	x <= 5
`>=`	Больше или равно	x >= 0

В Python важны отступы! Блоки кода внутри if должны иметь одинаковый отступ (обычно 4 пробела).

💡 Практические примеры

Простое условие:

age = 16

if age >= 18:
    print("Вы совершеннолетний")
else:
    print("Вы несовершеннолетний")

Множественные условия:

grade = 85

if grade >= 90:
    print("Оценка: 5 (Отлично)")
elif grade >= 75:
    print("Оценка: 4 (Хорошо)")
elif grade >= 60:
    print("Оценка: 3 (Удовлетворительно)")
else:
    print("Оценка: 2 (Неудовлетворительно)")

Вложенные условия:

temperature = 25
is_raining = False

if temperature > 20:
    if is_raining:
        print("Тепло, но дождь. Возьмите зонт!")
    else:
        print("Отличная погода для прогулки!")
else:
    print("Холодно. Оденьтесь теплее!")

Проверка нескольких условий:

x = 15

# and - все условия должны быть истинны
if x > 10 and x < 20:
    print("x между 10 и 20")

# or - хотя бы одно условие истинно
if x == 5 or x == 15:
    print("x равен 5 или 15")

# not - инверсия условия
if not (x < 10):
    print("x НЕ меньше 10")

Задача: Напишите программу, которая определяет категорию спортсмена по возрасту: младшая (до 12), средняя (12-16), старшая (17-18), взрослые (19+).

age = 14

if age < 12:
    category = "Младшая категория"
elif age <= 16:
    category = "Средняя категория"
elif age <= 18:
    category = "Старшая категория"
else:
    category = "Взрослая категория"

print(f"Возраст: {age} лет")
print(f"Категория: {category}")

# Вывод:
# Возраст: 14 лет
# Категория: Средняя категория

7 Циклы: while и for

📖 Теоретическая база

Циклы позволяют выполнять блок кода многократно. В Python есть два типа циклов:

Цикл while (с условием):

while условие:
    # блок выполняется, пока условие истинно
    инструкции

Цикл for (цикл перебора):

for переменная in последовательность:
    # блок выполняется для каждого элемента
    инструкции

Функция range():

range(n) - числа от 0 до n-1
range(start, stop) - от start до stop-1
range(start, stop, step) - с шагом step

Управление циклом:

break - немедленный выход из цикла
continue - переход к следующей итерации

Остерегайтесь бесконечных циклов! Убедитесь, что условие цикла когда-нибудь станет ложным.

💡 Практические примеры

Цикл while:

# Вычисление суммы квадратов чисел от 1 до 100
s = 0
i = 1
while i <= 100:
    s = s + i**2
    i = i + 1
print(f"Сумма квадратов: {s}")

Цикл for по элементам:

# Подсчет букв 'e' в строке
text = "Some text"
count = 0
for char in text:
    if char == "e":
        count += 1
print(f"Найдено {count} букв 'e'")

Цикл for с range():

# Примеры range()
print(list(range(5)))           # [0, 1, 2, 3, 4]
print(list(range(3, 8)))        # [3, 4, 5, 6, 7]
print(list(range(2, 12, 3)))    # [2, 5, 8, 11]

# Использование в цикле
for i in range(1, 6):
    print(f"{i} в квадрате = {i**2}")

Проход по индексам:

lst = [11, 18, 9, 12, 23, 4, 17]
lost = []

# Изменяем элементы больше 15
for idx in range(len(lst)):
    if lst[idx] > 15:
        lost.append(lst[idx])
        lst[idx] = 15

print(f"Изменённый список: {lst}")
print(f"Потерянные значения: {lost}")

Enumerate (индексы + значения):

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

for index, fruit in enumerate(fruits):
    print(f"{index}: {fruit}")
    
# Вывод:
# 0: яблоко
# 1: банан
# 2: апельсин

Break и continue:

# break - выход из цикла
for i in range(10):
    if i == 5:
        break  # прерываем при i=5
    print(i)  # выведет 0, 1, 2, 3, 4

# continue - пропуск итерации
for i in range(5):
    if i == 2:
        continue  # пропускаем i=2
    print(i)  # выведет 0, 1, 3, 4

Задача: Напишите программу, которая находит все четные числа от 1 до 20 и вычисляет их сумму.

# Решение 1: с циклом for
total = 0
even_numbers = []

for i in range(1, 21):
    if i % 2 == 0:  # проверка на четность
        even_numbers.append(i)
        total += i

print(f"Четные числа: {even_numbers}")
print(f"Их сумма: {total}")

# Решение 2: с range и шагом (элегантнее)
total2 = 0
for i in range(2, 21, 2):  # от 2 до 20 с шагом 2
    total2 += i

print(f"Сумма (способ 2): {total2}")

# Решение 3: с помощью sum() (самое короткое)
total3 = sum(range(2, 21, 2))
print(f"Сумма (способ 3): {total3}")

# Вывод:
# Четные числа: [2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
# Их сумма: 110

8 Математические операции

📖 Теоретическая база

Базовые операторы:

Оператор	Операция	Пример	Результат
`+`	Сложение	5 + 3	8
`-`	Вычитание	5 - 3	2
`*`	Умножение	5 * 3	15
`/`	Деление	5 / 2	2.5
`//`	Целочисленное деление	5 // 2	2
`%`	Остаток от деления	5 % 2	1
`**`	Возведение в степень	2 ** 3	8

Полезные функции:

abs(x) - модуль числа
round(x, n) - округление до n знаков
max(a, b, c) - максимум
min(a, b, c) - минимум
sum([a, b, c]) - сумма элементов

Модуль math:

from math import sin, cos, pi, sqrt, log, e

sin(pi/4)      # синус 45°
cos(2*pi/3)    # косинус 120°
sqrt(81)       # квадратный корень
log(e**2)      # натуральный логарифм

💡 Практические примеры

Базовые операции:

# Арифметические операции
result = (1 + 5.3) * 2  # 12.6
print(result)

# Целочисленное деление и остаток
quotient = 17 // 5   # 3
remainder = 17 % 5   # 2
print(f"17 : 5 = {quotient} (остаток {remainder})")

# Возведение в степень
power = 2 ** 10  # 1024
print(f"2^10 = {power}")

Работа с модулем и округлением:

# Абсолютное значение
print(abs(-3.2))        # 3.2
print(abs(5))           # 5

# Округление
print(round(3.14159))       # 3 (до целого)
print(round(3.14159, 2))    # 3.14 (до 2 знаков)
print(round(3.5))           # 4 (округление вверх)
print(round(2.5))           # 2 (округление к четному)

# Максимум и минимум
numbers = [23, 5, 67, 12, 89]
print(f"Максимум: {max(numbers)}")    # 89
print(f"Минимум: {min(numbers)}")     # 5
print(f"Сумма: {sum(numbers)}")       # 196

Тригонометрия и логарифмы:

from math import sin, cos, pi, sqrt, log, e

# Тригонометрические функции (углы в радианах!)
angle_deg = 45
angle_rad = angle_deg * pi / 180  # перевод в радианы
print(f"sin(45°) = {sin(angle_rad):.4f}")
print(f"cos(60°) = {cos(pi/3):.4f}")

# Квадратный корень
print(f"√81 = {sqrt(81)}")

# Логарифмы
print(f"ln(e²) = {log(e**2):.4f}")

# Пример: площадь круга
radius = 5
area = pi * radius**2
print(f"Площадь круга радиусом {radius} = {area:.2f}")

Проверка четности и деление:

# Проверка четности
number = 42
if number % 2 == 0:
    print(f"{number} - четное число")
else:
    print(f"{number} - нечетное число")

# Проверка делимости
if number % 7 == 0:
    print(f"{number} делится на 7 без остатка")

Задача: Напишите программу для вычисления площади и периметра прямоугольника. Также вычислите длину диагонали.

from math import sqrt

# Исходные данные
length = 8
width = 6

# Вычисления
area = length * width
perimeter = 2 * (length + width)
diagonal = sqrt(length**2 + width**2)

# Вывод результатов
print(f"Прямоугольник {length}×{width}:")
print(f"Площадь: {area} кв.ед.")
print(f"Периметр: {perimeter} ед.")
print(f"Диагональ: {diagonal:.2f} ед.")

# Вывод:
# Прямоугольник 8×6:
# Площадь: 48 кв.ед.
# Периметр: 28 ед.
# Диагональ: 10.00 ед.

9 Булева логика и логические операции

📖 Теоретическая база

Булева логика работает с логическими значениями True (истина) и False (ложь).

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

Оператор	Операция	Описание
`and`	Логическое И	True, если оба условия истинны
`or`	Логическое ИЛИ	True, если хотя бы одно условие истинно
`not`	Логическое НЕ	Инверсия: True → False, False → True

Таблицы истинности:

# AND (И) - оба должны быть True
True and True   → True
True and False  → False
False and True  → False
False and False → False

# OR (ИЛИ) - хотя бы один True
True or True    → True
True or False   → True
False or True   → True
False or False  → False

# NOT (НЕ) - инверсия
not True  → False
not False → True

Операторы сравнения возвращают логические значения:

> 3    # True
< 3    # False
== 5   # True
!= 3   # True

💡 Практические примеры

Базовые логические операции:

# AND - все условия должны быть истинны
age = 20
has_license = True

can_drive = age >= 18 and has_license
print(f"Может водить: {can_drive}")  # True

# OR - хотя бы одно условие истинно
is_weekend = False
is_holiday = True

free_day = is_weekend or is_holiday
print(f"Свободный день: {free_day}")  # True

# NOT - отрицание
is_raining = False
go_for_walk = not is_raining
print(f"Идем гулять: {go_for_walk}")  # True

Сложные логические выражения:

grade = 85
attendance = 90

# Комбинация условий
excellent = grade >= 90 and attendance >= 95
good = grade >= 75 and attendance >= 80
passed = grade >= 60 and attendance >= 75

print(f"Отлично: {excellent}")  # False
print(f"Хорошо: {good}")        # True
print(f"Сдал: {passed}")        # True

Проверка диапазонов:

temperature = 22

# Способ 1
comfortable = temperature >= 18 and temperature <= 25

# Способ 2 (более короткий)
comfortable = 18 <= temperature <= 25

print(f"Комфортная температура: {comfortable}")  # True

# Проверка вне диапазона
x = 15
out_of_range = x < 10 or x > 20
print(f"Вне диапазона [10, 20]: {out_of_range}")  # False

Приоритет операций:

# Порядок: not > and > or
result = True or False and False
# Выполняется как: True or (False and False)
# = True or False
# = True

# Используйте скобки для ясности
result = (True or False) and False
# = True and False
# = False

print(result)

Логические значения в условиях:

# Эти значения считаются False:
# False, None, 0, 0.0, "", [], (), {}, set()

# Все остальные значения считаются True

if []:  # пустой список = False
    print("Не выполнится")

if [1, 2]:  # непустой список = True
    print("Выполнится!")

# Проверка наличия элементов
numbers = [1, 2, 3]
if numbers:
    print(f"В списке {len(numbers)} элемента")

Задача: Напишите программу, которая проверяет, может ли студент сдать экзамен. Условия: средний балл ≥ 75 И посещаемость ≥ 80% ИЛИ есть рекомендация преподавателя.

average_grade = 72
attendance = 85
has_recommendation = True

# Способ 1: пошаговая проверка
meets_requirements = average_grade >= 75 and attendance >= 80
can_take_exam = meets_requirements or has_recommendation

print(f"Средний балл: {average_grade}")
print(f"Посещаемость: {attendance}%")
print(f"Рекомендация: {has_recommendation}")
print(f"Допущен к экзамену: {can_take_exam}")
print()

# Способ 2: одно выражение
allowed = (average_grade >= 75 and attendance >= 80) or has_recommendation
print(f"Допущен (способ 2): {allowed}")

# Подробный вывод
if average_grade >= 75 and attendance >= 80:
    print("Причина: выполнены основные требования")
elif has_recommendation:
    print("Причина: есть рекомендация преподавателя")
else:
    print("Причина: не допущен к экзамену")

# Вывод:
# Средний балл: 72
# Посещаемость: 85%
# Рекомендация: True
# Допущен к экзамену: True
# Причина: есть рекомендация преподавателя

10 Определение и вызов функций

📖 Теоретическая база

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

Определение функции:

def function_name(parameter1, parameter2):
    """Документация функции"""
    # Тело функции
    result = parameter1 + parameter2
    return result

Ключевые элементы:

def - ключевое слово определения функции
Имя функции - следует правилам именования переменных
Параметры - входные данные (могут отсутствовать)
Docstring - описание функции в тройных кавычках
return - возврат результата (необязательно)

Если функция не содержит return, она возвращает None по умолчанию.

💡 Практические примеры

Простая функция:

def greet(name):
    """Приветствует пользователя по имени"""
    message = f"Привет, {name}!"
    return message

# Вызов функции
result = greet("Анна")
print(result)  # Привет, Анна!

# Прямой вывод
print(greet("Иван"))  # Привет, Иван!

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

def calculate_rectangle(length, width):
    """Вычисляет площадь и периметр прямоугольника"""
    area = length * width
    perimeter = 2 * (length + width)
    return area, perimeter  # возврат нескольких значений

# Вызов функции
a, p = calculate_rectangle(5, 3)
print(f"Площадь: {a}, Периметр: {p}")

Функция с параметрами по умолчанию:

def power(base, exponent=2):
    """Возводит число в степень (по умолчанию в квадрат)"""
    return base ** exponent

print(power(5))      # 25 (5²)
print(power(5, 3))   # 125 (5³)
print(power(2, 10))  # 1024 (2¹⁰)

Функция без возвращаемого значения:

def print_table(n):
    """Выводит таблицу умножения для числа n"""
    for i in range(1, 11):
        print(f"{n} × {i} = {n * i}")

# Вызов функции
print_table(7)
# Вывод:
# 7 × 1 = 7
# 7 × 2 = 14
# ...

Рекурсивная функция:

def factorial(n):
    """Вычисляет факториал числа n"""
    if n <= 1:
        return 1
    else:
        return n * factorial(n - 1)

print(f"5! = {factorial(5)}")  # 120
print(f"7! = {factorial(7)}")  # 5040

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

def sum_all(*numbers):
    """Суммирует любое количество чисел"""
    total = 0
    for num in numbers:
        total += num
    return total

print(sum_all(1, 2, 3))           # 6
print(sum_all(10, 20, 30, 40))    # 100

# Более короткая версия
def sum_all_v2(*numbers):
    return sum(numbers)

🎯 Методические рекомендации

Функции должны выполнять одну конкретную задачу. Давайте функциям осмысленные имена, описывающие их действие (глаголы): calculate_area(), find_max(), is_prime().

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

Задача: Создайте функцию для проверки, является ли число простым. Простое число делится только на 1 и на себя.

def is_prime(n):
    """
    Проверяет, является ли число простым.
    
    Args:
        n: Целое число для проверки
    
    Returns:
        True если число простое, False иначе
    """
    if n < 2:
        return False
    
    # Проверяем делители от 2 до sqrt(n)
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            return False
    
    return True

# Тестирование функции
test_numbers = [2, 3, 4, 5, 15, 17, 20, 23, 100]

print("Проверка простых чисел:")
for num in test_numbers:
    if is_prime(num):
        print(f"{num} - простое")
    else:
        print(f"{num} - составное")

# Найти все простые числа до 30
primes = [n for n in range(2, 31) if is_prime(n)]
print(f"\nПростые числа до 30: {primes}")

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

📖 Теоретическая база

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

Открытие файла:

f = open("filename.txt", "mode", encoding="utf-8")

Режимы работы с файлами:

Режим	Описание
`'r'`	Чтение (read) - файл должен существовать
`'w'`	Запись (write) - создает новый или перезаписывает
`'a'`	Добавление (append) - дописывает в конец
`'r+'`	Чтение и запись

Основные операции:

f.read(n) - прочитать n символов (весь файл, если n не указан)
f.readline() - прочитать одну строку
f.readlines() - прочитать все строки в список
f.write(text) - записать текст
f.close() - закрыть файл (обязательно!)

Всегда закрывайте файлы после работы! Лучше использовать конструкцию with - она закроет файл автоматически.

💡 Практические примеры

Запись в файл:

# Простая запись
f = open("output.txt", "w", encoding="utf-8")
f.write("Привет, мир!\n")
f.write("Это вторая строка.\n")
f.close()

# Лучший способ - с автоматическим закрытием
with open("output.txt", "w", encoding="utf-8") as f:
    f.write("Привет, мир!\n")
    f.write("Это вторая строка.\n")
# Файл автоматически закрывается

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

# Чтение всего файла
with open("input.txt", "r", encoding="utf-8") as f:
    content = f.read()
    print(content)

# Чтение по строкам
with open("input.txt", "r", encoding="utf-8") as f:
    for line in f:
        print(line.strip())  # strip() удаляет \n

# Чтение всех строк в список
with open("input.txt", "r", encoding="utf-8") as f:
    lines = f.readlines()
    print(f"Всего строк: {len(lines)}")

Добавление в конец файла:

with open("log.txt", "a", encoding="utf-8") as f:
    f.write("Новая запись в логе\n")
    f.write(f"Время: {datetime.now()}\n")

Практический пример - анализ текста:

def analyze_file(filename):
    """Анализирует текстовый файл"""
    with open(filename, "r", encoding="utf-8") as f:
        lines = f.readlines()
    
    total_lines = len(lines)
    total_chars = sum(len(line) for line in lines)
    total_words = sum(len(line.split()) for line in lines)
    
    return {
        "lines": total_lines,
        "words": total_words,
        "chars": total_chars
    }

# Использование
stats = analyze_file("text.txt")
print(f"Строк: {stats['lines']}")
print(f"Слов: {stats['words']}")
print(f"Символов: {stats['chars']}")

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

# Запись данных учеников в CSV
students = [
    ["Имя", "Возраст", "Средний балл"],
    ["Анна", "15", "4.8"],
    ["Иван", "16", "4.2"],
    ["Мария", "15", "4.9"]
]

with open("students.csv", "w", encoding="utf-8") as f:
    for row in students:
        f.write(",".join(row) + "\n")

# Чтение CSV файла
with open("students.csv", "r", encoding="utf-8") as f:
    for line in f:
        data = line.strip().split(",")
        print(data)

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

from datetime import datetime

def add_diary_entry(text):
    """Добавляет запись в дневник с текущей датой"""
    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    entry = f"[{timestamp}] {text}\n"
    
    with open("diary.txt", "a", encoding="utf-8") as f:
        f.write(entry)
    
    print("Запись добавлена в дневник!")

def read_diary():
    """Читает и выводит все записи дневника"""
    try:
        with open("diary.txt", "r", encoding="utf-8") as f:
            entries = f.readlines()
            
        if entries:
            print("\n=== МОЙ ДНЕВНИК ===")
            for entry in entries:
                print(entry.strip())
            print(f"\nВсего записей: {len(entries)}")
        else:
            print("Дневник пуст")
    except FileNotFoundError:
        print("Файл дневника не найден")

# Использование
add_diary_entry("Сегодня был отличный день!")
add_diary_entry("Решил сложную задачу по Python")
add_diary_entry("Изучил работу с файлами")

# Чтение дневника
read_diary()

# Вывод:
# Запись добавлена в дневник!
# Запись добавлена в дневник!
# Запись добавлена в дневник!
#
# === МОЙ ДНЕВНИК ===
# [2025-11-06 14:30:15] Сегодня был отличный день!
# [2025-11-06 14:30:15] Решил сложную задачу по Python
# [2025-11-06 14:30:15] Изучил работу с файлами
#
# Всего записей: 3

12 Форматирование строк

📖 Теоретическая база

Python предоставляет несколько способов форматирования строк - вставки значений переменных в текст.

Методы форматирования:

F-строки (f-strings) - современный и удобный способ
Метод format() - универсальный метод
Оператор % - старый способ (не рекомендуется)

F-строки (рекомендуется):

name = "Анна"
age = 15
message = f"Меня зовут {name}, мне {age} лет"

Спецификаторы форматирования:

Формат	Описание	Пример
`{value:.2f}`	2 знака после запятой	3.14
`{value:10s}`	Строка шириной 10	"текст "
`{value:>10s}`	Выравнивание вправо	" текст"
`{value:^10s}`	По центру	" текст "
`{value:d}`	Десятичное целое	42
`{value:b}`	Двоичное	101010
`{value:x}`	Шестнадцатеричное	2a

💡 Практические примеры

F-строки (современный способ):

name = "Иван"
age = 16
height = 1.75

# Простое форматирование
print(f"Привет, {name}!")
print(f"Мне {age} лет и мой рост {height} м")

# С выражениями
print(f"Через год мне будет {age + 1}")
print(f"Мой рост: {height * 100:.0f} см")

# Форматирование чисел
pi = 3.14159
print(f"π ≈ {pi:.2f}")      # 3.14
print(f"π ≈ {pi:.4f}")      # 3.1416

Метод format():

# Позиционные аргументы
template = "{} + {} = {}"
print(template.format(2, 3, 5))  # 2 + 3 = 5

# Именованные аргументы
msg = "{name} получил оценку {grade}"
print(msg.format(name="Петр", grade=5))

# С индексами
text = "{0} {1} {0}"
print(text.format("Python", "язык"))  # Python язык Python

# Форматирование
price = 1234.5
print("Цена: {:,.2f} руб.".format(price))  # 1,234.50 руб.

Выравнивание и заполнение:

# Выравнивание
print(f"{'Лево':<10}|")     # Лево      |
print(f"{'Право':>10}|")    # Право|
print(f"{'Центр':^10}|")    # Центр  |

# Заполнение символами
print(f"{'Python':*^20}")   # *******Python*******
print(f"{42:0>5}")          # 00042

# Таблица
products = [
    ("Яблоки", 5, 50.0),
    ("Бананы", 3, 45.5),
    ("Апельсины", 4, 65.0)
]

print(f"{'Товар':<15} {'Кол-во':>7} {'Цена':>10}")
print("-" * 35)
for name, qty, price in products:
    print(f"{name:<15} {qty:>7} {price:>10.2f}")

Специальные форматы:

# Двоичная, восьмеричная, шестнадцатеричная
number = 42
print(f"Десятичное: {number:d}")      # 42
print(f"Двоичное: {number:b}")        # 101010
print(f"Восьмеричное: {number:o}")    # 52
print(f"Шестнадцатеричное: {number:x}")  # 2a
print(f"Шестнадцатеричное: {number:X}")  # 2A

# Проценты
score = 0.875
print(f"Результат: {score:.1%}")      # 87.5%

# Научная нотация
big = 1234567890
print(f"Число: {big:e}")              # 1.234568e+09

Работа со строковыми методами:

# join - соединение строк
words = ["Python", "это", "круто"]
sentence = " ".join(words)
print(sentence)  # Python это круто

delimiter = ", "
fruits = ["яблоко", "банан", "апельсин"]
result = delimiter.join(fruits)
print(result)  # яблоко, банан, апельсин

# split - разделение строки
text = "one,two,three,four"
parts = text.split(",")
print(parts)  # ['one', 'two', 'three', 'four']

# split с пробелами
sentence = "Привет мир Python"
words = sentence.split()
print(words)  # ['Привет', 'мир', 'Python']

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

def print_receipt(items):
    """
    Выводит чек покупок
    items - список кортежей (название, количество, цена)
    """
    print("=" * 50)
    print(f"{'ТОВАРНЫЙ ЧЕК':^50}")
    print("=" * 50)
    print(f"{'Товар':<25} {'Кол-во':>8} {'Цена':>8} {'Сумма':>8}")
    print("-" * 50)
    
    total = 0
    for name, qty, price in items:
        item_total = qty * price
        total += item_total
        print(f"{name:<25} {qty:>8} {price:>8.2f} {item_total:>8.2f}")
    
    print("=" * 50)
    print(f"{'ИТОГО К ОПЛАТЕ:':<38} {total:>11.2f}")
    print("=" * 50)

# Пример использования
purchases = [
    ("Молоко 3.2%", 2, 85.50),
    ("Хлеб белый", 1, 45.00),
    ("Яйца С1 (10 шт)", 1, 120.00),
    ("Масло сливочное", 1, 250.50),
    ("Сыр Российский", 0.5, 650.00)
]

print_receipt(purchases)

# Вывод:
# ==================================================
#                  ТОВАРНЫЙ ЧЕК                  
# ==================================================
# Товар                      Кол-во    Цена   Сумма
# --------------------------------------------------
# Молоко 3.2%                     2    85.50   171.00
# Хлеб белый                      1    45.00    45.00
# Яйца С1 (10 шт)                 1   120.00   120.00
# Масло сливочное                 1   250.50   250.50
# Сыр Российский                0.5   650.00   325.00
# ==================================================
# ИТОГО К ОПЛАТЕ:                          911.50
# ==================================================

13 Операции с контейнерами

📖 Теоретическая база

Python предоставляет множество встроенных функций и методов для работы с контейнерами (списки, множества, словари).

Общие функции для контейнеров:

len(c) - количество элементов
min(c), max(c) - минимум/максимум
sum(c) - сумма элементов (для чисел)
sorted(c) - отсортированная копия
reversed(c) - обратный итератор
value in c - проверка наличия

Методы списков:

lst.append(x) - добавить в конец
lst.insert(i, x) - вставить в позицию i
lst.remove(x) - удалить первое вхождение x
lst.pop(i) - удалить и вернуть элемент
lst.extend(seq) - добавить последовательность
lst.sort() - сортировать список
lst.reverse() - развернуть список

Операции с множествами:

s1 | s2 - объединение
s1 & s2 - пересечение
s1 - s2 - разность
s1 ^ s2 - симметричная разность

💡 Практические примеры

Операции со списками:

# Создание и изменение списка
numbers = [5, 2, 8, 1, 9]

# Добавление элементов
numbers.append(7)        # [5, 2, 8, 1, 9, 7]
numbers.insert(0, 10)    # [10, 5, 2, 8, 1, 9, 7]
numbers.extend([3, 4])   # [10, 5, 2, 8, 1, 9, 7, 3, 4]

# Удаление элементов
numbers.remove(8)        # Удалить 8
last = numbers.pop()     # Удалить последний (4)
first = numbers.pop(0)   # Удалить первый (10)

# Сортировка и разворот
numbers.sort()           # Сортировка по возрастанию
numbers.reverse()        # Разворот списка

print(numbers)

Поиск в списке:

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

# Проверка наличия
if "банан" in fruits:
    print("Бананы есть!")

# Индекс первого вхождения
index = fruits.index("банан")    # 1

# Количество вхождений
count = fruits.count("банан")    # 2

# Найти все индексы
indices = [i for i, x in enumerate(fruits) if x == "банан"]
print(f"Индексы бананов: {indices}")  # [1, 3]

Работа с множествами:

# Создание множеств
set1 = {1, 2, 3, 4, 5}
set2 = {4, 5, 6, 7, 8}

# Объединение (все уникальные элементы)
union = set1 | set2
print(f"Объединение: {union}")  # {1, 2, 3, 4, 5, 6, 7, 8}

# Пересечение (общие элементы)
intersection = set1 & set2
print(f"Пересечение: {intersection}")  # {4, 5}

# Разность (в первом, но не во втором)
difference = set1 - set2
print(f"Разность: {difference}")  # {1, 2, 3}

# Симметричная разность (в одном из множеств, но не в обоих)
sym_diff = set1 ^ set2
print(f"Симметричная разность: {sym_diff}")  # {1, 2, 3, 6, 7, 8}

# Добавление и удаление
set1.add(10)           # Добавить элемент
set1.remove(1)         # Удалить элемент (ошибка если нет)
set1.discard(100)      # Удалить элемент (без ошибки)

Работа со словарями:

# Создание словаря
grades = {
    "Анна": 5,
    "Иван": 4,
    "Мария": 5,
    "Петр": 3
}

# Доступ к элементам
print(grades["Анна"])           # 5
print(grades.get("Олег", 0))    # 0 (значение по умолчанию)

# Изменение и добавление
grades["Иван"] = 5              # Изменить
grades["Олег"] = 4              # Добавить

# Удаление
del grades["Петр"]              # Удалить по ключу
score = grades.pop("Олег")      # Удалить и получить значение

# Проверка наличия ключа
if "Анна" in grades:
    print("Анна в списке")

# Перебор словаря
for name, grade in grades.items():
    print(f"{name}: {grade}")

# Ключи и значения
names = list(grades.keys())     # Список ключей
scores = list(grades.values())  # Список значений

Полезные трюки:

# Удаление дубликатов из списка
numbers = [1, 2, 2, 3, 3, 3, 4, 5, 5]
unique = list(set(numbers))
print(unique)  # [1, 2, 3, 4, 5]

# Объединение списков
list1 = [1, 2, 3]
list2 = [4, 5, 6]
combined = list1 + list2      # [1, 2, 3, 4, 5, 6]

# Повторение списка
repeated = [1, 2] * 3         # [1, 2, 1, 2, 1, 2]

# Проверка на пустоту
if numbers:
    print("Список не пустой")

# Копирование
original = [1, 2, 3]
copy = original[:]            # Копия списка
copy = list(original)         # Другой способ

# List comprehension (генератор списков)
squares = [x**2 for x in range(10)]
even = [x for x in range(20) if x % 2 == 0]

Enumerate и zip:

# enumerate - индексы и значения
fruits = ["яблоко", "банан", "апельсин"]
for i, fruit in enumerate(fruits, start=1):
    print(f"{i}. {fruit}")

# zip - объединение списков
names = ["Анна", "Иван", "Мария"]
ages = [15, 16, 15]
for name, age in zip(names, ages):
    print(f"{name}: {age} лет")

# Создание словаря из двух списков
students = dict(zip(names, ages))
print(students)  # {'Анна': 15, 'Иван': 16, 'Мария': 15}

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

def analyze_votes(votes):
    """
    Анализирует результаты голосования
    votes - список кортежей (имя_голосующего, за_кого_голос)
    """
    # Извлекаем кандидатов и голосующих
    voters = [voter for voter, _ in votes]
    candidates = [candidate for _, candidate in votes]
    
    # Подсчет голосов
    vote_counts = {}
    for candidate in candidates:
        vote_counts[candidate] = vote_counts.get(candidate, 0) + 1
    
    # Сортировка по количеству голосов
    sorted_results = sorted(vote_counts.items(), 
                           key=lambda x: x[1], 
                           reverse=True)
    
    # Статистика
    total_votes = len(votes)
    unique_voters = len(set(voters))
    winner = sorted_results[0][0] if sorted_results else None
    
    # Вывод результатов
    print("=" * 50)
    print("РЕЗУЛЬТАТЫ ГОЛОСОВАНИЯ")
    print("=" * 50)
    
    for candidate, count in sorted_results:
        percentage = (count / total_votes) * 100
        print(f"{candidate:<20} {count:>5} голосов ({percentage:>5.1f}%)")
    
    print("=" * 50)
    print(f"Всего голосов: {total_votes}")
    print(f"Проголосовало: {unique_voters} человек")
    print(f"Победитель: {winner}")
    print("=" * 50)
    
    return vote_counts, winner

# Пример использования
votes = [
    ("Иван", "Кандидат А"),
    ("Мария", "Кандидат Б"),
    ("Петр", "Кандидат А"),
    ("Анна", "Кандидат А"),
    ("Олег", "Кандидат В"),
    ("Света", "Кандидат Б"),
    ("Дима", "Кандидат А"),
    ("Катя", "Кандидат Б"),
]

results, winner = analyze_votes(votes)

# Вывод:
# ==================================================
# РЕЗУЛЬТАТЫ ГОЛОСОВАНИЯ
# ==================================================
# Кандидат А                4 голосов ( 50.0%)
# Кандидат Б                3 голосов ( 37.5%)
# Кандидат В                1 голосов ( 12.5%)
# ==================================================
# Всего голосов: 8
# Проголосовало: 8 человек
# Победитель: Кандидат А
# ==================================================

📚 О курсе

🗂️ Быстрая навигация по темам

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

📖 Теоретическая база

Особенности строк:

💡 Практические примеры

Работа с целыми числами:

Числа с плавающей точкой:

Логические значения:

Строки:

🎯 Методические рекомендации

2 Контейнерные типы данных

📖 Теоретическая база

Особенности типов:

💡 Практические примеры

Списки (list):

Кортежи (tuple):

Словари (dict):

Множества (set):

3 Переменные и присваивание

📖 Теоретическая база

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

Типы присваивания:

💡 Практические примеры

Правильные имена переменных:

Неправильные имена:

Множественное присваивание:

Присваивание с операциями:

🎯 Методические рекомендации

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

📖 Теоретическая база

💡 Практические примеры

Преобразование строк в числа:

Преобразование чисел в строки:

Преобразование в логический тип:

Работа со списками и множествами:

5 Доступ к элементам последовательностей

📖 Теоретическая база

Индексация:

Срезы (slicing):

💡 Практические примеры

Доступ по индексу:

Срезы последовательностей:

Работа со строками:

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

🎯 Методические рекомендации

6 Условный оператор (if-elif-else)

📖 Теоретическая база

Структура условного оператора:

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

💡 Практические примеры

Простое условие:

Множественные условия:

Вложенные условия:

Проверка нескольких условий:

7 Циклы: while и for

📖 Теоретическая база

Цикл while (с условием):

Цикл for (цикл перебора):

Функция range():

Управление циклом:

💡 Практические примеры

Цикл while:

Цикл for по элементам:

Цикл for с range():

Проход по индексам:

Enumerate (индексы + значения):

Break и continue:

8 Математические операции

📖 Теоретическая база

Базовые операторы:

Полезные функции:

Модуль math:

💡 Практические примеры

Базовые операции:

Работа с модулем и округлением:

Тригонометрия и логарифмы:

Проверка четности и деление:

9 Булева логика и логические операции

📖 Теоретическая база