Röyxatlar (list)

#Röyxat nima uçun kerak?

Tasavvur qiling, guruhingizda 25 ta talaba bor va har birining bahosini saqlaşingiz kerak. 25 ta alohida özgaruvçi (baho1, baho2, ...) yaratiş noqulay va xatoga moyil. Buning örniga barça baholarni bitta röyxatga joylaysiz.

Röyxat (list) — bir neçta qiymatni tartib bilan saqlaydigan konteyner. U Pythonʼdagi eng köp işlatiladigan maʼlumot turlaridan biri. Röyxat kvadrat qavslar [] bilan yoziladi, elementlar vergul bilan ajratiladi.

#Röyxat yaratiş

Röyxatda istalgan turdagi qiymat bölişi mumkin: sonlar, satrlar, hatto boşqa röyxatlar. Turli turlarni aralaştiriş ham mumkin, lekin amalda bir röyxatda bir xil turdagi maʼlumot saqlaş tavsiya etiladi.

baholar = [5, 4, 5, 3, 4]
mevalar = ["olma", "anor", "uzum"]
aralash = [2026, "Toşkent", 3.5, True]
bosh = []
harflar = list("salom")

print(baholar)
print(mevalar)
print(aralash)
print(bosh)
print(harflar)
print(type(baholar))

Natija:

[5, 4, 5, 3, 4]
['olma', 'anor', 'uzum']
[2026, 'Toşkent', 3.5, True]
[]
['s', 'a', 'l', 'o', 'm']
<class 'list'>

list() funksiyasi boşqa ketma-ketlikni (masalan, satrni) röyxatga aylantiradi. Böş röyxat [] keyinçalik elementlar bilan töldiriş uçun qulay boşlanğiç nuqta.

#Indekslaş va kesiş

Röyxatda ham xuddi satrlardagidek indekslar işlaydi: birinçi element [0], oxirgisi [-1]. Kesiş ham bir xil: [boshi:oxiri:qadam], bunda oxiri kirmaydi.

kunlar = ["Duş", "Seş", "Çor", "Pay", "Juma", "Şan", "Yak"]

print(kunlar[0])
print(kunlar[-1])
print(kunlar[1:4])
print(kunlar[:5])
print(kunlar[5:])
print(kunlar[::2])
print(len(kunlar))

Natija:

Duş
Yak
['Seş', 'Çor', 'Pay']
['Duş', 'Seş', 'Çor', 'Pay', 'Juma']
['Şan', 'Yak']
['Duş', 'Çor', 'Juma', 'Yak']
7

#Röyxatlar özgaruvçan

Satrlardan farqli ölaroq, röyxat özgaruvçan (mutable): uni yaratgandan keyin ham elementlarini almaştiriş, qöşiş va öçiriş mumkin.

narxlar = [4000, 12000, 9500]
narxlar[1] = 13000      # sut qimmatlaşdi
print(narxlar)

narxlar[0:2] = [4500, 14000]   # kesim orqali almaştiriş
print(narxlar)

Natija:

[4000, 13000, 9500]
[4500, 14000, 9500]

#Element qöşiş

Röyxatni kengaytirişning uç asosiy usuli bor:

xaridlar = ["non", "sut"]

xaridlar.append("tuxum")
print(xaridlar)

xaridlar.extend(["un", "qand"])
print(xaridlar)

xaridlar.insert(0, "suv")
print(xaridlar)

# append bilan extend farqi
a = [1, 2]
a.append([3, 4])
print(a)

Natija:

['non', 'sut', 'tuxum']
['non', 'sut', 'tuxum', 'un', 'qand']
['suv', 'non', 'sut', 'tuxum', 'un', 'qand']
[1, 2, [3, 4]]

Oxirgi misolga eʼtibor bering: append() röyxatni bitta element sifatida qöşdi, natijada röyxat içida röyxat paydo böldi. Bir neçta elementni "yoyib" qöşiş uçun extend() kerak.

#Element öçiriş

navbat = ["Anvar", "Bobur", "Kamola", "Bobur", "Zarina"]

oxirgi = navbat.pop()
print("Çiqarildi:", oxirgi)

birinchi = navbat.pop(0)
print("Xizmat körsatildi:", birinchi)

navbat.remove("Bobur")
print(navbat)

navbat.clear()
print(navbat)

Natija:

Çiqarildi: Zarina
Xizmat körsatildi: Anvar
['Kamola', 'Bobur']
[]

#Qidiriş: index, count, in

index(x) qiymat birinçi uçragan joyning indeksini, count(x) esa neça marta uçraşini qaytaradi. in operatori şunçaki bor-yöqligini tekşiradi.

baholar = [5, 4, 5, 3, 4, 5]

print(baholar.index(3))
print(baholar.count(5))
print(2 in baholar)
print(4 in baholar)

Natija:

3
3
False
True

#len, min, max, sum

Sonli röyxatlar bilan işlaşda bu tört funksiya doim kerak böladi. Ular yordamida örtaça qiymatni ham bir qatorda hisoblaş mumkin.

harorat = [18, 21, 24, 19, 15, 22, 25]

print("Kunlar soni:", len(harorat))
print("Eng past:", min(harorat))
print("Eng yuqori:", max(harorat))
print("Örtaça:", round(sum(harorat) / len(harorat), 1))

Natija:

Kunlar soni: 7
Eng past: 15
Eng yuqori: 25
Örtaça: 20.6

#Saralaş: sort() va sorted()

Bu ikkisi öxşaş, lekin muhim farqi bor:

• royxat.sort() — röyxatning özini özgartiradi va None qaytaradi.
• sorted(royxat) — asl röyxatga tegmaydi, yangi saralangan röyxat qaytaradi.

Ikkalasi ham reverse=True (kamayiş tartibi) va key= (nimaga qarab saralaş) parametrlarini qabul qiladi.

narxlar = [12000, 4000, 25000, 9500]

yangi = sorted(narxlar)
print("sorted:", yangi)
print("asl röyxat:", narxlar)

narxlar.sort(reverse=True)
print("sort(reverse=True):", narxlar)

ismlar = ["Zarina", "anvar", "Bobur", "madina"]
print(sorted(ismlar))
print(sorted(ismlar, key=str.lower))
print(sorted(ismlar, key=len))

Natija:

sorted: [4000, 9500, 12000, 25000]
asl röyxat: [12000, 4000, 25000, 9500]
sort(reverse=True): [25000, 12000, 9500, 4000]
['Bobur', 'Zarina', 'anvar', 'madina']
['anvar', 'Bobur', 'madina', 'Zarina']
['anvar', 'Bobur', 'Zarina', 'madina']

Nega sorted(ismlar) da kiçik harf bilan yozilgan "anvar" va "madina" katta harfli ismlardan keyin tuşib qoldi? Çunki Python harflarni kodi böyiça soliştiradi va barça katta harflar kiçik harflardan oldin keladi. key=str.lower har bir ismni soliştirişdan oldin kiçik harfga ötkazadi, şuning uçun tartib "insoniy" böladi.

reverse() metodi esa saralamaydi, faqat mavjud tartibni teskari aylantiradi:

qadamlar = ["boşlaş", "yoziş", "tekşiriş"]
qadamlar.reverse()
print(qadamlar)

Natija:

['tekşiriş', 'yoziş', 'boşlaş']

#Nusxa va havola: eng köp uçraydigan tuzoq

b = a yozganingizda Python yangi röyxat yaratmaydi. U şunçaki ayni röyxatga ikkinçi nom beradi. Şuning uçun b orqali qilingan özgariş a da ham körinadi.

a = [1, 2, 3]
b = a            # havola: ikkala nom bitta röyxatni körsatadi
b.append(4)
print("a:", a)
print(a is b)

c = a.copy()     # haqiqiy nusxa
c.append(5)
print("a:", a)
print("c:", c)
print(a is c)

Natija:

a: [1, 2, 3, 4]
True
a: [1, 2, 3, 4]
c: [1, 2, 3, 4, 5]
False

Nusxa olişning uç usuli bor: a.copy(), a[:] va list(a). Hammasi sayoz nusxa (shallow copy) yaratadi: içma-iç röyxatlar bölsa, içki röyxatlar hali ham umumiy bölib qoladi. Bunday holatda copy modulidagi deepcopy() işlatiladi.

#Içma-iç röyxatlar (matritsa)

Röyxat elementi boşqa röyxat bölişi mumkin. Bu jadval yoki matritsa kabi ikki ölçovli maʼlumotlar uçun qulay. Elementga ikki indeks bilan murojaat qilinadi: [qator][ustun].

# 3 ta talabaning 3 ta fandan baholari
jadval = [
    [5, 4, 5],
    [3, 4, 4],
    [5, 5, 5],
]

print(jadval[1])
print(jadval[1][2])

for qator in jadval:
    print(qator, "->", sum(qator))

# birinçi ustun (birinçi fan) baholari
birinchi_fan = [qator[0] for qator in jadval]
print(birinchi_fan)

Natija:

[3, 4, 4]
4
[5, 4, 5] -> 14
[3, 4, 4] -> 11
[5, 5, 5] -> 15
[5, 3, 5]

#Yoyiş (unpacking)

Röyxat elementlarini bir neçta özgaruvçiga birdaniga taqsimlaş mumkin. Özgaruvçilar soni elementlar soniga teng bölişi kerak. Agar qolgan hammasini bitta özgaruvçiga yiğmoqçi bölsangiz, oldiga * qöying.

ism, yosh, shahar = ["Laylo", 20, "Buxoro"]
print(ism, yosh, shahar)

birinchi, *qolgan = [5, 4, 3, 5, 4]
print(birinchi)
print(qolgan)

boshi, *orta, oxiri = [10, 20, 30, 40, 50]
print(boshi, orta, oxiri)

Natija:

Laylo 20 Buxoro
5
[4, 3, 5, 4]
10 [20, 30, 40] 50

*qolgan har doim röyxat böladi, hatto böş bölsa ham. Bu usul fayl qatorlari yoki buyruq argumentlari bilan işlaşda juda qulay.

#Amaliy misol: xarid röyxati

Endi örganganlarimizni birlaştiramiz. Har bir xarid — [nomi, soni, narxi] körinişidagi kiçik röyxat. Umumiy summani hisoblaymiz va eng qimmat xaridni topamiz.

xaridlar = [
    ["Non", 3, 4000],
    ["Sut", 2, 12000],
    ["Tuxum", 10, 1500],
    ["Olma (kg)", 2, 15000],
]

jami = 0
for nomi, soni, narxi in xaridlar:
    summa = soni * narxi
    jami += summa
    print(f"{nomi:<12}{soni:>3} x {narxi:>6} = {summa:>7} söm")

print(f"{'Jami:':<27}{jami:>7} söm")

eng_qimmat = max(xaridlar, key=lambda x: x[1] * x[2])
print("Eng köp pul ketgan:", eng_qimmat[0])

Natija:

Non           3 x   4000 =   12000 söm
Sut           2 x  12000 =   24000 söm
Tuxum        10 x   1500 =   15000 söm
Olma (kg)     2 x  15000 =   30000 söm
Jami:                        81000 söm
Eng köp pul ketgan: Olma (kg)

key=lambda x: x[1] * x[2] — max() ga har bir xaridni uning umumiy summasi böyiça soliştirişni aytadi. lambda haqida funksiyalar bobida batafsil gaplaşamiz.

#Amaliy misol: talabalar baholari

baholar = [78, 92, 65, 88, 54, 99, 71]

saralangan = sorted(baholar, reverse=True)
print("Eng yaxşi 3 ta:", saralangan[:3])

otdi = [b for b in baholar if b >= 60]
print("Ötganlar soni:", len(otdi))
print("Ötolmaganlar:", [b for b in baholar if b < 60])
print("Örtaça:", round(sum(baholar) / len(baholar), 2))

Natija:

Eng yaxşi 3 ta: [99, 92, 88]
Ötganlar soni: 6
Ötolmaganlar: [54]
Örtaça: 78.14

Bu yerda [b for b in baholar if b >= 60] — röyxat generatori (list comprehension). U şart bajariladigan elementlardan yangi röyxat yasaydi. Hozirça uni "filtr" deb tuşunsangiz yetarli.

#Xulosa

• Röyxat (list) — tartiblangan, özgaruvçan konteyner; [] bilan yoziladi.
• Indekslaş va kesiş satrlardagidek işlaydi.
• Qöşiş: append(), extend(), insert(); öçiriş: pop(), remove(), clear().
• sort() röyxatning özini özgartiradi, sorted() yangi röyxat qaytaradi; key= va reverse= saralaşni boşqaradi.
• b = a nusxa emas, havola; nusxa uçun copy() yoki a[:] işlating.
• *qolgan yordamida röyxatning qolgan qismini bitta özgaruvçiga yiğiş mumkin.

#Maşqlar

1. sonlar = [3, 8, 1, 9, 4] röyxatiga oxiriga 7 ni, boşiga 0 ni qöşing, keyin röyxatni kamayiş tartibida saralab çiqaring.

sonlar = [3, 8, 1, 9, 4]
sonlar.append(7)
sonlar.insert(0, 0)
sonlar.sort(reverse=True)
print(sonlar)

1. [4, 2, 4, 7, 2, 2, 9] röyxatida 2 neça marta uçraşini va 7 qaysi indeksda turganini toping.

sonlar = [4, 2, 4, 7, 2, 2, 9]
print(sonlar.count(2))
print(sonlar.index(7))

1. Quyidagi kodda asl röyxati nega özgarib ketganini tuşuntiring va uni tuzating: asl = [1, 2, 3], yangi = asl, yangi.append(4).

# yangi = asl havola edi, şuning uçun ikkalasi bitta röyxat edi
asl = [1, 2, 3]
yangi = asl.copy()
yangi.append(4)
print(asl)
print(yangi)

1. Mahsulotlar va narxlar röyxati: [["Kitob", 45000], ["Ruçka", 3000], ["Daftar", 8000]]. Ularni narx böyiça arzondan qimmatga saralab, faqat nomlarini çiqaring.

mahsulotlar = [["Kitob", 45000], ["Ruçka", 3000], ["Daftar", 8000]]
saralangan = sorted(mahsulotlar, key=lambda m: m[1])
print([m[0] for m in saralangan])

1. [90, 75, 60, 85, 100] baholar röyxatidan yoyiş yordamida eng birinçi bahoni va qolganlarini ajrating, keyin qolganlarning örtaçasini hisoblang.

birinchi, *qolgan = [90, 75, 60, 85, 100]
print(birinchi)
print(sum(qolgan) / len(qolgan))