Числа в Python

Когда мы хотим представить информацию о количестве деревьев в саду, остатке на банковской карте или же провести какие-либо математические расчеты, мы используем числа. В Python числа представлены сразу несколькими родственными категориями типов. Сюда относятся целые (int), вещественные (float) и комплексные (complex) числа. Если возможностей базовых типов не хватает, всегда можно воспользоваться числовыми расширениями в виде модулей decimal или fractions. Все перечисленные числовые типы довольно легко преобразуются между собой, а математические операции с ними интуитивно понятны и производятся по общепринятым правилам математики.

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

Пример №1. Литералы целых чисел в Python.

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

• В десятичной системе счисления целые числа записываются в виде привычной нам последовательности цифр от нуля до десяти, например, 0, -33, +127.
• В двоичной системе счисления запись целого числа должна начинаться с нуля и латинской буквы B в верхнем или нижнем регистре (т.е. 0b или 0B), после чего должна идти последовательность нулей и единиц. Например, 0b01101, 0B1011, -0b1001. Если будут использованы другие цифры, интерпретатор сгенерирует сообщение об ошибке.
• В восьмеричной системе счисления целое число должно начинаться с нуля и латинской буквы O в верхнем или нижнем регистре (т.е. 0o или 0O), после чего должна идти последовательность цифр от нуля до семи (01234567). Например, 0o77, 0O35, -0O174. Если будут использованы цифры не входящие в данный диапазон, интерпретатор сгенерирует сообщение об ошибке.
• В шестнадцатеричной системе счисления запись целого числа должна начинаться с нуля и латинской буквы X в верхнем или нижнем регистре (т.е. 0x или 0X), после чего должны идти символы последовательности 0123456789ABCDEF, представляющих данную систему счисления. При этом буквы также разрешается использовать в любом регистре. Например, 0x7F, 0XDD5A, -0xfF9. Если будут использованы символы не входящие в данный диапазон, интерпретатор сгенерирует сообщение об ошибке.

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

• bin(int_num) – преобразует целое число в двоичную систему счисления, возвращая строку с представлением литерала числа в этой системе.
• oct(int_num) – преобразует целое число в восьмеричную систему счисления, возвращая строку с представлением литерала числа в этой системе.
• hex(int_num) – преобразует целое число в шестнадцатеричную систему счисления, возвращая строку с представлением литерала числа в этой системе.
• int(obj) – конструктор типа int может использоваться как с одним, так и с двумя аргументами. Когда указан только один аргумент, функция пытается преобразовать объект в целое число в десятичной системе счисления, а в случае невозможности такого преобразования возбуждает соответствующее исключение. При этом, если объект obj является вещественным числом, оно преобразуется в целое путем усечения дробной части, например, int(21.302) вернет 21.
• int(num_str, base=10) – если указано два аргумента, то первый аргумент должен быть строковым представлением целого числа в системе счисления с указанным основанием base. Разрешается использовать системы счисления с основаниями от 2 до 36. При этом префикс 0b, 0o или 0x у строкового представления числа можно опускать. Если же точно известно, что в строковом представлении числа присутствует соответствующий префикс, второму аргументу разрешается передавать ноль, т.к. интерпретатор сможет определить систему счисления переводимого числа по указанному префиксу. В случае невозможности преобразования строки в целое число функция возбуждает соответствующее исключение (см. пример №2).

Пример №2. Перевод целых чисел между СС.

Итак, функции bin(int_num), oct(int_num) и hex(int_num) принимают целые числа и возвращают строковые представления этих чисел в соответствующих системах счисления. Если же требуется обратное преобразование в десятичную систему, то следует передавать числа функции int(num) или, для их строковых представлений, функции int(num_str, base=10), предварительно указав основание системы счисления base переводимого числа.

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

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

Пример №3. Пример очень большого целого числа.

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

Операция	Описание
x | y	Битовое or (ИЛИ). Отрицательные числа представляются как двоичное дополнение.
x ^ y	Битовое xor (исключающее ИЛИ).
x & y	Битовое and (И).
x << n	Побитовый сдвиг влево (сдвигает значение x влево на n битов аналогично операции x*(2* *n) без проверки на переполнение).
x >> y	Побитовый сдвиг вправо (сдвигает значение x вправо на n битов аналогично операции x//(2**n) без проверки на переполнение ).
~x	Инверсия битов числа.

Таблица №4. Список битовых операций, применимых к целым числам.

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

• int.bit_length() – метод возвращает количество бит, которое необходимо для представления числа в памяти в двоичном виде, без учета знака и незначащих (лидирующих) нулей;
• int.to_bytes(length, byteorder, *, signed=False) – метод возвращает массив байтов, который соответствует данному числу;
• int.from_bytes(bytes, byteorder, *, signed=False) – метод класса, который возвращает целое число, соответствующее указанному массиву байтов.

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

Что касается записи литералов вещественных чисел (по-другому чисел с плавающей точкой), то в Python для них используется привычный нам математический синтаксис: сперва записывается знак числа (плюс можно не указывать), затем последовательность цифр целой части, разделительная точка и последовательность цифр дробной части. Например, 0.33, .33, 0.0, .0, -123.45, -.123. Также допустима запись вещественных чисел в экспоненциальной форме. При этом для представления степени 10ⁿ используется латинская буква E в верхнем или нижнем регистре (т.е. e или E), следующий за ней необязательный знак плюс или обязательный знак минус, а также сам показатель степени в виде положительного целого числа или нуля (см. пример №5).

Пример №5. Литералы вещественных чисел в Python.

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

Пример №6. Точность представления вещественных чисел в Python.

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

Пример №7. Побочные эффекты сложения вещественных чисел в Python.

Как видим, на первый взгляд результат действительно получился неожиданным (не забываем про кнопку «Результат»). Однако все верно. Ведь в данном случае при переводе десятичных чисел в двоичную систему компьютер не смог перевести их точно, округлив результат так, чтобы получившееся двоичное число поместилось в пределах выделяемого для хранения вещественного числа объема памяти. В результате у нас получилось число несколько меньшее, чем 0.8. Но, повторимся, это не проблема Python, это проблема математики и невозможности во всех случаях осуществить точный перевод чисел из одной системы счисления в другую.

Не стоит сравнивать вещественные числа, доверяя их точности до последнего знака.

В заключение данного пункта перечислим дополнительные методы типа float.

• float.as_integer_ratio() – метод возвращает кортеж из пары целых чисел, которые представляют собой числитель и знаменатель наименьшей дроби, равной данному вещественному числу. Если вещественное число отрицательное, то первое число в возвращаемом кортеже будет со знаком минус. При этом второе число всегда положительное (см. пример №8).
• float.is_integer() – метод возвращает True, если дробная часть вещественного числа равна нулю.
• float.hex() – метод возвращает строковое представление числа с плавающей точкой в шестнадцатеричной системе счисления. При этом следует иметь в виду, что экспонента в таком представлении обозначается буквой p, т.к. буква e представляет собой допустимый символ в 16-ной системе счисления.
• float.fromhex(float_num_str) – этот метод класса осуществляет преобразование строкового представления вещественного числа float_num_str в шестнадца­теричной системе счисления обратно в вещественное число в десятичной системе счисления.

Пример №8. Дополнительные методы типа float.

Комплексные числа в Python представлены типом complex, который хранит два вещественных числа: первое представляет собой действительную часть комплексного числа, а второе – мнимую. Как и принято в математике, действительная и мнимая части литерала комплексного числа объединяются знаком плюс или минус (см. пример №9). Однако за мнимой частью в Python следует символ j, как это принято в инженерии (в математике мнимая единица обозначается через i).

Пример №9. Литералы комплексных чисел в Python.

Как видно из примера, если действительная часть комплексного числа равна 0, ее можно опустить. Кроме того, отдельные части комплексного числа доступны в виде атрибутов real и imag, а получить сопряженное данному комплексное число можно изменив знак мнимой части при помощи метода complex.conjugate().

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

Все известные нам со школы математические операции полностью поддерживаются в Python. Перечислим их и рассмотрим примеры.

• x + y – сложение двух чисел.
• x - y – вычитание двух чисел.
• x * y – умножение двух чисел.
• x / y – деление двух чисел. При делении вещественных и целых чисел (даже без остатка) результат всегда является вещественным числом. Если же в делении присутствуют комплексные числа, интерпретатор возвращает комплексный результат (см. пример №10).
• x // y – деление с округлением вниз. Например, 1//2 = 0, -1//2 = -1, 1//-2 = -1, -1//-2 = 0.
• x % y – операция возвращает остаток от деления целых и вещественных чисел. Если оба числа целые, то возвращается целочисленный остаток (тип int). Например, 5%3 = 2, -5%3 = 1 (т.к. -5 = 3*(-2) + 1), 6%3 = 0. Если хотя бы одно число вещественное, остаток от деления также возвращается в вещественном виде (тип float), при чем из-за неточности представления вещественных чисел результат может оказаться неточным. Например, 5.2%3 = 2.2 (все в порядке), -5.2%3 = 0.7999999999999998 (получили неточный результат, хотя ожидали 0.8, т.к. -5.2 = 3*(-2) + 0.8). Что касается комплексных чисел, то для них операция неприменима.
• +x – операция используется в основном для повышения удобочитаемости кода, т.к. по факту она ничего не делает.
• -x – инверсия знака числа отличного от нуля, т.е. изменение плюса на минус или наоборот. Для нуля ничего не происходит.
• x ** y – возведение в степень. Отметим, что 0**0 = 1.

Пример №10. Базовые математические операции в Python.

Что касается математических выражений, в которых используются сразу несколько операций, то для их группировки предназначены круглые скобки (см. пример №11). При этом внутри скобок приоритет отдается сперва возведению в степень (x**y), затем равносильно умножению (x*y), делению (x/y), делению с округлением вниз (x//y) и получению остатка от деления (x%y); в конце равнозначно выполняются сложение (x + y) и вычитание (x - y). Более подробно о приоритете операторов в Python (и не только математических) мы поговорим позже.

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

Пример №11. Математические выражения в Python.

Обратите внимание, что при наличии в одном выражении целых и вещественных чисел, интерпретатор при необходимости осуществляет приведение целых чисел к типу float, т.е. к более объемлющему типу (в математике целые числа являются подмножеством вещест­вен­ных, а те в свою очередь принадлежат множеству комплексных чисел).

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

• divmod(x, y) – возвращает кортеж (x//y, x%y). При этом для комплексных чисел она не предназначена.
• pow(x, y) – возвращает x в степени y (аналог x ** y).
• abs(x) – возвращает абсолютное значение (модуль) числа x.
• round(x, n) – округляет число до n-го разряда после запятой. Если аргумент n не указан, то число округляется до ближайшего целого.
• max(num_1, num_2, ..., num_n) – возвращает максимальное из двух и более чисел.
• min(num_1, num_2, ..., num_n) – возвращает минимальное из двух и более чисел.
• sum(num_1, num_2, ..., num_n) – возвращает сумму двух и более чисел.
• int(x) – приведение числа к типу int.
• float(x) – приведение числа к типу float.
• complex(re, im=0) – приведение к типу complex. Аргумент im (мнимая часть будущего комплексного числа) можно не передавать, тогда он по умолчанию будет равен нулю.

Пример №12. Встроенные математические функции в Python.

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

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

• x < y – выражение вернет True, если x строго меньше y.
• x > y – выражение вернет True, если x строго больше y.
• x <= y – выражение вернет True, если x меньше или равно y.
• x >= y – выражение вернет True, если x больше или равно y.
• x == y – выражение вернет True, если x равно y (в программировании один знак равно означает присвоить, поэтому для обозначения равенства используются два знака равно).
• x != y – выражение вернет True, если x не равно y.

Использование операторов сравнения показано в примере №13.

Пример №13. Операторы сравнения чисел в Python.

В дополнение к базовому оператору присваивания = в Python применяется целый ряд комбинированных операторов присваивания, которые объединяют операцию присваивания с другой операцией. В общем случае выражение присваивания с комбини­рованным оператором x op= y можно считать сокращенной записью выражения x = x op y, где вместо op следует подставлять один из арифметических операторов. Например, x += y является сокращенной записью выражения x = x + y, в котором к значению переменной x прибавляется значение переменной y, после чего результат присваивается переменной x. Использование некоторых комбинированных операторов присваивания показано в примере №14.

Пример №14. Комбинированные операторы присваивания в Python.

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

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

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

• math.pi – представляет значение числа π с точностью, которая зависит от конкретной платформы. Мы его помним, как число 3.14.
• math.tau (чит. тау) – представляет удвоенное значение числа π с точностью, которая зависит от конкретной платформы. Т. о. τ – это отношение радиуса окружности к ее длине. Прибли­зительно оно равно 6.28.
• math.e – представляет значение числа e с точностью, которая зависит от конкретной платформы. Мы его помним, как число 2.72.
• math.inf (от англ. infinity) – представляет положительную бесконечность. Отметим, что значение является типом float и может быть получено вызовом конструктора float('inf'). Для получения отрицательной бесконечности следует использовать унарный оператор - (см. пример №15). К значению inf в математике приводит, например, операция деления на 0.
• math.nan (от англ. not a number) – представляет значение не число, которое также является типом float и может быть получено вызовом конструктора float('nan'). К значению nan приводят недопустимые математические операции (например, извлечение корня четной степени из отрицательного числа на множестве вещественных чисел) или выход за допустимый диапазон значений для данной математической функции.
• math.isinf(x) – возвращает True, если x является отрицательной или положительной бесконечностью, или False в противном случае.
• math.isnan(x) – возвращает True, если x является значением nan, или False в противном случае.
• math.isfinite(x) – возвращает False, только если x является nan, inf или -inf. Во всех остальных случаях функция возвращает True.

Пример №15. Математические константы модуля math.

Что касается конкретно функций модуля math, то в нем представлены различные функции теории чисел, степенные, логарифмические, тригонометрические, гиперболические и ряд других функций. Все мы их здесь рассматривать не будем, однако краткое описание некоторых из них приведем в списке ниже. Остальные в случае необходимости всегда можно с легкостью найти в разделе «Numeric and Mathematical Modules» справочника стандартной библиотеки в описании модуля math (или cmath для комплексных чисел). Итак.

• math.ceil(x) – возвращает x, округленное вверх до ближайшего целого (см. пример №16).
• math.floor(x) – возвращает x, округленное вниз до ближайшего целого.
• math.trunc(x) – возвращает целую часть x, полностью отсекая дробную.

Пример №16. Функции модуля math (часть 1).

• math.factorial(x) – возвращает факториал неотрицательного целого числа x. Отметим, что факториалы чисел 0 и 1 принимаются равными 1.
• math.sqrt(x) – возвращает квадратный корень из неотрицательного числа x (см. пример №17).
• math.log(x[, base]) – возвращает логарифм числа x по основанию base. Аргумент base можно опустить, тогда функция вернет натуральный логарифм числа x.

Пример №17. Функции модуля math (часть 2).

• math.sin(x) – возвращает синус угла x, значение которого задано в радианах. Отметим, что для косинуса угла функция имеет вид math.cos(x) (см. пример №18).
• math.tan(x) – возвращает тангенс угла x, значение которого задано в радианах.
• math.asin(x) – возвращает арксинус числа x. Для аркосинуса нужно использовать функцию math.acos(x), а для арктангенса – math.atan(x).
• math.degrees(x) – преобразует угол x из радиан в градусы.
• math.radians(x) – преобразует угол x из градусов в радианы.

Пример №18. Функции модуля math (часть 3).

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

Как мы уже знаем, числа типа float имеют весьма ограниченную точность. И хотя во многих случаях это не существенно, бывают ситуации, когда требуется повышенная точность вычислений, пусть даже и в ущерб производительности. В таких случаях нам на помощь приходит модуль decimal, который реализует неизменяемый числовой тип Decimal, представляющий числа с фиксированной точностью (см. пример №19).

Пример №19. Создание чисел фиксированной точности.

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

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

Числа типа Decimal обычно используются в определенном контексте, который подразумевает использование установленной точности представления, методики округления (вверх, вниз и т.д.) и некоторых других настроек (см. пример №20).

Пример №20. Изменение точности представления чисел Decimal.

Все настройки среды для арифметических операций получаемые при помощи метода decimal.getcontext() доступны для изменения. Кроме того, для установки нового контекста можно использовать метод decimal.setcontext(). С этим и некоторыми другими методами для работы с контекстами вы можете ознакомиться в модуле decimal стандартной библиотеки (см. раздел «Numeric and Mathematical Modules»).

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

Пример №21. Операции с числами Decimal.

Еще одним числовым типом в Python является тип Fraction. Он реализует объекты рациональных чисел, которые явным образом хранят числитель и знаменатель рациональной дроби (см. пример №22), что опять же при необходимости помогает избежать недостатков вещественных чисел.

Пример №22. Создание рациональных чисел.

В примере мы создали объекты рациональных чисел, указав в конструкторе Fraction в первом выражении числитель и знаменатель, а во втором передав ему вещественное число и строковое представление вещественного числа. Кроме того, рациональную дробь можно создать и конвертацией типа Decimal. В любом случае после создания объекты рациональных чисел могут участвовать в арифметических операциях, как обычные числа (см. пример №23).

Пример №23. Операции с рациональными числами.

Познакомиться с рациональными числами и их методами более подробно вы можете в модуле fractions стандартной библиотеки Python (см. раздел «Numeric and Mathematical Modules»).

• Числа в Python представлены тремя базовыми типами: целые числа int, числа с плавающей точкой float и комплексные числа complex. Также посредством стандартной библиотеки доступны два расширения в виде чисел с фиксированной точностью Decimal и рациональных чисел Fraction.
• Для записи литералов целых чисел используется десятичная система счисления, однако разрешается записывать их в двоичной (например, 0b101), восьмеричной (например, -0o175) и шестнадцатеричной (например, 0xF5A) системах счисления. Для перевода целых чисел из одной системы счисления в другую предназначены встроенные функции bin(int_num), oct(int_num), hex(int_num), int(num_str, base=10).
• Целые числа поддерживают длинную арифметику и могут быть сколь угодно большими. При этом следует помнить, что при обработке очень больших чисел приходится жертвовать скоростью их обработки.
• Для записи литералов вещественных чисел используется привычный нам математический синтаксис, например, -2.57, 0.0, .28 (ноль перед точкой можно опускать). Также допустима запись вещественных чисел в экспоненциальной форме, например, 1.2345e2 (т.е. 1.2345*10²) или -1.2345E-3 (т.е. -1.2345*10^-3).
• В обычных условиях точность вещественных чисел ограничивается максимум 17 значащими цифрами. Поэтому не стоит сравнивать их, доверяя точности до последнего знака.
• Комплексные числа в Python хранят два вещественных числа: первое представляет собой действительную часть комплексного числа, а второе – мнимую. Например, -0.4+7j, 2-1.45j или 3.1j (нулевую действительную часть можно опускать).
• В Python поддерживаются все известные нам со школы математические операции: сложение x + y, вычитание x - y, умножение x*y, деление x/y, деление с округлением вниз x//y, получение остатка от деления x%y, возведение в степень x**y. Стоит помнить, что некоторые операции не применимы к комплексным числам.
• В дополнение к базовому оператору присваивания = в Python применяется целый ряд комбинированных операторов присваивания, которые объединяют операцию присваивания с другой операцией. Например, +=, -=, *=, /=, //=, %=, **=. Как видим, в общем случае выражение присваивания с комбини­рованным оператором x op= y можно считать сокращенной записью выражения x = x op y, где вместо op следует подставлять один из арифметических операторов.
• Для сравнения чисел используются операторы <, >, <=, >=, == (равно), != (не равно).
• Помимо стандартных арифметических операций имеется и ряд полезных встроенных функций для работы с числами: divmod(x, y) – возвращает кортеж (x//y, x%y), pow(x, y) – возвращает x в степени y, abs(x) – возвращает модуль числа x, round(x, n) – округляет число до n-го разряда после запятой, max(num_1, num_2, ..., num_n), min(num_1, num_2, ..., num_n) и sum(num_1, num_2, ..., num_n) – соответственно возвращают максимальное, минимальное и сумму из двух и более чисел.
• Если встроенных функций недостаточно, можно воспользоваться расширением math стандартной библиотеки, которое обеспечивает доступ к широкому кругу математических функций и констант, которые определены стандартом языка C. Для комплексных чисел следует использовать модуль cmath.
• Для случаев, когда требуется повышенная точность вычислений, в Python предусмотрены дополнительные типы числовых объектов: числа с фиксированной точностью Decimal, которые позволяют устанавливать требуемую точность вычислений, способ округления и некоторые другие параметры, а также рациональные числа Fraction, которые явным образом хранят числитель и знаменатель рациональной дроби. Оба модуля доступны в стандартной библиотеке Python в разделе «Numeric and Mathematical Modules».

1. Какие из представленых литералов чисел относятся к типу int, а какие к типу float: 3.4, 0, 5.0, 0.0, 123+4.1j, 795? Проверьте типы программно. Показать решение.

# Выводим типы представленных литералов.
print('Тип 3.4:', type(3.4))
print('Тип 0:', type(0))
print('Тип 5.0:', type(5.0))
print('Тип 0.0:', type(0.0))	
print('Тип 123+4.1j:', type(123+4.1j))		
print('Тип 795:', type(795))

Тип 3.4: <class 'float'>
Тип 0: <class 'int'>
Тип 5.0: <class 'float'>
Тип 0.0: <class 'float'>
Тип 123+4.1j: <class 'complex'>
Тип 795: <class 'int'>
			

2. Определите системы счисления целых чисел 0x1101, 0b1101, 0o755, 0X755 и 755, записанные в исходном коде программы. Показать решение.

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

4. Как можно получить действительную и мнимую части комплексного числа? А как получить число, сопряженное к данному комплексному числу? Показать решение.

5. Вычислите устно и программно значения выражений 2*(3 + 4) и 2*3 + 4. Объясните результаты. Показать решение.

# Выводим результаты вычислений.
print('2*(3 + 4) =', 2*(3 + 4))
print('2*3 + 4 =', 2*3 + 4)

2*(3 + 4) = 14
2*3 + 4 = 10
			

6. Каким будет тип результата вычисления выражения 7 - 3 + 2.0 и почему? Проверьте свой ответ программно. Показать решение.

# Найдем результат.
res = 7 - 3 + 2.0
# Проверим тип.
print('Тип результата:', type(res))

				
Тип результата: <class 'float'>

			

7. Каким будет остаток от деления числа 63 на число 5? Проверьте свой ответ программно. Показать решение.

print('Остаток от деления 63 на 5:', 63%5)

Остаток от деления 63 на 5: 3

8. Как получить доступ к функциям модуля math? Показать решение.

9. Исправьте в коде пять ошибок (по одной в каждом блоке). Показать решение.

Импортируем модуль math.
import math

# Присвоим переменной вещественное число.
num_float = 375,44

# Округлим его до целых.
num_float = math.round(num_float)	

# Извлекаем корень из числа.
num_sqrt = sqrt(num_float)

# Выводим результат на экран.
input(num_sqrt)	

# Оформляем комментарий правильно.
# Импортируем модуль math.
import math

# Исправляем на десятичную точку.
# Присвоим переменной вещественное число.
num_float = 375.44

# round - это встроенная функция.
# Округлим его до целых.
num_float = round(375.44)	

# sqrt расположена в math.
# Извлекаем корень из числа.
num_sqrt = math.sqrt(num_float)

# input - ввод, print - вывод.
# Выводим результат на экран.
print(num_sqrt)	

10. Дополнительные тесты по теме расположены в разделе «Числа и математические выражения» нашего сборника тестов.

11. Дополнительные упражнения и задачи по теме расположены в разделе «Числа и математические выражения» нашего сборника задач и упражнений.

• Типы данных в Python
• Числа в Python
• Строки в Python
• К содержанию учебника