Генераторы и цикл for

Цикл for.

Цикл for может использоваться для различных целей.

Самый простой пример использования цикла:

for i in range(5):
    print(i)

0
1
2
3
4

При помощи этого цикла можно итерироваться по любому объекту-коллекции:

lst = ["qwerty", 12345, 34.42]

for i in lst:
    print(i)

qwerty
12345
34.42

Но в таком случае встает вопрос, что же общего между объектом-коллекцией и диапазоном значений? range является функцией. Попробуем посмотреть, что эта функция возвращает:

a = range(5)

print("object:\n\t", a)
print("type:\n\t", type(a))
print("Methods and attributes:\n\t", dir(a))

object:
     range(0, 5)
type:
     <class 'range'>
Methods and attributes:
     ['__bool__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'count', 'index', 'start', 'step', 'stop']

То есть range -- это класс и мы вызываем его конструктор. Объект этого класса является итерируемым, а значит с ним может работать цикл for. Чтобы создать итератор из объекта, воспользуемся функцией iter():

iterator = iter(a)

print("object:\n\t", iterator)
print("type:\n\t", type(iterator))
print("Methods and attributes:\n\t", dir(iterator))

object:
     <range_iterator object at 0x0000012FA12F9CF0>
type:
     <class 'range_iterator'>
Methods and attributes:
     ['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__length_hint__', '__lt__', '__ne__', '__new__', '__next__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__setstate__', '__sizeof__', '__str__', '__subclasshook__']

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

Для того, чтобы перейти к следующему состоянию, используется функция next().

print(next(iterator))
print(next(iterator))
print(next(iterator))
print(next(iterator))
print(next(iterator))

0
1
2
3
4

Но что же происходит, когда мы пытаемся получить следующий объект, но его не существует?

next(iterator)

---------------------------------------------------------------------------

StopIteration                             Traceback (most recent call last)

<ipython-input-19-4ce711c44abc> in <module>()
----> 1 next(iterator)


StopIteration:

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

def print_map(function, iterable):
    for i in iterable:
        print(function(i))

Генераторы

Рассмотрим несколько примеров итерируемых объектов, которые есть в языке python (кроме range).

map(function, iterable)

В начале рассмотрим функцию map(func, iterable). Эта функция позволяет применить некоторую другую функцию func ко всем элементам другого итерируемого объекта iterable. Обратите внимание, что объект-функция передается без круглых скобок

def baz(value):
    return value * value

lst = [1, 2, 3, 4, 5]

for i in map(baz, lst):
    print(i)

1
4
9
16
25

zip(iterable[, iterable, ...])

Функция zip(iterable[, iterable, ...]) позволяет параллельно итерироваться по большому количеству итерируемых объектов, получая из них соответствующие элементы в виде кортежа. Итератор прекращает свою работу, когда один из переданных объектов закончится.

names = ["Alex", "Bob", "Alice", "John", "Ann"]
age = [25, 17, 34, 24, 42]
sex = ["M", "M", "F", "M", "F"]

for values in zip(names, age, sex):
    print("name: {:>10} age: {:3} sex: {:2}".format(*values))

name:       Alex age:  25 sex: M
name:        Bob age:  17 sex: M
name:      Alice age:  34 sex: F
name:       John age:  24 sex: M
name:        Ann age:  42 sex: F

filter(func, iterable)

Пробегает по итерируемому объекту и возвращает только те элементы, которые удовлетворяют условию, описанному в функции func.

def bar(x):
    if abs((34-x*x))**0.5 > x:
        return True
    return False

for i in filter(bar, [0, 1, 2, 3, 4, 5]):
    print(i)

0
1
2
3
4

enumerate(iterable, start=0)

Принимает на вход итерируемый объект и возвращает пары (индекс элемента, элемент). Индексация начинается со start, который по умолчанию равен 0.

names = ["Alex", "Bob", "Alice", "John", "Ann"]

for idx, elem in enumerate(names, 1):
    print("{:02}: {:>7}".format(idx, elem))

01:    Alex
02:     Bob
03:   Alice
04:    John
05:     Ann

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

Для этих целей может использоваться ключевое слово yield. Функция, в которой содержится это ключевое слово, становится функцией-генератором. Из такой функции можно создать объект-итератор. При вызове функции next() выполнение этой функции дойдет до первого встреченного ключевого слова yield, после чего, подобно действию return, управление перейдет основной программе. Поток управления вернется обратно в функцию при следующем вызове next() и продолжит выполнение с того места, на котором остановился ранее.

Рассмотрим, каким образом можно написать свою собственную функцию range():

def my_range(a, b=None, step=1):
    if b is None:
        a, b = 0, a
    _current = a
    while True:
        yield _current
        _next = _current + step
        if (_next - b)*(_current - b) <= 0:
            break
        _current = _next

for i in my_range(5):
    print(i, end = " ")
print()

for i in my_range(1, 5):
    print(i, end = " ")
print()

for i in my_range(1, 10, 2):
    print(i, end = " ")
print()

for i in my_range(10, 0, -3):
    print(i, end = " ")
print()

0 1 2 3 4
1 2 3 4
1 3 5 7 9
10 7 4 1

def get_cartesian_product(a, b):
    raise RuntimeError("Not implemented")

get_cartesian_product([1, 2], [3, 4]) == [(1, 3), (1, 4), (2, 3), (2, 4)]

def get_permutations(s, n):
    raise RuntimeError("Not implemented")

get_permutations("cat", 2) == ["ac", "at", "ca", "ct", "ta", "tc"]

def get_combinations(s, n):
    raise RuntimeError("Not implemented")

get_combinations("cat", 2) == ["a", "c", "t", "ac", "at", "ct"]

def get_combinations_with_r(s, n):
    raise RuntimeError("Not implemented")

get_combinations_with_r("cat", 2) == ["aa", "ac", "at", "cc", "ct", "tt"]

def compress_string(s):
    raise RuntimeError("Not implemented")

compress_string('1222311') == [(1, 1), (3, 2), (1, 3), (2, 1)]

def maximize(lists, m):
    raise RuntimeError("Not implemented")

lists = [
    [5, 4],
    [7, 8, 9],
    [5, 7, 8, 9, 10]
]
maximize(lists, m=1000) == 206