11.6-dars: O'zgaruvchan standart argument tuzog'i

@dataclass
class Buyurtma:
    raqam: int
    savat: Savat = Savat()        # ✅ dataclass xato bermadi

b1, b2 = Buyurtma(1), Buyurtma(2)
b1.savat.qosh("non")
b2.savat.mahsulotlar              # ['non'] — boshqa mijozning savati!

def tashqi():
    def ichki(a=(1, 2), b=[1, 2]):
        ...
    return ichki

LOAD_CONST        ((1, 2))          ← o'zgarmas kortej — kompilyatsiyada tayyor konstanta
LOAD_SMALL_INT    1
LOAD_SMALL_INT    2
BUILD_LIST        2                 ← ro'yxat HAR SAFAR def bajarilganda quriladi
BUILD_TUPLE       2                 ← sukutlar korteji
LOAD_CONST        <code object ichki>
MAKE_FUNCTION
SET_FUNCTION_ATTRIBUTE 1 (defaults) ← kortej funksiyaning __defaults__ iga yoziladi
STORE_FAST        ichki

import types
toza = types.FunctionType(f.__code__, f.__globals__, f.__name__,
                          f.__defaults__ and tuple(copy.deepcopy(f.__defaults__)),
                          f.__closure__)
toza.__kwdefaults__ = copy.deepcopy(f.__kwdefaults__)

def bajarilganda → sukut ifodasi hisoblanadi → __defaults__ / __kwdefaults__
chaqiruvda → o'sha obyekt parametrga bog'lanadi
o'zgarmas konstanta → co_consts dan; ro'yxat/lug'at → BUILD_LIST/BUILD_MAP def paytida

modul def, metod (klass tanasi)          → bitta sukut
ichki def (har tashqi chaqiruv), sikl def → har safar yangi

__init__(self, x=[])        dataclass: x: K = K()        NamedTuple: x: list = []
partial(f, [])              class K: x = []              dict.fromkeys(k, [])

def f(x=None): x = [] if x is None else x
field(default_factory=Savat)
self.teglar = list(teglar) if teglar is not None else []

f.__defaults__, f.__kwdefaults__
dataclasses.fields(K)[i].default
NamedTuple._field_defaults

"""Sukut qiymat def paytida quriladi: dis, __defaults__ identifikatsiyasi, ichki va sikldagi def, xotira o'sishi."""

import dis


def opkodlar(funksiya):
    return [i.opname for i in dis.get_instructions(funksiya)
            if i.opname in ("LOAD_CONST", "BUILD_LIST", "BUILD_MAP", "BUILD_TUPLE", "MAKE_FUNCTION",
                            "SET_FUNCTION_ATTRIBUTE", "CALL")]


def tashqi():
    def ichki(a=(1, 2), b=[1, 2], c={"k": 1}):
        return a, b, c
    return ichki


print("=== 1. def paytidagi amallar ===")
print(f"  {opkodlar(tashqi)}")
print("  o'zgarmas kortej — LOAD_CONST, ro'yxat va lug'at — har def da BUILD_LIST / BUILD_MAP")

print("\n=== 2. Modul darajasidagi funksiya: bitta sukut ===")


def qosh(qiymat, royxat=[]):
    royxat.append(qiymat)
    return royxat


natijalar = [qosh(i) for i in range(3)]
print(f"  natijalar: {natijalar}")
print(f"  hammasi bitta obyekt: {all(n is qosh.__defaults__[0] for n in natijalar)}")

print("\n=== 3. Ichki def: har tashqi chaqiruv — yangi sukut ===")
f1, f2 = tashqi(), tashqi()
f1()[1].append(99)
print(f"  f1 sukuti o'zgartirildi → f1: {f1()[1]}, f2: {f2()[1]}, bitta obyekt: {f1.__defaults__[1] is f2.__defaults__[1]}")
print(f"  o'zgarmas kortej esa bitta konstanta: {f1.__defaults__[0] is f2.__defaults__[0]}")

print("\n=== 4. Sikldagi def: alohida sukut, lekin kechikkan i ===")
funksiyalar = []
for i in range(3):
    def yozuv(x=[]):
        x.append(i)
        return x
    funksiyalar.append(yozuv)
print(f"  sukutlar alohida: {funksiyalar[0].__defaults__[0] is not funksiyalar[1].__defaults__[0]}")
print(f"  natijalar: {[f() for f in funksiyalar]}   ⚠️ i — global, chaqiruv paytidagi qiymat")
funksiyalar2 = []
for i in range(3):
    def yozuv2(x=None, i=i):
        x = [] if x is None else x
        x.append(i)
        return x
    funksiyalar2.append(yozuv2)
print(f"  ✅ i=i va x=None: {[f() for f in funksiyalar2]}")

print("\n=== 5. Sukut — yashirin havola: kesh cheksiz o'sadi ===")


def narx_ol(mahsulot, _kesh={}):
    if mahsulot not in _kesh:
        _kesh[mahsulot] = len(mahsulot) * 1000
    return _kesh[mahsulot]


for i in range(10_000):
    narx_ol(f"mahsulot-{i}")
print(f"  10 000 noyob so'rovdan keyin sukut lug'atida: {len(narx_ol.__defaults__[0])} yozuv — hech qachon bo'shamaydi")

=== 1. def paytidagi amallar ===
  ['LOAD_CONST', 'BUILD_LIST', 'LOAD_CONST', 'BUILD_MAP', 'BUILD_TUPLE', 'LOAD_CONST', 'MAKE_FUNCTION', 'SET_FUNCTION_ATTRIBUTE']
  o'zgarmas kortej — LOAD_CONST, ro'yxat va lug'at — har def da BUILD_LIST / BUILD_MAP

=== 2. Modul darajasidagi funksiya: bitta sukut ===
  natijalar: [[0, 1, 2], [0, 1, 2], [0, 1, 2]]
  hammasi bitta obyekt: True

=== 3. Ichki def: har tashqi chaqiruv — yangi sukut ===
  f1 sukuti o'zgartirildi → f1: [1, 2, 99], f2: [1, 2], bitta obyekt: False
  o'zgarmas kortej esa bitta konstanta: True

=== 4. Sikldagi def: alohida sukut, lekin kechikkan i ===
  sukutlar alohida: True
  natijalar: [[2], [2], [2]]   ⚠️ i — global, chaqiruv paytidagi qiymat
  ✅ i=i va x=None: [[0], [1], [2]]

=== 5. Sukut — yashirin havola: kesh cheksiz o'sadi ===
  10 000 noyob so'rovdan keyin sukut lug'atida: 10000 yozuv — hech qachon bo'shamaydi

"""__init__, dataclass (tekshiruvdan o'tadigan maxsus klass), NamedTuple, partial, modul konstantasi."""

import functools
from dataclasses import dataclass, field
from typing import NamedTuple


class Savat:
    def __init__(self):
        self.mahsulotlar = []

    def qosh(self, m):
        self.mahsulotlar.append(m)


print("=== 1. __init__ sukuti ===")


class Mijoz:
    def __init__(self, ism, teglar=[]):
        self.ism = ism
        self.teglar = teglar


a, b = Mijoz("Aziz"), Mijoz("Dilnoza")
a.teglar.append("VIP")
print(f"  Dilnoza teglari: {b.teglar}, bitta ro'yxat: {a.teglar is b.teglar}")


class MijozToza:
    def __init__(self, ism, teglar=None):
        self.ism = ism
        self.teglar = list(teglar) if teglar is not None else []


a, b = MijozToza("Aziz"), MijozToza("Dilnoza")
a.teglar.append("VIP")
print(f"  ✅ None + list(): Dilnoza teglari: {b.teglar}")

print("\n=== 2. dataclass: list taqiqlanadi, maxsus klass — yo'q ===")
try:
    @dataclass
    class Buyurtma1:
        raqam: int
        savat: list = []
except ValueError as e:
    print(f"  list sukut: ValueError: {e}")


@dataclass
class Buyurtma2:
    raqam: int
    savat: Savat = Savat()


b1, b2 = Buyurtma2(1), Buyurtma2(2)
b1.savat.qosh("non")
print(f"  ⚠️ Savat() sukut: b2 savati {b2.savat.mahsulotlar}, bitta obyekt: {b1.savat is b2.savat}")
print(f"     Savat xeshlanadimi: {Savat.__hash__ is not None} — tekshiruv shu bo'yicha")


@dataclass
class Buyurtma3:
    raqam: int
    savat: Savat = field(default_factory=Savat)


b1, b2 = Buyurtma3(1), Buyurtma3(2)
b1.savat.qosh("non")
print(f"  ✅ default_factory: b2 savati {b2.savat.mahsulotlar}")

print("\n=== 3. NamedTuple — tekshiruv umuman yo'q ===")


class Nuqta(NamedTuple):
    x: int
    teglar: list = []


p1, p2 = Nuqta(1), Nuqta(2)
p1.teglar.append("boshlang'ich")
print(f"  p2.teglar: {p2.teglar}, _field_defaults: {Nuqta._field_defaults}")

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


def yozuvga_qosh(qiymat, jurnal):
    jurnal.append(qiymat)
    return jurnal


tizim_jurnali = functools.partial(yozuvga_qosh, jurnal=[])
tizim_jurnali("ishga tushdi")
tizim_jurnali("ulanish")
print(f"  partial ning barcha chaqiruvlari bitta ro'yxatga: {tizim_jurnali.keywords['jurnal']}")

print("\n=== 5. Modul konstantasini qaytarish ===")
STANDART_RUXSATLAR = ["o'qish"]


def ruxsatlar(rol):
    if rol == "mehmon":
        return STANDART_RUXSATLAR
    return STANDART_RUXSATLAR + ["yozish"]


ruxsatlar("mehmon").append("o'chirish")
print(f"  mehmon ruxsatlari endi: {ruxsatlar('mehmon')}, konstanta: {STANDART_RUXSATLAR}")
STANDART_RUXSATLAR_TOZA = ("o'qish",)
print(f"  ✅ tuple konstanta: {STANDART_RUXSATLAR_TOZA} — append imkonsiz")

=== 1. __init__ sukuti ===
  Dilnoza teglari: ['VIP'], bitta ro'yxat: True
  ✅ None + list(): Dilnoza teglari: []

=== 2. dataclass: list taqiqlanadi, maxsus klass — yo'q ===
  list sukut: ValueError: mutable default <class 'list'> for field savat is not allowed: use default_factory
  ⚠️ Savat() sukut: b2 savati ['non'], bitta obyekt: True
     Savat xeshlanadimi: True — tekshiruv shu bo'yicha
  ✅ default_factory: b2 savati []

=== 3. NamedTuple — tekshiruv umuman yo'q ===
  p2.teglar: ["boshlang'ich"], _field_defaults: {'teglar': ["boshlang'ich"]}

=== 4. functools.partial ===
  partial ning barcha chaqiruvlari bitta ro'yxatga: ['ishga tushdi', 'ulanish']

=== 5. Modul konstantasini qaytarish ===
  mehmon ruxsatlari endi: ["o'qish", "o'chirish"], konstanta: ["o'qish", "o'chirish"]
  ✅ tuple konstanta: ("o'qish",) — append imkonsiz

"""Ish vaqtida (inspect, dataclasses, NamedTuple) va statik (ast) tekshiruv: har ikki usul nimani topadi va nimani o'tkazib yuboradi."""

import ast
import dataclasses
import functools
import inspect
import textwrap
import types
from typing import NamedTuple

OZGARMAS = (int, float, complex, str, bytes, bool, type(None), tuple, frozenset, type, types.FunctionType, range)


def ozgaruvchanmi(qiymat):
    if isinstance(qiymat, OZGARMAS):
        return isinstance(qiymat, tuple) and any(ozgaruvchanmi(x) for x in qiymat)
    return True


def ish_vaqtida_tekshir(nomlar_maydoni, modul_nomi):
    topilgan = []
    for nom, obj in nomlar_maydoni.items():
        if not isinstance(obj, functools.partial) and getattr(obj, "__module__", None) != modul_nomi:
            continue                                   # import qilingan narsalar — boshqa modulniki
        funksiyalar = []
        if inspect.isfunction(obj):
            funksiyalar.append((nom, obj))
        elif inspect.isclass(obj):
            if dataclasses.is_dataclass(obj):
                for f in dataclasses.fields(obj):
                    if f.default is not dataclasses.MISSING and ozgaruvchanmi(f.default):
                        topilgan.append(f"{nom}.{f.name}: dataclass sukuti {type(f.default).__name__}")
            if issubclass(obj, tuple) and hasattr(obj, "_field_defaults"):
                for maydon, qiymat in obj._field_defaults.items():
                    if ozgaruvchanmi(qiymat):
                        topilgan.append(f"{nom}.{maydon}: NamedTuple sukuti {type(qiymat).__name__}")
            for mnom, m in vars(obj).items():
                if inspect.isfunction(m):
                    if not (dataclasses.is_dataclass(obj) and mnom == "__init__"):   # maydonlar yuqorida
                        funksiyalar.append((f"{nom}.{mnom}", m))
                elif not mnom.startswith("_") and not callable(m) and not hasattr(type(m), "__get__") \
                        and ozgaruvchanmi(m) and not dataclasses.is_dataclass(obj):
                    topilgan.append(f"{nom}.{mnom}: klass atributi {type(m).__name__}")
        elif isinstance(obj, functools.partial):
            for q in list(obj.args) + list(obj.keywords.values()):
                if ozgaruvchanmi(q):
                    topilgan.append(f"{nom}: partial argumenti {type(q).__name__}")
        for fnom, f in funksiyalar:
            imzo = inspect.signature(f)
            for p in imzo.parameters.values():
                if p.default is not p.empty and ozgaruvchanmi(p.default):
                    topilgan.append(f"{fnom}({p.name}=...): sukut {type(p.default).__name__}")
    return topilgan


MANBA = textwrap.dedent('''
    from dataclasses import dataclass, field
    from typing import NamedTuple
    import functools

    class Savat:
        def __init__(self):
            self.m = []

    def qosh(x, royxat=[]):
        royxat.append(x)

    def toza(x, royxat=None, *, teglar=()):
        return x

    def nomli(*, sozlama={}):
        return sozlama

    class Mijoz:
        standart_teglar = ["yangi"]
        def __init__(self, ism, teglar=set()):
            self.teglar = teglar

    @dataclass
    class Buyurtma:
        raqam: int
        savat: Savat = Savat()
        teglar: list = field(default_factory=list)

    class Nuqta(NamedTuple):
        x: int
        izohlar: list = []

    jurnal = functools.partial(print, [])
''')

print("=== 1. Ish vaqtida (kod bajarilgach) ===")
nomlar = {"__name__": "manba"}
exec(MANBA, nomlar)
for qator in ish_vaqtida_tekshir({k: v for k, v in nomlar.items() if not k.startswith("__")}, "manba"):
    print(f"  {qator}")


class StatikTekshiruvchi(ast.NodeVisitor):
    OZGARUVCHAN_TUGUNLAR = (ast.List, ast.Dict, ast.Set, ast.ListComp, ast.DictComp, ast.SetComp)
    OZGARUVCHAN_CHAQIRUVLAR = {"list", "dict", "set", "defaultdict", "deque", "bytearray"}

    def __init__(self):
        self.topilgan = []

    def _xavfli(self, tugun):
        if isinstance(tugun, self.OZGARUVCHAN_TUGUNLAR):
            return True
        return isinstance(tugun, ast.Call) and isinstance(tugun.func, ast.Name) \
            and tugun.func.id in self.OZGARUVCHAN_CHAQIRUVLAR

    def visit_FunctionDef(self, tugun):
        for sukut in tugun.args.defaults + [d for d in tugun.args.kw_defaults if d is not None]:
            if self._xavfli(sukut):
                self.topilgan.append(f"{tugun.lineno}-qator {tugun.name}(): sukut {ast.unparse(sukut)}")
        self.generic_visit(tugun)

    def visit_ClassDef(self, tugun):
        for element in tugun.body:
            qiymat = getattr(element, "value", None)
            if isinstance(element, (ast.Assign, ast.AnnAssign)) and qiymat is not None and self._xavfli(qiymat):
                self.topilgan.append(f"{element.lineno}-qator {tugun.name}: klass darajasida {ast.unparse(qiymat)}")
        self.generic_visit(tugun)


print("\n=== 2. Statik (ast, kod bajarilmasdan) ===")
t = StatikTekshiruvchi()
t.visit(ast.parse(MANBA))
for qator in t.topilgan:
    print(f"  {qator}")

print("\n=== 3. Solishtirish ===")
print("  ish vaqtida: Savat() dataclass sukutini va partial argumentini topdi (obyekt turini biladi)")
print("  statik: Savat() ni ko'rmadi (qaysi klass o'zgaruvchanligini bilmaydi), lekin kodni bajarmaydi")

=== 1. Ish vaqtida (kod bajarilgach) ===
  qosh(royxat=...): sukut list
  nomli(sozlama=...): sukut dict
  Mijoz.standart_teglar: klass atributi list
  Mijoz.__init__(teglar=...): sukut set
  Buyurtma.savat: dataclass sukuti Savat
  Nuqta.izohlar: NamedTuple sukuti list
  jurnal: partial argumenti list

=== 2. Statik (ast, kod bajarilmasdan) ===
  10-qator qosh(): sukut []
  16-qator nomli(): sukut {}
  20-qator Mijoz: klass darajasida ['yangi']
  21-qator __init__(): sukut set()
  32-qator Nuqta: klass darajasida []

=== 3. Solishtirish ===
  ish vaqtida: Savat() dataclass sukutini va partial argumentini topdi (obyekt turini biladi)
  statik: Savat() ni ko'rmadi (qaysi klass o'zgaruvchanligini bilmaydi), lekin kodni bajarmaydi

"""Sukutdagi kesh testlarni bog'laydi; types.FunctionType bilan toza klon; muqobillar: lru_cache, klass, closure."""

import copy
import types
from functools import lru_cache


def kurs_ol(valyuta, _kesh={}, _sorovlar=[]):
    """'Uchinchi tomon' funksiyasi: tarmoq so'rovlarini sukutdagi keshda saqlaydi."""
    if valyuta not in _kesh:
        _sorovlar.append(valyuta)
        _kesh[valyuta] = {"USD": 12_600, "EUR": 13_700}.get(valyuta, 0)
    return _kesh[valyuta]


def test_bitta_sorov(f):
    f("USD")
    f("USD")
    sorovlar = f.__defaults__[1]
    return "✅" if sorovlar == ["USD"] else f"❌ so'rovlar: {sorovlar}"


def test_ikki_valyuta(f):
    f("USD")
    f("EUR")
    sorovlar = f.__defaults__[1]
    return "✅" if sorovlar == ["USD", "EUR"] else f"❌ so'rovlar: {sorovlar}"


def toza_nusxa(f):
    yangi = types.FunctionType(f.__code__, f.__globals__, f.__name__,
                               copy.deepcopy(f.__defaults__), f.__closure__)
    yangi.__kwdefaults__ = copy.deepcopy(f.__kwdefaults__)
    yangi.__doc__ = f.__doc__
    return yangi


TOZA_HOLAT = toza_nusxa(kurs_ol)                   # hali hech kim chaqirmagan paytdagi nusxa

print("=== 1. ⚠️ Testlar tartibga bog'liq ===")
print(f"  test_ikki_valyuta: {test_ikki_valyuta(kurs_ol)}")
print(f"  test_bitta_sorov:  {test_bitta_sorov(kurs_ol)}   (oldingi test sukutdagi ro'yxatni to'ldirib qo'ygan)")

print("\n=== 2. ✅ Har test uchun toza klon ===")
print(f"  test_ikki_valyuta: {test_ikki_valyuta(toza_nusxa(TOZA_HOLAT))}")
print(f"  test_bitta_sorov:  {test_bitta_sorov(toza_nusxa(TOZA_HOLAT))}")
print(f"  asl funksiya hali ham iflos: {kurs_ol.__defaults__[1]}")

print("\n=== 3. O'z kodimizda — ochiq muqobillar ===")
tarmoq = []


@lru_cache(maxsize=128)
def kurs_lru(valyuta):
    tarmoq.append(valyuta)
    return {"USD": 12_600, "EUR": 13_700}.get(valyuta, 0)


class KursXizmati:
    def __init__(self, manba):
        self._manba = manba
        self._kesh = {}
        self.sorovlar = []

    def ol(self, valyuta):
        if valyuta not in self._kesh:
            self.sorovlar.append(valyuta)
            self._kesh[valyuta] = self._manba(valyuta)
        return self._kesh[valyuta]


def kurs_yasa(manba):
    kesh = {}

    def ol(valyuta):
        if valyuta not in kesh:
            kesh[valyuta] = manba(valyuta)
        return kesh[valyuta]

    ol.tozala = kesh.clear
    return ol


manba = {"USD": 12_600, "EUR": 13_700}.get
for v in ["USD", "USD", "EUR"]:
    kurs_lru(v)
print(f"  lru_cache: so'rovlar {tarmoq}, {kurs_lru.cache_info()}; testda cache_clear()")
xizmat = KursXizmati(manba)
for v in ["USD", "USD", "EUR"]:
    xizmat.ol(v)
print(f"  klass: so'rovlar {xizmat.sorovlar}; testda yangi KursXizmati(soxta_manba)")
ol = kurs_yasa(manba)
print(f"  closure: {ol('USD')}, {ol('USD')}; testda yangi kurs_yasa() yoki ol.tozala()")

print("\n=== 4. Sukut qiymatni ataylab ishlatish — erta bog'lash ===")
tugmalar = [lambda raqam=raqam: f"tugma {raqam}" for raqam in range(3)]
print(f"  {[t() for t in tugmalar]}   (o'zgarmas int — xavfsiz)")

=== 1. ⚠️ Testlar tartibga bog'liq ===
  test_ikki_valyuta: ✅
  test_bitta_sorov:  ❌ so'rovlar: ['USD', 'EUR']   (oldingi test sukutdagi ro'yxatni to'ldirib qo'ygan)

=== 2. ✅ Har test uchun toza klon ===
  test_ikki_valyuta: ✅
  test_bitta_sorov:  ✅
  asl funksiya hali ham iflos: ['USD', 'EUR']

=== 3. O'z kodimizda — ochiq muqobillar ===
  lru_cache: so'rovlar ['USD', 'EUR'], CacheInfo(hits=1, misses=2, maxsize=128, currsize=2); testda cache_clear()
  klass: so'rovlar ['USD', 'EUR']; testda yangi KursXizmati(soxta_manba)
  closure: 12600, 12600; testda yangi kurs_yasa() yoki ol.tozala()

=== 4. Sukut qiymatni ataylab ishlatish — erta bog'lash ===
  ['tugma 0', 'tugma 1', 'tugma 2']   (o'zgarmas int — xavfsiz)

def __init__(self, teglar=[]):
    self.teglar = teglar                        # ❌

def __init__(self, teglar=None):
    self.teglar = list(teglar) if teglar is not None else []   # ✅ nusxa ham

@dataclass
class Buyurtma:
    savat: Savat = Savat()                      # ❌ tekshiruvdan o'tadi, lekin bo'lishiladi

    savat: Savat = field(default_factory=Savat) # ✅

class Nuqta(NamedTuple):
    teglar: list = []                           # ❌

    teglar: tuple = ()                          # ✅

jurnalga = partial(qosh, jurnal=[])             # ❌ hamma chaqiruv bitta ro'yxatga

jurnal = []                                     # ✅ aniq nom — egalik ko'rinib turadi
jurnalga = partial(qosh, jurnal=jurnal)

STANDART = ["o'qish"]
def ruxsatlar():
    return STANDART                             # ❌ chaqiruvchi o'zgartiradi

STANDART = ("o'qish",)                          # ✅ yoki return list(STANDART)

def yozuv(matn, vaqt=datetime.now()):           # ❌ import paytidagi vaqt (7.3-dars)

def yozuv(matn, vaqt=None):
    vaqt = vaqt or datetime.now()               # ✅

def narx(m, _kesh={}): ...                      # ❌ cheksiz o'sish, testlar bog'lanadi

@lru_cache(maxsize=1024)                        # ✅ chegarali va tozalanadigan
def narx(m): ...

def f(royxat=None):
    royxat = royxat or []                       # ❌ chaqiruvchining bo'sh ro'yxati [] yangisi bilan almashadi

    royxat = [] if royxat is None else royxat   # ✅ bo'sh ro'yxat — haqiqiy argument

from dataclasses import dataclass
from typing import NamedTuple
import functools
1.  def f(x=[]):
        x.append(1)
        return len(x)
    print(f(), f(), f([]))
2.  print(f.__defaults__)
3.  def g(n, x=None):
        x = [] if x is None else x
        x.append(n)
        return x
    print(g(1), g(2))
4.  class K:
        def __init__(self, t=[]):
            self.t = t
    a = K()
    b = K()
    a.t.append("x")
    print(b.t, a.t is b.t)
5.  class S:
        pass
    @dataclass
    class D:
        s: S = S()
    print(D().s is D().s)
6.  try:
        @dataclass
        class E:
            l: list = []
    except ValueError:
        print("ValueError")
7.  class N(NamedTuple):
        t: list = []
    N().t.append(1)
    print(N().t)
8.  fs = []
    for i in range(3):
        def h(x=[]):
            return x
        fs.append(h)
    print(fs[0]() is fs[1]())
9.  def yasa():
        def ichki(x=[]):
            x.append(1)
            return x
        return ichki
    print(yasa()(), yasa()())
10. p = functools.partial(lambda x: x.append(1) or x, [])
    print(p(), p())
11. def v(t=(1, 2)):
        return t
    print(v() is v())
12. def w(*, k=[]):
        k.append(0)
        return k
    w()
    print(w.__kwdefaults__)

1.  @dataclass
    class Sessiya:
        foydalanuvchi: str
        savat: Savat = Savat()
        sozlama: dict = None

2.  class Hisobot:
        def __init__(self, qatorlar=[], filtrlar={}):
            self.qatorlar = qatorlar
            self.filtrlar = filtrlar

3.  class Marshrut(NamedTuple):
        nomi: str
        bekatlar: list = []

4.  def jurnal(xabar, darajalar=["INFO"], vaqt=time.time()):
        return f"[{vaqt}] {darajalar[0]}: {xabar}"

5.  def birlashtir(asosiy, qoshimcha=None):
        qoshimcha = qoshimcha or {}
        asosiy.update(qoshimcha)
        return asosiy