Wyrażenia generatora a zrozumienie listy

Kiedy należy używać wyrażeń generatora, a kiedy używać wyrażeń list w Pythonie?

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

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

Odpowiedź Johna jest dobra (ta lista jest lepsza, gdy chcesz powtórzyć coś wiele razy). Warto jednak zauważyć, że powinieneś użyć listy, jeśli chcesz użyć dowolnej z metod listy. Na przykład następujący kod nie będzie działać:

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

Zasadniczo użyj wyrażenia generatora, jeśli wszystko, co robisz, to iteracja raz. Jeśli chcesz przechowywać wygenerowane wyniki i korzystać z nich, prawdopodobnie lepiej jest zapoznać się z listą.

Ponieważ wydajność jest najczęstszym powodem wyboru jednego spośród drugiego, radzę nie martwić się o to i po prostu wybrać jedno; jeśli okaże się, że twój program działa zbyt wolno, wtedy i tylko wtedy powinieneś wrócić i martwić się o dostrojenie kodu.

Iteracja wyrażeniem generatora lub zrozumieniem listy zrobi to samo. Jednak zrozumienie listy utworzy najpierw całą listę w pamięci, podczas gdy wyrażenie generatora utworzy elementy w locie, dzięki czemu będziesz mógł używać jej do bardzo dużych (a także nieskończonych!) Sekwencji.

Używaj wyrażeń z listy, gdy wynik musi być wielokrotnie powtarzany lub gdy szybkość jest najważniejsza. Używaj wyrażeń generatora, gdy zakres jest duży lub nieskończony.

Aby uzyskać więcej informacji, zobacz Wyrażenia generatora i opisy list .

Ważną kwestią jest to, że analiza listy tworzy nową listę. Generator tworzy iterowalny obiekt, który „filtruje” materiał źródłowy „w locie”, gdy zużywasz bity.

Wyobraź sobie, że masz plik dziennika o wielkości 2 TB o nazwie „ogromny_plik.txt” i potrzebujesz zawartości i długości wszystkich wierszy rozpoczynających się od słowa „WEJŚCIE”.

Więc zacznij od napisania listy ze zrozumieniem:

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

Spowalnia to cały plik, przetwarza każdą linię i przechowuje pasujące linie w tablicy. Ta tablica może zatem zawierać do 2 TB treści. To dużo pamięci RAM i prawdopodobnie nie jest praktyczne dla twoich celów.

Zamiast tego możemy użyć generatora, aby zastosować „filtr” do naszych treści. Żadne dane nie są odczytywane, dopóki nie zaczniemy iteracji nad wynikiem.

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

Nawet żaden wiersz nie został jeszcze odczytany z naszego pliku. Powiedzmy, że chcemy jeszcze bardziej filtrować nasz wynik:

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

Wciąż nic nie zostało przeczytane, ale określiliśmy teraz dwa generatory, które będą działały na naszych danych, jak chcemy.

Wypiszmy nasze przefiltrowane linie do innego pliku:

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

Teraz czytamy plik wejściowy. Ponieważ nasza forpętla nadal żąda dodatkowych linii, long_entriesgenerator żąda linii od entry_linesgeneratora, zwracając tylko te, których długość jest większa niż 80 znaków. Z kolei entry_linesgenerator żąda wierszy (filtrowanych jak wskazano) z logfileiteratora, który z kolei odczytuje plik.

Dlatego zamiast „wypychać” dane do funkcji wyjściowej w postaci w pełni wypełnionej listy, dajesz funkcji wyjściowej sposób „wyciągania” danych tylko wtedy, gdy jest to potrzebne. W naszym przypadku jest to o wiele bardziej wydajne, ale nie tak elastyczne. Generatory są jednokierunkowe, jedno przejście; dane z odczytanego pliku dziennika są natychmiast odrzucane, więc nie możemy wrócić do poprzedniej linii. Z drugiej strony nie musimy martwić się o przechowywanie danych, gdy skończymy.

Zaletą wyrażenia generatora jest to, że zużywa mniej pamięci, ponieważ nie buduje całej listy jednocześnie. Wyrażeń generatora najlepiej używać, gdy lista jest pośrednikiem, takim jak sumowanie wyników lub tworzenie dykta z wyników.

Na przykład:

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

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

Zaletą jest to, że lista nie jest w pełni generowana, a zatem używana jest niewielka pamięć (i powinna być również szybsza)

Powinieneś jednak używać wyrażeń listowych, gdy pożądanym produktem końcowym jest lista. Nie będziesz zapisywać żadnych pamięci za pomocą wyrażeń generatora, ponieważ chcesz wygenerowaną listę. Korzyścią jest także możliwość korzystania z dowolnej z funkcji listy, takich jak sortowanie lub odwracanie.

Na przykład:

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

Podczas tworzenia generatora ze zmiennego obiektu (takiego jak lista) należy pamiętać, że generator zostanie oceniony na podstawie stanu listy w momencie korzystania z generatora, a nie w momencie tworzenia generatora:

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

Jeśli istnieje szansa, że ​​twoja lista zostanie zmodyfikowana (lub zmienny obiekt na tej liście), ale potrzebujesz stanu przy tworzeniu generatora, musisz zamiast tego użyć interpretacji listy.

Czasami możesz uciec od funkcji tee z itertools , zwraca ona wiele iteratorów dla tego samego generatora, z których można korzystać niezależnie.

Używam modułu Hadoop Mincemeat . Myślę, że to świetny przykład na zanotowanie:

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

Tutaj generator pobiera liczby z pliku tekstowego (nawet 15 GB) i stosuje prostą matematykę na tych liczbach, korzystając z funkcji zmniejszania map przez Hadoop. Gdybym nie użył funkcji plonu, ale zamiast zrozumienia listy, obliczenie sum i średniej zajęłoby znacznie więcej czasu (nie wspominając o złożoności przestrzeni).

Hadoop jest doskonałym przykładem wykorzystania wszystkich zalet generatorów.