§4. Целочисленный тип int. Арифметические операции. Стандартные функции. Приоритет операций

Целочисленный тип данных. Стандартные арифметические операции

Целый тип в python представлен в виде целого числа произвольной точности. Это означает, что можно работать с целыми числами настолько большими, насколько будет позволять доступная память компьютера. Однако нужно иметь ввиду, что размер числа также будет влиять и на скорость вычислений. Оптимальный размер целого числа, с которым будет эффективно производится вычислительные операции должен соответствовать длине машинного слова. Для 32-битной (машинное слово — 4 байта) архитектуры процессора максимальное значение беззнакового целого числа равно 4294967295.
Например, легко получить 100!

>>> from math import factorial
>>> print(factorial(100))
933262154439441526816992388562667004907159682643816214685929638952175
999932299156089414639761565182862536979208272237582511852109168640000
00000000000000000000

Для работы с целыми и вещественными типами определены следующие стандартные арифметические операции и функции:

Арифметические операции и стандартные функции
Операция Функция Описание
a + b add(a, b) Сложение
a / b truediv(a, b) Деление, результат float
a // b floordiv(a, b) Деление, результат int
a & b and_(a, b) Побитовое «И»
a ^ b xor(a, b) Побитовое «исключающее ИЛИ»
~ a invert(a) Побитовое «НЕ»
a | b or_(a, b) Побитовое «ИЛИ»
a ** b pow(a, b[, c]) a в степени b или (a ** b) % c
a << b lshift(a, b) Побитовый сдвиг влево
a % b mod(a, b) Остаток от деления a на b
a * b mul(a, b) Умножение
a @ b matmul(a, b) Умножение матриц
— a neg(a) Унарный минус
+ a pos(a) Унарный плюс
a >> b rshift(a, b) Побитовый сдвиг вправо
a — b sub(a, b) Вычитание
abs(a) Абсолютное значение
divmod(a, b) Возвращает частное и остаток как кортеж
round(x[, n]) Округление до ближайшего целого (int) или с точностью до n знаков (float)

Организация диалога с программой. Преобразование к типу int

Разработчик программы должен побеспокоиться о том, чтобы его программа имела интуитивно понятный интерфейс. Это означает, что в любой момент работы программы пользователь должен знать — какие действия он должен предпринять, чтобы получить желаемый результат в виде вывода на стандартное устройство. Для консольных приложений (т. е. приложений, которые не имеют оконного интерфейса) стандартными устройствами являются — клавиатура и монитор. Вывод консольной программы, написанной на python, осуществляется в окне командной оболочки операционной системы или, как в нашем случае, в окне консоли интегрированной среды IDE PyCharm. Для вывода данных используется, уже известная нам, функция print(). Чтобы осуществить клавиатурный ввод данных нам потребуется применить функцию input(). Например:

>>> print("Введите ваше имя:")
Введите ваше имя:
>>> MyName = input()
Андрей
>>> print("Сколько вам лет?")
Сколько вам лет?
>>> Age = input()
14
>>> print("Вас зовут", MyName, "\nвам", Age, "лет")
Вас зовут Андрей 
вам 14 лет

Параметром функции input() может выступать символьная строка — приглашение. Приведем пример задачи вычислительного характера. Постановка задачи. Получить сумму и произведение двух чисел A и B.
Программа 4.1

A = int(input("A = "))
B = int(input("B = "))
print("A * B = ", A * B)
print("A + B = ", A + B)

Вывод программы:

A = 12
B = 24
A * B =  288
A + B =  36

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

>>> a1 = '123.3'
>>> a2 = 123.3
>>> a3 = '123'
>>> print(int(a1))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '123.3'
>>> print(int(a2))
123
>>> print(int(a3))
123

Для преобразования из других систем счисления, функцию int() необходимо использовать с двумя аргументами. Второй аргумент указывает — в какой системе счисления представлен строковый литерал. Максимальное значение этого аргумента 36 (основание системы счисления в которой для представления цифр используется алфавит состоящий из цифр 0..9 и букв a..z):

>>> a4 = '0b10101011'
>>> print(int(a4))
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: invalid literal for int() with base 10: '0b10101011'
>>> print(int(a4,2))
171

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

Ассоциативность. Приоритет операций

В языке программирования python операции имеют следующий приоритет:

Приоритет операций в Python (от меньшего к большему)
Операции Описание
lambda Лямбда-выражение
if – else Условное выражение
or Булевское «или»
and Булевское «и»
not x Булевское «не»
in, not in, is, is not, <, <=, >, >=, !=, == Сравнение, включая тесты на членство и тесты на идентичность
| Побитовое OR
^ Побитовое XOR
& Побитовое AND
<<, >> Побитовые сдвиги
+, — Сложение, вычитание
*, @, /, //, % Умножение, умножение матриц, деление действительных чисел, целочисленное деление и взятие остатка от деления нацело
+x, -x, ~x Унарные операции и побитовое NOT
** Возведение в степень
await x
x[index], x[index:index], x(arguments…), x.attribute Обращение по идексу, срез, вызов, ссылка на атрибут

Из таблицы видно, что арифметические операции:
*, /, //, %
имеют равный приоритет и более высокий, чем операции сложения и вычитания.
Возникает вопрос: если операции имеют одинаковый приоритет, то в каком порядке (последовательности) будут выполняться эти операции в сложном выражении? Помимо приоритета, операции обладают ассоциативностью. Для арифметических операций ассоциативность «левая», т. е. операции будут выполняться последовательно слева направо.

>>> 2 + 4 * 6 / 3
10.0
>>> # результат 10, а не 12!
... 10 - 5 - 2
3
>>> # результат 3, а не 7!

Например, допустим мы хотим получить произведение разрядов трехзначного десятичного числа n. Составим следующее выражение:

n % 10 * n // 10 % 10 * n // 100

При введенном значении n = 236 мы получим следующий результат:

>>> n = 236
>>> print(n % 10 * n // 10 % 10 * n // 100)
2

Т. е., совсем не то, что мы ожидали (36). Выполним вычисления пошагово:

>>> print(n % 10)
6
>>> print(n % 10 * n)
1416
>>> print(n % 10 * n // 10)
141
>>> print(n % 10 * n // 10 % 10)
1
>>> print(n % 10 * n // 10 % 10 * n)
236
>>> print(n % 10 * n // 10 % 10 * n // 100)
2

Скобки изменяют порядок вычислений:

>>> print((n % 10) * ((n // 10) % 10) * (n // 100))
36

Теперь результат верный!

Форма сокращенных операций

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

Полная форма Краткая форма
a = a + b a += b
a = a — b a -= b
a = a * b a *= b
a = a / b a /= b
a = a // b a //= b
a = a % b a %= b
a = a | b a |= b
a = a ^ b a ^= b
a = a & b a &= b
a = a ** b a **= b
a = a >> b a >>= b
a = a << b a <<= b
a = a @ b a @= b

Пробелы между операцией “=” и сокращаемой операцией не допускаются.

Операция взятия остатка от деления – %

Для целых типов предусмотрены два вида операций деления:

  1. // — целочисленное деление с отбрасыванием дробной части
  2. % — получение остатка от деления

Примечание. Операция // применяемая к целому и действительному типу в одном выражении вернет действительный тип с обнуленной дробной частью.
С помощью операций целочисленного деления можно решать целый класс задач в которых требуется получать разряды числа. Например. Постановка задачи:
Дано трехзначное число n. Получить сумму и произведение цифр составляющих это число.
Программа 4.2

n = int(input('n = '))
print('Суммма разрядов числа:',
      n % 10 + (n // 10) % 10 + n // 100,
      '\nПроизведение разрядов числа:',
      (n % 10) * ((n // 10) % 10) * (n // 100))

Результат в консоли:

n = 236
Сумма цифр числа = 11
Произведение цифр = 36

Однако, операция взятия остатка от деления, с точки зрения математики, не совсем корректна. Это иллюстрирует следующий пример:

>>> a = 7
>>> b = 2
>>> c = -7
>>> d = -2
>>> a%b
1
>>> a%d
-1
>>> c%b
1
>>> c%d
-1

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

Побитовые операции

Побитовые операции выполняются над двоичными битами целочисленного типа. Это низкоуровневые операции, поэтому выполняются очень быстро. К побитовым операциям относятся:
&, |, ^, ~, >>, <<
Примером применения побитового XOR (^) может служить операция обмена значениями между двумя переменными без использования третьей:

>>> a = 4
>>> b = 6
>>> a = a ^ b
>>> b = a ^ b
>>> a = a ^ b
>>> a
6
>>> b
4

Побитовые сдвиги производят сдвиг всех битов на n позиций вправо или влево, при этом, самые правые n-бит отбрасываются (а лидирующие заменяются нулями) или будут отброшены первые n битов при смещении всех битов влево, а освободившиеся справа будут замещены нулями. Операция битового сдвига вправо на n позиций равносильна целочисленному делению на 2n (для положительных чисел). Обратная операции побитового сдвига влево равносильна умножению на 2n. Таким образом, операции побитового сдвига можно применять, например, для быстрого возведения 2 в степень n:

>>> a = 2
>>> a << 1
4
>>> a << 2
8
>>> a << 3
16
>>> a << 4
32
>>> a << 5
64

Для отрицательных чисел в языке python операции битового сдвига не применяются.

Print Friendly, PDF & Email

Comments are closed