Lug'atlar, to'plamlar va collections moduli

talaba = {
    "ism": "Aziz",
    "yosh": 21,
    "kurslar": ["Python", "ML"],
}
 
talaba["ism"]                 # 'Aziz'
talaba["yosh"] = 22           # o'zgartirish
talaba["shahar"] = "Buxoro"   # yangi kalit qo'shish
del talaba["kurslar"]         # o'chirish
"ism" in talaba               # True — KALITLAR orasidan qidiradi
len(talaba)                   # 3

dict(ism="Aziz", yosh=21)                 # kalitlar oddiy nom bo'lsa
dict(zip(["a", "b"], [1, 2]))             # {'a': 1, 'b': 2}
dict.fromkeys(["a", "b"], 0)              # {'a': 0, 'b': 0}
{x: x ** 2 for x in range(4)}             # {0: 0, 1: 1, 2: 4, 3: 9} — dict comprehension (7-bob)

koordinatalar = {(41.31, 69.24): "Toshkent", (39.65, 66.96): "Samarqand"}   # ✅ tuple kalit
kesh = {[1, 2]: "x"}       # ❌ TypeError: unhashable type: 'list'

config = {"model": "claude-opus-5-5"}
config["temperature"]           # KeyError: 'temperature'

config.get("temperature")               # None
config.get("temperature", 1.0)          # 1.0 — standart qiymat
config.pop("model")                     # qiymatni olib, kalitni o'chiradi
config.pop("yo'q", None)                # yo'q bo'lsa — None, xato emas
config.setdefault("tags", []).append("test")   # yo'q bo'lsa yaratib, qiymatini qaytaradi

# LBYL — "Look Before You Leap" (sakrashdan oldin qara)
if "temperature" in config:
    t = config["temperature"]
else:
    t = 1.0
 
# EAFP — "Easier to Ask Forgiveness than Permission" (ruxsat so'ragandan kechirim so'rash oson)
try:
    t = config["temperature"]
except KeyError:
    t = 1.0
 
# Ko'pincha eng yaxshisi — maxsus metod:
t = config.get("temperature", 1.0)

narxlar = {"olma": 12000, "nok": 15000, "uzum": 22000}
 
narxlar.keys()       # dict_keys(['olma', 'nok', 'uzum'])
narxlar.values()     # dict_values([12000, 15000, 22000])
narxlar.items()      # dict_items([('olma', 12000), ...])
 
for meva, narx in narxlar.items():
    print(f"{meva:<6} {narx:>7,} so'm")

a = {"x": 1, "y": 2}
b = {"y": 3, "z": 4}
a.keys() & b.keys()     # {'y'} — umumiy kalitlar
a.keys() - b.keys()     # {'x'}

dict(sorted(narxlar.items()))                                 # kalit bo'yicha
dict(sorted(narxlar.items(), key=lambda kv: kv[1], reverse=True))   # qiymat bo'yicha, kamayish
max(narxlar, key=narxlar.get)                                 # 'uzum' — eng qimmatining kaliti

default = {"model": "claude-opus-5-5", "max_tokens": 1024, "effort": "medium"}
user = {"max_tokens": 4096}
 
# 1. Yangi lug'at — o'ngdagisi ustun
params = {**default, **user}          # Python 3.5+
params = default | user               # Python 3.9+ — eng o'qiladigan
 
# 2. Joyida yangilash
default.update(user)                  # default o'zgaradi
default |= user                       # xuddi shunday

s = {1, 2, 3}
s.add(4)
s.discard(10)            # yo'q bo'lsa — jim (remove esa KeyError beradi)
bo_sh = set()            # {} — bu bo'sh LUG'AT, to'plam emas!
set([3, 1, 3, 2])        # {1, 2, 3} — dublikatlar yo'qoladi

a = {1, 2, 3}
b = {2, 3, 4}
 
a | b      # {1, 2, 3, 4} — birlashma (union)
a & b      # {2, 3}       — kesishma (intersection)
a - b      # {1}          — ayirma (difference)
a ^ b      # {1, 4}       — simmetrik ayirma
{1, 2} <= a  # True       — qism to'plammi (subset)

stop_words = {"va", "bilan", "uchun", "ham", "bu", "u"}   # set!
 
def filter_tokens(tokens: list[str]) -> list[str]:
    return [t for t in tokens if t not in stop_words]      # har tekshiruv O(1)

train_users = set(train_df["user_id"])
test_users = set(test_df["user_id"])
umumiy = train_users & test_users
if umumiy:
    print(f"⚠️ {len(umumiy)} ta foydalanuvchi ikkala qismda ham bor!")

from collections import Counter
 
so_zlar = "the cat and the hat and the bat".split()
c = Counter(so_zlar)
c                         # Counter({'the': 3, 'and': 2, 'cat': 1, 'hat': 1, 'bat': 1})
c["the"]                  # 3
c["yo'q"]                 # 0 — KeyError emas!
c.most_common(2)          # [('the', 3), ('and', 2)]
c.total()                 # 8 (Python 3.10+)
c.update(["the", "dog"])  # qo'shimcha sanash
 
Counter("abracadabra").most_common(2)   # [('a', 5), ('b', 2)]

from collections import defaultdict
 
# Guruhlash: har bir harf bilan boshlanadigan so'zlar
guruhlar = defaultdict(list)
for soz in ["olma", "anor", "nok", "orik", "nar"]:
    guruhlar[soz[0]].append(soz)     # kalit yo'q bo'lsa — avtomatik [] yaratiladi
 
dict(guruhlar)   # {'o': ['olma', 'orik'], 'a': ['anor'], 'n': ['nok', 'nar']}

from collections import deque
 
q = deque([1, 2, 3])
q.append(4)          # o'ngga — O(1)
q.appendleft(0)      # chapga — O(1) (list.insert(0, x) — O(n))
q.popleft()          # chapdan olish — O(1) (list.pop(0) — O(n))
 
oxirgilar = deque(maxlen=3)   # faqat oxirgi 3 ta element saqlanadi
for i in range(5):
    oxirgilar.append(i)
print(oxirgilar)     # deque([2, 3, 4], maxlen=3)

from collections import namedtuple
 
Point = namedtuple("Point", ["x", "y"])
p = Point(3, 4)
p.x, p.y              # (3, 4) — nom bilan
p[0]                  # 3 — indeks bilan ham
x, y = p              # unpacking ham ishlaydi
p._replace(x=10)      # Point(x=10, y=4) — yangi obyekt
p._asdict()           # {'x': 3, 'y': 4}

from collections import ChainMap
 
cli_args = {"lr": 0.1}
env = {"epochs": 20}
defaults = {"lr": 0.01, "epochs": 10, "batch_size": 32}
 
cfg = ChainMap(cli_args, env, defaults)   # chapdagisi ustun
cfg["lr"], cfg["epochs"], cfg["batch_size"]   # (0.1, 20, 32)

from collections import Counter
 
corpus = [
    "Python ML uchun eng mashhur til",
    "ML modellar ma'lumotdan o'rganadi",
    "Python va ML birga",
]
 
# 1. So'zlarni sanash
counts = Counter(word for line in corpus for word in line.lower().split())
 
# 2. Kamida 2 marta uchragan so'zlardan lug'at
SPECIAL = ["<pad>", "<unk>"]
vocab = SPECIAL + [w for w, n in counts.most_common() if n >= 2]
word2id = {w: i for i, w in enumerate(vocab)}
id2word = {i: w for w, i in word2id.items()}
 
 
def encode(text: str) -> list[int]:
    unk = word2id["<unk>"]
    return [word2id.get(w, unk) for w in text.lower().split()]
 
 
def decode(ids: list[int]) -> str:
    return " ".join(id2word[i] for i in ids)
 
 
print(word2id)                    # {'<pad>': 0, '<unk>': 1, 'ml': 2, 'python': 3}
print(encode("Python ML zo'r"))   # [3, 2, 1]
print(decode([3, 2, 1]))          # python ml <unk>