Как из модуля вывести число: § Модуль числа. Свойства модуля

Содержание

что это такое и как его найти?

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

Модуль с точки зрения геометрии

Забегая вперед, попробуем сразу понять, что же представляет собой модуль на практике — так будет легче уловить его смысл. Нарисуем на листе бумаги прямую координат, возьмем нуль за точку отсчета, а по правую и по левую стороны на одинаковом расстоянии поставим некие две точки — например, 5 и -5.

Модулем будет считаться именно фактическое расстояние до нуля от -5 и от 5. Очевидно, что это расстояние будет совершенно одинаковым. Поэтому в обоих случаях модуль будет равняться числу «5» — и неважно, какой знак стоит перед исходным числом, которое мы рассматриваем.

Как найти модуль числа?

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

Это можно сформулировать и иначе — модулем любого числа будет само это число в абсолютном выражении, то есть без учета знака. Записывается модуль так — по обе стороны от нужного числа ставятся вертикальные линии, например, модуль для числа «5» будет равен «5», а записываться он будет, как |5|.

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

  • Может ли модуль быть отрицательным? Нет! Модуль может быть только положительным. Даже если речь идет об отрицательном числе, например, -7, то его модуль будет равен |7| — числу, противоположному исходному.
  • Для нуля модуль всегда будет равен нулю. Верно и другое — нуль может быть модулем исключительно в том случае, если вычисляется он для числа нуль, и ни в каком другом.
  • Если нужно найти модуль для выражения типа a*b, то есть модуль произведения, то можно сначала найти модуль а, затем модуль b, и перемножить их друг на друга.
  • То же самое касается и деления — если нам нужно разделить y на z и найти модуль получившегося числа, то можно взять модуль y и разделить его на модуль z. Результат будет одним и тем же.

Похожие статьи

Найти модуль с корнем

Как известно, модуль числа — это его абсолютное значение, без учета знака. Модуль всегда неотрицателен. Это значит, что он может быть равен либо положительному числу, либо нулю.

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

|–3| = 3,
|–1,345| = 1,345.

Если представить числовую прямую (координатную прямую), то можно сказать, что на том расстоянии, на котором от нуля находится отрицательное число в одну сторону, на том же расстоянии от нуля находится его модуль, но в другую сторону.

Однако как найти модуль числового выражения, если его вычислить проблематично. Например, в выражениях с корнями когда получаются иррациональные числа. Пусть требуется найти модуль √2 – 2. Понятно, что здесь получится отрицательное число, т. к. 2 определенно больше √2. Следовательно, модулем этого выражения будет противоположное число. Но каково оно?

Чтобы получить противоположное число, надо умножить его на –1. Обычно просто приписывают к нему знак минуса. Если число отрицательное, то минус на минус дает плюс, и в результате получается положительное. Например, для –5 противоположное –(–5) = 5. Поэтому, когда берется модуль отрицательного числа, то можно не просто писать |–1,2| = |1,2|, а расписывать действие подробно:

|–1,2| = –(–1,2) = 1,2

Сделаем то же самое по отношению к выражению √2 – 2, коли мы уже знаем, что это отрицательное число:

|√2 – 2| = –(√2 – 2) = –√2 + 2 = 2 – √2

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

  1. Определить, является ли число положительным или отрицательным.
  2. Если число положительное или 0, то его модуль будет равен ему самому.
  3. Если число отрицательное, то умножить его на –1, после чего преобразовать выражение к удобному виду.

Теперь обратим внимание на следующее. Выше было сказано, что модуль отрицательного числа отстоит от точки отсчета (нуля) на таком же расстоянии (но в другую сторону), как и само это число. Однако в примере с корнем мы видим, что само выражение и его модуль не выглядят такими уж идентичными по абсолютному значению. Трудно сказать, действительно ли √2 – 2 отстоит от нуля на таком же расстоянии как 2 – √2.

Однако это так. Если записать отрицательное число с корнем как –2 + √2, то понятно, что мы получаем число, которое больше –2, т. е. находится от –2 ближе к нулю на √2. Модуль же числа равен 2 – √2. Это число, которое меньше 2 на √2. То есть тоже находится от 2 ближе к нулю на √2.

Модули. Курс «Python. Введение в программирование»

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

Чтобы разрешить проблему доступа к дополнительным возможностям языка, в программировании стало общепринятой практикой использовать так называемые модули, пакеты и библиотеки. Каждый модуль содержит коллекцию функций и классов, предназначенных для решения задач из определенной области. Так в модуле math языка Python содержатся математические функции, модуль random позволяет генерировать псевдослучайные числа, в модуле datetime содержатся классы для работы с датами и временем, модуль sys предоставляет доступ к системным переменным и т. д.

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

Для доступа к функционалу модуля, его надо импортировать в программу. После импорта интерпретатор «знает» о существовании дополнительных классов и функций и позволяет ими пользоваться.

В Питоне импорт осуществляется командой import. При этом существует несколько способов импорта. Рассмотрим работу с модулем на примере math. Итак,

Ничего не произошло. Однако в глобальной области видимости появилось имя math. Если до импорта вы упомянули бы имя math, то возникла бы ошибка NameError. Теперь же

>>> math
<module 'math' (built-in)>

В программе завелся объект math, относящийся к классу module.

Чтобы увидеть перечень функций, входящих в этот модуль, воспользуемся встроенной в Python функцией dir(), передав ей в качестве аргумента имя модуля:

>>> dir(math)
['__doc__', '__loader__', '__name__', 
'__package__', '__spec__', 'acos', 'acosh',
'asin', 'asinh', 'atan', 'atan2', 'atanh', 
'ceil', 'copysign', 'cos', 'cosh',
'degrees', 'e', 'erf', 'erfc', 'exp', 
'expm1', 'fabs', 'factorial', 'floor',
'fmod', 'frexp', 'fsum', 'gamma', 'gcd',
 'hypot', 'inf', 'isclose', 'isfinite',
'isinf', 'isnan', 'ldexp', 'lgamma', 'log', 
'log10', 'log1p', 'log2', 'modf',
'nan', 'pi', 'pow', 'radians', 'sin', 'sinh', 
'sqrt', 'tan', 'tanh', 'trunc']

Проигнорируем имена с двойными подчеркиваниями. Все остальное – имена функций и констант (переменных, которые не меняют своих значений), включенных в модуль math. Чтобы вызвать функцию из модуля, надо впереди написать имя модуля, поставить точку, далее указать имя функции, после чего в скобках передать аргументы, если они требуются. Например, чтобы вызвать функцию pow из math, надо написать так:

Обратите внимание, эта другая функция pow(), не та, что встроена в сам язык. «Обычная» функция pow() возвращает целое, если аргументы целые числа:

Для обращения к константе скобки не нужны:

>>> math.pi
3.141592653589793

Если мы не знаем, что делает та или иная функция, то можем получить справочную информацию о ней с помощью встроенной в язык Python функции help():

>>> help(math.gcd)
Help on built-in function gcd in module math:

gcd(...)
    gcd(x, y) -> int
    greatest common divisor of x and y

Для выхода из интерактивной справки надо нажать клавишу q. В данном случае сообщается, что функция возвращает целое число, и это наибольший общий делитель для чисел x и y. Описание модулей и их содержания также можно посмотреть в официальной документации на сайте python.org.

Второй способ импорта – это когда импортируется не сам модуль, а только необходимые функции из него.

>>> from math import gcd, sqrt, hypot

Перевести можно как «из модуля math импортировать функции gcd, sqrt и hypot«.

В таком случае при их вызове не надо перед именем функции указывать имя модуля:

>>> gcd(100, 150)
50
>>> sqrt(16)
4.0
>>> hypot(3, 4)
5.0

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

Импорт через from не лишен недостатка. В программе уже может быть идентификатор с таким же именем, как имя одной из импортируемых функций или констант. Ошибки не будет, но одно из них окажется «затерто»:

>>> pi = 3. 14
>>> from math import pi
>>> pi
3.141592653589793

Здесь исчезает значение 3.14, присвоенное переменной pi. Это имя теперь указывает на число из модуля math. Если импорт сделать раньше, чем присвоение значения pi, то будет все наоборот:

>>> from math import pi
>>> pi = 3.14
>>> pi
3.14

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

Однако можно изменить имя идентификатора из модуля на какое угодно:

>>> from math import pi as P
>>> P
3.141592653589793
>>> pi
3.14

В данном случае константа pi из модуля импортируется под именем P. Смысл подобных импортов в сокращении имен, так как есть модули с длинными именами, а имена функций и классов в них еще длиннее. Если в программу импортируется всего пара сущностей, и они используются в ней часто, то имеет смысл переименовать их на более короткий вариант. Сравните:

>>> import calendar
>>> calendar.weekheader(2)
'Mo Tu We Th Fr Sa Su'

и

>>> from calendar import weekheader as week
>>> week(3)
'Mon Tue Wed Thu Fri Sat Sun'

Во всех остальных случаях лучше оставлять идентификаторы содержимого модуля в пространстве имен самого модуля и получать доступ к ним через имя модуля, то есть выполнять импорт командой import имя_модуля, а вызывать, например, функции через имя_модуля.имя_функции().

Практическая работа. Создание собственного модуля

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

from math import pi, pow
 
def rectangle(a, b):
    return round(a * b, 2)
 
def triangle(a, h):
    return round(0. 5 * a * h, 2)
 
def circle(r):
    return round(pi * pow(r, 2), 2) 

Здесь также иллюстрируется принцип, что один модуль может импортировать другие. В данном случае импортируются функции из модуля math.

Поместите данный код в отдельный файл square.py. Однако куда поместить сам файл?

Когда интерпретатор Питона встречает команду импорта, то просматривает на наличие файла-модуля определенные каталоги. Их перечень можно увидеть по содержимому sys.path:

>>> import sys
>>> sys.path
['', '/usr/lib/python35.zip', 
'/usr/lib/python3.5', 
'/usr/lib/python3.5/plat-x86_64-linux-gnu',
'/usr/lib/python3.5/lib-dynload', 
'/home/pl/.local/lib/python3.5/site-packages',
'/usr/local/lib/python3.5/dist-packages', 
'/usr/lib/python3/dist-packages']

Это список адресов в Linux. В Windows он будет несколько другим. Первый элемент – пустая строка, что обозначает текущий каталог, то есть то место, где сохранена сама программа, импортирующая модуль. Если вы сохраните файл-модуль и файл-программу в одном каталоге, то интерпретатор без труда найдет модуль.

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

Можно добавить в sys.path свой каталог. Однако в этом случае либо код программы должен содержать команды изменения значения sys.path, либо надо править конфигурационный файл операционной системы. В большинстве случаев лучше так не делать.

Поместите файл square.py в тот же каталог, где будет исполняемая программа. Ее код должен включать инструкцию импорта модуля square (при импорте расширение файла не указывается) и вызов той функции и с теми параметрами, которые ввел пользователь. То есть у пользователя надо спросить, площадь какой фигуры он хочет вычислить. Далее запросить у него аргументы для соответствующей функции. Передать их в функцию из модуля square, а полученный оттуда результат вывести на экран.

Примечание. Исполнение модуля как самостоятельного скрипта, а также создание строк документации, которые отображает встроенная в Python функция help(), будут рассмотрены в курсе объектно-ориентированного программирования.

Примеры решения и дополнительные уроки в android-приложении и pdf-версии курса

Модуль Math — Примеры математических программ в Python

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

Содержание статьи

Специальные константы библиотеки math

В библиотеке Math в Python есть две важные математические константы.

Число Пи из библиотеки math

Первой важной математической константой является число Пи (π). Оно обозначает отношение длины окружности к диаметру, его значение 3,141592653589793. Чтобы получить к нему доступ, сначала импортируем библиотеку math следующим образом:

Затем можно получить доступ к константе, вызывая pi:

Вывод

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

import math

radius = 2
print(‘Площадь окружности с радиусом 2 равна:’, math.pi * (radius ** 2))

import math

 

radius = 2

print(‘Площадь окружности с радиусом 2 равна:’, math.pi * (radius ** 2))

Вывод

Площадь окружности с радиусом 2 равна: 12.566370614359172

Площадь окружности с радиусом 2 равна: 12.566370614359172

Мы возвели радиус во вторую степень и умножили значение на число Пи, как и следовало сделать в соответствии с формулой πr2.

Есть вопросы по Python?

На нашем форуме вы можете задать любой вопрос и получить ответ от всего нашего сообщества!

Telegram Чат & Канал

Вступите в наш дружный чат по Python и начните общение с единомышленниками! Станьте частью большого сообщества!

Паблик VK

Одно из самых больших сообществ по Python в социальной сети ВК. Видео уроки и книги для вас!

Число Эйлера из библиотеки math

Число Эйлера (е) является основанием натурального логарифма. Оно также является частью библиотеки Math в Python. Получить доступ к числу можно следующим образом:

Вывод

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

import math

print((math.e + 6 / 2) * 4.32)

import math

 

print((math.e + 6 / 2) * 4.32)

Вывод

Экспонента и логарифм библиотеки math

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

Функция экспоненты exp() в Python

Библиотека Math в Python поставляется с функцией exp(), которую можно использовать для вычисления значения е. К примеру, ex — экспонента от х. Значение е равно 2.718281828459045.

Метод может быть использован со следующим синтаксисом:

Параметр x может быть положительным или отрицательным числом. Если x не число, метод возвращает ошибку. Рассмотрим пример использования данного метода:

import math

# Инициализация значений
an_int = 6
a_neg_int = -8
a_float = 2.00

# Передача значений методу exp() и вывод
print(math.exp(an_int))
print(math.exp(a_neg_int))
print(math.exp(a_float))

import math

 

# Инициализация значений

an_int = 6

a_neg_int = -8

a_float = 2.00

 

# Передача значений методу exp() и вывод

print(math.exp(an_int))

print(math. exp(a_neg_int))

print(math.exp(a_float))

Вывод

403.4287934927351
0.00033546262790251185
7.38905609893065

403.4287934927351

0.00033546262790251185

7.38905609893065

Мы объявили три переменные и присвоили им значения с различными числовыми типами данных. Мы передали значения методу exp() для вычисления их экспоненты.

Мы также можем применить данный метод для встроенных констант, что продемонстрировано ниже:

import math

print(math.exp(math.e))
print(math.exp(math.pi))

import math

 

print(math.exp(math.e))

print(math.exp(math.pi))

Вывод

15.154262241479262
23.140692632779267

15.154262241479262

23.140692632779267

При передаче не числового значения методу будет сгенерирована ошибка TypeError, как показано далее:

import math

print(math. exp(«20»))

import math

 

print(math.exp(«20»))

Вывод

Traceback (most recent call last):
File «C:/Users/admin/mathe.py», line 3, in <module>
print (math.exp(«20»))
TypeError: a float is required

Traceback (most recent call last):

  File «C:/Users/admin/mathe.py», line 3, in <module>

    print (math.exp(«20»))

TypeError: a float is required

Как видно из примера выше, генерируется ошибка TypeError.

Функция логарифма log() в Python

Функция log() возвращает логарифм определенного числа. Натуральный логарифм вычисляется относительно основания е. В следующем примере показано использование функции логарифма:

import math

print(«math.log(10.43):», math.log(10.43))
print(«math.log(20):», math.log(20))
print(«math.log(math.pi):», math.log(math.pi))

import math

 

print(«math. log(10.43):», math.log(10.43))

print(«math.log(20):», math.log(20))

print(«math.log(math.pi):», math.log(math.pi))

В скрипте выше методу передаются числовые значения с различными типами данных. Также рассчитывается натуральный логарифм константы pi. Вывод следующий:

math.log(10.43): 2.344686269012681
math.log(20): 2.995732273553991
math.log(math.pi): 1.1447298858494002

math.log(10.43): 2.344686269012681

math.log(20): 2.995732273553991

math.log(math.pi): 1.1447298858494002

Функция log10() в Python

Метод log10() возвращает логарифм по основанию 10 определенного числа. К примеру:

import math

# Возвращает log10 числа 50
print(«log10 числа 50 равен:», math.log10(50))

import math

 

# Возвращает log10 числа 50

print(«log10 числа 50 равен:», math.log10(50))

Вывод

log10 числа 50 равен: 1. 6989700043360187

log10 числа 50 равен: 1.6989700043360187

Функция log2() в Python

Функция log2() возвращает логарифм определенного числа по основанию 2. К примеру:

import math

# Возвращает log2 числа 16
print(«log2 числа 16 равен:», math.log2(16))

import math

 

# Возвращает log2 числа 16

print(«log2 числа 16 равен:», math.log2(16))

Вывод

log2 числа 16 равен: 4.0

log2 числа 16 равен: 4.0

Функция log(x, y) в Python

Функция log(x, y) возвращает логарифм числа х по основанию y. К примеру:

import math

# Возвращает логарифм 3,4
print(«Логарифм 3 по основанию 4 равен:», math.log(3, 4))

import math

 

# Возвращает логарифм 3,4

print(«Логарифм 3 по основанию 4 равен:», math. log(3, 4))

Вывод

Логарифм 3 по основанию 4 равен: 0.6309297535714574

Логарифм 3 по основанию 4 равен: 0.6309297535714574

Функция log1p(x) в Python

Функция log1p(x) рассчитывает логарифм(1+x), как представлено ниже:

import math

print(«Значение логарифма(1+x) от 10 равно:», math.log1p(10))

import math

 

print(«Значение логарифма(1+x) от 10 равно:», math.log1p(10))

Вывод

Значение логарифма(1+x) от 10 равно: 2.3978952727983707

Значение логарифма(1+x) от 10 равно: 2.3978952727983707

Арифметические функции в Python

Арифметические функции используются для представления чисел в различных формах и осуществления над ними математических операций. Далее представлен перечень самых популярных арифметических функций:

  • ceil(): округление определенного числа вверх;
  • fabs(): возвращает модуль (абсолютное значение) указанного числа;
  • floor(): округление определенного числа вниз;
  • gcd(a, b): получение наибольшего общего делителя чисел a и b;
  • fsum(iterable): возвращает сумму всех элементов итерируемого объекта;
  • expm1(): возвращает (e^x)-1;
  • exp(x)-1: когда значение x слишком мало, вычисление exp(x)-1 может привести к значительной потери в точности. x (при использовании функции expml()) равно: 0.00010000500016667084

    К числу других математических функций относятся:

    • pow(): принимает два вещественных аргумента, возводит первый аргумент в степень, значением которой является второй аргумент, после чего возвращает результат. К примеру, pow(2, 2) эквивалентно выражению 2 ** 2;
    • sqrt(): возвращает квадратный корень определенного числа.

    Примеры данных методов представлены ниже:

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

    Вывод

    Квадратный корень

    Вывод

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

    Модуль math в Python поддерживает все тригонометрические функции. Самые популярные представлены ниже:

    • sin(a): Возвращает синус "а" в радианах;
    • cos(a): Возвращает косинус "а" в радианах;
    • tan(a): Возвращает тангенс "а" в радианах;
    • asin(a): Возвращает инвертированный синус. Аналогичным образом работают "atan" и "acos";
    • degrees(a): Конвертирует угол "a" из радиан в градусы;
    • radians(a): Конвертирует угол "a" из градусов в радианы.

    Рассмотрим следующий пример:

    import math

    angle_In_Degrees = 62
    angle_In_Radians = math.radians(angle_In_Degrees)

    print(‘Значение угла:’, angle_In_Radians)
    print(‘sin(x) равен:’, math.sin(angle_In_Radians))
    print(‘tan(x) равен:’, math.tan(angle_In_Radians))
    print(‘cos(x) равен:’, math.cos(angle_In_Radians))

    import math

     

    angle_In_Degrees = 62

    angle_In_Radians = math.radians(angle_In_Degrees)

     

    print(‘Значение угла:’, angle_In_Radians)

    print(‘sin(x) равен:’, math.sin(angle_In_Radians))

    print(‘tan(x) равен:’, math.tan(angle_In_Radians))

    print(‘cos(x) равен:’, math.cos(angle_In_Radians))

    Вывод

    Значение угла: 1. 0821041362364843
    sin(x) равен: 0.8829475928589269
    tan(x) равен: 1.8807264653463318
    cos(x) равен: 0.46947156278589086

    Значение угла: 1.0821041362364843

    sin(x) равен: 0.8829475928589269

    tan(x) равен: 1.8807264653463318

    cos(x) равен: 0.46947156278589086

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

    Конвертация типов числа в Python

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

    Вывод

    В вышеприведенном примере целое число 3 было преобразовано в вещественное число 3.0 с плавающей точкой. Результатом сложения также является число с плавающей точкой (или запятой).

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

    Например, чтобы преобразовать целое число в число с плавающей точкой, мы должны вызвать функцию float(), как показано ниже:

    a = 12
    b = float(a)
    print(b)

    a = 12

    b = float(a)

    print(b)

    Вывод

    Целое число типа integer было преобразовано в вещественное число типа float. float также можно конвертировать в integer следующим образом:

    a = 12.65
    b = int(a)
    print(b)

    a = 12.65

    b = int(a)

    print(b)

    Вывод

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

    Заключение

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

    Являюсь администратором нескольких порталов по обучению языков программирования Python, Golang и Kotlin. В составе небольшой команды единомышленников, мы занимаемся популяризацией языков программирования на русскоязычную аудиторию. Большая часть статей была адаптирована нами на русский язык и распространяется бесплатно.

    E-mail: [email protected]

    Образование
    Universitatea Tehnică a Moldovei (utm.md)

    • 2014 — 2018 Технический Университет Молдовы, ИТ-Инженер. Тема дипломной работы «Автоматизация покупки и продажи криптовалюты используя технический анализ»
    • 2018 — 2020 Технический Университет Молдовы, Магистр, Магистерская диссертация «Идентификация человека в киберпространстве по фотографии лица»

    Функции и методы модуля math в python ~ PythonRu

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

    Что такое модуль?

    В C и C++ есть заголовочные файлы, в которых хранятся функции, переменные классов и так далее. При включении заголовочных файлов в код появляется возможность не писать лишние строки и не использовать одинаковые функции по несколько раз. Аналогично в Python для этого есть модули, которые включают функции, классы, переменные и скомпилированный код. Модуль содержит группу связанных функций, классов и переменных.

    Есть три типа модулей в Python:

    1. Модули, написанные на Python (.py).
    2. Модули, написанные на C и загружаемые динамически (.dll, .pyd, .so, .sl и так далее).
    3. Модули, написанные на C, но связанные с интерпретатором.
      import sys
      print(sys.builtin_module_names)
      
      ('_ast', '_bisect', '_codecs', '_codecs_cn', '_codecs_hk', '_codecs_iso2022', 
      '_codecs_jp', '_codecs_kr', '_codecs_tw', '_collections', '_csv', '_datetime', 
      '_functools', '_heapq', '_imp', '_io', '_json', '_locale', '_lsprof', '_md5', 
      '_multibytecodec', '_opcode', '_operator', '_pickle', '_random', '_sha1', 
      '_sha256', '_sha512', '_sre', '_stat', '_string', '_struct', '_symtable', '_thread', 
      '_tracemalloc', '_warnings', '_weakref', '_winapi', 'array', 'atexit', 'audioop', 
      'binascii', 'builtins', 'cmath', 'errno', 'faulthandler', 'gc', 'itertools', 'marshal', 
      'math', 'mmap', 'msvcrt', 'nt', 'parser', 'signal', 'sys', 'time', 'winreg', 
      'xxsubtype', 'zipimport', 'zlib').
      

    Для получения списка модулей, написанных на C, но связанных с Python, можно использовать следующий код.

    Как видно из списка выше, модуль math написан на C, но связан с интерпретатором. Он содержит математические функции и переменные, о которых дальше и пойдет речь.

    Функции представления чисел

    ceil() и floor() — целая часть числа

    Сeil() и floor() — функции общего назначения. Функция ceil округляет число до ближайшего целого в большую сторону. Функция floor убирает цифры десятичных знаков. Обе принимают десятичное число в качестве аргумента и возвращают целое число.

    Пример:

    
    import math
    
    
    number=8.10
    
    
    print("Верхний предел 8.10 это:",math.ceil(number))
    
    
    print("Нижний предел 8.10 это:",math.floor(number))
    

    Вывод:

    Верхний предел 8.10 это: 9
    Нижний предел 8.10 это: 8
    

    Функция fabs() — абсолютное значение

    Функция fabs используется для вычисления абсолютного значения числа. Если число содержит любой отрицательный знак (-), то функция убирает его и возвращает положительное дробное число.

    Пример:

    
    import math
    
    number = -8.10
    
    print(math.fabs(number))
    

    Вывод:

    8.1
    

    factorial() — функция факториала

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

    Пример:

    
    import math    
    
    number = 5
    
    print("факториала числа", math.factorial(number))
    

    Вывод:

    факториала числа 120
    

    Примечание: при попытке использовать отрицательное число, возвращается ошибка значения (Value Error).

    Пример:

    
    import math    
    
    number = -5
    
    print("факториала числа", math.factorial(number))
    

    Вывод:

    ValueError: factorial() not defined for negative values
    

    Функция fmod() — остаток от деления

    Функция fmod(x,y) возвращает x % y. Разница в том, что выражение x % y работает только с целыми числами, а эту функцию можно использовать и для чисел с плавающей точкой.

    Пример:

    
    import math  
    
    print(math.fmod(5,2))  
    print(math.fmod(-5,2))  
    print(math.fmod(-5.2,2))  
    print(math.fmod(5.2,2))  
    

    Вывод:

    1.0
    -1.0
    -1.2000000000000002
    1.2000000000000002
    

    Функция frexp()

    Эта функция возвращает мантиссу и показатель степени в виде пары (m,n) любого числа x, решая следующее уравнение.x.

    Пример:

    
    import math   
        
    print("e в степени 5 ", math.exp(5))
    print("e в степени 2.5", math.exp(2.5))  
    

    Вывод:

    e в степени 5  148.4131591025766
    e в степени 2.5 12.182493960703473
    

    Функция expm1()

    Эта функция работает так же, как и exp, но возвращает exp(x)-1. Здесь, expm1 значит exm-m-1, то есть, exp-minus-1.

    Пример:

    
    import math   
        
    print(math.exp(5)-1)
    print(math.expm1(5))
    


    Вывод:

    147.4131591025766
    147.4131591025766
    

    Функция log() — логарифм числа

    Функция log(x[,base]) находит логарифм числа x по основанию e (по умолчанию). base— параметр опциональный. Если нужно вычислить логарифм с определенным основанием, его нужно указать.

    Пример:

    
    import math  
    	  
    
    print(math.log(2))  
    	  
    
    print(math.log(64,2)) 
    

    Вывод:

    0.6931471805599453
    6.0
    

    Функция log1p()

    Эта функция похожа на функцию логарифма, но добавляет 1 к x. log1p значит log-1-p, то есть, log-1-plus.

    Пример:

    
    import math  
    	  
    print(math.log1p(2))
    

    Вывод:

    1.0986122886681098
    

    Функция log10()

    Вычисляет логарифм по основанию 10.

    Пример:

    
    import math  
    
    print(math.log10(1000))
    

    Вывод:

    3.0
    

    Функция pow() — степень числа

    Используется для нахождение степени числа. Синтаксис функции pow(Base, Power). Она принимает два аргумента: основание и степень.

    Пример:

    
    import math  
    
    print(math.pow(5,4))
    

    Вывод:

    625.0
    

    Функция sqrt() — квадратный корень числа

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

    Пример:

    
    import math  
    
    print(math.sqrt(256))
    

    Вывод:

    16.0
    

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

    В Python есть следующие тригонометрические функции.

    Функция Значение
    sin принимает радиан и возвращает его синус
    cos принимает радиан и возвращает его косинус
    tan принимает радиан и возвращает его тангенс
    asin принимает один параметр и возвращает арксинус (обратный синус)
    acos принимает один параметр и возвращает арккосинус (обратный косинус)
    atan принимает один параметр и возвращает арктангенс (обратный тангенс)
    sinh принимает один параметр и возвращает гиперболический синус
    cosh принимает один параметр и возвращает гиперболический косинус
    tanh принимает один параметр и возвращает гиперболический тангенс
    asinh принимает один параметр и возвращает обратный гиперболический синус
    acosh принимает один параметр и возвращает обратный гиперболический косинус
    atanh принимает один параметр и возвращает обратный гиперболический тангенс

    Пример:

    
    import math  
      
    
    print("синус PI/2 :", math.sin(math.pi/2))  
    
    print("косинус 0 :", math.cos(0))  
    
    print("тангенс PI/4 :", math.tan(math.pi/4))  
      
    print()  
      
    
    print("арксинус 0 :", math.acos(0))  
    
    print("арккосинус 1 :", math.acos(1))  
    
    print("арктангенс 0.5 :", math.atan(0.5))  
      
    print()  
      
    
    print("гиперболический синус 1 :", math.sinh(1))  
    
    print("гиперболический косинус 0 :", math.cos(0))  
    
    print("гиперболический тангенс 1 :", math.tan(1))  
      
    print()  
      
    
    print("обратный гиперболический синус 1 :", math.acosh(1))  
    
    print("обратный гиперболический косинус 1 :", math.acosh(1))  
    
    print("обратный гиперболический тангенс 0.5 :", math.atanh(0.5))  
    

    Вывод:

    синус PI/2 : 1.0
    косинус 0 : 1.0
    тангенс PI/4 : 0.9999999999999999
    
    арксинус 0 : 1.5707963267948966
    арккосинус 1 : 0.0
    арктангенс 0.5 : 0.4636476090008061
    
    гиперболический синус 1 : 1.1752011936438014
    гиперболический косинус 0 : 1.0
    гиперболический тангенс 1 : 1.5574077246549023
    
    обратный гиперболический синус 1 : 0.0
    обратный гиперболический косинус 1 : 0.0
    обратный гиперболический тангенс 0.5 : 0.5493061443340549
    

    Функция преобразования углов

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

    • degrees(): конвертирует радиан в градусы;
    • radians(): конвертирует градус в радианы;

    Пример:

    
    import math  
    
    print(math.degrees(1.57))
    print(math.radians(90))
    

    Вывод:

    89.95437383553924
    1.5707963267948966
    

    Математические константы

    В Python есть две математические константы: pi и e.

    1. pi: это математическая константа со значением 3.1416..
    2. e: это математическая константа со значением 2.7183..

    Пример:

    
    import math  
    
    
    print("значение PI", math.pi)
    
    
    print("значение e", math.e)
    

    Вывод:

    значение PI 3.141592653589793
    значение e 2.718281828459045
    

    Интерактивный учебник языка 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…


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

    Функция ABS (Visual Basic для приложений)



    • Чтение занимает 2 мин

    В этой статье

    Возвращает значение передаваемого ему типа с указанием абсолютного значения числа.Returns a value of the same type that is passed to it specifying the absolute value of a number.

    СинтаксисSyntax

    ABS(число)Abs(number)

    Обязательный числовой аргумент может быть любым допустимым числовым выражением.The required number argument can be any valid numeric expression. Если number содержит Null, возвращается Null; если это неинициализированная переменная, возвращается нулевое значение.If number contains Null, Null is returned; if it is an uninitialized variable, zero is returned.

    ПримечанияRemarks

    Абсолютное значение числа — это его беззнаковая величина.The absolute value of a number is its unsigned magnitude. Например, ABS(-1) и ABS(1) Return. 1For example, ABS(-1) and ABS(1) both return 1.

    ПримерExample

    В этом примере функция Abs используется для вычисления абсолютного значения числа.This example uses the Abs function to compute the absolute value of a number.

    Dim MyNumber
    MyNumber = Abs(50.3)    ' Returns 50.3.
    MyNumber = Abs(-50.3)    ' Returns 50.3.
    

    См. такжеSee also

    Поддержка и обратная связьSupport and feedback

    Есть вопросы или отзывы, касающиеся Office VBA или этой статьи?Have questions or feedback about Office VBA or this documentation? Руководство по другим способам получения поддержки и отправки отзывов см. в статье Поддержка Office VBA и обратная связь.Please see Office VBA support and feedback for guidance about the ways you can receive support and provide feedback.



    12. Модули — Как думать как компьютерный ученый: обучение с помощью Python 3

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

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

    12.1. Случайные числа

    Мы часто хотим использовать случайные числа в программах, вот несколько типичных применений:

    • Чтобы сыграть в азартную игру, в которой компьютеру нужно бросить кости, выбрать число или подбросить монету,
    • Случайное перемешивание колоды игральных карт,
    • Разрешить / заставить вражеский космический корабль появиться в случайном месте и начать
      стрельба в игрока,
    • Для имитации возможных осадков, когда мы делаем компьютеризированную модель для
      оценка воздействия строительства плотины на окружающую среду,
    • Для шифрования банковских сеансов в Интернете.

    Python предоставляет случайный модуль, который помогает с такими задачами. Ты можешь
    найдите его с помощью справки, но вот основные вещи, которые мы с ним сделаем:

     случайный импорт
    
    # Создать объект черного ящика, который генерирует случайные числа
    rng = random.Random ()
    
    dice_throw = rng.randrange (1,7) # Возвращает int, одно из 1,2,3,4,5,6
    delay_in_seconds = rng.random () * 5,0
     

    Вызов метода randrange генерирует целое число между нижним и верхним
    аргумент, используя ту же семантику, что и диапазон — поэтому нижняя граница включена, но
    верхняя граница исключена.Все значения имеют равную вероятность появления
    (т.е. результаты равномерно распределены ). Как и диапазон, рандрейндж может
    также укажите необязательный аргумент step. Предположим, нам нужно на случайное нечетное число меньше
    чем 100, можно сказать:

     r_odd = rng.randrange (1, 100, 2)
     

    Другие методы также могут создавать другие дистрибутивы, например колоколообразный,
    или «нормальное» распределение может быть более подходящим для оценки сезонных осадков,
    или концентрация соединения в организме после приема дозы лекарства.

    Случайный метод возвращает число с плавающей запятой в интервале [0.0, 1.0) —
    квадратная скобка означает «закрытый интервал слева», а круглая скобка означает
    «Открытый интервал справа». Другими словами, 0,0 возможен, но все возвращается
    числа будут строго меньше 1.0. Обычно масштаб результаты после
    вызывая этот метод, чтобы перевести их в интервал, подходящий для вашего приложения. в
    в случае, показанном здесь, мы преобразовали результат вызова метода в число в
    интервал [0.0, 5,0). Опять же, это равномерно распределенные числа — числа
    числа, близкие к 0, с такой же вероятностью встречаются, как числа, близкие к 0,5, или числа, близкие к 1,0.

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

     cards = list (range (52)) # Сгенерировать целые числа [0 .. 51]
                             # представляет колоду карт.rng.shuffle (cards) # Перемешать колоду
     

    12.1.1. Повторяемость и тестирование

    Генераторы случайных чисел основаны на детерминированном алгоритме — повторяемом и предсказуемом.
    Итак, их называют псевдослучайными генераторами — они не являются действительно случайными.
    Они начинаются со значения seed . Каждый раз, когда вы запрашиваете другое случайное число, вы получаете
    один, основанный на текущем атрибуте семени, и состояние семени (которое является одним
    атрибутов генератора) будут обновлены.

    Для отладки и для написания юнит-тестов удобно
    иметь повторяемость — программы, которые делают одно и то же каждый раз при запуске.
    Мы можем организовать это, принудительно инициализировав генератор случайных чисел с помощью
    известное семя каждый раз. (Часто это требуется только во время тестирования — во время игры
    карт, в которых перетасованная колода всегда была в том же порядке, что и в прошлый раз
    быстро надоест!)

     drng = случайный.Random (123) # Создать генератор с известным начальным состоянием
     

    Этот альтернативный способ создания генератора случайных чисел дает явное начальное число.
    значение к объекту. Без этого аргумента система, вероятно, использует что-то, основанное на
    во время. Так что если взять несколько случайных чисел из drng сегодня, вы получите
    точно такая же случайная последовательность, как и завтра!

    12.1.2. Собирать шары из мешков, бросать кости, тасовать колоду карт

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

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12 
     случайный импорт
    
    def make_random_ints (число, нижняя_ граница, верхняя_ граница):
       "" "
         Сгенерируйте список, содержащий число случайных чисел в интервале между lower_bound
         и upper_bound.upper_bound - это открытая граница.
       "" "
       rng = random.Random () # Создать генератор случайных чисел
       результат = []
       для i в диапазоне (число):
          result.append (rng.randrange (нижняя_ граница, верхняя_ привязка))
       вернуть результат
     
     >>> make_random_ints (5, 1, 13) # Выбрать 5 случайных номеров месяцев
    [8, 1, 8, 5, 6]
     

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

    Но что, если вам не нужны дубликаты? Если вы хотите 5 разных месяцев,
    тогда этот алгоритм неверен.В этом случае хороший алгоритм — создать
    список возможностей, перемешайте его и вырежьте нужное количество элементов:

     xs = list (range (1,13)) # Сделать список 1..12 (нет дубликатов)
    rng = random.Random () # Создать генератор случайных чисел
    rng.shuffle (xs) # Перемешать список
    result = xs [: 5] # Берем первые пять элементов
     

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

    Второй алгоритм «перемешать и разрезать» был бы не так хорош, если бы
    вам нужно всего несколько элементов, но из очень большого домена.
    Предположим, мне нужно пять чисел от одного до десяти миллионов без дубликатов.
    Создание списка из десяти миллионов элементов, его перемешивание и отсечение
    первые пять были бы катастрофой производительности! Так что давайте еще раз попробуем:

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20 
     импорт случайный
    
    def make_random_ints_no_dups (число, нижняя_ граница, верхняя_ граница):
       "" "
         Создайте список, содержащий число случайных чисел между
         lower_bound и upper_bound.upper_bound - это открытая граница.
         Список результатов не может содержать дубликатов.
       "" "
       результат = []
       rng = random.Random ()
       для i в диапазоне (число):
            в то время как True:
                кандидат = rng.randrange (нижняя_ граница, верхняя_ привязка)
                если кандидат не в результате:
                    перерыв
            result.append (кандидат)
       вернуть результат
    
    xs = make_random_ints_no_dups (5, 1, 10000000)
    печать (хз)
     

    Это дает 5 случайных чисел без дубликатов:

     [3344629, 1735163, 9433892, 1081511, 40]
     

    Даже у этой функции есть свои подводные камни.Можете ли вы заметить, что произойдет в
    этот случай?

     xs = make_random_ints_no_dups (10, 1, 6)
     

    12.2. Модуль времени

    Когда мы начинаем работать с более сложными алгоритмами и более крупными программами, естественный
    беспокойство: «эффективен ли наш код?» Один из способов поэкспериментировать — определить время,
    операции берут. Модуль времени имеет функцию под названием часы, которая рекомендуется
    для этого.Каждый раз, когда вызывается часы, они возвращают число с плавающей запятой.
    представляющий, сколько секунд прошло с момента запуска вашей программы.

    Способ его использования — вызвать часы и присвоить результат переменной, скажем t0,
    непосредственно перед тем, как вы начнете выполнять код, который хотите измерить. Затем после выполнения вызовите
    снова часы (на этот раз мы сохраним результат в переменной t1). Различия
    t1-t0 — это время, прошедшее с начала, и показатель того, насколько быстро выполняется ваша программа.

    Давайте попробуем небольшой пример.Python имеет встроенную функцию суммы, которая может суммировать
    элементы в списке. Мы также можем написать свои собственные. Как мы думаем, они будут сравнивать
    на скорость? Мы попытаемся суммировать список [0, 1, 2 …] в обоих случаях, и
    сравните результаты:

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21 год
    22 
     время импорта
    
    def do_my_sum (хз):
        сумма = 0
        для v в xs:
            сумма + = v
        сумма возврата
    
    sz = 10000000 # Пусть в списке будет 10 миллионов элементов
    testdata = диапазон (sz)
    
    t0 = время.Часы()
    my_result = do_my_sum (тестовые данные)
    t1 = time.clock ()
    print ("my_result = {0} (затраченное время = {1: .4f} секунд)"
            .format (my_result, t1-t0))
    
    t2 = time.clock ()
    их_результат = сумма (тестовые данные)
    t3 = time.clock ()
    print ("their_result = {0} (затраченное время = {1: .4f} секунд)"
            .format (их_результат, t3-t2))
     

    На достаточно скромном ноутбуке получаем такие результаты:

     my_sum = 49999995000000 (затраченное время = 1,5567 секунды)
    их_сумма = 49999995000000 (затраченное время = 0.9897 секунд)
     

    Итак, наша функция работает примерно на 57% медленнее, чем встроенная.
    Генерация и суммирование десяти миллионов элементов менее чем за секунду — это не так уж и плохо!

    12,3. Математический модуль

    Математический модуль содержит математические функции, которые вы обычно
    калькулятор (sin, cos, sqrt, asin, log, log10) и некоторые математические константы
    как пи и е:

     >>> импорт математики
    >>> math.pi # Постоянное число пи
    3.1415

    589793 >>> math.e # Постоянная основа натурального журнала 2,718281828459045 >>> math.sqrt (2.0) # Функция извлечения квадратного корня 1,4142135623730951 >>> math.radians (90) # Преобразовать 90 градусов в радианы 1,5707963267948966 >>> math.sin (math.radians (90)) # Найти грех 90 градусов 1.0 >>> math.asin (1.0) * 2 # Удвойте arcsin 1.0, чтобы получить число пи 3,1415

    589793

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

    Обратите внимание на еще одно различие между этим модулем и нашим использованием random и turtle:
    в random и turtle мы создаем объекты и вызываем методы объекта. Это
    поскольку объекты имеют состояние — черепаха имеет цвет, положение, заголовок и т. д.,
    и каждый генератор случайных чисел имеет начальное значение, которое определяет его следующий результат.

    Математические функции являются «чистыми» и не имеют состояния — вычисление квадратного корня из
    2.0 не зависит от какого-либо состояния или истории того, что произошло в прошлом.
    Итак, функции не являются методами объекта —
    это просто функции, которые сгруппированы в модуль под названием math.

    12,4. Создание собственных модулей

    Все, что нам нужно сделать для создания наших собственных модулей, — это сохранить наш скрипт как
    файл с расширением .py. Предположим, например, что этот скрипт
    сохранен как файл с именем seqtools.py:

     def remove_at (pos, seq):
        return seq [: pos] + seq [pos + 1:]
     

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

     >>> импортировать seqtools
    >>> s = "Строка!"
    >>> seqtools.remove_at (4, с)
    'Жало!'
     

    Мы не включаем расширение файла .py, когда
    импорт. Python ожидает, что имена файлов модулей Python заканчиваются на .py,
    поэтому расширение файла не включается в оператор импорта .

    Использование модулей позволяет разбивать очень большие программы на
    управляемые по размеру части и чтобы связанные части оставались вместе.

    12,5. Пространства имен

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

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

     # Module1.ру
    
    question = "В чем смысл жизни, Вселенной и всего остального?"
    answer = 42
     
     # Module2.py
    
    question = "Каков ваш квест?"
    answer = "Искать Святой Грааль."
     

    Теперь мы можем импортировать оба модуля и получить доступ к вопросам и ответам в каждом из них:

     импортный модуль1
    import module2
    
    печать (module1.question)
    печать (module2.question)
    печать (module1.отвечать)
    печать (module2.answer)
     

    выведет следующее:

     В чем смысл жизни, Вселенной и всего остального?
    Какой у вас квест?
    42
    Искать Святой Грааль.
     

    Функции также имеют свои собственные пространства имен:

     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14 
     def f ():
        п = 7
        print ("печать n внутри f:", n)
    
    def g ():
        n = 42
        print ("печать n внутри g:", n)
    
    п = 11
    print ("печать n перед вызовом f:", n)
    f ()
    print ("печать n после вызова f:", n)
    грамм()
    print ("печать n после вызова g:", n)
     

    Запуск этой программы дает следующий результат:

     печатает n перед вызовом f: 11
    печать n внутри f: 7
    печать n после вызова f: 11
    печать n внутри g: 42
    печать n после вызова g: 11
     

    Три n ‘здесь не сталкиваются, так как каждый из них находится в разных
    пространство имен — это три имени для трех разных переменных, как и
    может быть три разных человека, и все они называются «Брюс».

    Пространства имен позволяют нескольким программистам работать над одним проектом без
    коллизии имен.

    12,6. Правила области действия и поиска

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

    В Python есть три важных области видимости:

    • Локальная область действия относится к идентификаторам, объявленным внутри функции. Эти идентификаторы сохраняются
      в пространстве имен, которое принадлежит функции, и каждая функция имеет собственное пространство имен.
    • Глобальная область относится ко всем идентификаторам, объявленным в текущем модуле или файле.
    • Встроенная область действия относится ко всем идентификаторам, встроенным в Python, таким как диапазон и
      min, которые можно использовать, не импортируя ничего, и которые (почти) всегда доступны.

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

     диапазон определения (n):
        вернуть 123 * n
    
    печать (диапазон (10))
     

    Что печатается? Мы определили нашу собственную функцию под названием range, поэтому здесь
    теперь потенциальная двусмысленность. Когда мы используем диапазон, мы имеем в виду наш собственный,
    или встроенный? Это определяет использование правил поиска в области видимости: наши собственные
    вызывается функция range, а не встроенная, потому что наша функция range
    находится в глобальном пространстве имен, которое имеет приоритет над встроенными именами.

    Таким образом, хотя имена вроде range и min встроены, их можно «скрыть».
    от вашего использования, если вы решите определить свои собственные переменные или функции, которые повторно используют
    эти имена. (Это сбивает с толку переопределение встроенных имен — чтобы быть
    хороший программист, вам нужно понимать правила области видимости и понимать
    что вы можете делать неприятные вещи, которые вызовут замешательство, и тогда вы их избегаете!)

    Теперь немного более сложный пример:

     n = 10
    м = 3
    def f (n):
       м = 7
       вернуть 2 * n + m
    
    print (f (5), n, m)
     

    Это напечатает 17 10 3.Причина в том, что две переменные m и n в строках 1 и 2
    находятся вне функции в глобальном пространстве имен. Внутри функции новые переменные
    вызываемые n и m создаются только на время выполнения f . Эти
    созданный в локальном пространстве имён функции f. В теле f правила поиска в области видимости
    определите, что мы используем локальные переменные m и n. Напротив, после того, как мы вернулись из f,
    аргументы n и m функции печати относятся к исходным переменным
    в строках 1 и 2, и они никоим образом не были изменены при выполнении функции f.

    Также обратите внимание, что def помещает здесь имя f в глобальное пространство имен. Так может быть
    позвонил по номеру 7.

    Каков объем переменной n в строке 1? Его масштаб — регион, в котором он находится.
    видимый — это строки 1, 2, 6, 7. Он скрыт от просмотра в строках 3, 4, 5 из-за
    локальная переменная n.

    12,7. Атрибуты и оператор точки

    Переменные, определенные внутри модуля, называются атрибутами модуля.
    Мы видели, что у объектов тоже есть атрибуты: например, у большинства объектов есть
    атрибут __doc__, некоторые функции имеют атрибут __annotations__.Доступ к атрибутам осуществляется с помощью оператора точка (.). Атрибут вопроса
    доступа к module1 и module2 можно получить с помощью module1.question и
    module2.question.

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

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

    12,8. Три варианта заявления об импорте

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

     импортная математика
    х = math.sqrt (10)
     

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

    Вот другое расположение:

     из math import cos, sin, sqrt
    х = sqrt (10)
     

    Имена добавляются непосредственно в текущее пространство имен и могут использоваться без уточнения.Название
    math сам по себе не импортируется, поэтому попытка использовать квалифицированную форму math.sqrt приведет к ошибке.

    Тогда у нас есть удобное сокращение:

     from math import * # Импортировать все идентификаторы из math,
                         # добавляем их в текущее пространство имен.
    x = sqrt (10) # Используйте их без квалификации.
     

    Из этих трех обычно предпочтительнее первый метод, даже если он
    означает, что набирать нужно немного больше каждый раз.Хотя мы можем делать вещи
    короче, импортировав модуль под другим именем:

     >>> import math as m
    >>> m.pi
    3,1415

    589793

    Но послушайте, с хорошими редакторами, которые делают автозаполнение, и быстрыми пальцами,
    это небольшая цена!

    Наконец, обратите внимание на этот случай:

     def area (радиус):
        импортная математика
        вернуть math.pi * radius * radius
    
    х = математика.sqrt (10) # Выдает ошибку
     

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

    12,9. Превратите тестер вашего устройства в модуль

    Ближе к концу главы 6 (Плодотворные функции) мы представили модульное тестирование и наш собственный тест.
    функции, и вам пришлось скопировать ее в каждый модуль, для которого вы
    написал тесты.Теперь мы можем поместить это определение в модуль его
    собственный, скажем unit_tester.py, и просто используйте вместо этого одну строку в каждом новом скрипте:

     из теста импорта unit_tester
     

    12.10. Глоссарий

    атрибут
    Переменная, определенная внутри модуля (или класса, или экземпляра — как мы будем
    увидим позже). Доступ к атрибутам модуля осуществляется с помощью точки .
    оператор
    (.).
    оператор точки
    Оператор точки (.) разрешает доступ к атрибутам и функциям
    модуль (или атрибуты и методы класса или экземпляра — как мы
    видел в другом месте).
    полное имя
    Имя, начинающееся с некоторого идентификатора пространства имен и оператора точки, или
    с помощью объекта-экземпляра, например math.sqrt или tess.forward (10).
    импортная ведомость

    Оператор, который делает объекты, содержащиеся в модуле, доступными для
    использовать в другом модуле. Есть две формы для импорта
    утверждение.Использование гипотетических модулей с именами mymod1 и mymod2
    каждый содержит
    функции f1 и f2, а также переменные v1 и v2, примеры
    из этих двух форм включают:

     импорт mymod1
    из mymod2 импортировать f1, f2, v1, v2
     

    Вторая форма переносит импортированные объекты в пространство имен
    модуль импорта, а первая форма сохраняет отдельный
    пространство имен для импортированного модуля, требующее доступа к mymod1.v1
    переменная v1 из этого модуля.

    метод

    Функциональный атрибут объекта. Методы вызываются (вызываются) на
    объект, использующий оператор точки. Например:

     >>> s = "это строка."
    >>> s.upper ()
    «ЭТО СТРОКА».
    >>>
     

    Мы говорим, что метод upper вызывается для строки s.
    s — неявно первый аргумент для upper.

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

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

    вместо

    предотвращает конфликты имен.

    ndard библиотека
    Библиотека — это набор программного обеспечения, используемого в качестве инструментов при разработке.
    другого программного обеспечения. Стандартная библиотека языка программирования:
    набор таких инструментов, которые распространяются вместе с ядром программирования
    язык. Python поставляется с обширной стандартной библиотекой.

    12.11. Упражнения

    1. Открыть справку для модуля календаря.

      1. Попробуйте следующее:

         импорт календаря
        cal = календарь.TextCalendar () # Создаем экземпляр
        cal.pryear (2012) # Что здесь происходит?
         
      2. Обратите внимание, что неделя начинается в понедельник. Отважный студент CompSci
        считает, что лучше начать неделю, если начнется его неделя.
        Четверг, потому что тогда до выходных всего два рабочих дня, а
        каждую неделю есть перерыв посередине. Прочтите документацию для TextCalendar,
        и узнайте, как вы можете помочь ему напечатать календарь, который соответствует его потребностям.

      3. Найдите функцию для печати только того месяца, в котором в этом году выпадает ваш день рождения.

      4. Попробуйте это:

         d = calendar.LocaleTextCalendar (6, «ИСПАНСКИЙ»)
        d.pryear (2012)
         

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

      5. Экспериментируйте с calendar.isleap. Чего он ожидает как
        аргумент? Что он возвращает в результате? Что это за функция?

      Сделайте подробные записи о том, что вы узнали из этих упражнений.

    2. Открыть справку по математическому модулю.

      1. Сколько функций в математическом модуле?
      2. Что делает math.ceil? А как насчет math.floor? (Подсказка : оба
        floor и ceil ожидают аргументов с плавающей запятой.)
      3. Опишите, как мы вычисляли то же значение, что и math.sqrt.
        без использования математического модуля.
      4. Какие две константы данных в математическом модуле?

      Запишите подробные записи вашего расследования в этом упражнении.

    3. Осмотрите модуль копирования. Что делает deepcopy
      делать? В каких упражнениях из предыдущей главы можно было бы использовать дипкопию?
      удобно?

    4. Создайте модуль с именем mymodule1.py. Добавить атрибуты myage, установленные в
      ваш текущий возраст и год, установленный на текущий год. Создать еще один
      модуль с именем mymodule2.py. Добавьте атрибуты myage, равные 0, и
      Год установлен на год вашего рождения. Теперь создайте файл с именем
      namespace_test.py. Импортируйте оба модуля выше и напишите
      следующая выписка:

       печать ((mymodule2.myage - mymodule1.myage) ==
             (mymodule2.year - mymodule1.year))
       

      Когда вы запустите namespace_test.py, вы увидите либо True, либо
      Ложь в качестве вывода в зависимости от того, были ли у вас уже
      день рождения в этом году.

      Этот пример показывает, что разные модули могут иметь
      атрибуты с именами myage и year. Поскольку они находятся в разных пространствах имен,
      они не конфликтуют друг с другом. Когда мы пишем namespace_test.py, мы
      полностью определить, какой именно переменный год или мой возраст мы имеем в виду.

    5. Добавьте следующий оператор в mymodule1.py, mymodule2.py и
      namespace_test.py из предыдущего упражнения:

       print («Меня зовут», __name__)
       

      Запустите namespace_test.py. Что происходит? Почему? Теперь добавьте в
      внизу mymodule1.py:

       если __name__ == "__main__":
          print ("Это не будет работать, если я импортирован.")
       

      Запустите mymodule1.py и снова namespace_test.py. В каком случае ты
      увидеть новый оператор печати?

    6. В оболочке Python / интерактивном интерпретаторе попробуйте следующее:

      Что Тим Петерс говорит о пространствах имен?

    7. Дайте ответ интерпретатора Python на каждое из следующих из
      непрерывная сессия переводчика:

       >>> s = "Если бы мы вынули кости, они не были бы хрустящими, не так ли?"
      >>> с.расколоть()
      >>> тип (s.split ())
      >>> s.split ("о")
      >>> s.split ("i")
      >>> "0" .join (s.split ("o"))
       

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

       def myreplace (старый, новый, s):
          "" "Заменить все вхождения старого на новое в s." ""
          ...
      
      
      test (myreplace (",", ";", "то, то и другое") ==
                               "это; то; и еще кое-что")
      test (myreplace ("", "**",
                       "Слова теперь будут разделены звездами.") ==
                       «Слова ** теперь ** будут ** разделяться ** ** звездочками»)
       

      Ваше решение должно пройти тесты.

    8. Создайте модуль с именем wordtools.py с нашими тестовыми каркасами на месте.

      Теперь добавьте функции в эти тесты, пройдя:

       test (чистое слово ("что?") == "что")
      test (cleanword ("'сейчас!'") == "сейчас")
      test (cleanword ("? + = 'w-o-r-d!, @ $ ()'") == "слово")
      
      test (has_dashdash ("расстояние - но"))
      тест (не has_dashdash ("несколько"))
      тест (has_dashdash ("говорил--"))
      test (has_dashdash ("расстояние - но"))
      тест (не has_dashdash ("- йо-йо-"))
      
      test (extract_words ("Сейчас время! 'Сейчас', время? Да, сейчас.") ==
            ['сейчас', 'есть', 'то', 'время', 'сейчас', 'есть', 'то', 'время', 'да', 'сейчас'])
      test (extract_words ("она пыталась сделать реверанс, пока говорила - причудливо") ==
            ['она', 'пыталась', 'к', 'реверанс', 'как', 'она', 'говорила', 'причудливо'])
      
      test (wordcount («сейчас», [«сейчас», «есть», «время», «есть», «сейчас», «есть», «есть»]) == 2)
      test (wordcount ("is", ["now", "is", "time", "is", "now", "the", "is"]) == 3)
      test (wordcount («время», [«сейчас», «есть», «время», «есть», «сейчас», «есть», «есть»]) == 1)
      test (wordcount («лягушка», [«сейчас», «есть», «время», «есть», «сейчас», «есть», «есть»]) == 0)
      
      test (wordset ([«сейчас», «есть», «время», «есть», «сейчас», «есть», «есть»]) ==
            [«есть», «сейчас», «время»])
      test (wordset (["Я", "a", "a", "is", "a", "is", "I", "am"]) ==
            [«Я», «а», «есть», «есть»])
      test (wordset (["or", "a", "am", "is", "are", "be", "but", "am"]) ==
            [«а», «я», «есть», «быть», «но», «есть», «или»])
      
      тест (длинное слово (["а", "яблоко", "груша", "виноград"]) == 5)
      test (longestword (["a", "am", "I", "be"]) == 2)
      test (longestword (["это", "supercalifragilisticexpialidocious"]) == 34)
      тест (длинное слово ([]) == 0)
       

      Сохраните этот модуль, чтобы вы могли использовать содержащиеся в нем инструменты в будущих программах.

    чисел в Python — настоящий Python

    Чтобы хорошо программировать, не нужно быть математиком. По правде говоря, немногим программистам нужно знать больше, чем основы алгебры. Конечно, то, сколько математики вам нужно знать, зависит от приложения, над которым вы работаете. В целом, уровень математики, необходимый для программиста, ниже, чем вы могли ожидать. Хотя математика и компьютерное программирование не так взаимосвязаны, как некоторые думают, числа являются неотъемлемой частью любого языка программирования, и Python не исключение.

    Из этого руководства вы узнаете, как:

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

    Приступим!

    Примечание: Это руководство адаптировано из главы «Числа и математика» в книге Основы Python: практическое введение в Python 3 .

    В книге используется встроенный редактор IDLE Python для создания и редактирования файлов Python и взаимодействия с оболочкой Python, поэтому в этом руководстве вы увидите ссылки на встроенные инструменты отладки IDLE. Однако у вас не должно возникнуть проблем с запуском примера кода из редактора и среды по вашему выбору.

    Бесплатный бонус: 5 мыслей о Python Mastery, бесплатный курс для разработчиков Python, который показывает вам план действий и образ мышления, которые вам понадобятся, чтобы вывести свои навыки Python на новый уровень.

    Целые числа и числа с плавающей запятой

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

    Целые числа

    Целое число — это целое число без десятичных знаков. Например, 1 — целое число, а 1.0 — нет. Имя для целочисленного типа данных — int , которое вы можете увидеть с помощью type () :

    >>>

      >>> тип (1)
    <класс 'int'>
      

    Вы можете создать целое число, набрав желаемое число. Например, следующее присваивает целое число 25 переменной num :

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

    Возможно, вы уже знакомы с тем, как преобразовать строку, содержащую целое число, в число с помощью int () . Например, следующее преобразует строку "25" в целое число 25 :

    int ("25") не является целочисленным литералом, поскольку целочисленное значение создается из строки.

    Когда вы пишете большие числа от руки, вы обычно группируете цифры в группы по три, разделенные запятой или десятичной точкой. Число 1000000 читать намного легче, чем число 1000000.

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

    >>>

      >>> 1000000
    1000000
    
    >>> 1_000_000
    1000000
      

    Нет предела тому, насколько большим может быть целое число, что может быть удивительно, учитывая, что компьютеры имеют конечный объем памяти. Попробуйте ввести наибольшее число, которое вы можете придумать, в интерактивном окне IDLE.Python справится с этим без проблем!

    Числа с плавающей запятой

    Число с плавающей запятой или с плавающей запятой для краткости — это число с десятичной запятой. 1,0 — это число с плавающей запятой, как и -2,75 . Имя типа данных с плавающей запятой — float :

    >>>

      >>> тип (1.0)
    <класс 'float'>
      

    Подобно целым числам, числа с плавающей запятой могут быть созданы из литералов с плавающей запятой или путем преобразования строки в число с плавающей запятой с помощью float () :

    >>>

      >>> float ("1.25 дюймов)
    1,25
      

    Есть три способа представить литерал с плавающей запятой. Каждое из следующих действий создает литерал с плавающей запятой со значением один миллион:

    >>>

      >>> 1000000.0
    1000000,0
    
    >>> 1_000_000.0
    1000000,0
    
    >>> 1e6
    1000000,0
      

    Первые два способа аналогичны двум методам создания целочисленных литералов. Третий подход использует нотацию E для создания литерала с плавающей запятой.

    Примечание: обозначение E является сокращением от экспоненциального представления .Возможно, вы видели, что это обозначение используется калькуляторами для представления чисел, которые слишком велики для отображения на экране.

    Чтобы написать литерал с плавающей запятой в нотации E, введите число, за которым следует буква e , а затем еще одно число. Python берет число слева от e и умножает его на 10 , возведенное в степень числа после e . Итак, 1e6 эквивалентно 1 × 10⁶.

    Python также использует нотацию E для отображения больших чисел с плавающей запятой:

    >>>

      >>> 200000000000000000.0
    2e + 17
      

    Поплавок 200000000000000000.0 отображается как 2e + 17 . Знак + указывает, что показатель степени 17 является положительным числом. Вы также можете использовать отрицательные числа в качестве экспоненты:

    Литерал 1e-4 интерпретируется как 10 в степени -4 , что составляет 1/10000, или 0,0001 .

    В отличие от целых чисел, числа с плавающей запятой имеют максимальный размер. Максимальное число с плавающей запятой зависит от вашей системы, но что-то вроде 2e400 должно выходить за рамки возможностей большинства машин. 2e400 составляет 2 × 10⁴⁰⁰, что намного больше, чем общее количество атомов во Вселенной!

    При достижении максимального числа с плавающей запятой Python возвращает специальное значение с плавающей запятой, inf :

    inf означает бесконечность, и это просто означает, что число, которое вы пытались создать, превышает максимальное значение с плавающей запятой, разрешенное на вашем компьютере. Тип inf по-прежнему float :

    >>>

      >>> п = 2e400
    >>> п
    инф
    >>> тип (n)
    <класс 'float'>
      

    Python также использует -inf , что означает отрицательную бесконечность и представляет собой отрицательное число с плавающей запятой, которое превышает минимальное число с плавающей запятой, разрешенное на вашем компьютере:

    Вы, вероятно, не будете часто встречать inf и -inf как программист, если только вы не работаете регулярно с очень большими числами.

    Проверьте свое понимание

    Разверните блок ниже, чтобы проверить свое понимание:

    Напишите программу, которая создает две переменные: num1 и num2 . И num1 , и num2 должны быть назначены целочисленным литералом 25000000 , один записан с подчеркиванием, а другой без. Выведите num1 и num2 на двух отдельных строках.

    Вы можете развернуть блок ниже, чтобы увидеть решение:

    Сначала присвойте значение 25000000 num1 без подчеркивания:

    Затем в новой строке присвойте значение 25_000_000 переменной num2 :

    Распечатайте обе переменные в отдельных строках, передав каждую переменную в отдельные вызовы print () :

    В выводе видно, что оба числа совпадают:

    Хотя обеим переменным присвоено значение 25000000 , запись значения с использованием подчеркивания для группировки цифр значительно упрощает человеку быстрое определение числа.Больше не надо щуриться в экран и считать нули!

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

    Арифметические операторы и выражения

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

    Дополнение

    Сложение производится оператором + :

    Два числа по обе стороны от оператора + называются операндами .В приведенном выше примере оба операнда являются целыми числами, но операнды не обязательно должны быть одного типа.

    Вы можете без проблем добавить int к float :

    Обратите внимание, что результат 1.0 + 2 равен 3.0 , что является числом с плавающей точкой . Каждый раз, когда к числу добавляется число с плавающей запятой , результатом является еще одно число с плавающей запятой . Сложение двух целых чисел всегда приводит к int .

    Примечание: PEP 8 рекомендует разделять оба операнда от оператора пробелом.

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

    Вычитание

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

    >>>

      >>> 1 - 1
    0
    
    >>> 5,0 - 3
    2.0
      

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

    Оператор - также используется для обозначения отрицательных чисел:

    Вы можете вычесть отрицательное число из другого числа, но, как вы можете видеть ниже, это иногда может сбивать с толку:

    >>>

      >>> 1 - -3
    4
    
    >>> 1 --3
    4
    
    >>> 1- -3
    4
    
    >>> 1--3
    4
      

    Из четырех приведенных выше примеров первый наиболее соответствует требованиям PEP 8.Тем не менее, вы можете заключить -3 в круглые скобки, чтобы было еще яснее, что второй - модифицирует 3 :

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

    Умножение

    Чтобы умножить два числа, используйте оператор * :

    >>>

      >>> 3 * 3
    9
    
    >>> 2 * 8.0
    16.0
      

    Тип числа, получаемого при умножении, подчиняется тем же правилам, что и сложение и вычитание. Умножение двух целых чисел дает int , а умножение числа на с плавающей запятой дает с плавающей запятой .

    Дивизион

    Оператор / используется для деления двух чисел:

    >>>

      >>> 9/3
    3.0
    
    >>> 5,0 / 2
    2,5
      

    В отличие от сложения, вычитания и умножения, деление с оператором / всегда возвращает с плавающей точкой .Если вы хотите убедиться, что после деления двух чисел вы получаете целое число, вы можете использовать int () для преобразования результата:

    Имейте в виду, что int () отбрасывает любую дробную часть числа:

    5.0 / 2 возвращает число с плавающей запятой 2.5 , а int (2.5) возвращает целое число 2 с удаленным .5 .

    Целочисленное деление

    Если запись int (5.0 / 2) кажется вам немного затянутой, Python предоставляет второй оператор деления, называемый оператором целочисленного деления ( // ), также известный как оператор деления этажа :

    >>>

      >>> 9 // 3
    3
    
    >>> 5.0 // 2
    2.0
    
    >>> -3 // 2
    -2
      

    Оператор // сначала делит число слева на число справа, а затем округляет до целого числа. Это может не дать ожидаемого значения, когда одно из чисел отрицательное.

    Например, -3 // 2 возвращает -2 . Сначала -3 делится на 2 , чтобы получить -1,5 . Затем -1,5 округляется до -2 . С другой стороны, 3 // 2 возвращает 1 , потому что оба числа положительны.

    Приведенный выше пример также показывает, что // возвращает число с плавающей запятой, когда одним из операндов является с плавающей запятой . Вот почему 9 // 3 возвращает целое число 3 , а 5.0 // 2 возвращает с плавающей запятой 2.0 .

    Давайте посмотрим, что произойдет, если вы попытаетесь разделить число на 0 :

    >>>

      >>> 1/0
    Отслеживание (последний вызов последний):
      Файл "", строка 1, в 
    ZeroDivisionError: деление на ноль
      

    Python дает вам ZeroDivisionError , сообщая вам, что вы только что пытались нарушить фундаментальное правило вселенной.

    Экспоненты

    Вы можете возвести число в степень с помощью оператора ** :

    >>>

      >>> 2 ** 2
    4
    
    >>> 2 ** 3
    8
    
    >>> 2 ** 4
    16
      

    Показатели не обязательно должны быть целыми числами. Также они могут быть поплавками:

    >>>

      >>> 3 ** 1,5
    5,196152422706632
    
    >>> 9 ** 0,5
    3.0
      

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

    Для положительных операндов оператор ** возвращает int, , если оба операнда являются целыми числами, и с плавающей запятой, , если любой из операндов является числом с плавающей запятой.

    Вы также можете возводить числа в отрицательную степень:

    >>>

      >>> 2 ** -1
    0,5
    
    >>> 2 ** -2
    0,25
      

    Возведение числа в отрицательную степень аналогично делению 1 на число в положительной степени.Итак, 2 ** -1 совпадает с 1 / (2 ** 1) , что совпадает с 1/2 или 0,5 . Точно так же 2 ** -2 совпадает с 1 / (2 ** 2) , что совпадает с 1/4 или 0,25 .

    Оператор модуля

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

    >>>

      >>> 5% 3
    2
    
    >>> 20% 7
    6
    
    >>> 16% 8
    0
      

    3 делит 5 один раз на остаток 2 , поэтому 5% 3 равно 2 .Аналогично, 7 делит 20 дважды с остатком 6 . В последнем примере 16 делится на 8 , поэтому 16% 8 равно 0 . Каждый раз, когда число слева от % делится на число справа, результат будет 0 .

    Одно из наиболее распространенных применений % — определить, делится ли одно число на другое. Например, число n даже тогда и только тогда, когда n% 2 равно 0 .Как вы думаете, что возвращает 1% 0 ? Давай попробуем:

    >>>

      >>> 1% 0
    Отслеживание (последний вызов последний):
      Файл "", строка 1, в 
    ZeroDivisionError: целочисленное деление или по модулю нуля
      

    Это имеет смысл, потому что 1% 0 дает остаток от деления 1 на 0 . Но вы не можете разделить 1 на 0 , поэтому Python вызывает ZeroDivisionError .

    Примечание: Когда вы работаете в интерактивном окне IDLE, такие ошибки, как ZeroDivisionError , не вызывают особых проблем.Отображается ошибка и появляется новое приглашение, позволяющее продолжить писать код.

    Однако, когда Python обнаруживает ошибку при выполнении сценария, выполнение останавливается. Другими словами, программа вылетает из . В главе 8 книги «Основы Python » вы узнаете, как обрабатывать ошибки, чтобы ваши программы не зависали неожиданно.

    Все становится немного сложнее, если вы используете оператор % с отрицательными числами:

    >>>

      >>> 5% -3
    -1
    
    >>> -5% 3
    1
    
    >>> -5% -3
    -2
      

    Несмотря на то, что на первый взгляд они могут шокировать, эти результаты являются продуктом четко определенного поведения в Python.Чтобы вычислить остаток r от деления числа x на число y , Python использует уравнение r = x - (y * (x // y)) .

    Например, чтобы найти 5% -3 , Python сначала находит (5 // -3) . Поскольку 5 / -3 составляет около -1,67 , это означает, что 5 // -3 равно -2 . Теперь Python умножает это на -3 , чтобы получить 6 . Наконец, Python вычитает 6 из 5 , чтобы получить -1 .

    Арифметические выражения

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

    Вот несколько примеров арифметических выражений:

    >>>

      >>> 2 * 3 - 1
    5
    
    >>> 4/2 + 2 ** 3
    10.0
    
    >>> -1 + (-3 * 2 + 4)
    -3
      

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

    Операторы * , /, // и % все имеют равный приоритет или приоритет в выражении, и каждый из них имеет более высокий приоритет, чем + и - операторов. Вот почему 2 * 3 - 1 возвращает 5 , а не 4 . 2 * 3 оценивается первым, потому что * имеет более высокий приоритет, чем оператор - .

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

    Если используются операторы с разными приоритетами, рассмотрите возможность добавления пробелов вокруг операторов с самым низким приоритетом (-ами). Используйте свое собственное суждение; однако никогда не используйте более одного пробела и всегда используйте одинаковое количество пробелов с обеих сторон двоичного оператора.(Источник)

    Еще одна хорошая практика — использовать круглые скобки для обозначения порядка, в котором должны выполняться операции, даже если скобки не нужны. Например, (2 * 3) - 1 потенциально яснее, чем 2 * 3 — 1.

    Заставьте Python лгать

    Как вы думаете, что такое 0,1 + 0,2 ? Ответ: 0,3 , верно? Посмотрим, что скажет об этом Python. Попробуйте это в интерактивном окне:

    >>>

      >>> 0.1 + 0,2
    0,30000000000000004
      

    Ну вот и все. . . почти правильно. Что, черт возьми, здесь происходит? Это ошибка в Python?

    Нет, это не ошибка! Это ошибка представления с плавающей запятой , и она не имеет ничего общего с Python. Это связано с тем, как числа с плавающей запятой хранятся в памяти компьютера.

    Число 0,1 можно представить в виде дроби 1/10 . И число 0,1 , и его дробная часть 1/10 являются десятичными представлениями или десятичными представлениями .Компьютеры, однако, хранят числа с плавающей запятой в представлении с основанием 2, чаще называемом двоичным представлением .

    При представлении в двоичном формате с десятичным числом 0,1 происходит что-то знакомое, но, возможно, неожиданное. Дробь 1/3 не имеет конечного десятичного представления. То есть 1/3 = 0,3333 ... с бесконечным числом 3 после десятичной точки. То же самое происходит с дробью 1/10 в двоичной системе.

    Двоичное представление 1/10 представляет собой следующую бесконечно повторяющуюся дробь:

      0.00011001100110011001100110011 ...
      

    Компьютеры имеют ограниченную память, поэтому число 0,1 должно храниться как приблизительное, а не как его истинное значение. Сохраняемое приближение немного выше фактического значения и выглядит так:

      0,1000000000000000055511151231257827021181583404541015625
      

    Однако вы могли заметить, что при запросе напечатать 0,1 Python печатает 0,1 , а не приближенное значение, указанное выше:

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

    Поскольку аппроксимация 0,1 в двоичном формате — это всего лишь приближение, вполне возможно, что более одного десятичного числа имеют одинаковое двоичное приближение.

    Например, и 0,1 , и 0,10000000000000001 имеют одинаковое двоичное приближение. Python выводит кратчайшее десятичное число, которое разделяет приближение.

    Это объясняет, почему в первом примере этого раздела 0.1 + 0,2 не равно 0,3 . Python складывает двоичные приближения для 0,1 и 0,2 , что дает число, равное , а не , двоичное приближение для 0,3 .

    Если от всего этого начинает кружиться голова, не волнуйтесь! Если вы не пишете программы для финансов или научных вычислений, вам не нужно беспокоиться о неточности арифметики с плавающей запятой.

    Математические функции и числовые методы

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

    1. round () , для округления чисел до некоторого числа десятичных знаков
    2. abs () , для получения абсолютного значения числа
    3. pow () , для возведения числа в некоторую степень

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

    круглые числа с округлением

    ()

    Вы можете использовать round () для округления числа до ближайшего целого:

    >>>

      >>> круглый (2.3)
    2
    
    >>> круглый (2.7)
    3
      

    round () имеет неожиданное поведение, когда число заканчивается на ,5 :

    >>>

      >>> круглый (2,5)
    2
    
    >>> круглый (3,5)
    4
      

    2,5 округляется до 2 , а 3,5 округляется до 4 . Большинство людей ожидают, что число, оканчивающееся на ,5 , будет округлено в большую сторону, поэтому давайте подробнее рассмотрим, что здесь происходит.

    Python 3 округляет числа в соответствии со стратегией, называемой округлением связей до четных.Связка — это любое число, последняя цифра которого равна пяти. 2,5 и 3,1415 являются связями, а 1,37 — нет.

    Когда вы округляете связи до четного, вы сначала смотрите на цифру, равную единице десятичного знака, слева от последней цифры в галстуке. Если эта цифра четная, вы округлите ее в меньшую сторону. Если цифра нечетная, округлите в большую сторону. Поэтому 2,5 округляется до 2 и 3,5 округляется до 4 .

    Примечание. Округление связей до четного — это стратегия округления, рекомендованная для чисел с плавающей запятой IEEE (Институт инженеров по электротехнике и электронике), поскольку она помогает ограничить влияние округления на операции с большим количеством чисел.

    IEEE поддерживает стандарт под названием IEEE 754 для работы с числами с плавающей запятой на компьютере. Он был опубликован в 1985 году и до сих пор широко используется производителями оборудования.

    Вы можете округлить число до заданного количества десятичных знаков, передав второй аргумент функции round () :

    >>>

      >>> круглый (3,14159, 3)
    3,142
    
    >>> круглый (2.71828, 2)
    2,72
      

    Число 3,14159 округляется до трех десятичных знаков, чтобы получить 3.142 , а число 2,71828 округляется до двух десятичных знаков, чтобы получить 2,72 .

    Второй аргумент round () должен быть целым числом. Если это не так, Python вызывает ошибку TypeError :

    .
    >>>

      >>> круглый (2,65, 1,4)
    Отслеживание (последний вызов последний):
      Файл "", строка 1, в 
        круглый (2,65, 1,4)
    TypeError: объект float нельзя интерпретировать как целое число
      

    Иногда round () не дает правильного ответа:

    >>>

      >>> # Ожидаемое значение: 2.68
    >>> круглый (2,675, 2)
    2,67
      

    2,675 — это ничья, потому что оно находится ровно посередине между числами 2,67 и 2,68 . Поскольку Python округляет связи до ближайшего четного числа, можно ожидать, что round (2,675, 2) вернет 2,68 , но вместо этого он вернет 2,67 . Эта ошибка является результатом ошибки представления с плавающей запятой, а не ошибки в round () .

    Работа с числами с плавающей запятой может вызывать разочарование, но это разочарование не относится к Python.Все языки, реализующие стандарт с плавающей запятой IEEE, имеют одни и те же проблемы, включая C / C ++, Java и JavaScript.

    Однако в большинстве случаев небольшие ошибки, встречающиеся с числами с плавающей запятой, незначительны, и результаты round () совершенно полезны.

    Найдите абсолютное значение с помощью

    abs ()

    Абсолютное значение числа n равно n , если n положительно, и — n , если n отрицательно.Например, абсолютное значение 3 равно 3 , а абсолютное значение -5 равно 5 .

    Чтобы получить абсолютное значение числа в Python, вы используете abs () :

    >>>

      >>> абс (3)
    3
    
    >>> абс (-5,0)
    5.0
      

    abs () всегда возвращает положительное число того же типа, что и его аргумент. То есть абсолютное значение целого числа всегда является положительным целым числом, а абсолютное значение числа с плавающей запятой всегда является положительным числом с плавающей запятой.

    Повышение мощности с помощью

    pow ()

    Ранее вы узнали, как возвести число в степень с помощью оператора ** . Вы также можете использовать pow () для достижения того же результата.

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

    Например, в следующем примере pow () возводит 2 в степень 3 :

    Как и в случае с ** , показатель степени в pow () может быть отрицательным:

    Итак, в чем разница между ** и pow () ?

    Функция pow () принимает необязательный третий аргумент, который вычисляет первое число, возведенное в степень второго числа, а затем берет модуль по отношению к третьему числу.Другими словами, pow (x, y, z) эквивалентно (x ** y)% z .

    Вот пример, в котором x = 2 , y = 3 и z = 2 :

    Сначала 2 возводится в степень 3 , чтобы получить 8 . Затем вычисляется 8% 2 , что составляет 0 , потому что 2 делит 8 без остатка.

    Проверить, встроен ли поплавок

    Возможно, вы знакомы со строковыми методами, такими как .lower () , .upper () и .find () . Целые числа и числа с плавающей запятой также имеют методы.

    Числовые методы используются нечасто, но есть один, который может быть полезен. Числа с плавающей запятой имеют метод .is_integer () , который возвращает Истина , если число целое — это означает, что у него нет дробной части — и в противном случае возвращает Ложь :

    >>>

      >>> число = 2,5
    >>> num.is_integer ()
    Ложь
    
    >>> число = 2.0
    >>> num.is_integer ()
    Правда
      

    Одно из применений для .is_integer () — для проверки пользовательского ввода. Например, если вы пишете приложение для онлайн-заказа пиццерии, вам нужно проверить, является ли количество пиццы, вводимых клиентом, целым числом.

    Функции round (), , abs (), и pow () являются встроенными функциями, то есть вам не нужно ничего импортировать, чтобы использовать их. Но эти три функции едва касаются всех функций, доступных для работы с числами в Python.

    Чтобы получить еще больше удовольствия от математики, ознакомьтесь с математическим модулем Python: все, что вам нужно знать!

    Проверьте свое понимание

    Разверните блок ниже, чтобы проверить свое понимание:

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

      Введите число: 5,432
    5,432 с округлением до 2 знаков после запятой составляет 5,43
      

    Вы можете развернуть блок ниже, чтобы увидеть решение:

    Чтобы получить ввод от пользователя, передайте запрос на input () :

      user_input = input («Введите число:»)
      

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

    Значение, возвращаемое функцией input () , является строкой, поэтому перед округлением числа необходимо преобразовать его в число с плавающей запятой:

    Имейте в виду, что приведенный выше код предполагает, что строка user_input действительно содержит числовое значение, а не какой-либо другой текст.

    Примечание: Если user_input действительно содержит нечисловой текст, то будет вызвана ошибка ValueError .Ознакомьтесь с исключениями Python: Введение для получения информации о том, как обрабатывать такие типы ошибок.

    Теперь вы можете использовать round () для округления значения до двух десятичных знаков:

      округленное_число = круглое (число; 2)
      

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

    Наконец, вы можете распечатать вывод, вставив rounded_num в строку f:

      print (f "{число} с округлением до 2 десятичных знаков равно {округленное_число}")
      

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

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

    Печать чисел в стиле

    Для отображения чисел пользователю необходимо вставить числа в строку. Вы можете сделать это с помощью f-строк, заключив переменную, присвоенную номеру, в фигурные скобки:

    >>>

      >>> п = 7,125
    >>> f "Значение n равно {n}"
    "Значение n равно 7,125"
      

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

    Например, чтобы отформатировать значение n в приведенном выше примере до двух десятичных знаков, замените содержимое фигурных скобок в строке f на {n: .2f} :

    >>>

      >>> п = 7,125
    >>> f "Значение n равно {n: .2f}"
    "Значение n равно 7,12"
      

    Двоеточие (: ) после переменной n указывает, что все, что находится после него, является частью спецификации форматирования. В этом примере спецификация форматирования — .2f .

    .2 в .2f округляет число до двух десятичных знаков, а f сообщает Python отображать n как число с фиксированной точкой . Это означает, что число отображается ровно с двумя десятичными знаками, даже если исходное число имеет меньше десятичных знаков.

    Когда n = 7,125 , результатом {n: .2f} будет 7,12 . Как и в случае с round () , Python округляет связи даже при форматировании чисел внутри строк.Итак, если вы замените n = 7,125 на n = 7,126 , тогда результат {n: .2f} будет 7,13 :

    >>>

      >>> п = 7,126
    >>> f "Значение n равно {n: .2f}"
    «Значение n равно 7,13».
      

    Чтобы округлить до одного десятичного знака, замените ,2 на ,1 :

    >>>

      >>> п = 7,126
    >>> f "Значение n равно {n: .1f}"
    "Значение n равно 7,1"
      

    Когда вы форматируете число как фиксированную точку, оно всегда отображается с указанным вами точным количеством десятичных знаков:

    >>>

      >>> п = 1
    >>> f "Значение n равно {n :.2f} "
    "Значение n равно 1.00"
    >>> f "Значение n равно {n: .3f}"
    "Значение n равно 1.000"
      

    Вы можете вставлять запятые, чтобы сгруппировать целую часть больших чисел по тысячам с опцией , :

    >>>

      >>> п = 1234567890
    >>> f "Значение n равно {n :,}"
    'Значение n равно 1,234,567,890'
      

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

    >>>

      >>> п = 1234,56
    >>> f "Значение n равно {n:,. 2f}"
    "Значение n равно 1234,56".
      

    Спецификатор , .2f полезен для отображения значений валюты:

    >>>

      >>> баланс = 2000,0
    >>> потрачено = 256,35
    >>> остаток = баланс - потрачено
    
    >>> f "Потратив $ {потрачено: .2f}, у меня осталось $ {осталось:,. 2f}"
    «Потратив 256 долларов.35 лет, у меня осталось 1743,65 доллара ''
      

    Еще одна полезная опция — % , которая используется для отображения процентов. Параметр % умножает число на 100 и отображает его в формате с фиксированной точкой, за которым следует знак процента.

    Параметр % всегда должен стоять в конце спецификации форматирования, и его нельзя смешивать с параметром f . Например, .1% отображает число в процентах с точностью до одного десятичного знака:

    >>>

      >>> ratio = 0.9
    >>> f "Более {ratio: .1%} питонистов говорят:" Настоящий питон - это круто! ""
    «Более 90,0% питонистов говорят:« Настоящий питон - это круто! »»
    
    >>> # Отображение процента с двумя десятичными знаками
    >>> f "Более {ratio: .2%} питонистов говорят:" Настоящий питон - скала! ""
    «Более 90% питонистов говорят:« Настоящий питон - это круто! »»
      

    Язык форматирования mini — мощный и обширный. Вы видели здесь только основы. Для получения дополнительной информации ознакомьтесь с официальной документацией.

    Проверьте свое понимание

    Разверните блок ниже, чтобы проверить свое понимание:

    Выведите число 150000 в виде валюты с тысячами, сгруппированными через запятую.Валюта должна отображаться с двумя десятичными знаками и начинаться с символа доллара США.

    Вы можете развернуть блок ниже, чтобы увидеть решение:

    Давайте постепенно наращиваем нашу фа-струну.

    Во-первых, f-строка, которая отображает значение 150000 без какого-либо форматирования, выглядит так:

    >>>

      >>> f "{150000}"
    150000
      

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

    Чтобы значение отображалось как число с плавающей запятой, поставьте двоеточие (: ) после числа 150000 , за которым следует буква f :

    >>>

      >>> f "{150000: f}"
    "150000.000000"
      

    По умолчанию Python отображает число с шестью десятичными знаками точности. Валюта должна иметь только два десятичных знака точности, поэтому вы можете добавить ,2 между : и f :

    .
    >>>

      >>> f "{150000 :.2f} "
    "150000.00"
      

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

    >>>

      >>> f "{150000:,. 2f}"
    "150,000.00"
      

    Наконец, добавьте знак доллара ( $ ) в начало строки, чтобы указать, что значение указано в долларах США:

    >>>

      >>> f "$ {150000:,. 2f}"
    "150 000 долларов США"
      

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

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

    Комплексные числа

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

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

    Чтобы создать комплексное число в Python, вы просто пишете действительную часть, затем знак плюс, затем мнимую часть с буквой j в конце:

    Когда вы проверите значение n , вы заметите, что Python заключает число в круглые скобки:

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

    Мнимые числа имеют два свойства: .real и .imag , которые возвращают действительную и мнимую составляющие числа соответственно:

    >>>

      >>> п.реально
    1.0
    
    >>> n.imag
    2.0
      

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

    Комплексные числа также имеют метод .conjugate () , который возвращает комплексное сопряжение числа:

    >>>

      >>> п.сопрягать ()
    (1-2j)
      

    Для любого комплексного числа сопряженное число является комплексным числом с одинаковой действительной частью и мнимой частью, которая одинакова по модулю, но с противоположным знаком. Итак, в этом случае комплексное сопряжение 1 + 2j равно 1 - 2j .

    Свойства .real и .imag не нуждаются в скобках после них, как .conjugate () .

    Метод .conjugate () — это функция, которая выполняет действие над комплексным числом, тогда как .реальные и .imag не выполняют никаких действий — они просто возвращают некоторую информацию о номере.

    Различие между методами и свойствами — важный аспект объектно-ориентированного программирования.

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

    >>>

      >>> a = 1 + 2j
    >>> b = 3 - 4j
    
    >>> а + б
    (4-2j)
    
    >>> а - б
    (-2 + 6j)
    
    >>> а * б
    (11 + 2j)
    
    >>> а ** б
    (932.13432212 + 95.9465336603415j)
    
    >>> а / б
    (-0,2 + 0,4j)
    
    >>> а // б
    Отслеживание (последний вызов последний):
      Файл "", строка 1, в 
    TypeError: невозможно принять комплексное число.
      

    Интересно, хотя и не удивительно с математической точки зрения, объекты int и float также имеют .реальные свойства и .imag , а также метод .conjugate () :

    >>>

      >>> х = 42
    >>> x.real
    42
    >>> x.imag
    0
    >>> x.conjugate ()
    42
    
    >>> у = 3,14
    >>> y.real
    3,14
    >>> y.imag
    0,0
    >>> y.conjugate ()
    3,14
      

    Для чисел с плавающей запятой и целых чисел .real и .conjugate () всегда возвращают само число, а .imag всегда возвращает 0 .Однако следует отметить, что n.real и n.imag возвращают целое число, если n является целым числом, и число с плавающей запятой, если n является плавающим.

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

    С другой стороны, комплексные числа важны в таких областях, как научные вычисления и компьютерная графика.Если вы когда-либо работали в этих областях, вам может пригодиться встроенная в Python поддержка комплексных чисел.

    Заключение: числа в Python

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

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

    • Как выполнять простую арифметику с числами с помощью арифметических операторов Python
    • Как написать арифметических выражений , используя лучшие практики PEP 8
    • Что такое чисел с плавающей запятой и почему они не всегда могут быть точными на 100 процентов
    • Как круглых чисел с округлением ()
    • Что такое комплексных чисел и как они поддерживаются в Python

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

    Дополнительная литература

    Дополнительную информацию о числах и математике в Python можно найти на следующих ресурсах:

    Python Input Output (I / O) Использование функций input () и print ()

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

    Некоторые функции, такие как input () и print () , широко используются для стандартных операций ввода и вывода соответственно.Давайте сначала посмотрим на раздел вывода.


    Вывод Python с использованием функции print ()

    Мы используем функцию print () для вывода данных на стандартное устройство вывода (экран). Мы также можем вывести данные в файл, но об этом мы поговорим позже.

    Пример его использования приведен ниже.

     
    print ('Это предложение выводится на экран')  

    Выход

      Это предложение выводится на экран  

    Другой пример приведен ниже:

      а = 5
    print ('Значение a равно', a)  

    Выход

      Значение a равно 5  

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

    Фактический синтаксис функции print () :

    print (* объекты, sep = '', end = '\ n', file = sys.stdout, flush = False) 

    Здесь объектов — значение (я) для печати.

    Между значениями используется разделитель sep . По умолчанию используется пробел.

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

    Файл — это объект, в котором печатаются значения, и его значение по умолчанию — sys.stdout (экран). Вот пример, чтобы проиллюстрировать это.

      печать (1, 2, 3, 4)
    печать (1, 2, 3, 4, sep = '*')
    печать (1, 2, 3, 4, sep = '#', end = '&')  

    Выход

      1 2 3 4
    1 * 2 * 3 * 4
    1 # 2 # 3 # 4 и  

    Форматирование вывода

    Иногда нам нужно отформатировать наш вывод, чтобы он выглядел привлекательно. Это можно сделать с помощью метода str.format () . Этот метод виден любому строковому объекту.

      >>> х = 5; у = 10
    >>> print ('Значение x равно {}, а y равно {}'. format (x, y))
    Значение x равно 5, а y равно 10  

    .

    Здесь фигурные скобки {} используются в качестве заполнителей. Мы можем указать порядок, в котором они печатаются, используя числа (индекс кортежа).

      print ('Я люблю {0} и {1}'. Format ('хлеб', 'масло'))
    print ('Я люблю {1} и {0}'. format ('хлеб', 'масло'))  

    Выход

      Я люблю хлеб с маслом
    Я люблю масло и хлеб  

    Мы даже можем использовать аргументы ключевого слова для форматирования строки.

      >>> print ('Привет, {имя}, {приветствие}'. Format (welcome = 'Goodmorning', name = 'John'))
    Привет, Джон, доброе утро  

    Мы также можем форматировать строки, как в старом стиле sprintf () , используемом в языке программирования C. Для этого мы используем оператор % .

      >>> х = 12,3456789
    >>> print ('Значение x равно% 3.2f'% x)
    Значение x равно 12,35.
    >>> print ('Значение x равно% 3.4f'% x)
    Значение x равно 12.3457  

    Ввод Python

    До сих пор наши программы были статичными. Значение переменных было определено или жестко закодировано в исходном коде.

    Чтобы обеспечить гибкость, мы можем захотеть получить ввод от пользователя. В Python у нас есть функция input () , позволяющая это сделать. Синтаксис для input () :

    ввод ([подсказка]) 

    , где подсказка — строка, которую мы хотим отобразить на экране. Это необязательно.

      >>> num = input ('Введите число:')
    Введите число: 10
    >>> число
    '10'  

    Здесь мы видим, что введенное значение 10 является строкой, а не числом. Чтобы преобразовать это в число, мы можем использовать функции int () или float () .

      >>> int ('10 ')
    10
    >>> float ('10 ')
    10,0  

    Эту же операцию можно выполнить с помощью функции eval () . Но eval идет дальше.Он может вычислять даже выражения, если на входе строка

      >>> int ('2 + 3')
    Отслеживание (последний вызов последний):
      Файл «<строка>», строка 301, в коде выполнения
      Файл «<интерактивный ввод>», строка 1, в <модуле>
    ValueError: недопустимый литерал для int () с базой 10: '2 + 3'
    >>> eval ('2 + 3')
    5  

    Python Импорт

    Когда наша программа станет больше, рекомендуется разбить ее на разные модули.

    Модуль — это файл, содержащий определения и инструкции Python.Модули Python имеют имя файла и заканчиваются расширением .py .

    Определения внутри модуля можно импортировать в другой модуль или интерактивный интерпретатор в Python. Для этого мы используем ключевое слово import .

    Например, мы можем импортировать модуль math , набрав следующую строку:

      импорт математики  

    Мы можем использовать модуль следующими способами:

      импорт математики
    печать (math.pi)  

    Выход

      3.1415

    589793

    Теперь все определения внутри модуля math доступны в нашей области. Мы также можем импортировать только некоторые определенные атрибуты и функции, используя ключевое слово из . Например:

      >>> from math import pi
    >>> пи
    3,1415

    589793

    При импорте модуля Python просматривает несколько мест, определенных в sys.path . Это список расположений каталогов.

      >>> import sys
    >>> sys.дорожка
    ['',
     'C: \ Python33 \ Lib \ idlelib',
     'C: \ Windows \ system32 \ python33.zip',
     'C: \ Python33 \ DLLs',
     'C: \ Python33 \ lib',
     'C: \\ Python33',
     'C: \ Python33 \ lib \ site-packages']  

    Мы также можем добавить в этот список наше собственное местоположение.

    Python-номеров


    Python-числа

    В Python есть три числовых типа:

    Переменные числовых типов создаются при присвоении им значения:

    Пример

    х = 1
    # int
    y = 2.8 # float
    z = 1j # сложный

    Чтобы проверить тип любого объекта в Python, используйте функцию type () :


    Внутр.

    Int или целое число — это целое число,
    положительное или отрицательное, без десятичных знаков, неограниченной длины.

    Пример

    Целые числа:

    x = 1
    y = 35656222554887711
    z =
    -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 (введите (z))

    Попробуй сам »



    Комплекс

    Комплексные числа записываются с мнимой частью «j»:

    Пример

    Комплекс:

    x = 3 + 5j
    y = 5j
    z = -5j

    print (type (x))
    print (type (y))
    print (введите (z))

    Попробуй сам »


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

    Вы можете преобразовать один тип в другой с помощью int () ,
    float () и complex () методы:

    Пример

    Преобразование из одного типа в другой:

    x = 1 # int
    y = 2.8 # float
    z = 1j # complex

    # преобразовать int в float:
    a = float (x)

    # преобразовать из float в int:
    b = int (y)

    # преобразовать int в сложный:
    c = complex (x)

    print (a)
    print (b)
    print (c)

    print (тип (a))
    print (тип (b))
    print (тип (c))

    Попробуй сам »

    Примечание: Комплексные числа нельзя преобразовать в числа другого типа.


    Случайное число

    Python не имеет функции random () для
    сделать случайное число, но в Python есть встроенный модуль, называемый
    случайных , которые можно использовать для получения случайных чисел:

    Пример

    Импортировать случайный модуль и отображать случайное число от 1 до 9:

    импортировать случайный отпечаток

    (random.randrange (1, 10))

    Попробуй сам »

    В нашем справочнике по произвольному модулю вы узнаете больше о модуле «Случайный выбор».



    Модуль Phonenumbers в Python — GeeksforGeeks

    Python — очень мощный язык, к тому же очень богатый библиотеками. phonenumbers — один из модулей, который предоставляет множество функций, таких как предоставление базовой информации о номере телефона, проверка номера телефона и т. Д. Здесь мы узнаем, как использовать модуль phonenumbers, просто написав простые программы на Python.Это порт Python библиотеки libphonenumber от Google.

    Установка

    Установите модуль телефонных номеров, введя следующую команду в командной строке.

     pip install телефонные номера
     

    Начало работы

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

    Python3

    импорт телефонные номера

    телефонный номер = тел.

    печать (phoneNumber)

    Выход:

     Код страны: 91 Национальный номер: 9876543210
     

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

    Python3

    импорт телефонные номера

    из телефонные номераparse ( "+6543210" )

    часовой пояс = часовой пояс.time_zones_for_number (номер телефона)

    47

    48

    Вывод:

     («Азия / Калькутта»,)
     

    3. Извлечь телефонные номера из текста: С помощью этого модуля мы можем извлечь телефонные номера, которые присутствуют в тексте / абзаце.Вы можете перебирать его, чтобы получить последовательность телефонных номеров. Для этого объект PhoneNumberMatcher предоставляет соответствующую функцию.

    Python3

    импорт телефонные номера

    текст = "Свяжитесь с нами по телефону +6543210 или +14638000 9

    37 phonenumbers.PhoneNumberMatcher (текст, "IN" )

    для номер в номера распечатать:

    47

    4

    Выход:

     PhoneNumberMatch [14,27) +6543210
     

    4.Оператор и регион телефонного номера: Здесь мы узнаем, как найти оператора связи и регион телефонного номера, используя функции геокодера и оператора связи этого модуля.

    Python3

    импорт телефонные номера

    из телефонные номера импорт геокодер, оператор связи

    телефонный номер

    parse ( "+6543210" )

    Carrier = carrier.name_for_number (phoneNumber, 000 'en' 7 регион) 7 9 7 9 = geocoder.description_for_number (phoneNumber, 'en' )

    print (Carrier)

    print

    print 9 (Region) :

     Airtel
    Индия
     

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

    Python3

    импорт телефонные номера

    телефонный_номер = phonenumbers.parse ( 8134 9139 8000 8148134 = телефонных номеров.is_valid_number (phone_number)

    возможных = phonenumbers.is_possible_number (phone_number)

    4 распечатать (распечатать)

    Выход:

     Ложь
    Правда 

    Внимание компьютерщик! Укрепите свои основы с помощью курса Python Programming Foundation и изучите основы.

    Для начала подготовьтесь к собеседованию. Расширьте свои концепции структур данных с помощью курса Python DS . И чтобы начать свое путешествие по машинному обучению, присоединитесь к Машинное обучение - курс базового уровня

    Модуль дроби на Python - GeeksforGeeks

    Модуль дроби на Python

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

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

    1. класс дробей. Дробь (числитель = 0, знаменатель = 1): Это требует, чтобы числитель и знаменатель были экземплярами чисел. Возвращается Rational и экземпляр дроби со значением = (числитель / знаменатель). Ошибка нулевого деления возникает, если знаменатель = 0.

      из фракций импорт Фракция

      печать (фракция ( 11 , 9 35000) 9 35000 печать (дробь ( 10 , 18 ))

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

      0

      0

    0 Выход
    11/35
    5/9
    0

  • класс фракций.Fraction (other_fraction): Для этого требуется, чтобы other_fraction был экземпляром чисел. Возвращается Rational и экземпляр дроби с таким же значением.
  • class fractions.Fraction (float): Для этого требуется экземпляр float , и возвращается экземпляр дроби с таким же значением.

    из фракций импорт фракция

    печать (фракция ( 1.13 ))

    Выход:

    1272266894732165/1125899

    2624

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

    из фракций импорт фракция

    печать (фракция ( '1.13 ' ))

    Выход:

    113/100
     
  • class fractions.Fraction (string): Для этого требуется строка или экземпляр экземпляра unicode , и возвращается экземпляр фракции с тем же значением.

    Форма для этого экземпляра: [знак] числитель [знаменатель «/»]
    Здесь знак представляет «+» или «-», а числитель и знаменатель представляют собой строки из однозначных чисел.

    из фракций импорт Фракция

    печать (фракция ( 000 8/25 '

    00 ) print (Дробь ( '1.13 ' ))

    печать (фракция ( ' 3/7 ' ))

    печать 2 t \ n ' ))

    Выход:

    25 августа
    113/100
    3/7
    1414213/1000000
     
  • limit_denominator (max_denominator = 1000000):
    • Этот метод полезен для поиска рациональных приближений к заданному числу с плавающей запятой.
    • Этот модуль находит и возвращает ближайшую к себе дробь, знаменатель которой не превышает max_denominator.
    • Этот модуль также можно использовать для возврата числителя данной дроби в наименьшем члене с помощью свойства числитель и знаменателя с помощью свойства знаменатель .

    из фракций импорт фракция

    печать (фракция ( '3.1415

    5897

    46 ' ))

    print (Дробь ( ' 3,1415

    5897

    46 ' ) .limit_denominator14 10000 Дробь ( '3,1415

    5897

    46' ) .limit_denominator ( 100 ))

    печать ( '3.1415

    5897

    46 ' ) .limit_denominator ( 10 ))

    print (Фракция ( 125 , ) 9

    печать (Дробь ( 125 , 50 ). Знаменатель)

    Выход:

    157079632679489661923/50000000000000000000
    355/113
    311/99
    22/7
    5
    2
     
  • Выполнение математических операций над дробями

    из дробей импорт Дробь

    100 ) + Дробь ( 25 , 18 ))

    печать (Дробь ( 18, ) / Дробь ( 18 , 10 ))

    печать (Дробь ( 18 , 5 908) , 5 908 Дробь ( 16 , 19 ))

    9 0813

    печать (Дробь ( 18 , 5 ) * Дробь ( 15 , 36 9000) 9 печать (Дробь ( 12 , 5 ) * * Дробь ( 12 , 000 10 ) Выход:

    2267/900
    2
    288/95
    3/2
    2.85556
     

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

    импорт математика

    из дробей импорт 7

    (math.sqrt (Fraction ( 25 , 4 )))

    print (math.sqrt (Fraction ( 28 , 3 )))

    print (math.floor (Fraction) 3558 8 12138

    print (Дробь (math.sin (math.pi / 3 )))

    print (math.sin print математика.pi / 3 )). limit_denominator ( 10 ))

    Выход:

    2,5
    3,0550504633
    2.0
    3
  • 1685776981/4503599627370496 6/7
  • Автор статьи Aditi Gupta . Если вам нравится GeeksforGeeks, и вы хотели бы внести свой вклад, вы также можете написать статью на сайте deposit.geeksforgeeks.org или отправить свою статью по почте @ geeksforgeeks.орг. Посмотрите, как ваша статья появляется на главной странице GeeksforGeeks, и помогите другим гикам.

    Пожалуйста, напишите комментарии, если вы обнаружите что-то неправильное, или если вы хотите поделиться дополнительной информацией по теме, обсуждаемой выше.

    Внимание компьютерщик! Укрепите свои основы с помощью курса Python Programming Foundation и изучите основы.

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

    Как отформатировать число как строку валюты в Python

    Введение

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

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

    Способы форматирования чисел

    Мы рассмотрим три альтернативные библиотеки и функции, которые позволяют нам конвертировать числа в денежные строки:

    • Модуль локали.
    • Вавилонский модуль.
    • Функция str.format () .

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

    Форматирование числа как денежной строки с языковым стандартом

    Модуль locale уже предустановлен с вашей версией Python .

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

    Инициализация локали

    Чтобы начать использовать модуль locale , сначала необходимо установить локаль:

      импорт локали
    
    
    печать (locale.setlocale (locale.LC_ALL, ''))
    
    
    печать (locale.setlocale (locale.LC_ALL, 'en_GB'))
      

    Приведенный выше код даст следующий результат:

      English_United States 1252
    en_GB
      

    Чтобы получить список доступных локалей, вы можете найти его в MS-LCID. Как вариант, распечатайте:

     
    для языка в локали.windows_locale.values ​​():
            печать (lang)
    
    
    для языка в locale.locale_alias.values ​​():
        печать (lang)
      

    Выполнение любого из вышеперечисленных вариантов даст примерно следующее:

      ru_GB
    af_ZA
    sq_AL
    gsw_FR
    am_ET
    ar_SA
    ar_IQ
    ar_EG
    ar_LY
    ar_DZ
    ...
      
    Форматирование чисел с использованием локали

    Выбрав предпочитаемый языковой стандарт, вы можете легко форматировать числовые строки:

      locale.setlocale (locale.LC_ALL, '')
    
    
    печать (locale.currency (12345.67, группировка = True))
    печать (locale.currency (12345.67))
      

    Запустив приведенный выше код, мы получим следующий результат:

      12 345,67 долл. США
    12345,67 долл. США
      

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

    str.format () метод

    Следующий метод, который мы рассмотрим, - это метод str.format () , преимущество которого заключается в том, что он наиболее простой:

      number_string = 340020,8
    
    number_commas_only = "{:,}". формат (строка_числа)
    печать (number_commas_only)
    
    
    number_two_decimal = "{:.2f} ". Формат (строка_числа)
    печать (число_два_десятичное)
    
    
    currency_string = "$ {:,. 2f}". format (number_string)
    печать (денежная_строка)
      

    Запустив приведенный выше код, мы получим следующий результат:

      340 020,8
    340020,80
    $ 340 020,80
      

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

    Форматирование числа как денежной строки с помощью Babel

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

    • 30-дневная гарантия возврата денег без вопросов
    • От начального до продвинутого
    • Регулярно обновляется (последнее обновление июнь 2021 г.)
    • Обновляется с дополнительными ресурсами и руководствами

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

    Чтобы установить Babel через pip , выполните следующую команду:

      $ pip установить Babel
    ...
    Успешно установлен Babel-2.9.0
      

    После установки для достижения тех же результатов, что и два других метода, перечисленных выше, вы можете просто вызвать format_currency () со строкой:

      импортные бабел. Номера
    number_string = 340020,8
    
    
    babel.numbers.format_currency (number_string, «USD», locale = 'en_US')
      

    Запустив приведенный выше код, мы получим следующий результат:

      340 020,80 долл. США
      

    Чтобы получить полный список доступных локалей:

      avail_loc = babel.localedata.locale_identifiers ()
    печать (avail_loc)
      

    Это выглядит примерно так:

      ['af', 'af_NA', 'af_ZA', 'agq', 'agq_CM', 'ak', 'ak_GH', 'am', 'am_ET', ...]
      

    Поиск чисел в строках и форматирование в денежном выражении

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

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

      импорт ре
    импортировать локаль
    импорт babel.numbers
    locale.setlocale (locale.LC_ALL, 'en_US')
      

    Затем мы придумываем шаблон регулярного выражения, необходимый для сопоставления числовых строк:

     
     шаблон = r '\ d + (\. \ d {1,2})?'
      

    Затем мы применяем три метода, которые мы узнали, к строковой переменной message :

      message = "Наш текущий бюджет составляет 180000, нам понадобится 25000.67 на покрытие арендной платы, затем 23400,4 на питание ".
    
    
    
    
    new_message_locale = re.sub (
        шаблон, лямбда x: locale.currency (float (x.group ()), grouping = True), message
    )
    new_message_str = re.sub (
        шаблон, лямбда x: "$ {:,. 2f}". формат (float (x.group ())), сообщение
    )
    new_message_babel = re.sub (
        шаблон,
        лямбда x: babel.numbers.format_currency (float (x.group ()), «USD», locale = «en_US»),
        сообщение,
    )
      

    Давайте сравним исходный результат с результатом, полученным всеми тремя методами:

      печать (сообщение)
    печать (new_message_locale)
    печать (new_message_str)
    печать (new_message_babel)
      
      Наш текущий бюджет 180000, нам понадобится 25000.67 на покрытие арендной платы, затем 23400,4 на питание.
    Наш текущий бюджет составляет 180 000,00 долларов, нам понадобится 25 000,67 долларов на оплату аренды, затем 23 400,40 долларов на еду.
    Наш текущий бюджет составляет 180 000,00 долларов, нам понадобится 25 000,67 долларов на оплату аренды, затем 23 400,40 долларов на еду.
    Наш текущий бюджет составляет 180 000,00 долларов, нам понадобится 25 000,67 долларов на оплату аренды, затем 23 400,40 долларов на еду.
      

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

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

    Заключение

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

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

    .

    Добавить комментарий

    Ваш адрес email не будет опубликован.