Основные операторы python

Введение в PEP8 (Python Enhancement Proposal #8)

Документ Python Enhancement Proposal #8 (сокращенно РЕР8) содержит предложения по стилевому оформлению кода программ на языке Python. Вообще говоря, вы вправе форматировать свой код так, как считаете нужным. Однако применение единообразного стиля облегчит изучение кода другими людьми и улучшит его удобочитаемость. Совместное использование общего стиля с другими Руthоn-программистами в рамках большого сообщества способствует улучшению качества программ при коллективной работе над проектами. Но даже если единственный человек, который когда-либо будет читать ваш код, — это вы, соблюдение рекомендаций РЕР 8 облегчит внесение последующих изменений в код.

Документ РЕР8 содержит детализированные правила написания кода на Python. По мере развития языка этот документ постоянно обновляется. Было бы неплохо, если бы вы прочитали целиком все руководство

• Официальный Guide PEP8 на английском языке 
• PEP 8 — руководство по написанию кода на Python. Перевод на русский язык
• PEP8 — стиль кода в языке Python

Ниже приведены некоторые правила, которых следует обязательно придерживаться.

1.2. Проверка нескольких условий.

Для проверки нескольких условий одновременно, используйте ключевое слово and. Чтобы выражение было истинно (True) оба условия должны быть истинны. В примере проверим возраст людей, чтобы был младше или в возрасте 30 лет.

>>> age_1 = 29
>>> age_2 = 20
>>> age_1 <= 30 and age_2 <= 30True

Если оба условия выполнены, то возвращается True.

Использование or для проверки нескольких условий.

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

>>> age_1 = 29
>>> age_2 = 20
>>> age_1 < 25 or age_2 < 25True

Переопределение операторов ‘==’ и ‘!=’

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

Еще одно различие между этими операторами заключается в том, что можно переопределить поведение / для пользовательского класса. Но нельзя переопределить поведение .

Если вы реализуете в пользовательском классе собственный метод , то сможете изменить поведение операторов / :

class TestingEQ:
    def __init__(self, n):
        self.n = n

    # используем '==', чтобы проверить четны ли оба числа
    # или нечетны
    def __eq__(self, other):
        if (self.n % 2 == 0 and other % 2 == 0):
            return True
        else:
            return False


print(5 == TestingEQ(1))
print(2 == TestingEQ(10))
print(1 != TestingEQ(2))

Выполнение кода дает следующий результат:

False
True
True

Итерация по Списку в Python С Использованием Понимания списка

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

Синтаксис

Понимание списка обычно состоит из трех параметров.

• expression: Это сам член, вызов метода или любое другое допустимое выражение, которое возвращает значение.
• пункт: Это объект или значение в списке или итеративном.
• list/iterable: Это список, набор, последовательность, генератор или любой другой объект, который может возвращать свои элементы по одному за раз

Объяснение

Это самый простой способ перебора списка, поскольку Python включает в себя простые и мощные инструменты, которые вы можете использовать в самых разных ситуациях. Здесь, в этом примере, print(i) является выражением. Второй ‘i’ – это элемент, который является значением iterable. И, наконец, итерируемый, в приведенном выше примере итерируемый-это список.

Числа: целые, вещественные, комплексные

Числа в Python 3: целые, вещественные, комплексные. Работа с числами и операции над ними.

Целые числа (int)

Числа в Python 3 ничем не отличаются от обычных чисел. Они поддерживают набор самых обычных математических операций:

x + y	Сложение
x — y	Вычитание
x * y	Умножение
x / y	Деление
x // y	Получение целой части от деления
x % y	Остаток от деления
-x	Смена знака числа
abs(x)	Модуль числа
divmod(x, y)	Пара (x // y, x % y)
x ** y	Возведение в степень
pow(x, y)	x y по модулю (если модуль задан)

Также нужно отметить, что целые числа в python 3, в отличие от многих других языков, поддерживают длинную арифметику (однако, это требует больше памяти).

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

Над целыми числами также можно производить битовые операции

x | y	Побитовое или
x ^ y	Побитовое исключающее или
x & y	Побитовое и
x > y	Битовый сдвиг вправо

x

Инверсия битов

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

int.bit_length() — количество бит, необходимых для представления числа в двоичном виде, без учёта знака и лидирующих нулей.

int.to_bytes(length, byteorder, *, signed=False) — возвращает строку байтов, представляющих это число.

classmethod int.from_bytes(bytes, byteorder, *, signed=False) — возвращает число из данной строки байтов.

Системы счисления

Те, у кого в школе была информатика, знают, что числа могут быть представлены не только в десятичной системе счисления. К примеру, в компьютере используется двоичный код, и, к примеру, число 19 в двоичной системе счисления будет выглядеть как 10011. Также иногда нужно переводить числа из одной системы счисления в другую. Python для этого предоставляет несколько функций:

• int(, ) — преобразование к целому числу в десятичной системе счисления. По умолчанию система счисления десятичная, но можно задать любое основание от 2 до 36 включительно.
• bin(x) — преобразование целого числа в двоичную строку.
• hex(х) — преобразование целого числа в шестнадцатеричную строку.
• oct(х) — преобразование целого числа в восьмеричную строку.

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

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

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

Также вещественные числа не поддерживают длинную арифметику:

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

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

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

float.is_integer() — является ли значение целым числом.

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

classmethod float.fromhex(s) — float из шестнадцатеричной строки.

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

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

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

Также для работы с комплексными числами используется также модуль cmath.

Логические выражения и логический тип данных

Часто в реальной жизни мы соглашаемся с каким-либо утверждением или отрицаем его. Например, если вам скажут, что сумма чисел 3 и 5 больше 7, вы согласитесь, скажете: «Да, это правда». Если же кто-то будет утверждать, что сумма трех и пяти меньше семи, то вы расцените такое утверждение как ложное.

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

Например, выражение 4 > 5 является логическим, так как его результатом является либо правда, либо ложь. Выражение 4 + 5 не является логическим, так как результатом его выполнения является число.

На позапрошлом уроке мы познакомились с тремя типами данных – целыми и вещественными числами, а также строками. Сегодня введем четвертый – логический тип данных (тип ). Его также называют булевым. У этого типа всего два возможных значения: True (правда) и False (ложь).

>>> a = True
>>> type(a)
<class 'bool'>
>>> b = False
>>> type(b)
<class 'bool'>

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

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

>>> int(True)
1
>>> int(False)
0

Возможно и обратное. Можно преобразовать какое-либо значение к булевому типу:

>>> bool(3.4)
True
>>> bool(-150)
True
>>> bool(0)
False
>>> bool(' ')
True
>>> bool('')
False

И здесь работает правило: всё, что не 0 и не пустота, является правдой.

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

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

Оператор	Описание
=	Присваивает значение правого выражения левому операнду.
+=	Увеличивает значение левого операнда на значение правого операнда и присваивает измененное значение обратно левому операнду. Например, если a = 10, b = 20 => a+ = b будет равно a = a+ b и, следовательно, a = 30.
-=	Уменьшает значение левого операнда на значение правого операнда и присваивает измененное значение обратно левому операнду. Например, если a = 20, b = 10 => a- = b будет равно a = a – b и, следовательно, a = 10.
*=	Умножает значение левого операнда на значение правого операнда и присваивает измененное значение обратно левому операнду. Например, если a = 10, b = 20 => a* = b будет равно a = a* b и, следовательно, a = 200.
%=	Делит значение левого операнда на значение правого операнда и присваивает напоминание обратно левому операнду. Например, если a = 20, b = 10 => a % = b будет равно a = a % b и, следовательно, a = 0.
**=	a**=b будет равно a=a**b, например, если a = 4, b =2, a**=b присвоит a 4**2 = 16.
//=	A//=b будет равно a = a// b, например, если a = 4, b = 3, a//=b присвоит 4//3 = 1 a.

Что такое функция в Python?

Функции в Python – это организованный блок многократно используемого кода, который можно вызывать при необходимости.

Функция содержит набор программных операторов, заключенных в {}. Функцию можно вызывать несколько раз, чтобы обеспечить возможность повторного использования и модульность программы Python.

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

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

В основном есть два типа функций:

• Функции, определяемые пользователем. Определяются пользователем для выполнения конкретной задачи.
• Встроенные функции. Это те функции, которые предварительно определены в Python.

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

Имена

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

• Имена функций, переменных и атрибутов должны следовать формату lowercase_underscore (нижний регистр букв, разделение слов символами подчеркивания) .
• Имена защищенных атрибутов экземпляра должны следовать _leading_underscore (один символ подчеркивания в начале).
• Имена закрытых атрибутов экземпляра должны следовать формату __leading_underscore (два символа подчеркивания в начале).
• Имена классов и исключений должны следовать формату CapitalizeWord (каждое слово начинается с прописной буквы).
• Константы уровня модуля должны записываться в формате ALL_CAPS (все буквы прописные, в качестве разделителя используется символ подчеркивания).
• В определениях методов экземпляров классов в качестве имени первого параметра следует всегда указывать self (это имя ссылается на текущий объект).
• В определениях методов классов в качестве имени первого параметра следует всегда указывать cls (это имя ссылается на текущий класс).

Синтаксис

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

Рассмотрим следующую задачу: для данного целого X определим ее абсолютное значение. Если X> 0, то программа должна печатать значение X, иначе оно должно печатать -X. Такое поведение невозможно достичь с помощью последовательной программы. Программа должна условно выбрать следующий шаг. Вот где помогают условия:

-273

x = int(input())
if x > 0:
    print(x)
else:
    print(-x)

Эта программа использует условный оператор . После того мы положим условие следующее двоеточием. После этого мы помещаем блок инструкций, который будет выполняться только в том случае, если условие истинно (т.е. имеет значение ). За этим блоком может следовать слово , двоеточие и другой блок инструкций, который будет выполняться только в том случае, если условие является ложным (т.е. имеет значение ). В приведенном выше случае условие ложно, поэтому выполняется блок «else». Каждый блок должен иметь отступы, используя пробелы.

Подводя итог, условный оператор в Python имеет следующий синтаксис:

if condition :
    true-block
    several instructions that are executed
    if the condition evaluates to True
else:
    false-block
    several instructions that are executed
    if the condition evaluates to False

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

-273

x = int(input())
if x < 0:
    x = -x
print(x)

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

Отступ является общим способом в Python для разделения блоков кода. Все инструкции в одном и том же блоке должны быть отступом одинаково, т. Е. Они должны иметь одинаковое количество пробелов в начале строки. Для отступов рекомендуется использовать 4 пробела.

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

Кстати, встроенная функция для абсолютного значения в Python:

-273

x = int(input())
print(abs(x))

Более сложный пример использования != в Python

Наконец, протестируем оператор сравнения на сложном примере.

Мы инициализировали класс с именем . Внутри этого класса мы инициализировали переменную , имеющую значение 0. Другая переменная — — была инициализирована со значением .

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

Затем мы инициализировали встроенный метод, использующий оператор неравенства, и применили в нем конструкцию .

Далее были созданы три объекта для отправки значений конструктору.

После этого мы сравнили объекты друг с другом и вывели на экран результат сравнения. Сохраним код и запустим его.

class Test:
    i = 0
    data = ''
    def __init__(self, i, s):
        self.i = i
        self.data = s
    def __ne__(self, other):
        if type(other) != type(self):
            return True
        if self.data != other.data:
            return True
        else:
            return False

t1 = Test(1, 'Aqsa')
t2 = Test(2, 'Aqsa')
t3 = Test(3, 'Yasin')
print(t1 != t2)
print(t2 != t3)

На выходе получим значение как возврат первого оператора , поскольку значения, проанализированные для обоих объектов, были одинаковыми. Напротив, второй возвращает True, потому что и имеют разные значения и, следовательно, они не равны.

Побитовая перегрузка оператора

Существуют различные определенные методы перегрузки побитовых операторов в Python.

Побитовый оператор	Syntax
&	__and __ (self, other)
|	__или __ (self, other)
^	__xor __ (self, other)
~	__invert __ (self)
<<	__lshift __ (self, other)
>>	__rshift __ (self, other)

class Operate(): 
    def __init__(self, x): 
        self.x = x 
          
    def __and__(self, res): 
        print("Bitwise AND operator overloading Example") 
        if isinstance(res, Operate): 
            return self.x  res.x 
        else: 
            raise ValueError("Must belong to Operate Class") 
    
          

if __name__ == "__main__": 
    a = Operate(6) 
    b = Operate(4) 
    print(ab) 

Вывод:

Bitwise AND operator overloading Example 4

Python, если заявление больше или равно

Python больше или равен Оператор может быть использован в Если заявление как выражение, чтобы определить, должен ли выполнить ветку или нет. Например, это состояние Проверяет, если значение переменной больше или равно 3, а если да, то входит в ветку IF.

Следующий код просит пользователя вводить свой возраст, используя функция. Затем он проверяет, если пользовательский ввод, при преобразовании в целое число, используя , по крайней мере 18. Если так, это входит в Если ветка. Если нет, это входит в еще ветка.

x = int(input('your age: '))

if x >= 18:
    print('you can vote')
else:
    print('you cannot vote - sorry')

Вот пример выполнения этого кода, где введен ветвь IF:

your age: 18
you can vote

Вот пример исполнения, где IF ветвь не введена:

your age: 17
you cannot vote - sorry

Как оценивается?

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

Однако это не регулярное заявление о назначении. Это называется Увеличенное заявление о назначении Отказ

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

# 2 + 3 is evaluated to 5, before assigning to a
a = 2 + 3

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

# Reads the value of a, before adding 3 to it in-place
a += 3

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

Оператор elif

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

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

Но помните, что первое условие всегда задается с

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

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

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

Сравнение строк с помощью is

Теперь давайте поговорим про сравнение строк с помощью оператора . Он работает следующим образом. Если две переменные указывают на один объект, оператор возвращает True, иначе — False.

Обратите внимание, что даже если обе строки имеют одинаковое значение, все равно может вернуться — если у сравниваемых объектов разные. Подробнее про разницу между операторами и можно почитать в статье «Чем == отличается от is?»

Итак, рассмотрим следующий пример. Мы берем три строки: , , . Переменной мы присваиваем значение . Переменную приравниваем к . приравниваем к , но не просто, а преобразовав в список , хотя, по сути, это и так список, т.е. значения не поменяются. А далее мы сравниваем строки операторами и .

string1 = 
string2 = string1
string3 = list(string1)

print(string1 == string2)
# True

print(string1 == string3)
# True

print(string1 is string2)
# True

print(string1 is string3)
# False

print(id(string1))
# 139879412641216

print(id(string2))
# 139879412641216

print(id(string3))
# 139879412022144

Переменные и абсолютно идентичны и ссылаются на одни и те же объекты. Однако для мы создали новый объект, и хотя значение совпадает со значением , они ссылаются на разные объекты.

Адреса объектов определяются с помощью функции . Мы видим, что адреса объектов и действительно разные, в то время как адреса и совпадают.

Именно поэтому сравнение и обоими операторами возвращает True, поскольку они имеют не только одинаковое значение, но и одинаковый адрес.

Сравнение и оператором дает True, а оператором дает False, так как значения совпадают, но объекты и их адреса — разные.

Классический алгоритм Евклида

Этот вид алгоритма Евклида является самым простым, он был придуман более 1300 лет назад. С появлением электронно-вычислительных машин расширились возможности по применению алгоритма Евклида, возникли новые более эффективные его реализации.

Алгоритм состоит из определенного количества шагов, количество которых зависит от размера входных данных.

Сложность алгоритма выражается функцией O(h2), где h – это количество десятичных цифр в наименьшем числе, наибольший делитель которых ищется алгоритмом.

Реализация на Python

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

Реализация с помощью остатка от деления

Идея такой реализации достаточна проста, алгоритм уменьшает числа до тех пор, пока одно из них не станет равно нулю, а другое искомому делителю. Для этого используется цикл , в котором большее число делится на меньшее и становится равным остатку от деления. Таким образом, функция вернёт наибольший общий делитель (НОД) её двух аргументов.

Код алгоритма Евклида на Python:

def gcd_rem_division(num1, num2):
    while num1 != 0 and num2 != 0:
        if num1 >= num2:
            num1 %= num2
        else:
            num2 %= num1
    return num1 or num2

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

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

• 1 итерация:
  168 % 105 = 63
  105
• 2 итерация:
  63
  105 % 63 = 42
• 3 итерация:
  63 % 42 = 21
  42
• 4 итерация:
  42 % 21 = 0
  21

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

a = gcd_rem_division(168, 105)
print(a) # Выведет 21

Реализация с помощью вычитания

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

Код вычисления НОД на Python:

def gcd_subtraction(num1, num2):
    while num1 != 0 and num2 != 0:
        if num1 >= num2:
            num1 -= num2
        else:
            num2 -= num1
    return num1 or num2

Также распишем работу программы с числами 168 и 105:

• 1 итерация:
  168 — 105 = 63
  105
• 2 итерация:
  63
  105 — 63 = 42
• 3 итерация:
  63 — 42 = 21
  42
• 4 итерация:
  21
  42 — 21 = 21
• 5 итерация:
  21 — 21 = 0
  21

Видно, что до 4 итерации результаты работы обоих версий алгоритма полностью совпадают. Отличия начинаются, когда в 4 итерации вместо 0 и 21, получается числа 21 и 21, из-за чего в алгоритме с вычитанием добавляется дополнительная итерация, но это не значит, что он работает менее эффективнее.

Проверка работы программы:

a = gcd_subtraction(168, 105)
print(a) # Выведет 21

Реализация с помощью рекурсии

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

Код программы на Python нахождения НОД с помощью рекурсии:

def gcd_recursion(num1, num2):
    if num1 == 0:
        return num2
    return gcd_recursion(num2 % num1, num1)

Первое, что стоит заметить, на ноль проверяется только

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

4 итерация:
42 % 21 = 0 — num1
21 — num2

То есть рекурсивный алгоритм проверит число на ноль, получит True и вернёт значение , которое и будет являться наибольшим общим делителем.

Особенности алгоритма: простые числа

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

• 35 = 5 * 7 * 1
• 18 = 2 * 9 * 1 = 3 * 6 * 1

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

Если алгоритм получает на вход одно простое число, это не значит, что он обязательно вернет единицу:

• 5 и 15: число 5 является простым, а 15 — нет, алгоритм вернет наибольший общий делитель 5.
• 5 и 21: число 5 — простое, а 21 — нет, будет возвращена единица, потому что 21 не делится на 5.
• 3 и 21: число 3 — простое, 21 — нет, будет возвращено число 3, потому что 21 делится на 3.

Исходя из этого, можно сказать, что алгоритм Евклида со 100%-ой вероятностью возвращает единицу в том случае, если на вход переданы два простых числа не равных друг другу.

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

Оператор

Краткое описание

+

Сложение (сумма x и y)

—

Вычитание (разность x и y)

*

Умножение (произведение x и y)

Деление
Внимание! Если x и y целые, то результат всегда будет целым числом! Для получения вещественного результата хотя бы одно из чисел должно быть вещественным. Пример: 40/5 → 8, а вот 40/5.0 → 8.0

=

Присвоение

+=

y+=x; эквивалентно y = y + x;

-=

y-=x; эквивалентно y = y — x;

*=

y*=x; эквивалентно y = y * x;

/=

y/=x; эквивалентно y = y / x;

%=

y%=x; эквивалентно y = y % x;

==

Равно

!=

не равно

> 

Больше

=

больше или равно

Часть после запятой отбрасывается
4 // 3 в результате будет 125 // 6 в результате будет 4

**

Возведение в степень
5 ** 2 в результате будет 25

and

логическое И

or

логическое ИЛИ

not

логическое отрицание НЕ