Mod в питоне как пишется

Python is a high-level, interpreted programming language that is widely used in various applications, such as web development, data analysis, artificial intelligence, and scientific computing. One of the built-in functions in Python is the mod function, which is used to calculate the remainder of a division operation. In this article, we will discuss the mod function in Python, its syntax, and how it works. We will also provide some examples to illustrate its usage.

What is Python Mod() Function?

The mod function in Python is used to calculate the remainder of a division operation between two numbers. The remainder is the amount left over after the division is performed. For example, the remainder of the division operation 10/3 is 1, since 10 divided by 3 equals 3 with a remainder of 1. The mod function returns the remainder of a division operation as a single value.

Syntax of the Python Mod Function

The syntax of the mod function in Python is as follows:

result = x % y

where x and y are the two numbers being divided, and the result is the remainder of the division operation.

Return Type of the Python Mod Function

The Python Mod Function returns the remainder of the parameters passed.

How does the Python Mod Function Work?

The mod function in Python works by performing the division operation between two numbers and returning the remainder. If the division operation results in a whole number, then the remainder is zero. For example, the mod function for 6 % 3 would return 0, since 6 divided by 3 is 2 with no remainder.

If the division operation results in a decimal or fractional value, then the mod function returns the decimal or fractional part as the remainder. For example, the mod function for 10 % 3 would return 1, since 10 divided by 3 equals 3 with a remainder of 1, which is the decimal part.

The mod function also works with negative numbers. In this case, the result of the mod function will have the same sign as the divisor (the second argument). For example, the mod function for -10 % 3 would return 2, since -10 divided by 3 equals -3 with a remainder of -1, and the remainder with the same sign as the divisor is 2.

Examples of the Python Mod Function

Let’s look at some examples of using the mod function in Python.

Example 1: Python Mod function with positive numbers
When both the dividend (the first operand) and the divisor (the second operand) of the modulo operator % are positive, the result is simply the remainder of the division operation. Here’s an example:

x = 10
y = 3


result = x % y
print("The remainder of ", x, " divided by ", y, " is ", result)

Output:

The remainder of  10  divided by  3  is  1

Explanation:
In this example, we are calculating 10 % 3. The result is 1, which is the remainder when 10 is divided by 3.

Example 2: Python Mod function with negative numbers
The modulo operator % in Python works differently with negative numbers compared to positive numbers. When the dividend (the first operand) is negative, the result of the modulo operation has the same sign as the divisor (the second operand). Here’s an example:

x = -7
y = 3


result = x % y
print("The remainder of ", x, " divided by ", y, " is ", result)

Output:

The remainder of  -7  divided by  3  is  2

Explanation:
In this example, we are calculating -7 % 3. The result is 2, which is the same as the result of (-7) + 3 = -4. Note that the result is positive, even though the dividend is negative. This is because divisor 3 is positive.

Example 3: Python Mod function with floating-point numbers
In this example, we will use the mod function to calculate the remainder of a division operation between two floating-point numbers.

x = 10.5
y = 3.2


result = x % y
print("The remainder of ", x, " divided by ", y, " is ", result)

Output:

The remainder of 10.5 divided by 3.2 is 0.8999999999999995

Explanation:
In this example, we see that the mod function returns a floating-point value as the remainder.

Example 4: Python Mod Function using divmod()
The modulo operator % returns the remainder of a division operation between two numbers. We can use divmod() to implement the modulo operator as follows:

def modulo_operator(dividend, divisor):
    quotient, remainder = divmod(dividend, divisor)
    return remainder


print( modulo_operator(10, 3))

Output:

1

Explanation:
In this implementation, we first use divmod() to get the quotient and remainder of the division operation. Since we are interested in the remainder (i.e., the result of the modulo operation), we return the remainder value.

In this example, we are calculating 10 % 3, which is 1. The modulo_operator() function correctly returns 1.

Note: that the modulo_operator() function behaves the same way as the built-in % operator. However, using divmod() to implement the modulo operation may be useful in some situations where you also need to get the quotient of the division operation.

Example 5: Python Mod Function with fmod()
The modulo operator % works only for integers, but we can use the fmod() function from the math module to implement a modulo operator that works with floating-point numbers. Here’s an example implementation:

import math


def modulo_operator(dividend, divisor):
    return math.fmod(dividend, divisor)


print(modulo_operator(5.5, 2.2))

Output:

1.1000000000000005

Explanation: In this implementation, we use the fmod() function from the math module to calculate the remainder of the division operation. The fmod() function returns the same result as the % operator, but it works with floating-point numbers.

In this example, we are calculating 5.5 % 2.2, which is 1.1. The modulo_operator() function returns 1.1000000000000005, which is the exact result of the calculation.

Note: that the fmod() function may have different behavior than the % operator for very large or very small numbers due to the limitations of floating-point arithmetic. Also, fmod() raises a ValueError if the second argument (divisor) is zero.

Example 6: Exception in Python Mod Function
In Python, the modulus operator % can raise a ZeroDivisionError exception if the divisor (the second operand) is zero. Here’s an example:

x = 10
y = 0


result = x % y
print("The remainder of ", x, " divided by ", y, " is ", result)

Output:

Traceback (most recent call last):
  File "", line 5, in 
ZeroDivisionError: integer division or modulo by zero

Explanation:
In this example, we are trying to calculate 10 % 0, which is not a valid operation because we cannot divide by zero. Python raises a ZeroDivisionError exception to indicate the error.

To handle this exception, we can use a try-except block like this:

a = 10
b = 0


try:
    result = a % b
except ZeroDivisionError:
    print("Error: division by zero")

Output:

Error: division by zero

Explanation:
In this example, we are trying to calculate the modulus operation of dividend % divisor. If divisor is zero, a ZeroDivisionError exception is raised, and we print an error message.

Note: If you are implementing a modulo operator using divmod() or math.fmod(), you may also need to handle a ZeroDivisionError exception when the divisor is zero.

Conclusion
In this article, we discussed the Python mod function and its usage to calculate the remainder of a division operation. We saw that the mod function works with positive, negative, and floating-point numbers, and returns the remainder as a single value. We have also learned about the divmod() and fmod(). The mod function is a useful tool in programming and can be used in various applications, such as calculating the modulo of a number, checking if a number is odd or even, and so on.

Frequently Asked Questions (FAQs)

Ques 1. What is the modulo function in Python?
Ans. The modulo function in Python is the % operator, which returns the remainder of a division operation.

Ques 2. What is the difference between the modulo operator and the floor division operator in Python?
Ans. The modulo operator % returns the remainder of a division operation, while the floor division operator // returns the quotient rounded down to the nearest integer.

Ques 3. How does the modulo operator work with negative numbers in Python?
Ans. When the dividend of the modulo operation is negative, the result has the same sign as the divisor. For example, -7 % 3 is 2, and 7 % -3 is -2.

Ques 4. What happens if the divisor of the modulo operation is zero in Python?
Ans. If the divisor is zero, Python raises a ZeroDivisionError exception.

Ques 5. Can I use the modulo operator with floating-point numbers in Python?
Ans. Yes, you can use the math.fmod() function to calculate the remainder of a division operation with floating-point numbers.

Ques 6. How can I handle exceptions when using the modulo operator in Python?
Ans. You can use a try-except block to handle exceptions, such as ZeroDivisionError when the divisor is zero.

Ques 7. What is the modulo operator used for in programming?
Ans. The modulo operator is often used in programming for tasks such as finding the remainder of a division operation, calculating the position of an element in a circular array and determining whether a number is even or odd.

When we see a ‘%’ the first thing that comes to our mind is the “percent” but in computer language, it means modulo operation(%) which returns the remainder of dividing the left-hand operand by right-hand operand or in layman’s terms it finds the remainder or signed remainder after the division of one number by another.

Given two positive numbers, a and n, a modulo n (a % n, abbreviated as a mod n) is the remainder of the Euclidean division of a by n, where a is the dividend and n is the divisor.

The Python Modulo Operator

Basically, the Python modulo operation is used to get the remainder of a division. The modulo operator(%) is considered an arithmetic operation, along with +, –, /, *, **, //. In most languages, both operands of this modulo operator have to be an integer. But Python Modulo is versatile in this case. The operands can be either integers or floats.

Syntax:

a % b

Here, a is divided by b, and the remainder of that division is returned.

Example 1: 

Modulo Operator With integer.

Example 2: 

Modulo Operator With float with a negative number.

Output:

13 mod 5 = 3
15.0 mod -7.0 = -6.0

Example 3:

Suppose, we want to calculate the remainder of every number from 1 to n when divided by a fixed number k.

 Output:

1 mod 3 = 1
2 mod 3 = 2
3 mod 3 = 0
4 mod 3 = 1
5 mod 3 = 2

ZeroDivisionError in Python

The only Exception you get with the Python modulo operation is ZeroDivisionError. This happens if the divider operand of the modulo operator becomes zero. That means the right operand can’t be zero. Let’s see the following code to know about this python exception.

 Output:

Cannot divide by zero! Change the value of the right operand.

Last Updated :
11 Apr, 2023

Like Article

Save Article

Как и в других языках программирования, оператор модуля Python выполняет ту же работу по нахождению модуля заданного числа. Оператор представляет собой математический символ, используемый для выполнения различных операций, таких как(+, -, * /) сложение, вычитание, умножение и деление над заданными двумя числами, чтобы вернуть результат в виде целого числа, а также числа с плавающей запятой.

Оператор указывает компилятору выполнить определенные действия на основе переданного символа оператора для данного числа.

Оператор модуля

Оператор модуля Python – это встроенный оператор, который возвращает оставшиеся числа путем деления первого числа на второе. Он также известен как Python modulo. В Python символ модуля представлен в виде символа процента(%). И называется он оператором остатка.

Ниже приведен синтаксис для получения остатка путем деления первого числа на второе.

 
Rem = X % Y  

Здесь X и Y – два целых числа, а модуль(%) используется между ними, чтобы получить остаток, где первое число(X) делится на второе число(Y).

Например, у нас есть два числа, 24 и 5. И мы можем получить остаток, используя модуль или оператор по модулю между числами 24% 5. Здесь 24 делится на 5, что возвращает 4 в качестве остатка и 4 в качестве частного. Когда первое число полностью делится на другое число, не оставляя остатка, результатом будет 0.

Получение остатка двух целых чисел с помощью цикла while

Давайте напишем программу для получения остатка от двух чисел, используя цикл while и оператор модуля(%) в Python.

Get_rem.py

 
while True: # if the while condition is true if block is executed 
    a = input('Do you want to continue or not(Y / N)? ') 
    if a.upper() != 'Y':  # If the user pass 'Y', the following statement is executed. 
        break 
 
    a = int(input(' First number is: ')) # first number 
    b = int(input(' Second number is: ')) # second number 
    print(a, ' % ', b, ' = ', a % b) # perform a % b 
    print(b, ' % ', a, ' = ', b % a) # perform b % a 

Выход:

Do you want to continue or not(Y / N)? Y 
First number is: 37 
Second number is: 5 
37 % 5 = 2 
5 % 37 = 5 
 
Do you want to continue or not(Y / N)? Y 
First number is: 37 
Second number is: 5 
24 % 5 = 4 
5 % 24 = 5 
 
Do you want to continue or not(Y / N)? Y 
First number is: 37 
Second number is: 5 
28 % 5 = 3 
5 % 28 = 5 

Остаток двух чисел с плавающей запятой

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

Mod.py

 
x = float(input('First number: ')) 
y = float(input(' Second number: ')) 
 
res = x % y # store the remainder in res variable 
print("Modulus of two float number is: ", x, "%", y, " = ", res, sep = " ") 

Выход:

First number: 40.5 
 Second number: 20.5 
Modulus of two float number is:  40.5 % 20.5 = 20.0 

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

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

Mod.py

 
while True: 
    x = input(' Do you want to continue(Y / N)? ') 
    if x.upper() != 'Y': 
        break 
    
    # input two integer number and store it into x and y 
    x = int(input(' First number: ')) 
    y = int(input(' Second number: ')) 
 
    print("Modulus of negative number is: ", x, "%", y, " = ", x % y, sep = " ") 
    print("Modulus of negative number is: ", y, "%", x, " = ", y % x, sep = " ") 

Выход:

First number: -10 
Second number: 3 
Modulus of negative number is:  -10 % 3  =  2 
Modulus of negative number is:  3 % -10  =  -7 
 Do you want to continue(Y / N)? N 

Нахождение остатка двух чисел с помощью функции fmod()

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

Fmod.py

 
import math    # import math package to use fmod() function. 
res = math.fmod(25.5, 5.5) # pass the parameters 
print("Modulus using fmod() is:", res) 
ft = math.fmod(75.5, 15.5) 
print(" Modulus using fmod() is:", ft) 
# take two integer from the user 
x = int( input( "First number is")) 
y = int(input("Second number is ")) 
out = math.fmod(x, y) # pass the parameters  
print("Modulus of two numbers using fmod() function is", x, " % ", y, " = ", out)   

Выход:

Modulus using fmod() is: 3.5 
 Modulus using fmod() is: 13.5 
First number is 24 
Second number is 5 
Modulus of two numbers using fmod() function is 24  %  5  =  4.0 

n чисел с помощью функции

Давайте напишем программу на Python, чтобы найти модуль n чисел с помощью функции и цикла for.

getRemainder.py

 
def getRemainder(n, k): 
    for i in range(1, n + 1): 
        # Store remainder in the rem variable when i is divided by k number 
        rem = i % k    
        print(i, " % ", k, " = ", rem, sep = " ") 
 
# use _name_ driver code 
if __name__ == "__main__": 
 
    # define the first number for displaying the number up to desired number.   
    n = int(input("Define a number till that you want to display the remainder ")) 
    k = int( input(" Enter the second number ")) # define the divisor  
 
    # call the define function 
    getRemainder(n, k)   

Выход:

Define a number till that you want to display the remainder 7 
 Enter the second number 5 
1 % 5 = 1 
2 % 5 = 2 
3 % 5 = 3 
4 % 5 = 4 
5 % 5 = 0 
6 % 5 = 1 
7 % 5 = 2 

Заданного массива с помощью функции mod()

Напишем программу для демонстрации функции mod() в Python.

Mod_fun.py

 
import numpy as np # import numpy package 
x = np.array([40, -25, 28, 35]) # define first array 
y = np.array([20, 4, 6, 8]) # define second array 
# call mod() function and pass x and y as the parameter 
print("The modulus of the given array is ", np.mod(x, y)) 

Выход:

The modulus of the given array is [0 3 4 3] 

Как мы видим в приведенной выше программе, переменные x и y содержат массивы. После этого мы используем функцию mod() для передачи x и y в качестве параметра массива, который делит первый массив(x) на второй массив(y), а затем возвращает остаток чисел.

Нахождение модуля двух чисел, используя numpy

Давайте рассмотрим программу для импорта пакета numpy из библиотеки Python, а затем воспользуемся функцией остатка для получения модуля в Python.

Num.py

 
import numpy as np # import numpy package as np 
# declaration of the variables with their values 
num = 38  
num2 = 8 
res = np.remainder(num, num2) # use np.remainder() function 
print( "Modulus is", num, " % ", num2, " = ", res) # display modulus num % num2 

Выход:

Modulus is 38 % 8 = 6 

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

Напишем программу для демонстрации оператора Python Exception in Modulus.

Except.py

 
x = int(input(' The first number is: ')) 
y = int(input(' The second number is: ')) 
 
# display the exception handling 
try: # define the try 
    print(x, ' % ', y, ' = ', x % y) 
except ZeroDivisionError as err: # define the exception  
    print('Cannot divide a number by zero! ' + 'So, change the value of the right operand.' )     

Выход:

The first number is: 24 
The second number is: 0 
Cannot divide a number by zero! So, change the value of the right operand. 

Как видно из приведенного выше результата, он отображает: «Невозможно разделить число на ноль! Поэтому измените значение правого операнда». Следовательно, мы можем сказать, что когда мы делим первое число на ноль, оно возвращает исключение.

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

Введение в операторы Python

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

Операторы языка Питон подразделяются на 7 видов:

• Знаки арифметических операций
• Сравнительные
• Присваивающие
• Логические
• Операторы принадлежности (или членства, или вложенности)
• Тождественные
• Битовые (или бинарные)

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

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

Рассмотрим примеры работы различных операторов (в качестве среды разработки в примерах используется Visual Studio 2019). Синтаксис python позволяет сразу же вычислять результат операции без присвоения его какой-либо переменной; это свойство будет использовано в некоторых примерах. Также не нужно производить import каких-либо библиотек: все основные команды python являются стандартными и зарезервированными.

Сложение

Складываем один и два:

Вычитание

Вычитаем из четырёх два:

Умножение

Умножаем десять на пять:

print(10 * 5)

# Вывод:

50


  

Деление

Делим двадцать четыре на шесть:

print(24 / 6)

# Вывод:

4.0


  

Примечание. Результат деления в Python 3 и выше всегда приводится к типу float (число с плавающей запятой), который требует большее количество памяти, чем, например, целочисленный тип int, в связи с чем деление (и другие операции) в питон работает медленнее, чем в более низкоуровневых языках.

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

Возводим семь во вторую степень (или в квадрат):

print(7 ** 2)

# Вывод:

49


  

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

Ищем целую часть от деления семи на два:

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

print(70 // 2.0)

# Вывод:

35.0


  

Одно из чисел вещественное в этом — в этом и состоит загвоздка. В таком случае ответ обязан быть вещественным числом.

Деление по модулю (остаток от деления)

Ищем остаток от деления семи на два:

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

Эти операторы сравнивают 2 значения (строковые или числовые). Любой из операторов данного типа возвращает булевое значение — True или False.

Оператор «меньше»

print(13 < 15)

# Вывод:

True


  

13 меньше, чем 15 — это верно.

print(13 < 12)

# Вывод:

False


  

13 меньше, чем 12 — это не верно.

Оператор «больше»

print(13 > 13)

# Вывод:

False


  

13 меньше, чем 13 — это не верно.

print(13 > 10)

# Вывод:

True


  

13 меньше, чем 10 — это верно.

Оператор «меньше или равно»

print(13 <= 17)

# Вывод:

True


  

13 меньше или равно 17 — это верно.

print(13 <= 1)

# Вывод:

False


  

13 меньше или равно 1 — это не верно.

Оператор «больше или равно»

print(13 >= 13)

# Вывод:

True


  

13 большее или равно 13 — это верно.

print(13 >= 17)

# Вывод:

False


  

13 большее или равно 17 — это не верно.

Оператор «равно»

print(13 == 13)

# Вывод:

True


  

13 равно 13 — это верно.

print(13 == 14)

# Вывод:

False


  

13 равно 14 — это не верно.

Оператор «не равно»

print(13 != 13)

# Вывод:

False


  

13 не равно 13 — это не верно.

print(13 != 14)

# Вывод:

True


  

13 не равно 14 — это верно.

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

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

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

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

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)

# Вывод:

100000000000000000000000000000000000000000000000000


  

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

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

a //= b

print(a)

# Вывод:

4

a = 68

b = 23

a //= b

print(a)

# Вывод:

2


  

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

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

И (and)

a = (1 + 3 == 4) and (2 * 2 == 6)

print(a)

# Вывод:

False


  

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

Или (or)

a = (1 + 3 == 4) or (2 * 2 == 6)

print(a)

# Вывод:

True


  

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

Не (not)

a = (1 + 3 == 4) and not (2 * 2 == 6)

print(a)

# Вывод:

True


  

Так как наш «неверный» правый операнд в результате применения к нему операции not изменил своё значение на True, то верным стало и всё выражение целиком.

Операторы принадлежности (членства)

Эти операторы проверяют, существует ли заданное значение в известном списке, словаре, кортеже или строке. Можно сказать, что таковых в питон всего 2 — это in и его отрицание not in. Соответственно, in вернёт True в случае наличия элемента в последовательности, а not in, наоборот, вернёт False, если данный элемент есть в последовательности, и True, если его нет.

В (in)

a = "abc" in "abcdef"

print(a)

# Вывод:

True


  

Строка «abc» является подстрокой строки «abcdef», соответственно, являясь подпоследовательностью данной последовательности.

a = 10 in (1, 7, 13, 6)

print(a)

# Вывод:

False


  

Числа 10 нет в этом списке, потому мы и видим False.

Нет в (not in)

a = 10 not in (1, 7, 13, 6)

print(a)

# Вывод:

True


  

Элемента 10 нет в данном списке, поэтому операция вернёт True. А если он будет:

a = 10 not in (1, 7, 13, 6, 10)

print(a)

# Вывод:

False


  

В этом списке уже есть значение 10, поэтому оператор непринадлежности возвращает False.

a = "abc" not in "abcdef"

print(a)

# Вывод:

False


  

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

Их, как и операторов принадлежности, всего два, и один из них является отрицанием другого. Оператор в python is сравнивает положение двух объектов в памяти и выясняет, один и тот же ли это объект, в случае успеха возвращая True. Оператор not is вернёт True, если проверка показала, что сравниваемые объекты являются разными (имеют разное расположение в памяти).

Это (is)

print("10" is '10')

# Вывод:

True


  

Разные кавычки не влияют на результат выполнения операции, так как это в любом случае строка, один и тот же объект. Но если сравнить строку и число, результат будет иным:

print(10 is '10')

# Вывод:

False


  

Это действительно разные объекты, находящиеся в разных местах памяти.

Это не (is not)

print(20 is not (20 + 1))

# Вывод:

True


  

Верно, ведь 20 не равно 21.

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

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

Всего в питон 6 побитовых операторов:

• & — бинарное «и»
• | — бинарное «или»
• ^ — бинарное «или нет» (исключающее ИЛИ, или XOR)
• ~ — инвертирующий оператор (отрицание, для него требуется только один операнд)
• << — бинарный сдвиг влево
• >> — бинарный сдвиг вправо

Бинарное «и»

Бинарное «или»

Бинарное «или нет»

Инвертирующий оператор

Бинарный сдвиг влево

Бинарный сдвиг вправо