for dövrü siyahılarla, sətirlərlə, lüğətlərlə, fayllarla, range və zip ilə işləyir — hətta yaddaşa heç vaxt sığmayacaq 10 GB-lıq log faylı ilə də. Bir dövr bu qədər müxtəlif obyekti necə gəzə bilir? Cavab iterasiya protokoludur — for ilə onun gəzdiyi obyektlər arasında kiçik bir razılaşma. Onu başa düşəndən sonra qiymətləri yalnız lazım olanda yaradan obyektlər yazacaqsan, sonsuz verilənlər axınlarını emal edəcəksən və yaddaşa qənaət edən emal konveyerləri quracaqsan. Bunun əsas aləti Python-un ən güclü imkanlarından biri olan generatorlardır.
İterasiya olunan obyekt və iterator
İterasiya olunan obyekt və iteratorTərif
İterasiya olunan obyekt (iterable) iterator verə bilən istənilən obyektdir: onun __iter__() metodu var (siyahılar, sətirlər, lüğətlər, çoxluqlar, fayllar, range). İterator isə qiymətləri faktiki olaraq bir-bir verən obyektdir: onun __next__() metodu növbəti qiyməti qaytarır, qiymətlər qurtaranda isə StopIteration istisnası qaldırır. Daxili iter(x) və next(it) funksiyaları sadəcə bu iki metodu çağırır.
for-un bizim üçün gördüyü işi əl ilə görək. iter() siyahıdan iterator istəyir, hər next() isə onu bir addım irəli aparır. Qiymətlər bitəndə iterator xüsusi qiymət qaytarmır — **StopIteration** istisnası qaldırır:
colors = ['red', 'green', 'blue']
it = iter(colors)
print(type(it).__name__)
print(next(it))
print(next(it))
print(next(it))
try:
next(it)
except StopIteration:
print('StopIteration: the iterator is exhausted')Gözlənilən nəticə
list_iterator red green blue StopIteration: the iterator is exhausted
Deməli, for dövrü əslində StopIteration görünənə qədər next() çağıran while dövrüdür. Aşağıda for-un işləyən imitasiyası var. O, sətirlə də, lüğətlə də eyni cür işləyir, çünki hər ikisi iterasiya olunandır (lüğəti gəzəndə onun açarları alınır):
def my_for(iterable, action):
it = iter(iterable)
while True:
try:
item = next(it)
except StopIteration:
break
action(item)
my_for('abc', print)
my_for({'x': 1, 'y': 2}, print)Gözlənilən nəticə
a b c x y
Praktikada iki detal vacibdir. Birincisi, iteratorun özü də iterasiya olunandır: onun __iter__() metodu self qaytarır, buna görə for x in it yazmaq olur. İkincisi, iterator birdəfəlikdir: o, yalnız irəli gedir və geri qaytarıla bilmir. Siyahı hər dəfə soruşanda yeni iterator verir, zip, map, filter, fayllar və generatorlar isə özləri iteratordur:
pairs = zip(['Aysel', 'Murad'], [91, 78])
print(list(pairs))
print(list(pairs))
nums = [1, 2, 3]
print(iter(nums) is iter(nums))
it = iter(nums)
print(iter(it) is it)Gözlənilən nəticə
[('Aysel', 91), ('Murad', 78)]
[]
False
TrueDavamını oxumaq üçün pulsuz qeydiyyatdan keç
Dərsin qalan bölmələri, test və qeydlər Educora hesabı ilə açılır. Qeydiyyat bir dəqiqə çəkir; irəliləyişin bütün cihazlarında saxlanılır.
Öz iterator sinfin
__iter__ və __next__ metodları olan istənilən sinif for dövründə, list() və sum() funksiyalarında, açma (unpacking) əməliyyatında — bir sözlə, iterasiya olunan obyekt qəbul edən hər yerdə işləyir. Budur geri sayım:
class Countdown:
def __init__(self, start):
self.current = start
def __iter__(self):
return self
def __next__(self):
if self.current <= 0:
raise StopIteration
value = self.current
self.current -= 1
return value
for n in Countdown(3):
print(n)
print(list(Countdown(5)))Gözlənilən nəticə
3 2 1 [5, 4, 3, 2, 1]
Kod işləyir, amma sadə ideya üçün çox «mərasim» tələb edir: vəziyyəti self.current-də əl ilə saxlamalı, StopIteration-ı özümüz qaldırmalı olduq. Generatorlar eyni işi xeyli az kodla görür.
Generatorlar: dayana bilən funksiyalar
İçində **yield sözü olan funksiya generator funksiyasıdır. Onu çağıranda gövdəsi icra olunmur — funksiya generator obyekti** qaytarır, bu obyekt isə iteratordur. Hər next() gövdəni növbəti yield-ə qədər icra edir, qiyməti verir və funksiyanı bütün lokal dəyişənləri ilə birlikdə dondurur. Növbəti next() işi dayandığı yerdən davam etdirir. Funksiya sona çatanda generator avtomatik olaraq StopIteration qaldırır.
def countdown(start):
print('start')
while start > 0:
yield start
start -= 1
print('done')
gen = countdown(2)
print(type(gen).__name__)
print(next(gen))
print(next(gen))
print(next(gen, 'no more values'))Gözlənilən nəticə
generator start 2 1 done no more values
start sözü countdown(2) çağırılanda yox, yalnız ilk next()-də çap olundu. next(gen, default) isə StopIteration əvəzinə susmaya görə qiyməti qaytarır.Bunu Countdown sinfi ilə müqayisə et: eyni davranış beş sətirdə, vəziyyət (start) isə adi lokal dəyişəndir. Generator funksiyası çağırılanda heç nə icra olunmadığı üçün onun içindəki xətalar da yalnız ilk next()-də üzə çıxır.
Tənbəl hesablama: qiymətlər tələb olunduqca
Generatorlar tənbəldir (lazy): qiyməti yalnız kimsə onu istəyəndə hesablayırlar. Generator ifadəsi — dairəvi mötərizədə yazılmış generator — siyahı generatorunun tənbəl əkizidir. Aşağıdakı siyahı bir milyon ədəd saxlayır (64 bitlik kompüterdə təxminən 8 MB), generator obyekti isə ardıcıllığın uzunluğundan asılı olmayaraq cəmi 200 bayta yaxın yer tutur. Amma unutma: o, birdəfəlikdir.
import sys
squares_list = [n * n for n in range(1_000_000)]
squares_gen = (n * n for n in range(1_000_000))
print(sys.getsizeof(squares_list) > 1_000_000)
print(sys.getsizeof(squares_gen) < 500)
print(sum(squares_gen))
print(sum(squares_gen))Gözlənilən nəticə
True True 333332833333500000 0
| Xüsusiyyət | Siyahı generatoru [...] | Generator ifadəsi (...) |
|---|---|---|
| Nə vaxt hesablanır | hamısı dərhal | hər element tələb olunanda |
| Yaddaş | bütün elementlər | bir dəfəyə bir element |
| Təkrar gəzmək | istənilən qədər | yalnız bir dəfə |
len() və indeks | var | yoxdur |
| Sonsuz ardıcıllıq | mümkün deyil | mümkündür |
Tənbəllik iki güclü üsulu mümkün edir. Sonsuz generator tamamilə normaldır — yetər ki, ondan lazım olan qədər qiymət götürəsən (itertools.islice ilk n qiyməti götürür). Generatorlar zənciri isə emal konveyeri yaradır: hər mərhələ əvvəlkindən bir dəfəyə bir element çəkir, ona görə də neçə gigabaytlıq fayl olsa belə, demək olar ki, sabit yaddaşla sətir-sətir emal olunur:
from itertools import islice
def naturals():
n = 1
while True:
yield n
n += 1
evens = (n for n in naturals() if n % 2 == 0)
print(list(islice(evens, 5)))
with open('server.log', 'w', encoding='utf-8') as f:
f.write('INFO start\nERROR disk full\nINFO ok\nERROR timeout\nWARN slow\n')
with open('server.log', encoding='utf-8') as f:
lines = (line.rstrip('\n') for line in f)
errors = (line for line in lines if line.startswith('ERROR'))
messages = (line.split(' ', 1)[1] for line in errors)
for msg in messages:
print(msg)Gözlənilən nəticə
[2, 4, 6, 8, 10] disk full timeout
yield from və ikitərəfli generatorlar
yield from iterable başqa iterasiya olunan obyektin — o cümlədən başqa generatorun — bütün qiymətlərini bir-bir ötürür. Bu, rekursiya üçün təbii alətdir, məsələn, istənilən dərinlikdə iç-içə siyahıları «düzləşdirmək» üçün:
def flatten(items):
for item in items:
if isinstance(item, list):
yield from flatten(item)
else:
yield item
data = [1, [2, 3, [4, 5]], [], [[6]], 7]
print(list(flatten(data)))Gözlənilən nəticə
[1, 2, 3, 4, 5, 6, 7]
yield from həm də ifadədir: onun qiyməti alt generatorun return ilə qaytardığı qiymətdir. yield-in özü də ifadədir — generator.send(value) generatoru davam etdirir və yield ifadəsi həmin qiyməti alır. Beləliklə, generator yalnız verilən yaratmır, həm də verilən qəbul edə bilir. İlk send()-dən əvvəl generator next() ilə birinci yield-ə qədər işə salınmalıdır:
def numbers(values):
total = 0
for v in values:
yield v
total += v
return total
def pipeline():
subtotal = yield from numbers([1, 2, 3])
print('subtotal:', subtotal)
yield from 'ab'
print(list(pipeline()))Gözlənilən nəticə
subtotal: 6 [1, 2, 3, 'a', 'b']
def running_average():
total, count = 0, 0
average = None
while True:
value = yield average
total += value
count += 1
average = total / count
avg = running_average()
next(avg)
print(avg.send(10))
print(avg.send(20))
print(avg.send(60))Gözlənilən nəticə
10.0 15.0 30.0
total, count) çağırışlar arasında saxlayır — bunun üçün sinif yazmaq lazım olmadı.Tapşırıq
chunks(items, size) generatorunu yaz: o, ardıcıllığı size uzunluqlu hissələrə bölüb onları bir-bir versin (sonuncu hissə daha qısa ola bilər). Kəsiklər sayəsində funksiya həm siyahı, həm də sətirlə işləməlidir.
def chunks(items, size):
# yield slices of `size` items; the last one may be shorter
...
print(list(chunks([1, 2, 3, 4, 5, 6, 7], 3)))
print(list(chunks('abcde', 2)))Gözlənilən nəticə
[[1, 2, 3], [4, 5, 6], [7]] ['ab', 'cd', 'e']
Tapşırıq
Fibonaççi ədədlərini (0, 1, 1, 2, 3, 5, …) sonsuza qədər verən fibonacci() generatorunu yaz və islice ilə ilk 10 ədədi çap et.
from itertools import islice
def fibonacci():
# yield 0, 1, 1, 2, 3, 5, ... forever
...
print(list(islice(fibonacci(), 10)))Gözlənilən nəticə
[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
Yadda saxla
forbir dəfəiter()çağırır, sonraStopIterationgörünənə qədərnext()çağırır.- İterasiya olunan obyektin
__iter__-i, iteratorun isə həm də__next__-i var; iterator birdəfəlikdir. yieldolan funksiya çağırılanda generator qaytarır; gövdə tənbəlcə, həryield-də dayanaraq icra olunur.- Generator ifadəsi
( ... )sabit yaddaş tutur, siyahı generatoru[ ... ]isə bütün siyahını qurur. yield fromişi başqa iterasiya olunan obyektə ötürür və alt generatorunreturnqiymətini qaytarır.