Питон как написать не равно нулю

Что такое оператор?

Говоря простым языком, в выражении 2 + 3, числа «2» и «3» называются операндами, знак «+» оператором. В языке программирования Python существуют следующие типы операторов:

• Арифметические операторы
• Операторы сравнения (реляционные)
• Операторы присваивания
• Побитовые операторы
• Логические операторы
• Операторы членства (Membership operators)
• Операторы тождественности (Identity operators)

Рассмотрим их по порядку.

Оператор	Описание	Примеры
+	Сложение — Суммирует значения слева и справа от оператора	15 + 5 в результате будет 20 20 + -3 в результате будет 17 13.4 + 7 в результате будет 20.4
—	Вычитание — Вычитает правый операнд из левого	15 — 5 в результате будет 10 20 — -3 в результате будет 23 13.4 — 7 в результате будет 6.4
*	Умножение — Перемножает операнды	5 * 5 в результате будет 25 7 * 3.2 в результате будет 22.4 -3 * 12 в результате будет -36
/	Деление — Делит левый операнд на правый	15 / 5 в результате будет 3 5 / 2 в результате будет 2 (В Python 2.x версии при делении двух целых чисел результат будет целое число) 5.0 / 2 в результате будет 2.5 (Чтобы получить «правильный» результат хотя бы один операнд должен быть float)
%	Деление по модулю — Делит левый операнд на правый и возвращает остаток.	6 % 2 в результате будет 0 7 % 2 в результате будет 1 13.2 % 5 в результате 3.2
**	Возведение в степень — возводит левый операнд в степень правого	5 ** 2 в результате будет 25 2 ** 3 в результате будет 8 -3 ** 2 в результате будет -9
//	Целочисленное деление — Деление в котором возвращается только целая часть результата. Часть после запятой отбрасывается.	12 // 5 в результате будет 2 4 // 3 в результате будет 1 25 // 6 в результате будет 4

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

Оператор	Описание	Примеры
==	Проверяет равны ли оба операнда. Если да, то условие становится истинным.	5 == 5 в результате будет True True == False в результате будет False «hello» == «hello» в результате будет True
!=	Проверяет равны ли оба операнда. Если нет, то условие становится истинным.	12 != 5 в результате будет True False != False в результате будет False «hi» != «Hi» в результате будет True
<>	Проверяет равны ли оба операнда. Если нет, то условие становится истинным.	12 <> 5 в результате будет True. Похоже на оператор !=
>	Проверяет больше ли значение левого операнда, чем значение правого. Если да, то условие становится истинным.	5 > 2 в результате будет True. True > False в результате будет True. «A» > «B» в результате будет False.
<	Проверяет меньше ли значение левого операнда, чем значение правого. Если да, то условие становится истинным.	3 < 5 в результате будет True. True < False в результате будет False. «A» < «B» в результате будет True.
>=	Проверяет больше или равно значение левого операнда, чем значение правого. Если да, то условие становится истинным.	1 >= 1 в результате будет True. 23 >= 3.2 в результате будет True. «C» >= «D» в результате будет False.
<=	Проверяет меньше или равно значение левого операнда, чем значение правого. Если да, то условие становится истинным.	4 <= 5 в результате будет True. 0 <= 0.0 в результате будет True. -0.001 <= -36 в результате будет False.

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

Оператор	Описание	Примеры
=	Присваивает значение правого операнда левому.	c = 23 присвоит переменной с значение 23
+=	Прибавит значение правого операнда к левому и присвоит эту сумму левому операнду.	с = 5 а = 2 с += а равносильно: с = с + а. с будет равно 7
-=	Отнимает значение правого операнда от левого и присваивает результат левому операнду.	с = 5 а = 2 с -= а равносильно: с = с — а. с будет равно 3
*=	Умножает правый операнд с левым и присваивает результат левому операнду.	с = 5 а = 2 с *= а равносильно: с = с * а. c будет равно 10
/=	Делит левый операнд на правый и присваивает результат левому операнду.	с = 10 а = 2 с /= а равносильно: с = с / а. c будет равно 5
%=	Делит по модулю операнды и присваивает результат левому.	с = 5 а = 2 с %= а равносильно: с = с % а. c будет равно 1
**=	Возводит в левый операнд в степень правого и присваивает результат левому операнду.	с = 3 а = 2 с **= а равносильно: с = с ** а. c будет равно 9
//=	Производит целочисленное деление левого операнда на правый и присваивает результат левому операнду.	с = 11 а = 2 с //= а равносильно: с = с // а. c будет равно 5

Побитовые операторы в Python:

Побитовые операторы предназначены для работы с данными в битовом (двоичном) формате. Предположим, что у нас есть два числа a = 60; и b = 13. В двоичном формате они будут иметь следующий вид:

a = 0011 1100

b = 0000 1101

Оператор	Описание	Примеры
&	Бинарный «И» оператор, копирует бит в результат только если бит присутствует в обоих операндах.	(a & b) даст нам 12, которое в двоичном формате выглядит так 0000 1100
|	Бинарный «ИЛИ» оператор копирует бит, если тот присутствует в хотя бы в одном операнде.	(a | b) даст нам 61, в двоичном формате 0011 1101
^	Бинарный «Исключительное ИЛИ» оператор копирует бит только если бит присутствует в одном из операндов, но не в обоих сразу.	(a ^ b) даст нам 49, в двоичном формате 0011 0001
~	Бинарный комплиментарный оператор. Является унарным (то есть ему нужен только один операнд) меняет биты на обратные, там где была единица становиться ноль и наоборот.	(~a ) даст в результате -61, в двоичном формате выглядит 1100 0011.
<<	Побитовый сдвиг влево. Значение левого операнда «сдвигается» влево на количество бит указанных в правом операнде.	a << 2 в результате даст 240, в двоичном формате 1111 0000
>>	Побитовый сдвиг вправо. Значение левого операнда «сдвигается» вправо на количество бит указанных в правом операнде.	a >> 2 даст 15, в двоичном формате  0000 1111

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

Оператор	Описание	Примеры
and	Логический оператор «И». Условие будет истинным если оба операнда истина.	True and True равно True. True and False равно False. False and True равно False. False and False равно False.
or	Логический оператор «ИЛИ». Если хотя бы один из операндов истинный, то и все выражение будет истинным.	True or True равно True. True or False равно True. False or True равно True. False or False равно False.
not	Логический оператор «НЕ». Изменяет логическое значение операнда на противоположное.	not True равно False. not False равно True.

Операторы членства в Python:

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

Оператор	Описание	Примеры
in	Возвращает истину, если элемент присутствует в последовательности, иначе возвращает ложь.	«cad» in «cadillac» вернет True. 1 in [2,3,1,6] вернет True. «hi» in {«hi»:2,»bye»:1} вернет True.  2 in {«hi»:2,»bye»:1} вернет False (в словарях проверяется наличие в ключах, а не в значениях).
not in	Возвращает истину если элемента нет в последовательности.	Результаты противоположны результатам оператора in.

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

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

Оператор	Описание	Примеры
is	Возвращает истину, если оба операнда указывают на один объект.	x is y вернет истину, если id(x) будет равно id(y).
is not	Возврашает ложь если оба операнда указывают на один объект.	x is not y, вернет истину если id(x) не равно id(y).

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

В следующей таблице описан приоритет выполнения операторов в Python от наивысшего (выполняется в первую очередь) до наинизшего.

Оператор	Описание
**	Возведение в степень
~ + —	Комплиментарный оператор
* / % //	Умножение, деление, деление по модулю, целочисленное деление.
+ —	Сложение и вычитание.
>> <<	Побитовый сдвиг вправо и побитовый сдвиг влево.
&	Бинарный «И».
^ |	Бинарный  «Исключительное ИЛИ» и бинарный «ИЛИ»
<= < > >=	Операторы сравнения
<> == !=	Операторы равенства
= %= /= //= -= += *= **=	Операторы присваивания
is is not	Тождественные операторы
in not in	Операторы членства
not or and	Логические операторы

В этом руководстве речь пойдет об операторах языка программирования 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. Для понимания особенностей работы операторов нужно продолжать с ними работать, использовать в условных конструкциях и объединять.

• Главная

• Инструкции

• Python

• Какие операторы используются в Python: руководство

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

• арифметические,
• сравнения,
• присваивания,
• тождественности,
• принадлежности,
• логические,
• побитовые.

В этой статье-справочнике подробно рассмотрим каждый из них и приведем примеры.

Арифметические

Для сложения, вычитания, умножения и деления используются, соответственно, +, -, * и /.

>>> 24 + 28
52
>>> 24 - 28
-4
>>> 24 * 28
672
>>> 24 / 28
0.8571428571428571

Для возведения в степень — **.

>>> 5 ** 2
25
>>> 5 ** 3
125
>>> 5 ** 4
625

Для целочисленного деления без остатка — //.

>>> 61 // 12
5
>>> 52 // 22
2
>>> 75 // 3
25
>>> 77 // 3
25

% выдает остаток, то есть выполняет деление по модулю:

>>> 62 % 6
2
>>> 65 % 9
2
>>> 48 % 5
3
>>> 48 % 12
0

Сравнения

Таких операторов выражения в Python шесть: >, <, >=, <=, ==, !=. Обратите внимание, что «равно» в Питоне при сравнении записывается так: ==, потому что один знак «равно» означает присвоение значения (об этом в следующей главе). Для выражения «не равно» используется сочетание символов !=. При сравнении значений интерпретатор языка будет выдавать ответы True и False в зависимости от того, являются ли выражения истинными или ложными. Примеры:

>>> 26 > 58
False
>>> 26 < 58
True
>>> 26 >= 26
True
>>> 58 <= 57
False
>>> 50 == 50
True
>>> 50 != 50
False
>>> 50 != 51
True

Присваивания

Для присвоения значений переменным используется один знак «равно»:

>>> b = 5
>>> variants = 20

Также предусмотрены удобные конструкции для совмещения всех арифметических действий с одновременным присваиванием полученного значения: +=, -=, *=, /=, //=, %=. Например:

>>> cars = 5
>>> cars += 7
>>> cars
12

Мы задали переменную сars и присвоили ей значение 5, затем добавили еще 7 с одновременным присвоением нового значения. Конечно, можно вместо cars += 7 написать и так:

>>> cars = cars + 7
>>> cars
12

Ошибки нет, но первый вариант более компактный. Посмотрим, как работают другие действия одновременно с присваиванием:

>>> train = 11
>>> train -= 2
>>> train
9
>>> moto = 3
>>> moto *= 7
>>> moto
21
>>> plain = 8
>>> plain /= 4
>>> plain
2.0

Обратите внимание, что в последнем случае мы получили не целое значение, int, а с запятой, float.

Тождественности

Таких операторов в Python 2: is и is not. Как и в английском, первый означает (это) есть, а второй — это не. Ответами интерпретатора, как и в случае со сравнениями, будут True или False.

>>> 55 is 55
True
>>> 55 is 56
False
>>> 55 is not 55
False
>>> 55 is not 56
True
>>> 55 is '55'
False
>>> '55' is "55"
True

Разбираемся, что произошло в последних двух операциях. В первом случае (55 is '55') сравнивалось целое число и строка, поэтому интерпретатор выдал False, а во втором ('55' is "55") оба операнда представляли собой строки, поэтому было выдано True. Заметьте, что Питону не важно, использует ли программа одинарные или двойные кавычки: оба варианта синтаксически допустимы, поэтому результат тождества оказался истинным.

Принадлежности

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

>>> wordlist = ('assistant', 'streetcar', 'fraudster', 'dancer', 'heat', 'blank', 'compass', 'commerce', 'judgment', 'approach')
>>> 'house' in wordlist
False
>>> 'assistant' in wordlist
True
>>> 'assistant' and 'streetcar' in wordlist
True

В последнем случае мы задействовали логический оператор (and), к рассмотрению которых и переходим.

Логические

В Питоне есть три логических оператора: and (и), or (или), а также not (не). and работает следующим образом: True возвращается только в том случае, если все операнды истинны. При этом обрабатываться может сколько угодно значений. Используем пример из главы выше:

>>> wordlist = ('assistant', 'streetcar', 'fraudster', 'dancer', 'heat', 'blank', 'compass', 'commerce', 'judgment', 'approach')
>>> 'assistant' and 'streetcar' in wordlist
True
>>> 'fraudster' and 'dancer' and 'heat' and 'blank' in wordlist
True
>>> 'fraudster' and 'dancer' and 'heat' and 'blank' and 'house' in wordlist
False

Как видим, значения 'house' в строке не оказалось, поэтому интерпретатор выдал False. Те же операции можно производить и над целочисленными значениями:

>>> numbers = 54 > 55 and 22 > 21
>>> print(numbers)
False

Всё верно, потому что одно из выражений ложно, а and требует, чтобы истинными были все условия.

or действует по-другому: выражение признается истинным в том случае, если истинно хотя бы одно из его значений. Поэтому, если в предыдущем примере мы заменим операторы and на or, то получим следующий результат:

>>> numbers = 54 > 55 or 22 > 21
>>> print(numbers)
True

22 больше 21 и при этом для операции or не важно, что первое выражение ложно.

А вот как работает not:

>>> first = True
>>> second = False
>>> print(not first)
False
>>> print(not second)
True

Из примера видно, что not переворачивает логические значения, меняя True на False и наоборот.

Побитовые

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

• & (AND)
• | (OR)
• ^ (XOR)
• ~ (NOT)
• << и >> (сдвиговые)

Битовые операторы основаны на принципах Булевой логики, поэтому действуют следующим образом:

& (AND) возвращает 1, если 1 есть в обоих операндах, в остальных случаях 0:

>>> 1 & 1
1
>>> 1 & 0
0
>>> 0 & 1
0
>>> 0 & 0
0

| (OR) возвращает 1, если 1 есть в одном из операндов, иначе вернет 0:

>>> 1 | 1
1
>>> 1 | 0
1
>>> 0 | 1
1
>>> 0 | 0
0

^ (XOR) возвращает 1, если операнды различаются, и 0, если они одинаковы:

>>> 1 ^ 1
0
>>> 1 ^ 0
1
>>> 0 ^ 1
1
>>> 0 ^ 0
0

~ (NOT) переворачивает биты, преобразуя положительные значения в отрицательные со сдвигом на единицу следующим образом:

>>> ~5
-6
>>> ~-5
4
>>> ~7
-8
>>> ~-7
6
>>> ~9
-10
>>> ~-9
8

<< и >> сдвигают биты на определенное количество, которое указывается справа:

>>> 1 << 1
2
>>> 1 >> 1
0

Для понимания сдвигов давайте разложим значения на биты, добавив, где нужно, разряд для удобства:

0 = 00
1 = 01
2 = 10

Поэтому, сдвигая в единице разряд влево, мы получаем 2, а если вправо, то 0. А если на два разряда?

>>> 1 << 2
4
>>> 1 >> 2
0

1 = 001
2 = 010
4 = 100

Сдвинув единицу на два разряда влево, мы получили 4, потому что 4 в битовом представлении будет 100. Сдвиг вправо на любое число разрядов всё равно дает нам ноль, так как бит «обнуляется» в любом случае.

Больше информации о битовых операторах можно найти в нашей статье о них. 

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

Чем отличаются операторы от функций

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

There’s the != (not equal) operator that returns True when two values differ, though be careful with the types because "1" != 1. This will always return True and "1" == 1 will always return False, since the types differ. Python is dynamically, but strongly typed, and other statically typed languages would complain about comparing different types.

There’s also the else clause:

# This will always print either "hi" or "no hi" unless something unforeseen happens.
if hi == "hi":     # The variable hi is being compared to the string "hi", strings are immutable in Python, so you could use the 'is' operator.
    print "hi"     # If indeed it is the string "hi" then print "hi"
else:              # hi and "hi" are not the same
    print "no hi"

The is operator is the object identity operator used to check if two objects in fact are the same:

a = [1, 2]
b = [1, 2]
print a == b # This will print True since they have the same values
print a is b # This will print False since they are different objects.