Модуль числа в python: Модуль числа в Python 3 — Функция abs библиотеки math

Модуль числа в Python 3 — Функция abs библиотеки math

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

Модуль числа

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

При вычислении модуля возможны 3 ситуации:

• Когда число больше 0. Если взять его по модулю — не изменится.
• Модуль нуля так же равен нулю.
• У отрицательного числа отбрасываем знак. То есть умножаем его на -1.

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

Комплексное число состоит из действительной составляющей и мнимой. Геометрически это можно представить как 2 ортогональные оси: действительную и мнимую. Отмечаем на координатных осях требуемую точку. Модулем будет длина отрезка, проведенного из начала координат в эту точку.

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

Вычисление

Вычислять модуль можно следующими способами:

• Используя стандартную функцию abs.
• С помощью функции fabs библиотеки math.
• При помощи самостоятельно написанной функции.

Все эти функции работают как в Python 2, так и в Python 3.

abs

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

a = -10
b = abs(a)
print(b)
print(type(b))

10
<class 'int'>

fabs

Можно так же воспользоваться функцией fabs из библиотеки math. Библиотеку можно подключить с помощью from math import fabs.

from math import fabs
a = -10
b = fabs(a)
print(b)
print(type(b))

10.0
<class 'float'>

Отличие abs от fabs заключается в том, что функция abs возвращает значение того же типа, что и аргумент. Функция же fabs вначале преобразует тип аргумента к вещественному числу.

Свое решение

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

Например, можно вычислить воспользоваться тернарным оператором.

a = -10
b = a if a > 0 else -a
print(b)

10

На основе такого условия сделаем свою функцию.

def my_abs(a):
    return a if a > 0 else -a
print(my_abs(-3))

3

Модуль комплексного числа

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

Функцией fabs мы не сможем воспользоваться. Если попытаемся это сделать, то получим ошибку приведения комплексного числа к действительному (TypeError).

from math import fabs
a = -10-2j
b = fabs(a)
print(b)

Traceback (most recent call last):
  File "main.py", line 3, in <module>
    b = fabs(a)
TypeError: can't convert complex to float

А вот с помощью abs преобразование удается.

a = -10-2j
b = abs(a)
print(b)

10.19803902718557

Или же напишем свою функцию:

from math import sqrt
def my_abs_complex(c):
    return sqrt(c.real**2 + c.imag**2)
a = -10-2j
b = my_abs_complex(a)
print(b)

10.198039027185569

Результаты получились одинаковыми. Но нам все равно пришлось подключить библиотеку math для вычисления квадратного корня.

модуль числа на примерах с int и float, синтаксис функции

Встроенная функция abs(x) в Python возвращает абсолютное значение аргумента x, который может быть целым или числом с плавающей точкой, или же объектом, реализующим функцию __abs__(). Для комплексных чисел функция возвращает их величину. Абсолютное значение любого числового значения -x или +x — это всегда соответствующее положительное +x.

Пример abs() с целым числом

Следующий код демонстрирует, как получить абсолютное значение 42 положительного числа 42.

x = 42
abs_x = abs(x)
print(f"Абсолютное значение {x} это {abs_x}")
# Вывод: Абсолютное значение 42 это 42
Вывод: «Абсолютное значение 42 это 42».
То же самое, но уже с отрицательным -42.
x = -42
abs_x = abs(x)
print(f"Абсолютное значение {x} это {abs_x}")
#  Вывод: Абсолютное значение -42 это 42
Пример с числом float
Вот как получить абсолютное значение 42.42 и для -42.42:
x = 42.42
abs_x = abs(x)
print(f"Абсолютное значение {x} это {abs_x}")
#  Абсолютное значение 42.42 это 42.42

x = -42.42
abs_x = abs(x)
print(f"Абсолютное значение {x} это {abs_x}")
#  Абсолютное значение -42.42 это 42.42
Комплексное число
Абсолютное значение комплексного числа (3+10j).
complex_number = (3+10j)
abs_complex_number = abs(complex_number)
print(f"Абсолютное значение {complex_number} это {abs_complex_number}")
#  Абсолютное значение (3+10j) это 10.44030650891055
abs() vs fabs()
abs(x) вычисляет абсолютное значение аргумента x. По аналогии функция fabs(x) модуля math вычисляет то же значение. Разница лишь в том, что math.fabs(x) возвращает число с плавающей точкой, а abs(x) вернет целое число, если в качестве аргумента было целое число. Fabs расшифровывается как float absolute value.
Пример c fabs():
x = 42
print(abs(x))
# 42

import math
print(math.fabs(x))
# 42.0
abs() vs. np.abs()
И abs() в Python, и np.abs() в NumPy вычисляют абсолютное значение числа, но есть два отличия. np.abs(x) всегда возвращает число с плавающей точкой. Также np.abs(x) принимает массив NumPy, вычисляя значение для каждого элемента коллекции.
Пример:
x = 42
print(abs(x))
# 42

import numpy as np
print(np.fabs(x))
# 42.0

a = np.array([-1, 2, -4])
print(np.abs(a))
# [1 2 4]
abs и np.abs абсолютно идентичны. Нет разницы какой использовать. У первой преимущество лишь в том, что ее вызов короче.
Вывод
Функция abs() — это встроенная функция, возвращающая абсолютное значение числа. Она принимает целые, с плавающей точкой и комплексные числа на вход.
Если передать в abs() целое число или число с плавающей точкой, то функция вернет не-отрицательное значение n и сохранит тип. Для целого числа — целое число. Для числа с плавающей точкой — число с плавающей точкой.
>>> abs(20)
20
>>> abs(20.0)
20.0
>>> abs(-20.0)
20.0
Комплексные числа состоят из двух частей и могут быть записаны в форме a + bj, где a и b — это или целые числа, или числа с плавающей точкой. Абсолютное значение a + bj вычисляется математически как math.sqrt(a**2 + b**2).
>>> abs(3 + 4j)
5.0
>>> math.sqrt(3**2 + 4**2)
5.0
Таким образом, результат всегда положительный и всегда является числом с плавающей точкой.
Модуль числа в Python – abs и fabs
Содержание:развернуть
Запускаю китайскую реплику «ТАРДИС», и вот мы в пятом классе. На доске нарисована числовая ось, а на ней выделен отрезок. Его начало в точке 4, а конец – в 8. Учительница говорит, что длину отрезка можно найти путём вычитания координаты начала отрезка из координаты его конца. Вычитаем, получаем 4, и радуемся – мы нашли длину. Ура! 🎉
Перемещаемся на год вперёд, и там происходит странное: учительница выделяет мелом другой отрезок, но делает это в каком-то неправильном месте – левее точки с цифрой «0». Теперь перед нами старая задача, но с новыми числами и даже буквами: A, B, минус 4 и минус 8. Мы начинаем искать длину отрезка AB = [-4;-8]:
Переводим непонимающий взгляд с получившейся отрицательной длины на довольную улыбающуюся учительницу, а затем на доску. Там наверху, рядом с сегодняшней датой, написана тема урока: «Модуль числа».
Что такое модуль числа
Теперь по-взрослому.
Модуль числа называют абсолютной величиной.
Для вещественных чисел модуль определяется так:
Формула модуля числа для вещественных чисел
Т.е. в любом случае, модуль – число большее или равное 0. Поэтому отрицательная длина в примере хитрой учительницы должна была быть взята по модулю:
Тогда дети бы увидели, что геометрический смысл модуля – есть расстояние. Это справедливо и для комплексных чисел, однако формальное определение для них отличается от вещественного:
, где z – комплексное число: z = x + iy.
В Python для нахождения модуля числа применяются две функции: fabs() из подключаемой библиотеки math и встроенная функция abs().
Abs
В то время как math.fabs() может оперировать только вещественными аргументами, abs() отлично справляется и с комплексными. Для начала покажем, что abs в python работает строго в соответствии с математическим определением.
# для вещественных чисел
 print(abs(-1))
 print(abs(0))
 print(abs(1))
> 1
 > 0
 > 1
Как видно, с вещественными числами всё в порядке. Перейдём к комплексным.
# для комплексных чисел
 print(complex(-3, 4))
 print(abs(complex(-3, 4)))
> (-3+4j)
 > 5.0
Если вспомнить, что комплексное число выглядит так: z = x + iy, а его модуль вычисляется по формуле:
, то можно без труда посчитать, что sqrt(3**2 + 4**2) действительно равно 5.0.
Можно заметить, что abs() возвращает значения разных типов. Это зависит от типа аргумента:
print(type(abs(1)))
 > <class 'int'>
print(type(abs(1.0)))
 > <class 'float'>
print(type(abs(complex(1.0, 1.0))))
 <class 'float'>
В этом кроется ещё одно отличие abs() от fabs(). Функция из модуля math всегда приводит аргумент к вещественному типу, а если это невозможно сделать – выбрасывает ошибку:
print(type(math.fabs(complex(2,3))))
 > TypeError: can't convert complex to float
Fabs
Для начала работы с fabs() необходимо импортировать модуль math с помощью следующей инструкции:
import math
Мы уже выяснили, что fabs() не работает с комплексными числами, поэтому проверим работу функции на вещественных:
print(math.fabs(-10))
 print(math.fabs(0))
 print(math.fabs(10))
> 10.0
 > 0.0
 > 10.0
Функция производит вычисления в соответствие с математическим определением, однако, в отличие от abs(), всегда возвращает результат типа float:
print(type(math.fabs(10)))
 > <class 'float'>
Основные свойства модулей
# Квадрат модуля = квадрату числа
 print(pow(4, 2) == pow(abs(4), 2))
 > True
# |x| = |-x|
 print(abs(-10) == abs(10))
 > True
# Модуль произведения = произведению модулей: |ab|=|a||b|
 print(math.fabs(11 * 3) == math.fabs(11) * math.fabs(3))
 > True
# Аналогично для деления: |a/b|=|a|/|b|
 print(math.fabs(48/8) == math.fabs(48) / math.fabs(8))
 > True
# |a ** b| = |a| ** b
 print(abs(2 ** 10) == abs(2) ** 10)
 > True
И еще несколько важных неравенств:
m <= |m|
-|m| <= m
|m| >= 0
|m + n| <= |m| + |n|
|m – n| <= |m| + |n|
|m| — |n| <= |m + n|
|m + n| >= ||m| — |n||
|m – n| >= ||m| — |n||
Оператор по модулю в Python
Что делает модуль в следующем фрагменте кода?
from math import *
3.14 % 2 * pi
Как мы вычисляем по модулю число с плавающей запятой?
 python
 python-3.x
 operators
 Поделиться
 Источник

 KodeWarrior    
 05 октября 2012 в 22:07
 5 ответов
 
 Получение по модулю байт-числа в Python
 При работе в Python, допустим, у меня есть длинный объект bytes . Я хочу получить его по модулю некоторого числа. Например, скажем, у меня есть байтовый объект b’hi’, и я хочу, чтобы он был по модулю 3, тогда результат будет 26729% 3 == 2 . (Объект bytes рассматривается как одно большое число.)…
 Как легко реализовать C-подобную операцию по модулю (остатку) в python 2.7
 Оператор по модулю % на отрицательных числах реализуется по-разному в python и в C. В C г.: -4 % 3 = -1 , в то время как в python: -4 % 3 = 2 . Я знаю, как реализовать python-подобный модуль в C. Интересно, как сделать обратное, то есть легко реализовать C-подобный модуль в python.

66
Когда у вас есть выражение:
a % b = c
Это действительно означает, что существует целое число n , которое делает c как можно меньшим, но неотрицательным.
a - n*b = c
Вручную вы можете просто вычесть 2 (или добавить 2 , если ваше число отрицательное) снова и снова, пока конечный результат не станет наименьшим возможным положительным числом:
  3.14 % 2
= 3.14 - 1 * 2
= 1.14
Кроме того, 3.14 % 2 * pi интерпретируется как (3.14 % 2) * pi . Я не уверен, что вы хотели написать 3.14 % (2 * pi) (в любом случае алгоритм один и тот же. Просто вычитайте/сложите, пока число не станет как можно меньше).
 Поделиться

 Blender    
 05 октября 2012 в 22:11

25
В дополнение к другим ответам,  в документации fmod есть некоторые интересные вещи, которые можно сказать по этому вопросу:
math.fmod(x, y)
Возврат fmod(x, y) , как определено платформой C
 библиотека. Обратите внимание, что выражение Python x % y может не возвращать тот же
 результат. Цель стандарта C состоит в том, чтобы fmod(x, y) был точно
 (математически; с бесконечной точностью) равно x - n*y для некоторого
 целого числа n, так что результат имеет тот же знак, что и x , и величину
 меньше abs(y) . Python в x % y возвращает результат со знаком y
 вместо этого и может быть не совсем вычислимым для аргументов с плавающей запятой. Для
 например, fmod(-1e-100, 1e100) -это -1e-100 , но результат Python
 -1e-100 % 1e100 -это 1e100-1e-100 , который не может быть представлен точно как поплавок, и округляется до удивительного 1e100 . По этой причине
 функция fmod() обычно предпочтительнее при работе с поплавками, в то время как
 Python — х x % y предпочтительнее при работе с целыми числами.
 Поделиться

 Thomas    
 05 октября 2012 в 22:14

3
То же самое , что вы ожидаете от нормального по модулю .., например 7 % 4 = 3, 7.3 % 4.0 = 3.3
Остерегайтесь проблем с точностью с плавающей запятой.
 Поделиться

 Xorlev    
 05 октября 2012 в 22:14

2
то же самое , что и нормальное по модулю 3.14 % 6.28 = 3.14, точно так же, как 3.14%4 =3.14 3.14%2 = 1.14 (остаток…)
 Поделиться

 Joran Beasley    
 05 октября 2012 в 22:12

1
вы должны использовать fmod(a,b)
While abs(x%y) < abs(y) is true математически, для floats это может быть неверно численно из-за roundoff .
Например, и предполагая, что платформа , на которой Python float является числом двойной точности IEEE 754 , для того, чтобы -1e-100 % 1e100 имел тот же знак, что и 1e100, вычисленный результат равен -1e-100 + 1e100, что численно точно равно 1e100 .
Функция fmod() в математическом модуле возвращает результат, знак которого совпадает со знаком первого аргумента, и в этом случае возвращает -1e-100 . Какой подход является более подходящим, зависит от приложения.
where x = a%b используется для целого числа по модулю
 Поделиться

 praveen kansara    
 15 мая 2013 в 14:26
 Javascript оператор по модулю ведет себя иначе, чем другие языки
 Согласно Википедии, оператор по модулю (остаток от целочисленного деления) на n должен давать результат между 0 и n-1 . Это действительно так в python : print(-1%5) # outputs 4 В Ruby году : puts -1%5 # outputs 4 В Haskell г. main = putStrLn $ show $ mod (-1) 5 Но в Javascript г. :…
 Оператор BigQuery по модулю (%) не работает в предложении WHERE
 Когда я использовал оператор по модулю (%) в предложении WHERE на BigQuery, SELECT * from `our-project.data_set1.table1` WHERE the_id % 10 = 0 LIMIT 1000 он был отклонен с сообщением об ошибке типа as; Ошибка: синтаксическая ошибка; недопустимый входной символ  %  в [1:50] Я сделал поворот, как…
Похожие вопросы:
Python по модулю на поплавках
 Может ли кто-нибудь объяснить, как работает оператор по модулю в Python? Я не могу понять, почему 3.5 % 0.1 = 0.1 .
Как я могу использовать оператор по модулю (%) в JavaScript?
 Как я могу использовать оператор по модулю (%) при вычислении чисел для проектов JavaScript?
Как смоделировать оператор по модулю в сплаве?
 Как смоделировать оператор по модулю в сплаве? Я хочу попробовать сплав, чтобы доказать, что любое кратное 4 делится на 2…. Вот мой код.. //proof that 4n is divisible by 2 module I4nDivisibleby2…
Получение по модулю байт-числа в Python
 При работе в Python, допустим, у меня есть длинный объект bytes . Я хочу получить его по модулю некоторого числа. Например, скажем, у меня есть байтовый объект b’hi’, и я хочу, чтобы он был по…
Как легко реализовать C-подобную операцию по модулю (остатку) в python 2.7
 Оператор по модулю % на отрицательных числах реализуется по-разному в python и в C. В C г.: -4 % 3 = -1 , в то время как в python: -4 % 3 = 2 . Я знаю, как реализовать python-подобный модуль в C….
Javascript оператор по модулю ведет себя иначе, чем другие языки
 Согласно Википедии, оператор по модулю (остаток от целочисленного деления) на n должен давать результат между 0 и n-1 . Это действительно так в python : print(-1%5) # outputs 4 В Ruby году : puts…
Оператор BigQuery по модулю (%) не работает в предложении WHERE
 Когда я использовал оператор по модулю (%) в предложении WHERE на BigQuery, SELECT * from `our-project.data_set1.table1` WHERE the_id % 10 = 0 LIMIT 1000 он был отклонен с сообщением об ошибке типа…
Попытка заставить оператор по модулю работать в javascript
 Попытка заставить оператор по модулю работать в javascript. Это относится к функции NodeRed, которая принимает значения в массиве. Я могу получить среднее значение без оператора по модулю, с ним…
Оператор по модулю в Elixir
 Как использовать оператор по модулю в Elixir? Например, в Ruby вы можете сделать: 5 % 2 == 0 Чем он отличается от оператора Ruby по модулю?
Оператор по модулю на множестве в Python
 Как использовать оператор по модулю для набора чисел? if value > 2 and value % 2 == 0 or value % 3 == 0 or value % 5 == 0 or value % 7 == 0 or value % 11 == 0: return False Как мне объединить все…
Модуль числа в Python
Функция модуль ABS для арифметических операций с отрицательными числами со знаком минус. Вычисление абсолютного значения для отрицательных чисел.
Модуль числа
Часто в программировании требуется вычислить абсолютное значение числа. Иначе говоря, отбросить знак.
При вычислении модуля возможны 3 ситуации:
Когда число больше 0. Если взять его по модулю — не изменится.
Модуль нуля так же равен нулю.
У отрицательного числа отбрасываем знак. То есть умножаем его на -1.
Но это все справедливо только для действительных чисел. Чему же тогда будет равен модуль комплексных?
Комплексное число состоит из действительной составляющей и мнимой. Геометрически это можно представить как 2 ортогональные оси: действительную и мнимую. Отмечаем на координатных осях требуемую точку. Модулем будет длина отрезка, проведенного из начала координат в эту точку.
Источник: http://planshet-info.ru/kompjutery/dlja-vychislenija-modulja-chisla-h-ispolzuetsja
Определение модуля числа
Алгебра дает четкое определения модуля числа. Модуль в математике — это расстояние от начала отсчёта до точки координатной прямой, соответствующей этому числу.
Если мы возьмем некоторое число «a» и изобразим его на координатной прямой точкой «A» — расстояние от точки «A» до начала отсчёта (то есть до нуля, длина отрезка «OA») будет называться модулем числа «a».
Знак модуля: |a| = OA
Разберем на примере:
Точка «В», которая соответствует числу «−3», находится на расстоянии 3 единичных отрезков от точки 0 (то есть от начала отсчёта). То есть длина отрезка «OB» равна 3 единицам.
Число 3 (длина отрезка «OB») называют модулем числа «−3».
Обозначение модуля: |−3| = 3
Читают символы выше следующим образом: «модуль числа минус три равен трем».
Точка «С», которая соответствует числу «+4», находится на расстоянии четырех единичных отрезков от начала отсчёта, то есть длина отрезка «OС» равна четырем единицам.
Число 4 называют модулем числа «+4» и обозначают так: |+4| = 4.
Также можно опустить плюс и записать значение, как |4| = 4.
Источник: http://skysmart.ru/articles/mathematic/modul-chisla
Пример abs() с целым числом
Следующий код демонстрирует, как получить абсолютное значение 42 положительного числа 42.
 x = 42abs_x = abs(x)print(f”Абсолютное значение {x} это {abs_x}”)# Вывод: Абсолютное значение 42 это 42
Вывод: «Абсолютное значение 42 это 42».
То же самое, но уже с отрицательным -42.
 x = -42abs_x = abs(x)print(f”Абсолютное значение {x} это {abs_x}”)#  Вывод: Абсолютное значение -42 это 42
Источник: http://pythonru.com/osnovy/abs-v-python-modul-chisla
Немного теории
Итак, поехали. Начнём с самого важного: что такое модуль? Напомню, что модуль числа — это просто то же самое число, но взятое без знака «минус». Т.е., например, $left| -5 right|=5$. Или $left| -129,5 right|=129,5$.
Вот так всё просто? Да, просто. А чему тогда равен модуль положительного числа? Тут ещё проще: модуль положительного числа равен самому этому числу: $left| 5 right|=5$; $left| 129,5 right|=129,5$ и т.д.
Получается любопытная вещь: разные числа могут иметь один тот же модуль. Например: $left| -5 right|=left| 5 right|=5$; $left| -129,5 right|=left| 129,5 right|=129,5$. Нетрудно заметить, что это за числа, у которых модули одинаковые: эти числа противоположны. Таким образом, отметим для себя, что модули противоположных чисел равны:
[left| -a right|=left| a right|]
Ещё один важный факт: модуль никогда не бывает отрицательным. Какое бы число мы ни взяли — хоть положительное, хоть отрицательное — его модуль всегда оказывается положительным (или в крайнем случае нулём). Именно поэтому модуль часто называют абсолютной величиной числа.
Кроме того, если объединить определение модуля для положительного и отрицательного числа, то получим глобальное определение модуля для всех чисел. А именно: модуль числа равен самому этому числу, если число положительное (или ноль), либо равен противоположному числу, если число отрицательное. Можно записать это в виде формулы:
[left| a right|=left{ begin{align}& a,quad age 0, \& -a,quad a lt 0. \end{align} right.]
Ещё есть модуль нуля, но он всегда равен нулю. Кроме того, ноль — единственное число, которое не имеет противоположного.
Таким образом, если рассмотреть функцию $y=left| x right|$ и попробовать нарисовать её график, то получится вот такая «галка»:
График модуля и пример решения уравнения
Из этой картинки сразу видно, что $left| -m right|=left| m right|$, а график модуля никогда не опускается ниже оси абсцисс. Но это ещё не всё: красной линией отмечена прямая $y=a$, которая при положительных $a$ даёт нам сразу два корня: ${{x}_{1}}$ и ${{x}_{2}}$, но об этом мы поговорим позже.:)
Помимо чисто алгебраического определения, есть геометрическое. Допустим, есть две точки на числовой прямой: ${{x}_{1}}$ и ${{x}_{2}}$. В этом случае выражение $left| {{x}_{1}}-{{x}_{2}} right|$  — это просто расстояние между указанными точками. Или, если угодно, длина отрезка, соединяющего эти точки:
Модуль — это расстояние между точками на числовой прямой
Из этого определения также следует, что модуль всегда неотрицателен. Но хватит определений и теории — перейдём к настоящим уравнениям.:)
Источник: http://berdov.com/docs/moduli/uravneniya-modul-kak-reshat/
Вычисление
Вычислять модуль можно следующими способами:
Используя стандартную функцию abs.
С помощью функции fabs библиотеки math.
При помощи самостоятельно написанной функции.
Все эти функции работают как в Python 2, так и в Python 3.
Для вычисления в Python модуля числа используется функция abs. Результат функции того же типа, которого был аргумент.
Можно так же воспользоваться функцией fabs из библиотеки math. Библиотеку можно подключить с помощью from math import fabs .
Свое решение
Если по каким то причинам нет возможности или желания использовать стандартные функции, то можно написать свое решение.
Например, можно вычислить воспользоваться тернарным оператором.
На основе такого условия сделаем свою функцию.
Источник: http://planshet-info.ru/kompjutery/dlja-vychislenija-modulja-chisla-h-ispolzuetsja
Расчет разницы между наименьшим отрицательным и положительным числом
Пример 2. Найти разность между наименьшим и наименьшим абсолютным значениями элементов массива.
Исходные данные:
Для расчета используем следующую формулу (формула массива CTRL+SHIFT+Enter):
Функция МИН выполняет поиск наименьшего значения в диапазоне. Для поиска наименьшего неотрицательного числа используется выражение МИН(ABS(B3:B12)).
Полученный результат:
Источник: http://exceltable.com/funkcii-excel/primer-funkcii-modul-abs
График функции
График функции равен y = |х|.
Для x 0 имеем y = x. 
Для x < 0 имеем y = −x. В результате получаем:
Этот график можно использовать при решении уравнений и неравенств.
Источник: http://skysmart.ru/articles/mathematic/modul-chisla
четверг, 7 апреля 2011 г.
Модуль числа 
Пример . 
Формула =ABS(55-62) вернет число 7
Для вычисления модуля комплексного числа используется инженерная функция МНИМ.ABS(комплексное число) . Комплексное число записывается в виде “x+yi” (кавычки обязательно).
Пример . 
Формула =МНИМ.ABS(“3+4i”) вернет число 5
Источник: http://planshet-info.ru/kompjutery/dlja-vychislenija-modulja-chisla-h-ispolzuetsja
Корень из квадрата
В контрольной или задаче ЕГЭ может встретиться задачка, в которой просят вычислить √a2 , где a – некоторое число или выражение.
При этом, √a2= |a|.
По определению арифметического квадратного корня √a2 — это такое неотрицательное число, квадрат которого равен a2 . 
Оно равно a, при а 0 и -а, при а < 0 , т. е. как раз |a|.
Источник: http://skysmart.ru/articles/mathematic/modul-chisla
Свойства модуля комплексных чисел
Область определения: вся комплексная плоскость.
Область значений: [0;+∞).
Модуль как комплексная функция не дифференцируется ни в одной точке, так как условия Коши-Римана не выполнены.
Источник: http://skysmart.ru/articles/mathematic/modul-chisla
Интерактивный учебник языка Python
1. Целочисленная арифметика
 
Для целых чисел определены операции
 +, -, * и **. Операция
 деления / для целых чисел возвращает вещественное число (значение типа float).
 Также функция возведения в степень возвращает значение типа float,
 если показатель степени — отрицательное число.
Но есть и специальная операция целочисленного деления, выполняющегося с отбрасыванием
 дробной части, которая обозначается // (она соответствует операции div в Паскале).
 Она возвращает целое число: целую часть частного. Другая близкая ей операция − это операция взятия остатка от деления,
 обозначаемая % (она соответствует операции mod в Паскале).
 Например:
	
print(17 / 3)   # выведет 5.66666666667
print(17 // 3)  # выведет 5
print(17 % 3)   # выведет 2
2. Действительные числа
 
В этом разделе речь пойдет о действительных числах, имеющих тип float.
Обратите внимание, что если вы хотите считать с клавиатуры действительное
 число, то результат, возращаемый функцией input() необходимо
 преобразовывать к типу float:
1.492
x = float(input())
print(x)
Действительные (вещественные) числа представляются в виде чисел с десятичной точкой (а не запятой, как принято
 при записи десятичных дробей в русских текстах). Для записи очень больших или очень маленьких
 по модулю чисел используется так называемая запись «с плавающей точкой»
 (также называемая «научная» запись). В этом случае число представляется в виде
 некоторой десятичной дроби, называемой мантиссой, умноженной на целочисленную степень десяти
 (порядок). Например, расстояние от Земли
 до Солнца равно 1.496·1011, а масса молекулы воды 2.99·10-23.
Числа с плавающей точкой в программах на языке Питон, а также при вводе и выводе записываются так:
 сначала пишется мантисса, затем пишется буква e, затем пишется порядок. Пробелы внутри этой
 записи не ставятся. Например, указанные выше константы можно записать в виде
 1.496e11 и 2.99e-23. Перед самим числом также может стоять знак минус.
Напомним, что результатом операции деления / всегда является действительное число (float),
 в то время как результатом операции // является целое число (int).
Преобразование действительных чисел к целому производится с округлением
 в сторону нуля, то есть int(1.7) == 1, int(-1.7) == -1.
3. Библиотека math
 
Для проведения вычислений с действительными числами язык Питон содержит много
 дополнительных функций, собранных в библиотеку (модуль), которая называется math.
Для использования этих функций в начале программы необходимо подключить математическую
 библиотеку, что делается командой
import math
Например, пусть мы хотим округлять вещественные числа до ближайшего целого числа вверх.
 Соответствующая функция ceil от одного аргумента вызывается, например, так: math.ceil(x)
 (то есть явно указывается, что из модуля math используется функция ceil).
 Вместо числа x может быть любое число, переменная или выражение.
 Функция возращает значение, которое можно вывести на экран, присвоить
 другой переменной или использовать в выражении:
	
import math

x = math.ceil(4.2)
y = math.ceil(4.8)
print(x)
print(y)
Другой способ использовать функции из библиотеки math, при котором не нужно будет
 при каждом использовании функции из модуля math указывать название
 этого модуля, выглядит так:
	
from math import ceil
 
x = 7 / 2
y = ceil(x)
print(y)
или так:
	
from math import *
 
x = 7 / 2
y = ceil(x)
print(y)
Ниже приведен список основных функций модуля math. Более подробное описание
 этих функций можно найти на сайте с документацией языка Питон.
Некоторые из перечисленных функций (int, round, abs)
 являются стандартными и не требуют подключения модуля math для использования.
Функция
Описание
Округление
int(x)
Округляет число в сторону нуля. Это стандартная функция, для ее использования не нужно подключать
 модуль math.
round(x)
Округляет число до ближайшего целого. Если дробная часть числа равна 0.5, то число округляется
 до ближайшего четного числа.
round(x, n)
Округляет число x
 до n знаков после точки. Это стандартная функция, для ее использования не нужно подключать
 модуль math.
floor(x)
Округляет число вниз («пол»), при этом floor(1.5) == 1, floor(-1.5) == -2
ceil(x)
Округляет число вверх («потолок»), при этом ceil(1.5) == 2, ceil(-1.5) == -1
abs(x)
Модуль (абсолютная величина). Это — стандартная функция.
Корни, логарифмы
sqrt(x)
Квадратный корень. Использование: sqrt(x)
log(x)
Натуральный логарифм. При вызове в виде log(x, b) возвращает логарифм по основанию b.
e
Основание натуральных логарифмов e = 2,71828…
Тригонометрия
sin(x)
Синус угла, задаваемого в радианах
cos(x)
Косинус угла, задаваемого в радианах
tan(x)
Тангенс угла, задаваемого в радианах
asin(x)
Арксинус, возвращает значение в радианах
acos(x)
Арккосинус, возвращает значение в радианах
atan(x)
Арктангенс, возвращает значение в радианах
atan2(y, x)
Полярный угол (в радианах) точки с координатами (x, y).
degrees(x)
Преобразует угол, заданный в радианах, в градусы.
radians(x)
Преобразует угол, заданный в градусах, в радианы.
pi
Константа π = 3.1415…

 Ссылки на задачи доступны в меню слева. Эталонные решения теперь доступны на странице самой задачи.
 
Функции теории чисел модуля math в Python.
Функции относящиеся к теории чисел.
В этом разделе представлены функции относящиеся к теории чисел.
Содержание:
Факториал числа,
Наибольший общий делитель целых чисел,
Функция math.frexp(),
Функция math.ldexp(),
Абсолютное значение числа,
Остаток от деления,
Получить дробную и целую часть числа,
Получить точную сумму элементов списка,
Получить число x со знаком числа y,
Сравнение в пределах указанной точности,
Наименьшее общее кратное целых чисел,
Следующее значение float после x по направлению к y,
Наименьший значащий бит числа float.
math.factorial(x):
Функция math.factorial() возвращает факториал указанного числа x.
>>> import math
>>> math.factorial(5)
120
Данная функция всегда возвращает число типа int и поддерживает длинную арифметику, т.е. величина обрабатываемого числа x и возвращаемого результата ограничивается только возможностями компьютера.
Если x не является целым числом или если x является отрицательным, то будет вызвано исключение ValueError.
Изменено в Python 3.9. Не рекомендуется передавать числа с плавающей запятой с целыми значениями (например, 5.0).
math.gcd(*integers):
Функция math.gcd() возвращает наибольший общий делитель указанных целочисленных аргументов *integers.
>>> import math
>>> math.gcd(3886, 9048)
# 58

# проверяем
>>> 3886/58, 9048/58
# (67.0, 156.0)
Если какой-либо из аргументов не равен нулю, то возвращаемое значение является наибольшим положительным целым числом, которое является делителем всех аргументов:
Если все аргументы равны нулю, то возвращаемое значение равно 0.
функция math.gcd() вызванная без аргументов возвращает 0.
Указанные числа должны быть целыми типа int, но могут быть как положительными, так и отрицательными:
>>> import math
>>> math.gcd(-4, -8)
# 4
>>> math.gcd(-4, -8.8)
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# TypeError: 'float' object cannot be interpreted as an integer
Изменено в Python 3.9: Добавлена ​​поддержка произвольного количества аргументов. Раньше поддерживалось только два аргумента.
math.frexp(x):
Функция math.frexp() возвращает кортеж из двух чисел (m, e) таких что x == m*2**e.
>>> import math
>>> math.frexp(123)
# (0.9609375, 7)
>>> 0.9609375*2**7
# 123.0
Число m принадлежит к типу float и всегда является таким, что 0.5 <= abs(m) < 1, даже для тех случаев, когда значением x является произвольная степень двойки. Число e всегда целое число int:
>>> math.frexp(0.25)
# (0.5, -1)
>>> math.frexp(64)
# (0.5, 7)
Если x равен 0, то будет возвращено (0.0, 0).
Данная функция используется тогда, когда представление чисел типа float не должно зависеть от архитектуры машины.
math.ldexp(x, i):
Функция math.ldexp() возвращает значение равное x*2**i, т.е. является обратной к функции math.frexp().
>>> import math
>>> math.ldexp(3, 4)
# 48.0
>>> math.ldexp(0.125, 8)
# 32.0
math.fabs(x):
Функция math.fabs() возвращает абсолютное значение, модуль числа x. Результат всегда тип float.
>>> import math
>>> math.fabs(-3)
3.0
Данная функция в отличии от встроенной функции abs() не обрабатывает комплексные числа.
math.fmod(x):
Функция math.fmod() возвращает остаток от деления числа x на число y, вычисленный так, как это определено в библиотеке math языка C.
>>> import math
>>> math.fmod(2.23, 0.2)
0.02999999999999986
Данная функция направлена на то, что бы результат был максимально приближен к значению x - n*y для некоторого целого числа n, что бы этот результат имел тот же знак, что и x, что бы разность x - n*y == abs(y).
Для чисел типа float данная функция является предпочтительнее чем команда x%y, которая в свою очередь является предпочтительной для чисел типа int. Так как для некоторых случаев, например при x = -1e-100 и x =  1e100, команда x%y может вообще выдать неправильный результат.
math.modf(x):
Функция math.modf() возвращает кортеж из двух чисел (f, w) где f это дробная, а w — целая часть числа x. Результат всегда имеет тип float.
>>> import math
>>> math.modf(3)
# (0.0, 3.0)
>>> math.modf(3.14)
# (0.14000000000000012, 3.0)
math.fsum(iterable):
Функция math.fsum() возвращает точную сумму значений в итерируемой последовательности iterable. Возвращаемый результат всегда типа float.
>>> import math
>>> sum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
# 0.9999999999999999
>>> math.fsum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
# 1.0
Может показаться, что эта сумма будет точной всегда, но на самом деле это не так:
>>> math.fsum([0.3, 0.3, 0.3])
0.8999999999999999
Многое зависит от сборки компилятора языка C, который используется на данной платформе. Если вам нужны точные арифметические операции с десятичными дробями, то воспользуйтесь модулем decimal.
math.copysign(x, y):
Функция math.copysign() возвращает число c абсолютным значением x, но со знаком числа y. Возвращаемый результат всегда типа float
>>> import math
>>> math.copysign(14, -12)
# -14.0
>>> math.copysign(-14, 12)
# 14.0
На платформах, которые поддерживают нули со знаком функция math.copysign(1.0, -0.0) возвращает -1.0.
math.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0):
Функция math.isclose() возвращает True если в пределах указанной точности, числа a и b близки настолько, что их можно считать равными.
>>> import math
>>> x = 7
>>> y = 7.000000000000001
>>> x==y
# False
>>> math.isclose(x, y)
# True
Считать числа близкими или нет, определяют два аргумента rel_tol и abs_tol.
Аргумент rel_tol это относительный допуск, определяемый как максимально допустимая разница между числами a и b относительно большего из них по модулю. По умолчанию rel_tol=1e-09, что гарантирует, что числа a и b будут одинаковы, в пределах 9 десятичных цифр. Что бы числа считались равными, если они, допустим, отличаются меньше чем на 0.1%, то достаточно установить rel_tol=0.001, но в любом случае данный параметр, должен быть больше нуля:
>>> y = 7.000001
>>> math.isclose(y, 6.999, rel_tol=0.001)
# True
Аргумент abs_tol это минимальный абсолютный допуск. полезен для сравнений, близких к нулю. Значение abs_tol должно быть не меньше нуля.
Данная функция эквивалентна команде abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol). Значения inf, -inf считаются близкими только сами к себе, а NaN не является близким ни к одному значению, включая само NaN.
math.lcm(*integers):
Функция math.lcm() возвращает наименьшее общее кратное указанных целочисленных аргументов *integers.
Если все аргументы отличны от нуля, то возвращаемое значение является наименьшим положительным целым числом, кратным всем аргументам.
Если какой-либо из аргументов равен нулю, то возвращается значение 0.
Функция math.lcm(), вызванная без аргументов возвращает 1.
Новое в Python 3.9.
math.nextafter(x, y):
Функция math.nextafter() возвращает следующее значение float после x по направлению к y.
Если x равно y, то функция возвращает y.
Примеры:
math.nextafter(x, math.inf) идет вверх: в сторону положительной бесконечности.
math.nextafter(x, -math.inf) идет вниз: в сторону минус бесконечности.
math.nextafter(x, 0.0) стремится к нулю.
math.nextafter(x, math.copysign(math.inf, x)) уходит от нуля.
Новое в Python 3.9.
Смотрите также математическую функцию math.ulp().
math.ulp(x):
Функция math.isclose() возвращает значение наименьшего значащего бита числа float x.
Если x — NaN (не число), то вернет x.
Если x отрицательный, то вернет ulp(-x).
Если x — положительная бесконечность, то вернет x.
Если x равен нулю, то вернет наименьшее положительное денормализованное представимое число float (меньше минимального положительного нормализованного числа float, sys.float_info.min).
Если x равен наибольшему положительному представимому числу float, то вернет значение младшего значащего бита x, так что первое число float меньше x будет x - ulp(x).
В противном случае (x — положительное конечное число) вернет значение младшего значащего бита x, так что первое число float больше x равно x + ulp(x).
ULP означает «Единица на последнем месте».
Новое в Python 3.9.
Смотрите также математическую функцию math.nextafter().
 math — Математические функции — документация Python 3.9.7 
 Этот модуль обеспечивает доступ к математическим функциям, определенным C
 стандарт.
 Эти функции нельзя использовать с комплексными числами; использовать функции
 то же имя из модуля  cmath , если вам требуется поддержка сложных
 числа. Различие между функциями, поддерживающими комплексные числа, и
 те, которые не делаются, поскольку большинство пользователей не хотят учиться так много
 математика, необходимая для понимания комплексных чисел.Получение исключения
 вместо сложного результата позволяет раньше обнаруживать неожиданный комплекс
 число, используемое в качестве параметра, чтобы программист мог определить, как и почему он
 был создан в первую очередь.
 Этот модуль предоставляет следующие функции. За исключением случаев, когда явно
 в противном случае все возвращаемые значения являются числами с плавающей запятой.
 Теоретико-числовые функции и функции представлений 
  математика.   потолок  ( x )
 Вернуть потолок  x , наименьшее целое число, большее или равное  x .Если  x  не является float, делегирует  x .__ ceil __ () , который должен вернуть
  Интегральное значение .
  математика.   гребень  ( n ,  k )
 Вернуть количество способов выбора  k  элементов из  n  элементов без повторения
 и без заказа.
 Оценивается как  n! / (k! * (n - k)!) , когда  k <= n  и оценивает
 до нуля, когда  k> n .
 Также называется биномиальным коэффициентом, потому что он эквивалентен
 к коэффициенту k-го члена в полиномиальном разложении
 выражение  (1 + x) ** n .
 Вызывает  TypeError , если какой-либо из аргументов не является целым числом.
 Вызывает  ValueError , если любой из аргументов отрицательный.
  математика.   копия  ( x ,  y )
 Вернуть число с плавающей запятой с величиной (абсолютным значением)  x , но со знаком
  л .На платформах, поддерживающих нули со знаком,  copysign (1.0, -0.0) 
 возвращает  -1,0 .
  математика.   фабрик  ( x )
 Вернуть абсолютное значение  x .
  математика.   факториал  ( x )
 Вернуть факториал  x  как целое число. Вызывает  ValueError , если  x  не является целым или
 отрицательный.
 Не рекомендуется, начиная с версии 3.9: прием чисел с плавающей запятой с целыми значениями (например,  5.0 ) не рекомендуется.
  математика.   этаж  ( x )
 Возвращает пол размером  x , наибольшее целое число, меньшее или равное  x .
 Если  x  не является плавающим, делегирует  x .__ floor __ () , который должен вернуть
  Интегральное значение .
  математика.  fmod  ( x ,  y )
 Вернуть  fmod (x, y) , как определено библиотекой платформы C. Обратите внимание, что
 Выражение Python  x% y  может не возвращать тот же результат. Намерение C
 стандартным является то, что  fmod (x, y)  должно быть точно (математически; до бесконечности
 точности), равного  x - n * y  для некоторого целого числа  n , так что результат имеет
 тот же знак, что и  x , и величина меньше  абс (y) .Python  x% y 
 вместо этого возвращает результат со знаком  y  и может быть неточно вычислимым
 для аргументов с плавающей запятой. Например,  fmod (-1e-100, 1e100)  это  -1e-100 , но
 результат Python  -1e-100% 1e100  будет  1e100-1e-100 , что не может быть
 представлен в точности как поплавок и округляется до удивительного  1e100 . Для
 по этой причине функция  fmod ()  обычно предпочтительнее при работе с
 float, тогда как Python  x% y  предпочтительнее при работе с целыми числами.
  математика.   frexp  ( x )
 Вернуть мантиссу и показатель степени  x  как пару  (m, e) .  м  - поплавок
 и  e  - целое число, такое что  x == m * 2 ** e  точно. Если  x  равно нулю,
 возвращает  (0,0, 0) , иначе  0,5 <= abs (m) <1 . Это используется, чтобы «выбрать
 отдельно »внутреннее представление поплавка портативным способом.
  математика.   fsum  ( итерация )
 Вернуть точную сумму значений с плавающей запятой в итерируемом объекте. Избегает
 потеря точности из-за отслеживания нескольких промежуточных частичных сумм:
 >>> сумма ([. 1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
0,9999999999999999
>>> fsum ([. 1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
1.0
 
 Точность алгоритма зависит от арифметических гарантий IEEE-754 и
 типичный случай, когда режим округления половинный.На некоторых не-Windows
 сборки, базовая библиотека C использует сложение с расширенной точностью и может
 иногда дважды округляют промежуточную сумму, в результате чего ее
 младший значащий бит.
 Для дальнейшего обсуждения и двух альтернативных подходов см. Поваренную книгу ASPN.
 рецепты точного суммирования с плавающей запятой.
  математика.   gcd  ( * целые числа )
 Возвращает наибольший общий делитель указанных целочисленных аргументов.Если какой-либо из аргументов отличен от нуля, то возвращаемое значение является наибольшим.
 положительное целое число, которое является делителем всех аргументов. Если все аргументы
 равны нулю, то возвращается значение  0 .  gcd ()  без аргументов
 возвращает  0 .
 Изменено в версии 3.9: Добавлена ​​поддержка произвольного количества аргументов. Раньше всего два
 аргументы были поддержаны.
  математика.   isclose  ( a ,  b ,  * ,  rel_tol = 1e-09 ,  abs_tol = 0.0 )
 Вернуть  Истина , если значения  a  и  b  близки друг к другу и
  Неверно  иначе.
 Считается ли два значения близкими или нет, определяется в соответствии с
 даны абсолютные и относительные допуски.
  rel_tol  - относительный допуск - это максимально допустимая разница.
 между  a  и  b  относительно большего абсолютного значения  a  или  b .Например, чтобы установить допуск 5%, передайте  rel_tol = 0,05 . По умолчанию
 допуск -  1e-09 , что гарантирует, что два значения совпадают.
 с точностью до 9 десятичных цифр.  rel_tol  должно быть больше нуля.
  abs_tol  - минимальный абсолютный допуск - полезен для сравнений рядом с
 нуль.  abs_tol  должен быть не меньше нуля.
 Если ошибок не возникает, результатом будет:
  абс (a-b) <= max (rel_tol * max (abs (a), abs (b)), abs_tol) .
 Специальные значения IEEE 754:  NaN ,  inf  и  -inf  будут
 обрабатывается в соответствии с правилами IEEE. В частности,  NaN  не считается
 близко к любому другому значению, включая  NaN .  inf  и  -inf  только
 считается близким к себе.
 См. Также
  PEP 485  - Функция проверки примерного равенства
  математика.   исфинит  ( x )
 Вернуть  Истинно , если  x  не является ни бесконечностью, ни NaN, и
  Неверно  иначе.(Обратите внимание, что  0,0   - это , считающееся конечным.)
  математика.   isinf  ( x )
 Вернуть  Истинно , если  x  - положительная или отрицательная бесконечность, и
  Неверно  иначе.
  математика.   иснан  ( x )
 Вернуть  Истина , если  x  - NaN (не число), и  Ложь  в противном случае.
  математика.   isqrt  ( n )
 Вернуть целочисленный квадратный корень неотрицательного целого числа  n . Это
 пол из точного квадратного корня из  n  или, что эквивалентно, наибольшего целого числа
  a  таким образом, что  a  ² ≤  n .
 Для некоторых приложений может быть удобнее иметь наименьшее целое число
  a  таким образом, чтобы  n  ≤  a  ², или, другими словами, потолок
 точный квадратный корень из  n .Для положительного значения  n  это можно вычислить, используя
  a = 1 + isqrt (n - 1) .
  математика.   куб.м  ( * целые числа )
 Возвращает наименьшее общее кратное указанных целочисленных аргументов.
 Если все аргументы отличны от нуля, то возвращаемое значение является наименьшим.
 положительное целое число, кратное всем аргументам. Если какой-либо из аргументов
 равно нулю, то возвращается значение  0 .  лкм ()  без аргументов
 возвращает  1 .
  математика.   ldexp  ( x ,  и )
 Возврат  x * (2 ** i) . По сути, это обратная функция
  frexp () .
  математика.   мод  ( x )
 Вернуть дробную и целую части  x . Оба результата несут знак
 размером  x  и являются поплавками.
  математика.  далее после  ( x ,  y )
 Вернуть следующее значение с плавающей запятой после  x  в направлении  y .
 Если  x  равно  y , вернуть  y .
 Примеры:
  math.nextafter (x, math.inf)  идет вверх: в сторону положительной бесконечности.
  math.nextafter (x, -math.inf)  идет вниз: в сторону минус бесконечности.
  математ.nextafter (x, 0.0)  стремится к нулю.
  math.nextafter (x, math.copysign (math.inf, x))  уходит от нуля.
 См. Также  math.ulp () .
  математика.   пермь  ( n ,  k = нет )
 Вернуть количество способов выбора  k  элементов из  n  элементов
 без повторов и по порядку.
 Оценивается как  n! / (п - к)! , когда  k <= n  и оценивает
 до нуля, когда  k> n .
 Если  k  не указано или None, тогда  k  по умолчанию  n 
 и функция возвращает  n! .
 Вызывает  TypeError , если какой-либо из аргументов не является целым числом.
 Вызывает  ValueError , если любой из аргументов отрицательный.
  математика.   прод  ( итерация ,  * ,  начало = 1 )
 Вычислить произведение всех элементов на входе  итерируемый .По умолчанию  начальное значение  для продукта -  1 .
 Если итерация пуста, вернуть начальное значение. Эта функция
 предназначен специально для использования с числовыми значениями и может отклонять
 нечисловые типы.
  математика.   остаток  ( x ,  y )
 Вернуть остаток в стиле IEEE 754  x  относительно  y . Для
 конечное  x  и конечное ненулевое  y , это разница  x - n * y ,
 где  n  - ближайшее целое число к точному значению частного  x /
 y .Если  x / y  находится ровно посередине между двумя последовательными целыми числами,
 ближайший , четное целое число  используется для  n . Остаток  r = остаток (x,
 y) , таким образом, всегда удовлетворяет  abs (r) <= 0,5 * abs (y) .
 Особые случаи соответствуют IEEE 754: в частности, остаток  (x, math.inf)  - это
  x  для любых конечных  x  и  остаток (x, 0)  и
  остаток (math.inf, x)  вызывает  ValueError  для любых  x , отличных от NaN.Если результат операции с остатком равен нулю, этот ноль будет иметь
 тот же знак, что и  x .
 На платформах, использующих двоичные числа с плавающей запятой IEEE 754, результат этого
 операция всегда точно представима: ошибка округления не вводится.
  математика.   усечение  ( x )
 Вернуть  Real  значение  x , усеченное до
  Integral  (обычно целое число). Делегаты
  х.__trunc __ () .
  математика.   ulp  ( x )
 Вернуть значение младшего бита числа с плавающей запятой  x :
 Если  x  - NaN (не число), верните  x .
 Если  x  отрицательное, вернуть  ulp (-x) .
 Если  x  - положительная бесконечность, верните  x .
 Если  x  равно нулю, вернуть наименьшее положительное значение.
  денормализованное  представимое число с плавающей запятой (меньше минимального положительного
  нормализованный  с плавающей запятой,  сис.float_info.min ).
 Если  x  равно наибольшему положительному представимому веществу с плавающей запятой,
 вернуть значение младшего бита  x , так что первый
 float меньше  x  составляет  x - ulp (x) .
 В противном случае ( x  - положительное конечное число) вернуть значение наименьшего
 значащий бит  x , так что первое число с плавающей запятой больше  x 
 равно  x + ulp (x) .
 ULP означает «Единица на последнем месте».
 См. Также  math.nextafter ()  и  sys.float_info.epsilon .
 Обратите внимание, что  frexp ()  и  modf ()  имеют другой шаблон вызова / возврата
 чем их эквиваленты в C: они принимают единственный аргумент и возвращают пару
 значения, вместо того, чтобы возвращать их второе возвращаемое значение через "output"
 параметр ’(в Python такого нет).
 Для функций  ceil () ,  floor ()  и  modf ()  обратите внимание, что  все 
 числа с плавающей запятой достаточно большой величины являются точными целыми числами.Поплавки Python обычно несут не более 53 бита точности (такая же, как у
 платформа C двойного типа), в этом случае любой поплавок  x  с  абс (x)> = 2 ** 52 
 обязательно не имеет дробных битов.
 Степенные и логарифмические функции 
  математика.   эксп.  ( x )
 Возврат  e  в степени  x , где  e  = 2,718281… это основание
 натуральных логарифмов. Обычно это более точно, чем математика .e ** x 
 или  pow (math.e, x) .
  математика.   экспм1  ( x )
 Возврат  e  в степени  x , минус 1. Здесь  e  - основание натурального
 логарифмы. Для малых чисел с плавающей запятой  x  вычитание в  exp (x) - 1 
 может привести к значительной потере точности;  expm1 () 
 функция предоставляет способ вычислить это количество с полной точностью:
 >>> из математического импорта exp, expm1
>>> exp (1e-5) - 1 # дает результат с точностью до 11 разряда
1.0000050000069649e-05
>>> expm1 (1e-5) # результат с полной точностью
1.0000050000166668e-05
 
  математика.   журнал  ( x  [,  основание ])
 С одним аргументом верните натуральный логарифм  x  (с основанием  e ).
 С двумя аргументами вернуть логарифм  x  к заданному основанию  ,
 рассчитывается как  log (x) / log (base) .
  математика.  log1p  ( x )
 Вернуть натуральный логарифм  1 + x  (основание  e ). В
 результат рассчитывается с точностью до  x , близкой к нулю.
  математика.   лог2  ( x )
 Вернуть логарифм по основанию 2  x . Обычно это более точно, чем
  журнал (x, 2) .
 См. Также
  int.bit_length ()  возвращает количество битов, необходимых для представления
 целое число в двоичном формате, исключая знак и ведущие нули.
  математика.   лог10  ( x )
 Вернуть десятичный логарифм  x . Обычно это более точно
 чем  log (x, 10) .
  математика.   pow  ( x ,  y )
 Возврат  x  в степени  y . Далее следуют исключительные случаи
 Приложение «F» стандарта C99, насколько это возможно. Особенно,
  pow (1.0, x)  и  pow (x, 0.0)  всегда возвращают  1.0 , даже
 когда  x  - это ноль или NaN. Если и  x , и  y  конечны,
  x  отрицательно, а  y  не является целым числом, тогда  pow (x, y) 
 не определено и вызывает  ValueError .
 В отличие от встроенного оператора  ** ,  math.pow ()  преобразует оба
 его аргументы для типа  с плавающей запятой . Используйте  **  или встроенный
  pow ()  функция для вычисления точных целочисленных степеней.
  математика.   кв.  ( x )
 Возвратите квадратный корень из  x .
 Тригонометрические функции 
  математика.   acos  ( x )
 Вернуть арккосинус  x  в радианах. Результат находится между  0  и
  пи .
  математика.   asin  ( x )
 Вернуть арксинус  x  в радианах.Результат находится между  -pi / 2  и
  пи / 2 .
  математика.   атан  ( x )
 Вернуть арктангенс  x  в радианах. Результат находится между  -pi / 2  и
  пи / 2 .
  математика.   атан2  ( y ,  x )
 Вернуть  atan (y / x)  в радианах. Результат находится между  -pi  и  pi .Вектор в плоскости от начала координат до точки  (x, y)  составляет этот угол
 с положительной осью X. Смысл  atan2 ()  в том, что признаки обоих
 ему известны входные данные, поэтому он может вычислить правильный квадрант для угла.
 Например,  atan (1)  и  atan2 (1, 1)  оба равны  pi / 4 , но  atan2 (-1,
 -1)  равно -3 * pi / 4 .
  математика.   cos  ( x )
 Вернуть косинус  x  радиан.
  математика.   расстояние  ( p ,  q )
 Вернуть евклидово расстояние между двумя точками  p  и  q , каждая
 заданная как последовательность (или итерация) координат. Две точки
 должен иметь такой же размер.
 Примерно эквивалентно:
 sqrt (сумма ((px - qx) ** 2,0 для px, qx в zip (p, q)))
 
  математика.   гипотеза  ( * координаты )
 Вернуть евклидову норму,  sqrt (сумма (x ** 2 для x в координатах)) .Это длина вектора от начала координат до точки
 задается координатами.
 Для двумерной точки  (x, y)  это эквивалентно вычислению
 гипотенуза прямоугольного треугольника по теореме Пифагора,
  sqrt (x * x + y * y) .
 Изменено в версии 3.8: Добавлена ​​поддержка n-мерных точек. Раньше только двое
 размерный случай был поддержан.
  математика.   sin  ( x )
 Вернуть синус  x  радиан.
  математика.   желто-коричневый  ( x )
 Вернуть тангенс  x  радиан.
 Угловое преобразование 
  математика.   градусов  ( x )
 Преобразование угла  x  из радианов в градусы.
  математика.   радиан  ( x )
 Преобразование угла  x  из градусов в радианы.
 Гиперболические функции 
 Гиперболические функции
 являются аналогами тригонометрических функций, основанных на гиперболах
 вместо кружков.
  математика.   acosh  ( x )
 Вернуть обратный гиперболический косинус  x .
  математика.   асинь  ( x )
 Вернуть обратный гиперболический синус  x .
  математика.  атанх  ( x )
 Вернуть арктангенс гиперболического значения  x .
  математика.   cosh  ( x )
 Вернуть гиперболический косинус  x .
  математика.   sinh  ( x )
 Вернуть гиперболический синус  x .
  математика.   танх  ( x )
 Вернуть гиперболический тангенс  x .
 Специальные функции 
  математика.   эрф  ( x )
 Вернуть функцию ошибки в
  х .
 Функцию  erf ()  можно использовать для вычисления традиционных статистических данных.
 функции, такие как кумулятивное стандартное нормальное распределение:
 def phi (x):
    'Кумулятивная функция распределения для стандартного нормального распределения'
    return (1.0 + erf (x / sqrt (2.0))) / 2.0
 
  математика.  erfc  ( x )
 Вернуть дополнительную функцию ошибок при  x . Дополнительная ошибка
 функция определяется как
  1.0 - erf (x) . Он используется для больших значений  x , где вычитание
 от одного вызовет потерю значимости.
  математика.   гамма  ( x )
 Вернуть гамма-функцию в
  х .
  математика.  lgamma  ( x )
 Вернуть натуральный логарифм абсолютного значения гаммы.
 функция при  x .
 Константы 
  математика.   пи 
 Математическая константа  π  = 3,141592…, с доступной точностью.
  математика.   e 
 Математическая константа  e  = 2,718281…, с доступной точностью.
  математика.   тау 
 Математическая константа  τ  = 6,283185…, с доступной точностью.
 Тау - постоянная окружности, равная 2  π , отношение длины окружности к
 его радиус. Чтобы узнать больше о Тау, посмотрите видео Ви Харта Pi is (still)
 Неправильно, и начни праздновать
 Тау день, съев в два раза больше пирога!
  математика.   инф 
 Положительная бесконечность с плавающей запятой.(Для отрицательной бесконечности используйте
  -math.inf .) Эквивалент выходу  float ('inf') .
  математика.   нан 
 Значение с плавающей запятой, «не число» (NaN). Эквивалентно выходу
  с плавающей запятой ('nan') .
  Детали реализации CPython:  Модуль  math  состоит в основном из тонких оберток вокруг платформы C.
 математические библиотечные функции. Поведение в исключительных случаях соответствует Приложению F к
 стандарт C99, где это необходимо.Текущая реализация повысит
  ValueError  для недопустимых операций, таких как  sqrt (-1.0)  или  log (0.0) 
 (где Приложение F C99 рекомендует сигнализировать о недопустимой операции или делении на ноль),
 и  OverflowError  для результатов, которые переполняются (например,
  exp (1000.0) ). NaN не будет возвращено ни одной из функций.
 выше, если один или несколько входных аргументов не были NaN; в этом случае,
 большинство функций вернут NaN, но (опять же после приложения F C99) там
 есть некоторые исключения из этого правила, например  pow (float ('nan'), 0.0)  или
  гипотеза (float ('nan'), float ('inf')) .
 Обратите внимание, что Python не пытается отличить сигнальные NaN от
 тихие NaN, и поведение для передачи сигналов NaN остается неопределенным.
 Типичное поведение - рассматривать все NaN, как если бы они были тихими.
 См. Также
 Модуль  cmath 
 Версии многих из этих функций с комплексными числами.
 cmath - Математические функции для комплексных чисел - Python 3.9.7 документация 
 Этот модуль обеспечивает доступ к математическим функциям для комплексных чисел. В
 функции в этом модуле принимают целые числа, числа с плавающей запятой или комплексные
 числа как аргументы. Они также примут любой объект Python, имеющий либо
  __complex __ ()  или метод  __float __ () : эти методы используются для
 преобразовать объект в комплексное число или число с плавающей запятой, соответственно, и
 затем функция применяется к результату преобразования.
 Примечание
 На платформах с аппаратной и системной поддержкой подписанных
 нули, функции, включающие сечения ветвей, продолжаются на  и на 
 стороны среза ветки: знак нуля отличает единицу
 сторону ветки срезать с другой. На платформах, которые не
 поддерживают подписанные нули, непрерывность указана ниже.
 Преобразование в полярные координаты и обратно 
 Комплексное число Python  z  хранится внутри с использованием прямоугольника  
 или  декартовых координат .Это полностью определяется его  реальными
 часть   z.real  и ее мнимая часть    z.imag . В других
 слов:
  Полярные координаты  дают альтернативный способ представления комплекса
 количество. В полярных координатах комплексное число  z  определяется как
 модуль  r  и фазовый угол  phi . Модуль  r  - это расстояние
 от  z  до начала координат, а фаза  phi  - против часовой стрелки
 угол, измеряемый в радианах, от положительной оси x до линии
 сегмент, соединяющий начало координат с  z .
 Следующие функции могут использоваться для преобразования из собственного
 прямоугольные координаты в полярные координаты и обратно.
  смат.   фаза  ( x )
 Вернуть фазу  x  (также известную как аргумент    x ) как
 плавать.  phase (x)  эквивалентно  math.atan2 (x.imag,
 x.real) . Результат лежит в диапазоне [-  π ,  π ], а ветвь
 разрез для этой операции лежит по отрицательной действительной оси,
 непрерывный сверху.В системах с поддержкой нулей со знаком
 (который включает в себя большинство используемых в настоящее время систем), это означает, что
 знак результата такой же, как знак  x.imag , даже если
  x.imag  равно нулю:
 >>> фаза (комплекс (-1,0; 0,0))
3,1415589793
>>> фаза (комплекс (-1,0, -0,0))
-3.1415589793
 
 Примечание
 Модуль (абсолютное значение) комплексного числа  x  может быть
 вычисляется с помощью встроенной функции  abs () .Здесь нет
 отдельная функция модуля  cmath  для этой операции.
  смат.   полярный  ( x )
 Вернуть представление  x  в полярных координатах. Возвращает
 пара  (r, phi) , где  r  - это модуль  x , а phi - это
 фаза  х .  полярный (x)  эквивалентен  (абс (x),
 фаза (x)) .
  смат.  прямое  ( r ,  phi )
 Вернуть комплексное число  x  с полярными координатами  r  и  phi .
 Эквивалентно  r * (math.cos (phi) + math.sin (phi) * 1j) .
 Степенные и логарифмические функции 
  смат.   эксп.  ( x )
 Возврат  e  в степени  x , где  e  - основание естественного
 логарифмы.
  смат.   журнал  ( x  [,  основание ])
 Возвращает логарифм  x  к заданному основанию  . Если  base  не
 указано, возвращает натуральный логарифм  x . Есть один срез ветки, от 0
 вдоль отрицательной действительной оси до -∞, непрерывно сверху.
  смат.   лог10  ( x )
 Вернуть десятичный логарифм  x .У него такой же отрезок ветки, как у
  журнал () .
  смат.   кв.  ( x )
 Возвратите квадратный корень из  x . У него такое же сечение ветки, как у  log () .
 Тригонометрические функции 
  смат.   acos  ( x )
 Вернуть арккосинус  x . Есть два разреза ветки: один идет прямо от
 1 вдоль вещественной оси до ∞, непрерывный снизу.Другой простирается слева от
 От -1 по действительной оси до -∞, непрерывно сверху.
  смат.   asin  ( x )
 Вернуть арксинус  x . Он имеет те же сечения ответвлений, что и  acos () .
  смат.   атан  ( x )
 Вернуть арктангенс  x . Есть два отреза ветки: один идет от
  1j  вдоль мнимой оси до  ∞j , непрерывно справа.В
 другой простирается от  -1j  вдоль мнимой оси до  -∞j , непрерывно
 слева.
  смат.   cos  ( x )
 Вернуть косинус  x .
  смат.   sin  ( x )
 Вернуть синус  x .
  смат.   желто-коричневый  ( x )
 Вернуть тангенс  x .
 Гиперболические функции 
  смат.   acosh  ( x )
 Вернуть обратный гиперболический косинус  x . Есть один срез ветки,
 продолжающаяся слева от 1 вдоль вещественной оси до -∞, непрерывная сверху.
  смат.   асинь  ( x )
 Вернуть обратный гиперболический синус  x . Есть два отрезка ветки:
 Один простирается от  1j  вдоль мнимой оси до  ∞j ,
 непрерывный справа.Другой простирается от  -1j  вдоль
 мнимая ось до  -∞j , непрерывная слева.
  смат.   атанх  ( x )
 Вернуть арктангенс гиперболического значения  x . Есть два отрезка ветки: один.
 простирается от  1  вдоль действительной оси до  ∞ , непрерывно снизу. В
 другой простирается от -1  вдоль действительной оси до  -∞ , непрерывно от
 выше.
  смат.   cosh  ( x )
 Вернуть гиперболический косинус  x .
  смат.   sinh  ( x )
 Вернуть гиперболический синус  x .
  смат.   танх  ( x )
 Вернуть гиперболический тангенс  x .
 Классификационные функции 
  смат.  исфинит  ( x )
 Вернуть  Истинно , если действительная и мнимая части  x  конечны, и
  Неверно  иначе.
  смат.   isinf  ( x )
 Вернуть  Истинно , если действительная или мнимая часть  x  является
 бесконечность и  Ложь  в противном случае.
  смат.   иснан  ( x )
 Вернуть  Истинно , если действительная или мнимая часть  x  является NaN,
 и  Неверно  в противном случае.
  смат.   isclose  ( a ,  b ,  * ,  rel_tol = 1e-09 ,  abs_tol = 0,0 )
 Вернуть  Истина , если значения  a  и  b  близки друг к другу и
  Неверно  иначе.
 Считается ли два значения близкими или нет, определяется в соответствии с
 даны абсолютные и относительные допуски.
  rel_tol  - относительный допуск - это максимально допустимая разница.
 между  a  и  b  относительно большего абсолютного значения  a  или  b .Например, чтобы установить допуск 5%, передайте  rel_tol = 0,05 . По умолчанию
 допуск -  1e-09 , что гарантирует, что два значения совпадают.
 с точностью до 9 десятичных цифр.  rel_tol  должно быть больше нуля.
  abs_tol  - минимальный абсолютный допуск - полезен для сравнений рядом с
 нуль.  abs_tol  должен быть не меньше нуля.
 Если ошибок не возникает, результатом будет:
  абс (a-b) <= max (rel_tol * max (abs (a), abs (b)), abs_tol) .
 Специальные значения IEEE 754:  NaN ,  inf  и  -inf  будут
 обрабатывается в соответствии с правилами IEEE. В частности,  NaN  не считается
 близко к любому другому значению, включая  NaN .  inf  и  -inf  только
 считается близким к себе.
 См. Также
  PEP 485  - Функция проверки примерного равенства
 Константы 
  смат.  пи 
 Математическая константа  π  в виде числа с плавающей запятой.
  смат.   e 
 Математическая константа  e  в виде числа с плавающей запятой.
  смат.   тау 
 Математическая константа  τ  в виде числа с плавающей запятой.
  смат.   инф 
 Положительная бесконечность с плавающей запятой.Эквивалент  float (inf) .
  смат.   инфдж 
 Комплексное число с нулевой действительной частью и мнимой положительной бесконечностью
 часть. Эквивалент  комплексному (0,0, float ('inf')) .
  смат.   нан 
 Значение с плавающей запятой, «не число» (NaN). Эквивалентно
  с плавающей запятой ('nan') .
  смат.  нанж 
 Комплексное число с нулевой действительной частью и мнимой частью NaN. Эквивалентно
  комплекс (0,0, float ('nan')) .
 Обратите внимание, что набор функций аналогичен, но не идентичен таковому в
 модуль  математика . Причина наличия двух модулей в том, что некоторые пользователи не
 интересуются комплексными числами и, возможно, даже не знают, что это такое. Они
 предпочел бы  math.sqrt (-1)  вызывать исключение, чем возвращать сложный
 количество.Также обратите внимание, что функции, определенные в  cmath , всегда возвращают
 комплексное число, даже если ответ может быть выражен действительным числом (в котором
 случай комплексного числа имеет мнимую часть нуля).
 Примечание о срезах ответвлений: это кривые, вдоль которых данная функция не может
 быть непрерывным. Они необходимы для многих сложных функций. это
 предполагается, что если вам нужно выполнять вычисления со сложными функциями, вы поймете
 насчет срезов веток. Проконсультируйтесь практически с любой (не слишком элементарной) книгой по сложным
 переменные для просветления.Для информации о правильном выборе филиала
 сокращения для числовых целей, хорошей ссылкой должно быть следующее:
 См. Также
 Кахан, W: Отрезки ветвей для сложных элементарных функций; или, много шума о
 ничего не значащий бит. В: Изерлес, А., и Пауэлл, М. (ред.), Современное состояние
 в численном анализе. Clarendon Press (1987), стр. 165–211.
 Python чисел, преобразование типов и математика 
 Числовой тип данных в Python 
 Python поддерживает целые числа, числа с плавающей запятой и комплексные числа.В Python они определены как классы  int ,  float  и  сложные классы .
 Целые числа и числа с плавающей запятой разделяются наличием или отсутствием десятичной запятой. Например, 5 - целое число, а 5.0 - число с плавающей запятой.
 Комплексные числа записываются в виде  x + yj , где  x  - действительная часть, а  y  - мнимая часть.
 Мы можем использовать функцию  type () , чтобы узнать, к какому классу принадлежит переменная или значение, и функцию  isinstance () , чтобы проверить, принадлежит ли она определенному классу.
 Давайте посмотрим на пример:
  а = 5

печать (тип (а))

печать (введите (5.0))

с = 5 + 3j
печать (c + 3)

print (isinstance (c, комплекс))  
 Когда мы запускаем вышеуказанную программу, мы получаем следующий результат:
  <класс 'int'>
<класс 'float'>
(8 + 3j)
Правда  
 Хотя целые числа могут иметь любую длину, число с плавающей запятой является точным только до 15 десятичных знаков (16-е место неточно).
 Числа, с которыми мы имеем дело каждый день, имеют десятичную (основание 10) систему счисления.Но компьютерные программисты (обычно встроенные программисты) должны работать с двоичной (основание 2), шестнадцатеричной (основание 16) и восьмеричной (основание 8) системами счисления.
 В Python мы можем представить эти числа, поместив соответствующий префикс перед этим числом. В следующей таблице перечислены эти префиксы.
 Система счисления
 Префикс
 Двоичный
 '0b' или '0B'
 восьмеричное
 '0o' или '0O'
 Шестнадцатеричный
 '0x' или '0X'
 Вот несколько примеров
  # Вывод: 107
печать (0b1101011)

# Вывод: 253 (251 + 2)
печать (0xFB + 0b10)

# Вывод: 13
печать (0o15)  
 Когда вы запустите программу, на выходе будет:
  107
253
13  
 Преобразование типа 
 Мы можем преобразовать один тип чисел в другой.Это также известно как принуждение.
 Такие операции, как сложение и вычитание, неявно (автоматически) заставляют целое число плавать, если один из операндов является плавающим.
  >>> 1 + 2,0
3,0  
 Мы видим выше, что 1 (целое число) приводится к 1.0 (с плавающей запятой) для сложения, и результат также является числом с плавающей запятой.
 Мы также можем использовать встроенные функции, такие как  int () ,  float ()  и  complex ()  для явного преобразования между типами.Эти функции могут даже преобразовывать из строк.
  >>> число (2.3)
2
>>> int (-2,8)
-2
>>> поплавок (5)
5.0
>>> комплекс ('3 + 5j')
(3 + 5j)  
 При преобразовании из числа с плавающей точкой в ​​целое число обрезается (десятичные части удаляются).
 Десятичный Python 
 Встроенный в Python класс float выполняет некоторые вычисления, которые могут нас удивить. Все мы знаем, что сумма 1,1 и 2,2 составляет 3,3, но Python, похоже, с этим не согласен.
  >>> (1,1 + 2,2) == 3,3
Ложь  
 Что происходит?
 Оказывается, числа с плавающей запятой реализованы в компьютерном оборудовании как двоичные дроби, поскольку компьютер понимает только двоичные (0 и 1). По этой причине большинство известных нам десятичных дробей не могут быть точно сохранены на нашем компьютере.
 Возьмем пример. Мы не можем представить дробь 1/3 в виде десятичного числа. Это даст 0,33333333 ... что бесконечно долго, и мы можем только аппроксимировать его.
 Оказывается, десятичная дробь 0,1 приведет к бесконечно длинной двоичной дроби 0,000110011001100110011 ... и наш компьютер хранит только ее конечное число.
 Это будет приблизительно 0,1, но никогда не будет равным. Следовательно, это ограничение нашего компьютерного оборудования, а не ошибка Python.
  >>> 1,1 + 2,2
3,3000000000000003  
 Чтобы решить эту проблему, мы можем использовать десятичный модуль, который поставляется с Python.В то время как числа с плавающей запятой имеют точность до 15 знаков после запятой, десятичный модуль имеет точность, задаваемую пользователем.
 Посмотрим разницу:
  импорт десятичный

печать (0,1)

печать (десятичное. десятичное (0,1))  
  Выход 
  0,1
0,1000000000000000055511151231257827021181583404541015625  
 Этот модуль используется, когда мы хотим выполнять десятичные вычисления, как мы учились в школе.
 Это также сохраняет значение.Мы знаем, что 25,50 кг точнее, чем 25,5 кг, поскольку в нем два значащих десятичных знака по сравнению с одним.
  из десятичного импортировать десятичный как D

print (D ('1.1') + D ('2.2'))

print (D ('1,2') * D ('2,50'))  
  Выход 
  3,3
3.000  
 Обратите внимание на нули в конце в приведенном выше примере.
 Мы можем спросить, почему бы каждый раз не реализовывать  Decimal  вместо float? Основная причина - оперативность. Операции с плавающей запятой должны выполняться быстрее, чем  десятичных  операций.
 Когда использовать десятичное число вместо числа с плавающей запятой? 
 Обычно мы используем Decimal в следующих случаях.
 Когда мы создаем финансовые приложения, требующие точного десятичного представления.
 Когда мы хотим контролировать требуемый уровень точности.
 Когда мы хотим реализовать понятие значащих десятичных знаков.
 Фракции Python 
 Python обеспечивает операции с дробными числами через модуль  fractions .
 У дроби есть числитель и знаменатель, оба из которых являются целыми числами. Этот модуль поддерживает арифметику рациональных чисел.
 Мы можем создавать объекты Fraction различными способами. Посмотрим на них.
  импортных фракций

печать (дроби. дробь (1.5))

печать (дроби. дробь (5))

печать (дроби. дробь (1,3))  
  Выход 
  3/2
5
1/3  
 Создавая  Fraction  из  float , мы можем получить некоторые необычные результаты.Это происходит из-за несовершенного представления двоичного числа с плавающей запятой, как обсуждалось в предыдущем разделе.
 К счастью,  Fraction  также позволяет создавать экземпляры со строкой. Это предпочтительный вариант при использовании десятичных чисел.
  импортных фракций

# Как float
# Выход: 24769797773/2251799813685248
печать (дроби. дробь (1.1))

# Как строка
# Вывод: 11/10
печать (дроби. дробь ('1,1'))  
  Выход 
  24769797773/2251799813685248
11/10  
 Этот тип данных поддерживает все основные операции.Вот несколько примеров.
  из фракций импортных фракций как F

печать (F (1, 3) + F (1, 3))

печать (1 / F (5, 6))

печать (F (-3, 10)> 0)

печать (F (-3, 10) <0)  
  Выход 
  2/3
6/5
Ложь
Правда  
 Python Математика 
 Python предлагает такие модули, как  math  и  random , для выполнения различных математических задач, таких как тригонометрия, логарифмы, вероятность и статистика и т. Д.
  импорт математики

печать (математика.Пи)

печать (math.cos (math.pi))

печать (math.exp (10))

печать (math.log10 (1000))

печать (math.sinh (1))

печать (math.factorial (6))  
  Выход 
  3,1415589793
-1,0
22026.4657718
3.0
1,17520118014
720  
 Вот полный список функций и атрибутов, доступных в математическом модуле Python.
  случайный импорт

печать (random.randrange (10, 20))

x = ['a', 'b', 'c', 'd', 'e']

# Получить случайный выбор
печать (случайный.выбор (х))

# Перемешать x
random.shuffle (x)

# Вывести перетасованный x
печать (х)

# Печатать случайный элемент
печать (random.random ())  
 Когда мы запускаем указанную выше программу, мы получаем следующий результат (значения могут отличаться из-за случайного поведения).
  18
е
['c', 'e', ​​'d', 'b', 'a']
0,56828211443  
 Вот полный список функций и атрибутов, доступных в модуле Python random.
 Как использовать оператор% - Real Python 
 Python поддерживает широкий спектр арифметических операторов, которые вы можете использовать при работе с числами в вашем коде.Одним из этих операторов является оператор по модулю   (% ), который возвращает остаток от деления двух чисел.
 Оператор по модулю Python иногда может быть упущен из виду. Но хорошее понимание этого оператора даст вам бесценный инструмент в вашем арсенале инструментов Python.
 Математический модуль по модулю 
 Термин  по модулю  происходит от раздела математики, называемого модульной арифметикой. Модульная арифметика имеет дело с арифметикой целых чисел на круговой числовой строке с фиксированным набором чисел.Все арифметические операции, выполняемые на этой числовой строке, будут повторяться, когда они достигнут определенного числа, называемого модулем  .
 Классическим примером модульной арифметики являются двенадцатичасовые часы. Двенадцатичасовые часы имеют фиксированный набор значений от 1 до 12. При подсчете двенадцатичасовых часов вы считаете до модуля 12, а затем возвращаетесь к 1. Двенадцатичасовые часы можно классифицировать как « по модулю 12 », иногда сокращается до« по модулю 12 ».
 Оператор по модулю используется, когда вы хотите сравнить число с модулем и получить эквивалентное число, ограниченное диапазоном модуля.
 Например, предположим, что вы хотите определить, сколько времени будет через девять часов после 8:00. В двенадцатичасовом формате вы не можете просто прибавить 9 к 8, потому что вы получите 17. Вам нужно взять результат, 17, и используйте  mod , чтобы получить эквивалентное значение в двенадцатичасовом контексте:
  8 часов + 9 = 17 часов
17 мод 12 = 5
  
  17 mod 12  возвращает  5 . Это означает, что девять часов после 8:00 - это 17:00. Вы определили это, взяв число  17  и применив его к контексту  mod 12 .
 Теперь, если подумать,  17  и  5  эквивалентны в контексте  mod 12 . Если бы вы посмотрели на часовую стрелку в 5:00 и 17:00, она была бы в том же положении. В модульной арифметике есть уравнение, описывающее эту взаимосвязь:
 Это уравнение гласит: « a  и  b  равны по модулю  n ». Это означает, что  a  и  b  эквивалентны в  mod n , поскольку они имеют одинаковый остаток при делении на  n .В приведенном выше уравнении  n  - это модуль   как для  a , так и для  b . Используя значения  17  и  5  из предыдущих, уравнение будет выглядеть так:
 Это гласит: « 17  и  5  равны по модулю  12 ».  17  и  5  имеют одинаковый остаток,  5 , при делении на  12 . Таким образом, в  mod 12  числа  17  и  5  эквивалентны.
 Вы можете подтвердить это с помощью деления:
  17/12 = 1 К 5
5/12 = 0 R 5
  
 Обе операции имеют одинаковый остаток,  5 , поэтому они эквивалентны по модулю  12 .
 Теперь это может показаться сложным математическим делом для оператора Python, но эти знания подготовят вас к использованию оператора по модулю в примерах далее в этом руководстве. В следующем разделе вы познакомитесь с основами использования оператора Python по модулю с числовыми типами  int  и  float .
 Основы операторов Python по модулю 
 Оператор по модулю, как и другие арифметические операторы, может использоваться с числовыми типами  int  и  float . Как вы увидите позже, его также можно использовать с другими типами, такими как  math.fmod () ,  decimal.Decimal  и вашими собственными классами.
 Оператор по модулю с 
 int 
 В большинстве случаев вы будете использовать оператор по модулю с целыми числами. Оператор по модулю, когда используется с двумя положительными целыми числами, вернет остаток от стандартного евклидова деления:
>>>
  >>> 15% 4
3

>>> 17% 12
5

>>> 240% 13
6

>>> 10% 16
10
  
 Будьте осторожны! Как и в случае с оператором деления (/), Python вернет  ZeroDivisionError , если вы попытаетесь использовать оператор по модулю с делителем  0 :
>>>
  >>> 22% 0
ZeroDivisionError: целочисленное деление или по модулю нуля
  
 Далее вы познакомитесь с использованием оператора по модулю с числом с плавающей запятой  .
 Оператор по модулю с плавающей запятой 
 
 Подобно  int , оператор по модулю, используемый с числом с плавающей запятой  , вернет остаток от деления, но как значение с плавающей запятой  :
>>>
  >>> 12,5% 5,5
1.5

>>> 17,0% 12,0
5.0
  
 Альтернативой использованию  с плавающей запятой  с оператором по модулю является использование  math.fmod ()  для выполнения операций по модулю на  с плавающей запятой  значений:
>>>
  >>> импорт математики
>>> математика.fmod (12.5, 5.5)
1.5

>>> math.fmod (8.5, 2.5)
1.0
  
 Официальные документы Python предлагают использовать  math.fmod ()  вместо оператора Python modulo при работе со значениями  float , поскольку  math.fmod ()  вычисляет результат операции по модулю. Если вы используете отрицательный операнд, вы можете увидеть разные результаты между  math.fmod (x, y)  и  x% y . В следующем разделе вы более подробно исследуете использование оператора по модулю с отрицательными операндами.
 Как и другие арифметические операторы, оператор по модулю и  math.fmod ()  могут столкнуться с проблемами округления и точности при работе с арифметикой с плавающей запятой:
>>>
  >>> 13,3% 1,1
0,09999999999999964

>>> импорт математики
>>> math.fmod (13.3, 1.1)
0,09999999999999964
  
 Если для вашего приложения важно поддерживать точность с плавающей запятой, вы можете использовать оператор по модулю с десятичным числом .Десятичный . Вы рассмотрите это позже в этом руководстве.
 Оператор по модулю с отрицательным операндом 
 Все операции по модулю, которые вы видели до этого момента, использовали два положительных операнда и возвращали предсказуемые результаты. Когда вводится отрицательный операнд, все становится сложнее.
 Как оказалось, способ, которым компьютеры определяют результат операции по модулю с отрицательным операндом, оставляет неоднозначность относительно того, должен ли остаток принимать знак делимого   (делимое число) или знак делителя   (число, на которое делится дивиденд).Разные языки программирования обрабатывают это по-разному.
 Например, в JavaScript остаток примет знак делимого:
 Остаток в этом примере,  2 , положительный, поскольку принимает знак дивиденда  8 . В Python и других языках остаток примет знак делителя:
 Здесь вы можете видеть, что остаток  -1  принимает знак делителя -3 .
 Вам может быть интересно, почему остаток в JavaScript равен  2 , а остаток в Python равен  -1 .Это связано с тем, как разные языки определяют результат операции по модулю. Языки, в которых остаток принимает знак делимого, используют следующее уравнение для определения остатка:
 Это уравнение состоит из трех переменных:
   r   - остаток.
   a   - дивиденд.
   n   - делитель.
  trunc ()  в этом уравнении означает, что используется усеченное деление  , которое всегда округляет отрицательное число до нуля.Для получения дополнительных пояснений см. Шаги операции по модулю ниже, используя  8  в качестве делимого и -3  в качестве делителя:
  r = 8 - (-3 * усечение (8 / -3))
r = 8 - (-3 * усечение (-2,666666666667))
r = 8 - (-3 * -2) # Округление в сторону 0
г = 8 - 6
г = 2
  
 Здесь вы можете увидеть, как такой язык, как JavaScript, получает остаток  2 . Python и другие языки, в которых остаток принимает знак делителя, используют следующее уравнение:
  этаж ()  в этом уравнении означает, что используется  этажное деление .При положительных числах деление этажа вернет тот же результат, что и усеченное деление. Но с отрицательным числом деление по полу округлит результат в меньшую сторону, в сторону от нуля:
  r = 8 - (-3 * этаж (8 / -3))
r = 8 - (-3 * этаж (-2.666666666667))
r = 8 - (-3 * -3) # Округление от 0
г = 8 - 9
г = -1
  
 Здесь видно, что результат  -1 .
 Теперь, когда вы понимаете, откуда берется разница в остатке, вам может быть интересно, почему это важно, если вы используете только Python.Как оказалось, не все операции по модулю в Python одинаковы. В то время как модуль, используемый с типами  int  и  float , принимает знак делителя, другие типы - нет.
 Вы можете увидеть пример этого, сравнив результаты  8.0% -3.0  и  math.fmod (8.0, -3.0) :
>>>
  >>> 8,0% -3
-1,0

>>> импорт математики
>>> math.fmod (8.0, -3.0)
2.0
  
  математ.fmod ()  принимает знак делимого с использованием усеченного деления, тогда как  float  использует знак делителя. Позже в этом руководстве вы увидите другой тип Python, в котором используется знак делимого, десятичное число , десятичное число .
 Оператор по модулю и 
 divmod () 
 Python имеет встроенную функцию  divmod () , которая внутренне использует оператор по модулю.  divmod ()  принимает два параметра и возвращает кортеж, содержащий результаты деления по этажам и по модулю с использованием предоставленных параметров.
 Ниже приведен пример использования  divmod ()  с  37  и  5 :
>>>
  >>> divmod (37, 5)
(7, 2)

>>> 37 // 5
7

>>> 37% 5
2
  
 Вы можете видеть, что  divmod (37, 5)  возвращает кортеж  (7, 2) .  7  является результатом разделения этажей на  37  и  5 .  2  является результатом  37  по модулю  5 .
 Ниже приведен пример, в котором второй параметр представляет собой отрицательное число. Как обсуждалось в предыдущем разделе, когда оператор по модулю используется с  int , остаток примет знак делителя:
>>>
  >>> divmod (37, -5)
(-8, -3)

>>> 37 // -5
-8

>>> 37% -5
-3 # Результат имеет знак делителя
  
 Теперь, когда у вас была возможность увидеть оператор по модулю, используемый в нескольких сценариях, важно взглянуть на то, как Python определяет приоритет оператора по модулю при использовании с другими арифметическими операторами.
 Приоритет оператора по модулю 
 Как и другие операторы Python, для оператора по модулю существуют особые правила, определяющие его приоритет при вычислении выражений. Оператор по модулю (% ) имеет тот же уровень приоритета, что и операторы умножения ( * ), деления (/) и деления пола ( // ).
 Взгляните на пример приоритета оператора по модулю ниже:
>>>
  >>> 4 * 10% 12 - 9
-5
  
 Операторы умножения и по модулю имеют одинаковый уровень приоритета, поэтому Python будет оценивать их слева направо.Вот шаги для вышеуказанной операции:
   4 * 10   оценивается, в результате получается  40% 12 - 9 .
   40% 12   оценивается, в результате получается  4 - 9 .
   4 - 9   вычисляется, в результате получается -5 .
 Если вы хотите переопределить приоритет других операторов, вы можете заключить в круглые скобки операцию, которая должна быть оценена первой:
>>>
  >>> 4 * 10% (12-9)
1
  
 В этом примере сначала оценивается  (12–9) , затем  4 * 10  и, наконец,  40% 3 , что равно  1 .
 Оператор модуля Python на практике 
 Теперь, когда вы познакомились с основами оператора Python по модулю, вы рассмотрите несколько примеров его использования для решения реальных задач программирования. Иногда бывает трудно определить, когда использовать в коде оператор по модулю. Приведенные ниже примеры дадут вам представление о многих способах его использования.
 Как проверить, четное или нечетное число 
 В этом разделе вы увидите, как можно использовать оператор по модулю, чтобы определить, является ли число четным или нечетным.Используя оператор по модулю с модулем  2 , вы можете проверить любое число, чтобы увидеть, делится ли оно без остатка на  2 . Если оно делится без остатка, то это четное число.
 Взгляните на  is_even () , который проверяет, является ли параметр  num  четным:
  def is_even (число):
    вернуть число% 2 == 0
  
 Здесь  num% 2  будет равно  0 , если  num  четное, и  1 , если  num  нечетное.Проверка против  0  вернет логическое значение  True  или  False  в зависимости от того, является ли  num  четным.
 Проверка на нечетные числа очень похожа. Чтобы проверить нечетное число, вы инвертируете проверку равенства:
  def is_odd (число):
    вернуть число% 2! = 0
  
 Эта функция вернет  True , если  num% 2  не равно  0 , что означает, что остаток доказывает, что  num  - нечетное число.Теперь вам может быть интересно, можно ли использовать следующую функцию, чтобы определить, является ли  num  нечетным числом:
  def is_odd (число):
    вернуть число% 2 == 1
  
 Ответ на этот вопрос - да  и  нет. Технически эта функция будет работать так же, как Python вычисляет по модулю с целыми числами. Тем не менее, вам следует избегать сравнения результата операции по модулю с  1 , поскольку не все операции по модулю в Python возвращают тот же остаток.
 Вы можете понять, почему, в следующих примерах:
>>>
  >>> -3% 2
1

>>> 3% -2
-1
  
 Во втором примере остаток принимает знак отрицательного делителя и возвращает  -1 . В этом случае логическая проверка  3% -2 == 1  вернет  False .
 Однако, если вы сравните операцию по модулю с  0 , то не имеет значения, какой операнд отрицательный. Результатом всегда будет  Истинно , если это четное число:
.
 >>>
  >>> -2% 2
0

>>> 2% -2
0
  
 Если вы будете сравнивать операцию Python по модулю с  0 , то у вас не должно возникнуть проблем с проверкой четных и нечетных чисел или любых других кратных чисел в вашем коде.
 В следующем разделе вы узнаете, как можно использовать оператор по модулю с циклами для управления потоком вашей программы.
 Как запускать код с определенными интервалами в цикле 
 С помощью оператора модуля Python вы можете запускать код через определенные промежутки времени внутри цикла. Это делается путем выполнения операции по модулю с текущим индексом цикла и модулем. Номер модуля определяет, как часто код, зависящий от интервала, будет выполняться в цикле. 15}", end = "")
 если индекс% модуля == 0:
 Распечатать()
 Распечатать()
 
 Этот код определяет  split_names_into_rows () , который принимает два параметра. name_list  - это список имен, который следует разбить на строки.  модуль  устанавливает модуль для операции, эффективно определяя, сколько имен должно быть в каждой строке.  split_names_into_rows ()  будет перебирать  name_list  и начинать новую строку после достижения значения модуля  .
 Прежде чем разбирать функцию более подробно, взгляните на нее в действии:
>>>
  >>> names = ["Пикард", "Райкер", "Трой", "Крашер", "Ворф", "Дейта", "Ла Форж"]
>>> split_names_into_rows (имена)
---- Пикард ----- ----- Райкер ----- ----- Трой ------
---- Дробилка ---- ----- Worf ------ ----- Данные ------
--- Ла Форж ----
  
 Как видите, список имен разделен на три строки, максимум по три имени в каждой строке.Модуль   по умолчанию  3 , но вы можете указать любое число:
>>>
  >>> split_names_into_rows (имена, модуль = 4)
---- Пикард ----- ----- Райкер ----- ----- Трой ------ ---- Крашер ----
----- Ворф ------ ----- Данные ------ --- Ла Форж ----

>>> split_names_into_rows (имена, модуль = 2)
---- Пикард ----- ----- Райкер -----
----- Трой ------ ---- Дробилка ----
----- Worf ------ ----- Данные ------
--- Ла Форж ----

>>> split_names_into_rows (имена, модуль = 1)
---- Пикард -----
----- Райкер -----
----- Трой ------
----Дробилка----
----- Ворф ------
-----Данные------
--- Ла Форж ----
  
 Теперь, когда вы увидели код в действии, вы можете разобрать, что он делает.Во-первых, он использует  enumerate ()  для перебора  name_list , присваивая текущему элементу списка  name , а значение счетчика  index . Вы можете видеть, что необязательный аргумент  start  для  enumerate ()  имеет значение  1 . Это означает, что счетчик  индекса  начнется с  1  вместо  0 :
.
  для индекса, имя в перечислении (name_list, start = 1):
  
 Затем внутри цикла функция вызывает  print ()  для вывода  name  в текущую строку.15 Синтаксис  указывает  print ()  выполнить следующие действия:
 Выведите не менее  15  символов, даже если строка короче 15 символов.
 Выровняйте строку по центру.
 Заполните любое пространство справа или слева от строки символом дефиса (–).
 Теперь, когда имя напечатано в строке, взглянем на основную часть  split_names_into_rows () :
 , если индекс% модуля == 0:
    Распечатать()
  
 Этот код берет индекс  текущей итерации  и, используя оператор по модулю, сравнивает его с модулем  .Если результат равен  0 , то он может запустить код, зависящий от интервала. В этом случае функция вызывает  print () , чтобы добавить новую строку, которая начинает новую строку.
 Приведенный выше код является только одним примером. Использование шаблона  index% modulus == 0  позволяет вам запускать другой код через определенные промежутки времени в ваших циклах. В следующем разделе вы немного углубитесь в эту концепцию и рассмотрите циклическую итерацию.
 Как создать циклическую итерацию 
  Циклическая итерация  описывает тип итерации, которая сбрасывается при достижении определенной точки.Как правило, этот тип итерации используется для ограничения индекса итерации определенным диапазоном.
 Вы можете использовать оператор по модулю для создания циклической итерации. Взгляните на пример использования библиотеки  turtle  для рисования формы:
  импортная черепаха
случайный импорт

def draw_with_cyclic_iteration ():
    colors = ["зеленый", "голубой", "оранжевый", "фиолетовый", "красный", "желтый", "белый"]

    turtle.bgcolor ("gray8") # Hex: # 333333
    turtle.pendown ()
    turtle.pencolor (random.выбор (цвета)) # Первый цвет случайный

    i = 0 # Начальный индекс

    в то время как True:
        i = (i + 1)% 6 # Обновить индекс
        turtle.pensize (i) # Установить размер pensize на i
        черепаха вперед (225)
        черепаха. правая (170)

        # Выберите случайный цвет
        если я == 0:
            turtle.pencolor (random.choice (цвета))
  
 В приведенном выше коде используется бесконечный цикл для рисования повторяющейся формы звезды. После каждых шести итераций он меняет цвет пера. Размер пера увеличивается с каждой итерацией, пока  i  не будет сброшено обратно на  0 .Если запустить код, то должно получиться примерно следующее:
 Важные части этого кода выделены ниже:
  импортная черепаха
случайный импорт

def draw_with_cyclic_iteration ():
    colors = ["зеленый", "голубой", "оранжевый", "фиолетовый", "красный", "желтый", "белый"]

    turtle.bgcolor ("gray8") # Hex: # 333333
    turtle.pendown ()
    turtle.pencolor (random.choice (цвета))

    i = 0 # Начальный индекс

    в то время как True:
        i = (i + 1)% 6 # Обновить индекс
        черепаха.pensize (i) # Установить pensize на i
        черепаха вперед (225)
        черепаха. правая (170)

        # Выберите случайный цвет
        если я == 0:
            turtle.pencolor (random.choice (цвета))
  
 Каждый раз при прохождении цикла  i  обновляется на основе результатов  (i + 1)% 6 . Это новое значение  i  используется для увеличения . Компенсация  с каждой итерацией. Как только  i  достигнет  5 ,  (i + 1)% 6  будет равно  0 , а  i  вернется к  0 .
 Вы можете увидеть шаги итерации ниже для более подробного пояснения:
  я = 0: (0 + 1)% 6 = 1
я = 1: (1 + 1)% 6 = 2
я = 2: (2 + 1)% 6 = 3
я = 3: (3 + 1)% 6 = 4
я = 4: (4 + 1)% 6 = 5
i = 5: (5 + 1)% 6 = 0 # Сброс
  
 Когда  i  сбрасывается обратно на  0 ,  .pencolor  изменяется на новый случайный цвет, как показано ниже:
 , если i == 0:
    turtle.pencolor (random.choice (цвета))
  
 Код в этом разделе использует  6  в качестве модуля, но вы можете установить его на любое число, чтобы настроить, сколько раз цикл будет повторяться перед сбросом значения  i .
 Как преобразовать единицы 
 В этом разделе вы узнаете, как можно использовать оператор по модулю для преобразования единиц. В следующих примерах единицы меньшего размера преобразуются в единицы большего размера без использования десятичных знаков. Оператор по модулю используется для определения любого остатка, который может существовать, когда меньшая единица не делится без остатка на большую единицу.
 В этом первом примере вы преобразуете дюймы в футы. Оператор по модулю используется для получения оставшихся дюймов, которые неравномерно не делятся на футы.Оператор деления пола ( // ) используется для округления общего количества футов в меньшую сторону:
  def convert_inches_to_feet (total_inches):
    дюймы = total_inches% 12
    футов = total_inches // 12

    print (f "{total_inches} дюймов = {футов} футов и {дюймов} дюймов")
  
 Вот пример используемой функции:
>>>
  >>> convert_inches_to_feet (450)
450 дюймов = 37 футов и 6 дюймов
  
 Как видно из выходных данных,  450% 12  возвращает  6 , то есть оставшиеся дюймы, которые не были равномерно разделены на футы.Результатом  450 // 12  является  37 , что представляет собой общее количество футов, на которое дюймы были равномерно разделены.
 В следующем примере вы можете пойти немного дальше.  convert_minutes_to_days ()  принимает целое число,  total_mins , представляющее количество минут, и выводит период времени в днях, часах и минутах:
  def convert_minutes_to_days (total_mins):
    дней = total_mins // 1440
    extra_minutes = total_mins% 1440

    часы = extra_minutes // 60
    минут = дополнительные_минуты% 60

    print (f "{total_mins} = {дней} дней, {часов} часов и {минут} минут")
  
 Разбив это, вы можете увидеть, что функция выполняет следующее:
 Определяет общее количество равномерно делимых дней с  total_mins // 1440 , где  1440  - количество минут в дне
 Вычисляет любые  дополнительных_минут  оставшихся с  total_mins% 1440 
 Использует  дополнительных_минут  для получения равномерно делимых  часов  и любых дополнительных  минут 
 Вы можете увидеть, как это работает, ниже:
>>>
  >>> convert_minutes_to_days (1503)
1503 = 1 день, 1 час и 3 минуты

>>> convert_minutes_to_days (3456)
3456 = 2 дня, 9 часов и 36 минут

>>> convert_minutes_to_days (35000)
35000 = 24 дня, 7 часов и 20 минут
  
 Хотя в приведенных выше примерах рассматривается только преобразование дюймов в футы и минут в дни, вы можете использовать любой тип единиц с оператором по модулю, чтобы преобразовать меньшую единицу в большую единицу.
  Примечание : Оба приведенных выше примера можно изменить для использования  divmod () , чтобы сделать код более лаконичным. Если вы помните,  divmod ()  возвращает кортеж, содержащий результаты деления этажа и по модулю с использованием предоставленных параметров.
 Ниже операторы деления по этажам и по модулю были заменены на  divmod () :
  def convert_inches_to_feet_updated (total_inches):
    футы, дюймы = divmod (total_inches, 12)
    print (f "{total_inches} дюймов = {футов} футов и {дюймов} дюймов")
  
 Как видите,  divmod (total_inches, 12)  возвращает кортеж, который распакован в  футов  и  дюймов .
 Если вы попробуете эту обновленную функцию, то получите те же результаты, что и раньше:
>>>
  >>> convert_inches_to_feet (450)
450 дюймов = 37 футов и 6 дюймов

>>> convert_inches_to_feet_updated (450)
450 дюймов = 37 футов и 6 дюймов
  
 Вы получите тот же результат, но теперь код более лаконичный. Вы также можете обновить  convert_minutes_to_days () :
  def convert_minutes_to_days_updated (total_mins):
    дней, extra_minutes = divmod (total_mins, 1440)
    часы, минуты = divmod (extra_minutes, 60)

    print (f "{total_mins} = {дней} дней, {часов} часов и {минут} минут")
  
 При использовании  divmod ()  функция легче читается, чем предыдущая версия, и возвращает тот же результат:
>>>
  >>> convert_minutes_to_days (1503)
1503 = 1 день, 1 час и 3 минуты

>>> convert_minutes_to_days_updated (1503)
1503 = 1 день, 1 час и 3 минуты
  
 Использование  divmod ()  не обязательно для всех ситуаций, но здесь имеет смысл, поскольку при расчетах преобразования единиц используется как деление по этажам, так и по модулю.
 Теперь, когда вы узнали, как использовать оператор по модулю для преобразования единиц, в следующем разделе вы узнаете, как можно использовать оператор по модулю для проверки простых чисел.
 Как определить, является ли число простым числом 
 В следующем примере вы увидите, как можно использовать оператор Python по модулю, чтобы проверить, является ли число простым числом  . Простое число - это любое число, которое содержит только два множителя:  1  и само себя. Некоторые примеры простых чисел:  2 ,  3 ,  5 ,  7 ,  23 ,  29 ,  59 ,  83  и  97 .
 Код ниже представляет собой реализацию для определения простоты числа с помощью оператора по модулю:
  def check_prime_number (число):
    если число <2:
        print (f "{число} должно быть больше или равно 2, чтобы быть простым.")
        возвращение

    факторы = [(1, число)]
    я = 2

    в то время как я * я <= число:
        если num% i == 0:
            Factors.append ((i, num // i))
        я + = 1

    если len (факторы)> 1:
        print (f "{число} не является простым. Имеет следующие множители: {факторы}")
    еще:
        print (f "{num} - простое число")
  
 Этот код определяет  check_prime_number () , который принимает параметр  num  и проверяет, является ли это простым числом.Если это так, то отображается сообщение о том, что  num  - простое число. Если это не простое число, отображается сообщение со всеми множителями числа.
  Примечание:  Приведенный выше код не самый эффективный способ проверки простых чисел. Если вы хотите копнуть глубже, посмотрите на Сито Эратосфена и Сито Аткина, где можно найти примеры более эффективных алгоритмов поиска простых чисел.
 Прежде чем вы внимательно посмотрите на функцию, вот результаты с использованием некоторых других чисел:
>>>
  >>> check_prime_number (44)
44 не простое.Он имеет следующие факторы: [(1, 44), (2, 22), (4, 11)]

>>> check_prime_number (53)
53 - простое число

>>> check_prime_number (115)
115 не простое. Он имеет следующие факторы: [(1, 115), (5, 23)]

>>> check_prime_number (997)
997 - простое число
  
 Углубившись в код, вы увидите, что он начинается с проверки, меньше ли  num   2 . Простые числа могут быть не более  2 . Если  число  меньше  2 , то выполнение функции не требуется.Он будет  print ()  сообщение и  вернет :
 , если число <2:
    print (f "{число} должно быть больше или равно 2, чтобы быть простым.")
    возвращение
  
 Если  num  больше  2 , то функция проверяет, является ли  num  простым числом. Чтобы проверить это, функция перебирает все числа от  2  до квадратного корня из  num , чтобы увидеть, делятся ли они на  num  равномерно. Если одно из чисел делится равномерно, значит, был найден множитель, и  num  не может быть простым числом.
 Вот основная часть функции:
  факторов = [(1, число)]
я = 2

в то время как я * я <= число:
    если num% i == 0:
        Factors.append ((i, num // i))
    я + = 1
  
 Здесь есть что распаковать, так что давайте рассмотрим это шаг за шагом.
 Сначала создается список из  факторов  с начальными факторами  (1, число) . Этот список будет использоваться для хранения любых других найденных факторов:
 Затем, начиная с  2 , код увеличивается на  i , пока не достигнет квадратного корня из  num .На каждой итерации он сравнивает  num  с  i , чтобы увидеть, делится ли оно без остатка. В коде нужно только проверить квадратный корень из  num  включительно, потому что он не будет содержать никаких множителей выше этого:
  я = 2

в то время как я * я <= число:
    если num% i == 0:
        Factors.append ((i, num // i))
    я + = 1
  
 Вместо того, чтобы пытаться определить квадратный корень из  num , функция использует цикл  while , чтобы проверить, является ли  i * i <= num .Пока  i * i <= num , цикл не достиг квадратного корня из  num .
 Внутри цикла  while  оператор по модулю проверяет, делится ли  num  без остатка на  i :
  факторов = [(1, число)]
i = 2 # Начать начальный индекс с 2

в то время как я * я <= число:
    если num% i == 0:
        Factors.append ((i, num // i))
    я + = 1
  
 Если  число  делится без остатка на  i , то  i  является множителем  число , и кортеж множителей добавляется к списку  множителей .
 После завершения цикла  и  код проверяет, были ли найдены какие-либо дополнительные факторы:
 , если len (факторы)> 1:
    print (f "{число} не является простым. Имеет следующие множители: {факторы}")
еще:
    print (f "{num} - простое число")
  
 Если в списке  факторов  существует более одного кортежа, то  num  не может быть простым числом. Для непростых чисел коэффициенты распечатываются. Для простых чисел функция выводит сообщение о том, что  num  - простое число.
 Как реализовать шифры 
 Оператор модуля Python может использоваться для создания шифров. Шифр - это тип алгоритма для выполнения шифрования и дешифрования входных данных, обычно текста. В этом разделе вы познакомитесь с двумя шифрами: шифром Цезаря   и шифром Виженера  .
 Цезарь Шифр ​​
 Первый шифр, на который вы посмотрите, - это шифр Цезаря, названный в честь Юлия Цезаря, который использовал его для тайной передачи сообщений.Это шифр подстановки, который использует подстановку букв для шифрования строки текста.
 Шифр ​​Цезаря работает, беря букву, которую нужно зашифровать, и сдвигая ее на определенное количество позиций влево или вправо в алфавите. Какая бы буква ни была в этой позиции, используется как зашифрованный символ. Это же значение сдвига применяется ко всем символам в строке.
 Например, если сдвиг был  5 , то  A  сместился бы на пять букв вверх и стал бы  F ,  B  стал бы  G  и так далее.Ниже вы можете увидеть процесс шифрования текста  REALPYTHON  со сдвигом  5 :
 В результате получается шифр  WJFQUDYMTS .
 Расшифровка шифра выполняется реверсированием сдвига. Процессы шифрования и дешифрования можно описать следующими выражениями, где  char_index  - это индекс символа в алфавите:
  encrypted_char_index = (char_index + shift)% 26
decrypted_char_index = (char_index - сдвиг)% 26
  
 Этот шифр использует оператор по модулю, чтобы гарантировать, что при сдвиге буквы индекс будет повторяться, если будет достигнут конец алфавита.Теперь, когда вы знаете, как работает этот шифр, взгляните на его реализацию:
  строка импорта

def caesar_cipher (текст, сдвиг, дешифрование = False):
    если не text.isascii () или не text.isalpha ():
        Raise ValueError ("Текст должен быть в формате ASCII и не содержать чисел.")

    нижний регистр = строка.ascii_lowercase
    верхний регистр = строка.ascii_uppercase
    результат = ""

    если расшифровать:
        сдвиг = сдвиг * -1

    для символа в тексте:
        если char.islower ():
            index = lowercase.index (char)
            результат + = нижний регистр [(индекс + сдвиг)% 26]
        еще:
            index = прописные буквы.индекс (символ)
            результат + = верхний регистр [(индекс + сдвиг)% 26]

    вернуть результат
  
 Этот код определяет функцию  caesar_cipher () , которая имеет два обязательных параметра и один необязательный параметр:
   текст   - это текст, который нужно зашифровать или расшифровать.
   сдвиг   - количество позиций для сдвига каждой буквы.
   decrypt   - логическое значение, которое задает, нужно ли расшифровывать  text .
  decrypt  включен, чтобы можно было использовать одну функцию для обработки как шифрования, так и дешифрования. Эта реализация может обрабатывать только буквенные символы, поэтому функция сначала проверяет, является ли  текст  буквенным символом в кодировке ASCII:
  def caesar_cipher (text, shift, decrypt = False):
    если не text.isascii () или не text.isalpha ():
        Raise ValueError ("Текст должен быть в формате ASCII и не содержать чисел.")
  
 Затем функция определяет три переменные для хранения  строчных  символов ASCII,  прописных  символов ASCII и результатов шифрования или дешифрования:
  нижний регистр = строка.ascii_lowercase # "abcdefghijklmnopqrstuvwxyz"
uppercase = string.ascii_uppercase # "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
результат = ""
  
 Затем, если функция используется для дешифрования  текста , она умножает  shift  на -1 , чтобы сдвинуть назад:
  если расшифровать:
    сдвиг = сдвиг * -1
  
 Наконец,  caesar_cipher ()  перебирает отдельные символы в  тексте  и выполняет следующие действия для каждого  char :
 Проверьте, является ли  char  строчными или прописными буквами.
 Получить индекс   из  символов  в списках  строчных  или  прописных  ASCII.
 Добавьте сдвиг   к этому индексу  , чтобы определить индекс используемого зашифрованного символа.
 Используйте % 26 , чтобы убедиться, что сдвиг вернется к началу алфавита.
 Добавить зашифрованный символ к строке результата  .
 После того, как цикл завершает итерацию по значению  текста , возвращается результат  :
  для символов в тексте:
    если char.islower ():
        index = lowercase.index (char)
        результат + = нижний регистр [(индекс + сдвиг)% 26]
    еще:
        index = uppercase.index (символ)
        результат + = верхний регистр [(индекс + сдвиг)% 26]

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

def caesar_cipher (текст, сдвиг, дешифрование = False):
    если не text.isascii () или не text.isalpha ():
        Raise ValueError ("Текст должен быть в формате ASCII и не содержать чисел.")

    нижний регистр = строка.ascii_lowercase
    прописные буквы = строка.ascii_uppercase
    результат = ""

    если расшифровать:
        сдвиг = сдвиг * -1

    для символа в тексте:
        если char.islower ():
            index = lowercase.index (char)
            результат + = нижний регистр [(индекс + сдвиг)% 26]
        еще:
            index = uppercase.index (символ)
            результат + = верхний регистр [(индекс + сдвиг)% 26]

    вернуть результат
  
 Теперь запустите код в Python REPL, используя текст  meetMeAtOurHideOutAtTwo  со сдвигом  10 :
>>>
  >>> caesar_cipher ("meetMeAtOurHideOutAtTwo", 10)
woodWoKdYebRsnoYedKdDgy
  
 Зашифрованный результат:  woodWoKdYebRsnoYedKdDgy .Используя этот зашифрованный текст, вы можете запустить расшифровку, чтобы получить исходный текст:
>>>
  >>> caesar_cipher ("woodWoKdYebRsnoYedKdDgy", 10, decrypt = True)
MeetMeAtOurHideOutAtTwo
  
 С шифром Цезаря интересно поиграть для введения в криптографию. Хотя шифр Цезаря редко используется сам по себе, он является основой для более сложных подстановочных шифров. В следующем разделе вы познакомитесь с одним из потомков шифра Цезаря, шифром Виженера.
 Шифр ​​Виженера 
 Шифр ​​Виженера представляет собой полиалфавитный замещающий шифр. Для шифрования он использует разные шифры Цезаря для каждой буквы входящего текста. Шифр Виженера использует ключевое слово, чтобы определить, какой шифр Цезаря следует использовать для поиска буквы шифра.
 Вы можете увидеть пример процесса шифрования на следующем изображении. В этом примере входной текст  REALPYTHON  зашифрован с использованием ключевого слова  MODULO :
 Для каждой буквы входящего текста,  REALPYTHON , используется буква из ключевого слова  MODULO , чтобы определить, какой столбец шифра Цезаря следует выбрать.Если ключевое слово короче вводимого текста, как в случае с  MODULO , то буквы ключевого слова повторяются до тех пор, пока все буквы вводимого текста не будут зашифрованы.
 Ниже представлена ​​реализация шифра Виженера. Как вы увидите, оператор по модулю используется в функции дважды:
  строка импорта

def vigenere_cipher (текст, ключ, decrypt = False):
    если не text.isascii () или не text.isalpha () или не text.isupper ():
        Raise ValueError ("Текст должен быть в верхнем регистре ASCII без цифр.")

    uppercase = string.ascii_uppercase # "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    результаты = ""

    для i, символ в перечислении (текст):
        current_key = ключ [i% len (ключ)]
        char_index = uppercase.index (символ)
        key_index = uppercase.index (текущий_ключ)

        если расшифровать:
            index = char_index - key_index + 26
        еще:
            index = char_index + key_index

        результаты + = верхний регистр [индекс% 26]

    вернуть результаты
  
 Вы могли заметить, что подпись для  vigenere_cipher ()  очень похожа на  caesar_cipher ()  из предыдущего раздела:
  def vigenere_cipher (текст, ключ, decrypt = False):
    если не текст.isascii () или не text.isalpha () или не text.isupper ():
        Raise ValueError ("Текст должен быть в верхнем регистре ASCII без цифр.")

    верхний регистр = строка.ascii_uppercase
    результаты = ""
  
 Основное отличие состоит в том, что вместо параметра  shift ,  vigenere_cipher ()  принимает параметр  key , который является ключевым словом, используемым во время шифрования и дешифрования. Еще одно отличие - добавление  text.isupper () . На основе этой реализации  vigenere_cipher ()  может принимать только вводимый текст в верхнем регистре.
 Подобно  caesar_cipher () ,  vigenere_cipher ()  выполняет итерацию по каждой букве входного текста, чтобы зашифровать или расшифровать его:
  для i, символ в перечислении (текст):
    current_key = ключ [i% len (ключ)]
  
 В приведенном выше коде вы можете увидеть, как функция впервые использовала оператор по модулю:
  current_key = ключ [i% len (ключ)]
  
 Здесь значение  current_key  определяется на основе индекса, возвращенного из  i% len (key) .Этот индекс используется для выбора буквы из строки  ключа , например  M  из  MODULO .
 Оператор по модулю позволяет использовать ключевое слово любой длины независимо от длины шифруемого текста  . Как только индекс  i , индекс символа, который в настоящее время зашифрован, равен длине ключевого слова, он начнется с начала ключевого слова.
 Для каждой буквы входящего текста несколько шагов определяют, как ее зашифровать или расшифровать:
 Определите  char_index  на основе индекса  char  внутри  прописных букв .
 Определите  key_index  на основе индекса  current_key  внутри  в верхнем регистре .
 Используйте  char_index  и  key_index , чтобы получить индекс для зашифрованного или дешифрованного символа.
 Взгляните на эти шаги в приведенном ниже коде:
  char_index = uppercase.index (char)
key_index = uppercase.index (текущий_ключ)

если расшифровать:
    index = char_index - key_index + 26
еще:
    index = char_index + key_index
  
 Как видите, индексы для расшифровки и шифрования рассчитываются по-разному.Поэтому в этой функции используется  дешифровать . Таким образом, вы можете использовать эту функцию как для шифрования, так и для дешифрования.
 После определения индекса   вы обнаружите, что функция использует второй оператор по модулю:
  результатов + = верхний регистр [индекс% 26]
  
  index% 26  гарантирует, что  index  символа не превышает  25 , таким образом гарантируя, что он остается внутри алфавита. С помощью этого индекса зашифрованный или дешифрованный символ выбирается из  прописных  и добавляется к  результатам .
 Вот еще раз полный код шифра Виженера:
  строка импорта

def vigenere_cipher (текст, ключ, decrypt = False):
    если не text.isascii () или не text.isalpha () или не text.isupper ():
        Raise ValueError ("Текст должен быть в верхнем регистре ASCII без цифр.")

    uppercase = string.ascii_uppercase # "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    результаты = ""

    для i, символ в перечислении (текст):
        current_key = ключ [i% len (ключ)]
        char_index = uppercase.index (символ)
        key_index = прописные буквы.индекс (текущий_ключ)

        если расшифровать:
            index = char_index - key_index + 26
        еще:
            index = char_index + key_index

        результаты + = верхний регистр [индекс% 26]

    вернуть результаты
  
 Теперь запустите его в Python REPL:
>>>
  >>> vigenere_cipher (text = "REALPYTHON", key = "MODULO")
DSDFAMFVRH

>>> encrypted = vigenere_cipher (text = "REALPYTHON", key = "MODULO")
>>> печать (в зашифрованном виде)
DSDFAMFVRH

>>> vigenere_cipher (зашифровано, "MODULO", decrypt = True)
РЕАЛПИТОН
  
 Отлично! Теперь у вас есть рабочий шифр Виженера для шифрования текстовых строк.
 Python: расширенный оператор по модулю использует 
 В этом заключительном разделе вы поднимете свои знания об операторах по модулю на новый уровень, используя их с десятичным числом . Десятичное число . Вы также узнаете, как добавить  .__ mod __ ()  к своим пользовательским классам, чтобы их можно было использовать с оператором по модулю.
 Использование оператора Python по модулю с десятичным числом 
. Десятичное число 
 Ранее в этом руководстве вы видели, как можно использовать оператор по модулю с числовыми типами, такими как  int  и  float , а также с  math.fmod () . Вы также можете использовать оператор по модулю с  Decimal  из модуля  decimal . Вы используете десятичное число . Десятичное число  используется, когда требуется дискретный контроль точности арифметических операций с плавающей запятой.
 Вот несколько примеров использования целых чисел с десятичным числом . Десятичное число  и оператор по модулю:
>>>
  >>> импортировать десятичный
>>> десятичное.Десятичное (15)% десятичное.Десятичное (4)
Десятичный ('3')

>>> десятичный.Десятичный (240)% десятичный. Десятичный (13)
Десятичный ('6')
  
 Вот некоторые числа с плавающей запятой, используемые с десятичным числом . Десятичное число  и оператор по модулю:
>>>
  >>> decimal.Decimal ("12,5")% decimal.Decimal ("5.5")
Десятичный ('1,5')

>>> decimal.Decimal ("13.3")% decimal.Decimal ("1.1")
Десятичный ('0,1')
  
 Все операции по модулю с десятичным числом . Десятичное число  возвращает те же результаты, что и другие числовые типы, за исключением случаев, когда один из операндов отрицательный.В отличие от  int  и  float , но, как и  math.fmod () ,  decimal. Decimal  использует знак делимого для результатов.
 Взгляните на приведенные ниже примеры, в которых сравниваются результаты использования оператора по модулю со стандартными значениями  int  и  с плавающей запятой  и с десятичным числом . Десятичное :
>>>
  >>> -17% 3
1 # Знак делителя

>>> десятичное.Десятичное (-17)% десятичное.Десятичное (3)
Десятичный (-2) # Знак дивиденда

>>> 17% -3
-1 # Знак делителя

>>> десятичный.Десятичный (17)% десятичный. Десятичный (-3)
Десятичный ("2") # Знак дивиденда

>>> -13,3% 1,1
1.0000000000000004 # Знак делителя

>>> decimal.Decimal ("- 13,3")% decimal.Decimal ("1,1")
Десятичный ("- 0,1") # Знак дивиденда
  
 По сравнению с  math.fmod () ,  десятичное. Десятичное число  будет иметь тот же знак, но точность будет другой:
>>>
  >>> decimal.Decimal ("- 13,3")% decimal.Decimal ("1,1")
Десятичный ("- 0,1")

>>> математика.fmod (-13,3, 1,1)
-0,09999999999999964
  
 Как видно из приведенных выше примеров, работа с десятичным числом , десятичным числом  и оператором по модулю аналогична работе с другими числовыми типами. Просто нужно иметь в виду, как он определяет знак результата при работе с отрицательным операндом.
 В следующем разделе вы узнаете, как можно переопределить оператор по модулю в своих классах, чтобы настроить его поведение.
 Использование оператора Python Modulo с настраиваемыми классами 
 Модель данных Python позволяет вам переопределить встроенные методы в объекте Python, чтобы настроить его поведение.В этом разделе вы узнаете, как переопределить  .__ mod __ () , чтобы вы могли использовать оператор по модулю со своими собственными классами.
 В этом примере вы будете работать с классом  Студент . Этот класс будет отслеживать количество времени, которое студент учился. Вот начальный номер . Студент  класса:
.
  класс Студент:
    def __init __ (я, имя):
        self.name = имя
        self.study_sessions = []

    def add_study_sessions (самостоятельно, сеансы):
        себя.study_sessions + = сеансы
  
 Класс  Student  инициализируется параметром  name  и начинается с пустого списка  study_sessions , который будет содержать список целых чисел, представляющих количество минут, изученных за сеанс. Также существует  .add_study_sessions () , который принимает параметр  sessions , который должен быть списком учебных сессий, который нужно добавить к  study_sessions .
 Теперь, если вы помните из приведенного выше раздела о преобразовании единиц,  convert_minutes_to_day ()  использовал оператор Python по модулю для преобразования  total_mins  в дни, часы и минуты.Теперь вы реализуете модифицированную версию этого метода, чтобы увидеть, как можно использовать свой собственный класс с оператором по модулю:
  def total_study_time_in_hours (студент, всего_мин.):
    часы = total_mins // 60
    минут = total_mins% 60

    print (f "{student.name} изучил {часы} часы и {минуты} минуты")
  
 Эту функцию можно использовать с классом  Студент , чтобы отобразить общее количество часов, которое изучил  Студент . В сочетании с классом  Student , приведенным выше, код будет выглядеть следующим образом:
  класс Студент:
    def __init __ (я, имя):
        себя.name = имя
        self.study_sessions = []

    def add_study_sessions (самостоятельно, сеансы):
        self.study_sessions + = сеансы

def total_study_time_in_hours (студент, total_mins):
    часы = total_mins // 60
    минут = total_mins% 60

    print (f "{student.name} изучил {часы} часы и {минуты} минуты")
  
 Если вы загрузите этот модуль в Python REPL, то можете использовать его так:
>>>
  >>> jane = Студент ("Джейн")
>>> jane.add_study_sessions ([120, 30, 56, 260, 130, 25, 75])
>>> total_mins = сумма (джейн.study_sessions)
>>> total_study_time_in_hours (Джейн, всего_минут)
Джейн занималась 11 часов 36 минут
  
 Приведенный выше код распечатывает общее количество часов обучения:  jane . Эта версия кода работает, но требует дополнительного шага суммирования  study_sessions , чтобы получить  total_mins  перед вызовом  total_study_time_in_hours () .
 Вот как можно изменить класс  Student , чтобы упростить код:
  класс Студент:
    def __init __ (я, имя):
        себя.name = имя
        self.study_sessions = []

    def add_study_sessions (самостоятельно, сеансы):
        self.study_sessions + = сеансы

    def __mod __ (сам, другое):
        возвратная сумма (self.study_sessions)% other

    def __floordiv __ (я, другой):
        возвратная сумма (self.study_sessions) // другое
  
 Переопределив  .__ mod __ ()  и  .__ floordiv __ () , вы можете использовать экземпляр  Student  с оператором по модулю. Вычисление суммы  ()  из  study_sessions  также включен в класс  Student .
 С этими изменениями вы можете использовать экземпляр  Student  непосредственно в  total_study_time_in_hours () . Поскольку  total_mins  больше не требуется, вы можете удалить его:
  def total_study_time_in_hours (студент):
    часы = студент // 60
    минут = студент% 60

    print (f "{student.name} изучил {часы} часы и {минуты} минуты")
  
 Вот полный код после изменений:
  класс Студент:
    def __init __ (я, имя):
        себя.name = имя
        self.study_sessions = []

    def add_study_sessions (самостоятельно, сеансы):
        self.study_sessions + = сеансы

    def __mod __ (сам, другое):
        возвратная сумма (self.study_sessions)% other

    def __floordiv __ (я, другой):
        возвратная сумма (self.study_sessions) // другое

def total_study_time_in_hours (студент):
    часы = студент // 60
    минут = студент% 60

    print (f "{student.name} изучил {часы} часы и {минуты} минуты")
  
 Теперь, вызвав код в Python REPL, вы увидите, что он гораздо лаконичнее:
>>>
  >>> jane = Студент ("Джейн")
>>> Джейн.add_study_sessions ([120, 30, 56, 260, 130, 25, 75])
>>> total_study_time_in_hours (Джейн)
Джейн занималась 11 часов 36 минут
  
 Переопределяя  .__ mod __ () , вы позволяете своим пользовательским классам вести себя больше как встроенные числовые типы Python.
 Заключение 
 На первый взгляд, оператор по модулю Python может не привлечь ваше внимание. Тем не менее, как вы видели, в этом скромном операторе есть так много всего. От проверки четных чисел до шифрования текста - вы видели множество различных применений оператора по модулю.
  Из этого руководства вы узнали, как: 
 Используйте оператор по модулю   с  int ,  float ,  math.fmod () ,  divmod ()  и  decimal. Decimal 
 Вычислить результаты операции по модулю  
 Решите  реальных задач  с помощью оператора по модулю
 Переопределить   .__ mod __ ()   в ваших собственных классах, чтобы использовать их с оператором по модулю
 Знания, полученные в этом руководстве, позволяют теперь с большим успехом начать использовать оператор по модулю в собственном коде.Удачного питонинга!
 Python-номеров 
 Python-числа 
 В Python есть три числовых типа:
 Переменные числовых типов создаются при присвоении им значения:
 Пример 
 х = 1
 # int 
 y = 2.8 # float 
 z = 1j # сложный
 Чтобы проверить тип любого объекта в Python, используйте функцию  type () :
 Внутр. 
 Int или целое число - это целое число,
 положительное или отрицательное, без десятичных знаков, неограниченной длины.
 Пример 
 Целые числа:
х = 1 
 у = 35656222554887711 
 г =
 -3255522
 печать (тип (x)) 
 печать (тип (y)) 
 печать (тип (z))
Попробуй сам "
 Поплавок 
 Число с плавающей запятой или «число с плавающей запятой» - это число, положительное или отрицательное, содержащее один или несколько десятичных знаков.
 Пример 
 Поплавки:
x = 1,10 
 y = 1,0 
 z = -35,59
 print (type (x)) 
 print (type (y)) 
 print (type (z))
Попробуй сам "
 Float также может быть научным числом с буквой "e" для обозначения степени 10.
 Пример 
 Поплавки:
 x = 35e3 
 y = 12E4 
 z = -87.7e100
 print (type (x)) 
 print (type (y)) 
 print (type (z))
Попробуй сам "
 Комплекс 
 Комплексные числа записываются с буквой j в качестве мнимой части:
 Пример 
 Комплекс:
 x = 3 + 5j 
 y = 5j 
 z = -5j
 print (type (x)) 
 print (type (y)) 
 print (type (z))
Попробуй сам "
 Преобразование типа 
 Вы можете преобразовать один тип в другой с помощью  int () ,
  float ()  и  complex ()  методов:
 Пример 
 Преобразование из одного типа в другой:
 х = 1 # целое 
 у = 2.8 # float 
 z = 1j # complex
 # преобразование из int в float: 
 a = float (x)
 # преобразование из float в int: 
 b = int (y)
 # преобразование из int в сложное: 
 c = сложная (x)
 печать (a) 
 печать (b) 
 печать (c)
 печать (тип (a)) 
 печать (тип (b)) 
 печать (тип (c))
Попробуй сам "
  Примечание:  Комплексные числа нельзя преобразовать в числа другого типа.
 Случайное число 
 Python не имеет функции  random ()  для
 сделать случайное число, но в Python есть встроенный модуль, называемый
  случайных , которые можно использовать для получения случайных чисел:
 Пример 
 Импортировать случайный модуль и отображать случайное число от 1 до 9:
 импортировать случайный отпечаток
 (random.randrange (1, 10))
Попробуй сам "
 В нашем справочнике по произвольному модулю вы узнаете больше о модуле «Случайный выбор».
 Математический модуль Python 
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
 Метод
 Описание
 math.acos ()
 Возвращает арккосинус числа
 math.acosh ()
 Возвращает обратный гиперболический косинус числа
 math.asin ()
 Возвращает арксинус числа
 математ.asinh ()
 Возвращает обратный гиперболический синус числа
 math.atan ()
 Возвращает арктангенс числа в радианах
 math.atan2 ()
 Возвращает арктангенс y / x в радианах.
 math.atanh ()
 Возвращает обратный гиперболический тангенс числа
 math.ceil ()
 Округляет число до ближайшего целого
 математ.расческа ()
 Возвращает количество способов выбрать k элементов из n элементов без повторения и порядка
 math.copysign ()
 Возвращает число с плавающей запятой, состоящее из значения первого параметра и знака второго параметра.
 math.cos ()
 Возвращает косинус числа
 math.cosh ()
 Возвращает гиперболический косинус числа
 математ.градусы ()
 Преобразует угол из радиан в градусы
 math.dist ()
 Возвращает евклидово расстояние между двумя точками (p и q), где p и
 q - координаты этой точки
 math.erf ()
 Возвращает функцию ошибки числа
 math.erfc ()
 Возвращает дополнительную функцию ошибки числа
 math.exp ()
 Возвращает E в степени x
 математ.ехр1 ()
 Возврат E  x 
 - 1
 math.fabs ()
 Возвращает абсолютное значение числа
 math.factorial ()
 Возвращает факториал числа
 math.floor ()
 Округляет число до ближайшего целого
 math.fmod ()
 Возвращает остаток от x / y
 math.frexp ()
 Возвращает мантиссу и показатель степени указанного числа
 математ.fsum ()
 Возвращает сумму всех элементов в любой итерации (кортежи, массивы, списки и т. Д.).
 math.gamma ()
 Возвращает гамма-функцию в x
 math.gcd ()
 Возвращает наибольший общий делитель двух целых чисел
 math.hypot ()
 Возвращает евклидову норму
 math.isclose ()
 Проверяет, близки ли два значения друг к другу или нет
 математ.isfinite ()
 Проверяет, является ли число конечным
 math.isinf ()
 Проверяет, является ли число бесконечным
 math.isnan ()
 Проверяет, является ли значение NaN (не числом) или нет
 math.isqrt ()
 Округляет квадратный корень в меньшую сторону до ближайшего целого
 math.ldexp ()
 Возвращает значение, обратное math.frexp ().
 что является x * (2 ** i) заданных чисел x и i
 математ.lgamma ()
 Возвращает логарифмическое значение гаммы x
 math.log ()
 Возвращает натуральный логарифм числа или логарифм числа по основанию
 math.log10 ()
 Возвращает десятичный логарифм числа
 math.log1p ()
 Возвращает натуральный логарифм 1 + x
 math.log2 ()
 Возвращает логарифм по основанию 2 x
 математ.Пермь ()
 Возвращает количество способов выбрать k элементов из n элементов с порядком и без повторения
 math.pow ()
 Возвращает значение x в степени y
 math.prod ()
 Возвращает произведение всех элементов в итерации
 математические радианы ()
 Преобразует значение градуса в радианы
 математический остаток ()
 Возвращает ближайшее значение, при котором числитель полностью делится на знаменатель.
 математ.грех ()
 Возвращает синус числа
 math.sinh ()
 Возвращает гиперболический синус числа
 math.sqrt ()
 Возвращает квадратный корень из числа
 math.tan ()
 Возвращает тангенс числа
 math.tanh ()
 Возвращает гиперболический тангенс числа
 math.trunc ()
 Возвращает усеченные целые части числа
 Python Numbers - GeeksforGeeks 
 Числовые типы данных хранят числовые значения.Это неизменяемые типы данных, что означает, что изменение значения числового типа данных приводит к появлению нового выделенного объекта.
 Различные типы числовых данных:
 Давайте посмотрим на каждый из них:
 Тип Int 
 int (Целые числа)   - это целое число, включая отрицательные числа, но не дроби. В Python нет ограничений на длину целочисленного значения.
  Пример 1:  Создание типа int и проверки
 Python3 
  число   =   -   8 
   тип num)) 
  Вывод: 
  
  Пример 2:  Выполнение арифметических операций с типом int
 Python3 
327
   5 
  b   =   6 
  c   =   a   +   b 
  c  , печать   ) 
  d   =   9 
  e   =   6 
 900 03
  f   =   d   -   e 
  печать   (  "Вычитание:"  , f) 
        
 
  h   =   2 
  i   =   g  / /  h 
       печать   ) 
  j   =   3 
  k   =   5 
  l   =    k          (  "Умножение:"  , l) 
  m   =   25 
  n   = 900 07  5 
  o   =   м  %   n 
  печать   (  "Модуль упругости:"
000
000
000 ,    =   6 
  q   =   2 
  r   =   p   *   *      Показатель степени: " , r) 
  Выход: 
 Сложение: 11
Вычитание: 3
Дивизион: 4
Умножение: 15
Модуль: 0
Экспонента: 36 
 Тип с плавающей запятой 
 Это действительное число с представлением с плавающей запятой.Он обозначается десятичной точкой. По желанию, можно добавить символ e или E, за которым следует положительное или отрицательное целое число, чтобы указать научную нотацию. . Вот некоторые примеры чисел, представленных как числа с плавающей запятой: 0,5 и -7,823457.
 Их можно создать напрямую, введя число с десятичной точкой или используя такие операции, как деление на целые числа. Лишние нули в конце номера автоматически игнорируются.
  Пример 1:  Создание типа с плавающей запятой и проверки
 Python3 
  число   =   3  /  4 
  000 000 000 печать  000 (num)) 
  Вывод: 
  
 Как мы видели, деление любых двух целых чисел дает число с плавающей запятой.
 Число с плавающей запятой также создается путем выполнения операции над двумя числами с плавающей запятой или над числом с плавающей запятой и целым числом.
 Python3 
  число   =   6   *   7,0 
  печать   (
3 
  935
 
 
  
   Вывод: 
  
  Пример 2:  Выполнение арифметических операций над типом float
 Python3 
  a   =   5.5 
  b   =   3,2 
  c   =   a   +   b 
  print  ,   " 
  c   =   a   -   b 
  печать   (  "Вычитание:"  , c)          a  /  b 
  print   (  "Подразделение:"  , c) 
  c   =   a   *   *     (  "Умножение:"  , c) 
  Выход 
 Сложение: 8.7
Вычитание: 2.3
Подразделение: 1.71875
Умножение: 17,6 
  Примечание:  Точность числа с плавающей запятой составляет только до 15 десятичных знаков, 16-е место может быть неточным.
 Комплексный тип 
 Комплексное число - это число, состоящее из действительной и мнимой частей. Например, 2 + 3j - комплексное число, где 2 - действительный компонент, а 3, умноженный на j, - мнимая часть.
  Пример 1:  Создание комплекса и проверка типа
 Python3 
  число   =   6   +   9j 
  000 000 000 000 (число)) 
  Вывод: 
  
  Пример 2:  Выполнение арифметических операций над комплексным типом
 Python3 
000
6
   1   +   5j 
  b   =   2   +   3j 
  c  000 000  =     (  «Дополнение:»  , c) 
  d   =  9000 6 1   +   5j 
  e   =   2   -   3j 
  f   =              (  "Вычитание:"  , f) 
  g   =   1   +   5j 
          3j 
  i   =   g  /  h 
  печать   (  "Подразделение:"  , i)   j)  
 =   1   +   5j 
  k   =   2   +   3j 
  l   =   j   *   k 
  print   (  "Умножение:"  , l) 
6 903 3 + 8j)
 Вычитание: (-1 + 8j)
 Подразделение: (1.3076
6
 + 0,5384615384615384j)
 Умножение: (-13 + 13j)
 Преобразование типов между числами 
 Мы можем преобразовать одно число в другую форму двумя способами:
  Использование арифметических операций:  Мы можем использовать такие операции, как сложение, вычитание для изменения тип числа неявно (автоматически), если один из операндов является плавающим. Этот метод не работает для комплексных чисел.
  Пример:  Преобразование типов с использованием арифметических операций
 Python3 
  a   =   1.6 
  b   =   5 
  c   =   a   +   b 
335 c
36  Вывод: 
 6,6 
  Использование встроенных функций:  Мы также можем использовать встроенные функции, такие как int (), float () и complex (), для явного преобразования в разные типы.
  Пример:  Преобразование типа с использованием встроенных функций
 Python3 
  a   =   2 
  печать   (
000)  с плавающей запятой 9000
  b   =   5.6 
  print   (  int   (b)) 
  c   =   '3' 
  print   (0006 тип    (c))) 
  d   =   '5.6' 
  print   (  тип   (  float )  (c)
)  (c)
  e   =   5 
  печать   (  комплексный   (e)) 
  f   =   6.5 
  печать   (  комплексная   (f)) 
  Выход: 
 2,0
5
<класс 'int'>
<класс 'float'>
(5 + 0j)
(6.5 + 0j) 
 Когда мы конвертируем float в int, десятичная часть обрезается.
  Примечание: 
 Мы не можем преобразовать номер сложного типа данных в числа типа данных int и числа с плавающей запятой.
 Мы не можем применять сложные встроенные функции к строкам.
 Десятичные числа в Python 
 Арифметические операции с плавающим числом могут дать неожиданные результаты. Давайте рассмотрим случай, когда мы хотим добавить 1,1 к 2,2. Вам всем должно быть интересно, что результат этой операции должен быть 3.3, но давайте посмотрим, что выводит Python.
  Пример: 
 Python3 
  a   =   1,1 
  b   =   2.2 
  c   =   a   +   b 
  печать   (c) 
0000
0000 3 результат неожиданный. Давайте рассмотрим другой случай, когда мы вычтем 1,2 и 1,0. Снова мы ожидаем, что результат будет 0,2, но давайте посмотрим, что выводит Python.
  Пример: 
 Python3 
  a   =   1.2 
  b   =   1.0 
  c   =   a   -   b 
  печать 
000 6 (c) 
000 3 : 
 0,19999999999999996 
 Вы все, должно быть, думаете, что с Python что-то не так, но это не так. Это мало связано с Python и гораздо больше связано с тем, как базовая платформа обрабатывает числа с плавающей запятой.Это нормальный случай, возникающий при внутренней обработке чисел с плавающей запятой. Эта проблема возникает, когда внутреннее представление чисел с плавающей запятой использует фиксированное количество двоичных цифр для представления десятичного числа. Некоторые десятичные числа трудно представить в двоичном формате, поэтому во многих случаях это приводит к небольшим ошибкам округления.
 В этом случае, если взять в качестве примера 1,2, представление 0,2 в двоичном формате будет 0,00110011001100110011001100 …… и так далее. Это бесконечное десятичное число сложно хранить внутри.Обычно значение объекта с плавающей запятой хранится в двоичном формате с плавающей запятой с фиксированной точностью (обычно 53 бита). Таким образом, мы представляем 1,2 внутренне как:
 1,0011001100110011001100110011001100110011001100110011 
, что в точности равно:
 1,1999999999999107
383830547332763671875 
 для таких случаев. Как указывалось ранее, точность числа с плавающей запятой составляет только до 15 знаков, но в десятичном числе точность определяется пользователем.Он выполняет операции с числами с плавающей запятой так же, как мы учились в школе. Давайте посмотрим на два приведенных выше примера и попробуем решить их, используя десятичное число.
  Пример: 
 Python3 
3 десятичный модуль для случаев - 
 Когда мы хотим определить требуемую точность самостоятельно
 Для финансовых приложений, которым требуются точные десятичные представления
  Примечание:  Для получения дополнительной информации о десятичных числах в Python и Функции, предоставляемые этим модулем, см. в разделе Десятичные функции в Python
 Случайные числа в Python 
 Python предоставляет модуль случайных чисел для генерации псевдослучайных чисел.Этот модуль может создавать случайные числа, выбирать случайный элемент из последовательности в Python и т. Д.
  Пример 1:  Создание случайного значения
 Python3 
  импорт   десятичный 
  a   =   десятичный. Десятичный (           =   в десятичной системе.Десятичный (  '2.2'  ) 
  c   =   a   +   b 
  печать   (c) 
5
  импорт   случайный 
  печать   (random.random ()) 
  Пример 2:  Выбор случайного элемента из строки или списка
 Python3 
  import   random 
  =   'geeksforgeeks' 
  L   =   [  1  ,   2  ,   3  ,            7  ,   7  ,   8  ,   0  ] 
 9000 6 print   (случайный.выбор (ы)) 
  печать   (случайный выбор (L)) 
  Примечание:  Для получения дополнительной информации о случайных числах см. наше руководство по случайным числам
 Python Mathematics 
 Математический модуль Python помогает выполнять различные математические операции: тригонометрию, статистику, вероятность, логарифмы и т. Д.
  Пример: 
 Python3 
  импорт   математика 
   =   3.5 
  print   (  "Потолок 3,5:"  , конец   =   "") 
  print   (math.ceil (a) 4)
  print   (  "Пол 3,5 составляет:"  , конец   =   "") 
  print   (math.floor (a)) 
  печать   (  "Значение 3.5 ** 2: " , конец   =  " ") 
  print   (  pow   (a,   2  )) 
  print
  (  "Значение log2 3,5:"  , конец   =   "") 
  печать   (math.log2 (a)) 
  печать  (  "Значение sqrt 3,5:"  , конец   =   "") 
  print   (math.sqrt (a)) 
  print   (  "Значение синуса 3,5:"  , end   =   "") 
  print   (math.s (a)) 
  Выход 
 
 Ceil 3,5 составляет: 4
 Этаж 3.5 составляет: 3
 Значение 3,5 ** 2: 12,25
 Значение log2, равное 3,5: 1.
Добавить комментарий Отменить ответ
Ваш адрес email не будет опубликован. Обязательные поля помечены *
Комментарий *
Имя * 
Email * 
Сайт