Funksiyalar: parametrlar, ko'rinish doirasi va closure'lar

def bmi(vazn_kg: float, boy_m: float) -> float:
    """Tana massasi indeksini hisoblaydi.
 
    Args:
        vazn_kg: vazn, kilogrammda.
        boy_m: bo'y, metrda.
 
    Returns:
        BMI qiymati.
    """
    return vazn_kg / boy_m ** 2
 
 
bmi(70, 1.75)    # 22.857...

def min_max(sonlar: list[float]) -> tuple[float, float]:
    return min(sonlar), max(sonlar)      # aslida bitta tuple qaytadi
 
kichik, katta = min_max([3, 1, 4])

# ❌ Ichma-ich if'lar
def chegirma(user, summa):
    if user is not None:
        if user.is_active:
            if summa > 100_000:
                return summa * 0.1
    return 0
 
# ✅ Erta qaytish — tekis, o'qiladigan
def chegirma(user, summa):
    if user is None or not user.is_active:
        return 0
    if summa <= 100_000:
        return 0
    return summa * 0.1

def salomlash(ism, salom="Assalomu alaykum", belgi="!"):
    return f"{salom}, {ism}{belgi}"
 
salomlash("Aziz")                         # pozitsion
salomlash("Aziz", "Salom")                # pozitsion, ikkitasi
salomlash("Aziz", belgi=".")              # kalit so'zli (keyword) — tartib muhim emas
salomlash(belgi="?", ism="Aziz")          # hammasi kalit so'zli

def jami(*sonlar):              # istalgancha pozitsion → tuple
    return sum(sonlar)
 
jami(1, 2, 3)                   # 6
 
def log_event(nom, **maydonlar):   # istalgancha kalit so'zli → dict
    print(nom, maydonlar)
 
log_event("login", user_id=42, ip="10.0.0.1")
# login {'user_id': 42, 'ip': '10.0.0.1'}

params = {"w": 3, "h": 4}
def yuza(w, h): return w * h
 
yuza(**params)          # yuza(w=3, h=4)
yuza(*[3, 4])           # yuza(3, 4)

def wrapper(*args, **kwargs):
    print("chaqirildi:", args, kwargs)
    return asl_funksiya(*args, **kwargs)    # hamma narsani o'zgarishsiz uzatadi

def f(a, b, /, c, *, d):
    ...
#     ↑     ↑     ↑
#     |     |     └── * dan keyingilar — FAQAT kalit so'z bilan
#     |     └──────── oddiy: ikkala usulda ham
#     └────────────── / dan oldingilar — FAQAT pozitsion
 
f(1, 2, 3, d=4)          # ✅
f(1, 2, c=3, d=4)        # ✅
f(1, 2, 3, 4)            # ❌ d faqat kalit so'z bilan
f(a=1, b=2, c=3, d=4)    # ❌ a, b faqat pozitsion

def generate(prompt: str, *, max_tokens: int = 1024, temperature: float = 1.0, stream: bool = False):
    ...
 
generate("Salom", stream=True)       # ✅ aniq
generate("Salom", 1024, 0.5, True)   # ❌ TypeError — True nima ekani noaniq bo'lardi

def add_item(item, items=[]):
    items.append(item)
    return items
 
print(add_item(1))   # [1]
print(add_item(2))   # [1, 2]  ← ?!

def add_item(item, items: list | None = None) -> list:
    if items is None:
        items = []
    items.append(item)
    return items

x = "global"
 
def tashqi():
    x = "enclosing"
    def ichki():
        x = "local"
        print(x)          # local
    ichki()
    print(x)              # enclosing
 
tashqi()
print(x)                  # global

x = 10
 
def f():
    print(x)    # UnboundLocalError: cannot access local variable 'x'...
    x = 5       # ← shu qator tufayli x butun f ichida lokal
 
f()

hisob = 0
 
def oshir():
    global hisob        # "modul darajasidagi hisob'ni o'zgartiraman"
    hisob += 1

list = [1, 2, 3]       # endi list — sizning ro'yxatingiz, tip emas
list("abc")            # TypeError: 'list' object is not callable

def kvadrat(x):
    return x * x
 
f = kvadrat                  # funksiyani o'zgaruvchiga saqlash (qavssiz!)
f(5)                         # 25
amallar = {"kv": kvadrat, "abs": abs}
amallar["kv"](3)             # 9 — lug'atda saqlash
 
kvadrat.__name__             # 'kvadrat'
kvadrat.__doc__              # docstring

def apply_all(fns, x):
    return [fn(x) for fn in fns]
 
apply_all([str.upper, str.lower, len], "Salom")   # ['SALOM', 'salom', 5]

kvadrat = lambda x: x * x            # ❌ — bunday qilmang, def yozing
sorted(juftlar, key=lambda p: p[1])  # ✅ — bir martalik, qisqa

def make_multiplier(n):
    def multiply(x):
        return x * n          # n — tashqi funksiyadan
    return multiply
 
double = make_multiplier(2)
triple = make_multiplier(3)
double(5), triple(5)          # (10, 15)

def make_counter():
    count = 0
    def increment():
        nonlocal count        # tashqi count'ni qayta bog'lash uchun
        count += 1
        return count
    return increment
 
c = make_counter()
c(); c()
print(c())                    # 3

import time
 
def make_rate_limiter(max_calls: int, per_seconds: float):
    calls: list[float] = []
 
    def allow() -> bool:
        now = time.monotonic()
        while calls and now - calls[0] > per_seconds:   # eski chaqiruvlarni tashlash
            calls.pop(0)
        if len(calls) < max_calls:
            calls.append(now)
            return True
        return False
 
    return allow
 
allow = make_rate_limiter(max_calls=5, per_seconds=60)
if allow():
    ...  # so'rov yuborish

fns = [lambda: i for i in range(3)]
[f() for f in fns]             # [2, 2, 2] — [0, 1, 2] emas!

fns = [lambda i=i: i for i in range(3)]
[f() for f in fns]             # [0, 1, 2]

def faktorial(n: int) -> int:
    if n <= 1:                 # tayanch holat (base case) — SHART
        return 1
    return n * faktorial(n - 1)

def json_depth(obj) -> int:
    """Ichma-ich JSON'ning chuqurligi."""
    if isinstance(obj, dict):
        return 1 + max((json_depth(v) for v in obj.values()), default=0)
    if isinstance(obj, list):
        return 1 + max((json_depth(v) for v in obj), default=0)
    return 0
 
json_depth({"a": [{"b": 1}], "c": 2})   # 3

from functools import lru_cache
 
@lru_cache(maxsize=None)
def fib(n: int) -> int:
    return n if n < 2 else fib(n - 1) + fib(n - 2)
 
fib(100)            # 354224848179261915075 — bir zumda (keshsiz — koinot umridan uzoq)
fib.cache_info()    # CacheInfo(hits=98, misses=101, maxsize=None, currsize=101)

from functools import partial
 
int_from_binary = partial(int, base=2)
int_from_binary("1010")          # 10
 
def call_llm(prompt, *, model, effort): ...
quick = partial(call_llm, model="claude-opus-5-5", effort="low")
deep = partial(call_llm, model="claude-opus-5-5", effort="high")
quick("Bu sharh ijobiymi?")

from functools import reduce
 
reduce(lambda a, b: a * b, [1, 2, 3, 4])   # 24