Введение в тему
В программировании мы сталкиваемся с необходимостью управлять потоком выполнения программы. Это означает, что нужно ответить на вопрос: какую часть кода и сколько раз выполнить в данный момент. По сути, именно эта часть программирования является его сердцем. В этом уроке мы будем отвечать на первый вопрос. Для этого используют так называемые условные операторы.
Зачем нужны условные инструкции
Сила и важность условных операторов в том, что большая часть логики описывается именно с их помощью. Они делают одну простую, но очень важную вещь: говорят интерпретатору Питона какую часть кода выполнять (какую не выполнять) в зависимости от какого-либо условия. Эти конструкции можно вкладывать друг в друга. Это называется логическим ветвлением. Однако, стоит проявлять особую осторожность с вложенностью: каждый новый уровень вложенности увеличивает сложность кода. Сложнее читать (понимать), выше вероятность допустить ошибку.
Как работает if else
Синтаксис
Условный оператор в Python следует широко распространённому в других языках программирования синтаксису: if else. Самый простой пример:
if True:
print("Всё правильно")
# Вывод:
Всё правильно
Давайте рассмотрим, что же здесь произошло:
1. Сперва указывается if с которого начинается оператор.
2. После if указывается условие. Если значение истинно, то выполняется код, следующий в «теле» оператора. В данном случае мы, вместо условия, указали сразу True (истина).
3. Двоеточие после условия обязательно.
4. Тело оператора – инструкции, которые будут выполнены в случае истинности условия.
У этого оператора есть и расширенные возможности. Если вам нужно выполнить другой код, но только если условие ложно, используйте else:
if 1 == 2:
print("Всё правильно")
else:
print("Да нет же!")
# Вывод:
Да нет же!
В теле оператора может быть сколько угодно строк:
i = 0
if i == 0:
print("Число равно нулю")
print("И на него нельзя делить")
else:
print("На такое число делить можно")
print("Так как оно не равно нулю")
# Вывод:
Число равно нулю
И на него нельзя делить
Другими словами, выполнение программы доходит до проверки условия в операторе, а затем перенаправляется в необходимый блок кода, который будет выполняться строка за строкой до самого конца блока. Остальные блоки оператора игнорируются.
Отступы
Одной из отличительных черт языка Python является использование отступов для выделения блоков кода. Такой подход имеет ряд преимуществ и главным из них является визуальная чистота. Отступы представляют из себя пробелы или табуляции в начале строк:
# начало кода
# код
# код
# код
# первый блок кода
# код
# код
# второй блок кода
# код
# код
# конец второго блока
# конец первого блока
# продолжение основного кода
Если отступы одинакового размера и следуют строка за строкой, интерпретатор языка идентифицирует их как единый программный блок.
# Начало основного потока
# выполнения программы
яблоки = 5
груши = 10
if яблоки < груши:
# Входим в первый блок
print('Яблок меньше чем груш')
if груши > 7:
# Входим во второй блок
print('И груш больше семи')
print('Варим компот из груш')
else:
# Входим в третий блок
print('Но груш меньше семи')
print('Варим компот из яблок и груш')
else:
# Входим в четвёртый блок
print('Груш меньше чем яблок')
print('Варим компот из яблок')
# Вывод:
Яблок меньше чем груш
И груш больше семи
Варим компот из груш
И так, варьируя ширину отступов, мы можем создавать различные структуры вложенности блоков.
Примеры
Давайте рассмотрим несколько примеров из реального, «боевого» кода:
Пример №1: класс для парсинга интернет-страниц:
# coding=utf-8
from pathlib import Path
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
from selenium.webdriver.firefox.options import Options
from selenium.webdriver.support import expected_conditions as ec
from selenium.webdriver.support.wait import WebDriverWait
class ObjSel:
def __init__(self):
pass
def __enter__(self):
return self
def init(self, adress, headless=True):
options = Options()
setattr(options, 'headless', headless)
caps = DesiredCapabilities().FIREFOX
caps["pageLoadStrategy"] = 'normal' # Ждём полной загрузки страницы. Если не хотим ждать- > "eager"
self.driver = webdriver.Firefox(capabilities=caps,
firefox_options=options,
executable_path=Path('geckodriver.exe'), )
self.vars = {}
self.driver.implicitly_wait(10)
self.driver.get(adress)
def web_manager(self, name, manager_type='element'):
if name is None:
print('Wrong name')
if manager_type == 'element':
if name.get('By.XPATH'):
return self.driver.find_element(By.XPATH, name['By.XPATH'])
elif name.get('By.CSS_SELECTOR'):
return self.driver.find_element(By.CSS_SELECTOR, name['By.CSS_SELECTOR'])
elif manager_type == 'clickable':
if name.get('By.XPATH'):
return WebDriverWait(self.driver, 3).until(
ec.element_to_be_clickable((By.XPATH, name['By.XPATH'])))
elif name.get('By.CSS_SELECTOR'):
return WebDriverWait(self.driver, 3).until(
ec.element_to_be_clickable((By.CSS_SELECTOR, name['By.CSS_SELECTOR'])))
elif manager_type == 'elements':
if name.get('By.XPATH'):
return self.driver.find_elements(By.XPATH, name['By.XPATH'])
elif name.get('By.CSS_SELECTOR'):
return self.driver.find_elements(By.CSS_SELECTOR, name['By.CSS_SELECTOR'])
def __exit__(self, exc_type, exc_val, exc_tb):
if 'driver' in self.__dict__.keys():
print("Удаление экземпляра Selenium")
self.driver.quit()
Здесь Вы можете увидеть несколько примеров использования условных операторов.
Пример №2: ниже приведена функция модуля queue из стандартной библиотеки. Эта функция получает значение из очереди:
def get(self, block=True, timeout=None):
with self.not_empty:
if not block:
if not self._qsize():
raise Empty
elif timeout is None:
while not self._qsize():
self.not_empty.wait()
elif timeout < 0:
raise ValueError("'timeout' must be a non-negative number")
else:
endtime = time() + timeout
while not self._qsize():
remaining = endtime - time()
if remaining <= 0.0:
raise Empty
self.not_empty.wait(remaining)
item = self._get()
self.not_full.notify()
return item
Оператор elif
Логика бывает не только бинарной, но и множественной. К примеру, что если дальнейшее выполнение программы зависит от одного из четырёх вариантов? Во многих языках программирования (особенно, старых) принято эту задачу решать так:
i = 4
if i == 1:
print("Один")
else:
if i == 2:
print("Два")
else:
if i == 3:
print("Три")
else:
if i == 4:
print("Четыре")
# Вывод:
Четыре
Но, такой код, как мы уже говорили, создаёт сложности в дальнейшем сопровождении из-за глубоких уровней вложенности. К счастью, Пайтон предоставляет более совершенный инструмент: elif. Перепишем предыдущий код:
i = 4
if i == 1:
print("Один")
elif i == 2:
print("Два")
elif i == 3:
print("Три")
elif i == 4:
print("Четыре")
# Вывод:
Четыре
Так получается нагляднее, не так ли?
Этих условий может быть не ограниченное количество. Они перебираются по очереди, пока одно из условий не окажется верным. После этого поток управления передаётся в тело elif, а после его выполнения выходит из условного оператора.
Заглушка pass
В теле условного оператора обязательно что-то должно быть указано. Если Вы хотите пропустить какое-то условие, Вы можете использовать оператор-заглушку pass.
Такой подход чаще всего используют при разработке на стадии прототипирования.
глаза = "голубые"
характер = "мягкий"
if глаза == "карие":
print('Познакомлюсь')
elif глаза == "голубые":
if характер == "мягкий":
print('Женюсь!')
else:
pass
else:
pass
# Вывод:
Женюсь!
if else в одну строку
В Python предусмотрена возможность записывать условный оператор в одну строку:
Что делать если Да if Условие else Что делать если Нет
Пример:
стакан = 1
print("Быть") if стакан / 2 >= 0.5 else print("Не быть")
# Вывод:
Быть
Но эту конструкцию стоит использовать только для простых условий и действий. Почему? Если её использовать для более сложных вещей, читаемость кода очень сильно падает. Как Вы думаете, что выведет следующий код:
x = 15
print(x // 7) if x % 3 >= 5 else print(x) if x % 4 < 2 else print(x * -1)
# Вывод:
?
Конструкция switch case
На момент написания этого урока, всё сообщество питонистов ждёт выход релиза Python 3.10. В этой версии, кроме прочего, появится, хорошо знакомое программистам из других языков, структурное сопоставление с шаблоном или switch/case. В Питоне же эта конструкция будет выглядеть как match/case. Сопоставление подразумевает определение при операторе match искомого значения, после которого можно перечислить несколько потенциальных кейсов, каждый с оператором case. В месте обнаружения совпадения между match и case выполняется соответствующий код. Пример из документации:
match x:
case host, port:
mode = "http"
case host, port, mode:
pass
охренный пример
без описания
так ото