Генераторні вирази та розуміння списку

Коли слід використовувати генераторні вирази і коли слід використовувати розуміння списку в Python?

# Generator expression
(x*2 for x in range(256))

# List comprehension
[x*2 for x in range(256)]

Відповідь Джона хороша (розуміння цього списку краще, коли ви хочете повторити щось кілька разів). Однак також варто зазначити, що вам слід скористатися списком, якщо ви хочете скористатися будь-яким із методів списку. Наприклад, наступний код не працює:

def gen():
    return (something for something in get_some_stuff())

print gen()[:2]     # generators don't support indexing or slicing
print [5,6] + gen() # generators can't be added to lists

В основному використовуйте генераторний вираз, якщо все, що ви робите, це повторення одного разу. Якщо ви хочете зберігати та використовувати згенеровані результати, то вам, мабуть, краще зрозуміти список.

Оскільки ефективність є найпоширенішою причиною вибору одного за іншим, моя порада - не турбуватися про це, а просто вибрати один; якщо ви виявите, що ваша програма працює занадто повільно, тоді і тільки тоді ви повинні повернутися назад і потурбуватися про налаштування свого коду.

Ітерація над виразом генератора чи розумінням списку зробить те саме. Однак розуміння списку спочатку створить весь список у пам'яті, тоді як вираз генератора створить елементи на льоту, тож ви зможете використовувати його для дуже великих (а також нескінченних!) Послідовностей.

Використовуйте розуміння списку, коли результат потрібно повторювати багаторазово, або коли швидкість є першорядною. Використовуйте вирази генератора, де діапазон великий чи нескінченний.

Щоб отримати докладнішу інформацію, перегляньте вирази генератора та перелічі розумінь .

Важливим моментом є те, що осмислення списку створює новий список. Генератор створює ітерабельний об'єкт, який буде "фільтрувати" вихідний матеріал під час руху, коли ви споживаєте біти.

Уявіть, що у вас є файл журналу 2 ТБ під назвою "величезний файл.txt", і ви хочете, щоб вміст і довжина для всіх рядків, що починаються з слова "ВПІТИ".

Тож ви спробуйте почати, написавши список розуміння:

logfile = open("hugefile.txt","r")
entry_lines = [(line,len(line)) for line in logfile if line.startswith("ENTRY")]

Це розбиває весь файл, обробляє кожен рядок і зберігає відповідні рядки у вашому масиві. Отже, цей масив може містити до 2 ТБ вмісту. Це багато оперативної пам’яті і, мабуть, не практичне для ваших цілей.

Тож замість цього ми можемо використовувати генератор, щоб застосувати "фільтр" до нашого вмісту. Жодні дані насправді не читаються, поки ми не почнемо повторювати результат.

logfile = open("hugefile.txt","r")
entry_lines = ((line,len(line)) for line in logfile if line.startswith("ENTRY"))

З нашого файлу ще не було прочитано жодного рядка. Насправді, скажімо, ми хочемо ще більше відфільтрувати результат:

long_entries = ((line,length) for (line,length) in entry_lines if length > 80)

Все ще нічого не було прочитано, але ми зараз вказали два генератори, які діятимуть на наші дані так, як ми хочемо.

Давайте випишемо наші відфільтровані рядки в інший файл:

outfile = open("filtered.txt","a")
for entry,length in long_entries:
    outfile.write(entry)

Тепер ми читаємо вхідний файл. Оскільки наш forцикл продовжує запитувати додаткові лінії, long_entriesгенератор вимагає від entry_linesгенератора рядків , повертаючи лише ті, довжина яких перевищує 80 символів. А в свою чергу entry_linesгенератор запитує рядки (відфільтровані так, як зазначено) від logfileітератора, який у свою чергу зчитує файл.

Тож замість того, щоб "підштовхувати" дані до своєї функції виводу у вигляді повноцінно заповненого списку, ви надаєте вихідній функції спосіб "тягнути" дані лише тоді, коли це потрібно. Це в нашому випадку набагато ефективніше, але не настільки гнучко. Генератори - це один шлях, один прохід; дані з прочитаного файлу журналу негайно видаляються, тому ми не можемо повернутися до попереднього рядка. З іншого боку, нам не потрібно турбуватися про збереження даних, коли ми закінчимо їх.

Перевага вираження генератора полягає в тому, що він використовує менше пам'яті, оскільки не створює весь список відразу. Генераторні вирази найкраще використовувати, коли список є посередником, наприклад підбиттям результатів або створенням виводу результатів.

Наприклад:

sum(x*2 for x in xrange(256))

dict( (k, some_func(k)) for k in some_list_of_keys )

Перевага полягає в тому, що список не генерується повністю, і, таким чином, використовується мало пам'яті (і також має бути швидше)

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

Наприклад:

reversed( [x*2 for x in xrange(256)] )

Створюючи генератор із об'єкта, що змінюється (наприклад, зі списку), майте на увазі, що генератор оцінюватиметься за станом списку під час використання генератора, а не під час створення генератора:

>>> mylist = ["a", "b", "c"]
>>> gen = (elem + "1" for elem in mylist)
>>> mylist.clear()
>>> for x in gen: print (x)
# nothing

Якщо є шанс зміни вашого списку (або об'єкта, що змінюється, всередині цього списку), але вам потрібен стан при створенні генератора, замість цього потрібно використовувати розуміння списку.

Іноді ви можете піти від функції трійника з itertools , вона повертає кілька ітераторів для одного і того ж генератора, який можна використовувати самостійно.

Я використовую модуль Hadoop Mincemeat . Я думаю, що це чудовий приклад, щоб взяти до відома:

import mincemeat

def mapfn(k,v):
    for w in v:
        yield 'sum',w
        #yield 'count',1


def reducefn(k,v): 
    r1=sum(v)
    r2=len(v)
    print r2
    m=r1/r2
    std=0
    for i in range(r2):
       std+=pow(abs(v[i]-m),2)  
    res=pow((std/r2),0.5)
    return r1,r2,res

Тут генератор отримує числа з текстового файлу (розміром до 15 Гб) і застосовує просту математику до цих чисел, використовуючи зменшення карти Hadoop. Якби я не використовував функцію урожайності, а натомість розуміння списку, знадобилось би набагато більше часу для обчислення сум і середнього рівня (не кажучи вже про складність простору).

Hadoop - прекрасний приклад використання всіх переваг генераторів.