Изучаем Python: математические операции

Математические операторы Python 3

Оператор — это символ, обозначающий операцию. Например, в математике знак плюс или + является оператором сложения.

Мы увидим аналогичные операторы, пришедшие в Python из математики. Но другие операторы специфичны для программирования.

Ниже представлена ​​таблица с кратким обзором математических операторов, доступных в Python.

Операция	Возвращаемое значение
х + у	Сумма x и y.
х — у	Разница x и y.
-ИКС	Измените знак x.
+ х	Идентичность x.
х * у	Произведение x и y.
х / у	Частное от деления x на y.
х // у	Частное от целочисленного деления x на y.
х% у	Модуль х / у.
х ** у	x в степени y.

Сумма в питоне и разность в питоне

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

Давайте посмотрим на несколько примеров. Начнем с целых чисел:

печать (1 + 5)

Производство

6

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

a = 88 b = 103 отпечаток (a + b)

Производство

191

Целые числа могут быть положительными или отрицательными. Следовательно, вы можете добавлять отрицательные числа к положительным:

c = -36 d = 25 отпечатков (c + d)

Производство

-одиннадцать

Точно так же сложение работает с числами с плавающей запятой:

e = 5.5 f = 2.5 печать (e + f)

Производство

8.0

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

г = 75,67 ч = 32 отпечатка (г — ч)

Производство

43,67

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

Библиотека (модуль) math

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

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

>>> импорт математики

Давайте посмотрим на наиболее часто используемые функции.

math.ceil (x)

Возвращает ближайшее целое число больше x.

>>> math.ceil (3.2) 4

math.fabs (x)

Возвращает абсолютное значение числа.

>>> math.fabs (-7) 7.0

математический факториал (x)

Вычислите факториал x.

>>> математический факториал (5) 120

математическая плоскость (x)

Возвращает ближайшее целое число меньше x.

>>> математический этаж (3.2) 3

math.exp (x)

Рассчитайте e ** x.

>>> math.exp (3) 20.085536923187668

math.log2 (x)

Логарифмическое основание 2.

math.log10 (x)

Логарифм по основанию 10.

math.log (x , основание)

Вычисляет логарифм по основанию и по умолчанию; также можно указать основание логарифма.

>>> math.log2 (8) 3.0 >>> math.log10 (1000) 3.0 >>> math.log (5) 1.6094379124341003 >>> math.log (4, 8) 0.66666666666666667

math.pow (х, у)

Вычислите значение x в степени y.

>>> math.pow (3, 4) 81.0

math.sqrt (x)

Корень квадратный из x.

>>> math.sqrt (25) 5.0

Тригонометрические функции, оставим их без примера.

math.cos (x)

math.sin (x)

math.tan (x)

math.acos (x)

asyn.math (x)

math.atan (x)

И напоследок пара констант.

math.pi

Пи.

math.e

Номер есть.

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

Комплексные числа (complex)

Как я уже писал выше, Python поддерживает комплексные числа без установки дополнительных модулей. Рассмотрим создание таких чисел на примере:

# создать и сложить два комплексных числа num1 = 1 + 2j num2 = 2 + 4j summa = num1 + num2 print (summa) # Вывод (3 + 6j)

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

В Python доступны побитовые операции, их можно выполнять с целыми числами.

И по крупицам).

>>> p = 9 >>> q = 3 >>> p & q 1

Побитовое ИЛИ (ИЛИ).

>>> p | q11

Побитовое исключающее ИЛИ (XOR).

>>> p ^ q 10

Инверсия.

>>> ~ п -10

Двигайтесь влево и вправо.

>>> p <<118> >> p >> 14

Деление без остатка

Для целочисленного деления в Python вы можете использовать целочисленное деление. В этом случае результатом будет целое число без остатка. Целочисленное деление в Python обозначается двумя косыми чертами «//».

В отличие от других языков программирования, Python позволяет результату целочисленного деления быть целым (int) или дробным (float) числом. В обоих случаях дробная часть отбрасывается и получается число с окончанием «.0».

Примеры поиска всей части дивизиона:

print (5 // 2) print (0 // 2) print (1234 // 5.0) 2 0 246.0

В первых двух случаях деление было на целые числа. Следовательно, результат — целое число. В третьем примере одно из чисел настоящее. В этом случае, следовательно, мы также получаем после запятой действительное число (типа float), которое имеет 0.

Вещественные числа (float)

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

>>> 0,1 + 0,1 + 0,1 + 0,1 + 0,1 + 0,1 + 0,1 + 0,1 + 0,1 + 0,10.9999999999999999

Для высокой точности используйте другие объекты (например, Decimal и Fraction)).

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

>>> a = 3 ** 1000 >>> a + 0.1Traceback (последний самый последний вызов): файл «», строка 1, в OverflowError: int слишком большой для преобразования в float

Простые примеры работы с числами:

>>> c = 150 >>> d = 12.9 >>> c + d162.9 >>> p = abs (dc) # Модуль числа >>> print (p) 137.1 >>> round (p) # Округление 137

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

float.as_integer_ratio () — пара целых чисел, отношение которых равно этому числу.

float.is_integer () — если значение целое.

float.hex () — преобразует число с плавающей запятой в шестнадцатеричное (шестнадцатеричное представление).

classmethod float.fromhex (s) — шестнадцатеричное число с плавающей запятой.

>>> (10.5) .hex () ‘0x1.5000000000000p + 3’ >>> float.fromhex (‘0x1.5000000000000p + 3’) 10.5

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

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

>>> importmath >>> math.pi3.141592653589793 >>> math.sqrt (85) 9.219544457292887

Модуль случайных чисел реализует генератор случайных чисел и функции случайного выбора.

>>> importrandom >>> random.random () 0.15651968855132303

Работа с комплексными числами

Чтобы создать комплексное число, вы можете использовать сложную функцию (a, b), где действительная часть передается как первый аргумент, а мнимая часть — как второй. Или напишите число как a + bj.

Давайте посмотрим на несколько примеров.

Создание комплексного числа.

>>> z = 1 + 2j >>> print (z) (1 + 2j) >>> x = complex (3, 2) >>> print (x) (3 + 2j)

Комплексные числа можно складывать, вычитать, умножать, делить и экспоненциально.

>>> x + z (4 + 4j) >>> x — z (2 + 0j) >>> x * z (-1 + 8j) >>> x / z (1,4-0,8j) >>> x ** z (-1.122722036363393-0.012635185355335208j) >>> x ** 3 (-9 + 46j)

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

>>> x = 3 + 2j >>> x.real 3.0 >>> x.imag 2.0

Чтобы получить комплексно-сопряженное число, вам нужно использовать метод conugate().

>>> x.conjugated () (3-2j)

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

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

Используйте другой браузер
x = 1 # создать целое число
y = 2.0 # создать число с плавающей запятой
z = 2 + 3j # создает комплексное число
a = float (x) # преобразование целого числа в число с плавающей запятой
b = int (x) # преобразование с плавающей точкой в ​​целое число
c = complex (x) # преобразовать целое число в комплексное
d = complex (y) # преобразовать числа с плавающей запятой в комплексные
print (a, type (a))
print (b, type (b))
print (c, type (c))
print (d, type (d))

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

1.0 1 (1 + 0j) (2 + 0j)

Ввести число в Python

Функция input () считывает вводимые пользователем данные в консоль и сохраняет их в переменной. Но что произойдет, если мы введем число, а затем обратимся к переменной?

>>> r = input()
33
>>> г
’33’ # это строка

Python напечатал строку, потому что число заключено в кавычки.

Чтобы ввести целое число, оберните функцию input () в другую функцию int().

>>> s = int (ввод())
22
>>> с
22

Для действительного числа соответственно в float().

>>> с
t = float (вход())
11,9
>>> т
11,9

Унарные арифметические операции Python

Унарное математическое выражение состоит из одного элемента. Знаки плюс и минус в Python могут использоваться как один оператор для возврата одного и того же значения (+) или изменения знака числа (-).

Знак плюс указывает на то же значение. Мы можем использовать его с положительными значениями:

я = 3.3 печать (+ я)

Производство

3.3

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

j = -19 print (+ j) re Python module — изучите регулярные выражения Python

Производство

-19

При использовании с отрицательным значением знак плюс возвращает то же отрицательное значение.

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

я = 3,3 печать (-i)

Производство

-3,3

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

j = -19 печать (-j)

Производство

19

Унарные арифметические операторы возвращают то же значение в случае + i или противоположное число в случае -i.

Оператор сравнения

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

Описание оператора

==	Если значения двух операндов равны, условие становится истинным.
!=	Если значения двух операндов не равны, условие становится истинным.
<=	Если первый операнд меньше или равен второму операнду, условие становится истинным.
>=	Если первый операнд больше или равен второму операнду, условие становится истинным.
>	Если первый операнд больше второго, условие становится истинным.
<	Если первый операнд меньше второго, условие становится истинным.

Проверка типа данных переменной

Python использует встроенную функцию type () для проверки типа данных переменной. Возьмем пример:

str = ‘1’ int = 1 float = 1.1 com1 = 1 + 2j com2 = 2 + 4j complex = com1 + com2 print (type (str)) # Печать print (type (int)) # Печать print (type (float)) # Печать print (type (complex)) # Распечатывает

Умножение и деление в питоне

Оператор, который мы будем использовать в Python для умножения, — это «*», а для деления «/». Пример умножения двух чисел с плавающей запятой в Python:

k = 100,1 l = 10,1 отпечаток (k * l)

Производство

1011.0099999999999

Когда вы делаете деление в Python 3, частное всегда будет числом с плавающей запятой, даже если вы используете два целых числа:

m = 80 n = 5 отпечаток (m / n)

Производство

16.0

Это одно из наиболее значительных различий между Python 2 и Python 3. В Python 3 результатом является дробное число. Поэтому, когда вы используете оператор / для деления 11 на 2, возвращается 5,5. В Python 2 значение, возвращаемое делением 11/2, было 5.

В Python 2 оператор / выполняет целочисленное деление, где частное — x, а возвращаемое число — наибольшее целое число, меньшее или равное x. Если вы последуете приведенному выше примеру в Python 2, вы получите 16 без десятичной точки.

Целочисленное деление Python 3 использует оператор «//». Выражение 100 // 40 вернет значение 2.

Вычитание (-)

Вычитание противоположно сложению. Оператор — знак «-«:

a = 15 b = 25 c = a — b печатает (c)> -10

То же самое и с действительными числами: если хотя бы один операнд имеет тип float, результатом будет float:

i = 10 j = 5 k = 0.0 # реальный ноль print (i — j — k)> 5.0 print (type (i — j — k)) >

Случайные числа

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

Используйте другой браузер
случайный вопрос
печать (random.randrange (1, 1000))

Результатом будет новое число от 1 до 1000, каждое со своим.

Деление с остатком Python

Изучение операций над наборами Python

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

Деление модуля Python (с остатком) — пример:

o = 85 p = 15 отпечатков (o% p)

Производство

10

В этом примере 85 делится на 15. Результат 5 с остатком 10. Отображается значение 10, потому что оператор возвращает остаток от деления.

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

q = 36.0 r = 6.0 print (или% p)

Производство

0,0

В приведенном выше примере 36,0 делится на 6,0 без остатка, поэтому возвращается 0,0.

Представление чисел в других системах счисления

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

Шестнадцатеричное числовое представление

>>> m = 124504 >>> шестнадцатеричный (m) ‘0x1e658’

Восьмеричное представление

>>> октябрь (м) ‘0o363130’

Двоичное представление числа

>>> контейнер (м) ‘0b11110011001011000’

Вывести число в Python

Функция print () печатает числа на экране.

печать (2,3,4)
2 3 4

Встроенные математические функции

Python имеет множество встроенных функций для работы с числами. Вот самые важные.

round()

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

Используйте другой браузер
# создать числа
а = 0,01
б = 1,45
с = 2,25
d = 3,7
е = 4,5
# округленное число
печать (круглый (а))
печать (круглый (б))
печать (круглый (с))
печать (круглый (d))
печать (раунд (ы))

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

0 1 2 4 4

abs()

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

Используйте другой браузер
# создать числа
а = 1,1
б = -1,5
с = 2
d = -3
е = 0
# показать абсолютное значение
печать (круглый (а))
печать (круглый (б))
печать (круглый (с))
печать (круглый (d))
печать (раунд (ы))

Производство:

1,1 1,5 2 3 0

pow()

Функция pow () используется для возведения числа в степень. Повторите то, что вы можете сделать с оператором **.

В функцию pow () необходимо передать два параметра. Первое — это число, которое нужно возвести в степень, а второе — это сама степень. Пример:

Используйте другой браузер
база = 8
мощность = 2
print (pow (основание, мощность))

Возводим 8 в степень 2. Вывод:

64

Модуль числа

Функция abs () находит число по модулю. Мы передаем значение в параметрах. Если переданное значение отрицательное, abs () вернет положительное число. Форма числа не может быть отрицательной.

>>> абс (-5)
5
>>> абс (5)
5

Остаток от деления (%)

Остаток от деления также называется делением по модулю. Оператор% сначала делит, а затем возвращает остаток.

print (21% 3)> 0 print (21% 5)> 1 print (21% 0)> ZeroDivisionError: целочисленное деление или деление по модулю на ноль

Остаток не может быть целым числом:

печать (21,3% 3)> 0,3000000000000007

Но прелесть этого оператора не в возвращаемой им остаточной стоимости.

Основная особенность модульного деления в том, что с его помощью легко проверить, что одно число делится на другое

Затем следуют четные / нечетные проверки:

import random def parity_check (num): «» «функция, которая проверяет четность числа. Любое четное число делится на 2 без остатка.» «» if num% 2 == 0: return ‘Число четное’ else: return ‘Число нечетное’ # генерируем случайное число и проверяем функцию rnum = random.randint (0, 100) print (rnum) print (parity_check (rnum))> 62> Число четное

Проверка нечетных / четных чисел будет обычным делом в вашей работе.

Возведение в степень Python

Оператор «**» в Python используется для увеличения левого числа оператора до правой степени. То есть в выражении 5 ** 3 число 5 возведено в третью степень.

В математике часто используется выражение 5³. То есть 5 умножается на себя в три раза. В Python мы получаем тот же результат (125), выполняя 5 ** 3 или 5 * 5 * 5.

Пример с переменными:

s = 52,25 t = 7 отпечаток (s ** t) 1063173305051,292

Увеличение числа с плавающей запятой 52,25 до степени 7 с помощью оператора ** приводит к получению большого числа с плавающей запятой.

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

Функция max () вернет наибольшее число.

>>> максимум (25, 8, 57) 57

Целочисленное деление (//)

Оператор «//» возвращает int, если оба операнда являются целыми числами, и float, если хотя бы один операнд является действительным числом. В любом из вариантов дробная часть будет отброшена, а результат будет округлен в меньшую сторону.

print (15 // 2) # вы можете видеть, что результат был округлен в меньшую сторону> 7 # и остался целым, поскольку и делимое, и делитель являются числами int print (type (15 // 2)) >

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

print (15 // 3.1)> 4.0 print (type (15 // 3.1)) >

при работе с отрицательными числами важно помнить об округлении в меньшую сторону:

print (5 // — 2)> -3 print (5 // 2)> 2

На ноль делить пока нельзя:

print (15 // 0)> ZeroDivisionError: целочисленное деление или деление по модулю на ноль

Округление до целого числа

Функция round () округляет до целого числа.

>>> круглый (2.33)
2
>>> круглый (4.5)
4

Проблемы чисел с плавающей точкой

Компьютер устроен так, что на аппаратном уровне он включает только две цифры: единицу и ноль. По этой причине разбиение и другие операции с дробями часто вызывают проблемы. Например, 1/10 в двоичной системе счисления — неправильная бесконечная дробь. Его нельзя записать полностью, поэтому вам нужно округлить, и выбор значения при округлении ограничен нулем и единицей.

Что говорить о делении, если ошибки возникают даже при операции сложения. Если сложить с собой число «0,1» четырнадцать раз, получится 1,400… 01. Откуда взялась эта единица? Он появился при преобразовании числа из двоичного в десятичное.

a = 0,1 для i в диапазоне (13): a + = 0,1 print (a) 1,4000000000000001

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

Наименьшее число

Функция min () в Python возвращает наименьшее число.

>>> мин (1,8,9)
1

Умножение (*)

Как и две предыдущие операции, умножение в Python не имеет скрытых или неочевидных функций. Умножьте два или более числа с помощью оператора звездочки» (*):

# на этот раз можно обойтись без создания переменных print (2 * 2)> 4 print (2 * 2.0)> 4.0 print (10000 * 0)> 0 print (-33 * 3)> -99

Логические операторы python

В Python всего 3 логических оператора, как в математической логике — «and», «или», «not», в Python это их английские аналоги — and, or, not. Результат этих операций соответствует таблице истинности.

И (and)

Использовать другой браузер Копировать копию a = (1 + 3 == 4) и (2 * 2 == 6) print (a) # Вывод: False

Результатом этой операции будет False, потому что оператор e требует, чтобы оба операнда были True. Тогда и только тогда будет возвращено True.

Или (or)

Использовать другой браузер Скопировано Копировать a = (1 + 3 == 4) или (2 * 2 == 6) print (a) # Вывод: True

Результат этой операции оказался True, потому что для оператора «или» достаточно, чтобы только один из операндов был равен True.

Сокращенные операции деления

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

	Заполнить форму	Короткая форма
Разделение	а = а / б	а / = Ь
Целая часть	а = а // б	а // = б
Отдыхать	а = а% b	а% = б

Вот пример:

а = 245 а% = 17 отпечаток (а) 7

Приоритет операторов

Операторы Python выполняются в порядке приоритета. Посмотрим на следующее выражение:

и = 10 + 10 * 5

Сначала выполняется умножение. Следовательно, если мы вызовем метод print (u), мы получим следующее значение:

Производство

60 Освоение Python 3 — Работа с файлами

Это потому, что 10 * 5 равно 50, поэтому мы прибавляем 10, чтобы получить 60.

Если бы вы сложили 10 и 10 и умножили сумму на 5, вам пришлось бы использовать круглые скобки, как в математике:

u = (10 + 10) * 5 отпечатков (u)

Производство

100

Числа с плавающей точкой (float)

Точка используется для разделения целой части числа в Python. Давайте посмотрим на создание поплавка на примере:

num1 = 0,1 num2 = 0,22 # Назначить целые числа переменным print (num1, num2) # Вывод 0,1 0,22

Деление (/)

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

print (8/2)> 4.0 # делимое и делитель являются целыми числами, а часто являются числами с плавающей запятой print (type (8/2)) > нажмите (8/3)> 2.6666666666666665

Этот вид деления наиболее близок к обычным и знакомым нам математикам. И даже здесь нельзя делить на ноль:

print (8/0)> ZeroDivisionError: деление на ноль

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

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

Арифметические действия в Python

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

a = 1 + 1 print (a) # print 2

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

a = 1 + 1.0 print (a) # Печать 2.0

Вычитание выполняется с помощью оператора «-». Пример:

a = 1 — 1 print (a) # Печать 0

Умножение выполняется с помощью оператора “*”:

a = 2 * 2 print (a) # Печать 4

Возведение в степень выполняется с помощью оператора «**». Пример:

a = 2 ** 3 print (a) # Печать 8

Также возведение в степень можно выполнить с помощью функции pow():

num1 = 2 num2 = 3 print (pow (num1, num2)) # Распечатать 8

Деление выполняется с помощью оператора «/». Пример:

a = 4/2 print (a) # Печать 2

Оператор «%» используется для получения остатка от деления. Пример:

a = 5% 2 print (a) # Печать 1

Целочисленное деление выполняется с помощью оператора «//». Пример:

a = 5 // 2 print (a) # Печать 2

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

е = 45 + 55
печать (и)
100
j = 4,5 + 5
печать (j)
9,5

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

Эти операторы присваивают значение правого операнда левому. Есть только один оператор, который просто присваивает значение, и это знак «=» (равно). Все остальные сначала выполняют некоторые арифметические операции между двумя операндами, и полученный результат записывается в левый операнд.

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

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

Использовать другой браузер Скопировано Копировать a = 100 b = 25 print (a, b) # Вывод: 100 25

Сложение и присваивание

Значение переменной b добавляется к значению переменной a, после чего результат записывается в a:

Использовать другой браузер Скопировано Копировать a + = b print (a) # Вывод: 125

Вычитание и присваивание

Значение переменной b вычитается из значения переменной a, после чего результат записывается в a:

Использовать другой браузер Копировать копию a — = b print (a) # Вывод: 75

Деление и присваивание

Значение переменной a делится на значение переменной b, после чего результат записывается в a:

Использовать другой браузер Копировать копию a / = b print (a) # Вывод: 4.0

Умножение и присваивание

Значение переменной a умножается на значение переменной b, после чего результат записывается в a:

Использовать другой браузер Скопировано Копировать a * = b print (a) # Вывод: 2500

Деление по модулю и присваивание

Значение переменной a делится на значение переменной b, после чего остаток от деления записывается в a:

Использовать другой браузер Копировать скопировано a% = b print (a) # Вывод: 0 a = 68 b = 23 a% = b print (a) # Вывод: 22

Возведение в степень и присваивание

Значение переменной a возводится в степень, равную значению переменной b, после чего результат записывается в a:

Использовать другой браузер Копировать копию a ** = b print (a) # Вывод: 1000000000000000000000000000000000000000000000

Деление с остатком и присваивание

Значение переменной a делится на значение переменной b, после чего целая часть результата деления записывается в a:

Использовать другой браузер Копировать копию a // = b print (a) # Вывод: 4 a = 68 b = 23 a // = b print (a) # Вывод: 2