Генераторы

Выражение-генератор

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

Генератор списка создает список полностью. И хотя это делается быстрее, чем работают другие эквивалентные конструкции, все равно при итерировании генератора списка требуется ждать, пока весь список не будет создан. Для больших списков необходима соответствующая память. Обратив генератор в выражение, получаем двойной эффект - не требуется ждать, не нужна память для списка. При обращении к выражению создается очередной элемент, и он передается на обработку. В результате не требуется память для хранения всего списка, поскольку генерируемый элемент выдается по требованию. Это большое преимущество при работе с массивными структурами данных.

Синтаксически превратить генератор в выражение элементарно. Достаточно квадратные скобки заменить на круглые.

Семантически выражение-генератор - это итератор, так что применим метод next, цикл for -in позволяет выполнить итерирование, а метод list возвращает список, хотя в этом случае все преимущества выражения теряются, поскольку вся идея состоит в том, чтобы список явно не строить.

Давайте вернемся к нашему примеру построения таблицы истинности логической функции. Когда у функции три переменных, то число значений равно 8, но при десяти переменных - их уже тысяча, а при двадцати - миллион (число значений равно 2^n). Поэтому разумно генератор превратить в выражение-генератор. Вот соответствующий код:

def test5():
    """ Построение таблицы истинности логической функции   
    Генератор-выражение"""
    L = [0, 1]
    gen_T = (x and y or u and v 
            for x in L for y in L for u in L for v in L)
    Print(gen_T)

Приведу результаты запуска этого теста:

Заметьте, в методе Print элементы выводятся на печать без явного построения списка. В содержательной задаче каждый элемент мог бы использоваться сразу же после его создания.

Функции - генераторы

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

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

Синтаксическое отличие такой функции от обычной функции незначительно, - оператор return заменяется оператором yield. Семантика выполнения отличается существенно. Такая функция, возвращая результат, не заканчивает работу, а приостанавливает выполнение, запоминая свое сoстояние. Функция в цикле, получив очередной результат, выдает его и приостанавливает работу до очередного вызова. Давайте приведу код такой функции, а потом подробнее обсудим семантику выполнения функции:

def fun_gen():
    """Функция генератор. Возвращает значение 
       и приостанавливает работу до следующего вызова.
   """
    L = [0, 1]   
    for x in L:
       for y in L:
          for u in L:
             for v in L:
                 yield x and y or u and v

Приведу теперь тест, в котором эта функция вызывается:

def test6():
    for value in fun_gen():
        print(value, end = ' ')
    print()
    values = []
    for value in fun_gen():
        values.append(value)
    Print(values)
    values = list(fun_gen())
    Print(values)

Что происходит, когда в тесте в первом цикле for вызывается функция-генератор fun_gen? В момент вызова начнет работать цикл четырехкратной вложенности. Телом этого цикла является оператор yield, который вычислит значение и вернет его вызывающей программе - test6. Заметьте, функция генератор fun_gen не завершила работу, а только ее приостановила, сохраняя текущее состояние. Цикл for в тесте снова вызовет функцию fun_gen, и она продолжит работу, выдав новое значение. Такой циклический процесс вызова функции- генератора будет продолжаться пока не будет исчерпана коллекция элементов, возвращаемых этой функцией.

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

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

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

def SumMatr(A, B):
    """Сложение квадратных матриц """
    n = len(A)
    LL = []
    for row in range(n):
        L = []
        for col in range(n):            
             L.append(A[row][col] + B[row][col])
        LL.append(L)
    return LL

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

def GenSumMatr(A, B):
    """Сложение квадратных матриц. Генераторы списков"""
    n = len(A)
    L = [[A[row][col] + B[row][col]
          for col in range(n)] for row in range(n)]
    return L  

Можно сделать следующий шаг и обычную функцию GenSumMatr преобразовать в функцию-генератор, возвращающую при каждом вызове очередную строку суммарной матрицы:

def FunGenSumMatr(A, B):
    """
    Сложение квадратных матриц. Функция-генератор
    При каждом вызове возвращается 
    очередная строка суммарной матрицы.
    Возвращаемое значение является генератором списка
    """
    n = len(A)
    for row in range(n):
        yield [A[row][col] + B[row][col] for col in range(n)]
         

Приведу тест, в котором вызываются все приведенные варианты суммирования матриц:

def test7():
    A = [[3, 5, 7], [2, 4, 2], [1, 2, 3]]
    B = [[1, 2, 3], [3, 2, 1], [2, 1, 2]]
    L = SumMatr(A, B)
    Print(L)
    L = GenSumMatr(A,B)
    Print(L)
    for row in FunGenSumMatr(A,B):
        Print(row)

Приведу результаты работы этого теста:

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

Если рассмотреть более интересную задачу умножения матриц, то написать реализацию, использующую генераторы циклов, не представляется возможным. Не всякие циклы, создающие список, можно преобразовать в генератор списков. Когда же это возможно и целесообразно, то в интересах эффективности это стоит делать. Программисты Python любят генераторы списков.