В этом руководстве речь пойдет об операторах языка программирования Python. Вы узнаете об арифметических, логических и битовых операторах, а также операторах сравнения, присваивания, принадлежности, тождественности и их синтаксисе. Все это будет проиллюстрировано примерами.
Оператор в Python — это символ, который выполняет операцию над одним или несколькими операндами. Операндом выступает переменная или значение, над которыми проводится операция.
Введение в операторы Python
Операторы Python бывают 7 типов:
Арифметические операторы Python
Этот тип включает операторы для проведения базовых арифметических операций.
Сложение (+)
Складывает значение по обе стороны оператора. Пример:
Вычитание (-)
Вычитает значение правой стороны из значения в левой. Пример:
Умножение (*)
Перемножает значения с обеих сторон оператора. Пример:
Деление (/)
Делит значение левой стороны на значение правой. Тип данных результата деления — число с плавающей точкой. Пример:
Возведение в степень (**)
Возводит первое число в степень второго. Пример:
Деление без остатка (//)
Выполняет деление и возвращает целочисленное значение частного, убирая цифры после десятичной точки. Пример:
Деление по модулю (остаток от деления) (%)
Выполняет деление и возвращает значение остатка. Пример:
Операторы сравнения
Операторы сравнения в Python проводят сравнение операндов. Они сообщают, является ли один из них больше второго, меньше, равным или и то и то.
Меньше (
Этот оператор проверяет, является ли значение слева меньше, чем правое. Пример:
Больше (>)
Проверяет, является ли значение слева больше правого.
Пример:
Меньше или равно (
Проверяет, является ли левая часть меньше или равной правой. Пример:
Больше или равно (>=)
Проверяет, является ли левая часть больше или равной правой. Пример:
Равно (==)
Не равно (!=)
Проверяет, не равно ли значение слева правому. Оператор <> выполняет ту же задачу, но его убрали в Python 3.
Операторы присваивания
Оператор присваивания присваивает значение переменной. Он может манипулировать значением до присваивания. Есть 8 операторов присваивания: 1 простой и 7 с использованием арифметических операторов.
Присваивание (=)
Присваивает значение справа левой части. Стоит обратить внимание, что == используется для сравнения, а = — для присваивания. Пример:
Сложение и присваивание (+=)
То же касается и все остальных операторов присваивания. Пример:
Вычитание и присваивание (-=)
Вычитает значение справа из левого и присваивает его выражению слева. Пример:
Деление и присваивание (/=)
Делит значение слева на правое. Затем присваивает его выражению слева. Пример:
Умножение и присваивание (*=)
Перемножает значения обеих сторон. Затем присваивает правое левому. Пример:
Деление по модулю и присваивание (%=)
Выполняет деление по модулю для обеих частей. Результат присваивает левой части. Пример:
Возведение в степень и присваивание (**=)
Выполняет возведение левой части в степень значения правой части. Затем присваивает значение левой части. Пример:
Деление с остатком и присваивание (//=)
Выполняет деление с остатком и присваивает результат левой части. Пример:
Это один из важных операторов Python
Логические операторы Python
Это союзы, которые позволяют объединять по несколько условий. В Python есть всего три оператора: and (и), or (или) и not (не).
И (and)
Если условия с двух сторон оператора and истинны, тогда все выражение целиком считается истинным. Пример:
Или (or)
Выражение ложно, если оба операнда с двух сторон ложные. Если хотя бы одно из них истинное, то и все выражение истинно. Пример:
Не (not)
Операторы принадлежности
Нет в (not in)
Этот оператор проверяет, НЕ является ли значение членом последовательности. Пример:
Операторы тождественности
Эти операторы проверяют, являются ли операнды одинаковыми (занимают ли они одну и ту же позицию в памяти).
Это (is)
Это не (is not)
Битовые операторы Python
Эти операторы работают над операндами бит за битом.
Бинарное И (&)
Бинарное ИЛИ (|)
Проводит побитовую операцию or на двух значениях. Здесь or для 10 (2) и 11 (3) возвращает 11 (3). Пример:
Бинарное ИЛИ НЕТ (^)
Проводит побитовую операцию xor (исключающее или) на двух значениях. Здесь результатом ИЛИ НЕ для 10 (2) и 11 (3) будет 01 (1). Пример:
Инвертирующий оператор (
Бинарный сдвиг влево (
Бинарный сдвиг вправо (>>)
Выводы
В этом уроке были рассмотрены все 7 типов операторов Python. Для каждого был предложен пример в IDE. Для понимания особенностей работы операторов нужно продолжать с ними работать, использовать в условных конструкциях и объединять.
Числа очень часто применяются в программирование для ведения счета в играх, представления данных в визуализации, хранение информации и т.д.
Содержание страницы:
1. Типы чисел
2. Арифметические операторы
2.1. Сложение и вычитание
2.2. Умножение
2.3. Возведение в степень
2.4. Деление
2.5. Деление с округлением
2.6. Оператор вычисления остатка от деления
3. Исключения и трассировка
1. Типы чисел в Python.
В Python числа делятся на несколько категорий в соответствии со способом их использования. Основные это целые числа ( int) и вещественные ( float) или числа с плавающей точкой. Чтобы узнать к какому типу относится число или переменная, можно воспользоваться встроенной функциейtype(). Запустите командную строку и активируйте Python. В скобках введите число или переменную, чтобы узнать ее тип.
2. Арифметические операторы Python.
В таблице перечислены арифметические операторы, среди которых встречаются некоторые знаки, не используемые в алгебре.
2.1. Сложение и вычитание в Python.
Сложение и вычитание в целом выполняется и записывается, как и обычно в алгебре.
2.2. Умножение в Python ( * )
В Python в качестве оператора умножения используется знак * (звездочка)
>>> 5 * 5 25
2.3. Возведение в степень в Python ( ** )
>>> 5 ** 6 15625 >>> 81 ** (1/2) 9.0
Для вычисления квадратного корня можно воспользоваться показателем степени 1/2. Корень 81 = 9.
2.4. Деление в Python ( / )
Оператор деления ( / ) делит числитель на знаменатель
>>> 10 / 2 5.0 >>> 10 / 8 1.25
2.5. Деление с округлением в Python ( // )
Операция целочисленное деление ( // ) делит числитель на знаменатель, в результате получается наибольшее целое число, не превышающее результат. В Python дробная часть отсекается.
При обычном деление 10 на 8, получается результат 1,25. Python отсекает дробную часть и в итоге получаем 1.
2.6. Оператор вычисления остатка от деления ( % )
Для вычисления остатка от деления в Python используется оператор вычисления остатка от деления %
>>> 21 % 5 1 >>> 18 % 4 2
>>> 9.5 % 4.5 0.5
В данных примерах при делении 21 на 5, получается частное 4 и остаток 1. Во втором случае при делении 18 на 4, получается 4 и остаток 2. Этот оператор чаще работает с целыми числами, но также может использоваться и с другими типами.
3. Исключения и трассировка.
>>> 5 / 0 Traceback (most recent call last): File » «, line 1, in ZeroDivisionError: division by zero
Числа в Python 3: целые, вещественные, комплексные. Работа с числами и операции над ними.
Целые числа (int)
Числа в Python 3 ничем не отличаются от обычных чисел. Они поддерживают набор самых обычных математических операций:
Также нужно отметить, что целые числа в python 3, в отличие от многих других языков, поддерживают длинную арифметику (однако, это требует больше памяти).
Битовые операции
Над целыми числами также можно производить битовые операции
x | y
Побитовое или
x ^ y
Побитовое исключающее или
x & y
Побитовое и
x > y
Битовый сдвиг вправо
Дополнительные методы
Системы счисления
Те, у кого в школе была информатика, знают, что числа могут быть представлены не только в десятичной системе счисления. К примеру, в компьютере используется двоичный код, и, к примеру, число 19 в двоичной системе счисления будет выглядеть как 10011. Также иногда нужно переводить числа из одной системы счисления в другую. Python для этого предоставляет несколько функций:
Вещественные числа (float)
Вещественные числа поддерживают те же операции, что и целые. Однако (из-за представления чисел в компьютере) вещественные числа неточны, и это может привести к ошибкам:
Для высокой точности используют другие объекты (например Decimal и Fraction)).
Также вещественные числа не поддерживают длинную арифметику:
Простенькие примеры работы с числами:
Дополнительные методы
Помимо стандартных выражений для работы с числами (а в Python их не так уж и много), в составе Python есть несколько полезных модулей.
Модуль math предоставляет более сложные математические функции.
Модуль random реализует генератор случайных чисел и функции случайного выбора.
Комплексные числа (complex)
В Python встроены также и комплексные числа:
Для работы с комплексными числами используется также модуль cmath.
У мение эффективно применять математические операции в рамках программирования – важный навык, который необходимо развивать, потому как с числами предстоит работать постоянно. Алгоритмы, функции, теория множеств, алгебра логики, комбинаторика и статистика — программисты пользуются ими регулярно и повсеместно.
Но не всё так страшно. Да, понимание математики на высоком уровне помогает стать высококвалифицированным программистом, но оно не является для этого обязательным условием. Тем не менее базовые вещи знать придётся. А в основе всех мощных математических инструментов лежат простые и понятные операции.
Сложение (+)
И самая простая и понятная из них — сложение. Никаких «подводных камней»: берём два или более чисел, пишем между ними знак » + » и присваиваем результат выражения переменной (или сразу выводим сумму на экран):
x = 5 y = 3 z = x + y print(z) > 8
Сложим несколько вещественных чисел и выведем их на экран без предварительной инициализации результирующей переменной:
q = 4.5 w = 2.5 e = 2.5 r = 0.5 print(q + w + e + r) > 10.0
Вообще говоря, если хотя бы одно из слагаемых — число вещественное, то вещественным будет и весь результат.
Вычитание – это обратная операция сложению. Оператором выступает знак «-«:
Умножение (*)
Как и две предыдущие операции, умножение в Python не таит в себе никаких скрытых или неочевидных особенностей. Умножаем два или более чисел при помощи оператора «звёздочка» ( * ):
Деление (/)
Сложение, вычитание и умножение тривиальны, а вот с делением не всё так просто. В Python существует три вида деления и столько же разных операторов. Начнём с истинного деления, за которое отвечает оператор » / «. Его главным отличием является то, что, вне зависимости от типов операндов, будет возвращен вещественный результат ( float ).
print(8/2) > 4.0 # делимое и делитель — int числа, а частое — float print(type(8/2)) > print(8/3) > 2.6666666666666665
Этот вид деления наиболее близок к обычному и знакомому нам математическому. И здесь тоже нельзя делить на ноль:
print(8/0) > ZeroDivisionError: division by zero
💁 Немного истории. В старых версиях Питон оператор «/» выполнял операцию классического деления: т.е. он делил целочисленно и усекал дробную часть в том случае, когда делимое и делитель были целыми. Если же операнды принадлежали к множеству вещественных чисел, то проводилось деление с сохранением дробной части, и результат был float.
Разработчики отказались от классического деления в Python 3.0 и вместо него добавили истинное деление. Архитекторы языка пошли на такой шаг по той причине, что в предыдущей модели классического деления результаты напрямую зависели от типов операндов. Из-за этого возникали трудности с их предварительной идентификацией и оценкой, что было особенно критично для Питона, как для языка с динамической типизацией.
Целочисленное деление (//)
print(15//2) # видно, что результат округлился в меньшую сторону > 7 # и остался целочисленным, поскольку и делимое, и делитель — int числа print(type(15//2)) >
При изменении любого из операндов на вещественное число, результат также изменится и станет float :
print(15//3.1) > 4.0 print(type(15//3.1)) >
Об округлении вниз важно помнить, когда работа идёт с отрицательными числами:
На ноль всё ещё нельзя делить:
print(15//0) > ZeroDivisionError: integer division or modulo by zero
Остаток от деления (%)
Остаток от деления ещё называют делением по модулю. Оператор » % » сначала делит, а затем возвращает остаток.
print(21 % 3) > 0 print(21 % 5) > 1 print(21 % 0) > ZeroDivisionError: integer division or modulo by zero
Остаток может не быть целочисленным:
print(21.3 % 3) > 0.3000000000000007
Но вся прелесть данного оператора заключается не в возвращаемом им значении остатка.
Главная фишка деления по модулю в том, что с его помощью легко проверяется факт делимости одного числа на другое
А отсюда вытекают и проверки на чётность/нечётность:
import random def parity_check(num): «»» функция, проверяющая четность числа. Любое четное число делится на 2 без остатка. «»» if num % 2 == 0: return ‘Число чётное’ else: return ‘Число нечётное’ # сгенерируем случайное число и проверим работу функции rnum = random.randint(0, 100) print(rnum) print(parity_check(rnum)) > 62 > Число чётное
💭 Проверка числа на чётность/нечётность будет часто встречаться в вашей работе.
Возведение в степень (**)
Нетипичный оператор для большинства других языков программирования. Тем он и удобен. Парная «звёздочка» ( ** ) выполняет классическое математическое возведение числа «a» в степень «b»:
a = 2 b = 10 print(a ** b) > 1024
И показатель степени, и основание могут быть отрицательными:
# степень 0.5 аналогична квадратному корню a = 100 b = 0.5 print(a ** b) > 10.0 a = 0.5 b = 2 print(a ** b) > 0.25
Операндов у возведения в степень также может быть несколько. В таком случае, оператор » ** » работает, как право-ассоциативный (т.е. операции выполняются справа-налево):
print(2 ** 2 ** 3) # Сначала выполняется 2 ** 3, а затем уже 2 ** 8. > 256
В завершении — про приоритет операций. Если в выражении используются разные операторы, то порядок их выполнения будет следующим:
Операнд – то, к чему применяется оператор. Например, в умножении 5 * 2 есть два операнда: левый операнд равен 5, а правый операнд равен 2. Иногда их называют «аргументами» вместо «операндов».
Унарным называется оператор, который применяется к одному операнду.
Обратите внимание как записаны два оператора в одну строчку: они разделены точкой с запятой. Так тоже можно делать. Если каждый оператор начинается с новой строки, то точку с запятой ставить не обязательно, если пишем несколько операторов в одну строчку, то они разделяются точкой с запятой.
Бинарным называется оператор, который применяется к двум операндам.
Тот же минус существует и в бинарной форме:
Конечно, +a это то же самое, что и a, поэтому, в основном, используется унарный минус. По приоритету унарные операции выше бинарных операций. Например, вот такая запись:
означает, что число –a возводится в степень 2, то есть, унарный минус имеет больший приоритет, чем бинарная операция ** возведения в степень.
Если же используются бинарные сложение и вычитание:
то их приоритет становится наименьшим среди всех арифметических операций (они выполняются в последнюю очередь).
Следующая бинарная операция умножение работает так, как мы привыкли ее использовать в математике:
Здесь сначала выполнится умножение, а затем – сложение. Если необходимо изменить приоритет выполнения операций, то используются круглые скобки:
Далее, деление двух чисел (или переменных) можно выполнить двумя способами. Первый – традиционный, делает деление, привычное в математике, например:
получим ожидаемый результат 1,5. Однако те из вас, кто имеет опыт программирования на таких языках как С++ или Java, знают, что при делении двух целочисленных значений, результат также получался целочисленным. Но в Python это не так! Его арифметические операции работают в соответствии с классическими правилами математики и деление здесь – это всегда полноценное деление двух значений, какими бы они ни были.
Однако, если все же требуется выполнить целочисленное деление (то есть, с отбрасыванием дробной части), то используется такой оператор:
И, как видите, теперь результат 1, а не 1,5. Причем, это целочисленное деление будет выполняться и с вещественными числами:
Вот такие два оператора деления существуют в Python.
Если же хотим вычислить остаток от целочисленного деления, то используется оператор:
С положительными целыми числами он работает также как и во многих других языках программирования. Например,
и так далее, мы будем получать числа от 0 до 4. Но с отрицательными числами вычисления будут отличаться от того же языка С++. Например,
то есть, остатки всегда будут положительными в диапазоне от 0 до 4, как это и должно быть по математике.
Все рассмотренные операторы (*, /, //, %) имеют одинаковый приоритет и выполняются слева-направо. То есть, если записать
то это следует интерпретировать как формулу
Следующая операция – возведение в степень. В самом простом варианте она записывается так:
здесь x, y могут быть и дробными числами. Например:
Это будет соответствовать извлечению квадратного корня из 1,96. Если запишем такую конструкцию:
то получим кубический корень из 27. Причем, обратите внимание, круглые скобки у степени здесь обязательны, т.к. приоритет операции ** выше, чем у деления. Если записать вот так:
то это будет эквивалентно такому выражению:
Вот на это следует обращать внимание. И еще один нюанс. Операция возведения в степень выполняется справа-налево. То есть, если записать вот такую строчку:
Это будет эквивалентно степени:
Сначала (справа) вычисляется 3**2 = 9, а затем, 2**9 = 512. Все остальные арифметические операции работают слева-направо.
Используя оператор присваивания совместно с арифметическими операторами, можно выполнять некоторые полезные арифметические преобразования переменных. Например, очень часто требуется увеличить или уменьшить некую переменную на определенное число. Это можно сделать вот так:
Но, можно и короче, вот так:
Они довольно часто используются в программировании. Также, помимо сложения и вычитания, можно записывать и такие выражения:
То есть, здесь до оператора присваивания можно записывать любую арифметическую операцию.
Все рассмотренные арифметические операции можно выполнять и с комплексными числами:
Кроме операции целочисленного деления // и вычисления остатка от деления %. Дополнительно у объектов комплексных чисел есть свойства:
для взятия действительной и мнимой части. И полезный метод:
для получения комплексно-сопряженного числа.
В языке Python имеются встроенные функции для работы с числами. Наиболее полезные, следующие:
вычисляет модуль числа x
округляет x до ближайшего целого
находит минимальное, среди указанных чисел
находит максимальное, среди указанных чисел
возводит x в степень y
Также в языке Python имеется стандартная библиотека math, которая содержит большое количество стандартных математических функций. Чтобы ей воспользоваться, необходимо вначале программы подключить эту библиотеку. Делается это с помощью ключевого слова import, за которым указывается имя библиотеки:
После этого становятся доступными следующие полезные функции:
возвращает ближайшее наибольшее целое для x
возвращает ближайшее наименьшее целое для x
возвращает модуль числа x
вычисляет факториал x!
вычисляет логарифм по основанию 2
вычисляет логарифм по основанию 10
вычисляет логарифм по указанному основанию base (по умолчанию base = e – натуральный логарифм)
возводит число x в степень y
вычисляет квадратный корень из x
Тригонометрические функции
вычисляет косинус x
вычисляет тангенс x
вычисляет арккосинус x
вычисляет арксинус x
вычисляет арктангенс x
Математические константы
Помимо этих есть и другие математические функции. При необходимости, о них можно почитать в официальной документации языка Python.
Применение этих функций вполне очевидно, например, их можно вызвать вот так:
И так далее. Вот так работают арифметические операции в Python и вот такие математические функции имеются в стандартной библиотеке math.
Видео по теме
#1. Первое знакомство с Python Установка на компьютер
#2. Варианты исполнения команд. Переходим в PyCharm
#3. Переменные, оператор присваивания, функции type и id
#4. Числовые типы, арифметические операции
#5. Математические функции и работа с модулем math
#6. Функции print() и input(). Преобразование строк в числа int() и float()
#7. Логический тип bool. Операторы сравнения и операторы and, or, not
#8. Введение в строки. Базовые операции над строками
