13 февраля 2021

Числа в Python

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

723

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

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

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

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

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

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

Целые числа

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

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

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

>>> num = 25

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

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

>>> int("25")
25

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

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

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

>>> 1000000
1000000

>>> 1_000_000
1000000

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

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

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

>>> type(1.0)
<class 'float'>

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

>>> float("1.25")
1.25

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

>>> 1000000.0
1000000.0

>>> 1_000_000.0
1000000.0

>>> 1e6
1000000.0

Первые два способа аналогичны двум методам создания целочисленных литералов. Третий подход использует нотацию 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 как программист, если только вы не будете регулярно работать с очень большими числами.

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

Два способа записать целые числа

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

Способ решения

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

num1 = 25000000

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

num2 = 25_000_000

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

print(num1)
print(num2)

На выходе вы можете видеть, что оба числа одинаковы:

25000000
25000000

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


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

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

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

Сложение

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

>>> 1 + 2
3

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

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

>>> 1.0 + 2
3.0

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

Вычитание

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

>>> 1 - 1
0

>>> 5.0 - 3
2.0

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

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

>>> -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, а умножение числа на floatfloat.

Деление

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

>>> 9 / 3
3.0

>>> 5.0 / 2
2.5

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

Число 0,1 можно представить как дробь 1/10. И число 0,1, и его дробная часть 1/10 являются десятичными представлениями или представлениями base-10. Однако компьютеры хранят числа с плавающей запятой в представлении base-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 имеет несколько встроенных функций, которые можно использовать для работы с числами. В этом разделе вы узнаете о трех наиболее распространенных:

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

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

Круглые числа с round()

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

>>> round(2.3)
2

>>> round(2.7)
3

Вы можете округлить число до заданного количества десятичных знаков, передав второй аргумент функции 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 без остатка.

Проверка, является ли float целым числом

Возможно, вы знакомы со строковыми методами, такими как .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.

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

Округлите числа до двух цифр

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

Enter a number: 5.432
5.432 rounded to 2 decimal places is 5.43

Решение

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

user_input = input("Enter a number: ")

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

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

num = float(user_input)

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

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

rounded_num = round(num, 2)

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

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

print(f"{num} rounded to 2 decimal places is {rounded_num}")

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


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

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

Для отображения чисел пользователю необходимо вставить числа в строку. Вы можете сделать это с помощью 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!'"

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

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

Отобразите валюту

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

Решение

Давайте постепенно наращивать нашу f-строку.

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

>>> f"{150000}"
150000

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

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

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

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

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

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

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

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

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

F-строки – это всего лишь один из способов форматирования чисел для отображения.


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

Сложные числа

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

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

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

>>> 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. Вы можете использовать эти знания для решения широкого круга проблем, с которыми вы столкнетесь в своей карьере программиста.