Сколько существует операторов сравнения в языке python
Перейти к содержимому

Сколько существует операторов сравнения в языке python

  • автор:

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

Что такое оператор и операнды? Это можно объяснить простым примером: 10 > 5 . В этом выражении 10 и 5 — левый и правый операнды. Знак > — оператор.

Пусть переменная a = 10 , а переменная b = 5

Оператор Описание Пример Результат
== Проверяет, равны ли значение операндов. Если равны, то условие является истиной a == b False
!= Проверяет, равны ли значение операндов. Если НЕ равны, то условие является истиной a != b True
> Проверяет значение левого операнда. Если оно больше, чем значение правого, то условие является истиной a > b True
Проверяет значение левого операнда. Если оно меньше, чем значение правого, то условие является истиной a < b False
>= Проверяет значение левого операнда. Если оно больше, либо равно значению правого, то условие является истиной a >= b True
Проверяет значение левого операнда. Если оно меньше, либо равно значению правого, то условие является истиной a

False

Python с нуля. Освойте с Виртуальным ИИ-помощником!

Теоретические уроки и практические задачи
Пишите и проверяйте код прямо в браузере
Виртуальный ИИ-помощник поможет в любое время дня и ночи
Сообщество учеников для взаимопомощи и обмена опытом
200 000+ зарегистрированных участников. Присоединяйтесь!
Попробовать бесплатно
©2023 Letpy

Мы используем файлы cookie

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

Операции сравнения в Python, цепочки сравнений

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

Разрешенные операции сравнения:

  • x < y - строго x меньше y ,
  • x
  • x > y — строго x больше y ,
  • x >= y — x больше или равно y ,
  • x == y — x равно y ,
  • x != y — x не равно y .

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

x  y  z # эквивалентно x  y and y  z 
a  b  c  d # эквивалентно a  b and b  c and c  d 

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

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

Оператор == всегда определен, но для некоторых типов объектов, например объектов класса, эквивалентен оператору идентичности is .

Операторы < , и >= применяются только там, где они имеют смысл, например они вызывают исключение TypeError , когда один из аргументов является комплексным числом.

Неидентичные экземпляры класса обычно при сравнении будут неравны, если только класс не определяет метод __eq__() .

Экземпляры класса не могут быть упорядочены относительно других экземпляров того же класса или других типов объектов, если класс не определяет достаточное количество методов __lt__() , __le__() , __gt__() и __ge__() . В общем случае определение методов __lt__() и __eq__() для этих целей бывает достаточно.

Важно! Числа типа float не являются десятичными дробями (decimal.Decimal) и используют двоичную арифметику, поэтому иногда выражения могут вычисляться с ничтожно малыми погрешностями. Из-за этих погрешностей операции сравнения работают не так как ожидается.

>>> 0.8 - 0.5 == 0.3 # False >>> 0.8 - 0.5 - 0.3 == 0 # False >>> 0.8 - 0.5 - 0.3 # 5.551115123125783e-17 >>> from decimal import Decimal >>> Decimal('0.8') - Decimal('0.5') - Decimal('0.3') == 0 # True >>> Decimal('0.8') - Decimal('0.5') - Decimal('0.3') # Decimal('0.0') 

Поведение встроенных типов в операциях сравнения:

  • Числа встроенных числовых типов int , float , complex и стандартных библиотечных типов fractions.Fraction и decimal.Decimal можно сравнивать внутри и между их типами, с ограничением, что комплексные числа не поддерживают сравнение порядка. В пределах задействованных типов они сравнивают математически (алгоритмически) правильно без потери точности. Нечисловые значения float(‘NaN’) и decimal.Decimal(‘NaN’) являются особыми. Любое упорядоченное сравнение числа с нечисловым значением неверно. Нечисловые значения не равны самим себе. Например, если x = float(‘NaN’) , 3 < x , x < 3 и x == x все ложны, а x! = X истинно. Это поведение соответствует стандарту IEEE 754.
  • None и NotImplemented являются одиночными. PEP 8 советует, что сравнения для одиночных экземпляров всегда должны выполняться с использованием или нет, а не с операторами равенства.
  • Двоичные последовательности (экземпляры bytes или bytearray ) можно сравнивать внутри и между их типами. Они сравнивают лексикографически, используя числовые значения своих элементов.
  • Строки (экземпляры str ) сравниваются лексикографически с использованием числовых кодовых точек Unicode (результат встроенной функции ord() ) их символов.

Строки и двоичные последовательности напрямую сравнивать нельзя.

  • Чтобы две коллекции были равными, они должны быть одного типа, иметь одинаковую длину и каждая пара соответствующих элементов должна быть равной. Например [1,2] == (1,2) ложно, потому что типы последовательностей разные.
  • Коллекции, поддерживающие сравнение порядка (сортировку), упорядочиваются также, как их первые неравные элементы, например [1,2, x]

Подводные камни (ловушки цепочек сравнения).

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

Нетранзитивные операторы.

Чтобы проверить, совпадают ли a , b и c , можно использовать цепочку сравнения a == b == c . А как проверить, ВСЕ ли они разные? Первое, что приходит в голову — это a != b != c , и попадаем в первую ловушку!

>>> a = c = 1 >>> b = 2 >>> a != b != c # True 

Но это не так. Они не все разные, ведь a == c . Проблема здесь в том, что a != b != c — это a != b and b != c , т.е. проверяет, что b отличается от a и от c , но ничего не говорит о том, как связаны a и c .

С математической точки зрения, != не является транзитивным, т. е. знание того, как a относится к b , и знание того, как b относится к c , не говорит о том, как a относится к c . Что касается транзитивного примера, можно взять оператор равенства == . Если a == b and b == c , то также верно, что a == c .

Непостоянное значение в выражении.

Если b содержит что-то непостоянное или выражение с побочными эффектами, то эти два выражения не эквивалентны.

Этот пример показывает разницу в количестве оценок значения в середине выражения:

def f(): print("run") return 3 >>> 1  f()  5 # run # True >>> 1  f() and f()  5 # run # run # True 
lst = [-2, 2] def f(): global lst lst = lst[::-1] return lst[0] >>> 1  f() and f()  0 # True >>> 1  f()  0 # False 

Синтаксис lst[::-1] — это срез, который переворачивает список.

Плохо читаемые цепочки сравнения.

Цепочки сравнения выглядят действительно естественно, но в некоторых конкретных случаях она не так хороша. Это довольно субъективный вопрос, но лучше избегать цепочки, в которых операторы не «выровнены«, например:

Можно утверждать, например, что a < b >c читается как «проверим, b больше, чем a и c ?«, но лучше эту цепочку записать так max(a, c) < b или b >max(a, c) .

Есть некоторые другие цепочки, которые просто сбивают с толку:

В Python операторы is , is not , in и not in являются операторами сравнения, следовательно их также можно связать с другими операторами. Это создает странные ситуации, такие как:

>>> a = 3 >>> lst = [3, 5] >>> a in lst == True # False 

Примеры использования цепочек сравнения.

>>> a = 1 >>> b = 2 >>> c = 3 >>> a  b  c # True 

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

>>> a = b = 1 >>> c = 2 >>> if a == b == c: . print("все равны") . else: . print("некоторые отличаются") # некоторые отличаются >>> c = 1 >>> if a == b == c: . print("все равны") . else: . print("некоторые отличаются") # все равны 

На самом деле можно связать произвольное количество операторов сравнения в цепочку? Например, a == b == c == d == e проверяет, совпадают ли все пять переменных, в то время как a < b < c < d < e проверяет, есть ли строго возрастающая последовательность.

6. Python – Основные операторы языка

Python – это универсальный язык, который можно использовать для создания всевозможных приложений. Мы рассмотрим основные операторы в Python. Вы должны хорошо понимать, как использовать основные операторы в Python.

Давайте разберёмся, что такое операторы. Операторы – это конструкции, которые могут управлять значением операндов.

Рассмотрим выражение «4 + 5 = 9». Здесь «4» и «5» называются операндами, а «+» называется оператором.

Типы операторов

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

Язык Python поддерживает следующие типы операторов:

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

Давайте посмотрим все операторы Python один за другим.

Оглавление

  • 1. Python – Самоучитель для начинающих
  • 2. Python – Обзор
  • 3. Python – Установка среды
  • 4. Python – Базовый синтаксис
  • 4.1. Python – Аргументы командной строки
  • 5. Python – Типы переменных
  • 6. Python – Основные операторы
  • 6.1. Python – Арифметические операторы
  • 6.2. Python – Операторы сравнения
  • 6.3. Python – Операторы присваивания: примеры
  • 6.4. Python – Побитовые операторы
  • 6.5. Python – Логические операторы
  • 6.6. Python – Операторы членства
  • 6.7. Python – Операторы идентификации
  • 6.8. Python – Приоритет операторов
  • 7. Python – Условные операторы
  • 7.1. Python – Условие if
  • 7.2. Python – Условные операторы if. else и elif
  • 7.3. Python – Вложенные операторы if
  • 8. Python – Циклы
  • 8.1. Python – Цикл while
  • 8.2. Python – Цикл for
  • 8.3. Python – Вложенные циклы
  • 8.4. Python – Оператор break
  • 8.5. Python – Оператор continue
  • 8.6. Python – Оператор pass
  • 9. Python – Числа
  • 9.1. Python – Метод abs()
  • 9.2. Python – Метод ceil()
  • 9.3. Python – Метод cmp()
  • 9.4. Python – Метод exp()
  • 9.5. Python – Метод fabs()
  • 9.6. Python – Метод floor()
  • 9.7. Python – Метод log()
  • 9.8. Python – Метод log10()
  • 9.9. Python – Метод max()
  • 9.10. Python – Метод min()
  • 9.11. Python – Метод modf()
  • 9.12. Python – Метод pow()
  • 9.13. Python – Метод round()
  • 9.14. Python – Метод sqrt()
  • 9.15. Python – Метод choice()
  • 9.16. Python – Метод randrange()
  • 9.17. Python – Метод random()
  • 9.18. Python – Метод seed()
  • 9.19. Python – Метод shuffle()
  • 9.20. Python – Метод uniform()
  • 9.21. Python – Метод acos()
  • 9.22. Python – Метод asin()
  • 9.23. Python – Метод atan()
  • 9.24. Python – Метод atan2()
  • 9.25. Python – Метод cos()
  • 9.26. Python – Метод hypot()
  • 9.27. Python – Метод sin()
  • 9.28. Python – Метод tan()
  • 9.29. Python – Метод degrees()
  • 9.30. Python – Метод radians()

Условия (if, else, elif) и операторы сравнения

На прошлом занятии мы научились выводить данные с помощью функции print() . Например, чтобы вывести число 5 на экран нужно написать в интерпретаторе print(5) , и он сделает свое дело.

Но что, если нужно что-то ввести в программу из внешнего мира? Например, если наш самописный калькулятор умеет складывать 2 числа и выводить ответ, то как ввести эти самые 2 числа? На помощь придет функция input() . Попробуем написать вышеописанный калькулятор.

Функции input() можно передать в качестве аргумента строку, которую увидит пользователь перед вводом.

>>> a = input('Введите число a: ') Введите число a: 56 >>> b = input('Введите число b: ') Введите число b: 23 >>> print(a + b) 5623 

Как видно из примера, что-то пошло не так. Вместо заветных 46 после сложения 12 и 34 мы получили 1234. Все дело в типах данных. Функция input() всегда считывает данные в виде строки. Так и в примере она считала 12 и 34 как 2 строки и просто «слепила» их вместе. Мы же хотим складывать числа. Чтобы все работало хорошо, нужно выполнить преобразование типов данных.

В данном случае можно сделать вот так:

>>> a = int(input('Введите число a: ')) Введите число a: 56 >>> b = (input('Введите число b: ')) Введите число b: 23 >>> print(a + b) 79 

То, чего мы и хотели.

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

>>> # Преобразование числа в строку >>> a = 34 >>> b = str(a) >>> print('Преобразованное число:', b, ', его тип:', type(b)) Преобразованное число: 34 , его тип: class 'str'> 
>>> # Преобразование строки в число с плавающей точкой >>> a = '45.34' >>> b = float(a) >>> print(a, type(a)) 45.34 class 'str'> >>> print(b, type(b)) 45.34 float'> >>> b**2 2055.7156000000004 
>>> # Преобразовать строку с НЕ числом в число не получится >>> a = 'python' >>> b = int(a) Traceback (most recent call last): File "", line 1, in module> b = int(a) ValueError: invalid literal for int() with base 10: 'python' 

В примерах мы используем функцию type() . Как должно быть понятно из её названия, она выясняет тип переменной. Возвращает она что-то страшное вида . Сейчас не стоит вникать почему так. Нам важно, что преобразование прошло правильно и получился тип str .

Как вы уже поняли, чтобы преобразовать что-то во что-то, надо взять и вызвать функцию, совпадающую по имени с названием типа данных. В нашем примере это str() , int() и float() .

Почему нужно конвертировать строки в числа

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

>>> a = input('Введите целое число:') Введите целое число:12 >>> b = input('Введите целое число:') Введите целое число:45 >>> if a > b: . print('Большее число:', a) . else: . print('Большее число:', b) Большее число: 45 

Вы удовлетворитесь ответом и пойдете домой. Но потом выяснится, что если ввести другие 2 числа, то все сломается:

>>> a = input('Введите целое число:') Введите целое число:4 >>> b = input('Введите целое число:') Введите целое число:30 >>> if a > b: . print('Большее число:', a) . else: . print('Большее число:', b) Большее число: 4 

Значит, не все так просто…

Чтобы разобраться в вопросе, нужно знать как сравниваются строки.

Компьютер умеет работать только с одним типом данных — числами. Мы же помимо чисел используем кучу разных типов данных: числа, строки, списки, словари, кортежи (последние 3 будут обсуждаться дальше в курсе). Оказывается, что и они все хранятся и обрабатываются компьютером в виде чисел. Разберемся со строчками.

Когда люди задумались, как можно обрабатывать строки, им прошла в голову простая идея — а давайте создадим единую таблицу, в которой каждому символу поставим в соответствие число. Так появилась таблица ASCII (American standard code for information interchange).

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

Python версии 3 использует Unicode — кодировку, которая на данный момент включает в себя знаки почти всех письменных языков мира. Emoji в ней, кстати, тоже есть ��������‍����

При сравнении строк, Python переводит все символы строки в числа и производит сравнение чисел.

Если перевести “числовые” строки из примеров выше в списки чисел, то получится:

  • ’12’ = [49, 50]
  • ’45’ = [52, 53]
  • ‘4’ = [52]
  • ’30’ = [51, 48]

Когда же мы пишем ‘4’ < '30' , то Python снова сравнивает числа обоих строк по очереди, но на этот раз получается иначе: 52 < 51 - False и ответ получается '4' >’30’ , что абсолютно верно с точки зрения сравнения строк, но абсолютный бред с точки зрения сравнения чисел.

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

Поэтому, если вы работаете с числами, то всегда работайте с ними как с числами, а не как со строками.

Условия

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

Теперь предположим, что мы хотим определить абсолютное значение любого числа. Наша программа должна будет напечатать сам x в случае, если он неотрицателен и -x в противном случае. Линейной структурой программы здесь не обойтись*, поэтому нам на помощь приходит инструкция if (если). Вот как это работает в питоне:

>>> # Ввод данных с преобразованием типа >>> x = int(input()) >>> >>> if x > 0: . print(x) >>> else: . print(-x) 

На самом деле в python есть функция abs() , с помощью которой можно взять модуль числа. Но в качестве примера использования конструкции if и так хорошо.

Разберем этот кусочек кода. После слова if указывается проверяемое условие (x > 0) , завершающееся двоеточием (это важно). После этого идет блок (последовательность) инструкций, который будет выполнен, если условие истинно. В нашем примере это вывод на экран величины x . Затем идет слово else (иначе), также завершающееся двоеточием (и это важно), и блок инструкций, который будет выполнен, если проверяемое условие неверно. В данном случае будет выведено значение -x .

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

Небольшая ремарка относительно табуляции. Мы используем 4 пробела! В современных текстовых редакторах при нажатии на tab автоматически вставляется 4 пробела. Не надо жать 4 раза кнопку space как вот тут. Никакой войны, никаких табов. Просто 4 пробела.

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

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

if Условие: блок инструкций, в случае если условие истинно else: блок инструкций, в случае если условие не выполняется 

Вторая часть условной конструкции (та, что с else) может и отсутствовать, например так:

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

Эта программа тоже выведет абсолютное значение x, как и та, что была ранее.

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

Все операторы сравнения в питоне достаточно интуитивны. Вот список основных:

> — больше. Условие истинно, если то, что слева от знака больше того, что справа.
< - меньше. Условие истинно, если то, что слева от знака меньше того, что справа.
>= — больше либо равно.
== — в точности равно.
!= — не равно.

Вложенные условные инструкции

Условия могут быть вложены одно в другое, чтобы реализовывать еще более сложную логику, например:

>>> a = int(input()) >>> b = int(input()) >>> >>> if a > 0: . if b > 0: . print("a, b > 0") . else: . print("a > 0, b < 0") . else: . if b > 0: . print("a, b < 0") . else: . print("a < 0, b >0") . 

Главное, не забывать отступы и двоеточия.

Тип данных bool

Операторы сравнения возвращают значения специального логического типа bool. Значения логического типа могут принимать одно из двух значений: True (истина) или False (ложь) .

Если преобразовать логическое True к типу int , то получится 1 , а преобразование False даст 0 . При обратном преобразовании число 0 преобразуется в False , а любое ненулевое число в True . При преобразовании str в bool пустая строка преобразовывается в False , а любая непустая строка в True .

Рассмотрим несколько примеров:

>>> # Сравнение строки >>> name = input('Введите своё имя:') >>> if name != '': >>> print('Привет,', name) >>> else: >>> print('Вы не ввели своё имя!') 
>>> # Преобразование bool к int >>> print(int(True)) 1 >>> print(int(False)) 0 

Обратите внимание, ключевые слова True или False пишутся с большой буквы. Если написать их с маленькой, то python подумает, что это переменная, попытается её найти и сломается, когда не найдет 🙁 . А если вы вздумаете называть свои переменные false или true , то сдать зачет по курсу вам не светит 🙂 . Учитесь сразу хорошему стилю программирования.

>>> # Преобразование bool к int >>> print(int(true)) Traceback (most recent call last): File "", line 1, in module> print(int(true)) NameError: name 'true' is not defined 

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

Если мы хотим проверить два или более условий за раз, мы можем воспользоваться операторами and , or или not . Вот как они работают:

and (логическое И) возвращает истину ( True ) только в случае если оба условия по отдельности верны (тоже возвращают True )
or (логическое ИЛИ) вернет истину в случае, если хотя бы одно из условий верно.
not (логическое НЕТ) возьмет результат условия и “обратит” его. То есть, если результат условия True , то not примененный к этому условию вернет False и наоборот.

Давайте посмотрим как это работает на примере. Код ниже проверяет, что хотя бы одно число из двух нацело делится на 10 (кончается на 0) и если так, то печатает YES, а если нет, то печатает NO:

>>> a = int(input()) >>> b = int(input()) >>> >>> if a % 10 == 0 or b % 10 == 0: . print('YES') . else: . print('NO') . 

Пусть теперь мы хотим проверить, что числа a и b должны быть еще и обязательно больше нуля:

>>> a = int(input()) >>> b = int(input()) >>> >>> if (a % 10 == 0 and a > 0) or (b % 10 == 0 and b > 0): . print('YES') . else: . print('NO') . 

Как видите, мы можем не только использовать and и or в одном if , но и группировать условия скобками для того, чтобы явно обозначить приоритет вычисления условий.

Посмотрим пример с not . Пусть мы хотим проверить, что число a — положительное, а число b — неотрицательное. Это можно проверить вот таким условием:

>>> if a > 0 and not (b  0): . pass . 

Оператор pass очень полезен, когда нужно ничего не делать. Если его не поставить, то будет синтаксическая ошибка. А так, код считается правильным!

Кстати, not (b < 0) можно было бы и заменить на b >= 0 и код бы работал точно так же.

Конструкция elif

Иногда писать конструкции if-else долго и утомительно, особенно если приходится проверять много условий разом. В этом случае на помощь придет elif (сокращение от else if). По сути elif позволяет существенно упростить конструкцию ниже:

>>> if a > 0: . pass . else: . if b > 0: . pass . 

И сделать ее вот такой:

>>> if a > 0: . pass . elif b > 0: . pass . 

Обратите внимание, мы избавились от одного уровня вложенности. То есть, сам код стал более читаемым, но при этом нисколько не проиграл в функциональности. Разумеется, конструкции типа if-elif могут завершиться и блоком else , например так:

>>> if a > 0: . pass . elif b > 0: . pass . elif c > 0: . pass . else: . pass . 

Задача: знак числа

В математике есть функция sgn, показывающая знак числа. Она определяется так: если число больше 0, то функция возвращает 1. Если число меньше нуля, то функция возвращает -1. Если число равно 0, то функция возвращает 0. Реализуйте данную функцию — для введенного числа выведите число, определяющее его знак. Используйте операторы сравнения и конструкцию if-elif-else .

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

Задача: високосный год

Дано натуральное число. Требуется определить, является ли год с данным номером високосным. Если год является високосным, то выведите YES, иначе выведите NO. Напомним, что в соответствии с григорианским календарем, год является високосным, если его номер кратен 4, но не кратен 100, а также если он кратен 400.

>>> year = int(input()) >>> if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0): . print('YES') . else: . print('NO') . 

Ссылки по теме

  • http://pythontutor.ru/lessons/ifelse/
  • http://pythonicway.com/python-conditionals

Домашнее задание

Вам надо написать на питоне 6 программ, каждая из которых будет спрашивать у пользователя 3 числа (a, b, c) и печатать на экран удовлетворяют ли введенные числа перечисленным свойствам:

  1. a и b в сумме дают c
  2. a умножить на b равно c
  3. a даёт остаток c при делении на b
  4. c является решением линейного уравнения ax + b = 0
  5. a разделить на b равно c
  6. a в степени b равно c

Оформите каждую программу в виде отдельного файла с расширением .py .

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *