В этой главе вы научились эффективно работать с элементами списка. Вы узнали, как работать со списком в цикле for, как Python использует отступы для определения структуры программы и как избежать некоторых типичных ошибок при использовании отступов. Вы научились создавать простые числовые списки, а также изучили некоторые операции с числовыми списками. Вы узнали, как создать срез списка для работы с подмножеством элементов и как правильно копировать списки с использованием среза. Глава завершается описанием кортежей, до определенной степени защищающих наборы значений, которые не должны изменяться, и рекомендациями по стилевому оформлению вашего кода (сложность которого со временем только возрастает) для упрощения его чтения.
В главе 5 мы займемся обработкой различных условий с использованием команд if. Вы научитесь группировать относительно сложные наборы проверок для обработки именно той ситуации или информации, которая вам нужна. Также в этой главе будет рассматриваться использование команд if при переборе элементов списка для выполнения действий с элементами, выбранными по некоторому условию.
5. Команды if
Программисту часто приходится проверять наборы условий и принимать решения в зависимости от этих условий. Команда if в языке Python позволяет проверить текущее состояние программы и выбрать дальнейшие действия в зависимости от результатов проверки.
В этой главе вы научитесь писать условные проверки для любых интересующих вас условий. Мы начнем с простых команд if, а затем перейдем к более сложным сериям команд if для проверки комбинированных условий. Затем эта концепция будет применена к спискам; вы узнаете, как написать цикл, который выполняет с большинством элементов списка одну операцию, и о том, что для некоторых элементов с конкретными значениями применяется особая обработка.
Простой пример
Следующий короткий пример показывает, как правильно организовать обработку специальных ситуаций с использованием if. Допустим, у вас имеется список машин, и вы хотите вывести название каждой машины. Названия большинства машин должны записываться с капитализацией (первая буква в верхнем регистре, остальные в нижнем). С другой стороны, значение 'bmw' должно записываться в верхнем регистре. Следующий код перебирает список названий машин и ищет в нем значение 'bmw'. Для всех элементов, содержащих значение 'bmw', значение выводится в верхнем регистре:
cars.py
cars = ['audi', 'bmw', 'subaru', 'toyota']
for car in cars:
(1) . .if car == 'bmw':
. . . .print(car.upper())
. .else:
. . . .print(car.title())
Цикл в этом примере (1) сначала проверяет, содержит ли car значение 'bmw'. Если проверка дает положительный результат, то значение выводится в верхнем регистре. Если car содержит все что угодно, кроме 'bmw', то при выводе значения применяется капитализация:
Audi
BMW
Subaru
Toyota
В этом примере объединяются несколько концепций, о которых вы узнаете в этой главе. Для начала рассмотрим основные конструкции, применяемые для проверки условий в программах.
Проверка условий
В каждой команде if центральное место занимает выражение, результатом которого является логическая истина (True) или логическая ложь (False); это выражение называется условием. В зависимости от результата проверки Python решает, должен ли выполняться код в команде if. Если результат условия равен True, то Python выполняет код, следующий за командой if.
Проверка равенства
Во многих условиях текущее значение переменной сравнивается с конкретным значением, интересующим вас. Простейшее условие проверяет, равно ли значение переменной конкретной величине:
(1) >>>car = 'bmw'
(2)>>>car == 'bmw'
True
В строке (1) переменной car присваивается значение 'bmw'; операция выполняется одним знаком =, как вы уже неоднократно видели. Строка (2) проверяет, равно ли значение car строке 'bmw'; для проверки используется двойной знак равенства (==). Этот оператор возвращает True, если значения слева и справа от оператора равны; если же значения не совпадают, оператор возвращает False. В нашем примере значения совпадают, поэтому Python возвращает True.
Если car принимает любое другое значение вместо 'bmw', проверка возвращает False:
(1) >>>car = 'audi'
(2)>>>car == 'bmw'
False
Одиночный знак равенства выполняет операцию; код (1) можно прочитать в форме «Присвоить car значение 'audi'». С другой стороны, двойной знак равенства, как в строке (2), задает вопрос: «Значение car равно 'bmw'?» Такое применение знаков равенства встречается во многих языках программирования.
Проверка равенства без учета регистра
В языке Python проверка равенства выполняется с учетом регистра. Например, два значения с разным регистром символов равными не считаются:
>>>car = 'Audi'
>>>car == 'audi'
False
Если регистр символов важен, такое поведение приносит пользу. Но если проверка должна выполняться на уровне символов без учета регистра, преобразуйте значение переменной к нижнему регистру перед выполнением сравнения:
>>>car = 'Audi'
>>>car.lower() == 'audi'
True
Условие возвращает True независимо от регистра символов 'Audi', потому что проверка теперь выполняется без учета регистра. Функция lower() не изменяет значения, которое изначально хранилось в car, так что сравнение не отражается на исходной переменной:
(1) >>>car = 'Audi'
(2)>>>car.lower() == 'audi'
True
(3)>>>car
'Audi'
В точке (1) строка 'Audi' сохраняется в переменной car. В точке (2) значение car приводится к нижнему регистру и сравнивается со значением строки 'audi', также записанным в нижнем регистре. Две строки совпадают, поэтому Python возвращает True. Вывод в точке (3) показывает, что значение, хранящееся в car, не изменилось в результате проверки.
Веб-сайты устанавливают определенные правила для данных, вводимых пользователями подобным образом. Например, сайт может использовать проверку условия, чтобы убедиться в том, что имя каждого пользователя уникально (а не совпадает с именем другого пользователя, отличаясь от него только регистром символов). Когда кто-то указывает новое имя пользователя, это имя преобразуется к нижнему регистру и сравнивается с версиями всех существующих имен в нижнем регистре. Во время такой проверки имя 'John' будет отклонено, если в системе уже используется любая разновидность 'john'.
Проверка неравенства
Если вы хотите проверить, что два значения различны, используйте комбинацию из восклицательного знака и знака равенства (!=). Восклицательный знак представляет отрицание, как и во многих языках программирования.
Для знакомства с оператором неравенства мы воспользуемся другой командой if. В переменной хранится заказанное дополнение к пицце; если клиент не заказал анчоусы (anchovies), программа выводит сообщение:
toppings.py
requested_topping = 'mushrooms'
(1) if requested_topping != 'anchovies':
. .print("Hold the anchovies!")
Строка (1) сравнивает значение requested_topping со значением 'anchovies'. Если эти два значения не равны, Python возвращает True и выполняет код после команды if. Если два значения равны, Python возвращает False и не выполняет код после команды if. Так как значение requested_topping отлично от 'anchovies', команда print будет выполнена:
Hold the anchovies!
В большинстве условных выражений, которые вы будете использовать в программах, будет проверяться равенство, но иногда проверка неравенства оказывается более эффективной.
Сравнения чисел
Проверка числовых значений достаточно прямолинейна. Например, следующий код проверяет, что переменная age равна 18:
>>>age = 18
>>>age == 18
True
Также можно проверить условие неравенства двух чисел. Например, следующий код выводит сообщение, если значение переменной answer отлично от ожидаемого:
magic_ number.py
answer = 17
(1) if answer != 42:
. .print("That is not the correct answer. Please try again!")
Условие (1) выполняется, потому что значение answer (17) не равно 42. Так как условие истинно, блок с отступом выполняется:
That is not the correct answer. Please try again!
В условные команды также можно включать всевозможные математические сравнения: меньше, меньше или равно, больше, больше или равно:
>>>age = 19
>>>age < 21
True
>>>age <= 21
True
>>>age > 21
False
>>>age >= 21
False
Все эти математические сравнения могут использоваться в условиях if, что повышает точность формулировки интересующих вас условий.
Проверка нескольких условий
Иногда требуется проверить несколько условий одновременно. Например, в некоторых случаях для выполнения действия бывает нужно, чтобы истинными были сразу два условия; в других случаях достаточно, чтобы истинным было хотя бы одно из двух условий. Ключевые слова and и or помогут вам в подобных ситуациях.
Использование and для проверки нескольких условий
Чтобы проверить, что два условия истинны одновременно, объедините их ключевым словом and; если оба условия истинны, то и все выражение тоже истинно. Если хотя бы одно (или оба) условия ложны, то и результат всего выражения равен False.
Например, чтобы убедиться в том, что каждому из двух людей больше 21 года, используйте следующую проверку:
(1) >>>age_0 = 22
>>>age_1 = 18
(2)>>>age_0 >= 21 and age_1 >= 21
False
(3) >>>age_1 = 22
>>>age_0 >= 21 and age_1 >= 21
True
В точке (1) определяются две переменные, age_0 и age_1. В точке (2) программа проверяет, что оба значения равны 21 и более. Левое условие выполняется, а правое нет, поэтому все условное выражение дает результат False. В точке (3) переменной age_1 присваивается значение 22. Теперь значение age_1 больше 21; обе проверки проходят, а все условное выражение дает истинный результат.
Чтобы код лучше читался, отдельные условия можно заключить в круглые скобки, но это не обязательно. С круглыми скобками проверка может выглядеть так:
(age_0 >= 21) and (age_1 >= 21)
Использование or для проверки нескольких условий
Ключевое слово or тоже позволяет проверить несколько условий, но результат общей проверки является истинным в том случае, когда истинно хотя бы одно или оба условия. Ложный результат достигается только в том случае, если оба отдельных условия ложны.
Вернемся к примеру с возрастом, но на этот раз проверим, что хотя бы одна из двух переменных больше 21:
(1) >>>age_0 = 22
>>>age_1 = 18
(2)>>>age_0 >= 21 or age_1 >= 21
True
(3)>>>age_0 = 18
>>>age_0 >= 21 or age_1 >= 21
False
Как и в предыдущем случае, в точке (1) определяются две переменные. Так как условие для age_0 в точке (2) истинно, все выражение также дает истинный результат. Затем значение age_0 уменьшается до 18. При проверке (3) оба условия оказываются ложными, и общий результат всего выражения тоже ложен.
Проверка вхождения значений в список
Иногда бывает важно проверить, содержит ли список некоторое значение, прежде чем выполнять действие. Например, перед завершением регистрации нового пользователя на сайте можно проверить, существует ли его имя в списке имен действующих пользователей, или в картографическом проекте определить, входит ли передаваемое место в список известных мест на карте.
Чтобы узнать, присутствует ли заданное значение в списке, воспользуйтесь ключевым словом in. Допустим, вы пишете программу для пиццерии. Вы создали список дополнений к пицце, заказанных клиентом, и хотите проверить, входят ли некоторые дополнения в этот список.
>>> requested_toppings = ['mushrooms', 'onions', 'pineapple']
(1) >>>'mushrooms' in requested_toppings
True
(2)>>>'pepperoni' in requested_toppings
False
В точках (1) и (2) ключевое слово in приказывает Python проверить, входят ли значения 'mushrooms' и 'pepperoni' в список requested_toppings. Это весьма полезно, потому что вы можете создать список значений, критичных для вашей программы, а затем легко проверить, присутствует ли проверяемое значение в списке.
Проверка отсутствия значения в списке
В других случаях программа должна убедиться в том, что значение не входит в список. Для этого используется ключевое слово not. Для примера рассмотрим список пользователей, которым запрещено писать комментарии на форуме. Прежде чем разрешить пользователю отправку комментария, можно проверить, не был ли пользователь включен в «черный список»:
banned_users.py
banned_users = ['andrew', 'carolina', 'david']
user = 'marie'
(1) if user not in banned_users:
. .print(user.title() + ", you can post a response if you wish.")
Строка (1) достаточно четко читается: если пользователь не входит в «черный список» banned_users, то Python возвращает True и выполняет строку с отступом. Пользователь 'marie' в этот список не входит, поэтому программа выводит соответствующее сообщение:
Marie, you can post a response if you wish.
Логические выражения
В процессе изучения программирования вы рано или поздно услышите термин «логическое выражение». По сути это всего лишь другое название для проверки условия. Результат логического выражения равен True или False, как и результат условного выражения после его вычисления.
Логические выражения часто используются для проверки некоторых условий — например, запущена ли компьютерная игра или разрешено ли пользователю редактирование некоторой информации на сайте:
game_active = True
can_edit = False
Логические выражения предоставляют эффективные средства для контроля состояния программы или определенного условия, играющего важную роль в вашей программе.
Упражнения
5-1. Проверка условий: напишите последовательность условий. Выведите описание каждой проверки и ваш прогноз относительно ее результата. Код должен выглядеть примерно так:
car = 'subaru'
print("Is car == 'subaru'? I predict True.")
print(car == 'subaru')
print("\nIs car == 'audi'? I predict False.")
print(car == 'audi')
• Внимательно просмотрите результаты. Убедитесь в том, что вы понимаете, почему результат каждой строки равен True или False.
• Создайте как минимум 10 условий. Не менее 5 должны давать результат True, а не менее 5 других — результат False.
5-2. Больше условий: количество условий не ограничивается 10. Попробуйте написать другие условия и включить их в conditional_tests.py. Программа должна выдавать по крайней мере один истинный и один ложный результат для следующих видов проверок.
• Проверка равенства и неравенства строк.
• Проверки с использованием функции lower().
• Числовые проверки равенства и неравенства, условий «больше», «меньше», «больше или равно», «меньше или равно».
• Проверки с ключевым словом and и or.
• Проверка вхождения элемента в список.
• Проверка отсутствия элемента в списке.