Как правильно пишутся слова и словосочетания в русском языке. Большая база слов и выражений. Быстрый поиск.
Python как пишется не равно
Оператор неравенства != в Python
В Python для проверки верности неравенства используется != или is not . Когда значения любых двух переменных Python или операндов, предоставленных по обе стороны от оператора неравенства, не равны, он должен возвращать True , в противном случае — False .
Выполняя сравнение, следует иметь в виду тип переменных. Многие языки структурированных запросов «ругаются» по поводу сопоставления различных типов. А вот Python гибок, хотя и жестко типизирован. Если значения двух переменных совпадают, но принадлежат к разным типам, оператор неравенства должен возвращать True .
Ниже мы приведем несколько примеров, чтобы показать, как работают операторы неравенства Python.
Сравнение при помощи оператора != переменных одного и двух типов
Наш первый пример будет содержать различные способы сравнения двух или более значений переменных разных типов с помощью оператора неравенства.
Мы инициализируем две целочисленные переменные, x и y . После этого используем знак != для сравнения их значений. Результат в виде булева значения будет сохранен в новой переменной c . После этого мы выводим значение этой переменной.
При выполнении этого кода мы получим результат False , потому что значения переменных x и y были равны и имели одинаковый тип данных.
Теперь давайте обновим наш код. Мы объявим три разные переменные, причем только две из них будут иметь одинаковое значение.
После этого мы воспользуемся оператором неравенства != , чтобы получить результат сравнения переменных a и b . В этом случае мы используем оператор неравенства прямо в предложении print .
Затем мы сравним переменные a и c вне предложения print и запишем результат в переменную f . После этого используем значение этой переменной в print.
Наконец, мы объявим переменную строкового типа q и сравним ее с целочисленной переменной a в предложении print.
В выводе мы видим одно ложное и два истинных значения. Первые два результата мы получили, сравнивая переменные целочисленного типа. Однако последнее сравнение было между переменными целочисленного и строкового типов. И хотя обе переменные были равны 3, одна из них была строковой, а вторая – целочисленной. Поэтому мы получили True , значения не равны.
Использование оператора неравенства в if-блоках
Давайте посмотрим, как оператор неравенства используется в условии if .
У нас есть две переменные: переменная x – целочисленного типа, а y – строкового. Мы инициализируем предложение if и используем в нем оператор != , чтобы проверить наши переменные на неравенство. Если условие будет выполняться, то в выводе мы увидим фразу о том, что переменные не равны.
После выполнения кода в выводе мы получили желаемую строку.
Рассмотрим другой пример. На этот раз мы используем обе переменные строкового типа и сравним их в операторе if . Также мы используем print() , чтобы вывести значения обеих переменных.
При запуске кода мы не получаем никаких ошибок (т.е. наши переменные действительно не равны).
А теперь давайте рассмотрим пример посложнее.
Используем целочисленную переменную z , имеющую значение 21. Сначала мы вычислим остаток от деления z на 2. После этого, при помощи if , зададим условие с != , чтобы сравнить вычисленное значение с 0. Таким образом мы проверим, является ли значение z четным. Если полученное значение не равно 0 (т.е. остаток от деления на 2 равен единице), в выводе мы получим значение переменной z и сообщение о том, что оно не является четным.
В результате выполнения кода переменная z была выведена на экран вместе со строкой is not even !.
Использование оператора != в блоках if-else
В приведенных выше примерах мы использовали оператор if . На этот раз давайте воспользуемся оператором if-else .
Напишем следующий код. Прежде всего, инициализируем переменную целочисленного типа a , значение которой равно 10. После этого мы запускаем условие if-else .
Условие if использует оператор неравенства is not для сравнения переменной a со значением 20. Если условие удовлетворяется, мы получим результат «Values are not Equal». В противном случае программа перейдет к else и выведет «Values are Equal».
Запустим наш код. Вы можете видеть, что условие в операторе if выполнено и в выводе мы получаем сообщение о том, что значения не равны – «Values are not Equal».
Давайте взглянем на другой пример. Объявим строку str , имеющую значение Aqsa . Если наша str равна Aqsa , то нам выведется на экран Hy Aqsa . Если же условие оператора if не выполняется, программа переходит на следующую строчку кода – оператор elif . В таком случае мы получим сообщение Bye .
Поскольку условие в операторе if выполняется, на выходе мы получим результат первого print() , и к условию elif программа не перейдет .
Давайте изменим значение переменной str на Yasin . На этот раз условие в операторе if не соблюдается, и программа переходит к условию elif . Следовательно, на экран будет выведен результат второго print() .
Запустив код теперь, мы получим результат работы print() в блоке elif – Bye .
Более сложный пример использования != в Python
Наконец, протестируем оператор сравнения != на сложном примере.
Мы инициализировали класс с именем Test . Внутри этого класса мы инициализировали переменную i , имеющую значение 0. Другая переменная — data — была инициализирована со значением None .
После этого мы инициализировали конструктор нашего класса, чтобы получить значения этих переменных для каждого экземпляра класса.
Затем мы инициализировали встроенный метод, использующий оператор неравенства, и применили в нем конструкцию if-else .
Далее были созданы три объекта для отправки значений конструктору.
После этого мы сравнили объекты друг с другом и вывели на экран результат сравнения. Сохраним код и запустим его.
На выходе получим значение False как возврат первого оператора print() , поскольку значения, проанализированные для обоих объектов, были одинаковыми. Напротив, второй print() возвращает True, потому что t2 и t3 имеют разные значения и, следовательно, они не равны.
Вывод
Сегодня мы поговорили об операторе неравенства в Python. С помощью различных примеров и сценариев мы узнали, как работает оператор != и как его применять для проверки неидентичности двух переменных.
В этом руководстве речь пойдет об операторах языка программирования Python. Вы узнаете об арифметических, логических и битовых операторах, а также операторах сравнения, присваивания, принадлежности, тождественности и их синтаксисе. Все это будет проиллюстрировано примерами.
Оператор в Python — это символ, который выполняет операцию над одним или несколькими операндами. Операндом выступает переменная или значение, над которыми проводится операция.
Введение в операторы Python
Операторы Python бывают 7 типов:
Арифметические операторы
Операторы сравнения
Операторы присваивания
Логические операторы
Операторы принадлежности
Операторы тождественности
Битовые операторы
Арифметические операторы Python
Этот тип включает операторы для проведения базовых арифметических операций.
Сложение (+)
Складывает значение по обе стороны оператора. Пример:
Вычитание (-)
Вычитает значение правой стороны из значения в левой. Пример:
Умножение (*)
Перемножает значения с обеих сторон оператора. Пример:
Деление (/)
Делит значение левой стороны на значение правой. Тип данных результата деления — число с плавающей точкой. Пример:
Возведение в степень (**)
Возводит первое число в степень второго. Пример:
Деление без остатка (//)
Выполняет деление и возвращает целочисленное значение частного, убирая цифры после десятичной точки. Пример:
Деление по модулю (остаток от деления) (%)
Выполняет деление и возвращает значение остатка. Пример:
Операторы сравнения
Операторы сравнения в Python проводят сравнение операндов. Они сообщают, является ли один из них больше второго, меньше, равным или и то и то.
Меньше (
Этот оператор проверяет, является ли значение слева меньше, чем правое. Пример:
Больше (>)
Проверяет, является ли значение слева больше правого.
Меньше или равно (
Проверяет, является ли левая часть меньше или равной правой. Пример:
Больше или равно (>=)
Проверяет, является ли левая часть больше или равной правой. Пример:
Равно (==)
Этот оператор проверяет, равно ли значение слева правому. 1 равна булевому True , а 2 (двойка) — нет. 0 равен False . Пример:
Не равно (!=)
Проверяет, не равно ли значение слева правому. Оператор <> выполняет ту же задачу, но его убрали в Python 3.
Когда условие выполнено, возвращается True . В противном случае — False . Это возвращаемое значение можно использовать в последующих инструкциях и выражениях. Пример:
Операторы присваивания
Оператор присваивания присваивает значение переменной. Он может манипулировать значением до присваивания. Есть 8 операторов присваивания: 1 простой и 7 с использованием арифметических операторов.
Присваивание (=)
Присваивает значение справа левой части. Стоит обратить внимание, что == используется для сравнения, а = — для присваивания. Пример:
Сложение и присваивание (+=)
Суммирует значение обеих сторон и присваивает его выражению слева. a += 10 — это то же самое, что и a = a + 10 .
То же касается и все остальных операторов присваивания. Пример:
Вычитание и присваивание (-=)
Вычитает значение справа из левого и присваивает его выражению слева. Пример:
Деление и присваивание (/=)
Делит значение слева на правое. Затем присваивает его выражению слева. Пример:
Умножение и присваивание (*=)
Перемножает значения обеих сторон. Затем присваивает правое левому. Пример:
Деление по модулю и присваивание (%=)
Выполняет деление по модулю для обеих частей. Результат присваивает левой части. Пример:
Возведение в степень и присваивание (**=)
Выполняет возведение левой части в степень значения правой части. Затем присваивает значение левой части. Пример:
Деление с остатком и присваивание (//=)
Выполняет деление с остатком и присваивает результат левой части. Пример:
Это один из важных операторов Python
Логические операторы Python
Это союзы, которые позволяют объединять по несколько условий. В Python есть всего три оператора: and (и), or (или) и not (не).
И (and)
Если условия с двух сторон оператора and истинны, тогда все выражение целиком считается истинным. Пример:
Или (or)
Выражение ложно, если оба операнда с двух сторон ложные. Если хотя бы одно из них истинное, то и все выражение истинно. Пример:
Не (not)
Этот оператор инвертирует булевые значения выражения. True превращается в False и наоборот. В примере внизу булево значение 0 — False . Поэтому оно превращается в True . Пример:
Операторы принадлежности
Эти операторы проверяют, является ли значение частью последовательности. Последовательность может быть списком, строкой или кортежем. Есть всего два таких оператора: in и not in .
Проверяет, является ли значение членом последовательности. В этом примере видно, что строки fox нет в списке питомцев. Но cat — есть, поэтому она возвращает True . Также строка me является подстрокой disappointment . Поэтому она вернет True . Пример:
Нет в (not in)
Этот оператор проверяет, НЕ является ли значение членом последовательности. Пример:
Операторы тождественности
Эти операторы проверяют, являются ли операнды одинаковыми (занимают ли они одну и ту же позицию в памяти).
Это (is)
Если операнды тождественны, то вернется True . В противном случае — False . Здесь 2 не является 20 , поэтому вернется False . Но ‘2’ — это то же самое, что и «2» . Разные кавычки не меняют сами объекты, поэтому вернется True . Пример:
Это не (is not)
2 — это число, а ‘2’ — строка. Поэтому вернется True . Пример:
Битовые операторы Python
Эти операторы работают над операндами бит за битом.
Бинарное И (&)
Проводит побитовую операцию and над двумя значением. Здесь бинарная 2 — это 10 , а 3 — 11 . Результатом побитового and является 10 — бинарная 2 . Побитовое and над 011 (3) и 100 (4) выдает результат 000 (0). Пример:
Бинарное ИЛИ (|)
Проводит побитовую операцию or на двух значениях. Здесь or для 10 (2) и 11 (3) возвращает 11 (3). Пример:
Бинарное ИЛИ НЕТ (^)
Проводит побитовую операцию xor (исключающее или) на двух значениях. Здесь результатом ИЛИ НЕ для 10 (2) и 11 (3) будет 01 (1). Пример:
Инвертирующий оператор (
Он возвращает инвертированные двоичные числа. Другими словами, переворачивает биты. Битовая 2 — это 00000010 . Ее инвертированная версия — 11111101 . Это бинарная -3 . Поэтому результат -3 . Похожим образом
1 равняется -2 . Пример:
Еще раз, инвертированная -3 — это 2 .
Бинарный сдвиг влево (
Он сдвигает значение левого операнда на позицию, которая указана справа. Так, бинарная 2 — это 10 . 2 сдвинет значение на две позиции влево и выйдет 1000 — это бинарная 8 . Пример:
Бинарный сдвиг вправо (>>)
Сдвигает значение левого оператора на позицию, указанную справа. Так, бинарная 3 — это 11 . 3 >> 2 сдвинет значение на два положение вправо. Результат — 00 , то есть 0 . 3 >> 1 сдвинет на одну позицию вправо, а результатом будет 01 — бинарная 1 . Пример:
Выводы
В этом уроке были рассмотрены все 7 типов операторов Python. Для каждого был предложен пример в IDE. Для понимания особенностей работы операторов нужно продолжать с ними работать, использовать в условных конструкциях и объединять.
Как использовать операторы Not Equal и Equal в Python
В Python вы можете использовать операторы «не равно» и «равно», чтобы проверить, имеют ли два объекта Python одинаковое значение. Этот учебник научит вас использовать эти операторы с большим количеством примеров кода.
синтаксис оператора не равно (!=) и варианты использования,
синтаксис оператора равенства (==) с примерами и
использование операторов is и not для проверки идентичности любых двух объектов Python.
Синтаксис оператора не равно Python
Для любых двух объектов Python obj1 и obj2 общий синтаксис использования оператора не равно:
возвращает True, когда значения obj1 и obj2 не равны, и
возвращает False в противном случае.
Примечание. Как упоминалось выше, obj1 и obj2 могут быть целыми числами, числами с плавающей запятой, строками, списками и т.д.
Примеры кода оператора Python Not Equal
В этом разделе давайте напишем несколько примеров, чтобы лучше понять оператор не равно.
Использование оператора Python Not Equal для сравнения
Вы можете запускать примеры кода в интегрированной среде разработки Python для toadmin.ru — прямо из браузера. Или вы можете запустить на своей локальной машине.
Поскольку num1 = 27, а num2 также равно 27 (3*9 = 27), значения num1 и num2 равны. Таким образом, оператор != возвращает False.
В приведенном ниже коде для num1 установлено значение 7. А для num2 установлено значение 7. Поскольку они относятся к разным типам данных, оператор не равно возвращает True.
Вы приводите строку к целому числу, как показано ниже:
В этом случае вы можете видеть, что возвращаемый результат равен False, так как num1 и num2 теперь равны целому числу 7.
Вы также можете использовать оператор не равно с коллекциями Python, такими как списки, кортежи и наборы.
Примечание. Для наборов данных, таких как списки, оператор не равно работает путем проверки значений отдельных элементов. Например, два списка list1 и list2 — каждый длиной n — равны, только если list1[i] == список2[i] для i в <0,1,2,3. n-1>.
В приведенном выше примере список1 и список2 отличаются только одним элементом. И оператор not equal != возвращает True, как и ожидалось.
Использование оператора Python Not Equal в условных выражениях
Вы часто будете использовать оператор «не равно» как часть условных выражений Python.
Например, фрагмент кода ниже показывает, как вы можете проверить, является ли число нечетным.
Число, которое не делится без остатка на 2, является нечетным. А это сводится к условию num%2 != 0.
Вы также можете использовать условные операторы в понимание списка когда вы хотите сохранить только те элементы списка, которые соответствуют определенному условию. В приведенном ниже примере нечетные_10 — это список всех нечетных чисел меньше 10.
На этом мы завершаем обсуждение оператора «не равно» (!=).✅
Как вы уже могли догадаться, оператор «равно» производит эффект, противоположный оператору «не равно».
Вы узнаете больше об этом в следующем разделе.
Синтаксис оператора равенства Python
Вот синтаксис для использования оператора равенства Python:
возвращает True, когда значения obj1 и obj2 равны, и
возвращает False в противном случае.
Примеры кода оператора равенства Python
Оператор равенства (==) можно использовать очень похоже на оператор не равно.
Давайте закодируем следующие примеры:
чтобы проверить, равны ли две строки,
чтобы проверить, является ли число четным, и
использовать условные операторы в понимании списка
Использование оператора Python Not Equal для сравнения
В приведенном ниже фрагменте кода str1 и str2 равны по значению. Таким образом, оператор равенства (==) возвращает True.
Оператор равенства Python
Давайте теперь используем оператор равенства в условном выражении.
Примечание: число, которое без остатка делится на 2, является четным. А в коде это сводится к условию num%2 == 0
Давайте теперь возьмем этот пример и воспользуемся распознаванием списков Python, чтобы получить все четные числа меньше 10.
В приведенном выше примере
range(10) возвращает объект диапазона, который можно пройти в цикле, чтобы получить все целые числа от 0 до 9.
Условие num%2 == 0 истинно только для четных чисел.
Итак, even_10 — это список всех четных чисел меньше 10.
Итак, вы узнали, как проверять равенство с помощью операторов не равно (!=) и равно (==).
В следующем разделе вы узнаете, как проверить подлинность двух объектов. Вы проверите, идентичны ли два объекта Python.
Как использовать операторы Python is и not is
Если вы новичок в программировании на Python, возможно, вы запутались между операторами == и is. Поясним это в этом разделе.
В предыдущем разделе у нас был пример, где str1 и str2 равны, а оператор == возвращает True.
Теперь запустите следующий фрагмент кода.
Вы можете видеть, что str1 является str2 возвращает False.
Давайте сделаем шаг назад и поймем, что делает оператор is в Python.
Оператор is работает с любыми двумя объектами Python. И возвращает True только в том случае, если два объекта идентичны, то есть они ссылаются на один и тот же объект в памяти.
Несмотря на то, что str1 равен str2, str1 не является str2, поскольку они указывают на два разных объекта в памяти. И поэтому у них разные личности.
В Python вы можете использовать я бы() функция для получения идентификатора объекта.
▶ Запустите следующую ячейку кода, чтобы получить идентификаторы str1 и str2.
Как видите, str1 и str2 имеют разные идентификаторы. И str1 is str2 возвращает False, как и ожидалось.
Давайте быстро проверим это, как показано:
Интуитивно оператор is not делает противоположное оператору is.
Оператор is not работает с любыми двумя объектами Python. И возвращает False только в том случае, если два объекта идентичны, то есть они ссылаются на один и тот же объект в памяти. В противном случае он возвращает True.
В приведенных выше примерах кода попробуйте заменить is на is not и проверьте результат.
Вывод 👩💻
Надеюсь, вы нашли этот урок полезным.
как использовать операторы «равно» (==) и «не равно» (!=), чтобы проверить, имеют ли два объекта Python одинаковое значение,
разница между равенством и идентичностью объектов Python и
как операторы Python есть и не помогают в проверке идентичности двух объектов Python.
Узнайте, как рассчитать разницу во времени или сделать игру в змейку на питоне, здесь.
Увидимся в следующем уроке. А пока удачного обучения и кодирования!🎉
Python – весьма перспективный язык программирования, который набирает популярность. Он позволяет создавать функциональный контент совершенно разного направления: от бизнес-софта до развлекательных утилит. Достаточно прост в изучении и освоении с нуля.
Погружаясь в основы Python, нельзя забывать о таком важном моменте, как операторы. Именно о них зайдет речь далее. Вниманию будут представлены логические операторы Python, а также иные их варианты. Эта информация пригодится не только новичкам в сфере разработке, но и опытным программистам.
Немного терминологии
Python является язык общего назначения. Он включает в себя принципы объектно-ориентированного программирования. Поэтому перед тем, как изучать операторы и их нюансы, стоит запомнить несколько ключевых терминов. Без них создать качественное приложение не представляется возможным:
Алгоритм – своеобразный набор правил и инструкций. Он необходим для обработки функций и выполнения тех или иных задач.
API – интерфейс прикладного программирования. Включает в себя структурные данные, протоколы и правила, позволяющие быстро разрабатывать ПО, а также налаживать его взаимодействие с разного рода службами.
Переменные – именованные ячейки памяти. Они резервируются системой с учетом типа используемых данных в исходном коде.
Константа – постоянное значение. Оно не подлежит никаким корректировкам на протяжении всего жизненного цикла софта.
Аргумент – значение, которое передается в команду или функцию.
Объекты – наборы связанных между собой переменных, констант и иных структурных данных, выбираемых и обрабатываемых совместно.
Классы – перечни связанных объектов. Наделяются общими свойствами.
Итерация – один проход через команду или функцию в коде.
Отдельно стоит выделить такие понятия как «оператор» и «операнд». Первый термин указывает на объект, умеющий управлять операндами. Для этого задействуются специальные символы и записи (функции). Операнд – объект, которым можно манипулировать через так называемые операторы.
Основные операторы
Оператор в Питоне – символ, который будет отвечать за выполнение операции над одним или сразу несколькими операндами. Последним компонентом будет выступать переменная или значение, с которой требуется проводить дальнейшую работу.
Всего в рассматриваемом ЯП несколько типов операторов:
арифметические;
сравнения;
присваивания;
логические;
принадлежности;
битовые;
тождественные.
Все перечисленные операторы отвечают за различные операции, проводимые при обработке программного кода. Без них представить даже элементарную программу не получится. Поэтому далее каждый тип рассмотрен более подробно.
Арифметические
Арифметические операторы в Python – самые простые. Данная категория «команд» встречается даже новичкам. С ними знакомятся еще в школьной программе. Они отвечают за элементарные математические действия.
Сложение (+). Производит сложение значений по обе стороны «команды».
Вычитание (-). Осуществляет вычитание правой стороны из значения левой в заданном выражении.
Умножение (*). Перемножает написанное с обеих сторон выражения.
Деление (/). Делит левый операнд на правый. Тип информации результата – это число с плавающей точкой.
Возведение в степень (**). Отвечает за возведение первого написанного числа в степень второго у заданной функции.
Деление без остатка (//). Производит деление согласно установленным математическим правилам. После этого возвращает значение, оставляя только целочисленную часть от полученного частного. Все, что идет после десятичной точки, система отбросит.
Остаток от деления (%). Эта операция также называется делением по модулю. При ее использовании происходит «раздел» и возврат значения остатка.
Все это должен знать даже школьник. А у разработчика подобная категория манипуляций вообще не вызывает никаких трудностей.
Сравнение
Операторы сравнения отвечают за проверку заданного в приложении равенства. Они указывают, каким является один из операндов:
Меньше ( ). True на выходе будет получено, когда «условия» слева больше правого.
Меньше или равно ( =). True устанавливается, если левая часть записи окажется больше или аналогичной правой.
Равно (==). В данном случае происходит проверка на непосредственное равенство. Если параметр слева такой же, как справа, на выходе получится true. В противном случае – False.
Не равно (!=). Оператор, который убран в Питоне 3. Он проверяет, не равен ли параметр слева правому. При успешном выполнении условия приложение выдаст True.
Здесь в основном придется учитывать результат в виде True и False. Перечисленные манипуляции тоже достаточно активно используются в разработке софта.
Присваивание
Операторы присваивания будут отвечать за передачу переменной того или иного значения. Тут нет true или false. Данная категория включает в себя:
Обычное присваивание (=). Параметр справа передается левой части.
Сложение и присваивание (+=). Суммирует параметры с обеих сторон и передает результат левой части.
Вычитание и присваивание (-=). Из правого вычитается «левое». Далее последнему передается соответствующий результат.
Деление и присваивание (/=).
Умножение и присваивание (*=).
Деление по модулю и присваивание (%=).
Возведение в степень и присваивание (**=).
Деление с остатком и присваивание (//=).
Последний является одним из самых важных в Питоне.
Логические операторы
Логические операторы выполняют роль своеобразных союзов. Они будут выдавать на выходе True или False. Дают возможность объединения нескольких условий в единое целое:
И (and). Если написанное с двух сторон оператора – это true, то и все выражение окажется true.
Или (or). Результат «ложь» выводится тогда, когда два операнда false. В противном случае – true.
Не (not). Работает с булевыми значениями. True становится False. Обратное соотношение тоже действует.
Других логических операторов в рассматриваемом языке программирования нет.
Принадлежность
Зато есть операторы принадлежности. Они проверяют, является ли значение частью заданной последовательности: списка, кортежа, строки:
В (in). Осуществляет проверку на принадлежность к последовательности. Возвращает True при соответствии указанному условию.
Нет в (not in). Проводит проверку на НЕ принадлежность к последовательности.
Других операторов в данной категории нет.
Тождественность
Операторы тождественности проверяют, являются ли операнды одинаковыми. На практике встречаются не слишком часто:
Это (is). Если тождественность есть, осуществляется возврат True.
Это нет (is not).
Остается изучить последнюю крупную категорию операторов в Питоне.
Битовые операторы
Осуществляют работу над операндами побитово. Здесь можно увидеть:
Бинарное И (&). Отвечает за побитовую операцию and.
Или (|). Побитово проводит or.
Или нет (^). Это – исключающее или (XOR).
Инвертирующий оператор (
). Возвращает инвертированные двоичные числа. Будет переворачивать биты.
Сдвиг влево ( >).
Теперь понятно, какие есть операнды и операции над ними в Питоне. А лучше изучить их на практике помогут компьютерные онлайн курсы.
В этом уроке вы узнаете все о разных типах операторов в Python, их синтаксисе и примерах использования.
Что такое операторы
Операторы — специальные символы, которые выполняют арифметические и логические вычисления. Значения, на которые действует оператор, называются операндами.
Здесь оператор + выполняет сложение, 2 и 3 — операнды, а 5 — вывод операции.
Арифметические операторы
Арифметические операторы используются для выполнения математических операций — сложения, вычитания, умножения и т. д.
Сложение двух операндов или унарный плюс
Вычитание правого оператора из левого или унарный минус
Деление левого операнда на правый (результат всегда типа float)
Остаток от деления левого операнда на правый
Деление с округлением — деление, результат которого корректируется в меньшую сторону
Показатель степени — левый операнд возводится в значение правого операнда
Операторы сравнения
Операторы сравнения используются для сравнения значений, они возвращают True или False в зависимости от условия.
Больше чем: True, если левый операнд больше правого
Больше или равно: True, если левый операнд больше или равен правому
True, если значения обоих операндов True
True, если значение одного из операндов True
True, если значение операнда False (дополняет значение операнда)
Побитовые операторы
Побитовые операторы работают с операндами как со строками из 0 и 1. Они действуют бит за битом, как и говорит название.
Например, 2 в двоичной системе счисления — 10 , а 7 — 111 .
В таблице ниже: x = 10 ( 00001010 в двоичной системе счисления) и y = 4 ( 00000100 в двоичной системе счисления)
Операторы присваивания
Операторы присваивания используются для назначения переменной некоторого значения.
a = 5 — простой оператор присваивания, который приравнивает значение 5 справа переменной а слева.
В Python множество составных операторов, подобных a += 5 — он прибавляет 5 к переменной a и позже присваивает ей получившееся значение. Этот оператор равносилен записи a = a + 5 .
Эквивалентно
x is и is not — операторы тождественности в Python. Они проверяют, находятся ли два значения (или две переменные) по одному адресу в памяти. То, что две переменные равны еще не значит, что они идентичны.
True, если операнды идентичны (указывают на один объект)
True, если операнды не идентичны (не указывают на один объект)
Мы видим, что x1 и y1 — целочисленные переменные с одинаковыми значениями, поэтому они равны и идентичны. То же с x2 и y2 (строки).
Но x3 и y3 — списки. Они равны, но не идентичны, поскольку интерпретатор кладет их в разные места в памяти, хоть эти списки и равны.
Операторы принадлежности
in и not in — операторы принадлежности в Python. Они проверяют, есть ли значение или переменная в последовательности (строке, списке, кортеже, множестве или словаре). Иначе говоря, проверяют вхождение элемента в коллекцию. В словаре можно проверить только присутствие ключа, не значения.
True, если значение или переменная есть в последовательности
True, если значения или переменной нет в последовательности
‘П’ есть в x , а вот строки ‘привет’ в x нет (помните: Python чувствителен к регистру). Таким же образом образом 1 — ключ, а ‘a’ — значение в словаре y , поэтому вывод ‘б’ in y — False .
В этой статье мы поговорим про различные операторы в Python. Мы на примерах разберем арифметические, битовые и логические операторы, а также операторы присваивания и сравнения. Кроме того, мы рассмотрим операторы принадлежности и идентичности, такие как is , is not и in , not in .
Арифметические операторы
Python реализует семь основных бинарных арифметических операторов, два из которых могут использоваться как унарные операторы. Они приведены в следующей таблице:
Оператор
Название
Описание
a + b
Сложение
Сумма a и b
a — b
Вычитание
Разность a и b
a * b
Умножение
Произведение a и b
a / b
Деление
Частное a и b
a // b
Целочисленное деление
Деление a на b без остатка (дробная часть отбрасывается)
a % b
Взятие модуля
Целый остаток от деления a на b
a ** b
Возведение в степень
a , возведенное в степень b
-a
Отрицание
Отрицательное значение a
+a
Унарный плюс
а без изменений (используется редко)
Эти операторы можно использовать и комбинировать интуитивно понятным образом, используя стандартные круглые скобки для группировки операций. К примеру, это может выглядеть так:
Целочисленное деление — это обычное деление, только с усечённой дробной частью:
Оператор целочисленного деления был добавлен в Python 3. Если вы работаете в Python 2, вы должны знать, что стандартный оператор деления ( / ) действует как оператор целочисленного деления для целых чисел и как обычный оператор деления для чисел с плавающей запятой.
Наконец, упомянем ещё один арифметический оператор, который был добавлен в Python 3.5. Это оператор a @ b , предназначенный для указания матричного произведения a и b для использования в различных пакетах линейной алгебры.
Битовые операторы
В дополнение к стандартным числовым операциям в Python есть операторы для выполнения побитовых логических операций над целыми числами. Они используются гораздо реже стандартных арифметических операций, но знать их полезно. Шесть побитовых операторов сведены в следующую таблицу:
Оператор
Название
Описание
a & b
Логическое И
Биты, определенные как в a , так и в b
a | b
Логическое ИЛИ
Биты, определенные в a или b или в обоих
a ^ b
Исключающее ИЛИ
Равен 1, если только a или только b равно 1
a a влево на b единиц
a >> b
Побитовый сдвиг вправо
Сдвинуть биты a вправо на b единиц
a
Логическое НЕ
Отрицание a
Эти побитовые операторы имеют смысл только с точки зрения двоичного представления чисел. Это можно увидеть, используя встроенную функцию bin :
Результат имеет префикс 0b , что указывает на двоичное представление. Остальные цифры означают, что число 10 выражается как сумма 1⋅2 3 +0⋅2 2 +1⋅2 1 +0⋅2 0 . Точно так же мы можем написать:
Теперь, используя логическое ИЛИ, мы можем найти число, которое объединяет биты 4 и 10:
Эти побитовые операторы не так полезны, как стандартные арифметические операторы, но стоит увидеть их хотя бы раз, чтобы понять, какой класс операций они выполняют. В частности, у пользователей других языков иногда возникает соблазн использовать исключающее ИЛИ (т. е. a ^ b ), на самом деле имея в виду возведение в степень (т. е. a ** b ).
Операторы присваивания
Мы видели, что переменным можно присваивать значение с помощью оператора = . Например, следующим образом:
Мы можем использовать эти переменные в выражениях с любым из упомянутых ранее операторов. Например, чтобы добавить 2 к a , мы пишем:
Мы можем захотеть обновить переменную a новым значением. В этом случае мы могли бы объединить сложение и присваивание и написать a = a + 2 . Поскольку этот тип комбинированной операции и присваивания очень распространен, Python включает встроенные операторы обновления для всех арифметических операций:
Расширенный оператор присваивания есть для каждого из бинарных операторов, перечисленных ранее. Они выглядят следующим образом:
Каждый из этих операторов эквивалентен применению соответствующего оператора с последующим присваиванием. То есть для любого оператора ■ выражение a ■= b эквивалентно a = a ■ b с небольшой оговоркой.
Для изменяемых объектов, таких как списки, массивы или датафреймы, эти расширенные операции присваивания на самом деле немного отличаются от своих более подробных аналогов. Они изменяют содержимое исходного объекта, а не создают новый объект для хранения результата. Но это тонкости, в целом же укороченная версия работает так же, как и полная, но экономит кучу вашего времени.
Операторы сравнения
Другой тип операций, который может быть очень полезным, — это сравнение различных переменных. Для этого в Python реализованы стандартные операторы сравнения, которые возвращают логические значения True или False . Операции сравнения представлены в следующей таблице:
Оператор
Описание
a == b
a равняется b
a a строго меньше чем b
a a меньше либо равно b
a != b
a не равняется b
a > b
a строго больше чем b
a >= b
a больше либо равно b
Эти операторы сравнения можно комбинировать с арифметическими и побитовыми операторами, чтобы осуществлять самые разнообразные операции над числами. Например, мы можем проверить, является ли число нечетным, проверив, что остаток от деления на 2 возвращает 1:
Мы можем объединить несколько сравнений, чтобы проверить более сложные отношения:
И, чтобы у вас немного закружилась голова, взгляните на это сравнение:
— это оператор инвертирования битов, и, очевидно, когда вы инвертируете все биты нуля, вы получите -1. Если вам интересно, почему это так, посмотрите схему кодирования целых чисел с дополнением до двух, которую Python использует для кодирования целых чисел со знаком, и подумайте, что происходит, когда вы начинаете переворачивать все биты целых чисел, закодированных таким образом.
От редакции Pythonist: об операторе != можно почитать в статье «Оператор неравенства != в Python».
Логические операторы
При работе с логическими значениями Python предоставляет операторы для объединения значений с использованием стандартных понятий «и», «или» и «не». Эти операторы ожидаемо представлены словами and , or и not :
Поклонники булевой алгебры могут заметить, что оператор исключающего ИЛИ не включен. Он, конечно, может быть построен несколькими способами путем составления других операторов. Или же вы можете использовать хитрый трюк:
Иногда в языке возникает путаница: когда использовать логические операторы ( and , or , not ), а когда побитовые ( & , | ,
). Ответ кроется в их названиях: логические операторы следует использовать, когда вы хотите вычислить логические значения (т.е. истинность или ложность) утверждений. Побитовые операции следует использовать, когда вы хотите работать с отдельными битами или компонентами рассматриваемых объектов.
Операторы принадлежности и идентичности
Помимо and , or и not , Python также имеет операторы для проверки принадлежности и идентичности. Они следующие:
Оператор
Описание
a is b
Возвращает True, если a и b — идентичные объекты
a is not b
Возвращает True, если a и b — не идентичные объекты
a in b
Возвращает True, если a содержится в b
a not in b
Возвращает True, если a не содержится в b
Операторы is и is not проверяют идентичность объекта. Идентичность объекта отличается от равенства, как мы видим здесь:
Как выглядят одинаковые объекты? Вот пример:
Разница между этими двумя случаями в том, что в первом a и b указывают на разные объекты, а во втором они указывают на один и тот же объект. Оператор is проверяет, указывают ли две переменные на один и тот же контейнер (объект), а не на то, что содержит контейнер.
Новички часто испытывают искушение использовать is , хотя на самом деле имеют в виду == . Подробнее о разнице между == и is можно почитать в статье «Чем == отличается от is?«.
Операторы принадлежности проверяют принадлежность к составным объектам. Так, например, мы можем написать:
Эти операции членства являются примером простоты Python по сравнению с языками более низкого уровня, такими как C. В языке C членство обычно определяется путем ручного построения цикла по списку и проверки равенства каждого значения. В Python вы просто печатаете то, что хотите узнать, в манере, напоминающей простой текст.
Заключение
Итак, сегодня мы разобрали на примерах различные операторы в Python. Надеемся вам было полезно! Успехов в написании кода!
Б ольшинство строк программного кода представляют собой выражения. Например: 1 + 2 — это выражение. Выражение состоит из 2 частей:
Оператор (+) — функционал, представленный в виде символов (например + ==) или зарезервированных слов (например and not).
Операнды (1 и 2) — это данные, над которыми производится действия.
После того как Python-интерпретатор вычислит выражение, мы можем, как в примере выше, присвоить результат переменной sum . Или, например, сразу вывести результат на экран:
Операторы сравнения
Рассмотрим простой пример — 1 + 2 == 3 .
Для проверки истинности данного условия, используется логический тип. Когда мы выполним данное выражение, в результате нам вернется True (истина) или False (ложь).
В данном примере мы используем один из операторов сравнения — «==» (равно). Всего в Python таких операторов 6:
Операторы присваивания в Python работаю вполне очевидно — значение находящееся справа присваивается переменной, находящейся слева. Существует несколько разновидностей операторов присваивания:
= — значение правого операнда присвоится левому операнду;
+= — сумма левого и правого операнда присвоится левому операнду;
-= — разность левого и правого операнда присвоится левому операнду;
*= — произведение левого и правого операнда присвоится левому операнду;
/= — разделит левый операнд на правый и результат присвоится левому операнду;
//= — результат целочисленного деления левого операнда на правый операнд присвоится левому операнду;
%= — разделит левый операнд на правый по модулю и результат присвоится левому операнду;
**= — возведет левый операнд в степень правого и результат присвоится левому операнду.
>>> a = 10 >>> print(a) 10 >>> a = 10 >>> a += 1 # аналогично a = a + 1 >>> print(a) 11 >>> a = 10 >>> a -= 2 # аналогично a = a — 2 >>> print(a) 8 >>> a = 10 >>> a *= 2 # аналогично a = a * 2 >>> print(a) 20 >>> a = 10 >>> a /= 2 # аналогично a = a / 2 >>> print(a) 5.0 >>> a = 10 >>> a //= 3 # аналогично a = a // 2 >>> print(a) 3 >>> a = 10 >>> a %= 3 # аналогично a = a % 2 >>> print(a) 1 >>> a = 10 >>> a **= 2 # аналогично a = a ** 2 >>> print(a) 100
Python поддерживает не только обычное присваивание правого операнда левому, но и множественное присваивание.
С помощью такого присваивания можно поменять значения переменных между собой:
>>> a = 1 >>> b = 2 >>> a, b = b, a >>> print(a, b) 2 1
Также с помощью множественного присваивания можно «распаковывать» строки (str), списки (list), кортежи (tuple) и словари (dict).
Распаковка особенно удобна, когда функция возвращает несколько значений в виде кортежа (tuple):
>>> def test_page(): return 404, «Not found» >>> code, message = test_page() >>> print(code, message) 404 Not found
Главное условие распаковки – количество элементов должно совпадать
Если необходимо распаковать лишь несколько элементов, воспользуйтесь переменной со знаком » * «:
>>> text = «deactivate» >>> first, second, *other_letters = text >>> print(first, second, other_letters) d e [‘a’, ‘c’, ‘t’, ‘i’, ‘v’, ‘a’, ‘t’, ‘e’]
Побитовые операторы
Данные операторы предназначены для работы с данными в битовом (двоичном) формате. Про битовые операции смотрите статью на википедии .
— побитовое отрицание (для него требуется только один операнд);
& — побитовое » И «;
| — побитовое » ИЛИ «;
^ — исключающее » ИЛИ «;
— побитовый сдвиг влево;
>> — побитовый сдвиг вправо.
Операторы членства
В Python существует всего 2 оператора принадлежности — in и not in и предназначены они для проверки наличия элемента в строке (str), списке (list), словаре (dict) или кортеже (tuple).
in — возвращает True если элемент присутствует в последовательности;
not in — возвращает True если элемент отсутствует в последовательности.
>>> «host» in «host=local» True >>> 2 in [1,2,4,5] True >>> «one» in <"one": 1, "two": 1># в словаре проверка по ключам True >>> True in («string», 2, True) True >>> «str» not in («string», 2, True) True
Операторы тождественности
Данные операторы сравнивают размещение двух объектов в памяти.
is — возвращает True если оба операнда указывают на один и тот же объект;
is not — возвращает True если оба операнда указывают на разные объекты.
>>> x = 5 >>> type(x) is int True >>> x = 5.1 >>> type(x) is int False >>> x = [1, 2, 3] # id(x) = 64620552 >>> y = [1, 2, 3] # id(y) = 60529960 >>> x is y False
Приоритет операторов
Таблица приоритетов операторов в Python показана ниже.
Элементы отсортированы по убыванию, с высокого приоритета к более низкому. В комбинациях с несколькими операторами, оператор с большим приоритетом выполняется первым.
Например, в выражении 1 + 2 ** 2 * 10 сначала выполнится возведение в степень, далее умножение, потом сложение. Итого результат: 41 .
Когда мы хотим проверить, зарегистрирован ли пользователь на сайте, мы запрашиваем у него логин и пароль. Если логин существует в базе данных и введённый пароль совпадает с паролем в базе, то мы авторизуем пользователя. Иначе продолжаем запрашивать у пользователя логин и пароль.В примерах ниже мы сравним значения одного типа друг с другом на языке программирования Python.
Вот как реализовано сравнение двух строк в Python :
Пример с проверкой пароля:
Логическое сравнение или его результат используется в конструкциях if-else и циклах while .
Логические выражения
Логическое выражение в самом простом смысле — это математическое сравнение. В Python вопрос » Что больше: 3 или 5? » будет записан в следующем виде: 3 > 5 и звучать как: “Три больше пяти. Правда? — Нет.”
Или такой вариант: 4 != 0 ( 4 не равно 0. Правда?)
Как записываются операторы сравнения в Python:
a == b — А равно Б
a > b — А больше Б
a >= b — А больше или равно Б
a — А меньше Б
a — А меньше или равно Б
a != b — А не равно Б
Результат такого сравнения можно сохранить в переменную, как и любое другое значение:
Можно сравнивать сразу несколько значений подряд:
В итоге в первом значении мы получили True, а во втором Python выдал False.
Сравнение строк
Помимо чисел, в Python можно сравнивать друг с другом строки , списки и другие типы данных.
Вот, например, как выглядит сравнение двух строк в Python:
Во втором случае результатом оказалась ложь, т.к. сравнение чувствительно к регистру символов.
Также строки можно проверять между собой на большинство/меньшинство.
В первом случае всё просто — строки равны.
Во втором: происходит посимвольное сравнение строк. Первые два символа равны, сравниваются следующие. ‘b’ > ‘a’ истинно, т.к. символ ‘b’ стоит в алфавите по порядку после ‘a’ . Поэтому всё выражение истинно. Чтобы проще было понять, можно вместо букв поставить их порядковые номера в алфавите: 123 > 111
Посимвольное сравнение не зависит от длины строк, поэтому в третьем случае выражение ложно: ‘a’ > ‘x’
Такое сравнение называется лексикографическим: wikipedia.
Сравнение других типов значений
Сравнение списков аналогично сравнению строк. Например, когда условие в Python не равно. Каждый элемент списка по очереди сравнивается с другим.
Значения разных типов можно также сравнивать между собой:
Результат ложный, т.к. типы данных не равны. (Строка и число).
Проверка на большинство/меньшинство разных типов выдаст ошибку:
Преобразование значений в тип bool
Значения False или True можно получить непосредственно из самих значений, без операции сравнения. Например, строка ‘a’ будет True , а 0 — False . Для этого нужно вызвать функцию bool() и передать ей параметр, который мы хотим преобразовать:
А вот пустая строка или список будут равны False :
Логика простая — если размер списка или строки равен нулю, то переменная bool в Python будет равна False .
Все остальные значения, отличные от 0 или с длиной больше 0 будут True.
Как правило, булевые операции в Python нужны, когда проверяется наличие какой-либо информации в переменной, например, заполнил ли пользователь необходимые поля в форме регистрации или оставил их пустыми.
Упрощённая версия такой проверки:
Логические операторы
Если мы хотим проверить на истинность сразу несколько логических выражений или значений, то нам нужно использовать в Python 3 логические операторы .
Например ввел ли пользователь своё имя и больше ли 12 лет его возраст:
Мы использовали логический оператор and . Он возвращает истинное значение, только тогда, когда по обе стороны от него находятся истинные значения.
or — Возвращает истинное значение, когда хотя бы с одной стороны от него находится истинное значение.
not — Меняет значение на противоположное.
Все они работают с булевыми эквивалентами значений. Т.е. сначала преобразуют их в тип bool , а затем производят вычисления.
Логические операции можно комбинировать между собой в одном выражении:
Вычисления происходят по порядку. Чтобы изменить его, надо использовать скобки, как в математике.
Значение поменялось на истинное, т.к. сначала считается выражение внутри скобок ( False ), а затем происходит его инверсия. В Python есть одна особенность при использовании операторов and и or . Они не обязательно возвращают только True b False . Они возвращают непосредственно само значение, на котором остановились вычисления.
В первом случае вернулся 0 , потому что расчёты остановились на переменной age . Так как все операторы являются and , то если одно из значений ложно, то и всё выражение будет ложно, следовательно, дальше считать нет смысла.
Во втором случае обратная ситуация. Все операторы являются or , поэтому вычисления останавливаются на первом истинном значении. Собственно, оно нам и вернулось — значение переменной name1.
Другие виды логических операторов
Существуют также другие логические операции, которые используются реже и в специфических ситуациях.
Например, есть логические побитовые операции , которые применяются в шифровании данных.
Одна из таких — XOR : исключающее ИЛИ. В Python этой операции соответствует символ ^ .
Пример шифрования числа. Вместо чисел могут быть любые бинарные данные.
Список всех побитовых операторов в Python:
Операция
Значение
a & b
Побитовое И для a и b
a | b
Побитовое ИЛИ для a и b
a ^ b
Исключающее ИЛИ для a и b
a
Инверсия битов для a
a
Побитовый сдвиг влево для a на b
a >> b
Побитовый сдвиг вправо для a на b
Однако не все логические операции присутствуют в питоне. Например, в питоне нет логической операции импликация .
Заключение
Мы рассмотрели логические выражения и операторы в Python 3. Больше о работе с python читайте в блоге cloud.timeweb.com .
Кстати, в официальном канале Timeweb Cloud собрали комьюнити из специалистов, которые говорят про IT-тренды, делятся полезными инструкциями и даже приглашают к себе работать.
Какие операторы используются в Python: руководство
Операторы языка Python — это те инструменты, которые используются для выполнения различных действий с переменными, а также числовыми и другими значениями, которые называются операндами, то есть объектами, над которыми выполняются операции. Операторы делятся на несколько типов, в зависимости от того, какие действия выполняют. Вот какие операторы используются в Python :
арифметические,
сравнения,
присваивания,
тождественности,
принадлежности,
логические,
побитовые.
В этой статье-справочнике подробно рассмотрим каждый из них и приведем примеры.
Арифметические
Для сложения, вычитания, умножения и деления используются, соответственно, + , — , * и / .
Для возведения в степень — ** .
Для целочисленного деления без остатка — // .
% выдает остаток, то есть выполняет деление по модулю:
Сравнения
Таких операторов выражения в Python шесть: > , , >= , , == , != . Обратите внимание, что «равно» в Питоне при сравнении записывается так: == , потому что один знак «равно» означает присвоение значения (об этом в следующей главе). Для выражения «не равно» используется сочетание символов != . При сравнении значений интерпретатор языка будет выдавать ответы True и False в зависимости от того, являются ли выражения истинными или ложными. Примеры:
Присваивания
Для присвоения значений переменным используется один знак «равно»:
Также предусмотрены удобные конструкции для совмещения всех арифметических действий с одновременным присваиванием полученного значения: += , -= , *= , /= , //= , %= . Например:
Мы задали переменную сars и присвоили ей значение 5 , затем добавили еще 7 с одновременным присвоением нового значения. Конечно, можно вместо cars += 7 написать и так:
Ошибки нет, но первый вариант более компактный. Посмотрим, как работают другие действия одновременно с присваиванием:
Обратите внимание, что в последнем случае мы получили не целое значение, int , а с запятой, float .
Тождественности
Таких операторов в Python 2 : is и is not . Как и в английском, первый означает (это) есть , а второй — это не . Ответами интерпретатора, как и в случае со сравнениями, будут True или False .
Разбираемся, что произошло в последних двух операциях. В первом случае ( 55 is ’55’ ) сравнивалось целое число и строка, поэтому интерпретатор выдал False , а во втором ( ’55’ is «55» ) оба операнда представляли собой строки, поэтому было выдано True . Заметьте, что Питону не важно, использует ли программа одинарные или двойные кавычки: оба варианта синтаксически допустимы, поэтому результат тождества оказался истинным.
Принадлежности
Этих операторов тоже только два: in и not in . Они проверяют, есть или нет определенное значение в какой-либо последовательности. Например:
В последнем случае мы задействовали логический оператор ( and ), к рассмотрению которых и переходим.
Логические
В Питоне есть три логических оператора: and (и), or (или), а также not (не). and работает следующим образом: True возвращается только в том случае, если все операнды истинны. При этом обрабатываться может сколько угодно значений. Используем пример из главы выше:
Как видим, значения ‘house’ в строке не оказалось, поэтому интерпретатор выдал False . Те же операции можно производить и над целочисленными значениями:
Всё верно, потому что одно из выражений ложно, а and требует, чтобы истинными были все условия.
or действует по-другому: выражение признается истинным в том случае, если истинно хотя бы одно из его значений. Поэтому, если в предыдущем примере мы заменим операторы and на or , то получим следующий результат:
22 больше 21 и при этом для операции or не важно, что первое выражение ложно.
А вот как работает not :
Из примера видно, что not переворачивает логические значения, меняя True на False и наоборот.
Побитовые
Побитовые (или битовые) операторы используются в Python для изменения объектов на уровне битов. Их всего пять (сдвиговые принадлежат к одному типу, поскольку различаются только направлением сдвига):
Битовые операторы основаны на принципах Булевой логики, поэтому действуют следующим образом:
& (AND) возвращает 1, если 1 есть в обоих операндах, в остальных случаях 0:
| (OR) возвращает 1, если 1 есть в одном из операндов, иначе вернет 0:
^ (XOR) возвращает 1, если операнды различаются, и 0, если они одинаковы:
(NOT) переворачивает биты, преобразуя положительные значения в отрицательные со сдвигом на единицу следующим образом:
и >> сдвигают биты на определенное количество, которое указывается справа:
Для понимания сдвигов давайте разложим значения на биты, добавив, где нужно, разряд для удобства:
Поэтому, сдвигая в единице разряд влево, мы получаем 2, а если вправо, то 0. А если на два разряда?
Сдвинув единицу на два разряда влево, мы получили 4, потому что 4 в битовом представлении будет 100. Сдвиг вправо на любое число разрядов всё равно дает нам ноль, так как бит «обнуляется» в любом случае.
Больше информации о битовых операторах можно найти в нашей статье о них.
В завершение проясним один важный момент и разграничим похожие по способу действия языковые инструменты.
Чем отличаются операторы от функций
Вы наверняка заметили, что в этот обзор не попала ни одна функция. Путаница в определении этих инструментов возникает из-за того, что и те, и другие производят похожие действия, то есть так или иначе преобразуют объекты. Однако функции более глобальны, то есть могут выполнять операции со строками и целыми блоками кода, а операторы — только с отдельными значениями и переменными. Поэтому функция может состоять в Python из блока операторов , а вот операторы из функций — никогда.
