Kortejlar (tuple) va luğatlar (dict)

#Bu bobda nimalarni örganamiz

Oldingi bobda röyxatlar bilan tanişdik. Endi yana ikkita muhim maʼlumot turini köramiz:

• Kortej (tuple) — röyxatga öxşaydi, lekin özgarmas. Özgarmasligi kerak bölgan maʼlumotlar uçun.
• Luğat (dict) — qiymatlarni tartib raqami böyiça emas, kalit böyiça saqlaydi. Telefon kitobçasi yoki mahsulot katalogi kabi maʼlumotlar uçun ideal.

#Kortejlar (tuple)

#Kortej yaratiş

Kortej oddiy qavslar () bilan yoziladi. Aslida kortejni qavslar emas, vergul yaratadi — qavslar faqat öqişni osonlaştiradi.

nuqta = (41.3, 69.2)
rang = (255, 128, 0)
hafta_oxiri = ("Şanba", "Yakşanba")
sana = 2026, 10, 26        # qavssiz ham kortej
bosh = ()

print(nuqta)
print(sana)
print(type(sana))
print(len(rang), len(bosh))
print(rang[0], rang[-1])

Natija:

(41.3, 69.2)
(2026, 10, 26)
<class 'tuple'>
3 0
255 0

Indekslaş, kesiş, len(), in, count() va index() kortejlarda ham xuddi röyxatlardagidek işlaydi.

#Bitta elementli kortej

Bu yangi boşlovçilar köp qoqiladigan joy. (5) — bu kortej emas, şunçaki qavs içidagi son. Bitta elementli kortej yaratiş uçun oxiriga vergul qöyiş şart.

a = (5)
b = (5,)
c = "olma",

print(type(a))
print(type(b))
print(c)

Natija:

<class 'int'>
<class 'tuple'>
('olma',)

#Kortejlar özgarmas

Kortejni yaratgandan keyin uning elementlarini almaştirib, qöşib yoki öçirib bölmaydi. Şuning uçun kortejda append(), remove() yoki sort() kabi metodlar yöq.

koordinata = (41.3, 69.2)
try:
    koordinata[0] = 40.0
except TypeError as xato:
    print("Xato:", xato)

Natija:

Xato: 'tuple' object does not support item assignment

Nega bu foydali? Özgarmaslik — bu kafolat. Agar maʼlumot kortejda bölsa, uni dasturning boşqa qismi tasodifan buzib qöymasligiga işonçingiz komil böladi. Bundan taşqari, kortejni luğat kaliti sifatida işlatiş mumkin, röyxatni esa yöq (bu haqda quyida).

#Kortejni yoyiş

Kortej elementlarini bir neçta özgaruvçiga bir qatorda taqsimlaş mumkin. Maşhur "ikki özgaruvçini almaştiriş" usuli ham aslida kortej yoyiş.

talaba = ("Madina", 19, "Informatika")
ism, yosh, yonalish = talaba
print(f"{ism}, {yosh} yoş, {yonalish}")

a, b = 10, 20
a, b = b, a
print(a, b)

birinchi, *qolgan = (3, 1, 4, 1, 5)
print(birinchi, qolgan)

Natija:

Madina, 19 yoş, Informatika
20 10
3 [1, 4, 1, 5]

#Funksiyadan bir neçta qiymat qaytariş

Funksiya return a, b deb yozsa, aslida bitta kortej qaytaradi. Çaqiruvçi tomonda uni darhol yoyib oliş mumkin. Bu juda qulay va Pythonʼda keng tarqalgan usul.

def statistika(sonlar: list[int]) -> tuple[int, int, float]:
    return min(sonlar), max(sonlar), sum(sonlar) / len(sonlar)

baholar = [72, 85, 90, 64, 88]
eng_kam, eng_kop, ortacha = statistika(baholar)
print("Eng kam:", eng_kam)
print("Eng köp:", eng_kop)
print("Örtaça:", ortacha)

Natija:

Eng kam: 64
Eng köp: 90
Örtaça: 79.8

#Qaçon kortej, qaçon röyxat?

#Luğatlar (dict)

#Luğat yaratiş

Luğat — kalit: qiymat juftliklari töplami. U jingalak qavslar {} bilan yoziladi. Kalit yordamida qiymatni bir zumda topiş mumkin, xuddi haqiqiy luğatda söz orqali uning maʼnosini topganingiz kabi.

talaba = {
    "ism": "Bobur",
    "yoş": 20,
    "kurs": 2,
    "baholar": [5, 4, 5],
}
print(talaba)

bosh = {}
print(type(bosh))

# dict() funksiyasi orqali
kurs = dict(usd=12650, eur=13700)
print(kurs)

Natija:

{'ism': 'Bobur', 'yoş': 20, 'kurs': 2, 'baholar': [5, 4, 5]}
<class 'dict'>
{'usd': 12650, 'eur': 13700}

Kalit özgarmas tur bölişi kerak: satr, son yoki kortej. Röyxatni kalit qilib bölmaydi. Qiymat esa istalgan narsa bölişi mumkin. Bitta luğatda bir xil kalit ikki marta böla olmaydi.

#Qiymatni oliş: [] va get()

Qiymatni lugat[kalit] bilan oliş mumkin. Lekin kalit mavjud bölmasa, KeyError xatosi çiqadi. get() metodi esa xato bermaydi: kalit bölmasa, None yoki siz bergan standart qiymatni qaytaradi.

talaba = {"ism": "Bobur", "yoş": 20}

print(talaba["ism"])
print(talaba.get("yoş"))
print(talaba.get("telefon"))
print(talaba.get("telefon", "körsatilmagan"))

try:
    print(talaba["telefon"])
except KeyError as xato:
    print("KeyError:", xato)

Natija:

Bobur
20
None
körsatilmagan
KeyError: 'telefon'

#Qöşiş, yangilaş va öçiriş

Yangi kalitga qiymat bersangiz — qöşiladi, mavjud kalitga bersangiz — yangilanadi. Bir neçta juftlikni birdaniga yangilaş uçun update() işlatiladi.

mahsulot = {"nomi": "Çoynak", "narx": 85000}

mahsulot["rang"] = "oq"           # qöşiş
mahsulot["narx"] = 79000          # yangilaş
mahsulot.update({"soni": 12, "narx": 75000})
print(mahsulot)

olib_tashlandi = mahsulot.pop("rang")   # öçirib, qiymatini qaytaradi
print(olib_tashlandi)

del mahsulot["soni"]                    # şunçaki öçiradi
print(mahsulot)

Natija:

{'nomi': 'Çoynak', 'narx': 75000, 'rang': 'oq', 'soni': 12}
oq
{'nomi': 'Çoynak', 'narx': 75000}

pop() ham del ham kalit bölmasa KeyError beradi. Lekin pop(kalit, standart) körinişida ikkinçi argument bersangiz, xato örniga öşa qiymat qaytadi.

#keys(), values(), items() va aylanib çiqiş

Luğat ustida for sikli işlatilsa, u kalitlar böyiça aylanadi. Qiymatlar kerak bölsa values(), kalit va qiymat birga kerak bölsa items() işlatiladi.

narxlar = {"non": 4000, "sut": 12000, "tuxum": 1500}

print(list(narxlar.keys()))
print(list(narxlar.values()))
print(list(narxlar.items()))

for nomi, narx in narxlar.items():
    print(f"{nomi}: {narx} söm")

print("Eng qimmati:", max(narxlar, key=narxlar.get))
print("sut" in narxlar)
print(12000 in narxlar)

Natija:

['non', 'sut', 'tuxum']
[4000, 12000, 1500]
[('non', 4000), ('sut', 12000), ('tuxum', 1500)]
non: 4000 söm
sut: 12000 söm
tuxum: 1500 söm
Eng qimmati: sut
True
False

#Içma-iç luğatlar

Luğat qiymati boşqa luğat bölişi mumkin. Bu murakkab maʼlumotlarni, masalan, bir neçta talaba haqidagi maʼlumotni tartibli saqlaşga yordam beradi.

guruh = {
    "Bobur": {"yoş": 20, "baho": 88},
    "Madina": {"yoş": 19, "baho": 95},
    "Sardor": {"yoş": 21, "baho": 74},
}

print(guruh["Madina"]["baho"])

guruh["Sardor"]["baho"] = 80
for ism, malumot in guruh.items():
    print(f"{ism}: {malumot['yoş']} yoş, baho {malumot['baho']}")

Natija:

95
Bobur: 20 yoş, baho 88
Madina: 19 yoş, baho 95
Sardor: 21 yoş, baho 80

#setdefault() va | bilan birlaştiriş

setdefault(kalit, standart) — kalit bor bölsa uning qiymatini qaytaradi, yöq bölsa avval standart qiymatni yozib qöyadi. U guruhlaşda juda qulay.

Python 3.9 dan boşlab ikki luğatni | operatori bilan birlaştiriş mumkin. Bir xil kalit bölsa, öngdagi luğatning qiymati ğolib çiqadi.

# Talabalarni şahar böyiça guruhlaş
talabalar = [("Anvar", "Buxoro"), ("Laylo", "Xiva"), ("Zarina", "Buxoro")]
shaharlar = {}
for ism, shahar in talabalar:
    shaharlar.setdefault(shahar, []).append(ism)
print(shaharlar)

standart = {"til": "uz", "mavzu": "yoruğ", "şrift": 14}
foydalanuvchi = {"mavzu": "qoronği"}
sozlamalar = standart | foydalanuvchi
print(sozlamalar)

Natija:

{'Buxoro': ['Anvar', 'Zarina'], 'Xiva': ['Laylo']}
{'til': 'uz', 'mavzu': 'qoronği', 'şrift': 14}

#Luğat generatori (kiçik tanişuv)

Röyxat generatoriga öxşab, luğatni ham bir qatorda yaratiş mumkin: {kalit: qiymat for ... in ...}. Bu haqda keyingi boblarda batafsil gaplaşamiz, hozirça bitta misol:

narxlar_usd = {"kitob": 4, "daftar": 1, "sumka": 25}
kurs = 12650
narxlar_som = {nomi: narx * kurs for nomi, narx in narxlar_usd.items()}
print(narxlar_som)

Natija:

{'kitob': 50600, 'daftar': 12650, 'sumka': 316250}

#Amaliy misol: telefon kitobçasi

Kontaktlarni ism böyiça saqlaymiz, qidiramiz, qöşamiz va öçiramiz. Bu yerda luğatning asosiy kuçi körinadi: kontaktlar qançalik köp bölmasin, ism böyiça qidiriş bir zumda bajariladi.

kitobcha = {
    "Anvar": "+998 90 111 22 33",
    "Kamola": "+998 93 444 55 66",
}

def qidir(ism: str) -> str:
    return kitobcha.get(ism, "Kontakt topilmadi")

kitobcha["Laylo"] = "+998 97 777 88 99"
print(qidir("Laylo"))
print(qidir("Bekzod"))

kitobcha.pop("Anvar", None)
print("Kontaktlar soni:", len(kitobcha))
for ism in sorted(kitobcha):
    print(f"{ism:<8} {kitobcha[ism]}")

Natija:

+998 97 777 88 99
Kontakt topilmadi
Kontaktlar soni: 2
Kamola   +998 93 444 55 66
Laylo    +998 97 777 88 99

#Amaliy misol: sözlar çastotasi

Matnda har bir söz neça marta uçraşini sanaymiz. Bu vazifa luğatlar uçun klassik misol: kalit — söz, qiymat — uning soni.

matn = "olma anor olma uzum anor olma behi uzum olma"

chastota: dict[str, int] = {}
for soz in matn.split():
    chastota[soz] = chastota.get(soz, 0) + 1

print(chastota)

# eng köp uçragandan kamiga qarab
for soz, son in sorted(chastota.items(), key=lambda j: j[1], reverse=True):
    print(f"{soz:<6} {'#' * son} {son}")

Natija:

{'olma': 4, 'anor': 2, 'uzum': 2, 'behi': 1}
olma   #### 4
anor   ## 2
uzum   ## 2
behi   # 1

chastota.get(soz, 0) + 1 — eng muhim qator. Söz birinçi marta uçraganda get() 0 qaytaradi, keyingi safarlarda esa mavjud sonni.

#Amaliy misol: mahsulot katalogi

Kitob dökoni katalogini içma-iç luğat sifatida saqlaymiz, xarid summasini hisoblaymiz va omborda kam qolgan mahsulotlarni topamiz.

katalog = {
    "K001": {"nomi": "Python asoslari", "narx": 95000, "ombor": 12},
    "K002": {"nomi": "Algoritmlar", "narx": 120000, "ombor": 3},
    "K003": {"nomi": "Ingliz tili", "narx": 68000, "ombor": 0},
}

savat = {"K001": 2, "K002": 1}

jami = 0
for kod, soni in savat.items():
    mahsulot = katalog[kod]
    summa = mahsulot["narx"] * soni
    jami += summa
    print(f"{mahsulot['nomi']} x{soni}: {summa:,} söm")
print(f"Jami: {jami:,} söm")

kam_qolgan = [m["nomi"] for m in katalog.values() if m["ombor"] < 5]
print("Kam qolgan:", kam_qolgan)

Natija:

Python asoslari x2: 190,000 söm
Algoritmlar x1: 120,000 söm
Jami: 310,000 söm
Kam qolgan: ['Algoritmlar', 'Ingliz tili']

{summa:,} formati minglarni vergul bilan ajratadi — katta summalarni öqiş ança osonlaşadi.

#Xulosa

• Kortej (tuple) — özgarmas tartiblangan töplam; bitta elementli kortejda vergul şart: (5,).
• Kortejlar yoyiş, funksiyadan bir neçta qiymat qaytariş va luğat kalitlari uçun qulay.
• Luğat (dict) — kalit: qiymat juftliklari; kalit noyob va özgarmas bölişi kerak.
• Xavfsiz öqiş uçun get(kalit, standart), yangilaş uçun []= va update(), öçiriş uçun pop() va del.
• keys(), values(), items() bilan aylanib çiqasiz; in faqat kalitlarni tekşiradi.
• setdefault() guruhlaşni, | esa luğatlarni birlaştirişni osonlaştiradi.

#Maşqlar

1. (12, 7, 30) kortejidan yoyiş yordamida soat, daqiqa, soniya özgaruvçilarini yarating va 12:07:30 körinişida çiqaring.

soat, daqiqa, soniya = (12, 7, 30)
print(f"{soat:02}:{daqiqa:02}:{soniya:02}")

1. Aylana radiusini qabul qilib, uning yuzasi va uzunligini kortej sifatida qaytaradigan aylana(r) funksiyasini yozing. Natijalarni 2 xonagaça yaxlitlang.

import math

def aylana(r: float) -> tuple[float, float]:
    return round(math.pi * r ** 2, 2), round(2 * math.pi * r, 2)

yuza, uzunlik = aylana(3)
print(yuza, uzunlik)

1. Luğat berilgan: {"Anvar": 85, "Laylo": 92, "Bobur": 58}. Unga "Zarina": 77 ni qöşing, "Bobur" ni öçiring va eng yuqori bahoga ega talabaning ismini çiqaring.

baholar = {"Anvar": 85, "Laylo": 92, "Bobur": 58}
baholar["Zarina"] = 77
del baholar["Bobur"]
print(baholar)
print(max(baholar, key=baholar.get))

1. "kitobxon" sözidagi har bir harf neça marta uçraşini luğat yordamida sanang.

harflar = {}
for h in "kitobxon":
    harflar[h] = harflar.get(h, 0) + 1
print(harflar)

1. Taxminiy valyuta kurslari {"USD": 12650, "EUR": 13700, "RUB": 155} luğatida. 250 000 söm har bir valyutada qança bölişini luğat generatori bilan hisoblang (2 xonagaça yaxlitlang).

kurslar = {"USD": 12650, "EUR": 13700, "RUB": 155}
summa = 250_000
natija = {v: round(summa / k, 2) for v, k in kurslar.items()}
print(natija)