7.11-dars: Funksiya — birinchi darajali obyekt
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:
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'shishBu — Pythonning eng kuchli xususiyatlaridan biri. Uning ustiga qurilgan:
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 tizimlariLekin nozikliklar bor:
class A:
def metod(self): return 1
A.metod # <function A.metod>
A().metod # <bound method A.metod>
A.metod(A()) # 1
A().metod() # 1Bu darsda:
- Birinchi darajali obyekt nima demak
- Funksiya atributlari va
__dict__ - Yuqori tartibli funksiyalar (higher-order)
callableobyektlar:__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:
def salom(): return "Salom!"
f = salom
f() # "Salom!"
f is salom # True — bir obyekt2. Konteynerga solish:
amallar = [len, str, abs]
[f(-5) for f in amallar] # ❌ len(-5) xato
AMALLAR = {"+": operator.add, "-": operator.sub}
AMALLAR["+"](2, 3) # 53. Argument sifatida uzatish:
def qoll(f, x):
return f(x)
qoll(abs, -5) # 5
qoll(len, "abc") # 34. Qaytarish:
def kopaytiruvchi(n):
def ichki(x):
return x * n
return ichki5. Ichma-ich aniqlash:
def tashqi():
def ichki(): ...
return ichki6. Atribut qo'shish:
def f(): ...
f.chaqiruvlar = 0
f.metadata = {"versiya": "1.0"}7. Solishtirish va hashlash:
f is g # ✅ identiklik
{f, g} # ✅ to'plamda
{f: "izoh"} # ✅ lug'at kalitiNima MUMKIN EMAS:
f < g # ❌ TypeError — tartib yo'q
f + g # ❌
len(f) # ❌
f[0] # ❌2.2. Funksiya atributlari
def f(a: int, b: str = "x") -> bool:
"""Docstring."""
return TrueStandart 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:
def f(): ...
f.chaqiruvlar = 0
f.__dict__ # {'chaqiruvlar': 0}Bu — dekoratorlarda keng ishlatiladi:
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:
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:
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:
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:
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 natijaDekorator — yuqori tartibli funksiyaning eng muhim namunasi:
def dekorator(f): # funksiya oladi
def ichki(*a, **kw):
return f(*a, **kw)
return ichki # funksiya qaytaradi10-qismda batafsil.
2.4. callable obyektlar
Funksiya — chaqiriladigan obyektlarning bir turi. Boshqalari:
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:
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:
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):
a = A()
m = a.metod
m() # 1 — self avtomatik uzatiladi
m.__self__ is a # True
m.__func__ is A.metod # Truea.metod har murojaatda yangi obyekt yaratadi:
a.metod is a.metod # False!
a.metod == a.metod # True8-qismda batafsil.
2.5. Dispatch jadvallari
if/elif zanjiri o'rniga lug'at:
# ❌ 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 (
elifzanjiri O(n)) - Yangi amal qo'shish — bir qator
- Ro'yxatni dinamik kengaytirish mumkin
- Test qilish oson
Ro'yxatga olish dekoratori:
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 - bfunctools.singledispatch — tur bo'yicha:
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):
match amal:
case "+": return a + b
case "-": return a - bmatch — statik naqshlar uchun, dispatch jadvali — dinamik uchun.
2.6. functools
partial — qisman qo'llash:
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) # 1024partial ichida:
kvadrat.func # kuch
kvadrat.args # ()
kvadrat.keywords # {'daraja': 2} partial — funksiya emas:
type(kvadrat) # <class 'functools.partial'>
callable(kvadrat) # True
kvadrat.__name__ # ❌ AttributeErrorpartialmethod — metodlar uchun:
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:
from functools import cache, lru_cache
@cache # 3.9+, cheksiz
def fib(n): ...
@lru_cache(maxsize=128)
def qimmat(x): ...cached_property:
from functools import cached_property
class A:
@cached_property
def qimmat_hisob(self):
return ogir_amal() # bir marta hisoblanadi2.7. Amaliy naqshlar
1. Strategiya (Strategy pattern):
def qayta_ishla(malumot, strategiya=sorted):
return strategiya(malumot)2. Callback:
def yukla(url, muvaffaqiyat, xato=None):
try:
natija = _yukla(url)
muvaffaqiyat(natija)
except Exception as x:
if xato:
xato(x)3. Plagin tizimi:
PLAGINLAR = []
def plagin(f):
PLAGINLAR.append(f)
return f4. Middleware zanjiri:
def zanjir(*middleware):
def qoll(sorov):
for m in middleware:
sorov = m(sorov)
return sorov
return qoll5. Kechiktirilgan hisoblash:
kechiktirilgan = partial(qimmat_hisob, malumot)
# ... keyinroq ...
natija = kechiktirilgan()6. Funksiyalarni saralash/filtrlash:
funksiyalar = [f for f in vars(modul).values()
if callable(f) and f.__name__.startswith("test_")]3. Tez ma'lumotnoma
Birinchi darajali obyekt
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
__name__, __qualname__, __doc__, __module__
__defaults__, __kwdefaults__, __annotations__
__code__ (co_varnames, co_argcount, ...)
__globals__ (havola!), __closure__
__dict__ (foydalanuvchi atributlari)
__wrapped__ (@wraps)callable obyektlar
funksiya, lambda, sinf, metod, __call__ li obyekt
callable(x) bilan tekshirish
class K:
def __call__(self, x): ... holat + repr + merosMetodlar
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
AMALLAR = {"+" : add, "-": sub}
AMALLAR[amal](a, b) O(1), kengaytiriladi
@royxatga_ol("nom") dekorator bilan
@singledispatch tur bo'yichafunctools
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 dispatch4. Batafsil misollar
Misol 1 — Nima qilish mumkin
"""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:
=== 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: TrueNima ko'rsatdi: 2.1, 2.2, 2.4-bo'limlar.
Misol 2 — Yuqori tartibli funksiyalar
"""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:
=== 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 sNima ko'rsatdi: 2.3, 2.6-bo'limlar.
Misol 3 — Dispatch va callable obyektlar
"""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:
=== 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 TrueNima ko'rsatdi: 2.4, 2.5-bo'limlar.
Misol 4 — Amaliy: plagin va quvur tizimi
"""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:
=== 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
sorted(r, key=len()) # ❌ TypeError
sorted(r, key=len) # ✅
Timer(5, f()) # ❌ hozir chaqiradi
Timer(5, f) # ✅2. partial da __name__ kutish
p = partial(f, 1)
p.__name__ # ❌ AttributeError
p.func.__name__ # ✅3. Bog'langan metodni saqlash
d[a.metod] = 1 # ⚠️ har safar yangi obyekt
d[(a, "metod")] = 1 # ✅4. elif zanjiri
if x == "a": ... # ❌ uzun
elif x == "b": ...
DISPATCH = {"a": f1, "b": f2} # ✅
DISPATCH[x]()5. @wraps unutish
def dek(f):
def ichki(*a): return f(*a) # ⚠️ metadata yo'qoladi
return ichki6. Funksiya atributini dekoratordan oldin
f.x = 1
f = dekorator(f) # ⚠️ x yo'qolishi mumkin
# → @wraps __dict__ ni ko'chiradi7. __call__ obyektni funksiya deb tekshirish
inspect.isfunction(obj) # ❌ False
callable(obj) # ✅8. Sinf metodini funksiya sifatida uzatish
map(A.metod, obyektlar) # ✅ ishlaydi (self — birinchi argument)
map(a.metod, r) # ⚠️ self allaqachon bog'langan7. 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,
functoolsto'liq, funksional dasturlash - 6.3-dars (o'tilgan):
key=funksiyasi - 5.12-dars (o'tilgan):
match/casevs dispatch - Dizayn naqshlari: Strategy, Command, Observer, Plugin
8. Eng yaxshi amaliyotlar
if/elifzanjiri o'rniga dispatch jadvali. O(1) va kengaytiriladi.Ro'yxatga olish uchun dekorator.
@royxatga_ol("nom").Tur bo'yicha dispatch —
singledispatch.isinstancezanjiri o'rniga.Holat kerak bo'lsa
__call__sinf.repr, meros, atributlar.Mavjud funksiya argumentini bog'lash —
partial.lambdaemas.Dekoratorda
@wraps. Metadata va__dict__ko'chiriladi.callable(x)bilan tekshiring.isfunctionjuda tor.Funksiya atributlarini dekorator uchun ishlating. Statistika, konfiguratsiya.
9. Amaliy topshiriq
Vazifa 1: Natijani bashorat qiling
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
<class 'function'>True True True{'x': 1}False— har safar yangiTrue— qiymat bo'yicha tengTrue23—__call__partial3-
TypeError— tartib yo'q False True
Vazifa 2: Xatolarni tuzating
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
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 ishlatingVazifa 3: Dispatch tizimi
Yozing:
Registrsinfi —__call__dekorator sifatida- Metadata, ustuvorlik, shartli ro'yxatga olish
chaqir(nom, *args),barchasini_chaqir(*args)- Nom bo'yicha qidirish (
difflibbilan taklif) singledispatchbilan solishtiringmatch/casebilan solishtiring
Vazifa 4: Kompozitsiya kutubxonasi
Yozing:
kompozitsiya(*fs),quvur(*fs)qoll_n(f, n)— n marta qo'llashsharti_bilan(shart, f, g)— shartli tanlovxatoni_ushla(f, sukut)— xavfsiz o'rashkeshla(f)— sodda memoizatsiya- Har biri
__name__va__doc__sozlasin - Operator sintaksisi (
f | g,f >> g)
Vazifa 5: __call__ vs yopilma
Bir vazifani ikki xil yozing:
Validator— sinf va yopilma versiyalariSanagich,Kesh,Chegaralovchi- Har biri uchun: xotira, tezlik,
repr, holatga kirish - Qaysi biri qachon yaxshiroq — jadval
- Meros va kengaytirish imkoniyati
Vazifa 6: Plagin tizimi
To'liq tizim yozing:
- Plaginlarni ro'yxatga olish (dekorator)
- Bog'liqliklar (
talab_qiladi=["a", "b"]) - Topologik tartibda bajarish
- Xatolarni izolyatsiya qilish
- Yoqish/o'chirish
- Modul fayllaridan avtomatik yuklash (
importlib) - 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:
def f(): pass
g = f
f == g # True — bir obyekt
f == (lambda: None) # False
hash(f) == hash(g) # TrueSukut 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:
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 2
len < print # True yoki False — id() asosidaPython 2 har qanday obyektni solishtirishga ruxsat berardi:
1 < "abc" # True (Python 2)
[1] < {2: 3} # ishlaydiBu — jimgina noto'g'ri natijalar manbai edi:
# Python 2
sorted([1, "a", None, [2]]) # ishlaydi, lekin natija ma'nosizPython 3 buni tuzatdi:
1 < "abc" # TypeError
len < print # TypeErrorBu — Python 3 ning muhim tuzatishlaridan biri (PEP 3100).
Nega tenglik qoldirildi:
Tenglik va hash har qanday obyekt uchun kerak:
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:
sorted(funksiyalar, key=lambda f: f.__name__) # nom bo'yicha
sorted(funksiyalar, key=lambda f: f.__code__.co_firstlineno) # qator
sorted(funksiyalar, key=id) # ⚠️ tasodifiyYa'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:
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.Dispatch jadvali
if/elifzanjirini almashtiradi.AMALLAR = {"+": add, ...}— O(1), dinamik kengaytiriladi va xato xabari mavjudlarni ko'rsatadi. Tur bo'yicha esa@singledispatch.callable— funksiyadan kengroq. Sinflar, metodlar,partial,__call__li obyektlar ham chaqiriladi. Holat kerak bo'lsa__call__sinfrepr, 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.
Izohlar · 0
Izoh yozish uchun kiring.