Основы математических вычислений на языке Python
Математические вычисления в Python: основы и примеры
Как выполнить базовые математические операции в Python?
Python поддерживает все стандартные арифметические операторы: сложение (+), вычитание (-), умножение (*), деление (/), целочисленное деление (//), остаток от деления (%) и возведение в степень (**). Ниже приведён простой пример.
a = 15
b = 4
print('Сложение:', a + b)
print('Вычитание:', a - b)
print('Умножение:', a * b)
print('Деление:', a / b)
print('Целочисленное деление:', a // b)
print('Остаток:', a % b)
print('Возведение в степень:', a ** b)что делает strip в python (метод strip() в python)
Сложение: 19 Вычитание: 11 Умножение: 60 Деление: 3.75 Целочисленное деление: 3 Остаток: 3 Возведение в степень: 50625
математические примеры python (математические примеры в python)
Типичные проблемы:
- Деление на ноль (ZeroDivisionError) – возникает, если второй операнд равен нулю. Решение: проверять делитель перед вычислением или обрабатывать исключение.
- Неявное преобразование типов – при смешивании целых и дробных чисел результат становится дробным. Если нужен именно целый результат, используйте целочисленное деление или явное преобразование.
- Ошибки округления дробных чисел – из-за двоичного представления чисел с плавающей точкой, например
0.1 + 0.2 != 0.3. Для точных денежных расчётов применяется модуль decimal.
Как использовать математические функции из стандартной библиотеки?
Модуль math предоставляет тригонометрические, логарифмические, степенные функции и константы (π, e). Перед использованием модуль нужно импортировать.
import math
# Константы
print('π =', math.pi)
print('e =', math.e)
# Тригонометрия
angle = math.radians(60) # перевод градусов в радианы
print('sin 60° =', math.sin(angle))
print('cos 60° =', math.cos(angle))
# Логарифмы
print('ln(10) =', math.log(10))
print('log2(8) =', math.log2(8))
print('log10(100) =', math.log10(100))
# Степень и корень
print('sqrt(25) =', math.sqrt(25))
print('pow(3,4) =', math.pow(3, 4))
новые возможности условного оператора python (новые возможности условного оператора в python)
π = 3.141592653589793 e = 2.718281828459045 sin 60° = 0.8660254037844386 cos 60° = 0.5000000000000001 ln(10) = 2.302585092994046 log2(8) = 3.0 log10(100) = 2.0 sqrt(25) = 5.0 pow(3,4) = 81.0
Float python пример (примеры float в python)
Ошибки:
- Передача аргумента вне области определения (ValueError), например
math.sqrt(-1). Для комплексных чисел используйте модуль cmath. - Использование
math.pow()возвращает float, в отличие от встроенного оператора**, который может вернуть целое число.
Как получить случайное число или выбрать случайный элемент?
Модуль random генерирует псевдослучайные числа. Можно получать случайные целые, дробные числа, выбирать элементы из последовательности.
import random
# Случайное целое в диапазоне [1, 10]
num = random.randint(1, 10)
print('Случайное целое:', num)
# Случайное дробное в [0, 1)
frac = random.random()
print('Случайное дробное:', frac)
# Случайный элемент из списка
toys = ['кубик', 'мяч', 'машинка', 'конструктор']
choice = random.choice(toys)
print('Выбранная игрушка:', choice)
# Перемешивание списка
cards = list(range(1, 11))
random.shuffle(cards)
print('Перемешанные карты:', cards)Python кортежи примеры (примеры кортежей в python)
Случайное целое: 7 Случайное дробное: 0.482650132456 Выбранная игрушка: мяч Перемешанные карты: [3, 8, 1, 10, 4, 9, 6, 2, 5, 7]
словарь в python пример (примеры словарей в python)
Примечания:
- Генерация случайных чисел не подходит для криптографии – используйте модуль secrets.
- Функция
random.seed()позволяет воспроизводить одинаковые последовательности (полезно для отладки).
Как работать с комплексными числами?
Комплексные числа представляются в виде a + bj, где j – мнимая единица. Python поддерживает арифметику комплексных чисел, а модуль cmath добавляет специализированные функции.
z1 = 3 + 4j
z2 = 1 - 2j
# Арифметические операции
print('Сумма:', z1 + z2)
print('Разность:', z1 - z2)
print('Произведение:', z1 * z2)
print('Деление:', z1 / z2)
# Модуль (абсолютное значение)
print('|z1| =', abs(z1))
import cmath
# Квадратный корень из отрицательного числа
sqrt_neg = cmath.sqrt(-9)
print('sqrt(-9) =', sqrt_neg)является ли число четным python (проверка числа на четность в python)
Сумма: (4+2j) Разность: (2+6j) Произведение: (11-2j) Деление: (-0.2+1.4j) |z1| = 5.0 sqrt(-9) = 3j
типы данных в python с примерами (типы данных в python с примерами)
Обратите внимание: стандартные функции math.sqrt() не работают с комплексными числами. Для них необходим cmath. Также сравнение комплексных чисел (<, >) не поддерживается.
Как округлить числа с разной точностью?
В Python есть несколько способов округления: встроенная функция round(), а также math.floor() (вниз) и math.ceil() (вверх).
import math
value = 3.14159
# Округление до 2 знаков
print('round:', round(value, 2))
# Округление вниз и вверх до целого
print('floor:', math.floor(value))
print('ceil:', math.ceil(value))
# Отбрасывание дробной части (округление к нулю)
print('int(value):', int(value))множественный выбор python (множественный выбор (if-elif-else) в python)
round: 3.14 floor: 3 ceil: 4 int(value): 3
проверить является ли числом python (проверка, является ли значение числом в python)
Проблема: round() использует банковское округление (к ближайшему чётному) для чисел, находящихся ровно посередине. Например round(2.5) даст 2, а round(3.5) – 4. Для строго математического округления от нуля применяют decimal.Decimal.
Как решить квадратное уравнение с помощью Python?
Корни квадратного уравнения ax² + bx + c = 0 находятся по дискриминанту. Python позволяет вычислить действительные и комплексные корни.
import math
a, b, c = 1, -3, 2 # уравнение x² - 3x + 2 = 0
d = b**2 - 4*a*c
if d > 0:
x1 = (-b + math.sqrt(d)) / (2*a)
x2 = (-b - math.sqrt(d)) / (2*a)
print('Два действительных корня:', x1, x2)
elif d == 0:
x = -b / (2*a)
print('Один корень:', x)
else:
# Комплексные корни
import cmath
x1 = (-b + cmath.sqrt(d)) / (2*a)
x2 = (-b - cmath.sqrt(d)) / (2*a)
print('Комплексные корни:', x1, x2)
Два действительных корня: 2.0 1.0
Потенциальная ошибка: деление на ноль, если a == 0. Уравнение перестаёт быть квадратным. Рекомендуется проверять коэффициент a.
Как избежать ошибок округления при работе с десятичными дробями?
Тип Decimal из модуля decimal обеспечивает точные десятичные вычисления. Полезно для финансовых расчётов.
from decimal import Decimal, getcontext
# Установка точности (количество знаков после запятой)
getcontext().prec = 28
a = Decimal('0.1')
b = Decimal('0.2')
print('0.1 + 0.2 =', a + b)
# Сравнение с float
print('Использование float:', 0.1 + 0.2 == 0.3)
print('Использование Decimal:', a + b == Decimal('0.3'))
0.1 + 0.2 = 0.3 Использование float: False Использование Decimal: True
Ошибки:
- Создание Decimal из float (
Decimal(0.1)) приведёт к унаследованной погрешности. Всегда передавайте строку или целое число. - Разная точность при арифметических операциях может потребовать явного округления через
quantize().
Как работать с дробями (рациональными числами)?
Модуль fractions позволяет точно представлять обыкновенные дроби и выполнять с ними операции.
from fractions import Fraction
f1 = Fraction(1, 3)
f2 = Fraction(2, 5)
print('Сумма:', f1 + f2)
print('Произведение:', f1 * f2)
print('Обратная дробь к f1:', 1 / f1)
# Автоматическое сокращение
f3 = Fraction(6, 9)
print('Сокращённая дробь:', f3)
Сумма: 11/15 Произведение: 2/15 Обратная дробь к f1: 3 Сокращённая дробь: 2/3
Обратите внимание: создание дроби через Fraction(0.1) даст неожиданный результат (очень большая дробь) из-за погрешности float. Рекомендуется использовать строки: Fraction('0.1') или Fraction(1, 10).
Расширенные математические примеры
Вычисление факториала
Факториал числа n (n!) можно вычислить рекурсивно или с помощью math.factorial.
import math
# Встроенная функция
print('math.factorial(10) =', math.factorial(10))
# Рекурсивное определение
def factorial_rec(n):
if n == 0:
return 1
return n * factorial_rec(n - 1)
print('Рекурсивный факториал 10 =', factorial_rec(10))
math.factorial(10) = 3628800 Рекурсивный факториал 10 = 3628800
Нахождение наибольшего общего делителя (НОД)
Модуль math содержит функцию gcd(), но также можно реализовать алгоритм Евклида.
import math
a, b = 48, 18
print('НОД(48,18) =', math.gcd(a, b))
# Собственная реализация
def gcd_own(x, y):
while y:
x, y = y, x % y
return x
print('Собственная реализация:', gcd_own(48, 18))
НОД(48,18) = 6 Собственная реализация: 6
Вычисление площади круга и объёма шара
import math
radius = 5
# Площадь круга: πr²
area = math.pi * radius ** 2
print('Площадь круга (r=5):', round(area, 2))
# Объём шара: (4/3)πr³
volume = 4/3 * math.pi * radius ** 3
print('Объём шара (r=5):', round(volume, 2))
Площадь круга (r=5): 78.54 Объём шара (r=5): 523.6
Статистические функции (среднее, медиана)
Модуль statistics предоставляет функции для работы с наборами чисел.
import statistics
data = [4, 8, 6, 5, 3, 4, 9]
print('Среднее:', statistics.mean(data))
print('Медиана:', statistics.median(data))
print('Стандартное отклонение:', statistics.stdev(data))
Среднее: 5.571428571428571 Медиана: 5 Стандартное отклонение: 2.1491317172427176
Сравнение чисел с плавающей точкой с помощью math.isclose
Из-за погрешности float прямое сравнение может не сработать. Функция math.isclose проверяет, что числа близки друг к другу в пределах заданной относительной и абсолютной погрешности.
import math
a = 0.1 + 0.2
b = 0.3
print('Прямое сравнение:', a == b)
print('math.isclose:', math.isclose(a, b))
# Настройка допуска
print('С rel_tol=1e-5:', math.isclose(a, b, rel_tol=1e-5))
print('С abs_tol=1e-10:', math.isclose(a, b, abs_tol=1e-10))
Прямое сравнение: False math.isclose: True С rel_tol=1e-5: True С abs_tol=1e-10: True
Генерация случайного пароля
Для создания надёжного пароля используется модуль random или secrets.
import random
import string
def generate_password(length=12):
# Все символы: буквы, цифры, знаки препинания
chars = string.ascii_letters + string.digits + string.punctuation
password = ''.join(random.choice(chars) for _ in range(length))
return password
print('Сгенерированный пароль:', generate_password(16))
Сгенерированный пароль: k@V7n$!q3bLx&cRp
Корни из отрицательных чисел с модулем cmath
import cmath
# Кубический корень из -8 (комплексный)
cube_root = (-8) ** (1/3) # Один из корней
print('Главный кубический корень (-8):', cube_root)
# Все корни уравнения z^3 = -8
for k in range(3):
root = 2 * cmath.exp(2j * math.pi * k / 3) # из формулы Муавра
# Но проще: 2 * (cos(2πk/3) + i sin(2πk/3))
# Для наглядности используем полярное представление:
angle = (math.pi + 2 * math.pi * k) / 3
root = 2 * (math.cos(angle) + 1j * math.sin(angle))
print(f'Корень {k}: {root}')
Главный кубический корень (-8): (1.0000000000000002+1.7320508075688772j) Корень 0: (1+1.7320508075688772j) Корень 1: (-1.9999999999999998+2.4492935982947064e-16j) Корень 2: (1-1.7320508075688772j)
Примечание: вычисление корня через ** даёт только один (главный) корень. Для получения всех корней используется формула Муавра.