Ilg'or imkoniyatlar

sonlar = range(1, 11)

# Ro'yxat
kvadratlar = [son ** 2 for son in sonlar]

# Shart bilan filtrlash
juftlar = [son for son in sonlar if son % 2 == 0]

# Shartli qiymat (ternar)
belgilar = ["juft" if son % 2 == 0 else "toq" for son in sonlar]

# To'plam - takrorlar yo'qoladi
qoldiqlar = {son % 3 for son in sonlar}

# Lug'at
kublar = {son: son ** 3 for son in range(1, 6)}

print(kvadratlar)
print(juftlar)
print(belgilar[:4])
print(qoldiqlar)
print(kublar)

# Ikki o'lchamli jadvalni yassilash
jadval = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
yassi = [element for qator in jadval for element in qator]
print(yassi)

# Ko'paytirish jadvali
kopaytirish = [[satr * ustun for ustun in range(1, 6)] for satr in range(1, 6)]
for qator in kopaytirish:
    print(qator)

import sys

royxat = [son ** 2 for son in range(1_000_000)]      # kvadrat qavs
generator = (son ** 2 for son in range(1_000_000))   # dumaloq qavs

print(f"Ro'yxat:   {sys.getsizeof(royxat):>10,} bayt")
print(f"Generator: {sys.getsizeof(generator):>10,} bayt")

def fibonachchi(nechta):
    """Fibonachchi ketma-ketligini birma-bir hosil qiladi."""
    oldingi, joriy = 0, 1
    for _ in range(nechta):
        yield oldingi
        oldingi, joriy = joriy, oldingi + joriy


for son in fibonachchi(10):
    print(son, end=" ")
print()

# Ro'yxatga aylantirish ham mumkin
print(list(fibonachchi(15)))

def log_satrlari(yol, kalit_soz):
    """Katta log faylidan faqat kerakli satrlarni birma-bir qaytaradi."""
    with open(yol, "r", encoding="utf-8") as fayl:
        for raqam, satr in enumerate(fayl, start=1):
            if kalit_soz in satr:
                yield raqam, satr.strip()


# 10 GB li faylni ham xotirani to'ldirmasdan o'qiydi
for raqam, satr in log_satrlari("xatolar.log", "ERROR"):
    print(f"{raqam:>5}: {satr}")

class TeskariSanoq:
    """Berilgan sondan nolgacha teskari sanaydi."""

    def __init__(self, boshlanish):
        self.joriy = boshlanish

    def __iter__(self):
        return self

    def __next__(self):
        if self.joriy <= 0:
            raise StopIteration
        self.joriy -= 1
        return self.joriy + 1


for son in TeskariSanoq(5):
    print(son, end=" ")
print("Start!")

import time
from functools import wraps


def vaqtni_olcha(funksiya):
    """Funksiya bajarilish vaqtini o'lchaydi."""

    @wraps(funksiya)
    def orab_oluvchi(*args, **kwargs):
        boshlanish = time.perf_counter()
        natija = funksiya(*args, **kwargs)
        davomiylik = time.perf_counter() - boshlanish
        print(f"  [{funksiya.__name__}] {davomiylik:.4f} soniya")
        return natija

    return orab_oluvchi


@vaqtni_olcha
def katta_yigindi(chegara):
    """Berilgan chegaragacha bo'lgan sonlar yig'indisi."""
    return sum(range(chegara))


natija = katta_yigindi(5_000_000)
print(f"Natija: {natija:,}")

from functools import wraps


def qayta_urin(marta=3):
    """Xato bo'lsa funksiyani belgilangan marta qayta chaqiradi."""
    def dekorator(funksiya):
        @wraps(funksiya)
        def orab_oluvchi(*args, **kwargs):
            for urinish in range(1, marta + 1):
                try:
                    return funksiya(*args, **kwargs)
                except Exception as xato:
                    print(f"  {urinish}-urinish muvaffaqiyatsiz: {xato}")
                    if urinish == marta:
                        raise
        return orab_oluvchi
    return dekorator


def kirish_talab_qilinadi(funksiya):
    """Foydalanuvchi tizimga kirganini tekshiradi."""
    @wraps(funksiya)
    def orab_oluvchi(foydalanuvchi, *args, **kwargs):
        if not foydalanuvchi.get("kirgan"):
            return "Ruxsat yo'q: avval tizimga kiring"
        return funksiya(foydalanuvchi, *args, **kwargs)
    return orab_oluvchi


@kirish_talab_qilinadi
def maxfiy_malumot(foydalanuvchi):
    return f"Salom {foydalanuvchi['ism']}, maxfiy ma'lumot: 42"


mehmon = {"ism": "Noma'lum", "kirgan": False}
egasi = {"ism": "Husanboy", "kirgan": True}

print(maxfiy_malumot(mehmon))
print(maxfiy_malumot(egasi))

from functools import lru_cache


@lru_cache(maxsize=None)
def fibonachchi(son):
    """Keshlash bilan - juda tez."""
    if son < 2:
        return son
    return fibonachchi(son - 1) + fibonachchi(son - 2)


print(fibonachchi(50))
print(fibonachchi.cache_info())

class Sana:
    def __init__(self, kun, oy, yil):
        self.kun, self.oy, self.yil = kun, oy, yil

    @classmethod
    def matndan(cls, matn):
        """Alternativ konstruktor: "08.09.2026" -> Sana obyekti."""
        kun, oy, yil = map(int, matn.split("."))
        return cls(kun, oy, yil)

    @staticmethod
    def kabisa_yilmi(yil):
        """Klass yoki obyektga bog'liq bo'lmagan yordamchi funksiya."""
        return yil % 4 == 0 and (yil % 100 != 0 or yil % 400 == 0)

    def __str__(self):
        return f"{self.kun:02d}.{self.oy:02d}.{self.yil}"


sana = Sana.matndan("08.09.2026")
print(sana)
print(Sana.kabisa_yilmi(2026))
print(Sana.kabisa_yilmi(2028))

import time


class Taymer:
    """Kod blokining bajarilish vaqtini o'lchaydi."""

    def __init__(self, nomi):
        self.nomi = nomi

    def __enter__(self):
        self.boshlanish = time.perf_counter()
        print(f"[{self.nomi}] boshlandi...")
        return self

    def __exit__(self, xato_turi, xato_qiymati, izlar):
        davomiylik = time.perf_counter() - self.boshlanish
        if xato_turi is None:
            print(f"[{self.nomi}] tugadi: {davomiylik:.4f} soniya")
        else:
            print(f"[{self.nomi}] xato bilan tugadi: {xato_qiymati}")
        return False        # xatoni yashirmaymiz


with Taymer("Katta hisob-kitob"):
    jami = sum(son ** 2 for son in range(3_000_000))

print(f"Natija: {jami:,}")

from contextlib import contextmanager
import time


@contextmanager
def taymer(nomi):
    boshlanish = time.perf_counter()
    try:
        yield
    finally:
        print(f"[{nomi}] {time.perf_counter() - boshlanish:.4f} soniya")


with taymer("Saralash"):
    katta_royxat = sorted(range(1_000_000), reverse=True)

from itertools import count, cycle, chain, combinations, groupby

# Cheksiz sanoq
for son in count(10, 5):
    if son > 30:
        break
    print(son, end=" ")
print()

# Bir nechta ro'yxatni ketma-ket aylanish
for element in chain([1, 2], ["a", "b"], (True, False)):
    print(element, end=" ")
print()

# Kombinatsiyalar
jamoa = ["Husanboy", "Sardor", "Malika"]
for juftlik in combinations(jamoa, 2):
    print(" - ".join(juftlik))