Iteratorlar va generatorlar

Nimalarni örganasiz
- Iterable va iterator orasidagi farq hamda
forsikliiter()vanext()dan qanday foydalanişi - Iterator klassini qanday yoziş va nega generator körinişidagi
__iter__uni qayta işlatiladigan qiladi yieldbilan generator funksiyalarni qanday yoziş- Nega generatorlar lazy (qiymatlarni faqat söralganda hosil qiladi) hisoblanadi va bu çeksiz ketma-ketliklarga qanday imkon beradi
- Katta fayllar uçun generator konveyerlarini qanday quriş
Nega bu muhim
Toşkentdagi gavjum onlayn dökonning log fayli 20 million qatordan iborat bölişi mumkin. Uni röyxatga yuklasangiz, dasturingizga xotira yetmay qolişi mumkin. Generator bilan esa qatorlarni birma-bir öqiysiz, tozalaysiz va filtrlaysiz, xotira sarfi esa juda kiçik bölib qoladi. Iteratorlarni tuşunsangiz, for sikli aslida nima qilişini ham tuşunasiz.
Iterable va iteratorlar
Röyxatlar, satrlar, luğatlar va range() - takrorlanuvçi obyektlar (iterable): ular böylab aylaniş mumkin. Iterator esa aylanişni amalda bajaradi: u qayerda turganini eslab qoladi va keyingi elementni beradi.
| Iterable | Iterator | |
|---|---|---|
| Misollar | list, str, dict, set, range | iter() qaytaradigan narsa, fayllar, generatorlar |
| Özining örnini eslab qoladimi? | ||
next() bilan işlaydimi? | ||
| Köp marta aylanib çiqiş mumkinmi? | , u tugab qoladi |
Örnatilgan iter() iterable ni iteratorga aylantiradi, next() esa iteratordan bitta element söraydi. Heç narsa qolmaganda next() StopIteration çaqiradi yoki, agar berilgan bölsa, standart qiymatni qaytaradi:
cities = ["Toşkent", "Samarqand"]
it = iter(cities)
print(type(it))
print(next(it))
print(next(it))
print(next(it, "boşqa şahar yöq"))<class 'list_iterator'>
Toşkent
Samarqand
boşqa şahar yöqRöyxat özgarmadi; iterator u böylab xatçöp kabi harakatlandi.
for sikli qanday işlaydi
for sikli - iter(), next() va StopIteration ning qulay sintaksisga öralgan körinişi. for price in prices: print(price) aynan quyidagini bajaradi:
prices = [15000, 8000, 22000]
it = iter(prices)
while True:
try:
price = next(it)
except StopIteration:
break
print(price)15000
8000
22000Iterator faqat oldinga yuradi. Barça elementlarni berib bölgaç, u tugagan (exhausted) hisoblanadi, yaʼni butunlay böşab qoladi:
scores = [90, 85, 97]
it = iter(scores)
print(list(it))
print(list(it)) # iterator allaqaçon tugagan
print(sum(scores)) # röyxatning özi joyida[90, 85, 97]
[]
272Fayllar, generatorlar hamda map(), filter() va zip() natijalari ham iterator hisoblanadi va xuddi şunday tugab qoladi.
Öz iterator klassingizni yoziş
Operatorlar va konteynerlar darsida __iter__ ni körgansiz. Töliq iterator klassida ikkita metod bor: __iter__ iteratorni qaytaradi (iterator uçun bu self), __next__ esa keyingi qiymatni qaytaradi yoki StopIteration çaqiradi:
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
countdown = Countdown(3)
print(list(countdown))
print(list(countdown))[3, 2, 1]
[]Ikkinçi aylaniş böş. Countdown özining iteratori hisoblanadi, şuning uçun joriy örin obyektning özida saqlanadi va bitta aylaniş uni tugatadi. Röyxat bunday işlamaydi: har bir sikl iter() dan yangi iterator oladi. Keyingi bölimdagi generatorlar buni tuzatişni osonlaştiradi.
yield li generator funksiyalar
Generator funksiya return örniga yield dan foydalanadi. Uni çaqirganda funksiya tanasi bajarilmaydi. Çaqiruv generator obyektini qaytaradi, generator obyekti esa iteratordir. yield qiymatni beradi va funksiyani pauza qiladi, keyingi next() çaqiruvi esa uni aynan yield dan keyingi joydan davom ettiradi:

def make_tea():
print(" [suv qaynatiladi]")
yield "suv tayyor"
print(" [çoy barglari solinadi]")
yield "çoy tortildi"
print(" [funksiya tugaydi]")
steps = make_tea()
print("Generator yaratildi, hali heç narsa işlamadi")
print(next(steps))
print(next(steps))
print(next(steps, "boşqa qadam yöq"))Generator yaratildi, hali heç narsa işlamadi
[suv qaynatiladi]
suv tayyor
[çoy barglari solinadi]
çoy tortildi
[funksiya tugaydi]
boşqa qadam yöqUçinçi next() funksiyani oxirigaça bajardi, şuning uçun generator StopIteration çaqirdi va next standart qiymatni qaytardi. Python lokal özgaruvçilar va örinni siz uçun saqlab turadi, şuning uçun teskari sanoq bir neçta qatorda yoziladi:
def countdown(start):
current = start
while current > 0:
yield current
current -= 1
print(list(countdown(3)))[3, 2, 1]Qayta işlatiladigan iterable klass
Endi Countdown uçun tuzatiş: faqat boşlanğiç qiymatni saqlang va __iter__ ni generator metod qilib yozing. Har bir sikl __iter__ ni qaytadan çaqiradi va xuddi röyxatdagidek yangi generator oladi:
class Countdown:
def __init__(self, start):
self.start = start
def __iter__(self):
current = self.start
while current > 0:
yield current
current -= 1
countdown = Countdown(3)
print(list(countdown))
print(list(countdown))[3, 2, 1]
[3, 2, 1]Klassni for sikli bilan aylanib çiqiladigan qilişning odatiy usuli aynan şu.
Generatorlar lazy
Röyxat barça elementlarini hozirning özida xotirada saqlaydi. Generator esa faqat joriy holatini saqlaydi va har bir elementni söralganda hosil qiladi. Ularning ölçamlarini sys.getsizeof() bilan soliştirib köring:
import sys
numbers_list = [n * n for n in range(1_000_000)]
numbers_gen = (n * n for n in range(1_000_000))
print(f"röyxat: {sys.getsizeof(numbers_list):>9,} bayt")
print(f"generator: {sys.getsizeof(numbers_gen):>9,} bayt")
print(sum(numbers_gen))röyxat: 8,448,728 bayt
generator: 208 bayt
333332833333500000Bayt sonlari Python versiyalari va platformalarga qarab farq qiladi (bu saytdagi muharrir 32-bitli yiğmada işlaydi, şuning uçun undagi sonlar taxminan ikki barobar kiçik), lekin röyxat megabaytlarni, generator esa qança element hosil qilişidan qatʼi nazar, bir-ikki yuz baytni egallaydi. (... for ...) şakli Comprehension ifodalari darsidagi generator ifodasi.
Qiymatlar talab bölganda yaratilgani uçun generator hatto çeksiz işlaşi mumkin. itertools.islice faqat birinçi bir neçta elementni oladi:
from itertools import islice
def fibonacci():
a, b = 0, 1
while True:
yield a
a, b = b, a + b
print(list(islice(fibonacci(), 10)))[0, 1, 1, 2, 3, 5, 8, 13, 21, 34]Katta fayllar uçun generator konveyerlari
Generatorlarni zanjir qilib ulaş mumkin: har bir qadam iterable oladi va qayta işlangan elementlarni yield qiladi, şuning uçun bitta qator keyingi qator hali öqilmasdan barça qadamlardan ötib boradi. Fayl obyekti allaqaçon qatorlar böyiça iterator, şuning uçun heç narsa birdaniga xotiraga yuklanmaydi:
from pathlib import Path
Path("sales.txt").write_text(
"Toşkent,çoy,15000\n"
"\n"
"Samarqand,somsa,8000\n"
"Toşkent,qahva,45000\n"
"buzuq qator\n",
encoding="utf-8",
)
def read_lines(path):
with open(path, encoding="utf-8") as file:
for line in file:
yield line.strip()
def skip_blank(lines):
for line in lines:
if line:
yield line
def parse_sales(lines):
for line in lines:
parts = line.split(",")
if len(parts) != 3:
print(f" taşlab ketildi: {line!r}")
continue
city, product, amount = parts
yield {"city": city, "product": product, "amount": int(amount)}
sales = parse_sales(skip_blank(read_lines("sales.txt"))) # hali heç narsa öqilmadi
tashkent = (sale["amount"] for sale in sales if sale["city"] == "Toşkent")
print(f"Toşkent jami: {sum(tashkent):,} söm") taşlab ketildi: 'buzuq qator'
Toşkent jami: 60,000 sömsum() butun konveyerni harakatga keltiradi: u söragan har bir qiymat barça qadamlardan ötib keladi. Har bir funksiya juda kiçik, uni röyxat ustida testlaş oson va u 10 gigabaytlik faylda ham işlaydi. len() yoki indekslaş kerak bölsa, yoki natijani bir neça marta aylanib çiqiş kerak bölsa, generator örniga röyxat işlating.
Özingiz sinab köring
Boşqa şahar böyiça filtrlang yoki 10,000 sömdan katta summalarni qoldiradigan qadam qöşing.
Köp uçraydigan xatolar
1. Tugagan iterator böylab ikki marta aylaniş
evens = (n for n in range(10) if n % 2 == 0)
print(sum(evens))
print(max(evens, default="heç narsa qolmadi"))20
heç narsa qolmadisum() generatorni tugatib qöydi. Tuzatiş: qiymatlar ikki marta kerak bölsa, röyxat yarating.
2. Röyxatga next() ni çaqiriş
cities = ["Toşkent", "Buxoro"]
print(next(cities))TypeError: 'list' object is not an iteratorRöyxat iterable, lekin iterator emas. Tuzatiş: next(iter(cities)).
3. with içidan generator qaytariş
def read_lines(path):
with open(path, encoding="utf-8") as file:
return (line.strip() for line in file)
for line in read_lines("cities.txt"):
print(line)ValueError: I/O operation on closed file.return with blokidan çiqib ketadi, bu esa sikl bitta qatorni ham öqimasdan oldin faylni yopadi. Tuzatiş: konveyerdagi read_lines kabi with bloki içida yield qiling, şunda qiymatlar tortib olinayotganda fayl oçiq turadi.
Maşqlar
1. Qölda sikl
for siklisiz, while sikli içida iter() va next() dan foydalanib, "Samarqand" ning har bir harfini - bilan ajratib çiqaring.
Yeçim
it = iter("Samarqand")
letters = []
while True:
try:
letters.append(next(it))
except StopIteration:
break
print("-".join(letters))S-a-m-a-r-q-a-n-d2. Juft sonlar generatori
0 dan limit gaça (u ham kiradi) juft sonlarni yield qiladigan evens(limit) generator funksiyasini yozing. list(evens(10)) ni çiqaring.
Yeçim
def evens(limit):
n = 0
while n <= limit:
yield n
n += 2
print(list(evens(10)))[0, 2, 4, 6, 8, 10]3. Bölaklar
Bir martada size ta elementdan iborat röyxatlarni yield qiladigan chunks(items, size) generatorini yozing (oxirgi bölak qisqaroq bölişi mumkin). U bilan 7 ta talaba ismini 3 kişilik guruhlarga böling.
Yeçim
def chunks(items, size):
chunk = []
for item in items:
chunk.append(item)
if len(chunk) == size:
yield chunk
chunk = []
if chunk:
yield chunk
names = ["Aziza", "Bekzod", "Dilnoza", "Farrux", "Malika", "Jasur", "Nodira"]
for i, group in enumerate(chunks(names, 3), start=1):
print(f"{i}-guruh: {group}")1-guruh: ['Aziza', 'Bekzod', 'Dilnoza']
2-guruh: ['Farrux', 'Malika', 'Jasur']
3-guruh: ['Nodira']Oxirgi if chunk: qolgan elementlarni yield qiladi.
4. Joriy balans
Har bir tranzaksiyadan keyingi balansni yield qiladigan running_balance(start, transactions) generatorini yozing. start=100000 va [-25000, 40000, -60000, 15000] tranzaksiyalari uçun har bir balansni çiqaring.
Yeçim
def running_balance(start, transactions):
balance = start
for amount in transactions:
balance += amount
yield balance
for balance in running_balance(100000, [-25000, 40000, -60000, 15000]):
print(f"{balance:>8,} söm") 75,000 söm
115,000 söm
55,000 söm
70,000 söm5. Log konveyeri
Yeçimdagi app.log faylini yozing. Tozalangan qatorlarni öqiydigan, faqat ERROR qatorlarini qoldiradigan va faqat xabarning özini yield qiladigan generatorlar konveyerini quring. Har bir xabarni, xatolar sonini va next() bilan topilgan birinçi xatoni çiqaring.
Yeçim
from pathlib import Path
Path("app.log").write_text(
"2026-09-01 INFO foydalanuvçi kirdi\n"
"2026-09-01 ERROR tölov amalga oşmadi\n"
"\n"
"2026-09-02 ERROR karta rad etildi\n"
"2026-09-03 WARNING sekin javob\n",
encoding="utf-8",
)
def read_lines(path):
with open(path, encoding="utf-8") as file:
for line in file:
yield line.strip()
def errors_only(lines):
for line in lines:
parts = line.split(" ", 2)
if len(parts) == 3 and parts[1] == "ERROR":
yield parts[2]
messages = list(errors_only(read_lines("app.log")))
for message in messages:
print("-", message)
print("Xatolar:", len(messages))
first = next(errors_only(read_lines("app.log")), None)
print("Birinçi xato:", first)- tölov amalga oşmadi
- karta rad etildi
Xatolar: 2
Birinçi xato: tölov amalga oşmadisplit(" ", 2) köpi bilan ikki marta böladi, şuning uçun xabar öz böşliqlarini saqlab qoladi. next() faqat birinçi xato qatorigaça öqiydi.
Xulosa
- Iterable böylab aylaniş mumkin; iterator esa öz örnini eslab qoladi,
next()bilan işlaydi va bir marta aylanişdan keyin tugaydi. foriter()ni bir marta, keyinStopIterationgaçanext()ni çaqiradi.yieldli funksiya har biryieldda pauza qiladi va keyingi sörovda davom etadi. Generator körinişidagi__iter__klassni sikl bilan köp marta aylanib çiqiş imkonini beradi.- Generatorlar lazy: xotira sarfi juda kam, iş faqat kerak bölganda bajariladi, hatto çeksiz ketma-ketliklar ham mumkin (bir neçtasini
islicebilan oling). - Kiçik generatorlar zanjiri katta fayllar uçun konveyer hosil qiladi;
yieldniwithbloki içida saqlang.