Числа¶
Числа в Python 3 — целые, вещественные, комплексные. Работа с числами и операции над ними.
Целые числа (int)¶
Числа в Python 3 ничем не отличаются от обычных чисел. Они поддерживают набор самых обычных математических операций:
Синтаксис | Описание |
---|---|
x + y | Сложение |
x — y | Вычитание |
x * y | Умножение |
x / y | Деление |
x // y | Получение целой части от деления |
x % y | Остаток от деления |
-x | Смена знака числа |
abs(x) | Модуль числа |
divmod(x, y) | Пара ( x // y , x % y ) |
x ** y | Возведение в степень |
pow(x, y[, z]) | x y по модулю (если модуль задан) |
Также нужно отметить, что целые числа в python 3, в отличие от многих других языков, поддерживают длинную арифметику (однако, это требует больше памяти).
>>> 255 + 34 289 >>> 5 * 2 10 >>> 20 / 3 6.666666666666667 >>> 20 // 3 6 >>> 20 % 3 2 >>> 3 ** 4 81 >>> pow(3, 4) 81 >>> pow(3, 4, 27) 0 >>> 3 ** 150 369988485035126972924700782451696644186473100389722973815184405301748249
Битовые операции¶
Над целыми числами также можно производить битовые операции
Синтаксис | Описание |
---|---|
x | y | Побитовое или |
x ^ y | Побитовое исключающее или |
x & y | Побитовое и |
x | Битовый сдвиг влево |
x >> y | Битовый сдвиг вправо |
~x | Инверсия битов |
Дополнительные методы¶
int.bit_length() количество бит, необходимых для представления числа в двоичном виде, без учёта знака и лидирующих нулей.
>>> n = -37 >>> bin(n) '-0b100101' >>> n.bit_length() 6
int.to_bytes(length, byteorder, *, signed=False) возвращает строку байтов, представляющих это число.
>>> (1024).to_bytes(2, byteorder='big') b'\x04\x00' >>> (1024).to_bytes(10, byteorder='big') b'\x00\x00\x00\x00\x00\x00\x00\x00\x04\x00' >>> (-1024).to_bytes(10, byteorder='big', signed=True) b'\xff\xff\xff\xff\xff\xff\xff\xff\xfc\x00' >>> x = 1000 >>> x.to_bytes((x.bit_length() // 8) + 1, byteorder='little') b'\xe8\x03'
classmethod int.from_bytes(bytes, byteorder, *, signed=False) возвращает число из данной строки байтов.
>>> int.from_bytes(b'\x00\x10', byteorder='big') 16 >>> int.from_bytes(b'\x00\x10', byteorder='little') 4096 >>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=True) -1024 >>> int.from_bytes(b'\xfc\x00', byteorder='big', signed=False) 64512 >>> int.from_bytes([255, 0, 0], byteorder='big') 16711680
Системы счисления¶
Те, у кого в школе была информатика, знают, что числа могут быть представлены не только в десятичной системе счисления. К примеру, в компьютере используется двоичный код, и, к примеру, число 19 в двоичной системе счисления будет выглядеть как 10011 . Также иногда нужно переводить числа из одной системы счисления в другую. Python для этого предоставляет несколько функций:
int([object], [основание системы счисления]) преобразование к целому числу в десятичной системе счисления. По умолчанию система счисления десятичная, но можно задать любое основание от 2 до 36 включительно. bin(x) преобразование целого числа в двоичную строку. hex(х) преобразование целого числа в шестнадцатеричную строку. oct(х) преобразование целого числа в восьмеричную строку.
>>> a = int('19') # Переводим строку в число >>> b = int('19.5') # Строка не является целым числом Traceback (most recent call last): File "", line 1, in ValueError: invalid literal for int() with base 10: '19.5' >>> c = int(19.5) # Применённая к числу с плавающей точкой, # отсекает дробную часть >>> print(a, c) 19 19 >>> bin(19) '0b10011' >>> oct(19) '0o23' >>> hex(19) '0x13' >>> 0b10011 # Так тоже можно записывать числовые константы 19 >>> int('10011', 2) 19 >>> int('0b10011', 2) 19
Вещественные числа (float)¶
Вещественные числа поддерживают те же операции, что и целые. Однако (из-за представления чисел в компьютере) вещественные числа неточны, и это может привести к ошибкам:
>>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 0.9999999999999999
Для высокой точности используют другие объекты (например Decimal и Fraction )).
Также вещественные числа не поддерживают длинную арифметику:
>>> a = 3 ** 1000 >>> a + 0.1 Traceback (most recent call last): File "", line 1, in OverflowError: int too large to convert to float
Простенькие примеры работы с числами:
>>> c = 150 >>> d = 12.9 >>> c + d 162.9 >>> p = abs(d - c) # Модуль числа >>> print(p) 137.1 >>> round(p) # Округление 137
Дополнительные методы¶
float.as_integer_ratio() пара целых чисел, чьё отношение равно этому числу. float.is_integer() является ли значение целым числом. float.hex() переводит float в hex (шестнадцатеричную систему счисления). classmethod float.fromhex(s) float из шестнадцатеричной строки.
>>> (10.5).hex() '0x1.5000000000000p+3' >>> float.fromhex('0x1.5000000000000p+3') 10.5
Помимо стандартных выражений для работы с числами (а в Python их не так уж и много), в составе Python есть несколько полезных модулей.
Модуль math предоставляет более сложные математические функции.
>>> import math >>> math.pi 3.141592653589793 >>> math.sqrt(85) 9.219544457292887
Модуль random реализует генератор случайных чисел и функции случайного выбора.
>>> import random >>> random.random() 0.15651968855132303
Комплексные числа (complex)¶
В Python встроены также и комплексные числа:
>>> x = complex(1, 2) >>> print(x) (1+2j) >>> y = complex(3, 4) >>> print(y) (3+4j) >>> z = x + y >>> print(x) (1+2j) >>> print(z) (4+6j) >>> z = x * y >>> print(z) (-5+10j) >>> z = x / y >>> print(z) (0.44+0.08j) >>> print(x.conjugate()) # Сопряжённое число (1-2j) >>> print(x.imag) # Мнимая часть 2.0 >>> print(x.real) # Действительная часть 1.0 >>> print(x > y) # Комплексные числа нельзя сравнить Traceback (most recent call last): File "", line 1, in TypeError: unorderable types: complex() > complex() >>> print(x == y) # Но можно проверить на равенство False >>> abs(3 + 4j) # Модуль комплексного числа 5.0 >>> pow(3 + 4j, 2) # Возведение в степень (-7+24j)
Для работы с комплексными числами используется также модуль cmath .
Числа: целые, вещественные, комплексные
Числа в Python 3: целые, вещественные, комплексные. Работа с числами и операции над ними.
Целые числа (int)
Числа в Python 3 ничем не отличаются от обычных чисел. Они поддерживают набор самых обычных математических операций:
x + y | Сложение |
x — y | Вычитание |
x * y | Умножение |
x / y | Деление |
x // y | Получение целой части от деления |
x % y | Остаток от деления |
-x | Смена знака числа |
abs(x) | Модуль числа |
divmod(x, y) | Пара (x // y, x % y) |
x ** y | Возведение в степень |
pow(x, y[, z]) | x y по модулю (если модуль задан) |
Также нужно отметить, что целые числа в python 3, в отличие от многих других языков, поддерживают длинную арифметику (однако, это требует больше памяти).
Над целыми числами также можно производить битовые операции
x | y | Побитовое или |
x ^ y | Побитовое исключающее или |
x & y | Побитовое и |
x | Битовый сдвиг влево |
x >> y | Битовый сдвиг вправо |
~x | Инверсия битов |
Дополнительные методы
int.bit_length() — количество бит, необходимых для представления числа в двоичном виде, без учёта знака и лидирующих нулей.
int.to_bytes(length, byteorder, *, signed=False) - возвращает строку байтов, представляющих это число.
int.from_bytes(bytes, byteorder, *, signed=False) - возвращает число из данной строки байтов.
Те, у кого в школе была информатика, знают, что числа могут быть представлены не только в десятичной системе счисления. К примеру, в компьютере используется двоичный код, и, к примеру, число 19 в двоичной системе счисления будет выглядеть как 10011. Также иногда нужно переводить числа из одной системы счисления в другую. Python для этого предоставляет несколько функций:
- int([object], [основание системы счисления]) — преобразование к целому числу в десятичной системе счисления. По умолчанию система счисления десятичная, но можно задать любое основание от 2 до 36 включительно.
- bin(x) — преобразование целого числа в двоичную строку.
- hex(х) — преобразование целого числа в шестнадцатеричную строку.
- oct(х) — преобразование целого числа в восьмеричную строку.
Вещественные числа поддерживают те же операции, что и целые. Однако (из-за представления чисел в компьютере) вещественные числа неточны, и это может привести к ошибкам:
Для высокой точности используют другие объекты (например Decimal и Fraction)).
Также вещественные числа не поддерживают длинную арифметику:
Простенькие примеры работы с числами:
float.as_integer_ratio() — пара целых чисел, чьё отношение равно этому числу.
float.is_integer() — является ли значение целым числом.
float.hex() — переводит float в hex (шестнадцатеричную систему счисления).
classmethod float.fromhex(s) — float из шестнадцатеричной строки.
Помимо стандартных выражений для работы с числами (а в Python их не так уж и много), в составе Python есть несколько полезных модулей.
Модуль math предоставляет более сложные математические функции.
В Python встроены также и комплексные числа:
: complex() Для работы с комплексными числами используется также модуль cmath.
Для вставки кода на Python в комментарий заключайте его в теги
- Модуль csv - чтение и запись CSV файлов
- Создаём сайт на Django, используя хорошие практики. Часть 1: создаём проект
- Онлайн-обучение Python: сравнение популярных программ
- Книги о Python
- GUI (графический интерфейс пользователя)
- Курсы Python
- Модули
- Новости мира Python
- NumPy
- Обработка данных
- Основы программирования
- Примеры программ
- Типы данных в Python
- Видео
- Python для Web
- Работа для Python-программистов
- Сделай свой вклад в развитие сайта!
- Самоучитель Python
- Карта сайта
- Отзывы на книги по Python
- Реклама на сайте
Работа с числами в Python
В этом материале рассмотрим работу с числами в Python. Установите последнюю версию этого языка программирования и используйте IDE для работы с кодом, например, Visual Studio Code.
В Python достаточно просто работать с числами, ведь сам язык является простым и одновременно мощным. Он поддерживает всего три числовых типа:
- int (целые числа)
- float (числа с плавающей точкой)
- complex (комплексные числа)
Хотя int и float присутствуют в большинстве других языков программирования, наличие типа комплексных чисел — уникальная особенность Python. Теперь рассмотрим в деталях каждый из типов.
Целые и числа с плавающей точкой в Python
В программирование целые числа — это те, что лишены плавающей точкой, например, 1, 10, -1, 0 и так далее. Числа с плавающей точкой — это, например, 1.0, 6.1 и так далее.
Создание int и float чисел
Для создания целого числа нужно присвоить соответствующее значение переменной. Возьмем в качестве примера следующий код:
var1 = 25
Здесь мы присваиваем значение 25 переменной var1 . Важно не использовать одинарные или двойные кавычки при создании чисел, поскольку они отвечают за представление строк. Рассмотрим следующий код.
var1 = "25"
# или
var1 = '25'
В этих случаях данные представлены как строки, поэтому не могут быть обработаны так, как требуется. Для создания числа с плавающей точкой, типа float , нужно аналогичным образом присвоить значение переменной.
var1 = 0.001
Здесь также не стоит использовать кавычки.
Проверить тип данных переменной можно с помощью встроенной функции type() . Можете проверить результат выполнения, скопировав этот код в свою IDE.
var1 = 1 # создание int
var2 = 1.10 # создание float
var3 = "1.10" # создание строки
print(type(var1))
print(type(var2))
print(type(var3))
В Python также можно создавать крупные числа, но в таком случае нельзя использовать запятые.
# создание 1,000,000
var1 = 1,000,000 # неправильно
Если попытаться запустить этот код, то интерпретатор Python вернет ошибку. Для разделения значений целого числа используется нижнее подчеркивание. Вот пример корректного объявления.
# создание 1,000,000
var1 = 1_000_000 # правильно
print(var1)
Значение выведем с помощью функции print :
1000000
Арифметические операции над целыми и числами с плавающей точкой
Используем такие арифметические операции, как сложение и вычитание, на числах. Для запуска этого кода откройте оболочку Python, введите python или python3 . Терминал должен выглядеть следующим образом:

Сложение
В Python сложение выполняется с помощью оператора + . В терминале Python выполните следующее.
Результатом будет сумма двух чисел, которая выведется в терминале.

Теперь запустим такой код.
>>> 1.0 + 2 3.0
В нем было выполнено сложение целого и числа с плавающей точкой. Можно обратить внимание на то, что результатом также является число с плавающей точкой. Таким образом сложение двух целых чисел дает целое число, но если хотя бы один из операндов является числом с плавающей точкой, то и результат станет такого же типа.
Вычитание
В Python для операции вычитания используется оператор -. Рассмотрим примеры.
>>> 3 - 1 2 >>> 1 - 5 -4 >>> 3.0 - 4.0 -1.0 >>> 3 - 1.0 2.0
Положительные числа получаются в случае вычитания маленького числа из более крупного. Если же из маленького наоборот вычесть большое, то результатом будет отрицательно число. По аналогии с операцией сложения при вычитании если один из операндов является числом с плавающей точкой, то и весь результат будет такого типа.
Умножение
Для умножения в Python применяется оператор * .
>>> 8 * 2 16 >>> 8.0 * 2 16.0 >>> 8.0 * 2.0 16.0
Если перемножить два целых числа, то результатом будет целое число. Если же использовать число с плавающей точкой, то результатом будет также число с плавающей точкой.
Деление
В Python деление выполняется с помощью оператора / .
>>> 3 / 1 3.0 >>> 4 / 2 2.0 >>> 3 / 2 1.5
В отличие от трех предыдущих операций при делении результатом всегда будет число с плавающей точкой. Также нужно помнить о том, что на 0 делить нельзя, иначе Python вернет ошибку ZeroDivisionError . Вот пример такого поведения.
>>> 1 / 0 Traceback (most recent call last): File "", line 1, in ZeroDivisionError: division by zero
Деление без остатка
При обычном делении с использованием оператора / результатом будет точное число с плавающей точкой. Но иногда достаточно получить лишь целую часть операции. Для этого есть операции интегрального деления. Стоит рассмотреть ее на примере.
>>> 2 // 1 2 >>> 4 // 3 1 >>> 5 // 2 2
Результатом такой операции становится частное. Остаток же можно получить с помощью модуля, о котором речь пойдет дальше.
Остаток от деления
Для получения остатка деления двух чисел используется оператор деления по модулю % .
>>> 5 % 2 1 >>> 4 % 2 0 >>> 3 % 2 1 >>> 5 % 3 2
На этих примерах видно, как это работает.
Возведение в степень
Число можно возвести в степень с помощью оператора ** .
>>> 3**2 9 >>> 2**4 16 >>> 3**3 27
Комплексные числа
Комплексные числа — это числа, которые включают мнимую часть. Python поддерживает их «из коробки». Их можно запросто создавать и использовать. Пример:
Преобразует число/строку с записью числа в вещественное число
Если аргумент является строкой, то запись должна содержать десятичное число и может иметь предшествующий знак и начальные(конечные) пробелы. Предшествующий знак может быть '+' или '-' , знак '+' не имеет никакого влияния на результат. Аргумент может также быть строкой, представляющей NaN (не число), или положительной или отрицательной бесконечностью. Точнее, входные данные должны соответствовать общепринятой грамматике после удаления начальных и конечных пробельных символов
Если аргумент является целым числом или числом с плавающей запятой, возвращается число с плавающей запятой с тем же значением (в пределах точности Python с плавающей запятой). Если аргумент находится вне диапазона вещественных чисел Python, бросается исключение OverflowError .
Дополнительно смотрите материал по теме "Проблемы точности типа float в Python".
Примеры преобразований числа или строки в число с плавающей запятой.
str_to_float = ' -3.500 ' x = float(str_to_float) print(x) # Вывод -3.5 x = float(10) print(x) # Вывод 10.0
- ОБЗОРНАЯ СТРАНИЦА РАЗДЕЛА
- Функция abs(), абсолютное значение числа
- Функция all(), все элементы True
- Функция any(), хотя бы один элемент True
- Функция ascii(), преобразует строку в ASCII
- Функция bin(), число в двоичную строку
- Класс bool(), логическое значение объекта
- Функция breakpoint(), отладчик кода
- Класс bytearray(), преобразует в массив байтов
- Класс bytes(), преобразует в строку байтов
- Функция callable(), проверяет можно ли вызвать объект
- Функция chr(), число в символ Юникода
- Класс classmethod, делает функцию методом класса
- Функция compile() компилирует блок кода Python
- Класс complex(), преобразует в комплексное число
- Функция delattr(), удаляет атрибут объекта
- Класс dict() создает словарь
- Функция dir(), все атрибуты объекта
- Функция divmod(), делит числа с остатком
- Функция enumerate(), счетчик элементов последовательности
- Функция eval(), выполняет строку-выражение с кодом
- Функция exec(), выполняет блок кода
- Функция filter(), фильтрует список по условию
- Класс float(), преобразует в вещественное число
- Функция format(), форматирует значение переменной
- Класс frozenset(), преобразует в неизменяемое множество
- Функция getattr(), значение атрибута по имени
- Функция globals(), переменные глобальной области
- Функция hasattr(), наличие атрибута объекта
- Функция hash(), хэш-значение объекта
- Функция help(), справка по любому объекту
- Функция hex(), число в шестнадцатеричную строку
- Функция id(), идентификатор объекта
- Функция input(), ввод данных с клавиатуры
- Класс int(), преобразует в тип int
- Функция isinstance(), принадлежность экземпляра к классу
- Функция issubclass(), проверяет наследование класса
- Функция iter(), создает итератор
- Функция len(), количество элементов объекта
- Класс list(), преобразовывает в список
- Функция locals(), переменные локальной области
- Функция map(), обработка последовательности без цикла
- Функция max(), максимальное значение элемента
- Класс memoryview(), ссылка на буфер обмена
- Функция min(), минимальное значение элемента
- Функция next(), следующий элемент итератора
- Класс object(), возвращает безликий объект
- Функция oct(), число в восьмеричную строку
- Функция open(), открывает файл на чтение/запись
- Функция ord(), число символа Unicode
- Функция pow(), возводит число в степень
- Функция print(), печатает объект
- Класс property(), метод класса как свойство
- Класс range(), генерирует арифметические последовательности
- Функция repr(), описание объекта
- Функция reversed(), разворачивает последовательность
- Функция round(), округляет число
- Класс set(), создает или преобразовывает в множество
- Функция setattr(), создает атрибут объекта
- Класс slice(), шаблон среза
- Функция sorted(), выполняет сортировку
- Декоратор staticmethod(), метод класса в статический метод
- Класс str(), преобразует объект в строку
- Функция sum(), сумма последовательности
- Функция super(), доступ к унаследованным методам
- Класс tuple(), создает или преобразует в кортеж
- Класс type(), возвращает тип объекта
- Функция vars(), словарь переменных объекта
- Функция zip(), объединить элементы в список кортежей
- Функция __import__(), находит и импортирует модуль
- Функция aiter(), создает асинхронный итератор
- Функция anext(), следующий элемент асинхронного итератора