# Python

## Управление потоком исполнения, функции и модули

### Раздел 1. Конструкции для управления потоком исполнения

Мы рассмотрели большую часть конструкций для управления потоком исполнения в лекции 1. Это if-elif-else выражения, циклы while и for ... in. Единственное, что ускользнуло от нашего внимания — условные выражения. Это своего рода ответ на тернарый оператор в языках с C-подобным синтаксисом.

В общем случае условное выражение выглядит так:

*выражение* if *условие* else *альтернатива*

Например:


```python
for i in range(1, 21):
    print("Нечетное" if i & 1 else "Четное")
```

    Нечетное
    Четное
    Нечетное
    Четное
    Нечетное
    Четное
    Нечетное
    Четное
    Нечетное
    Четное
    Нечетное
    Четное
    Нечетное
    Четное
    Нечетное
    Четное
    Нечетное
    Четное
    Нечетное
    Четное


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


```python
for i in range(1, 10):
    pass
```


```python
for i in range(1, 10):
```


      File "<ipython-input-3-6df1f476ba84>", line 1
        for i in range(1, 10):
                              ^
    SyntaxError: unexpected EOF while parsing



Для циклов также есть инструкции, нерасмотренные ранее: continue и break. Инструкция continue переходит на следующий этап выполнения цикла, а инструкция break обрывает его выполнение:


```python
for i in range(1, 21):
    if i & 1:
        continue
    print("Нечетное" if i & 1 else "Четное")
    
print("\n\n\n")
    
for i in range(1, 21):
    if i > 5:
        break
    print("Нечетное" if i & 1 else "Четное")
```

    Четное
    Четное
    Четное
    Четное
    Четное
    Четное
    Четное
    Четное
    Четное
    Четное
    
    
    
    
    Нечетное
    Четное
    Нечетное
    Четное
    Нечетное


После циклов можно писать блок с else, который будет выполнен в случае нормального завершения цикла:


```python
for i in range(1, 21):
    print("Нечетное" if i & 1 else "Четное")
else:
    print("Цикл завершен нормально")
    
print("\n\n\n")
    
for i in range(1, 21):
    if i > 5:
        break
    print("Нечетное" if i & 1 else "Четное")
else:
    print("Цикл завершен нормально")
```

    Нечетное
    Четное
    Нечетное
    Четное
    Нечетное
    Четное
    Нечетное
    Четное
    Нечетное
    Четное
    Нечетное
    Четное
    Нечетное
    Четное
    Нечетное
    Четное
    Нечетное
    Четное
    Нечетное
    Четное
    Цикл завершен нормально
    
    
    
    
    Нечетное
    Четное
    Нечетное
    Четное
    Нечетное


### Раздел 2. Обработка исключений

Исключительные ситуации требуют... исключений! Хотя иногда вы можете столнуться с тем, что некоторые вызовы из сторонних библиотек предполагают анализ обработку ошибок в стиле C (возвращение кода ошибки, запись кода ошибки в глобальную переменную и т.д.), но это очень плохой путь. Большой плюс исключений заключается в том, что вы можете проявлять гибкость при их обработке: разным образом обрабатывать исключения разных групп, вешать один обработчик исключений на очень большие группы исключений, обрабатывать их на любом уровне исполнения и т.д.

Общий синтаксис для ловли и обработки исключений:

```Python
try:
    блок_в_котором_может_возникнуть исключение
except группа_исключений_1 as переменная_1:
    обработка_исключений_1
...
except группа_исключений_N as переменная_N:
    обработка_исключений_N
else:
    блок_который_выполняется_если_исключений_не_было
finally:
    блок_который_выполняется_в_любом_случае
```

Блоки else и finally являются необязательными, но хотя бы один except должен присутствовать. Переменные типа `переменная_N` позволяют доступиться к объекту исключения внутри обработчика.

Блок finally **всегда** выполняется в конце. **Всегда** подразумевает, что даже если у вас есть return внутри одного из блоков-обработчиков, finally выполнится. Как правило, там размещается сохранение временных результатов и очистка ресурсов (например, закрытие соединения с БД).

Все блоки except применяются по очереди. В случае возникновения исключения, сначала первый блок проверяет, подходит ли ему это исключение. "Подходит" означает, что в данном выражении except либо указан класс этого исключения, либо класс-предок класса этого исключения. Если исключение не подходит, то идет проверка по следующему блоку. Таким образом, следующая конструкция не имеет смысла:

```Python
try:
    какой-то_код
except Класс-предок as e1:
    обработка_класса-предка
except Класс-потомок as e2:
    обработка_класса-потомка
```

Всегда будет выполняться обработка класса-предка

Для возбуждения исключения используется инструкция raise:

```Python
raise исключение(аргументы)
raise исключение(аргументы) from исходное_исключение
raise
```

Первая форма возбуждает исключение заданного типа (встроенного или определенного пользователем), который должен быть потомком класса Exception. Вторая и третья форма используются только внутри обработчиков исключений. Вторая форма позволяет возбуждать цепочку исключений, а третья - просто возбуждает то же исключение, которое обрабатывается на данный момент.

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

```Python
class новое_исключение(исключение_предок): pass
```

По сути своей это объявление класса (ООП — тема лекции номер 5), у которого нет тела (инструкция pass). После этого объявления вы сможете ловить данные исключения в обработчиках исключений.

### Раздел 3. Функции, определяемые пользователем

В Python есть четыре вида функций: глобальные, локальные, лямбда-функции и методы.

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

Мы уже видели стандартное определение функции:


```python
def greetings(name, greeting):
    print("{0}, {1}!".format(greeting, name))
    
greetings("Bob", "Hello")
```

    Hello, Bob!


Если мы хотим задать значение по умолчанию какому-либо из аргументов функции, после его имени необходимо поставить = и желаемое значение:


```python
def greetings(name, greeting="Hello"):
    print("{0}, {1}!".format(greeting, name))
    
greetings("John")
```

    Hello, John!


Нужно учитывать, что параметры со значениями по умолчанию **всегда** должны идти после параметров без значений по умолчанию. При вызове функции, можно явно указать параметры, к которым мы обращаемся, тогда их порядок не важен (только необходимо, чтобы были указаны все параметры без значений по умолчанию):


```python
greetings(greeting="Oh hi", name="Mark")
```

    Oh hi, Mark!


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


```python
greetings("Dawg", greeting="What`s up")
```

    What`s up, Dawg!


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

Имена функций и их параметров согласно PEP 8 рекомендуется называть в camel_case. Следует избегать необщепринятых сокращений в именах функций и параметрах. Имена параметров должны отражать суть того, что в них хранится, а имена функци — суть того, что они делают.

Можно задокументировать любую функцию при помощи *docstring* — строки, которая идет после строки с инструкцией def, до любой из инструкций внутри функции:


```python
def greetings(name, greeting="Hello"):
    "Prints greeting"
    print("{0}, {1}!".format(greeting, name))
    
greetings.__doc__
```




    'Prints greeting'



Естественно, этот строковый литерал может содержать несколько строк


```python
def greetings(name, greeting="Hello"):
    """Prints \
greeting"""
    print("{0}, {1}!".format(greeting, name))
    
print(greetings.__doc__)
```

    Prints greeting


С операторами распаковки мы уже знакомы: \* позволяет распаковывать коллекции, а \*\* — словари, например:


```python
lst = ["World", "Hello"]
dct = {"greeting" : "Hi", "name" : "Jim"}

greetings(*lst)
greetings(**dct)
```

    Hello, World!
    Hi, Jim!


#### Анонимные функции

Синтаксис для описания лямбда функций выглядит следующим образом:

```Python
lambda аргументы: выражение
```

Аргументы необязательны, внутри выражения не может содержаться ветвление или циклы, а также инструкции return и yield. При этом можно использовать условные выражения. Результат выражения и является возвращаемым значением лямбда функции. Результатам лямбда-выражения является объект функции:


```python
f = lambda x: "Нечетное" if x & 1 else "Четное"

for i in range(1, 11):
    print(f(i))
```

    Нечетное
    Четное
    Нечетное
    Четное
    Нечетное
    Четное
    Нечетное
    Четное
    Нечетное
    Четное


#### Утверждения

Утверждения (assertions) позволяют проверять, удовлетворяют ли некоторые значения определенным условиям. Синтаксис утверждений следующий:

```Python
assert выражение, необязательное_выражение
```

Если выражение имеет булевое значение True, то программа выполняется в обычном режиме. В противном случае возбуждается исключение AssertionError. Если указано необязательное\_выражение, то оно передается в качестве аргумента AssertionError (полезно для обозначение того, что именно пошло не так). Данные выражения часто используются в тестировании, но, в принципе, можно таким образом проверять корректность, скажем, переданных функции аргументов. Я рекомендуюю в последнем случае все-таки использовать инструкцию throw с более подходящими классами исключений.

Выражения assert можно игнорировать, передав флаг -0 интерпретатору при запуске программы. Также, можно установить переменную окружения PYTHONOPTIMYZE в 0. При передаче флага -00 интерпретатору будут игнорироваться и инструкции assert, и строки документации (docstrings).

#### Доступ к переменным в глобальной области видимости

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


```python
greeting = "Hello"

def greetings(name):
    global greeting
    print("{0}, {1}!".format(greeting, name))
    
greetings("James")
```

    Hello, James!


Также есть возможность указать область видимости nonlocal, тогда будет выбрано значение из ближайшей области видимости, которая находится выше текущей:


```python
name = "Helen"

def greet1():
    name = "Maria"
    def set_name(new_name):
        nonlocal name
        name = new_name
    set_name("Natalia")
    print("Hello, ", name)
    
def greet2():
    name = "Maria"
    def set_name(new_name):
        global name
        name = new_name
    set_name("Natalia")
    print("Hello, ", name)
    

print(name)
greet1()
print(name)
greet2()
print(name)
```

    Helen
    Hello,  Natalia
    Helen
    Hello,  Maria
    Natalia


Как видно, в первом случае доступ был к переменной name области видимости функции greet1, а во втором — к переменной name в глобальной области видимости.

### Раздел 4. Модули

Говоря простым языком, модуль в Python — любой .py файл. Пакет модулей — директория, которая содержит пустой файл \_\_init\_\_.py и некоторое количество .py файлов.

Импортирование имен из модулей происходит посредством инструкции import. Если после инструкции указать имя модуля, то все имена из этого модуля будут доступны через имя\_модуля.идентификатор. Модули можно импортировать, присваивая им новый идентификатор в текущей области имен. Также можно импортировать конкретные идентификаторы из модуля. Сущностям из модуля также можно назначать свои идентификаторы. Чтобы импортировать все идентификаторы из модуля в текущее пространство имен, необходимо указать звездочку (астериск, \*). Вот примеры всех вариантов:


```python
import os
import math as m
from sys import path
from datetime import date, time
from cmath import sin as s
from requests import *
```

Все модули, которые находятся в пакете являются объектами этого пакета. Т.е. если у вас есть директория Server, внутри которой находится файл \_\_init\_\_.py и файл, скажем, Router.py, то последний может быть импортирован следующим образом:


```python
import Server.Router as rt
```

Или:


```python
from Server import Router as rt
```

Предположим, что вы хотите из модуля Router пакета Server обратиться к модулю Templates того же пакета. Тогда пакет будет доступен по имени . (текущая директория):


```python
form . import Templates as tmpl
```

### Раздел 5. Решение домашнего задания

Рассмотрим решение [задачи](https://lambda-it.ru/post/27).

Наиболее эффективное и наглядное ее решение — сведение ее к [задаче поиска наибольшей общей подстроки](https://ru.wikipedia.org/wiki/%D0%9D%D0%B0%D0%B8%D0%B1%D0%BE%D0%BB%D1%8C%D1%88%D0%B0%D1%8F_%D0%BE%D0%B1%D1%89%D0%B0%D1%8F_%D0%BF%D0%BE%D0%B4%D1%81%D1%82%D1%80%D0%BE%D0%BA%D0%B0).

Для написания нашего решения обратимся к одному из классов разреженных матриц, которые предложены в модуле scipy.sparse. Поскольку наша матрица будет в основном содержать значение 0, то имеет смысл выбрать класс dok_matrix:


```python
from scipy.sparse import dok_matrix as M
```

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


```python
def longest_common_subsequence(a, b):
    n = len(a)
    m = len(b)
    x = 1
    y = 1
    maximum = 0
    row_based = n >= m
    
    matrix = M((n + 1, m + 1))
    
    for i in range(1, n + 1):
        for j in range(1, m + 1):
            if a[i-1] == b[j-1]:
                matrix[i, j] = matrix[i-1, j-1] + 1
                tmp = matrix[i, j]
                if tmp > maximum:
                    maximum = tmp
                    x = i
                    y = j
    maximum = int(maximum)
    return a[x - maximum:x] if row_based else b[y - maximum: y]
```


```python
print(longest_common_subsequence([1, 2, 3, 4, 5, 6, 0], [1, 4, 5, 6, 7, 8]))
```

    [4, 5, 6]


### Раздел 6. Домашнее задание

Прочитать главы 4 и 5 Саммерфилда, выполнить упражнения после них

Самостоятельно изучить раздел 5 главы, посвященный стандартной библиотеке Python.

Переписать игру "быки и коровы", разделив ее на 3 модуля: основной, в котором описан интерфейс командной строки и логика игры, модуль, в котором содержатся функции связанные с вариантом, когда компьютер угадывает, и модуль, в котором содержатся функции, связанные с вариантом, когда угадывает игрок.

Решить задачу, которая будет опубликована в субботу.