Операторы и выражения в python

Операции с числами

Является ли переменная числом

Любую переменную можно проверить на тип (int, float или complex):

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

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

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

Арифметические операции

• – сложение;
• – вычитание;
• – умножение;
• – деление;
• – целочисленное деление;
• – остаток от деления;
• – возведение в степень;
• – смена знака;
• – модуль числа;
• – возвращает кортеж из частного и остатка от деления x на y;
• – возведение числа в степень (z – деление по модулю);
• – округление числа (ndigits — знаки после запятой).

Преобразования

• – преобразование в целое число
• – преобразование в число с плавающей точкой
• – преобразование в комплексное число
• – целоe числа в двоичную строку;
• – целое число в восьмеричную строку;
• – целое число в шестнадцатеричную строку;
• – перевод целого числа 123 в список цифр этого числа;
• – перевод списка цифр в целое число 123;
• – число в строку;

Ввод чисел

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

Если нужен список чисел, введите несколько чисел через пробел и выполните:

Вывод чисел

Для вывода числа используйте

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

Другие полезные функции

• – посчитает длину числа;
• – если остаток от деления равен 0, то число четное;
• – диапазон чисел от 0 до 5, по которому можно итерироваться;
• – перевернет число (123 -> 321).

Шаблоны регулярных выражений

За исключением символов (+?. * ^ $ () [] {} | ), все остальные соответствуют самим себе. Вы можете избежать экранировать специальный символ с помощью бэкслеша ().

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

№	Шаблон & Описание
1	^ — соответствует началу строки.
2	$— соответствует концу строки.
3	. — соответствует любому символу, кроме новой строки. Использование флага re.M позволяет также соответствовать новой строке.
4	— соответствует любому из символов в скобках.
5	— соответствует любому символу, кроме тех, что в квадратных скобках.
6	foo* — соответствует 0 или более вхождений “foo”.
7	bar+ —- соответствует 1 или более вхождениям “bar”.
8	foo? —- соответствует 0 или 1 вхождению “foo”.
9	bar{3} —- соответствует трем подряд вхождениям “bar”.
10	foo{3,} — соответствует 3 или более вхождениям “foo”.
11	bar{2,5} —- соответствует от 2 до 5 вхождениям “bar”.
12	a|b — соответствует либо a, либо b.
13	(foo) — группирует регулярные выражения.
14	(?imx) — временно включает параметры i, m или x в регулярное выражение. Если используются круглые скобки — затрагивается только эта область.
15	(?-imx) — временно отключает опции i, m или x в регулярном выражении. Если используются круглые скобки — затрагивается только эта область.
16	(?: foo) — Группирует регулярные выражения без сохранения совпадающего текста.
17	(?imx: re) — Временно включает параметры i, m или x в круглых скобках.
18	(?-imx: re) — временно отключает опции i, m или x в круглых скобках.
19	(?#…) — комментарий.
20	(?= foo) — совпадает со всеми словами после которых » foo».
21	(?! foo) — совпадает со всеми словами после которых нет » foo».
22	(?> foo) — совпадает со всеми словами перед которыми » foo».
23	\w — совпадает с буквенным символом.
24	\W — совпадает с не буквенным символом.
25	\s — совпадает с пробельными символами (\t, \n, \r, \f и пробелом).
26	\S — все кроме пробельных символов.
27	\d — соответствует цифрам (0-9).
28	\D — все кроме цифры.
29	\A — соответствует началу строки.
30	\Z – соответствует концу строки. Включая перевод на новую строку, если такая есть.
31	\z — соответствует концу строки.
32	\G — соответствует месту, где закончилось последнее соответствие.
33	\b — соответствует границам слов, когда поставлены внешние скобки.
34	\B — все кроме границы слова.
35	**\n,\t,\r,\f ** — соответствует новым строкам, подстрокам.
36	\1…\9 — соответствует подгруппе n-й группы.
37	\10 — соответсвуйет номеру группы. В противном случае относится к восьмеричному представлению символьного кода.

Целые числа (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)	x y по модулю (если модуль задан)

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

Битовые операции

Над целыми числами также можно производить битовые операции

x | y	Побитовое или
x ^ y	Побитовое исключающее или
x & y	Побитовое и
x > y	Битовый сдвиг вправо

x

Инверсия битов

Дополнительные методы

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

int.to_bytes(length, byteorder, *, signed=False) — возвращает строку байтов, представляющих это число.

classmethod int.from_bytes(bytes, byteorder, *, signed=False) — возвращает число из данной строки байтов.

Системы счисления

Те, у кого в школе была информатика, знают, что числа могут быть представлены не только в десятичной системе счисления. К примеру, в компьютере используется двоичный код, и, к примеру, число 19 в двоичной системе счисления будет выглядеть как 10011. Также иногда нужно переводить числа из одной системы счисления в другую. Python для этого предоставляет несколько функций:

• int(, ) — преобразование к целому числу в десятичной системе счисления. По умолчанию система счисления десятичная, но можно задать любое основание от 2 до 36 включительно.
• bin(x) — преобразование целого числа в двоичную строку.
• hex(х) — преобразование целого числа в шестнадцатеричную строку.
• oct(х) — преобразование целого числа в восьмеричную строку.

Алгоритм очереди кучи.

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

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

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

1. Модуль использует индексацию с нуля. Это делает связь между индексом для узла и индексами для его дочерних элементов несколько менее очевидной, но является более подходящей, поскольку Python использует индексацию с нуля.
2. Метод модуля возвращает наименьший элемент, а не самый большой. В учебниках он называется . Элемент чаще встречается в учебниках из-за его пригодности для сортировки на месте.

Эти два аспекта позволяют просматривать кучу как обычный список Python без сюрпризов: — самый маленький элемент, а поддерживает инвариант кучи!

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

Функция heappush() модуля heapq в Python.
Функция `heappush()` модуля `heapq` добавляет значение элемента в кучу, сохраняя инвариант кучи.

Функция heappop() модуля heapq в Python.
Функция `heappop()` модуля `heapq` возвращает и удаляет наименьший элемент из кучи `heap`, сохраняя инвариант кучи.

Функция heappushpop() модуля heapq в Python.
Функция heappushpop() модуля heapq добавляет значение элемента item в кучу heap, затем возвращает и удаляет самый маленький элемент из кучи heap.

Функция heapify() модуля heapq в Python.
Функция `heapify()` модуля `heapq` преобразовывает список `x` в кучу на месте за линейное время.

Функция heapreplace() модуля heapq в Python.
Функция `heapreplace()` модуля `heapq` сначала удаляет и возвращает наименьший элемент из кучи `heap`, а потом добавляет новый элемент `item`. Размер кучи `heap` не меняется. Если куча пуста, поднимается исключение `IndexError`.

Функция merge() модуля heapq в Python.
Функция `merge()` модуля `heapq` объединяет несколько отсортированных последовательностей `*iterables` в один отсортированный итератор. Например, объединить записи с метками времени из нескольких файлов журнала.

Функция nlargest() модуля heapq в Python.
Функция `nlargest()` модуля `heapq` возвращает список с `n` самыми большими элементами из набора данных, определенного с помощью итерации `iterable`.

Функция nsmallest() модуля heapq в Python.
Функция `nsmallest()` модуля `heapq` возвращает список с `n` наименьшими элементами из набора данных, определенного с помощью итерируемой последовательности `iterable`.

Примеры использования heapq.
Примеры: назначений приоритетов задач вместе с основной задачей, которую нужно выполнить и пирамидальная сортировка.

Реализация очереди приоритетов.
Реализация очереди приоритетов.

Способы извлечения корня

В языке программирования Python 3 существует три способа извлечения корней:

• Использование функции sqrt из стандартной математической библиотеки math.
• Операция возведения в степень **
• Применение функции pow(x, n)

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

from math import sqrt
x = sqrt(4)
print(x)

2.0

Если же нам нужно вычислить в Python корень квадратный из суммы квадратов, то можно воспользоваться функцией hypot из модуля math. Берется сумма квадратов аргументов функции, из нее получается корень. Аргументов у функции два.

from math import hypot
x = hypot(4,3)
print(x)

5.0

Еще одним, чуть более универсальным методом, будет использование возведения в степень. Известно, что для того, чтобы взять корень n из числа, необходимо возвести его в степень 1/n. Соответственно, извлечение квадратного корня из числа 4 будет выглядеть так:

n = 2
x = 4**(1./n)
print(x)

2.0

Обратите внимание, что в Python 2 необходимо ставить точку после единицы, иначе произойдет целочисленное деление, и 1/n == 0, а не нужной нам дроби. В Python 3 можно не ставить точку.. Последний метод использует функцию pow(value, n)

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

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

x = pow(4, 0.5)
print(x)

2.0

Какой метод быстрее?

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

from time import monotonic
from math import sqrt
iterations = 1000000
start = monotonic()
for a in range(iterations):
    x = sqrt(4)
print("sqrt time: {:>.3f}".format(monotonic() - start) + " seconds")
start = monotonic()
for a in range(iterations):
    x = 4 ** 0.5
print("** time: {:>.3f}".format(monotonic() - start) + " seconds")
start = monotonic()
for a in range(iterations):
    x = pow(4, 0.5)
print("pow time: {:>.3f}".format(monotonic() - start) + " seconds")

sqrt time: 0.266 seconds
** time: 0.109 seconds
pow time: 0.453 seconds

Как видно, самое быстрое решение – использовать **. На втором месте метод sqrt, а pow – самый медленный. Правда, метод sqrt наиболее нагляден при вычислении в Python квадратных корней.

Таким образом, если критична скорость, то используем **. Если скорость не критична, а важна читаемость кода, то следует использовать sqrt.

Важность функций

Абстракция

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

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

Нам не важно, кто совершает движение: и для человека и для самолёта средняя скорость будет рассчитываться одинаково

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

Возможность повторного использования

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

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

Всего 10 таких сортировок, и привет, лишние 60 строк кода.

Модульность

Разбитие больших и сложных процессов на простые составляющие – важная часть, как кодинга, так и реальной жизни. В повседневности мы занимаемся этим неосознанно. Когда убираемся в квартире, мы пылесосим, моем полы и окна, очищаем поверхности от пыли и наводим блеск на всё блестящее. Всё это – составляющие одного большого процесса под названием «уборка», но каждую из них также можно разбить на более простые подпроцессы.

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

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

Без применения модульности получится сплошная последовательность инструкций:

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

Это и называется модульностью.

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

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

Пример из жизни: в ВУЗе учатся два человека с совпадающими ФИО. Их нужно как-то различать. Если сделать пространствами имён группы этих студентов, то проблема будет решена. В рамках своей группы ФИО этих студентов будут уникальными.

Синтаксис

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

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

А теперь представьте, что произойдёт, когда вы раскрутитесь, и покупатели станут приходить один за другим. В таком случае, чеки надо будет выдавать очень быстро. Но что делать, если вдруг нагрянет ваш любимый клиент и купит 10 сортов мёда в разных количествах? Далеко не все в очереди согласятся ждать, пока вы посчитаете общую сумму и внесёте её в чек.

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

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

Теперь этот список передадим в функцию как аргумент, и самостоятельно считать больше не придётся.

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

9 ответов

179

Лучший ответ

выполняет целочисленное деление. .

Итак, вы вычисляете x (1/2) в первом случае x (0) во втором.

Так что это не так, это правильный ответ на другой вопрос.

07 март 2012, в 03:47
Поделиться

77

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

Это поведение является «нормальным» в Python 2.x, тогда как в Python 3.x выполняется оценка . Если вы хотите, чтобы ваш код Python 2.x вел себя как 3.x w.r.t. деление писать — тогда будет оцениваться до и для обратной совместимости оценивать до .

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

07 март 2012, в 03:02
Поделиться

8

выполняет целочисленное деление в Python 2:

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

07 март 2012, в 04:03
Поделиться

5

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

03 апр. 2018, в 01:56
Поделиться

5

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

Или вы можете преобразовать 1 или 2 из 1/2 в значение с плавающей запятой.

07 март 2012, в 04:32
Поделиться

1

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

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

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

Например, нам нужно найти 30 квадратных корней. Мы знаем, что результат между 5 и 6.

число равно 30, а оценка — 5. Результат каждого рекурсивного вызова:

Последний результат — наиболее точное вычисление квадратного корня из числа. Это то же значение, что и встроенная функция math.sqrt().

25 янв. 2018, в 09:57
Поделиться

Возможно, простой способ запомнить: добавить точку после числителя (или знаменателя) 16 ** (1./2) # 4 289 ** (1./2) # 17 27 ** (1./3) # 3

06 апр. 2018, в 02:29
Поделиться

-1

Я надеюсь, что приведенный ниже код ответит на ваш вопрос.

25 июль 2017, в 02:17
Поделиться

-1

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

10 фев. 2017, в 19:28
Поделиться

Ещё вопросы

• 304Что такое Python-эквивалент PHP var_dump ()?
• 324Любимые советы и особенности Django?
• 214Django — Как переименовать поле модели, используя South?
• 157Django: перенаправление на предыдущую страницу после входа в систему
• 135Как получить доступ к элементу словаря в шаблоне Django?
• 115Получение параметров из URL
• 116Как отобразить текущий год в шаблоне Django?
• 99Как вы сериализуете экземпляр модели в Django?
• 93Как мне упаковать приложение на python, чтобы оно могло быть установлено pip?
• 624Как я могу проверить значения NaN?

Классификация люстр и критерии выбора

Генераторы списков

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

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

Пример генератора списка:

Пример посложнее:

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

Операции над числами

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

Операция	Назначение
a + b	Сложение a и b
a – b	Разница между a и b
a * b	Умножение a на b
a / b	Деление a на b
a % b	Остаток от деления a на b
a // b	Целая часть от деления a и b
a ** b	Возведение a в степень b

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

Операция	Назначение
a & b	Побитовое И для a и b
a | b	Побитовое ИЛИ для a и b
a ^ b	Исключающее ИЛИ для a и b
~a	Инверсия битов для a
a << b	Побитовый сдвиг влево для a на b
a >> b	Побитовый сдвиг вправо для a на b

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

Метод	Назначение
sqrt(a)	Квадратный корень из a
log(a)	Натуральный логарифм из a
fabs(a)	Возвращает модуль a
round(a)	Округляет a до ближайшего целого
round(a, b)	Округляет a до b знаков после точки
floor(a)	Округляет a до меньшего целого значения
ceil(a)	Округляет a до большего целого значения
isfinite(a)	Проверяет, является ли a числом
modf(a)	Возвращает целую и дробную части a
sin(a)	Синус угла a, указанного в радианах
cos(a)	Косинус угла a, указанного в радианах
tan(a)	Тангенс угла a, указанного в радианах

Функция fabs модуля math вначале пытается привести аргумент к вещественному типу (float), и только потом вычисляет модуль. Для вычисления модуля числа так же есть стандартная функция abs.

Ввод числа с клавиатуры

Для того чтобы получить числовые данные от пользователя используется стандартный метод input. Его вызов позволяет получать ввод информации с клавиатуры, который выполняется во время запуска программы на компьютере. В качестве аргумента для этого метода можно использовать строку, предлагающую пользователю ввести числовые сведения. Ниже показан пример того, как ввести в Pyhon с клавиатуры число. Переменная n получает значение и отображается на экране с помощью print:

n = input("Press n: ")
print("n = " + str(n))

Press n: 10
n = 10

Максимальное значение

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

import sys
print(sys.maxsize)

9223372036854775807

Логические операции с десятичным модулем

Decimal содержит набор встроенных функций для выполнения логических операций с десятичными числами, таких как AND, OR, XOR и т. Д.

• Функция logical_and(): выполняет операцию логического И над двумя десятичными числами и возвращает результат.
• Функция logical_or(): выполняет операцию логического ИЛИ над двумя десятичными числами и возвращает результат.
• Функция logical_xor(): выполняет логическую операцию XOR над двумя десятичными числами и возвращает результат.

#Syntax for logical_and() function-
decimal1.logical_and(decimal2)

#Syntax for logical_or() function-
decimal1.logical_or(decimal2)

#Syntax for logical_xor() function-
decimal1.logical_xor(decimal2)

Пример:

import decimal as d

valx = d.Decimal(1001)
valy = d.Decimal(1111)

print("Value 1: ",valx)
print("Value 2: ",valy)

AND = valx.logical_and(valy)
print("The logical AND value of the two decimals: ",AND)

OR = valx.logical_or(valy)
print("The logical OR value of the two decimals: ",OR)

XOR = valx.logical_xor(valy)
print("The logical XOR value of the two decimals: ",XOR)

Выход:

Value 1:  1001
Value 2:  1111
The logical AND value of the two decimals:  1001
The logical OR value of the two decimals:  1111
The logical XOR value of the two decimals:  110

Целые числа (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)	xy по модулю (если модуль задан)

Также нужно отметить, что целые числа в 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)
>>> 3 ** 150
369988485035126972924700782451696644186473100389722973815184405301748249

Битовые операции

Над целыми числами также можно производить битовые операции

x | y	Побитовое или
x ^ y	Побитовое исключающее или
x & y	Побитовое и
x << n	Битовый сдвиг влево
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(, byteorder='big')
16711680

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

Нетипичный оператор для большинства других языков программирования. Тем он и удобен. Парная «звёздочка» (**) выполняет классическое математическое возведение числа «a» в степень «b»:

И показатель степени, и основание могут быть отрицательными:

И дробными:

Операндов у возведения в степень также может быть несколько. В таком случае, оператор «**» работает, как право-ассоциативный (т.е. операции выполняются справа-налево):

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

1. возведение в степень;
2. умножение, деление, целочисленное деление и деление по модулю;
3. сложение и вычитание.

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

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

Python

3 + 5.1

1

3+5.1

Вывод

Shell

8.1

1

8.1

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

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

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

Python

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

1 2 3

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

Вывод

Shell

12.0

1

12.0

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

Python

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

1 2 3

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

Вывод

Shell

12

1

12

Вещественное число было преобразовано в целое через удаление дробной части и сохранение базового числа

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

Заключение

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

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

Положительное число

Именно на работу с неотрицательными числами «заточена» функция

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

А можете – из вещественных:

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

Отрицательное число

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

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

Поэтому, если передадите отрицательное число в , то получите ошибку: