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

Содержание

Ввод данных и преобразование типов
Почему нужно конвертировать строки в числа
Условия
Операторы сравнения
Вложенные условные инструкции
Тип данных bool
Логические операторы
Конструкция elif
Задачи
1. Знак числа
2. Високосный год
Ссылки по теме
Домашнее задание

Ввод данных и преобразования типов

На прошлом занятии мы научились выводить данные с помощью функции 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 <class 'float'>
>>> b**2
2055.7156000000004

>>> # Преобразовать строку с НЕ числом в число не получится
>>> a = 'python'
>>> b = int(a)
Traceback (most recent call last):
  File "<pyshell#22>", line 1, in <module>
    b = int(a)
ValueError: invalid literal for int() with base 10: 'python'

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

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

Windows-1251
КОИ-8
ISO-8859
Юникод
и множество других…

Python версии 3 использует Unicode - кодировку, которая на данный момент включает в себя знаки почти всех письменных языков мира. Emoji в ней, кстати, тоже есть 😀😃😇👩‍💻🐁

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

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

'12' = [49, 50]
'45' = [52, 53]
'4' = [52]
'30' = [51, 48]

Когда мы пишем '12' < '45', то Python сравнивает числа обоих строк по очереди: 49 < 52 - True, значит строка '12' меньше, чем строка '45'.

Когда же мы пишем '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 "<pyshell#32>", 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.