11.3-dars: Havola semantikasi

maydon = [[" "] * 3] * 3
maydon[0][0] = "X"
print(maydon)
# [['X', ' ', ' '], ['X', ' ', ' '], ['X', ' ', ' ']]

@dataclass(frozen=True)
class Sozlama:
    ruxsatlar: list

s = Sozlama(["o'qish"])
s.ruxsatlar += ["o'chirish"]      # FrozenInstanceError: cannot assign to field 'ruxsatlar'
s.ruxsatlar                       # ["o'qish", "o'chirish"] — xato berdi, lekin o'zgardi!

class Guruh:
    def __init__(self, talabalar):
        self._talabalar = talabalar          # ⚠️ chaqiruvchining ro'yxati

    @property
    def talabalar(self):
        return self._talabalar               # ⚠️ ichki ro'yxat tashqariga

x = ...                  qayta bog'lash (faqat nom)
x.metod(), x[i] = , x.a = , x[:] = , del x[i]   o'zgartirish (obyekt)
x += y   list/set/dict → o'zgartirish     int/str/tuple → yangi obyekt
x = x + y                har doim yangi obyekt

[[0]*3]*3        ❌    [[0]*3 for _ in range(3)]   ✅
dict.fromkeys(k, [])  ❌    {x: [] for x in k} / defaultdict(list)  ✅
class K: lst = []     ❌    self.lst = [] (__init__ da)  ✅

tuple, frozen dataclass, property, MappingProxyType — sayoz himoya
obj.maydon += [...]  → ichki ro'yxat o'zgaradi VA keyin xato

list — jim o'tkazib yuboradi   dict/set — RuntimeError
for x in list(konteyner):     royxat[:] = [x for x in royxat if ...]

deepcopy / pickle — umumiy qism va sikl saqlanadi
json — umumiy qism yo'qoladi, sikl → ValueError

"""[[x]*n]*m, [[]]*n, dict.fromkeys, klass atributi; umumiy ichki obyektlarni topuvchi funksiya."""


def umumiylar(tuzilma, yol="root", korildi=None, natija=None):
    """Bir nechta joydan ishora qilingan o'zgaruvchan obyektlarni topadi."""
    if korildi is None:
        korildi, natija = {}, {}
    if isinstance(tuzilma, (list, dict, set)):
        if id(tuzilma) in korildi:
            natija.setdefault(id(tuzilma), [korildi[id(tuzilma)]]).append(yol)
            return natija
        korildi[id(tuzilma)] = yol
        elementlar = tuzilma.items() if isinstance(tuzilma, dict) else enumerate(tuzilma)
        for kalit, qiymat in elementlar:
            umumiylar(qiymat, f"{yol}[{kalit!r}]", korildi, natija)
    return natija


print("=== 1. [[' '] * 3] * 3 ===")
yomon = [[" "] * 3] * 3
yomon[0][0] = "X"
print(f"  yurishdan keyin: {yomon}")
print(f"  umumiy qismlar: {list(umumiylar(yomon).values())}")
yaxshi = [[" "] * 3 for _ in range(3)]
yaxshi[0][0] = "X"
print(f"  ✅ comprehension: {yaxshi}, umumiy: {list(umumiylar(yaxshi).values())}")

print("\n=== 2. [0] * 3 xavfsiz — element o'zgarmas ===")
sonlar = [0] * 3
sonlar[0] += 5
print(f"  {sonlar} — uya qayta bog'landi, 0 obyekti o'zgarmadi")

print("\n=== 3. dict.fromkeys va [[]] * n ===")
guruhlar = dict.fromkeys(["A", "B", "C"], [])
guruhlar["A"].append("Aziz")
print(f"  dict.fromkeys: {guruhlar}")
navbatlar = [[]] * 3
navbatlar[1].append("vazifa")
print(f"  [[]] * 3:      {navbatlar}")
from collections import defaultdict
guruhlar2 = defaultdict(list)
guruhlar2["A"].append("Aziz")
print(f"  ✅ defaultdict: {dict(guruhlar2)}, ✅ comprehension: {[[] for _ in range(3)]}")

print("\n=== 4. Klass atributi — hamma nusxalar uchun bitta ===")


class Savat:
    mahsulotlar = []

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


a, b = Savat(), Savat()
a.qosh("non")
print(f"  a.qosh('non') → b.mahsulotlar: {b.mahsulotlar}, bitta obyekt: {a.mahsulotlar is b.mahsulotlar is Savat.mahsulotlar}")


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


print(f"  ✅ __init__ da: {SavatTogri().mahsulotlar is SavatTogri().mahsulotlar}")

print("\n=== 5. Murakkab konfiguratsiyada umumiy qismlar ===")
standart_portlar = [80, 443]
sozlama = {
    "web": {"portlar": standart_portlar, "host": "0.0.0.0"},
    "api": {"portlar": standart_portlar, "host": "127.0.0.1"},
    "zaxira": [standart_portlar, {"portlar": standart_portlar}],
}
for yollar in umumiylar(sozlama).values():
    print(f"  bitta obyekt {len(yollar)} joyda: {yollar}")
sozlama["web"]["portlar"].append(8080)
print(f"  web ga 8080 qo'shildi → api portlari: {sozlama['api']['portlar']}")

=== 1. [[' '] * 3] * 3 ===
  yurishdan keyin: [['X', ' ', ' '], ['X', ' ', ' '], ['X', ' ', ' ']]
  umumiy qismlar: [['root[0]', 'root[1]', 'root[2]']]
  ✅ comprehension: [['X', ' ', ' '], [' ', ' ', ' '], [' ', ' ', ' ']], umumiy: []

=== 2. [0] * 3 xavfsiz — element o'zgarmas ===
  [5, 0, 0] — uya qayta bog'landi, 0 obyekti o'zgarmadi

=== 3. dict.fromkeys va [[]] * n ===
  dict.fromkeys: {'A': ['Aziz'], 'B': ['Aziz'], 'C': ['Aziz']}
  [[]] * 3:      [['vazifa'], ['vazifa'], ['vazifa']]
  ✅ defaultdict: {'A': ['Aziz']}, ✅ comprehension: [[], [], []]

=== 4. Klass atributi — hamma nusxalar uchun bitta ===
  a.qosh('non') → b.mahsulotlar: ['non'], bitta obyekt: True
  ✅ __init__ da: False

=== 5. Murakkab konfiguratsiyada umumiy qismlar ===
  bitta obyekt 4 joyda: ["root['web']['portlar']", "root['api']['portlar']", "root['zaxira'][0]", "root['zaxira'][1]['portlar']"]
  web ga 8080 qo'shildi → api portlari: [80, 443, 8080]

"""Har amal uchun: id o'zgardimi va taxallus o'zgarishni ko'rdimi — list, tuple, str, set, dict."""


def sina(nom, boshlangich, amal_matni):
    muhit = {"x": boshlangich}
    muhit["taxallus"] = muhit["x"]
    eski_id = id(muhit["x"])
    oldingi = repr(muhit["taxallus"])
    exec(amal_matni, {}, muhit)
    yangi_obyekt = id(muhit["x"]) != eski_id
    taxallus_ozgardi = repr(muhit["taxallus"]) != oldingi
    tur = "qayta bog'lash" if yangi_obyekt else "o'zgartirish"
    return f"  {nom:6} {amal_matni:22} {tur:15} id o'zgardi: {str(yangi_obyekt):5}  taxallus ko'rdi: {taxallus_ozgardi}"


print("=== list ===")
for amal in ["x.append(4)", "x[0] = 9", "x[:] = [7, 7]", "x += [4]", "x = x + [4]", "x = [1, 2, 3]",
             "x.sort(reverse=True)", "x = sorted(x)", "del x[0]"]:
    print(sina("list", [1, 2, 3], amal))

print("\n=== tuple, str, int — o'zgarmas ===")
for nom, qiymat, amal in [("tuple", (1, 2), "x += (3,)"), ("str", "ab", "x += 'c'"), ("int", 5000, "x += 1"),
                          ("str", "ab", "x = x.upper()")]:
    print(sina(nom, qiymat, amal))

print("\n=== set, dict ===")
for nom, qiymat, amal in [("set", {1, 2}, "x.add(3)"), ("set", {1, 2}, "x |= {3}"), ("set", {1, 2}, "x = x | {3}"),
                          ("dict", {"a": 1}, "x['b'] = 2"), ("dict", {"a": 1}, "x |= {'b': 2}"),
                          ("dict", {"a": 1}, "x = x | {'b': 2}"), ("dict", {"a": 1}, "x.update(c=3)")]:
    print(sina(nom, qiymat, amal))

=== list ===
  list   x.append(4)            o'zgartirish    id o'zgardi: False  taxallus ko'rdi: True
  list   x[0] = 9               o'zgartirish    id o'zgardi: False  taxallus ko'rdi: True
  list   x[:] = [7, 7]          o'zgartirish    id o'zgardi: False  taxallus ko'rdi: True
  list   x += [4]               o'zgartirish    id o'zgardi: False  taxallus ko'rdi: True
  list   x = x + [4]            qayta bog'lash  id o'zgardi: True   taxallus ko'rdi: False
  list   x = [1, 2, 3]          qayta bog'lash  id o'zgardi: True   taxallus ko'rdi: False
  list   x.sort(reverse=True)   o'zgartirish    id o'zgardi: False  taxallus ko'rdi: True
  list   x = sorted(x)          qayta bog'lash  id o'zgardi: True   taxallus ko'rdi: False
  list   del x[0]               o'zgartirish    id o'zgardi: False  taxallus ko'rdi: True

=== tuple, str, int — o'zgarmas ===
  tuple  x += (3,)              qayta bog'lash  id o'zgardi: True   taxallus ko'rdi: False
  str    x += 'c'               qayta bog'lash  id o'zgardi: True   taxallus ko'rdi: False
  int    x += 1                 qayta bog'lash  id o'zgardi: True   taxallus ko'rdi: False
  str    x = x.upper()          qayta bog'lash  id o'zgardi: True   taxallus ko'rdi: False

=== set, dict ===
  set    x.add(3)               o'zgartirish    id o'zgardi: False  taxallus ko'rdi: True
  set    x |= {3}               o'zgartirish    id o'zgardi: False  taxallus ko'rdi: True
  set    x = x | {3}            qayta bog'lash  id o'zgardi: True   taxallus ko'rdi: False
  dict   x['b'] = 2             o'zgartirish    id o'zgardi: False  taxallus ko'rdi: True
  dict   x |= {'b': 2}          o'zgartirish    id o'zgardi: False  taxallus ko'rdi: True
  dict   x = x | {'b': 2}       qayta bog'lash  id o'zgardi: True   taxallus ko'rdi: False
  dict   x.update(c=3)          o'zgartirish    id o'zgardi: False  taxallus ko'rdi: True

"""frozen dataclass va property da += tuzog'i; kirish/chiqishdagi sizish; himoya nusxalari va o'zgarmas ko'rinishlar."""

from dataclasses import FrozenInstanceError, dataclass, field
from types import MappingProxyType

print("=== 1. ⚠️ frozen dataclass: xato berdi, lekin o'zgardi ===")


@dataclass(frozen=True)
class Sozlama:
    ruxsatlar: list = field(default_factory=list)


s = Sozlama(["o'qish"])
try:
    s.ruxsatlar += ["o'chirish"]
except FrozenInstanceError as e:
    print(f"  FrozenInstanceError: {e}")
print(f"  s.ruxsatlar: {s.ruxsatlar}   ⚠️ __iadd__ allaqachon ishladi")
s.ruxsatlar.append("admin")
print(f"  append ga hech qanday to'siq yo'q: {s.ruxsatlar}")

print("\n=== 2. ⚠️ Setter'siz property ===")


class Hisob:
    def __init__(self):
        self._tarix = []

    @property
    def tarix(self):
        return self._tarix


h = Hisob()
try:
    h.tarix += ["soxta yozuv"]
except AttributeError as e:
    print(f"  AttributeError: {e}")
print(f"  h._tarix: {h._tarix}")

print("\n=== 3. ✅ Chuqur o'zgarmas dataclass ===")


@dataclass(frozen=True)
class SozlamaToza:
    ruxsatlar: tuple = ()
    chegaralar: MappingProxyType = field(default_factory=lambda: MappingProxyType({}))

    def __post_init__(self):
        object.__setattr__(self, "ruxsatlar", tuple(self.ruxsatlar))
        object.__setattr__(self, "chegaralar", MappingProxyType(dict(self.chegaralar)))


manba_ruxsat = ["o'qish"]
manba_chegara = {"sorov": 100}
t = SozlamaToza(manba_ruxsat, manba_chegara)
manba_ruxsat.append("o'chirish")
manba_chegara["sorov"] = 999
print(f"  manba o'zgargandan keyin: {t.ruxsatlar}, {dict(t.chegaralar)}")
for tavsif, amal in [("ruxsatlar += ", lambda: setattr(t, "ruxsatlar", t.ruxsatlar + ("x",))),
                     ("ruxsatlar.append", lambda: t.ruxsatlar.append("x")),
                     ("chegaralar['sorov'] =", lambda: t.chegaralar.__setitem__("sorov", 1))]:
    try:
        amal()
    except (FrozenInstanceError, AttributeError, TypeError) as e:
        print(f"  {tavsif:24} → {type(e).__name__}")

print("\n=== 4. Inkapsulyatsiya sizishi va himoya nusxalari ===")


class GuruhYomon:
    MAKS = 3

    def __init__(self, talabalar):
        if len(talabalar) > self.MAKS:
            raise ValueError("guruh to'la")
        self._talabalar = talabalar

    @property
    def talabalar(self):
        return self._talabalar


class GuruhToza:
    MAKS = 3

    def __init__(self, talabalar):
        talabalar = tuple(talabalar)
        if len(talabalar) > self.MAKS:
            raise ValueError("guruh to'la")
        self._talabalar = talabalar

    @property
    def talabalar(self):
        return self._talabalar

    def qosh(self, ism):
        if len(self._talabalar) >= self.MAKS:
            raise ValueError("guruh to'la")
        self._talabalar += (ism,)


for klass in (GuruhYomon, GuruhToza):
    royxat = ["Aziz", "Dilnoza"]
    g = klass(royxat)
    royxat.append("Bobur")
    royxat.append("Malika")
    try:
        g.talabalar.append("Sardor")
    except AttributeError:
        pass
    print(f"  {klass.__name__:11} kirish sizishi + chiqish sizishi → {len(g.talabalar)} talaba (MAKS {klass.MAKS}): {list(g.talabalar)}")

=== 1. ⚠️ frozen dataclass: xato berdi, lekin o'zgardi ===
  FrozenInstanceError: cannot assign to field 'ruxsatlar'
  s.ruxsatlar: ["o'qish", "o'chirish"]   ⚠️ __iadd__ allaqachon ishladi
  append ga hech qanday to'siq yo'q: ["o'qish", "o'chirish", 'admin']

=== 2. ⚠️ Setter'siz property ===
  AttributeError: property 'tarix' of 'Hisob' object has no setter
  h._tarix: ['soxta yozuv']

=== 3. ✅ Chuqur o'zgarmas dataclass ===
  manba o'zgargandan keyin: ("o'qish",), {'sorov': 100}
  ruxsatlar +=             → FrozenInstanceError
  ruxsatlar.append         → AttributeError
  chegaralar['sorov'] =    → AttributeError

=== 4. Inkapsulyatsiya sizishi va himoya nusxalari ===
  GuruhYomon  kirish sizishi + chiqish sizishi → 5 talaba (MAKS 3): ['Aziz', 'Dilnoza', 'Bobur', 'Malika', 'Sardor']
  GuruhToza   kirish sizishi + chiqish sizishi → 2 talaba (MAKS 3): ['Aziz', 'Dilnoza']

"""list/dict/set ni iteratsiya paytida o'zgartirish; to'g'ri naqshlar; deepcopy, pickle va JSON umumiy qism va sikllar bilan."""

import copy
import json
import pickle

print("=== 1. ⚠️ Ro'yxatdan iteratsiya paytida o'chirish ===")
buyurtmalar = ["bekor", "bekor", "yangi", "bekor", "tolangan", "bekor"]
yomon = list(buyurtmalar)
for holat in yomon:
    if holat == "bekor":
        yomon.remove(holat)
print(f"  for + remove:            {yomon}   ⚠️ xato yo'q, lekin 'bekor' qoldi")
ikkinchi = list(buyurtmalar)
for holat in list(ikkinchi):
    if holat == "bekor":
        ikkinchi.remove(holat)
print(f"  ✅ nusxa ustida:          {ikkinchi}")
uchinchi = list(buyurtmalar)
taxallus = uchinchi
uchinchi[:] = [h for h in uchinchi if h != "bekor"]
print(f"  ✅ royxat[:] = [...]:     {uchinchi}, taxallus ham yangilandi: {taxallus is uchinchi}")

print("\n=== 2. dict va set ===")
holatlar = {"#1": "bekor", "#2": "yangi", "#3": "bekor"}
try:
    for kalit in holatlar:
        if holatlar[kalit] == "bekor":
            del holatlar[kalit]
except RuntimeError as e:
    print(f"  dict: RuntimeError: {e}")
for kalit in holatlar:
    holatlar[kalit] = holatlar[kalit].upper()
print(f"  qiymatlarni o'zgartirish ruxsat: {holatlar}")
teglar = {"shoshilinch", "katta"}
try:
    for t in teglar:
        teglar.add(t + "!")
except RuntimeError as e:
    print(f"  set: RuntimeError: {e}")
holatlar = {"#1": "bekor", "#2": "yangi", "#3": "bekor"}
for kalit in [k for k, v in holatlar.items() if v == "bekor"]:
    del holatlar[kalit]
print(f"  ✅ avval kalitlarni yig'ish: {holatlar}")

print("\n=== 3. Graf: umumiy qism va sikl ===")
standart = {"valyuta": "UZS", "soliq": 12}
sozlama = {"toshkent": standart, "samarqand": standart, "ota": None}
sozlama["ota"] = sozlama


def tekshir(nom, nusxa):
    umumiy = nusxa["toshkent"] is nusxa["samarqand"]
    sikl = nusxa["ota"] is nusxa
    print(f"  {nom:14} umumiy qism saqlandi: {umumiy}, sikl saqlandi: {sikl}, aslidan mustaqil: {nusxa['toshkent'] is not standart}")


tekshir("copy.copy", copy.copy(sozlama))
tekshir("copy.deepcopy", copy.deepcopy(sozlama))
tekshir("pickle", pickle.loads(pickle.dumps(sozlama)))
try:
    json.dumps(sozlama)
except ValueError as e:
    print(f"  json (sikl bilan): ValueError: {e}")
siklsiz = {"toshkent": standart, "samarqand": standart}
j = json.loads(json.dumps(siklsiz))
print(f"  json (siklsiz): umumiy qism saqlandi: {j['toshkent'] is j['samarqand']}")
j["toshkent"]["soliq"] = 15
print(f"  ⚠️ json nusxasida toshkent soliqi o'zgartirildi → samarqand: {j['samarqand']['soliq']} (endi bog'lanmagan)")

=== 1. ⚠️ Ro'yxatdan iteratsiya paytida o'chirish ===
  for + remove:            ['yangi', 'tolangan', 'bekor']   ⚠️ xato yo'q, lekin 'bekor' qoldi
  ✅ nusxa ustida:          ['yangi', 'tolangan']
  ✅ royxat[:] = [...]:     ['yangi', 'tolangan'], taxallus ham yangilandi: True

=== 2. dict va set ===
  dict: RuntimeError: dictionary changed size during iteration
  qiymatlarni o'zgartirish ruxsat: {'#2': 'YANGI', '#3': 'BEKOR'}
  set: RuntimeError: Set changed size during iteration
  ✅ avval kalitlarni yig'ish: {'#2': 'yangi'}

=== 3. Graf: umumiy qism va sikl ===
  copy.copy      umumiy qism saqlandi: True, sikl saqlandi: False, aslidan mustaqil: False
  copy.deepcopy  umumiy qism saqlandi: True, sikl saqlandi: True, aslidan mustaqil: True
  pickle         umumiy qism saqlandi: True, sikl saqlandi: True, aslidan mustaqil: True
  json (sikl bilan): ValueError: Circular reference detected
  json (siklsiz): umumiy qism saqlandi: False
  ⚠️ json nusxasida toshkent soliqi o'zgartirildi → samarqand: 12 (endi bog'lanmagan)

jadval = [[0] * ustunlar] * qatorlar            # ❌
jadval = [[0] * ustunlar for _ in range(qatorlar)]   # ✅

guruhlar = dict.fromkeys(nomlar, [])            # ❌
guruhlar = {n: [] for n in nomlar}              # ✅

class Foydalanuvchi:
    teglar = []                                 # ❌ umumiy

class Foydalanuvchi:
    def __init__(self):
        self.teglar = []                        # ✅

def __init__(self, elementlar):
    self.elementlar = elementlar                # ❌ chaqiruvchi keyin o'zgartiradi

    self.elementlar = list(elementlar)          # ✅ (yoki tuple)

@property
def buyurtmalar(self):
    return self._buyurtmalar                    # ❌ tashqaridan append

    return tuple(self._buyurtmalar)             # ✅

@dataclass(frozen=True)
class Marshrut:
    bekatlar: list                              # ❌ ichi o'zgaradi

    bekatlar: tuple                             # ✅ + __post_init__ da tuple(...)

for x in royxat:
    if yomon(x):
        royxat.remove(x)                        # ❌ o'tkazib yuboradi

royxat[:] = [x for x in royxat if not yomon(x)] # ✅

nusxa = json.loads(json.dumps(sozlama))         # ❌ umumiy qismlar, sikllar, turlar yo'qoladi
nusxa = copy.deepcopy(sozlama)                  # ✅

from dataclasses import dataclass, field, FrozenInstanceError
1.  a = [1, 2]
    b = a
    a += [3]
    print(b)
2.  a = [1, 2]
    b = a
    a = a + [3]
    print(b)
3.  a = (1, 2)
    b = a
    a += (3,)
    print(b, a is b)
4.  m = [[0] * 2] * 2
    m[1][0] = 5
    print(m)
5.  d = dict.fromkeys("ab", [])
    d["a"].append(1)
    print(d)
6.  class K:
        x = []
    K().x.append(1)
    print(K().x)
7.  @dataclass(frozen=True)
    class F:
        l: list = field(default_factory=list)
    f = F()
    try:
        f.l += [1]
    except FrozenInstanceError:
        pass
    print(f.l)
8.  r = [1, 2, 2, 3]
    for x in r:
        if x == 2:
            r.remove(x)
    print(r)
9.  d = {"a": 1}
    for k in d:
        d[k] = 2
    print(d)
10. s = [1, 2]
    t = s
    s[:] = [9]
    print(t, s is t)
11. x = [1]
    y = [x, x]
    y[0].append(2)
    print(y)
12. import copy
    x = [1]
    y = copy.deepcopy([x, x])
    print(y[0] is y[1], y[0] is x)

1.  def yangi_taxta(n):
        return [["."] * n] * n

2.  class Kutubxona:
        kitoblar = {}
        def qosh(self, isbn, nom):
            self.kitoblar[isbn] = nom

3.  @dataclass(frozen=True)
    class Marshrut:
        bekatlar: list
    m = Marshrut(bekatlar)
    bekatlar.append("Chilonzor")          # m ga ta'sir qilmasligi kerak edi

4.  def faol_emaslarni_ochir(foydalanuvchilar):
        for f in foydalanuvchilar:
            if not f["faol"]:
                foydalanuvchilar.remove(f)

5.  def konfiguratsiya_nusxasi(cfg):
        return json.loads(json.dumps(cfg))    # cfg da datetime va umumiy qismlar bor