Comprehension'lar, iteratorlar va generatorlar

# Odatiy sikl
kvadratlar = []
for x in range(10):
    kvadratlar.append(x ** 2)
 
# Comprehension — bir xil natija
kvadratlar = [x ** 2 for x in range(10)]

[ IFODA   for ELEMENT in ITERABLE   if SHART ]
   ↑          ↑                        ↑
 nima       nimadan                 qaysilarini
 qo'yish    olish                   (ixtiyoriy)

juftlar = [x for x in range(20) if x % 2 == 0]
ismlar = [ism.strip().title() for ism in xom_ismlar if ism.strip()]
uzunliklar = [len(s) for s in so_zlar]

[x for x in sonlar if x > 0]              # filtr: musbatlarni OLADI (kam element)
[x if x > 0 else 0 for x in sonlar]       # ifoda: manfiylarni 0 ga ALMASHTIRADI (element soni o'zgarmaydi)

matritsa = [[1, 2, 3], [4, 5, 6]]
tekis = [x for qator in matritsa for x in qator]     # [1, 2, 3, 4, 5, 6]

tekis = []
for qator in matritsa:        # birinchi for
    for x in qator:           # ikkinchi for
        tekis.append(x)

so_zlar = ["olma", "nok", "uzum"]
 
{s: len(s) for s in so_zlar}               # {'olma': 4, 'nok': 3, 'uzum': 4}
{v: k for k, v in lug_at.items()}          # lug'atni teskari aylantirish
{k: v for k, v in config.items() if v is not None}   # None qiymatlarni olib tashlash
{x % 3 for x in range(10)}                 # {0, 1, 2} — set

def build_params(model: str, max_tokens: int, temperature: float | None = None,
                 top_p: float | None = None) -> dict:
    params = {"model": model, "max_tokens": max_tokens,
              "temperature": temperature, "top_p": top_p}
    return {k: v for k, v in params.items() if v is not None}
 
build_params("claude-opus-5-5", 1024)   # {'model': 'claude-opus-5-5', 'max_tokens': 1024}

x = "tashqi"
kv = [x for x in range(3)]
print(x)          # 'tashqi' — comprehension ichidagi x tashqariga "oqib chiqmaydi"

mevalar = ["olma", "nok"]
it = iter(mevalar)
next(it)        # 'olma'
next(it)        # 'nok'
next(it)        # StopIteration
next(it, "tugadi")   # 'tugadi' — standart qiymat bilan xato chiqmaydi

it = iter(mevalar)
while True:
    try:
        meva = next(it)
    except StopIteration:
        break
    print(meva)

juftlar = zip([1, 2, 3], "abc")    # zip — iterator
print(list(juftlar))               # [(1, 'a'), (2, 'b'), (3, 'c')]
print(list(juftlar))               # [] — tugab bo'lgan!

kv = (x * x for x in range(3))     # generator ifodasi — iterator
print(sum(kv))                     # 5
print(sum(kv))                     # 0 — "bo'sh" generator, xato yo'q!

def hisobla():
    print("boshlandi")
    yield 1
    print("o'rtada")
    yield 2
    print("tugadi")
 
 
g = hisobla()           # hech narsa chiqmaydi — kod hali ishlamadi
for v in g:
    print("olindi", v)

boshlandi
olindi 1
o'rtada
olindi 2
tugadi

import sys
 
ro_yxat = [x * x for x in range(1_000_000)]
gen = (x * x for x in range(1_000_000))
 
sys.getsizeof(ro_yxat)   # ~8 400 000 bayt (8 MB, va bu faqat ko'rsatkichlar!)
sys.getsizeof(gen)       # ~200 bayt — hajmdan qat'i nazar

import json
from collections.abc import Iterator
 
 
def read_jsonl(path: str) -> Iterator[dict]:
    """JSONL faylni qatorma-qator o'qiydi — fayl hajmi xotiraga ta'sir qilmaydi."""
    with open(path, encoding="utf-8") as f:
        for line_no, line in enumerate(f, 1):
            line = line.strip()
            if not line:
                continue
            try:
                yield json.loads(line)
            except json.JSONDecodeError:
                print(f"⚠️ {line_no}-qator buzilgan, o'tkazib yuborildi")
 
 
def filter_long(records: Iterator[dict], min_len: int) -> Iterator[dict]:
    for r in records:
        if len(r.get("text", "")) >= min_len:
            yield r
 
 
def batched(items: Iterator[dict], size: int) -> Iterator[list[dict]]:
    batch = []
    for item in items:
        batch.append(item)
        if len(batch) == size:
            yield batch
            batch = []
    if batch:
        yield batch
 
 
# Pipeline: hech qaysi qadam butun faylni xotiraga yuklamaydi
records = read_jsonl("dataset.jsonl")
long_records = filter_long(records, min_len=200)
for batch in batched(long_records, size=32):
    process(batch)       # masalan, modelga yuborish

def fibonacci():
    a, b = 0, 1
    while True:            # cheksiz — lekin muammo emas, chunki dangasa
        yield a
        a, b = b, a + b
 
from itertools import islice
list(islice(fibonacci(), 10))    # [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]

def flatten(nested):
    for item in nested:
        if isinstance(item, list):
            yield from flatten(item)    # ichki generatorning hamma qiymatlarini uzatadi
        else:
            yield item
 
list(flatten([1, [2, [3, 4]], 5]))   # [1, 2, 3, 4, 5]

sum(x * x for x in range(10))                  # funksiyaning yagona argumenti bo'lsa, qo'shimcha qavs shart emas
any(line.startswith("ERROR") for line in log)  # birinchi topilganda to'xtaydi!
max(len(s) for s in so_zlar)
", ".join(str(x) for x in sonlar)

list(map(str.upper, ["a", "b"]))          # ['A', 'B']
list(filter(lambda x: x > 0, [-1, 2, 3])) # [2, 3]
list(filter(None, [0, 1, "", 2]))         # [1, 2] — falsy'larni olib tashlaydi

import itertools as it
 
it.count(10, 5)                    # 10, 15, 20, ... (cheksiz)
it.cycle("ab")                     # a, b, a, b, ... (cheksiz)
it.repeat("x", 3)                  # x, x, x
it.islice(gen, 5)                  # iteratordan "slice" — birinchi 5 tasi
it.chain([1, 2], [3])              # 1, 2, 3 — ketma-ket ulash
it.chain.from_iterable(ro_yxatlar) # ro'yxatlar ro'yxatini tekislash
it.batched(range(7), 3)            # (0, 1, 2), (3, 4, 5), (6,) — Python 3.12+
it.pairwise([1, 2, 3, 4])          # (1, 2), (2, 3), (3, 4) — Python 3.10+
it.accumulate([1, 2, 3, 4])        # 1, 3, 6, 10 — yig'ma yig'indi
it.zip_longest([1, 2], [1], fillvalue=0)   # (1, 1), (2, 0)
it.takewhile(lambda x: x < 3, [1, 2, 5, 1])   # 1, 2 — shart buzilguncha

it.product("ab", [0, 1])          # ('a', 0), ('a', 1), ('b', 0), ('b', 1)
it.combinations([1, 2, 3], 2)     # (1, 2), (1, 3), (2, 3)
it.permutations([1, 2, 3], 2)     # (1, 2), (1, 3), (2, 1), ... — tartib muhim

grid = {
    "lr": [1e-4, 3e-4, 1e-3],
    "batch_size": [16, 32],
    "dropout": [0.1, 0.3],
}
 
keys = list(grid)
for values in it.product(*grid.values()):
    params = dict(zip(keys, values))
    print(params)       # 3 * 2 * 2 = 12 ta kombinatsiya

[(k, list(g)) for k, g in it.groupby("aaabbc")]
# [('a', ['a', 'a', 'a']), ('b', ['b', 'b']), ('c', ['c'])]

import numpy as np
 
sonlar = list(range(1_000_000))
sum(x * x for x in sonlar)          # ~25–50 ms (kompyuterga bog'liq)
 
arr = np.arange(1_000_000)
(arr * arr).sum()                   # ~1 ms