Как найти число без остатка python

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

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

Оператор деления

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

Это появилось в 3-ей версии Python, ранее результатом деления целых чисел было только целое число, чтобы получить дробный результат, программисты явно указывали одному из операндов тип «float», в противном случае дробная часть просто отбрасывалась.

Важно понимать, что деление в Python, как и другие операции, работает медленнее, чем в более низкоуровневых языках программирования. Это связано с высоким уровнем автоматизации и абстракции, из-за динамической типизации интерпретатор вынужден приводить числа к дробному типу «float», который требует большего количества памяти.

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

Примеры:

print(int(1) / int(2))
print(5 / 5)
print(1 / 3)

0.5
1.0
0.3333333333333333

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

Дополнительно хотелось бы отметить, что если точности типа данных float не достаточно, можно воспользоваться библиотекой decimal. В частности мы её использовали при написании программы «калькулятор» в отдельной статье.

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

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

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

Примеры нахождения целой части от деления:

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

2
0
246.0

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

Остаток

Для получения остатка от деления в Python 3 используется операция, обозначающаяся символом процента «%». Остаток — это оставшаяся после целочисленного деления часть числа. Операция взятия остатка используется для решения различных видов задач.

Примеры:

print(10 % 3)
print(5 % 10)
print(5 % 0.25)

1
5
0.0

Определение остатка от деления очень часто используется в программах для нахождения, допустим, чётных чисел. Или, например, если обработка данных выполняется в цикле, и нужно выводить в консоль сообщение о ходе обработки не каждый раз, а на каждой 10-ой итерации.

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

example_list = [3, 7, 2, 8, 1, 12]
for value in example_list:
    if value % 2 == 0:
        print(value)

2
8
12

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

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

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

a = 0.1
for i in range(13):
    a += 0.1
print(a)

1.4000000000000001

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

Деление комплексных чисел

Комплексные числа — это числа вида «a + b·i». Они занимают наивысшую ступень в иерархии чисел, арифметические операции над ними существенно отличаются от операций над обычными числами.

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

Пример:

print((5 + 8j) / 2)

(2.5+4j)

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

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

Приведём пример:

a = 245
a %= 17
print(a)

7

Деление на ноль

Если попробовать в Python выполнить деление на 0, то мы получим исключение ZeroDivisionError.

Исключение следует обрабатывать, это можно сделать так:

try:
    print(24 / 0)
except Exception as e:
    print(e)

division by zero

Но в этом случае мы обрабатываем все исключения. Зачастую так делать не совсем корректно. Мы знаем, что в нашем коде возможно деление на 0 и, чтобы отловить именно эту ошибку, следует заменить except Exception as e: на except ZeroDivisionError as e:.
Но можно и проверять перед выполнением операции, что делитель не равен 0. Например так:

a = 14
b = None
if a == 0:
    print('делитель равен нулю!')
else:
    b = 345/a
    print('Операция выполнена, результат = ' + str(b))

Операция выполнена, результат = 24.642857142857142

Статья содержит описание основных операторов языка 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)
• ~ — инвертирующий оператор (отрицание, для него требуется только один операнд)
• << — бинарный сдвиг влево
• >> — бинарный сдвиг вправо

Бинарное «и»

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

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

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

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

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

Оператор // в Python 3 используется для выполнения деления без остатка.

Это означает, что a // b сначала делит a на b и получает целое частное, отбрасывая остаток. Это означает, что результат a//b всегда целое число.

Примеры

Вот несколько примеров, иллюстрирующих то же самое:

>>> 2 // 3
0
>>> 1.3 // 2
0.0
>>> 1.3 // 1.0
1.0
>>> 3.4 // 1.1
3.0
>>> 3.4 // 1.2
2.0
>>> -1//2
-1
>>> -6 // 2
-3
>>> -6 // -3
2

Это показывает, как оператор // выполняет деление на основе пола, учитывая только целую часть деления, даже для чисел с плавающей запятой.

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

Перегрузка оператора //

// по умолчанию относится к оператору __floordiv__() , поэтому вы можете выполнить перегрузку оператора, переопределив этот метод ( operator.__floordiv__(a, b) )

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

Таким образом, два целочисленных списка [3, 4, 5] и [2, 2, 1] дадут [3//2, 4//2, 5//1] , который является просто списком [1, 2, 5] .

import operator

class MyClass():
    def __init__(self, a):
        self.a = a

    def __floordiv__(self, b):
        if isinstance(self.a, list) and isinstance(b.a, list) and len(self.a) == len(b.a):
            result = []
            # Overload // operator for Integer lists
            for i, j in zip(self.a, b.a):
                result.append(i // j)
            return result
        else:
            # Perform Default // operation otherwise
            return operator.__floordiv__(self.a, b.a)

m = MyClass([3, 4, 5])
n = MyClass([2, 2, 1])

print(m // n)

Вывод

[1, 2, 5]

Вывод

В этой статье мы узнали об операторе деления без остатка //. Мы также узнали о выполнении перегрузки оператора для этого, реализовав operator.__floordiv__(a, b) .

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

Оператор в Python — это символ, который выполняет операцию над одним или несколькими операндами.
Операндом выступает переменная или значение, над которыми проводится операция.

Операторы Python бывают 7 типов:

• Арифметические операторы
• Операторы сравнения
• Операторы присваивания
• Логические операторы
• Операторы принадлежности
• Операторы тождественности
• Битовые операторы

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

Этот тип включает операторы для проведения базовых арифметических операций.

Сложение (+)

Складывает значение по обе стороны оператора.
Пример:

>>> 3+4

7  

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

Вычитает значение правой стороны из значения в левой.
Пример:

>>> 3-4

-1  

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

Перемножает значения с обеих сторон оператора.
Пример:

>>> 3*4

12  

Деление (/)

Делит значение левой стороны на значение правой. Тип данных результата деления — число с плавающей точкой.
Пример:

>>> 3/4

0.75 

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

Возводит первое число в степень второго.
Пример:

>>> 3**4

81

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

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

>>> 4//3

1

>>> 10//3

3

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

Выполняет деление и возвращает значение остатка.
Пример:

>>> 3%4

3

>>> 4%3

1

>>> 10%3

1

>>> 10.5%3

1.5

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

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

Меньше (<)

Этот оператор проверяет, является ли значение слева меньше, чем правое.
Пример:

>>> 4<3

False

Больше (>)

Проверяет, является ли значение слева больше правого.

Пример:

>>> 4>3

True

Меньше или равно (<=)

Проверяет, является ли левая часть меньше или равной правой.
Пример:

>>> 7<=7

True

Больше или равно (>=)

Проверяет, является ли левая часть больше или равной правой.
Пример:

>>> 0>=0

True

Равно (==)

Этот оператор проверяет, равно ли значение слева правому. 1 равна булевому True, а 2 (двойка) — нет. 0 равен False.
Пример:

>>> 3==3.0

True

>>> 1==True

True

>>> 7==True

False

>>> 0==False

True

>>> 0.5==True

False

Не равно (!=)

Проверяет, не равно ли значение слева правому. Оператор <> выполняет ту же задачу, но его убрали в Python 3.

Когда условие выполнено, возвращается True. В противном случае — False. Это возвращаемое значение можно использовать в последующих инструкциях и выражениях.
Пример:

>>> 1!=1.0

False

>>> 1==True  # Это вызывает SyntaxError

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

Оператор присваивания присваивает значение переменной. Он может манипулировать значением до присваивания. Есть 8 операторов присваивания: 1 простой и 7 с использованием арифметических операторов.

Присваивание (=)

Присваивает значение справа левой части. Стоит обратить внимание, что == используется для сравнения, а = — для присваивания.
Пример:

>>> a = 7
>>> print(a)

7

Сложение и присваивание (+=)

Суммирует значение обеих сторон и присваивает его выражению слева. a += 10 — это то же самое, что и a = a + 10.

То же касается и все остальных операторов присваивания.
Пример:

>>> a += 2
>>> print(a)

9 

Вычитание и присваивание (-=)

Вычитает значение справа из левого и присваивает его выражению слева.
Пример:

>>> a -= 2
>>> print(a)

7

Деление и присваивание (/=)

Делит значение слева на правое. Затем присваивает его выражению слева.
Пример:

>>> a /= 7
>>> print(a)

1.0

Умножение и присваивание (*=)

Перемножает значения обеих сторон. Затем присваивает правое левому.
Пример:

>>> a *= 8
>>> print(a)

8.0

Деление по модулю и присваивание (%=)

Выполняет деление по модулю для обеих частей. Результат присваивает левой части.
Пример:

>>> a %= 3
>>> print(a)

2.0

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

Выполняет возведение левой части в степень значения правой части. Затем присваивает значение левой части.
Пример:

>>> a **= 5
>>> print(a)

32.0

Деление с остатком и присваивание (//=)

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

>>> a //= 3
>>> print(a)

10.0

Это один из важных операторов Python

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

Это союзы, которые позволяют объединять по несколько условий. В Python есть всего три оператора: and (и), or (или) и not (не).

И (and)

Если условия с двух сторон оператора and истинны, тогда все выражение целиком считается истинным.
Пример:

>>> a = 7 > 7 and 2 > -1
>>> print(a)

False

Или (or)

Выражение ложно, если оба операнда с двух сторон ложные. Если хотя бы одно из них истинное, то и все выражение истинно.
Пример:

>>> a = 7 > 7 or 2 > -1
>>> print(a)

True

Не (not)

Этот оператор инвертирует булевые значения выражения. True превращается в False и наоборот. В примере внизу булево значение 0 — False. Поэтому оно превращается в True.
Пример:

>>> a = not(0)
>>> print(a)

True

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

Эти операторы проверяют, является ли значение частью последовательности. Последовательность может быть списком, строкой или кортежем. Есть всего два таких оператора: in и not in.

В (in)

Проверяет, является ли значение членом последовательности. В этом примере видно, что строки fox нет в списке питомцев. Но cat — есть, поэтому она возвращает True. Также строка me является подстрокой disappointment. Поэтому она вернет True.
Пример:

>>> pets=['dog','cat', 'ferret']
>>> 'fox' in pets

False

>>> 'cat' in pets

True

>>> 'me' in 'disappointment'

True

Нет в (not in)

Этот оператор проверяет, НЕ является ли значение членом последовательности.
Пример:

>>> 'pot' not in 'disappointment'

True

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

Эти операторы проверяют, являются ли операнды одинаковыми (занимают ли они одну и ту же позицию в памяти).

Это (is)

Если операнды тождественны, то вернется True. В противном случае — False. Здесь 2 не является 20, поэтому вернется False. Но '2' — это то же самое, что и "2". Разные кавычки не меняют сами объекты, поэтому вернется True.
Пример:

>>> 2 is 20

False

>>> '2' is "2"

True

Это не (is not)

2 — это число, а '2' — строка. Поэтому вернется True.
Пример:

>>> 2 is not '2'

True

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

Эти операторы работают над операндами бит за битом.

Бинарное И (&)

Проводит побитовую операцию and над двумя значением. Здесь бинарная 2 — это 10, а 3 — 11. Результатом побитового and является 10 — бинарная 2. Побитовое and над 011(3) и 100(4) выдает результат 000(0).
Пример:

>>> 2&3

2

>>> 3&4

0

Бинарное ИЛИ (|)

Проводит побитовую операцию or на двух значениях. Здесь or для 10(2) и 11(3) возвращает 11(3).
Пример:

>>> 2|3

3

Бинарное ИЛИ НЕТ (^)

Проводит побитовую операцию xor (исключающее или) на двух значениях. Здесь результатом ИЛИ НЕ для 10(2) и 11(3) будет 01(1).
Пример:

>>> 2^3

1

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

Он возвращает инвертированные двоичные числа. Другими словами, переворачивает биты. Битовая 2 — это 00000010. Ее инвертированная версия — 11111101. Это бинарная -3. Поэтому результат -3. Похожим образом ~1 равняется -2.
Пример:

>>> ~-3

2

Еще раз, инвертированная -3 — это 2.

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

Он сдвигает значение левого операнда на позицию, которая указана справа. Так, бинарная 2 — это 10. 2 << 2 сдвинет значение на две позиции влево и выйдет 1000 — это бинарная 8.
Пример:

>>> 2<<2

8

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

Сдвигает значение левого оператора на позицию, указанную справа. Так, бинарная 3 — это 11. 3 >> 2 сдвинет значение на два положение вправо. Результат — 00, то есть 0. 3 >> 1 сдвинет на одну позицию вправо, а результатом будет 01 — бинарная 1.
Пример:

>>> 3>>2
>>> 3>>1

1

Выводы

В этом уроке были рассмотрены все 7 типов операторов Python. Для каждого был предложен пример в IDE. Для понимания особенностей работы операторов нужно продолжать с ними работать, использовать в условных конструкциях и объединять.