Python kursi7.11-dars: Funksiya — birinchi darajali obyekt
Python kursi · Funksiyalar

7.11-dars: Funksiya — birinchi darajali obyekt

33 daqiqa11/14-dars

7-QISM — FUNKSIYALAR · 11-dars


1. Kirish va motivatsiya

1-darsda ko'rdik: funksiya — obyekt. Endi bu nima berishini ko'ramiz.

Birinchi darajali obyekt (first-class object) — obyekt bilan qilish mumkin bo'lgan hamma narsani qila oladigan qiymat:

python
def salom(): return "Salom!"

f = salom                       # o'zgaruvchiga
r = [salom, print, len]         # ro'yxatga
d = {"salom": salom}            # lug'atga
def g(h): return h()            # argument sifatida
def k(): return salom           # qaytarish qiymati
salom.versiya = "1.0"           # atribut qo'shish

Bu — Pythonning eng kuchli xususiyatlaridan biri. Uning ustiga qurilgan:

python
sorted(r, key=len)              # funksiya argument
@dekorator                      # funksiya → funksiya
map(f, r)                       # funksiya argument
defaultdict(list)               # funksiya sukut qiymat
callback lar, plaginlar, ro'yxatga olish tizimlari

Lekin nozikliklar bor:

python
class A:
    def metod(self): return 1

A.metod                         # <function A.metod>
A().metod                       # <bound method A.metod>
A.metod(A())                    # 1
A().metod()                     # 1

Bu darsda:

  • Birinchi darajali obyekt nima demak
  • Funksiya atributlari va __dict__
  • Yuqori tartibli funksiyalar (higher-order)
  • callable obyektlar: __call__, metodlar, sinflar
  • Dispatch jadvallari va ro'yxatga olish
  • functools: partial, wraps, singledispatch

2. Nazariya — chuqur tushuntirish

2.1. Nima qilish mumkin

1. O'zgaruvchiga bog'lash:

python
def salom(): return "Salom!"

f = salom
f()                             # "Salom!"
f is salom                      # True — bir obyekt

2. Konteynerga solish:

python
amallar = [len, str, abs]
[f(-5) for f in amallar]        # ❌ len(-5) xato

AMALLAR = {"+": operator.add, "-": operator.sub}
AMALLAR["+"](2, 3)              # 5

3. Argument sifatida uzatish:

python
def qoll(f, x):
    return f(x)

qoll(abs, -5)                   # 5
qoll(len, "abc")                # 3

4. Qaytarish:

python
def kopaytiruvchi(n):
    def ichki(x):
        return x * n
    return ichki

5. Ichma-ich aniqlash:

python
def tashqi():
    def ichki(): ...
    return ichki

6. Atribut qo'shish:

python
def f(): ...
f.chaqiruvlar = 0
f.metadata = {"versiya": "1.0"}

7. Solishtirish va hashlash:

python
f is g                          # ✅ identiklik
{f, g}                          # ✅ to'plamda
{f: "izoh"}                     # ✅ lug'at kaliti

Nima MUMKIN EMAS:

python
f < g                           # ❌ TypeError — tartib yo'q
f + g                           # ❌
len(f)                          # ❌
f[0]                            # ❌

2.2. Funksiya atributlari

python
def f(a: int, b: str = "x") -> bool:
    """Docstring."""
    return True

Standart atributlar:

Atribut Ma'nosi
__name__ Nom
__qualname__ To'liq nom (Sinf.metod)
__doc__ Docstring
__module__ Modul nomi
__defaults__ Pozitsion sukutlar
__kwdefaults__ Faqat nomli sukutlar
__annotations__ Tur ko'rsatkichlari
__code__ Kod obyekti
__globals__ Modul nom fazosi
__closure__ Yopilma hujayralari
__dict__ Foydalanuvchi atributlari
__wrapped__ @wraps qo'ygan asl funksiya

O'z atributingizni qo'shish:

python
def f(): ...
f.chaqiruvlar = 0
f.__dict__                      # {'chaqiruvlar': 0}

Bu — dekoratorlarda keng ishlatiladi:

python
def sanagich(f):
    @wraps(f)
    def ichki(*a, **kw):
        ichki.chaqiruvlar += 1
        return f(*a, **kw)
    ichki.chaqiruvlar = 0
    ichki.tozala = lambda: setattr(ichki, "chaqiruvlar", 0)
    return ichki

__code__ ichida:

python
f.__code__.co_name              # 'f'
f.__code__.co_varnames          # ('a', 'b')
f.__code__.co_argcount          # 2
f.__code__.co_consts            # konstantalar
f.__code__.co_filename          # fayl
f.__code__.co_firstlineno       # qator

__globals__ — havola, nusxa emas:

python
def f():
    return X

f.__globals__ is globals()      # True (bir modulda)

Shuning uchun funksiya global o'zgaruvchining joriy qiymatini ko'radi.

2.3. Yuqori tartibli funksiyalar

Yuqori tartibli funksiya — funksiyani argument sifatida oladi yoki qaytaradi.

Standart kutubxonadan:

python
sorted(r, key=f)
map(f, r)
filter(f, r)
min(r, key=f), max(r, key=f)
functools.reduce(f, r)
functools.partial(f, *args)
functools.lru_cache(f)
defaultdict(f)

O'z yuqori tartibli funksiyangiz:

python
def takrorla(f, n):
    """f ni n marta chaqiradi."""
    return [f() for _ in range(n)]


def qoll_hammaga(f, malumot):
    return [f(x) for x in malumot]


def kompozitsiya(*funksiyalar):
    """f(g(h(x)))"""
    def natija(x):
        for f in reversed(funksiyalar):
            x = f(x)
        return x
    return natija


def quvur(*funksiyalar):
    """h(g(f(x))) — teskari tartib"""
    def natija(x):
        for f in funksiyalar:
            x = f(x)
        return x
    return natija

Dekorator — yuqori tartibli funksiyaning eng muhim namunasi:

python
def dekorator(f):               # funksiya oladi
    def ichki(*a, **kw):
        return f(*a, **kw)
    return ichki                # funksiya qaytaradi

10-qismda batafsil.

2.4. callable obyektlar

Funksiya — chaqiriladigan obyektlarning bir turi. Boshqalari:

python
callable(len)                   # True — funksiya
callable(str)                   # True — sinf
callable(str.upper)             # True — metod
callable("abc".upper)           # True — bog'langan metod
callable(lambda: 1)             # True
callable(print)                 # True — ichki funksiya
callable(5)                     # False
callable("abc")                 # False

__call__ bilan sinf:

python
class Kopaytiruvchi:
    def __init__(self, n):
        self.n = n

    def __call__(self, x):
        return x * self.n


ikkilash = Kopaytiruvchi(2)
ikkilash(5)                     # 10
callable(ikkilash)              # True

Funksiya vs __call__ sinf:

Funksiya (yopilma) __call__ sinf
Holat __closure__ self atributlari
Holatga kirish Qiyin obj.n
Holatni o'zgartirish nonlocal obj.n = 5
repr <function> Sozlash mumkin
Meros
Xotira Kamroq Ko'proq
Tezlik Tezroq Sekinroq

Metodlar:

python
class A:
    def metod(self): return 1
    @staticmethod
    def statik(): return 2
    @classmethod
    def sinf_metodi(cls): return 3


A.metod                         # <function A.metod>       — oddiy funksiya
A().metod                       # <bound method A.metod>   — bog'langan
A.statik                        # <function A.statik>
A.sinf_metodi                   # <bound method A.sinf_metodi>

Bog'langan metod (bound method):

python
a = A()
m = a.metod
m()                             # 1 — self avtomatik uzatiladi
m.__self__ is a                 # True
m.__func__ is A.metod           # True

a.metod har murojaatda yangi obyekt yaratadi:

python
a.metod is a.metod              # False!
a.metod == a.metod              # True

8-qismda batafsil.

2.5. Dispatch jadvallari

if/elif zanjiri o'rniga lug'at:

python
# ❌ Uzun zanjir
def hisobla(amal, a, b):
    if amal == "+":
        return a + b
    elif amal == "-":
        return a - b
    elif amal == "*":
        return a * b
    ...

# ✅ Dispatch jadvali
AMALLAR = {
    "+": operator.add,
    "-": operator.sub,
    "*": operator.mul,
    "/": operator.truediv,
}

def hisobla(amal, a, b):
    f = AMALLAR.get(amal)
    if f is None:
        raise ValueError(f"Noma'lum amal: {amal}")
    return f(a, b)

Afzalliklari:

  • O(1) qidiruv (elif zanjiri O(n))
  • Yangi amal qo'shish — bir qator
  • Ro'yxatni dinamik kengaytirish mumkin
  • Test qilish oson

Ro'yxatga olish dekoratori:

python
AMALLAR = {}

def royxatga_ol(nom):
    def dekorator(f):
        AMALLAR[nom] = f
        return f
    return dekorator


@royxatga_ol("+")
def qosh(a, b):
    return a + b


@royxatga_ol("-")
def ayir(a, b):
    return a - b

functools.singledispatch — tur bo'yicha:

python
from functools import singledispatch

@singledispatch
def formatla(x):
    return str(x)

@formatla.register
def _(x: int):
    return f"{x:,}"

@formatla.register
def _(x: list):
    return ", ".join(map(formatla, x))

formatla(1234)                  # '1,234'
formatla([1, 2])                # '1, 2'

match/case bilan solishtirish (5.12-dars):

python
match amal:
    case "+": return a + b
    case "-": return a - b

match — statik naqshlar uchun, dispatch jadvali — dinamik uchun.

2.6. functools

partial — qisman qo'llash:

python
from functools import partial

def kuch(asos, daraja):
    return asos ** daraja

kvadrat = partial(kuch, daraja=2)
ikki_darajasi = partial(kuch, 2)

kvadrat(5)                      # 25
ikki_darajasi(10)               # 1024

partial ichida:

python
kvadrat.func                    # kuch
kvadrat.args                    # ()
kvadrat.keywords                # {'daraja': 2}

partial — funksiya emas:

python
type(kvadrat)                   # <class 'functools.partial'>
callable(kvadrat)               # True
kvadrat.__name__                # ❌ AttributeError

partialmethod — metodlar uchun:

python
from functools import partialmethod

class Hujjat:
    def _holat(self, holat):
        self.holat = holat

    yoq = partialmethod(_holat, "yoqilgan")
    ochir = partialmethod(_holat, "o'chirilgan")

wraps — metadata ko'chirish (7.5-dars).

reduce — 12-darsda.

cache / lru_cache:

python
from functools import cache, lru_cache

@cache                          # 3.9+, cheksiz
def fib(n): ...

@lru_cache(maxsize=128)
def qimmat(x): ...

cached_property:

python
from functools import cached_property

class A:
    @cached_property
    def qimmat_hisob(self):
        return ogir_amal()      # bir marta hisoblanadi

2.7. Amaliy naqshlar

1. Strategiya (Strategy pattern):

python
def qayta_ishla(malumot, strategiya=sorted):
    return strategiya(malumot)

2. Callback:

python
def yukla(url, muvaffaqiyat, xato=None):
    try:
        natija = _yukla(url)
        muvaffaqiyat(natija)
    except Exception as x:
        if xato:
            xato(x)

3. Plagin tizimi:

python
PLAGINLAR = []

def plagin(f):
    PLAGINLAR.append(f)
    return f

4. Middleware zanjiri:

python
def zanjir(*middleware):
    def qoll(sorov):
        for m in middleware:
            sorov = m(sorov)
        return sorov
    return qoll

5. Kechiktirilgan hisoblash:

python
kechiktirilgan = partial(qimmat_hisob, malumot)
# ... keyinroq ...
natija = kechiktirilgan()

6. Funksiyalarni saralash/filtrlash:

python
funksiyalar = [f for f in vars(modul).values()
               if callable(f) and f.__name__.startswith("test_")]

3. Tez ma'lumotnoma

Birinchi darajali obyekt

python
f = salom                   o'zgaruvchiga
[f, g], {"a": f}            konteynerga
def h(f): f()               argument
def h(): return f           qaytarish
f.atribut = 1               atribut qo'shish
{f}, {f: "x"}               hashlanadi

❌ f < g, f + g, len(f), f[0]

Atributlar

python
__name__, __qualname__, __doc__, __module__
__defaults__, __kwdefaults__, __annotations__
__code__ (co_varnames, co_argcount, ...)
__globals__ (havola!), __closure__
__dict__ (foydalanuvchi atributlari)
__wrapped__ (@wraps)

callable obyektlar

python
funksiya, lambda, sinf, metod, __call__ li obyekt
callable(x) bilan tekshirish

class K:
    def __call__(self, x): ...      holat + repr + meros

Metodlar

python
A.metod         <function>          — oddiy funksiya
A().metod       <bound method>      — self bog'langan
m.__self__      obyekt
m.__func__      asl funksiya
a.metod is a.metod  → False (har safar yangi)

Dispatch jadvali

python
AMALLAR = {"+" : add, "-": sub}
AMALLAR[amal](a, b)         O(1), kengaytiriladi

@royxatga_ol("nom")         dekorator bilan
@singledispatch             tur bo'yicha

functools

python
partial(f, *a, **kw)        qisman qo'llash
partialmethod               metodlar uchun
wraps(f)                    metadata ko'chirish
cache / lru_cache           memoizatsiya
cached_property             bir marta hisoblash
reduce                      (12-dars)
singledispatch              tur bo'yicha dispatch

4. Batafsil misollar

Misol 1 — Nima qilish mumkin

python
"""Funksiya obyekt sifatida."""

import operator
from functools import partial, wraps

print("=== 1. Yetti imkoniyat ===")


def salom(ism="dunyo"):
    """Salomlashadi."""
    return f"Salom, {ism}!"


print(f"  1. O'zgaruvchiga:")
f = salom
print(f"     f = salom;  f() = {f()!r}")
print(f"     f is salom: {f is salom}")

print(f"\n  2. Konteynerga:")
AMALLAR = [len, str, abs, salom]
print(f"     [len, str, abs, salom]")
print(f"     [f.__name__ for f in r] = {[f.__name__ for f in AMALLAR]}")

LUGAT = {"salom": salom, "uzunlik": len}
print(f"     LUGAT['salom']('Aziz') = {LUGAT['salom']('Aziz')!r}")

print(f"\n  3. Argument sifatida:")


def qoll(f, *args):
    return f(*args)


print(f"     qoll(abs, -5)      = {qoll(abs, -5)}")
print(f"     qoll(salom, 'Ali') = {qoll(salom, 'Ali')!r}")

print(f"\n  4. Qaytarish:")


def yaratuvchi(n):
    def ichki(x):
        return x * n
    return ichki


print(f"     yaratuvchi(3)(5) = {yaratuvchi(3)(5)}")

print(f"\n  5. Ichma-ich aniqlash:")
print(f"     def tashqi(): def ichki(): ...  ✅")

print(f"\n  6. Atribut qo'shish:")
salom.versiya = "1.0"
salom.muallif = "Wisar"
print(f"     salom.versiya = {salom.versiya!r}")
print(f"     salom.__dict__ = {salom.__dict__}")

print(f"\n  7. Hashlanadi:")
print(f"     {{salom, len}} = {len({salom, len})} element")
print(f"     {{salom: 'izoh'}}[salom] = {({salom: 'izoh'})[salom]!r}")


print("\n=== 2. ❌ Nima MUMKIN EMAS ===")

MUMKIN_EMAS = [
    ("salom < len",     lambda: salom < len),
    ("salom + len",     lambda: salom + len),
    ("len(salom)",      lambda: len(salom)),
    ("salom[0]",        lambda: salom[0]),
    ("salom * 2",       lambda: salom * 2),
    ("-salom",          lambda: -salom),
    ("for x in salom",  lambda: list(salom)),
]

for kod, f in MUMKIN_EMAS:
    try:
        f()
        natija = "✅ ishladi"
    except TypeError as e:
        natija = f"❌ TypeError: {str(e)[:44]}"
    print(f"  {kod:<18} {natija}")


print("\n=== 3. Atributlar ===")


def toliq(a: int, b: str = "x", *args, c: float = 1.0, **kwargs) -> bool:
    """To'liq imzoli funksiya.

    Ikkinchi qator.
    """
    return True


ATRIBUTLAR = [
    "__name__", "__qualname__", "__module__",
    "__defaults__", "__kwdefaults__", "__annotations__",
]

print(f"  {'Atribut':<20} {'Qiymat'}")
print("  " + "─" * 62)
for atr in ATRIBUTLAR:
    qiymat = str(getattr(toliq, atr))
    if len(qiymat) > 40:
        qiymat = qiymat[:38] + "…"
    print(f"  {atr:<20} {qiymat}")

print(f"  {'__doc__ (1-qator)':<20} {toliq.__doc__.splitlines()[0]}")

print(f"\n  __code__ ichida:")
KOD_ATRIBUTLARI = ["co_name", "co_argcount", "co_kwonlyargcount",
                   "co_varnames", "co_firstlineno", "co_flags"]
for atr in KOD_ATRIBUTLARI:
    qiymat = str(getattr(toliq.__code__, atr))
    if len(qiymat) > 40:
        qiymat = qiymat[:38] + "…"
    print(f"    {atr:<20} {qiymat}")

print(f"\n  __globals__ — HAVOLA:")
print(f"    toliq.__globals__ is globals(): {toliq.__globals__ is globals()}")

GLOBAL_TEST = "asl"


def globalni_oqi():
    return GLOBAL_TEST


print(f"    globalni_oqi() = {globalni_oqi()!r}")
GLOBAL_TEST = "o'zgargan"
print(f"    GLOBAL_TEST o'zgardi → {globalni_oqi()!r}   ⭐ joriy qiymat")


print("\n=== 4. Foydalanuvchi atributlari ===")


def sanagich_dekorator(f):
    @wraps(f)
    def ichki(*args, **kwargs):
        ichki.chaqiruvlar += 1
        ichki.oxirgi_args = (args, kwargs)
        return f(*args, **kwargs)

    ichki.chaqiruvlar = 0
    ichki.oxirgi_args = None
    ichki.tozala = lambda: setattr(ichki, "chaqiruvlar", 0)
    return ichki


@sanagich_dekorator
def hisobla(a, b=2):
    return a ** b


for args, kwargs in [((2,), {}), ((3, 3), {}), ((2,), {"b": 10})]:
    hisobla(*args, **kwargs)

print(f"  @sanagich_dekorator bilan:\n")
print(f"    chaqiruvlar:  {hisobla.chaqiruvlar}")
print(f"    oxirgi_args:  {hisobla.oxirgi_args}")
print(f"    __name__:     {hisobla.__name__}   ⭐ @wraps saqladi")
print(f"    __wrapped__:  {hisobla.__wrapped__.__name__}")

hisobla.tozala()
print(f"    tozalashdan keyin: {hisobla.chaqiruvlar}")

print(f"\n  Barcha atributlar: {sorted(hisobla.__dict__)}")


print("\n=== 5. Funksiyalarni tekshirish ===")

import inspect

OBYEKTLAR = [
    ("def funksiya", toliq),
    ("lambda", lambda x: x),
    ("ichki funksiya", inspect),
    ("sinf", int),
    ("metod", str.upper),
    ("bog'langan metod", "abc".upper),
    ("partial", partial(pow, 2)),
    ("__call__ obyekt", None),
    ("son", 42),
    ("satr", "abc"),
]


class Chaqiriladigan:
    def __call__(self):
        return 1


OBYEKTLAR[7] = ("__call__ obyekt", Chaqiriladigan())

print(f"  {'Obyekt':<20} {'callable':<10} {'isfunction':<12} {'ismethod':<10} {'turi'}")
print("  " + "─" * 70)
for nom, o in OBYEKTLAR:
    print(f"  {nom:<20} {str(callable(o)):<10} "
          f"{str(inspect.isfunction(o)):<12} "
          f"{str(inspect.ismethod(o)):<10} {type(o).__name__}")


print("\n=== 6. Metodlar ===")


class A:
    def metod(self):
        return "metod"

    @staticmethod
    def statik():
        return "statik"

    @classmethod
    def sinf_metodi(cls):
        return "sinf_metodi"


a = A()

print(f"  {'Ifoda':<20} {'Turi':<24} {'Chaqirish'}")
print("  " + "─" * 64)
NAMUNALAR = [
    ("A.metod",         A.metod,        lambda: A.metod(a)),
    ("a.metod",         a.metod,        lambda: a.metod()),
    ("A.statik",        A.statik,       lambda: A.statik()),
    ("a.statik",        a.statik,       lambda: a.statik()),
    ("A.sinf_metodi",   A.sinf_metodi,  lambda: A.sinf_metodi()),
]

for kod, obj, chaqir in NAMUNALAR:
    tur = type(obj).__name__
    print(f"  {kod:<20} {tur:<24} {chaqir()!r}")

print(f"\n  ⭐ Bog'langan metod:")
m = a.metod
print(f"    m = a.metod")
print(f"    m.__self__ is a:       {m.__self__ is a}")
print(f"    m.__func__ is A.metod: {m.__func__ is A.metod}")
print(f"    m() = {m()!r}   (self avtomatik)")

print(f"\n  ⚠️ Har murojaatda YANGI obyekt:")
print(f"    a.metod is a.metod: {a.metod is a.metod}")
print(f"    a.metod == a.metod: {a.metod == a.metod}")
print(f"    id farqi: {id(a.metod) != id(a.metod)}")

Natijaning muhim qismi:

text
=== 2. ❌ Nima MUMKIN EMAS ===
  salom < len        ❌ TypeError: '<' not supported between instances of
  salom + len        ❌ TypeError: unsupported operand type(s) for +
  len(salom)         ❌ TypeError: object of type 'function' has no len()

=== 3. Atributlar ===
  Atribut              Qiymat
  ──────────────────────────────────────────────────────────────
  __name__             toliq
  __defaults__         ('x',)
  __kwdefaults__       {'c': 1.0}
  __annotations__      {'a': <class 'int'>, 'b': <class 'str'…

    toliq.__globals__ is globals(): True
    GLOBAL_TEST o'zgardi → "o'zgargan"   ⭐ joriy qiymat

=== 6. Metodlar ===
  Ifoda                Turi                     Chaqirish
  ────────────────────────────────────────────────────────────────
  A.metod              function                 'metod'
  a.metod              method                   'metod'
  A.statik             function                 'statik'
  A.sinf_metodi        method                   'sinf_metodi'

    a.metod is a.metod: False
    a.metod == a.metod: True

Nima ko'rsatdi: 2.1, 2.2, 2.4-bo'limlar.

Misol 2 — Yuqori tartibli funksiyalar

python
"""Funksiyalarni argument va natija sifatida."""

import time
from functools import reduce, partial, wraps
from operator import add, mul

print("=== 1. Standart kutubxonadan ===")

MALUMOT = [3, 1, 4, 1, 5, 9, 2, 6]
SOZLAR = ["shaftoli", "olma", "banan", "anor"]

NAMUNALAR = [
    ("sorted(r, key=len)",          sorted(SOZLAR, key=len)),
    ("max(r, key=len)",             max(SOZLAR, key=len)),
    ("min(r, key=len)",             min(SOZLAR, key=len)),
    ("list(map(str, r))",           list(map(str, MALUMOT))[:4]),
    ("list(filter(bool, r))",       list(filter(lambda x: x > 3, MALUMOT))),
    ("reduce(add, r)",              reduce(add, MALUMOT)),
    ("reduce(mul, r)",              reduce(mul, MALUMOT)),
    ("any(map(lambda x: x>8, r))",  any(map(lambda x: x > 8, MALUMOT))),
    ("all(map(lambda x: x>0, r))",  all(map(lambda x: x > 0, MALUMOT))),
]

for kod, natija in NAMUNALAR:
    print(f"  {kod:<30} → {natija}")


print("\n=== 2. O'z yuqori tartibli funksiyalaringiz ===")


def takrorla(f, n):
    """f ni n marta chaqiradi."""
    return [f() for _ in range(n)]


def qoll_hammaga(f, malumot):
    """Har elementga f ni qo'llaydi."""
    return [f(x) for x in malumot]


def shart_bilan(f, shart, malumot):
    """Shartga mos elementlarga f ni qo'llaydi."""
    return [f(x) if shart(x) else x for x in malumot]


def kompozitsiya(*funksiyalar):
    """f(g(h(x))) — o'ngdan chapga."""
    def natija(x):
        for f in reversed(funksiyalar):
            x = f(x)
        return x
    natija.__name__ = " ∘ ".join(
        getattr(f, "__name__", "?") for f in funksiyalar
    )
    return natija


def quvur(*funksiyalar):
    """h(g(f(x))) — chapdan o'ngga."""
    def natija(x):
        for f in funksiyalar:
            x = f(x)
        return x
    natija.__name__ = " → ".join(
        getattr(f, "__name__", "?") for f in funksiyalar
    )
    return natija


import random
random.seed(1)

print(f"  takrorla(lambda: random.randint(1,6), 5)")
print(f"    → {takrorla(lambda: random.randint(1, 6), 5)}")

print(f"\n  qoll_hammaga(abs, [-1, 2, -3])")
print(f"    → {qoll_hammaga(abs, [-1, 2, -3])}")

print(f"\n  shart_bilan(lambda x: x*10, lambda x: x>3, {MALUMOT})")
print(f"    → {shart_bilan(lambda x: x * 10, lambda x: x > 3, MALUMOT)}")


def ikkilash(x): return x * 2
def qoshish(x): return x + 1
def kvadrat(x): return x ** 2


k = kompozitsiya(kvadrat, ikkilash, qoshish)
q = quvur(qoshish, ikkilash, kvadrat)

print(f"\n  kompozitsiya(kvadrat, ikkilash, qoshish):")
print(f"    {k.__name__}")
print(f"    k(3) = {k(3)}   ← kvadrat(ikkilash(qoshish(3))) = ((3+1)*2)²")

print(f"\n  quvur(qoshish, ikkilash, kvadrat):")
print(f"    {q.__name__}")
print(f"    q(3) = {q(3)}   ← bir xil natija, boshqa tartib")


print("\n=== 3. Dekorator — yuqori tartibli funksiya ===")


def vaqt_olch(f):
    """Funksiya oladi, funksiya qaytaradi."""
    @wraps(f)
    def ichki(*args, **kwargs):
        boshlandi = time.perf_counter()
        natija = f(*args, **kwargs)
        ichki.oxirgi_vaqt = time.perf_counter() - boshlandi
        return natija
    ichki.oxirgi_vaqt = 0.0
    return ichki


def qayta_urin(n=3):
    """Parametrli dekorator — uch daraja."""
    def dekorator(f):
        @wraps(f)
        def ichki(*args, **kwargs):
            for i in range(n):
                try:
                    return f(*args, **kwargs)
                except Exception:
                    if i == n - 1:
                        raise
        return ichki
    return dekorator


@vaqt_olch
def sekin(n):
    return sum(range(n))


sekin(1_000_000)
print(f"  @vaqt_olch:")
print(f"    sekin(1M) vaqti: {sekin.oxirgi_vaqt * 1000:.1f} ms")

print(f"\n  Dekorator ichkarisi:")
print(f"    vaqt_olch — funksiya oladi, funksiya qaytaradi")
print(f"    qayta_urin(3) — funksiya QAYTARADIGAN funksiya qaytaradi")
print(f"      qayta_urin(3)     → dekorator")
print(f"      dekorator(f)      → ichki")
print(f"      ichki(*a, **kw)   → natija")


print("\n=== 4. functools.partial ===")


def kuch(asos, daraja, modul=None):
    natija = asos ** daraja
    return natija % modul if modul else natija


kvadrat_p = partial(kuch, daraja=2)
kub_p = partial(kuch, daraja=3)
ikki_darajasi = partial(kuch, 2)
mod_hisob = partial(kuch, daraja=10, modul=1000)

print(f"  def kuch(asos, daraja, modul=None)\n")
print(f"  {'partial':<30} {'Chaqiruv':<16} {'Natija'}")
print("  " + "─" * 60)
NAMUNALAR = [
    ("partial(kuch, daraja=2)",  "kvadrat_p(5)",    kvadrat_p(5)),
    ("partial(kuch, daraja=3)",  "kub_p(5)",        kub_p(5)),
    ("partial(kuch, 2)",         "ikki_darajasi(10)", ikki_darajasi(10)),
    ("partial(kuch, daraja=10, modul=1000)", "mod_hisob(7)", mod_hisob(7)),
]
for p, chaqiruv, natija in NAMUNALAR:
    print(f"  {p:<30} {chaqiruv:<16} {natija}")

print(f"\n  partial ichkarisi:")
print(f"    kvadrat_p.func     = {kvadrat_p.func.__name__}")
print(f"    kvadrat_p.args     = {kvadrat_p.args}")
print(f"    kvadrat_p.keywords = {kvadrat_p.keywords}")
print(f"    type(kvadrat_p)    = {type(kvadrat_p).__name__}")

try:
    kvadrat_p.__name__
except AttributeError as e:
    print(f"    kvadrat_p.__name__ → ❌ {e}")

print(f"\n  ⚠️ partial — funksiya EMAS:")
import inspect
print(f"    inspect.isfunction(kvadrat_p) = {inspect.isfunction(kvadrat_p)}")
print(f"    callable(kvadrat_p)           = {callable(kvadrat_p)}")


print("\n=== 5. partial vs lambda vs yopilma ===")


def kuch_lambda(daraja):
    return lambda asos: asos ** daraja


def kuch_yopilma(daraja):
    def ichki(asos):
        return asos ** daraja
    ichki.__name__ = f"kuch_{daraja}"
    return ichki


USULLAR = [
    ("partial",     partial(kuch, daraja=2)),
    ("lambda",      kuch_lambda(2)),
    ("yopilma",     kuch_yopilma(2)),
]

print(f"  {'Usul':<12} {'Natija(5)':<12} {'__name__':<16} {'Turi'}")
print("  " + "─" * 56)
for nom, f in USULLAR:
    natija = f(5)
    fname = getattr(f, "__name__", "(yo'q)")
    print(f"  {nom:<12} {natija:<12} {fname:<16} {type(f).__name__}")

import timeit
SOZLASH = """
from functools import partial
from __main__ import kuch, kuch_lambda, kuch_yopilma
p = partial(kuch, daraja=2)
l = kuch_lambda(2)
y = kuch_yopilma(2)
"""

print(f"\n  Tezlik (1M chaqiruv):")
for nom, kod in [("partial", "p(5)"), ("lambda", "l(5)"), ("yopilma", "y(5)")]:
    vaqt = timeit.timeit(kod, setup=SOZLASH, number=1_000_000)
    print(f"    {nom:<12} {vaqt:.3f} s")

print("""
  ⭐ Tanlov:
     partial  — mavjud funksiyaning argumentini bog'lash
     lambda   — qisqa, bir martalik
     yopilma  — __name__, __doc__ berish kerak bo'lsa
""")


print("\n=== 6. Funksiyalar ro'yxati bilan ishlash ===")

TOZALASH_QADAMLARI = [
    str.strip,
    str.lower,
    lambda s: s.replace("  ", " "),
    lambda s: s.replace("ʻ", "'"),
]


def tozala(matn, qadamlar=TOZALASH_QADAMLARI):
    for f in qadamlar:
        matn = f(matn)
    return matn


NAMUNALAR = [
    "  SALOM  DUNYO  ",
    "  Oʻzbekiston  ",
    "TEST",
]

print(f"  Tozalash quvuri ({len(TOZALASH_QADAMLARI)} qadam):\n")
for m in NAMUNALAR:
    print(f"    {m!r:<26} → {tozala(m)!r}")

print(f"\n  Qadamlarni dinamik o'zgartirish:")
qisqa = TOZALASH_QADAMLARI[:2]
print(f"    Faqat strip + lower: {tozala('  SALOM  ', qisqa)!r}")

print(f"\n  Har qadam natijasi:")
matn = "  Oʻzbekiston  RESPUBLIKASI  "
print(f"    Asl: {matn!r}")
for f in TOZALASH_QADAMLARI:
    matn = f(matn)
    nom = getattr(f, "__name__", "<lambda>")
    print(f"    {nom:<12} → {matn!r}")

Natijaning muhim qismi:

text
=== 2. O'z yuqori tartibli funksiyalaringiz ===
  kompozitsiya(kvadrat, ikkilash, qoshish):
    kvadrat ∘ ikkilash ∘ qoshish
    k(3) = 64   ← kvadrat(ikkilash(qoshish(3))) = ((3+1)*2)²

  quvur(qoshish, ikkilash, kvadrat):
    qoshish → ikkilash → kvadrat
    q(3) = 64   ← bir xil natija, boshqa tartib

=== 4. functools.partial ===
  partial                        Chaqiruv         Natija
  ────────────────────────────────────────────────────────────
  partial(kuch, daraja=2)        kvadrat_p(5)     25
  partial(kuch, 2)               ikki_darajasi(10) 1024

    kvadrat_p.__name__ → ❌ 'functools.partial' object has no attribute '__name__'

=== 5. partial vs lambda vs yopilma ===
  Tezlik (1M chaqiruv):
    partial      0.412 s
    lambda       0.298 s
    yopilma      0.301 s

Nima ko'rsatdi: 2.3, 2.6-bo'limlar.

Misol 3 — Dispatch va callable obyektlar

python
"""Dispatch jadvallari va chaqiriladigan obyektlar."""

import operator
from functools import singledispatch, wraps
from dataclasses import dataclass

print("=== 1. if/elif vs dispatch jadvali ===")


def hisobla_elif(amal, a, b):
    """❌ Uzun zanjir."""
    if amal == "+":
        return a + b
    elif amal == "-":
        return a - b
    elif amal == "*":
        return a * b
    elif amal == "/":
        return a / b if b else float("inf")
    elif amal == "**":
        return a ** b
    elif amal == "%":
        return a % b if b else 0
    else:
        raise ValueError(f"Noma'lum amal: {amal}")


AMALLAR = {
    "+": operator.add,
    "-": operator.sub,
    "*": operator.mul,
    "/": lambda a, b: a / b if b else float("inf"),
    "**": operator.pow,
    "%": lambda a, b: a % b if b else 0,
}


def hisobla_dispatch(amal, a, b):
    """✅ Dispatch jadvali."""
    f = AMALLAR.get(amal)
    if f is None:
        mavjud = ", ".join(sorted(AMALLAR))
        raise ValueError(f"Noma'lum amal {amal!r}. Mavjud: {mavjud}")
    return f(a, b)


print(f"  a=10, b=3:\n")
print(f"  {'Amal':<6} {'elif':<12} {'dispatch'}")
print("  " + "─" * 34)
for amal in ["+", "-", "*", "/", "**", "%"]:
    a, b = hisobla_elif(amal, 10, 3), hisobla_dispatch(amal, 10, 3)
    belgi = "✅" if a == b else "❌"
    print(f"  {amal:<6} {str(a)[:10]:<12} {belgi} {b}")

print(f"\n  Noma'lum amal:")
for f, nom in [(hisobla_elif, "elif"), (hisobla_dispatch, "dispatch")]:
    try:
        f("?", 1, 2)
    except ValueError as e:
        print(f"    {nom:<10} ❌ {e}")

print("""
  ⭐ Dispatch afzalliklari:
     • O(1) qidiruv (elif — O(n))
     • Yangi amal — bir qator
     • Dinamik kengaytirish
     • Xato xabari mavjudlarni ko'rsatadi
""")

print(f"  Dinamik kengaytirish:")
AMALLAR["//"] = operator.floordiv
AMALLAR["max"] = max
print(f"    AMALLAR['//'] = floordiv")
print(f"    hisobla_dispatch('//', 10, 3) = {hisobla_dispatch('//', 10, 3)}")
print(f"    hisobla_dispatch('max', 10, 3) = {hisobla_dispatch('max', 10, 3)}")


print("\n=== 2. Ro'yxatga olish dekoratori ===")


class Registr:
    def __init__(self, nom: str):
        self.nom = nom
        self._elementlar: dict[str, callable] = {}

    def __call__(self, nom=None, **metadata):
        """⭐ Registr o'zi chaqiriladigan — dekorator sifatida."""
        def dekorator(f):
            kalit = nom or f.__name__
            f._registr_metadata = metadata
            self._elementlar[kalit] = f
            return f
        return dekorator

    def chaqir(self, nom, *args, **kwargs):
        if nom not in self._elementlar:
            raise KeyError(f"{nom!r} topilmadi. Mavjud: "
                           f"{', '.join(sorted(self._elementlar))}")
        return self._elementlar[nom](*args, **kwargs)

    def __len__(self):
        return len(self._elementlar)

    def __contains__(self, nom):
        return nom in self._elementlar

    def royxat(self):
        return [(n, f.__doc__ or "", getattr(f, "_registr_metadata", {}))
                for n, f in sorted(self._elementlar.items())]


formatlar = Registr("formatlar")


@formatlar("json", kengaytma=".json")
def json_format(malumot):
    """JSON formatida."""
    import json
    return json.dumps(malumot, ensure_ascii=False)


@formatlar("csv", kengaytma=".csv")
def csv_format(malumot):
    """CSV formatida."""
    if not malumot:
        return ""
    ustunlar = list(malumot[0])
    qatorlar = [",".join(ustunlar)]
    qatorlar += [",".join(str(q.get(u, "")) for u in ustunlar) for q in malumot]
    return "\n".join(qatorlar)


@formatlar(kengaytma=".txt")
def matn_format(malumot):
    """Oddiy matn."""
    return "\n".join(str(q) for q in malumot)


MALUMOT = [{"ism": "Aziz", "yosh": 30}, {"ism": "Bobur", "yosh": 25}]

print(f"  Ro'yxatga olingan formatlar ({len(formatlar)}):\n")
print(f"    {'Nom':<14} {'Docstring':<20} {'Metadata'}")
print("    " + "─" * 54)
for nom, doc, meta in formatlar.royxat():
    print(f"    {nom:<14} {doc:<20} {meta}")

print(f"\n  Chaqirish:")
for nom in ["json", "csv", "matn_format"]:
    natija = formatlar.chaqir(nom, MALUMOT)
    birinchi_qator = natija.splitlines()[0] if natija else ""
    print(f"    {nom:<14} {birinchi_qator[:48]}")

try:
    formatlar.chaqir("xml", MALUMOT)
except KeyError as e:
    print(f"\n    xml → ❌ {e}")


print("\n=== 3. functools.singledispatch ===")


@singledispatch
def formatla(x):
    """Sukut — har qanday obyekt."""
    return f"<{type(x).__name__}: {x}>"


@formatla.register
def _(x: int):
    return f"{x:,}"


@formatla.register
def _(x: float):
    return f"{x:.2f}"


@formatla.register
def _(x: str):
    return f'"{x}"'


@formatla.register
def _(x: list):
    return "[" + ", ".join(formatla(y) for y in x) + "]"


@formatla.register
def _(x: dict):
    return "{" + ", ".join(f"{formatla(k)}: {formatla(v)}"
                           for k, v in x.items()) + "}"


@formatla.register(type(None))
def _(x):
    return "yo'q"


SINOVLAR = [
    1234567,
    3.14159,
    "salom",
    [1, "a", 2.5],
    {"a": 1, "b": [2, 3]},
    None,
    (1, 2),
    {1, 2},
]

print(f"  {'Kirish':<26} {'Turi':<12} {'Natija'}")
print("  " + "─" * 62)
for x in SINOVLAR:
    print(f"  {str(x)[:24]:<26} {type(x).__name__:<12} {formatla(x)}")

print(f"\n  Ro'yxatga olingan turlar:")
print(f"    {sorted(t.__name__ for t in formatla.registry)}")


print("\n=== 4. __call__ obyektlari ===")


class Kopaytiruvchi:
    """Funksiya kabi, lekin holat va repr bilan."""

    def __init__(self, n: int):
        self.n = n
        self.chaqiruvlar = 0

    def __call__(self, x):
        self.chaqiruvlar += 1
        return x * self.n

    def __repr__(self):
        return f"Kopaytiruvchi({self.n}, chaqiruvlar={self.chaqiruvlar})"


def kopaytiruvchi_yopilma(n):
    """Yopilma versiyasi."""
    def ichki(x):
        return x * n
    return ichki


k_sinf = Kopaytiruvchi(3)
k_yopilma = kopaytiruvchi_yopilma(3)

print(f"  Ikkalasi ham chaqiriladi:\n")
print(f"    {'':<12} {'k(5)':<8} {'callable':<10} {'repr'}")
print("    " + "─" * 56)
print(f"    {'Sinf':<12} {k_sinf(5):<8} {str(callable(k_sinf)):<10} {k_sinf!r}")
print(f"    {'Yopilma':<12} {k_yopilma(5):<8} "
      f"{str(callable(k_yopilma)):<10} {str(k_yopilma)[:28]}")

print(f"\n  Sinf afzalliklari:")
k_sinf(1); k_sinf(2)
print(f"    • Holat ko'rinadi:  {k_sinf!r}")
print(f"    • Atribut o'zgartirish: k.n = 10")
k_sinf.n = 10
print(f"      k(5) = {k_sinf(5)}")
print(f"    • Qo'shimcha metodlar, meros, xususiyatlar")

print(f"\n  Yopilma afzalliklari:")
import sys
print(f"    • Xotira: {sys.getsizeof(k_yopilma)} B vs "
      f"{sys.getsizeof(k_sinf) + sys.getsizeof(vars(k_sinf))} B")

import timeit
SOZLASH = """
from __main__ import Kopaytiruvchi, kopaytiruvchi_yopilma
ks = Kopaytiruvchi(3)
ky = kopaytiruvchi_yopilma(3)
"""
for nom, kod in [("Sinf", "ks(5)"), ("Yopilma", "ky(5)")]:
    vaqt = timeit.timeit(kod, setup=SOZLASH, number=2_000_000)
    print(f"    • Tezlik ({nom}): {vaqt:.3f} s")


print("\n=== 5. Chaqiriladigan obyektlar iyerarxiyasi ===")

import inspect


class Sinf:
    def metod(self): pass
    @staticmethod
    def statik(): pass
    @classmethod
    def sinf_m(cls): pass
    def __call__(self): pass


obyekt = Sinf()


def oddiy(): pass


OBYEKTLAR = [
    ("def funksiya",        oddiy),
    ("lambda",              lambda: 1),
    ("ichki funksiya",      len),
    ("sinf",                Sinf),
    ("metod (sinfdan)",     Sinf.metod),
    ("bog'langan metod",    obyekt.metod),
    ("statik metod",        Sinf.statik),
    ("sinf metodi",         Sinf.sinf_m),
    ("__call__ obyekt",     obyekt),
    ("partial",             __import__("functools").partial(oddiy)),
    ("generator funksiya",  (lambda: (yield))),
    ("tur (int)",           int),
]

print(f"  {'Obyekt':<22} {'callable':<9} {'isfunction':<11} "
      f"{'ismethod':<9} {'isclass'}")
print("  " + "─" * 68)
for nom, o in OBYEKTLAR:
    print(f"  {nom:<22} {str(callable(o)):<9} "
          f"{str(inspect.isfunction(o)):<11} "
          f"{str(inspect.ismethod(o)):<9} {inspect.isclass(o)}")


print("\n=== 6. Amaliy: hodisa tizimi ===")


class Hodisalar:
    def __init__(self):
        self._obunachi: dict[str, list] = {}

    def obuna(self, hodisa: str, ustuvorlik: int = 0):
        """Dekorator: funksiyani ro'yxatga oladi."""
        def dekorator(f):
            f._ustuvorlik = ustuvorlik
            self._obunachi.setdefault(hodisa, []).append(f)
            self._obunachi[hodisa].sort(
                key=lambda g: -getattr(g, "_ustuvorlik", 0)
            )
            return f
        return dekorator

    def tarqat(self, hodisa: str, *args, **kwargs) -> list:
        return [f(*args, **kwargs)
                for f in self._obunachi.get(hodisa, [])]


hodisalar = Hodisalar()


@hodisalar.obuna("kirish", ustuvorlik=10)
def xavfsizlik_tekshiruvi(ism):
    return f"[10] xavfsizlik: {ism} tekshirildi"


@hodisalar.obuna("kirish", ustuvorlik=5)
def jurnalga_yoz(ism):
    return f"[5]  jurnal: {ism} kirdi"


@hodisalar.obuna("kirish")
def xabar_yubor(ism):
    return f"[0]  xabar: Salom, {ism}!"


class StatistikaYig(object):
    """⭐ __call__ obyekt ham obunachi bo'la oladi."""

    def __init__(self):
        self.hisob = 0

    def __call__(self, ism):
        self.hisob += 1
        return f"[0]  statistika: jami {self.hisob} kirish"


statistika = StatistikaYig()
hodisalar.obuna("kirish")(statistika)

print(f"  Obunachi turlari: funksiya, funksiya, funksiya, __call__ obyekt\n")
print(f"  tarqat('kirish', 'Aziz'):")
for n in hodisalar.tarqat("kirish", "Aziz"):
    print(f"    {n}")

print(f"\n  tarqat('kirish', 'Bobur'):")
for n in hodisalar.tarqat("kirish", "Bobur"):
    print(f"    {n}")

print(f"\n  ⭐ Ustuvorlik bo'yicha tartiblangan")
print(f"  ⭐ __call__ obyekt ham funksiya kabi ishlatildi")

Natijaning muhim qismi:

text
=== 1. if/elif vs dispatch jadvali ===
  Noma'lum amal:
    elif       ❌ Noma'lum amal: ?
    dispatch   ❌ Noma'lum amal '?'. Mavjud: %, *, **, +, -, /

=== 3. functools.singledispatch ===
  Kirish                     Turi         Natija
  ──────────────────────────────────────────────────────────────
  1234567                    int          1,234,567
  3.14159                    float        3.14
  salom                      str          "salom"
  [1, 'a', 2.5]              list         [1, "a", 2.50]
  None                       NoneType     yo'q
  (1, 2)                     tuple        <tuple: (1, 2)>

=== 5. Chaqiriladigan obyektlar iyerarxiyasi ===
  Obyekt                 callable  isfunction  ismethod  isclass
  ────────────────────────────────────────────────────────────────────
  def funksiya           True      True        False     False
  bog'langan metod       True      False       True      False
  __call__ obyekt        True      False       False     False
  sinf                   True      False       False     True

Nima ko'rsatdi: 2.4, 2.5-bo'limlar.

Misol 4 — Amaliy: plagin va quvur tizimi

python
"""Funksiya-obyekt asosidagi kengaytiriladigan tizim."""

import inspect
import time
from dataclasses import dataclass, field
from functools import wraps, partial
from typing import Callable, Any

print("=== Ma'lumot qayta ishlash quvuri ===\n")


@dataclass
class Kontekst:
    """Quvur bo'ylab uzatiladigan holat."""
    malumot: Any
    metadata: dict = field(default_factory=dict)
    tarix: list[str] = field(default_factory=list)
    xatolar: list[str] = field(default_factory=list)

    def qayd(self, nom: str) -> "Kontekst":
        self.tarix.append(nom)
        return self


class Quvur:
    """Funksiyalar zanjiri."""

    def __init__(self, *bosqichlar: Callable):
        self.bosqichlar = list(bosqichlar)

    def qosh(self, f: Callable) -> "Quvur":
        return Quvur(*self.bosqichlar, f)

    def oldiga(self, f: Callable) -> "Quvur":
        return Quvur(f, *self.bosqichlar)

    def olib_tashla(self, nom: str) -> "Quvur":
        return Quvur(*(f for f in self.bosqichlar
                       if getattr(f, "__name__", "") != nom))

    def __call__(self, kontekst: Kontekst) -> Kontekst:
        for f in self.bosqichlar:
            nom = getattr(f, "__name__", type(f).__name__)
            try:
                kontekst = f(kontekst)
                kontekst.qayd(nom)
            except Exception as x:
                kontekst.xatolar.append(f"{nom}: {x}")
        return kontekst

    def __len__(self):
        return len(self.bosqichlar)

    def __repr__(self):
        nomlar = [getattr(f, "__name__", type(f).__name__)
                  for f in self.bosqichlar]
        return f"Quvur({' → '.join(nomlar)})"


# ─── Bosqichlar: oddiy funksiyalar ───

def tozala(k: Kontekst) -> Kontekst:
    """Bo'sh qatorlarni olib tashlaydi."""
    k.malumot = [q.strip() for q in k.malumot if q.strip()]
    return k


def izohsiz(k: Kontekst) -> Kontekst:
    """# bilan boshlanuvchilarni olib tashlaydi."""
    k.malumot = [q for q in k.malumot if not q.startswith("#")]
    return k


def songa(k: Kontekst) -> Kontekst:
    """Sonlarni ajratadi."""
    sonlar, notogri = [], []
    for q in k.malumot:
        try:
            sonlar.append(float(q))
        except ValueError:
            notogri.append(q)
    k.malumot = sonlar
    k.metadata["notogri"] = notogri
    return k


def statistika(k: Kontekst) -> Kontekst:
    """Statistika hisoblaydi."""
    if k.malumot:
        k.metadata["statistika"] = {
            "soni": len(k.malumot),
            "jami": sum(k.malumot),
            "ortacha": sum(k.malumot) / len(k.malumot),
            "min": min(k.malumot),
            "max": max(k.malumot),
        }
    return k


# ─── Parametrli bosqich (yopilma) ───

def filtrla(shart: Callable[[float], bool], nom: str = "filtrla"):
    """⭐ Funksiya qaytaruvchi funksiya."""
    def bosqich(k: Kontekst) -> Kontekst:
        oldingi = len(k.malumot)
        k.malumot = [x for x in k.malumot if shart(x)]
        k.metadata.setdefault("filtrlangan", 0)
        k.metadata["filtrlangan"] += oldingi - len(k.malumot)
        return k
    bosqich.__name__ = nom
    return bosqich


def xarita(f: Callable, nom: str = "xarita"):
    def bosqich(k: Kontekst) -> Kontekst:
        k.malumot = [f(x) for x in k.malumot]
        return k
    bosqich.__name__ = nom
    return bosqich


# ─── __call__ obyekt bosqich ───

class Chegarala:
    """⭐ Holat saqlaydigan bosqich."""

    def __init__(self, n: int):
        self.n = n
        self.chaqiruvlar = 0
        self.tashlangan = 0

    def __call__(self, k: Kontekst) -> Kontekst:
        self.chaqiruvlar += 1
        self.tashlangan += max(0, len(k.malumot) - self.n)
        k.malumot = k.malumot[:self.n]
        return k

    @property
    def __name__(self):
        return f"chegarala({self.n})"

    def __repr__(self):
        return (f"Chegarala({self.n}, chaqiruvlar={self.chaqiruvlar}, "
                f"tashlangan={self.tashlangan})")


# ─── Dekorator bosqich ───

def vaqt_olch(f):
    """Bosqich vaqtini o'lchaydi."""
    @wraps(f)
    def ichki(k: Kontekst) -> Kontekst:
        boshlandi = time.perf_counter()
        natija = f(k)
        vaqt = time.perf_counter() - boshlandi
        natija.metadata.setdefault("vaqtlar", {})[f.__name__] = vaqt
        return natija
    return ichki


# ═══ NAMOYISH ═══

XOM = """
  42
  # izoh
  17.5

  notogri
  8
  -3
  99
  # yana izoh
  100
  0
"""

print("=== 1. Asosiy quvur ===\n")

quvur = Quvur(tozala, izohsiz, songa, statistika)
print(f"  {quvur}\n")

k = quvur(Kontekst(XOM.strip().splitlines()))

print(f"  Natija:      {k.malumot}")
print(f"  Tarix:       {' → '.join(k.tarix)}")
print(f"  Noto'g'ri:   {k.metadata.get('notogri')}")
print(f"  Statistika:")
for nom, qiymat in k.metadata.get("statistika", {}).items():
    print(f"    {nom:<10} {qiymat:,.2f}" if isinstance(qiymat, float)
          else f"    {nom:<10} {qiymat}")


print("\n\n=== 2. Quvurni kengaytirish ===\n")

chegarala_3 = Chegarala(3)

kengaytirilgan = (
    Quvur(tozala, izohsiz, songa)
    .qosh(filtrla(lambda x: x > 0, "musbatlar"))
    .qosh(xarita(lambda x: round(x), "yaxlitlash"))
    .qosh(chegarala_3)
    .qosh(statistika)
)

print(f"  {kengaytirilgan}\n")

k2 = kengaytirilgan(Kontekst(XOM.strip().splitlines()))

print(f"  Natija:      {k2.malumot}")
print(f"  Filtrlangan: {k2.metadata.get('filtrlangan')} ta")
print(f"  Chegarala:   {chegarala_3!r}")
print(f"  Statistika:  {k2.metadata.get('statistika')}")


print("\n\n=== 3. Bosqichni olib tashlash ===\n")

qisqartirilgan = kengaytirilgan.olib_tashla("musbatlar")
print(f"  {qisqartirilgan}\n")

k3 = qisqartirilgan(Kontekst(XOM.strip().splitlines()))
print(f"  Natija: {k3.malumot}   (manfiy ham qoldi)")


print("\n\n=== 4. Vaqt o'lchash bilan ===\n")

vaqtli = Quvur(
    vaqt_olch(tozala),
    vaqt_olch(izohsiz),
    vaqt_olch(songa),
    vaqt_olch(statistika),
)

KATTA = [str(i) if i % 7 else f"# {i}" for i in range(50_000)]
k4 = vaqtli(Kontekst(KATTA))

print(f"  {len(KATTA):,} qator:\n")
print(f"    {'Bosqich':<14} {'Vaqt':>10}")
print("    " + "─" * 26)
for nom, vaqt in k4.metadata.get("vaqtlar", {}).items():
    print(f"    {nom:<14} {vaqt * 1000:>7.2f} ms")
print(f"\n    Natija: {k4.metadata['statistika']['soni']:,} son")


print("\n\n=== 5. Bosqich turlari ===\n")

BOSQICHLAR = [
    ("Oddiy funksiya",      tozala),
    ("Yopilma (parametrli)", filtrla(lambda x: x > 0)),
    ("__call__ obyekt",     Chegarala(5)),
    ("Dekoratorlangan",     vaqt_olch(songa)),
    ("lambda",              lambda k: k),
    ("partial",             partial(filtrla, lambda x: x > 0)),
]

print(f"  {'Tur':<22} {'callable':<10} {'__name__':<20} {'turi'}")
print("  " + "─" * 66)
for nom, b in BOSQICHLAR:
    fname = getattr(b, "__name__", "(yo'q)")
    if not isinstance(fname, str):
        fname = str(fname)
    print(f"  {nom:<22} {str(callable(b)):<10} {fname:<20} "
          f"{type(b).__name__}")

print("""
  ⭐ Quvur HAR QANDAY chaqiriladigan obyektni qabul qiladi:
     • Oddiy funksiya
     • Yopilma (parametrli bosqich)
     • __call__ obyekt (holat bilan)
     • Dekoratorlangan funksiya
     • lambda
""")


print("\n=== 6. Ishlatilgan naqshlar ===\n")

print("""
  1️⃣ Funksiya — argument
     Quvur(tozala, izohsiz, songa)

  2️⃣ Funksiya — qaytarish qiymati
     filtrla(shart) → bosqich funksiyasi

  3️⃣ Funksiya — atribut bilan
     bosqich.__name__ = nom

  4️⃣ Funksiyalar ro'yxati
     self.bosqichlar = [f1, f2, f3]

  5️⃣ __call__ obyekt
     class Chegarala: def __call__(self, k): ...

  6️⃣ Dekorator (funksiya → funksiya)
     @vaqt_olch

  7️⃣ Zanjirlash (fluent interface)
     .qosh(f).qosh(g).olib_tashla("nom")

  ⭐ Hammasi "funksiya — birinchi darajali obyekt" ga tayanadi.
""")

Natijaning muhim qismi:

text
=== 1. Asosiy quvur ===

  Quvur(tozala → izohsiz → songa → statistika)

  Natija:      [42.0, 17.5, 8.0, -3.0, 99.0, 100.0, 0.0]
  Tarix:       tozala → izohsiz → songa → statistika
  Noto'g'ri:   ['notogri']
  Statistika:
    soni       7
    jami       263.50
    ortacha    37.64
    min        -3.00
    max        100.00

=== 2. Quvurni kengaytirish ===

  Quvur(tozala → izohsiz → songa → musbatlar → yaxlitlash
        → chegarala(3) → statistika)

  Natija:      [42, 18, 8]
  Filtrlangan: 2 ta
  Chegarala:   Chegarala(3, chaqiruvlar=1, tashlangan=2)

Nima ko'rsatdi: 2.1, 2.3, 2.4, 2.7-bo'limlar.


5. To'g'ri va noto'g'ri tushunishlar

Noto'g'ri fikr To'g'risi
"Funksiya — maxsus narsa" Oddiy obyekt, int kabi
"Funksiyani solishtirish mumkin" is/== , </>
"a.metod is a.metod" False — har safar yangi bog'langan metod
"partial — funksiya" functools.partial obyekti
"callable(x) faqat funksiya uchun" Sinf, metod, __call__ obyekt ham
"Funksiyaga atribut qo'shib bo'lmaydi" Mumkin — f.x = 1
"__globals__ — nusxa" Havola — joriy qiymatlar
"if/elif dispatch bilan bir xil" Dispatch O(1), elif O(n)
"__call__ sinf funksiyadan tezroq" Sekinroq (metod qidiruvi)

6. Keng tarqalgan xatolar va yechimlari

1. Funksiyani chaqirib yuborish

python
sorted(r, key=len())                # ❌ TypeError
sorted(r, key=len)                  # ✅

Timer(5, f())                       # ❌ hozir chaqiradi
Timer(5, f)                         # ✅

2. partial da __name__ kutish

python
p = partial(f, 1)
p.__name__                          # ❌ AttributeError
p.func.__name__                     # ✅

3. Bog'langan metodni saqlash

python
d[a.metod] = 1                      # ⚠️ har safar yangi obyekt
d[(a, "metod")] = 1                 # ✅

4. elif zanjiri

python
if x == "a": ...                    # ❌ uzun
elif x == "b": ...

DISPATCH = {"a": f1, "b": f2}       # ✅
DISPATCH[x]()

5. @wraps unutish

python
def dek(f):
    def ichki(*a): return f(*a)     # ⚠️ metadata yo'qoladi
    return ichki

6. Funksiya atributini dekoratordan oldin

python
f.x = 1
f = dekorator(f)                    # ⚠️ x yo'qolishi mumkin
                                    # → @wraps __dict__ ni ko'chiradi

7. __call__ obyektni funksiya deb tekshirish

python
inspect.isfunction(obj)             # ❌ False
callable(obj)                       # ✅

8. Sinf metodini funksiya sifatida uzatish

python
map(A.metod, obyektlar)             # ✅ ishlaydi (self — birinchi argument)
map(a.metod, r)                     # ⚠️ self allaqachon bog'langan

7. Integratsiya — bu bilim qayerda kerak bo'ladi

  • 7.1, 7.10-darslar (o'tilgan): funksiya obyekt, lambda
  • 7.12-dars: map, filter, reduce
  • 8-qism: metodlar, __call__, staticmethod, classmethod
  • 10, 15-qismlar: dekoratorlar, functools to'liq, funksional dasturlash
  • 6.3-dars (o'tilgan): key= funksiyasi
  • 5.12-dars (o'tilgan): match/case vs dispatch
  • Dizayn naqshlari: Strategy, Command, Observer, Plugin

8. Eng yaxshi amaliyotlar

  1. if/elif zanjiri o'rniga dispatch jadvali. O(1) va kengaytiriladi.

  2. Ro'yxatga olish uchun dekorator. @royxatga_ol("nom").

  3. Tur bo'yicha dispatch — singledispatch. isinstance zanjiri o'rniga.

  4. Holat kerak bo'lsa __call__ sinf. repr, meros, atributlar.

  5. Mavjud funksiya argumentini bog'lash — partial. lambda emas.

  6. Dekoratorda @wraps. Metadata va __dict__ ko'chiriladi.

  7. callable(x) bilan tekshiring. isfunction juda tor.

  8. Funksiya atributlarini dekorator uchun ishlating. Statistika, konfiguratsiya.


9. Amaliy topshiriq

Vazifa 1: Natijani bashorat qiling

python
def f(): return 1
class A:
    def m(self): return 2
    def __call__(self): return 3
a = A()

1.  print(type(f))
2.  print(callable(f), callable(a), callable(A))
3.  f.x = 1; print(f.__dict__)
4.  print(a.m is a.m)
5.  print(a.m == a.m)
6.  print(a.m.__self__ is a)
7.  print(A.m(a))
8.  print(a())
9.  from functools import partial
    p = partial(f); print(type(p).__name__)
10. print(len({f, print, len}))
11. print(f < print)
12. import inspect
    print(inspect.isfunction(a.m), inspect.ismethod(a.m))
Javoblar
  1. <class 'function'>
  2. True True True
  3. {'x': 1}
  4. False — har safar yangi
  5. True — qiymat bo'yicha teng
  6. True
  7. 2
  8. 3 — __call__
  9. partial
  10. 3
  11. TypeError — tartib yo'q
  12. False True

Vazifa 2: Xatolarni tuzating

python
1.  sorted(r, key=len())
2.  threading.Timer(5, saqla())
3.  p = partial(f, 1); print(p.__name__)
4.  if x == "a": f1()
    elif x == "b": f2()
    elif x == "c": f3()
5.  def dek(f):
        def ichki(*a): return f(*a)
        return ichki
6.  if inspect.isfunction(obj): obj()
7.  d[a.metod] = "izoh"
8.  if isinstance(x, int): ...
    elif isinstance(x, str): ...
    elif isinstance(x, list): ...
Javoblar
python
1.  sorted(r, key=len)
2.  threading.Timer(5, saqla)
3.  print(p.func.__name__)
4.  DISPATCH = {"a": f1, "b": f2, "c": f3}; DISPATCH[x]()
5.  @wraps(f) qo'shing
6.  if callable(obj): obj()
7.  d[(a, "metod")] = "izoh"
8.  @singledispatch ishlating

Vazifa 3: Dispatch tizimi

Yozing:

  1. Registr sinfi — __call__ dekorator sifatida
  2. Metadata, ustuvorlik, shartli ro'yxatga olish
  3. chaqir(nom, *args), barchasini_chaqir(*args)
  4. Nom bo'yicha qidirish (difflib bilan taklif)
  5. singledispatch bilan solishtiring
  6. match/case bilan solishtiring

Vazifa 4: Kompozitsiya kutubxonasi

Yozing:

  1. kompozitsiya(*fs), quvur(*fs)
  2. qoll_n(f, n) — n marta qo'llash
  3. sharti_bilan(shart, f, g) — shartli tanlov
  4. xatoni_ushla(f, sukut) — xavfsiz o'rash
  5. keshla(f) — sodda memoizatsiya
  6. Har biri __name__ va __doc__ sozlasin
  7. Operator sintaksisi (f | g, f >> g)

Vazifa 5: __call__ vs yopilma

Bir vazifani ikki xil yozing:

  1. Validator — sinf va yopilma versiyalari
  2. Sanagich, Kesh, Chegaralovchi
  3. Har biri uchun: xotira, tezlik, repr, holatga kirish
  4. Qaysi biri qachon yaxshiroq — jadval
  5. Meros va kengaytirish imkoniyati

Vazifa 6: Plagin tizimi

To'liq tizim yozing:

  1. Plaginlarni ro'yxatga olish (dekorator)
  2. Bog'liqliklar (talab_qiladi=["a", "b"])
  3. Topologik tartibda bajarish
  4. Xatolarni izolyatsiya qilish
  5. Yoqish/o'chirish
  6. Modul fayllaridan avtomatik yuklash (importlib)
  7. Konfiguratsiya bilan

Vazifa 7: O'ylash

Nega Pythonda funksiyani solishtirish (f < g) mumkin emas, lekin f == g va hash(f) ishlaydi?

Javob

Chunki tenglik ma'noli, tartib esa emas.

== va hash — identiklikka asoslangan:

python
def f(): pass
g = f

f == g                      # True — bir obyekt
f == (lambda: None)         # False
hash(f) == hash(g)          # True

Sukut bo'yicha object.__eq__ — is bilan bir xil, object.__hash__ — id() asosida.

Bu ma'noli: "bu ikkalasi bir xil funksiyami?" — javob bor.

< uchun ma'no yo'q:

python
len < print                 # ??? qaysi biri "kichik"?

Funksiyalar uchun tabiiy tartib mavjud emas:

  • Nom bo'yichami? (abs < len?)
  • Yaratilish vaqti bo'yichami?
  • Xotira manzili bo'yichami? (id() — tasodifiy)
  • Argumentlar soni bo'yichami?

Har bir variant o'zboshimchalik bo'lardi.

Python 2 da mumkin edi:

python
# Python 2
len < print                 # True yoki False — id() asosida

Python 2 har qanday obyektni solishtirishga ruxsat berardi:

python
1 < "abc"                   # True (Python 2)
[1] < {2: 3}                # ishlaydi

Bu — jimgina noto'g'ri natijalar manbai edi:

python
# Python 2
sorted([1, "a", None, [2]])         # ishlaydi, lekin natija ma'nosiz

Python 3 buni tuzatdi:

python
1 < "abc"                   # TypeError
len < print                 # TypeError

Bu — Python 3 ning muhim tuzatishlaridan biri (PEP 3100).

Nega tenglik qoldirildi:

Tenglik va hash har qanday obyekt uchun kerak:

python
x in royxat                 # __eq__ ishlatadi
{f: "izoh"}                 # __hash__ ishlatadi
{f, g}                      # ikkalasi
d.get(f)

Ularsiz funksiyalarni konteynerlarda saqlash mumkin bo'lmasdi.

Umumiy qoida (Python 3):

Amal Sukut xatti-harakat
==, != is bilan bir xil (identiklik)
hash() id() asosida
<, >, <=, >= TypeError

Tartib faqat __lt__ va boshqalar aniq aniqlangan turlarda ishlaydi: sonlar, satrlar, tuple, datetime, Decimal, dataclass(order=True).

Solishtirish kerak bo'lsa:

python
sorted(funksiyalar, key=lambda f: f.__name__)       # nom bo'yicha
sorted(funksiyalar, key=lambda f: f.__code__.co_firstlineno)    # qator
sorted(funksiyalar, key=id)                         # ⚠️ tasodifiy

Ya'ni: aniq mezon ko'rsatiladi. Bu — Zen ning "Aniq yashirinlikdan yaxshi" tamoyili.

Xulosa: Python 3 "ma'nosiz solishtirish" ni taqiqladi. Tenglik — identiklik uchun ma'noli va texnik jihatdan zarur. Tartib — o'zboshimchalik bo'lardi, shuning uchun dasturchi key= bilan uni aniq ko'rsatishi kerak.

Nimani mustahkamlaydi: 2.1, 2.4-bo'limlar.


Xulosa

Bu darsda funksiyaning birinchi darajali obyekt ekanini o'rgandik.

Eng muhim uch fikr:

  1. Funksiya — oddiy obyekt. Uni o'zgaruvchiga bog'lash, konteynerga solish, argument sifatida uzatish, qaytarish, atribut qo'shish va hashlash mumkin. Faqat tartib (<, >) yo'q — chunki u ma'nosiz bo'lardi.

  2. Dispatch jadvali if/elif zanjirini almashtiradi. AMALLAR = {"+": add, ...} — O(1), dinamik kengaytiriladi va xato xabari mavjudlarni ko'rsatadi. Tur bo'yicha esa @singledispatch.

  3. callable — funksiyadan kengroq. Sinflar, metodlar, partial, __call__ li obyektlar ham chaqiriladi. Holat kerak bo'lsa __call__ sinf repr, meros va atributlarga kirish beradi; yopilma esa tezroq va tejamli.

Keyingi darsda map, filter, reduce ni ko'ramiz: funksional dasturlashning uch asosiy vositasi va ular qachon generatordan yaxshiroq.

Funksiyalar · 11-dars yakunlandi

7.11-dars: Funksiya — birinchi darajali obyekt

33 daqvaqt
0belgi
Keyingi dars: 7.12-dars: map, filter, reduce
Telegram'da
Darsda xato koʻrdingizmi?

Izohlar · 0