Занятие 1. Ввод и вывод данных

Типы данных в Python

Введение в типы данных в программировании

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

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

Тип данных int в Python

Что такое int?

int (integer) — это тип данных для хранения целых чисел. Целые числа — это числа без дробной части: ..., -3, -2, -1, 0, 1, 2, 3, ...

В Python числа типа int могут быть сколь угодно большими (ограничены только объемом памяти компьютера)

Создание переменных типа int

# Создание целых чисел
возраст = 25
температура = -10
количество_яблок = 0
большое_число = 123456789012345678901234567890
print(возраст)           # Выведет: 25
print(температура)       # Выведет: -10
print(количество_яблок)  # Выведет: 0
print(большое_число)     # Выведет: 123456789012345678901234567890

Операции с int

# Арифметические операции
a = 10
b = 3
сложение = a + b         # 13
вычитание = a - b        # 7
умножение = a * b        # 30
деление_нацело = a // b  # 3 (целая часть от деления)
остаток = a % b          # 1 (остаток от деления)
степень = a ** b         # 1000 (10 в степени 3)
print(f"Сложение: {сложение}")
print(f"Вычитание: {вычитание}")
print(f"Умножение: {умножение}")
print(f"Деление нацело: {деление_нацело}")
print(f"Остаток от деления: {остаток}")
print(f"Возведение в степень: {степень}")

Тип данных float в Python

Что такое float?

float (floating point number) — это тип данных для хранения чисел с плавающей точкой (дробных чисел). Эти числа содержат дробную часть: 3.14, -0.5, 2.0, 1.23e-4.

Создание переменных типа float

# Создание чисел с плавающей точкой
цена = 19.99
температура = -5.5
пи = 3.14159
научная_запись = 1.5e3  # 1.5 * 10^3 = 1500.0
print(цена)           # Выведет: 19.99
print(температура)    # Выведет: -5.5
print(пи)             # Выведет: 3.14159
print(научная_запись) # Выведет: 1500.0

Особенности работы с float

# Преобразование int в float
целое_число = 5
дробное_число = float(целое_число)  # 5.0
print(f"Целое: {целое_число}, тип: {type(целое_число)}")
print(f"Дробное: {дробное_число}, тип: {type(дробное_число)}")
# Операции с float
a = 7.5
b = 2.3
результат_сложения = a + b                 # 9.8
результат_деления = a / b                  # 3.2608695652173911
округленный_результат = round(a / b, 2)    # 3.26
print(f"Сложение: {результат_сложения}")
print(f"Деление: {результат_деления}")
print(f"Округленное деление: {округленный_результат}")

Тип данных str в Python

Что такое str?

str (string) — это тип данных для хранения текстовой информации (строк). Строка — это последовательность символов, заключенная в кавычки.

Создание строк

# Различные способы создания строк
имя = "Анна"
фамилия = 'Иванова'
многострочный_текст = """Это текст,
который занимает
несколько строк"""
# Пустая строка
пустая_строка = ""
print(имя)                    # Выведет: Анна
print(фамилия)                # Выведет: Иванова
print(многострочный_текст)
print(f"Пустая строка: '{пустая_строка}'")

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

# Конкатенация (сложение строк)
имя = "Петр"
фамилия = "Петров"
полное_имя = имя + " " + фамилия
print(полное_имя)  # Выведет: Петр Петров
# Повторение строки
смех = "ха" * 3
print(смех)  # Выведет: хахаха
# Длина строки
текст = "Привет, мир!"
длина = len(текст)
print(f"Длина строки '{текст}': {длина}")  # Выведет: Длина строки 'Привет, мир!': 12
# Обращение к символам строки
первый_символ = текст[0]      # 'П'
последний_символ = текст[-1]  # '!'
print(f"Первый символ: {первый_символ}")
print(f"Последний символ: {последний_символ}")

Тип данных bool в Python

Что такое bool?

bool (boolean) — это тип данных для хранения логических значений. В Python есть только два булевых значения: True (истина) и False (ложь). Этот тип данных особенно важен для условных операторов и циклов

Создание булевых значений

# Прямое создание булевых значений
правда = True
ложь = False
print(правда)  # Выведет: True
print(ложь)    # Выведет: False
# Проверка типа
print(type(правда))  # Выведет: <class 'bool'<
print(type(ложь))    # Выведет: <class 'bool'<

Логические операции

# Логические операторы
a = True
b = False
# Логическое И (and)
результат_and = a and b  # False
print(f"True and False = {результат_and}")
# Логическое ИЛИ (or)
результат_or = a or b    # True
print(f"True or False = {результат_or}")
# Логическое НЕ (not)
результат_not_a = not a  # False
результат_not_b = not b  # True
print(f"not True = {результат_not_a}")
print(f"not False = {результат_not_b}")

Операции сравнения

# Операции сравнения всегда возвращают bool
число1 = 10
число2 = 20
равно = число1 == число2              # False
не_равно = число1 != число2           # True
больше = число1 > число2              # False
меньше = число1 < число2              # True
больше_или_равно = число1 >= число2   # False
меньше_или_равно = число1 <= число2   # True
print(f"10 == 20: {равно}")
print(f"10 != 20: {не_равно}")
print(f"10 > 20: {больше}")
print(f"10 < 20: {меньше}")
print(f"10 >= 20: {больше_или_равно}")
print(f"10 <= 20: {меньше_или_равно}")

Отличия типов данных в Python

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

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

Сравнительная таблица типов данных

Примечание: Указанный вес является примерным для 64-битных систем. Размер целых чисел (int) и строк (str) не фиксирован и растет по мере увеличения их значения или длины.

Автоматическое определение типа

# Python автоматически определяет тип данных
переменная1 = 42          # int
переменная2 = 3.14        # float
переменная3 = "Привет"    # str
переменная4 = True        # bool
print(f"Тип {переменная1}: {type(переменная1)}")
print(f"Тип {переменная2}: {type(переменная2)}")
print(f"Тип {переменная3}: {type(переменная3)}")
print(f"Тип {переменная4}: {type(переменная4)}")

Особенности операций с разными типами

# Смешанные операции
целое = 10
дробное = 3.5
результат = целое + дробное  # int + float = float
print(f"10 + 3.5 = {результат}, тип: {type(результат)}")
# Деление всегда возвращает float
результат_деления = 10 / 2  # Результат будет 5.0, а не 5
print(f"10 / 2 = {результат_деления}, тип: {type(результат_деления)}")
# Целочисленное деление
результат_целочисленного = 10 // 3  # Результат будет 3
print(f"10 // 3 = {результат_целочисленного}, тип: {type(результат_целочисленного)}")

Важные моменты при работе с типами данных

• Неизменяемость: Все рассмотренные типы данных (int, float, str, bool) являются неизменяемыми. Это означает, что вы не можете изменить существующий объект, но можете создать новый
• Автоматическое преобразование: Python автоматически преобразует типы в некоторых операциях (например, int + float = float).
• Проверка типов: Используйте функцию type() для определения типа переменной или isinstance() для проверки принадлежности к определенному типу.
• Осторожность с преобразованиями: Не все преобразования возможны (например, int("abc") вызовет ошибку).

2. Переменные Python

Введение в переменные в программировании

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

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

Объявление переменных

Что такое объявление переменной?

Объявление переменной - это процесс создания переменной и присвоения ей значения. В Python переменная создается в момент первого присвоения значения. Не нужно заранее указывать тип данных - Python определит его автоматически.

Синтаксис объявления переменных

# Базовый синтаксис: имя_переменной = значение
имя = "Иван"
возраст = 25
рост = 1.75
студент = True
print(имя)      # Выведет: Иван
print(возраст)  # Выведет: 25
print(рост)     # Выведет: 1.75
print(студент)  # Выведет: True

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

# Присваивание нескольких значений одновременно
x, y, z = 1, 2, 3
print(f"x = {x}, y = {y}, z = {z}")  # Выведет: x = 1, y = 2, z = 3
# Присваивание одного значения нескольким переменным
a = b = c = 10
print(f"a = {a}, b = {b}, c = {c}")  # Выведет: a = 10, b = 10, c = 10
# Обмен значениями переменных
первое_число = 100
второе_число = 200
print(f"До обмена: первое = {первое_число}, второе = {второе_число}")
# Обмен значениями (элегантный способ в Python)
первое_число, второе_число = второе_число, первое_число
print(f"После обмена: первое = {первое_число}, второе = {второе_число}")

Переопределение переменных

# Переменные можно переопределять
счетчик = 0
print(f"Начальное значение: {счетчик}")
счетчик = 5
print(f"Новое значение: {счетчик}")
счетчик = счетчик + 1  # Увеличиваем на 1
print(f"Увеличенное значение: {счетчик}")
# Сокращенная запись для арифметических операций
счетчик += 10  # Эквивалентно: счетчик = счетчик + 10
print(f"После добавления 10: {счетчик}")
счетчик *= 2   # Эквивалентно: счетчик = счетчик * 2
print(f"После умножения на 2: {счетчик}")

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

Основные правила именования переменных в программировании

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

Обязательные правила

# ПРАВИЛЬНЫЕ имена переменных:
имя = "Петр"
age = 25
user_name = "ivan_petrov"
количество_товаров = 10
price2 = 100.0
_private_var = "секретное значение"
# НЕПРАВИЛЬНЫЕ имена переменных (вызовут ошибку):
# 2price = 100.0        # Нельзя начинать с цифры
# user-name = "ivan"    # Нельзя использовать дефис
# class = "математика"  # Нельзя использовать зарезервированные слова
# user name = "ivan"    # Нельзя использовать пробелы

Зарезервированные слова

Это зарезервированные слова Python, их нельзя использовать как имена переменных

import keyword
зарезервированные_слова = keyword.kwlist
print("Зарезервированные слова Python:")
for слово in зарезервированные_слова:
    print(слово)
# Примеры того, чего делать НЕЛЬЗЯ:
# if = 5        # Ошибка!
# for = "text"  # Ошибка!
# def = 10      # Ошибка!
# Правильные альтернативы:
условие = 5
цикл = "text"
определение = 10

Соглашения по стилю (PEP 8)

# Используйте snake_case для переменных (слова разделяются подчеркиванием)
имя_пользователя = "Анна"
максимальная_скорость = 120
количество_попыток = 3
# Используйте описательные имена
# ПЛОХО:
x = 3.14159
n = "Иван"
d = 1000
# ХОРОШО:
число_пи = 3.14159
имя_студента = "Иван"
дневная_зарплата = 1000
# Константы пишите ЗАГЛАВНЫМИ_БУКВАМИ
МАКСИМАЛЬНАЯ_СКОРОСТЬ = 120
КОЛИЧЕСТВО_СЕКУНД_В_МИНУТЕ = 60
НАЗВАНИЕ_КОМПАНИИ = "ТехноСофт"
# Избегайте однобуквенных имен (кроме счетчиков в коротких циклах)
# ПЛОХО:
a = 100
b = 200
c = a + b
# ХОРОШО:
цена_товара = 100
количество = 200
общая_стоимость = цена_товара + количество

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

Что такое динамическая типизация?

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

Отличие от статической типизации

# В Python (динамическая типизация):
переменная = 42        # Сейчас это int
print(f"Значение: {переменная}, тип: {type(переменная)}")
переменная = "Привет"  # Теперь это str
print(f"Значение: {переменная}, тип: {type(переменная)}")
переменная = 3.14      # Теперь это float
print(f"Значение: {переменная}, тип: {type(переменная)}")
переменная = True      # Теперь это bool
print(f"Значение: {переменная}, тип: {type(переменная)}")
# В языках со статической типизацией (например, C++, Java)
# нужно заранее объявить тип:
# int переменная = 42;        // Всегда будет int
# string другая = "Привет";   // Всегда будет string

Преимущества динамической типизации

# Гибкость в использовании
def обработать_данные(данные):
    """Функция может работать с разными типами данных"""
    if isinstance(данные, int):
        return данные * 2
    elif isinstance(данные, str):
        return данные.upper()
    elif isinstance(данные, list):
        return len(данные)
    else:
        return f"Неизвестный тип: {type(данные)}"
# Тестируем с разными типами
результат1 = обработать_данные(10)           # int
результат2 = обработать_данные("привет")     # str
результат3 = обработать_данные([1, 2, 3])    # list
print(f"Результат 1: {результат1}")  # Выведет: 20
print(f"Результат 2: {результат2}")  # Выведет: ПРИВЕТ
print(f"Результат 3: {результат3}")  # Выведет: 3

Потенциальные проблемы

Проблема 1: Неожиданное изменение типа

счетчик = 0
print(f"Начальное значение: {счетчик}, тип: {type(счетчик)}")
# Где-то в коде...
счетчик = "ноль"  # Случайно присвоили строку
print(f"Новое значение: {счетчик}, тип: {type(счетчик)}")
# Попытка математической операции вызовет ошибку
try:
    счетчик += 1
except TypeError as e:
    print(f"Ошибка: {e}")

Проблема 2: Неявное преобразование типов

число1 = 10
число2 = "20"
# Это вызовет ошибку
try:
    результат = число1 + число2
except TypeError as e:
    print(f"Ошибка сложения: {e}")
# Правильный способ
результат = число1 + int(число2)
print(f"Правильный результат: {результат}")

Функция определения типа

Основные функции для работы с типами

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

Функция type()

# Функция type() возвращает точный тип объекта
число = 42
дробь = 3.14
строка = "Привет"
логическое = True
список = [1, 2, 3]
print(f"type(42): {type(число)}")
print(f"type(3.14): {type(дробь)}")
print(f"type('Привет'): {type(строка)}")
print(f"type(True): {type(логическое)}")
print(f"type([1, 2, 3]): {type(список)}")
# Получение имени типа как строки
print(f"Имя типа: {type(число).__name__}")
print(f"Имя типа: {type(строка).__name__}")

Функция isinstance()

# isinstance() проверяет, является ли объект экземпляром определенного типа
переменная = 100
# Проверка одного типа
print(f"isinstance(100, int): {isinstance(переменная, int)}")
print(f"isinstance(100, str): {isinstance(переменная, str)}")
# Проверка нескольких типов одновременно
print(f"isinstance(100, (int, float)): {isinstance(переменная, (int, float))}")
# Практическое использование
def безопасное_деление(a, b):
    """Безопасное деление с проверкой типов"""
    if not isinstance(a, (int, float)) or not isinstance(b, (int, float)):
        return "Ошибка: оба аргумента должны быть числами"
    if b == 0:
        return "Ошибка: деление на ноль"
    return a / b
# Тестируем функцию
print(безопасное_деление(10, 2))      # 5.0
print(безопасное_деление(10, 0))      # Ошибка: деление на ноль
print(безопасное_деление(10, "2"))    # Ошибка: оба аргумента должны быть числами

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

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

Введение в преобразования типов в программировании

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

В Python существует два вида преобразований:

• Явное преобразование (explicit conversion) - когда программист сам указывает, во что нужно преобразовать данные
• Неявное преобразование (implicit conversion) - когда Python автоматически преобразует типы при выполнении операций

Явное преобразование

Что такое явное преобразование?

Явное преобразование - это когда мы сами указываем Python, в какой тип нужно преобразовать данные, используя специальные функции: int(), float(), str(), bool().

При явном преобразовании мы используем функции: int(), float(), str(), bool()

Преобразование целого числа в дробь, строку или логический тип данных

Преобразование int в float

# Преобразование целого числа в дробное
число = 5
дробь = float(число)
print(f"Целое число: {число}")           # 5
print(f"Дробное число: {дробь}")         # 5.0
print(f"Тип: {type(дробь)}")             # <class 'float'>

Преобразование int в str

# Преобразование целого числа в строку
возраст = 25
возраст_строка = str(возраст)
print(f"Число: {возраст}")               # 25
print(f"Строка: '{возраст_строка}'")     # '25'
print(f"Тип: {type(возраст_строка)}")    # <class 'str'>

# Использование в тексте
сообщение = "Мне " + str(возраст) + " лет"
print(сообщение)                         # Мне 25 лет

Преобразование int в bool

# Преобразование целого числа в логическое значение
print(f"bool(0) = {bool(0)}")            # False
print(f"bool(1) = {bool(1)}")            # True
print(f"bool(-5) = {bool(-5)}")          # True
print(f"bool(100) = {bool(100)}")        # True
# Правило: 0 = False, любое другое число = True

Преобразование переменных типа float в int, str, bool

Преобразование float в int

# Преобразование дробного числа в целое
цена = 99.99
цена_целая = int(цена)
print(f"Дробь: {цена}")                  # 99.99
print(f"Целое: {цена_целая}")            # 99
# Внимание! Дробная часть просто отбрасывается
print(f"int(3.7) = {int(3.7)}")         # 3
print(f"int(-2.9) = {int(-2.9)}")       # -2

Преобразование float в str

# Преобразование дробного числа в строку
температура = 36.6
температура_строка = str(температура)
print(f"Число: {температура}")
print(f"Строка: '{температура_строка}'")
print(f"Тип: {type(температура_строка)}")
# Использование в тексте
сообщение = "Температура " + str(температура) + " градусов"
print(сообщение)

Преобразование float в bool

# Преобразование дробного числа в логическое значение
print(f"bool(0.0) = {bool(0.0)}")       # False
print(f"bool(1.5) = {bool(1.5)}")       # True
print(f"bool(-0.1) = {bool(-0.1)}")     # True
# Правило: 0.0 = False, любое другое число = True

Преобразование строки в целые числа, дробные числа и в булевую переменную

Преобразование str в int

# Преобразование строки в целое число
возраст_строка = "25"
возраст = int(возраст_строка)
print(f"Строка: '{возраст_строка}'")
print(f"Число: {возраст}")
print(f"Тип: {type(возраст)}")
# Ошибки преобразования
try:
    число = int("abc")  # Ошибка!
except ValueError:
    print("Ошибка: нельзя преобразовать 'abc' в число")

Преобразование str в float

# Преобразование строки в дробное число
цена_строка = "99.99"
цена = float(цена_строка)
print(f"Строка: '{цена_строка}'")
print(f"Дробь: {цена}")
print(f"Тип: {type(цена)}")

# Можно преобразовать и целые числа
целое_как_строка = "42"
дробь = float(целое_как_строка)
print(f"'{целое_как_строка}' -> {дробь}")  # 42.0

Преобразование str в bool

# Преобразование строки в логическое значение
print(f"bool('') = {bool('')}")          # False (пустая строка)
print(f"bool('привет') = {bool('привет')}")  # True
print(f"bool('0') = {bool('0')}")        # True (строка не пустая!)
print(f"bool('False') = {bool('False')}")    # True

Правило: только пустая строка = False, любая другая = True

Преобразование булевых переменных в строки, дробь и целые числа

Преобразование bool в str

# Преобразование логического значения в строку
активен = True
неактивен = False
print(f"str(True) = '{str(активен)}'")   # 'True'
print(f"str(False) = '{str(неактивен)}'") # 'False'
# Использование в тексте
статус = "Пользователь " + str(активен)
print(статус)  # Пользователь True

Преобразование bool в int

# Преобразование логического значения в целое число
print(f"int(True) = {int(True)}")        # 1
print(f"int(False) = {int(False)}")      # 0
# Практическое применение - подсчет
результаты = [True, False, True, True, False]
правильных = sum(результаты)  # True считается как 1
print(f"Правильных ответов: {правильных}")  # 3

Преобразование bool в float

# Преобразование логического значения в дробное число
print(f"float(True) = {float(True)}")    # 1.0
print(f"float(False) = {float(False)}")  # 0.0

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

Неявное преобразование происходит автоматически, когда Python выполняет операции с разными типами данных.

Арифметические операции

# int + float = float
целое = 10
дробное = 3.5
результат = целое + дробное
print(f"{целое} + {дробное} = {результат}")  # 10 + 3.5 = 13.5
print(f"Тип результата: {type(результат)}")   # <class 'float'>
# Деление всегда дает float
деление = 10 / 2
print(f"10 / 2 = {деление}")                 # 5.0 (не 5!)
print(f"Тип: {type(деление)}")               # <class 'float'>

Операции с bool

# bool участвует в арифметических операциях как число
print(f"True + 5 = {True + 5}")              # 6 (True = 1)
print(f"False * 10 = {False * 10}")          # 0 (False = 0)
print(f"True + False = {True + False}")      # 1 (1 + 0)

Строки и числа

# Строки НЕ преобразуются автоматически!
try:
    результат = "5" + 3  # Ошибка!
except TypeError:
    print("Ошибка: нельзя складывать строку и число")
# Правильный способ
число_строка = "5"
число = 3
результат = int(число_строка) + число  # Сначала преобразуем
print(f"Правильно: {результат}")  # 8

Сравнения

# Сравнение разных числовых типов
print(f"5 == 5.0: {5 == 5.0}")              # True
print(f"1 == True: {1 == True}")            # True
print(f"0 == False: {0 == False}")          # True
# Но типы разные!
print(f"type(5): {type(5)}")                # <class 'int'>
print(f"type(5.0): {type(5.0)}")            # <class 'float'>

Важные правила

1. int + float = float — при операциях с целыми и дробными числами результат всегда дробный
2. Деление всегда дает float — даже если числа нацело делятся
3. bool = число — True = 1, False = 0 в арифметических операциях
4. Строки НЕ преобразуются автоматически — нужно делать это явно
5. Сравнения работают между числовыми типами — но типы остаются разными

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

Существующие математические операции

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

Базовые арифметические операции в Python

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

Python поддерживает пять основных арифметических операций:

Сложение ( + )

# Сложение чисел
a = 10
b = 5
результат = a + b
print(f"{a} + {b} = {результат}")  # 10 + 5 = 15
# Сложение с разными типами
целое = 7
дробное = 2.5
сумма = целое + дробное
print(f"{целое} + {дробное} = {сумма}")  # 7 + 2.5 = 9.5

Вычитание ( - )

# Вычитание чисел
a = 20
b = 8
разность = a - b
print(f"{a} - {b} = {разность}")  # 20 - 8 = 12
# Отрицательные числа
результат = 5 - 10
print(f"5 - 10 = {результат}")  # 5 - 10 = -5

Умножение ( * )

# Умножение чисел
a = 6
b = 7
произведение = a * b
print(f"{a} * {b} = {произведение}")  # 6 * 7 = 42
# Умножение с дробными числами
цена = 15.5
количество = 3
общая_стоимость = цена * количество
print(f"Цена {цена} * {количество} = {общая_стоимость}")  # 46.5

Деление ( / )

# Обычное деление
a = 15
b = 3
частное = a / b
print(f"{a} / {b} = {частное}")  # 15 / 3 = 5.0
# Деление всегда дает float
результат = 10 / 2
print(f"10 / 2 = {результат}")  # 10 / 2 = 5.0 (не 5!)
print(f"Тип: {type(результат)}")  # <class 'float'>
# Деление с остатком
print(f"7 / 2 = {7 / 2}")  # 7 / 2 = 3.5

Специальные операторы в питоне

Введение в специальные операторы

Кроме основных операций, Python имеет три специальных оператора для работы с числами.

// целочисленное деление

Что такое целочисленное деление?

Целочисленное деление (//) — это деление, которое возвращает только целую часть результата, отбрасывая дробную часть.

# Целочисленное деление
print(f"7 // 2 = {7 // 2}")    # 7 // 2 = 3
print(f"15 // 4 = {15 // 4}")  # 15 // 4 = 3
print(f"20 // 6 = {20 // 6}")  # 20 // 6 = 3
# Сравнение с обычным делением
print(f"7 / 2 = {7 / 2}")      # 7 / 2 = 3.5
print(f"7 // 2 = {7 // 2}")    # 7 // 2 = 3

Работа с отрицательными числами

# Целочисленное деление с отрицательными числами
print(f"-7 // 2 = {-7 // 2}")   # -7 // 2 = -4
print(f"7 // -2 = {7 // -2}")   # 7 // -2 = -4
print(f"-7 // -2 = {-7 // -2}") # -7 // -2 = 3
# Округление идет к меньшему целому числу
print(f"-7 / 2 = {-7 / 2}")     # -7 / 2 = -3.5
print(f"-7 // 2 = {-7 // 2}")   # -7 // 2 = -4

% остаток от деления

Что такое остаток от деления?

Остаток от деления (%) — это то, что остается после целочисленного деления.

# Остаток от деления
print(f"7 % 2 = {7 % 2}")      # 7 % 2 = 1
print(f"15 % 4 = {15 % 4}")    # 15 % 4 = 3
print(f"20 % 6 = {20 % 6}")    # 20 % 6 = 2
# Если число делится нацело, остаток равен 0
print(f"10 % 5 = {10 % 5}")    # 10 % 5 = 0
print(f"8 % 2 = {8 % 2}")      # 8 % 2 = 0

Связь с целочисленным делением

# Проверим связь // и %
число = 17
делитель = 5
частное = число // делитель
остаток = число % делитель
print(f"{число} = {делитель} * {частное} + {остаток}")
print(f"17 = 5 * 3 + 2")  # Проверка: 5 * 3 + 2 = 17

** возведение в степень в Python

Что такое возведение в степень?

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

# Возведение в степень
print(f"2 ** 3 = {2 ** 3}")    # 2 ** 3 = 8 (2 * 2 * 2)
print(f"5 ** 2 = {5 ** 2}")    # 5 ** 2 = 25 (5 * 5)
print(f"10 ** 4 = {10 ** 4}")  # 10 ** 4 = 10000
# Степень может быть дробной
print(f"9 ** 0.5 = {9 ** 0.5}")  # 9 ** 0.5 = 3.0 (квадратный корень)
print(f"8 ** (1/3) = {8 ** (1/3)}")  # 8 ** (1/3) = 2.0 (кубический корень)

Особые случаи

# Возведение в степень 0
print(f"5 ** 0 = {5 ** 0}")     # 5 ** 0 = 1
print(f"100 ** 0 = {100 ** 0}") # 100 ** 0 = 1
# Возведение в степень 1
print(f"7 ** 1 = {7 ** 1}")     # 7 ** 1 = 7
# Отрицательные степени
print(f"2 ** -3 = {2 ** -3}")   # 2 ** -3 = 0.125 (1/8)
print(f"10 ** -2 = {10 ** -2}") # 10 ** -2 = 0.01 (1/100)

Приоритет арифметических операций в питоне

Порядок выполнения операций в программировании

Python выполняет математические операции в определенном порядке, как в обычной математике:

1. Скобки () — самый высокий приоритет
2. ** Возведение в степень
3. * Умножение, деление /, целочисленное деление //, остаток %
4. + Сложение, - Вычитание — самый низкий приоритет

Примеры приоритета

# Без скобок
результат1 = 2 + 3 * 4
print(f"2 + 3 * 4 = {результат1}")  # 2 + 3 * 4 = 14 (не 20!)
# Со скобками
результат2 = (2 + 3) * 4
print(f"(2 + 3) * 4 = {результат2}")  # (2 + 3) * 4 = 20
# Степень выполняется первой
результат3 = 2 + 3 ** 2
print(f"2 + 3 ** 2 = {результат3}")  # 2 + 3 ** 2 = 11 (не 25!)
# Со скобками
результат4 = (2 + 3) ** 2
print(f"(2 + 3) ** 2 = {результат4}")  # (2 + 3) ** 2 = 25

Операции одинакового приоритета

# Умножение и деление выполняются слева направо
результат1 = 12 / 3 * 2
print(f"12 / 3 * 2 = {результат1}")  # 12 / 3 * 2 = 8.0
# Это равно: (12 / 3) * 2 = 4 * 2 = 8
# А НЕ: 12 / (3 * 2) = 12 / 6 = 2
# Сложение и вычитание тоже слева направо
результат2 = 10 - 3 + 2
print(f"10 - 3 + 2 = {результат2}")  # 10 - 3 + 2 = 9

Сложные примеры

# Сложное выражение
выражение = 2 + 3 * 4 ** 2 - 5 / 2
print(f"2 + 3 * 4 ** 2 - 5 / 2 = {выражение}")
# Разберем по шагам:
# 1. 4 ** 2 = 16
# 2. 3 * 16 = 48
# 3. 5 / 2 = 2.5
# 4. 2 + 48 = 50
# 5. 50 - 2.5 = 47.5
# Проверим по шагам
шаг1 = 4 ** 2       # 16
шаг2 = 3 * шаг1      # 48
шаг3 = 5 / 2         # 2.5
шаг4 = 2 + шаг2      # 50
шаг5 = шаг4 - шаг3   # 47.5
print(f"Результат по шагам: {шаг5}")

Советы для запоминания

1. Всегда используйте скобки для ясности, даже если они не нужны
2. Помните аббревиатуру: скобки → степень → умножение/деление
3. При сомнении — добавьте скобки
4. Разбивайте сложные выражения на простые части

# Хорошая практика - использование скобок для ясности
сложное_выражение = ((2 + 3) * 4) - (5 / 2)
print(f"Ясное выражение: {сложное_выражение}")
# Разбивка на части
часть1 = (2 + 3) * 4
часть2 = 5 / 2
результат = часть1 - часть2
print(f"По частям: {результат}")

Функция вывода и форматирование данных в Python print

функция вывода print

Функция print() - это основной способ вывода информации на экран в Python. Она позволяет показать результаты работы программы пользователю.

Функция вывода print

Базовое использование

# Простой вывод
print("Привет, мир!")
# Вывод переменных
имя = "Анна"
возраст = 25
print(имя)
print(возраст)

Вывод нескольких значений

Вывод нескольких элементов сразу

# Вывод нескольких значений через запятую
имя = "Петр"
возраст = 30
город = "Москва"
print(имя, возраст, город)
# Выведет: Петр 30 Москва
# Вывод разных типов данных
число = 42
дробь = 3.14
логическое = True
print(число, дробь, логическое)
# Выведет: 42 3.14 True

Смешивание текста и переменных

# Комбинирование текста и переменных
имя = "Мария"
возраст = 22
print("Имя:", имя, "Возраст:", возраст)
# Выведет: Имя: Мария Возраст: 22

# Вывод результатов вычислений
a = 10
b = 5
print("Сумма:", a, "+", b, "=", a + b)
# Выведет: Сумма: 10 + 5 = 15

Параметры sep и end

Параметр sep (разделитель)

sep — это параметр, который определяет, что печатается между элементами.

# По умолчанию разделитель - пробел
print("a", "b", "c")
# Выведет: a b c

# Изменяем разделитель на запятую
print("a", "b", "c", sep=",")
# Выведет: a,b,c

# Разделитель - дефис
print("a", "b", "c", sep="-")
# Выведет: a-b-c

# Разделитель - пустая строка
print("a", "b", "c", sep="")
# Выведет: abc

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

# Создание CSV-строки
имя = "Иван"
фамилия = "Петров"
возраст = 28
print(имя, фамилия, возраст, sep=",")
# Выведет: Иван,Петров,28

# Создание пути к файлу
папка = "документы"
подпапка = "проекты"
файл = "отчет.txt"
print(папка, подпапка, файл, sep="/")
# Выведет: документы/проекты/отчет.txt

Параметр end (окончание)

end — это параметр, который определяет, что печатается в конце строки.

# По умолчанию в конце - перевод строки
print("Первая строка")
print("Вторая строка")
# Выведет:
# Первая строка
# Вторая строка

# Изменяем окончание на пробел
print("Первая строка", end=" ")
print("Вторая строка")
# Выведет: Первая строка Вторая строка

# Окончание - точка
print("Предложение", end=".")
print(" Следующее предложение")
# Выведет: Предложение. Следующее предложение

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

# Создание строки без переносов
print("Загрузка", end="")
print(".", end="")
print(".", end="")
print(".", end="")
print(" Готово!")
# Выведет: Загрузка... Готово!

# Вывод чисел в одну строку
числа = [1, 2, 3, 4, 5]
for число in числа:
    print(число, end=" ")
print()  # Перенос строки в конце
# Выведет: 1 2 3 4 5

Комбинирование sep и end

# Используем оба параметра
print("a", "b", "c", sep="-", end="!\n")
# Выведет: a-b-c!

# Создание таблицы
print("Имя", "Возраст", "Город", sep=" | ", end="\n")
print("Анна", "25", "Москва", sep=" | ", end="\n")
print("Петр", "30", "СПб", sep=" | ", end="\n")
# Выведет:
# Имя | Возраст | Город
# Анна | 25 | Москва
# Петр | 30 | СПб

Форматированный вывод данных в Python

Введение в форматирование

Форматирование — это способ красиво и точно представить данные в тексте. В Python есть три основных способа форматирования.

f-строки в Python

Что такое f-строки?

f-строки (f-strings) — это современный и удобный способ форматирования строк в Python. Они начинаются с буквы f перед кавычками.

# Основное использование f-строк
имя = "Алексей"
возраст = 27
# Вставляем переменные в фигурные скобки
сообщение = f"Меня зовут {имя}, мне {возраст} лет"
print(сообщение)
# Выведет: Меня зовут Алексей, мне 27 лет

Вычисления в f-строках

# Можно выполнять вычисления прямо в строке
a = 10
b = 5
print(f"{a} + {b} = {a + b}")
# Выведет: 10 + 5 = 15
print(f"{a} * {b} = {a * b}")
# Выведет: 10 * 5 = 50

# Работа с более сложными выражениями
цена = 100
количество = 3
скидка = 0.1
print(f"Общая стоимость: {цена * количество * (1 - скидка)}")
# Выведет: Общая стоимость: 270.0

Форматирование чисел

# Округление дробных чисел
число = 3.14159
print(f"Число: {число:.2f}")  # 2 знака после запятой
# Выведет: Число: 3.14
print(f"Число: {число:.0f}")  # Без дробной части
# Выведет: Число: 3

# Форматирование больших чисел
большое_число = 1234567
print(f"Число: {большое_число:,}")  # С разделителями
# Выведет: Число: 1,234,567

Простые примеры f-строк

# Информация о студенте
имя = "Елена"
группа = "ИТ-21"
средний_балл = 4.75
print(f"Студент: {имя}")
print(f"Группа: {группа}")
print(f"Средний балл: {средний_балл:.1f}")
# Выведет:
# Студент: Елена
# Группа: ИТ-21
# Средний балл: 4.8

Функция format()

Основы format()

format() — это метод строки, который позволяет вставлять значения в определенные места.

# Основное использование format()
имя = "Дмитрий"
возраст = 33
# Фигурные скобки {} — это места для вставки
сообщение = "Меня зовут {}, мне {} лет".format(имя, возраст)
print(сообщение)
# Выведет: Меня зовут Дмитрий, мне 33 лет

Нумерация позиций

# Можно указывать номера позиций
print("Первое: {0}, второе: {1}".format("А", "Б"))
# Выведет: Первое: А, второе: Б

# Можно менять порядок
print("Второе: {1}, первое: {0}".format("А", "Б"))
# Выведет: Второе: Б, первое: А

# Можно повторять
print("{0} + {0} = {1}".format(5, 10))
# Выведет: 5 + 5 = 10

Именованные параметры

# Использование имен вместо позиций
print("Имя: {name}, возраст: {age}".format(name="Ольга", age=29))
# Выведет: Имя: Ольга, возраст: 29

# Можно менять порядок
print("Возраст: {age}, имя: {name}".format(name="Ольга", age=29))
# Выведет: Возраст: 29, имя: Ольга

Форматирование с format()

# Округление чисел
число = 3.14159
print("Число: {:.2f}".format(число))
# Выведет: Число: 3.14
print("Число: {:.0f}".format(число))
# Выведет: Число: 3

# С именованными параметрами
print("Цена: {price:.2f} руб.".format(price=199.99))
# Выведет: Цена: 199.99 руб.

Простые примеры format()

# Информация о покупке
товар = "Молоко"
цена = 55.50
количество = 2
сообщение = "Товар: {}, цена: {:.2f}, количество: {}, итого: {:.2f}".format(
    товар, цена, количество, цена * количество)
print(сообщение)
# Выведет: Товар: Молоко, цена: 55.50, количество: 2, итого: 111.00

% форматирование данных

Основы % форматирования

% форматирование — это старый способ форматирования строк в Python, похожий на язык C.

# Основное использование % форматирования
имя = "Сергей"
возраст = 31
# %s — для строк, %d — для целых чисел
сообщение = "Меня зовут %s, мне %d лет" % (имя, возраст)
print(сообщение)
# Выведет: Меня зовут Сергей, мне 31 лет

Основные спецификаторы

# %s — строка
print("Имя: %s" % "Анна")

# %d — целое число  
print("Возраст: %d" % 25)

# %f — дробное число
print("Цена: %f" % 99.99)

# %% — символ %
print("Скидка: %d%%" % 15)
# Выведет: Скидка: 15%

Форматирование дробных чисел

# Указание количества знаков после запятой
число = 3.14159
print("Число: %.2f" % число)  # 2 знака
# Выведет: Число: 3.14
print("Число: %.0f" % число)  # Без дробной части
# Выведет: Число: 3

# Указание общей ширины
print("Число: %10.2f" % число)  # 10 символов всего, 2 после запятой
# Выведет: Число:       3.14

Простые примеры % форматирования

# Отчет о продажах
продавец = "Иванов"
продаж = 15
выручка = 45000.50
отчет = "Продавец: %s, продаж: %d, выручка: %.2f руб." % (продавец, продаж, выручка)
print(отчет)
# Выведет: Продавец: Иванов, продаж: 15, выручка: 45000.50 руб.

Сравнение всех способов форматирования

# Одна и та же информация тремя способами
имя = "Мария"
возраст = 28
зарплата = 50000.75
# f-строки (современный способ)
print(f"Сотрудник: {имя}, возраст: {возраст}, зарплата: {зарплата:.2f}")
# format() (универсальный способ)
print("Сотрудник: {}, возраст: {}, зарплата: {:.2f}".format(имя, возраст, зарплата))
# % форматирование (старый способ)
print("Сотрудник: %s, возраст: %d, зарплата: %.2f" % (имя, возраст, зарплата))
# Все три выведут одинаково:
# Сотрудник: Мария, возраст: 28, зарплата: 50000.75

Какой способ форматирования выбрать?

1. f-строки — лучший выбор для современного Python (быстрые и читаемые)

2. format() — хорош для сложного форматирования и старых версий Python

3. % форматирование — используется редко, в основном в старом коде

# Рекомендуется использовать f-строки
имя = "Алексей"
возраст = 25
# Хорошо
print(f"Привет, {имя}! Тебе {возраст} лет.")
# Тоже нормально
print("Привет, {}! Тебе {} лет.".format(имя, возраст))
# Старый стиль (не рекомендуется)
print("Привет, %s! Тебе %d лет." % (имя, возраст))

Ввод данных с input() в питоне

Ввод данных в языках программирования

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

Функция ввода input()

Основы работы с input()

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

# Простое использование input()
имя = input()
print("Привет,", имя)
# Если пользователь введет "Анна", выведется:
# Привет, Анна

Что возвращает input()

Важно: input() всегда возвращает строку (str), независимо от того, что ввел пользователь.

# Получаем данные от пользователя
данные = input()
print("Вы ввели:", данные)
print("Тип данных:", type(данные))
# Даже если пользователь введет число 25, получим:
# Вы ввели: 25
# Тип данных: <class 'str'>

Преобразование вводимых данных с помощью функций int, float, bool

Проблема с типами данных

# Проблема: нельзя сразу считать как число
возраст = input()  # Пользователь вводит "25"
через_год = возраст + 1  # Ошибка! Нельзя сложить строку и число
# TypeError: can only concatenate str (not "int") to str

Преобразование в int

# Правильное преобразование в целое число
возраст_строка = input()
возраст = int(возраст_строка)
через_год = возраст + 1
print("Через год вам будет:", через_год)
# Можно делать в одну строку
возраст = int(input())
print("Ваш возраст:", возраст)

Преобразование в float

# Преобразование в дробное число
рост_строка = input()
рост = float(рост_строка)
print("Ваш рост:", рост, "см")
# В одну строку
вес = float(input())
индекс_массы = вес / (рост / 100) ** 2
print("Ваш ИМТ:", индекс_массы)

Преобразование в bool

# Преобразование в логическое значение
ответ = input()  # Пользователь вводит что-то
логическое = bool(ответ)
print("Ваш ответ:", ответ)
print("Как bool:", логическое)
# Помните: только пустая строка даст False
# Любая непустая строка (даже "false") даст True

Умное преобразование в bool

# Более умное преобразование
ответ = input()
ответ_нижний = ответ.lower()
if ответ_нижний in ["да", "yes", "true", "1"]:
    результат = True
elif ответ_нижний in ["нет", "no", "false", "0"]:
    результат = False
else:
    результат = bool(ответ)  # Стандартное преобразование
print("Результат:", результат)

Обработка числового ввода

Проблемы с преобразованием

# Что произойдет, если пользователь введет не число?
try:
    число = int(input())
    print("Вы ввели число:", число)
except ValueError:
    print("Это не число!")

Безопасный ввод числа

# Функция для безопасного ввода целого числа
def получить_целое_число():
    while True:
        try:
            число = int(input())
            return число
        except ValueError:
            print("Ошибка! Введите целое число:")
# Использование
возраст = получить_целое_число()
print("Ваш возраст:", возраст)

Безопасный ввод дробного числа

# Функция для безопасного ввода дробного числа
def получить_дробное_число():
    while True:
        try:
            число = float(input())
            return число
        except ValueError:
            print("Ошибка! Введите число:")
# Использование
рост = получить_дробное_число()
print("Ваш рост:", рост)

Ввод с проверкой диапазона

# Ввод числа в определенном диапазоне
def получить_число_в_диапазоне(минимум, максимум):
    while True:
        try:
            число = int(input())
            if минимум <= число <= максимум:
                return число
            else:
                print(f"Число должно быть от {минимум} до {максимум}")
        except ValueError:
            print("Ошибка! Введите целое число:")
# Использование
print("Введите возраст от 0 до 120:")
возраст = получить_число_в_диапазоне(0, 120)
print("Ваш возраст:", возраст)

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

Параметр prompt

Функция input() может принимать один аргумент - prompt (приглашение для ввода).

# Без приглашения
имя = input()
# С приглашением
имя = input("Введите ваше имя: ")

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

# Примеры с приглашениями
имя = input("Как вас зовут? ")
возраст = input("Сколько вам лет? ")
город = input("Где вы живете? ")
print("Привет,", имя)
print("Вам", возраст, "лет")
print("Вы из города", город)

Красивые приглашения

# Красивое оформление приглашений
print("=== РЕГИСТРАЦИЯ ===")
имя = input("Введите ваше имя: ")
фамилия = input("Введите вашу фамилию: ")
email = input("Введите ваш email: ")
print(f"\nДобро пожаловать, {имя} {фамилия}!")
print(f"Ваш email: {email}")

Многострочные приглашения

# Длинные приглашения
приглашение = """Добро пожаловать в программу!
Введите ваше имя: """
имя = input(приглашение)
print(f"Привет, {имя}!")

Приглашения с форматированием

# Приглашения с дополнительной информацией
товар = "Хлеб"
цена = 25.50
количество = int(input(f"Сколько купить '{товар}' по {цена} руб.? "))
общая_стоимость = цена * количество
print(f"Общая стоимость: {общая_стоимость} руб.")

Советы по использованию input()

• 1. Всегда используйте приглашения - они делают программу понятнее
• 2. Проверяйте ввод - пользователи могут ввести неожиданные данные
• 3. Преобразуйте типы - помните, что input() всегда возвращает строку
• 4. Обрабатывайте ошибки - используйте try-except для безопасности

Библиотека math в Python

Модули в программировании

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

Импорт модуля

Способы импорта

# Способ 1: Импорт всего модуля
import math
# Использование: math.функция()
результат = math.sqrt(16)
print(результат)  # 4.0
# Способ 2: Импорт конкретных функций
from math import sqrt, pi
# Использование: функция() без math.
результат = sqrt(16)
print(pi)  # 3.141592653589793
# Способ 3: Импорт всех функций (не рекомендуется)
from math import *
# Можно использовать все функции без math.
результат = sqrt(16)
константа = pi

Рекомендуемый способ

# Лучше всего использовать полный импорт
import math
# Это более читаемо и безопасно
корень = math.sqrt(25)
синус = math.sin(math.pi / 2)

Основные функции модуля math в Python

math.sqrt()

Извлечение квадратного корня

math.sqrt() — функция для извлечения квадратного корня из числа.

import math
# Извлечение квадратного корня
print(math.sqrt(16))    # 4.0
print(math.sqrt(25))    # 5.0
print(math.sqrt(2))     # 1.4142135623730951
print(math.sqrt(100))   # 10.0
# Корень из дробного числа
print(math.sqrt(2.25))  # 1.5
print(math.sqrt(0.25))  # 0.5

math.pow()

Возведение в степень

math.pow() — функция для возведения числа в степень.

import math
# Возведение в степень
print(math.pow(2, 3))    # 8.0
print(math.pow(5, 2))    # 25.0
print(math.pow(10, 0))   # 1.0
# Дробные степени
print(math.pow(8, 1/3))  # 2.0 (кубический корень)
print(math.pow(9, 0.5))  # 3.0 (квадратный корень)
# Отрицательные степени
print(math.pow(2, -3))   # 0.125 (1/8)

Сравнение с оператором **

import math
# math.pow() всегда возвращает float
print(math.pow(2, 3))              # 8.0
print(type(math.pow(2, 3)))        # <class 'float'>
# Оператор ** сохраняет тип
print(2 ** 3)                      # 8
print(type(2 ** 3))                # <class 'int'>

Тригонометрические функции

math.sin(), math.cos(), math.tan()

Тригонометрические функции работают с углами в радианах.

import math
# Синус
print(math.sin(0))             # 0.0
print(math.sin(math.pi/2))     # 1.0 (90 градусов)
print(math.sin(math.pi))       # 0.0 (180 градусов)
# Косинус
print(math.cos(0))             # 1.0
print(math.cos(math.pi/2))     # 0.0 (практически 0)
print(math.cos(math.pi))       # -1.0
# Тангенс
print(math.tan(0))             # 0.0
print(math.tan(math.pi/4))     # 1.0 (45 градусов)

Преобразование градусов в радианы

import math
# Функция для преобразования градусов в радианы
def градусы_в_радианы(градусы):
    return градусы * math.pi / 180
# Или используем встроенную функцию
угол_градусы = 90
угол_радианы = math.radians(угол_градусы)
print(f"Синус 90°: {math.sin(угол_радианы)}")     # 1.0
print(f"Косинус 90°: {math.cos(угол_радианы)}")   # 0.0

math.log()

Логарифмы

math.log() — функция для вычисления логарифмов.

import math
# Натуральный логарифм (основание e)
print(math.log(1))       # 0.0
print(math.log(math.e))  # 1.0
print(math.log(10))      # 2.302585092994046
# Логарифм с другим основанием
print(math.log(8, 2))     # 3.0 (логарифм 8 по основанию 2)
print(math.log(100, 10))  # 2.0 (логарифм 100 по основанию 10)
# Специальные логарифмы
print(math.log10(100))    # 2.0 (десятичный логарифм)
print(math.log2(8))       # 3.0 (двоичный логарифм)

Другие полезные функции

math.ceil() и math.floor()

import math
# Округление вверх
print(math.ceil(3.1))     # 4
print(math.ceil(3.9))     # 4
print(math.ceil(-2.1))    # -2
# Округление вниз
print(math.floor(3.1))    # 3
print(math.floor(3.9))    # 3
print(math.floor(-2.1))   # -3
# Практический пример
цена = 99.99
количество = 7
общая_стоимость = цена * количество
print(f"Точная стоимость: {общая_стоимость}")
print(f"Округлено вверх: {math.ceil(общая_стоимость)}")
print(f"Округлено вниз: {math.floor(общая_стоимость)}")

math.factorial()

import math
# Факториал
print(math.factorial(5))  # 120 (5! = 5*4*3*2*1)
print(math.factorial(0))  # 1
print(math.factorial(1))  # 1
# Практический пример: размещения
def размещения(n, k):
    return math.factorial(n) // math.factorial(n - k)
print(f"Размещений из 5 по 3: {размещения(5, 3)}")  # 60

math.gcd() и math.lcm()

import math
# Наибольший общий делитель
print(math.gcd(12, 18))    # 6
print(math.gcd(15, 25))    # 5
# Наименьшее общее кратное (с Python 3.9+)
# print(math.lcm(12, 18))  # 36
# Практический пример
числитель = 12
знаменатель = 18
нод = math.gcd(числитель, знаменатель)
упрощенный_числитель = числитель // нод
упрощенный_знаменатель = знаменатель // нод
print(f"Дробь {числитель}/{знаменатель} = {упрощенный_числитель}/{упрощенный_знаменатель}")

math.fabs()

import math
# Абсолютное значение (всегда возвращает float)
print(math.fabs(-5))      # 5.0
print(math.fabs(3.14))    # 3.14
print(math.fabs(-3.14))   # 3.14
# Сравнение с abs()
print(abs(-5))            # 5 (int)
print(math.fabs(-5))      # 5.0 (float)

Константы в модуле math в питоне

math.pi — число пи

Константа π (пи)

math.pi — это математическая константа π ≈ 3.14159...

import math
# Значение π
print(math.pi)  # 3.141592653589793
# Использование в формулах
радиус = 5
длина_окружности = 2 * math.pi * радиус
площадь_круга = math.pi * радиус**2
print(f"Радиус: {радиус}")
print(f"Длина окружности: {длина_окружности:.2f}")
print(f"Площадь круга: {площадь_круга:.2f}")

math.e

Константа e (число Эйлера)

math.e — это математическая константа e ≈ 2.71828...

import math
# Значение e
print(math.e)  # 2.718281828459045
# Связь с натуральным логарифмом
print(math.log(math.e))  # 1.0
print(math.exp(1))       # 2.718281828459045 (e^1)

Полезные советы

1. Всегда импортируйте math в начале программы

2. Помните о радианах в тригонометрических функциях

3. Проверяйте входные данные для функций с ограничениями

4. Используйте константы math.pi и math.e вместо приближенных значений

Примеры программ на Python

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

Пример программы на питоне: Калькулятор площади круга

Вот простой код для вычисления площади круга по заданному радиусу:

import math
radius = float(input("Введите радиус круга: "))
area = math.pi * radius ** 2
print(f"Площадь круга с радиусом {radius} равна {area:.2f}")

Пример программы на пайтоне: Калькулятор

Пример простого калькулятора, который выполняет основные арифметические операции:

operation = input("Введите операцию (+, -, *, /): ")
num1 = float(input("Введите первое число: "))
num2 = float(input("Введите второе число: "))
if operation == '+':
    result = num1 + num2
    print(f"Результат: {result}")
elif operation == '-':
    result = num1 - num2
    print(f"Результат: {result}")
elif operation == '*':
    result = num1 * num2
    print(f"Результат: {result}")
elif operation == '/':
    result = num1 / num2
    print(f"Результат: {result}")
else:
    print("Неверная операция") 

Пример простой программы на Python: Конвертер валют

Простой пример конвертера валют, который использует фиксированный курс:

amount = float(input("Введите сумму в валюте (например, USD): "))
rate = float(input("Введите курс (например, 0.85 для USD в EUR): "))
converted_amount = amount * rate
print(f"Сумма в конвертируемой валюте: {converted_amount:.2f}")

Эти примеры показывают основные возможности Python для решения практических задач, таких как вычисление площадей, выполнение математических операций и конвертация валют.