- Математические операторы Python 3
- Сумма в питоне и разность в питоне
- Библиотека (модуль) math
- Комплексные числа (complex)
- Битовые операции
- Деление без остатка
- Вещественные числа (float)
- Дополнительные методы
- Работа с комплексными числами
- Конвертация типов чисел
- Ввести число в Python
- Унарные арифметические операции Python
- Оператор сравнения
- Проверка типа данных переменной
- Умножение и деление в питоне
- Вычитание (-)
- Случайные числа
- Деление с остатком Python
- Представление чисел в других системах счисления
- Вывести число в Python
- Встроенные математические функции
- round()
- abs()
- pow()
- Модуль числа
- Остаток от деления (%)
- Возведение в степень Python
- Максимальное число
- Целочисленное деление (//)
- Округление до целого числа
- Проблемы чисел с плавающей точкой
- Наименьшее число
- Умножение (*)
- Логические операторы python
- И (and)
- Или (or)
- Сокращенные операции деления
- Приоритет операторов
- Числа с плавающей точкой (float)
- Деление (/)
- Арифметические действия в 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
Ввести число в 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)) # Печать
Умножение и деление в питоне
Оператор, который мы будем использовать в 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)) >
Этот вид деления наиболее близок к обычным и знакомым нам математикам. И даже здесь нельзя делить на ноль:
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
- https://www.internet-technologies.ru/articles/kak-vypolnyat-matematicheskie-deystviya-s-pomoschyu-operatorov-python-3.html
- https://devpractice.ru/python-lesson-4-arithmetic-operations/
- https://timeweb.com/ru/community/articles/chisla-v-python-i-metody-raboty-s-nimi
- https://all-python.ru/osnovy/delenie.html
- https://PythonWorld.ru/tipy-dannyx-v-python/chisla-int-float-complex.html
- https://PythonRu.com/osnovy/rabota-s-chislami-v-python
- https://MyRusakov.ru/python-numbers.html
- https://pythonpip.ru/osnovy/osnovnye-operatory-v-python
- https://pythonchik.ru/matematika/matematicheskie-operacii-v-python
- [https://PythonInfo.ru/osnovy/ostatok-ot-deleniya-python]