Числа в Python

Оглавление

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

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

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

Давайте начнем!

Примечание: Это руководство взято из главы “Числа и математика” в Основы Python: практическое введение в Python 3. Если вы предпочитаете видеокурс, то ознакомьтесь с Основами Python: числа и математика.

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

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

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

Целые числа

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

>>> type(1)
<class 'int'>

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

>>> num = 25

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

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

>>> int("25")
25

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

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

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

>>> 1000000
1000000

>>> 1_000_000
1000000

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

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

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

>>> type(1.0)
<class '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
0.0001

Литерал 1e-4 интерпретируется как 10, возведенный в степень -4, которая равна 1/10000, или 0.0001.

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

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

>>> 2e400
inf

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

>>> n = 2e400
>>> n
inf
>>> type(n)
<class 'float'>

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

>>> -2e400
-inf

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

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

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

Дополнение

Добавление выполняется с помощью оператора +:

>>> 1 + 2
3

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

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

>>> 1.0 + 2
3.0

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

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

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

Вычитание

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

>>> 1 - 1
0

>>> 5.0 - 3
2.0

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

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

>>> -3
-3

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

>>> 1 - -3
4

>>> 1 --3
4

>>> 1- -3
4

>>> 1--3
4

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

>>> 1 - (-3)
4

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

Умножение

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

>>> 3 * 3
9

>>> 2 * 8.0
16.0

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

Подразделение

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

>>> 9 / 3
3.0

>>> 5.0 / 2
2.5

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

>>> int(9 / 3)
3

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

>>> int(5.0 / 2)
2

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, поскольку оба числа положительные.

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

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

>>> 1 / 0
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: division by zero

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 возвращает float 3.0.

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

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

>>> 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
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ZeroDivisionError: integer division or modulo by zero

Это имеет смысл, потому что 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. Это связано с тем, как числа с плавающей запятой хранятся в памяти компьютера.

Примечание: Это руководство взято из главы “Числа и математика” в Основы Python: практическое введение в Python 3. Если вам нравится то, что вы читаете, то обязательно ознакомьтесь с остальной частью книги.

Число 0.1 может быть представлено в виде дроби 1/10. Как число 0.1, так и его дробь 1/10 являются десятичными представлениями или представлениями с основанием 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, а не приблизительное значение, указанное выше:

>>> 0.1
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()

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

>>> round(2.3)
2

>>> round(2.7)
3

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

>>> round(2.5)
2

>>> round(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():

>>> round(3.14159, 3)
3.142

>>> round(2.71828, 2)
2.72

Число 3.14159 округляется до трех знаков после запятой, чтобы получить 3.142, а число 2.71828 округляется до двух знаков после запятой, чтобы получить 2.72.

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

>>> round(2.65, 1.4)
Traceback (most recent call last):
  File "<pyshell#0>", line 1, in <module>
    round(2.65, 1.4)
TypeError: 'float' object cannot be interpreted as an integer

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

>>> # Expected value: 2.68
>>> round(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():

>>> abs(3)
3

>>> abs(-5.0)
5.0

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

Возводим в степень с pow()

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

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

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

>>> pow(2, 3)
8

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

>>> pow(2, -2)
0.25

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

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

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

>>> pow(2, 3, 2)
0

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

Проверьте, является ли число с плавающей точкой целым

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

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

>>> num = 2.5
>>> num.is_integer()
False

>>> num = 2.0
>>> num.is_integer()
True

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

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

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

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

>>> n = 7.125
>>> f"The value of n is {n}"
'The value of n is 7.125'

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

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

>>> n = 7.125
>>> f"The value of n is {n:.2f}"
'The value of n is 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:

>>> n = 7.126
>>> f"The value of n is {n:.2f}"
'The value of n is 7.13'

Для округления до одного знака после запятой замените .2 на .1:

>>> n = 7.126
>>> f"The value of n is {n:.1f}"
'The value of n is 7.1'

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

>>> n = 1
>>> f"The value of n is {n:.2f}"
'The value of n is 1.00'
>>> f"The value of n is {n:.3f}"
'The value of n is 1.000'

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

>>> n = 1234567890
>>> f"The value of n is {n:,}"
'The value of n is 1,234,567,890'

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

>>> n = 1234.56
>>> f"The value of n is {n:,.2f}"
'The value of n is 1,234.56'

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

>>> balance = 2000.0
>>> spent = 256.35
>>> remaining = balance - spent

>>> f"After spending ${spent:.2f}, I was left with ${remaining:,.2f}"
'After spending $256.35, I was left with $1,743.65'

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

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

>>> ratio = 0.9
>>> f"Over {ratio:.1%} of Pythonistas say 'Real Python rocks!'"
"Over 90.0% of Pythonistas say 'Real Python rocks!'"

>>> # Display percentage with 2 decimal places
>>> f"Over {ratio:.2%} of Pythonistas say 'Real Python rocks!'"
"Over 90.00% of Pythonistas say 'Real Python rocks!'"

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

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

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

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

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

>>> n = 1 + 2j

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

>>> n
(1+2j)

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

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

>>> n.real
1.0

>>> n.imag
2.0

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

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

>>> n.conjugate()
(1-2j)

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

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

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

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

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

>>> a = 1 + 2j
>>> b = 3 - 4j

>>> a + b
(4-2j)

>>> a - b
(-2+6j)

>>> a * b
(11+2j)

>>> a ** b
(932.1391946432212+95.9465336603415j)

>>> a / b
(-0.2+0.4j)

>>> a // b
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can't take floor of complex number.

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

>>> x = 42
>>> x.real
42
>>> x.imag
0
>>> x.conjugate()
42

>>> y = 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%
  • Как округлять числа с помощью round()
  • Что такое комплексные числа и как они поддерживаются в Python

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

Читать далее

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

Back to Top