8. Kolleksiyalar¶

Python'da bir nechta qiymatlarni bir joyda saqlash uchun kolleksiyalar ishlatiladi.

Asosiy kolleksiya turlari:

list
tuple
set
dictionary

Har birining o‘ziga xos vazifasi bor.

List¶

list bir nechta qiymatlarni tartibli holda saqlaydi.

mevalar = [
    "olma",
    "banan",
    "anor"
]

print(
    mevalar
)

Natija:

['olma', 'banan', 'anor']

List:

Tartibli
O‘zgaruvchan
Takroriy qiymatlarga ruxsat beradi
Indeks bilan ishlaydi

List indekslari¶

mevalar = [
    "olma",
    "banan",
    "anor"
]

Indekslar:

0 → olma
1 → banan
2 → anor

Masalan:

print(
    mevalar[0]
)

print(
    mevalar[2]
)

Natija:

olma
anor

Manfiy indeks¶

print(
    mevalar[-1]
)

Natija:

anor

-3 → olma
-2 → banan
-1 → anor

List slicing¶

List ham slicingni qo‘llab-quvvatlaydi.

sonlar = [
    10,
    20,
    30,
    40,
    50
]

print(
    sonlar[1:4]
)

Natija:

[20, 30, 40]

Listni o‘zgartirish¶

List mutable bo‘lgani uchun elementni o‘zgartirish mumkin.

mevalar = [
    "olma",
    "banan",
    "anor"
]

mevalar[1] = "uzum"

print(
    mevalar
)

Natija:

['olma', 'uzum', 'anor']

`append()`¶

List oxiriga yangi element qo‘shadi.

mevalar = [
    "olma",
    "banan"
]

mevalar.append(
    "anor"
)

print(
    mevalar
)

Natija:

['olma', 'banan', 'anor']

`insert()`¶

Ma’lum indeksga element qo‘shadi.

mevalar = [
    "olma",
    "anor"
]

mevalar.insert(
    1,
    "banan"
)

print(
    mevalar
)

Natija:

['olma', 'banan', 'anor']

`extend()`¶

Bir listdagi elementlarni boshqa listga qo‘shadi.

birinchi_royxat = [
    1,
    2,
    3
]

ikkinchi_royxat = [
    4,
    5,
    6
]

birinchi_royxat.extend(
    ikkinchi_royxat
)

print(
    birinchi_royxat
)

Natija:

[1, 2, 3, 4, 5, 6]

`remove()`¶

Berilgan qiymatning birinchi uchraganini o‘chiradi.

mevalar = [
    "olma",
    "banan",
    "anor"
]

mevalar.remove(
    "banan"
)

print(
    mevalar
)

Natija:

['olma', 'anor']

Agar qiymat mavjud bo‘lmasa, ValueError yuz beradi.

`pop()`¶

Indeks bo‘yicha elementni olib tashlaydi va uni qaytaradi.

mevalar = [
    "olma",
    "banan",
    "anor"
]

olingan_meva = mevalar.pop(
    1
)

print(
    olingan_meva
)

print(
    mevalar
)

Natija:

banan
['olma', 'anor']

Argument bermasak, oxirgi element olinadi:

mevalar = [
    "olma",
    "banan",
    "anor"
]

olingan_meva = mevalar.pop()

print(
    olingan_meva
)

Natija:

anor

`clear()`¶

Listdagi barcha elementlarni o‘chiradi.

mevalar = [
    "olma",
    "banan",
    "anor"
]

mevalar.clear()

print(
    mevalar
)

Natija:

[]

`index()`¶

Elementning indeksini topadi.

mevalar = [
    "olma",
    "banan",
    "anor"
]

joylashuv = mevalar.index(
    "banan"
)

print(
    joylashuv
)

Natija:

`count()`¶

Element necha marta uchraganini hisoblaydi.

sonlar = [
    1,
    2,
    2,
    3,
    2
]

soni = sonlar.count(
    2
)

print(
    f"2 soni {soni} marta uchradi."
)

Natija:

2 soni 3 marta uchradi.

`sort()`¶

Listni tartiblaydi.

sonlar = [
    5,
    2,
    8,
    1,
    3
]

sonlar.sort()

print(
    sonlar
)

Natija:

[1, 2, 3, 5, 8]

Teskari tartib:

sonlar.sort(
    reverse=True
)

print(
    sonlar
)

Natija:

[8, 5, 3, 2, 1]

`sorted()`¶

sorted() yangi tartiblangan list qaytaradi.

sonlar = [
    5,
    2,
    8,
    1,
    3
]

tartiblangan_sonlar = sorted(
    sonlar
)

print(
    sonlar
)

print(
    tartiblangan_sonlar
)

Birinchi list o‘zgarmaydi.

`reverse()`¶

List elementlarining tartibini teskariga aylantiradi.

mevalar = [
    "olma",
    "banan",
    "anor"
]

mevalar.reverse()

print(
    mevalar
)

Natija:

['anor', 'banan', 'olma']

Listni nusxalash¶

Quyidagi kod kutilganidek mustaqil nusxa yaratmaydi:

birinchi_royxat = [
    1,
    2,
    3
]

ikkinchi_royxat = birinchi_royxat

ikkinchi_royxat.append(
    4
)

print(
    birinchi_royxat
)

Natija:

[1, 2, 3, 4]

Chunki ikkala o‘zgaruvchi bir xil list obyektiga murojaat qilmoqda.

Nusxa olish:

birinchi_royxat = [
    1,
    2,
    3
]

ikkinchi_royxat = birinchi_royxat.copy()

ikkinchi_royxat.append(
    4
)

print(
    birinchi_royxat
)

print(
    ikkinchi_royxat
)

Natija:

[1, 2, 3]
[1, 2, 3, 4]

Tuple¶

Tuple listga o‘xshaydi, lekin o‘zgarmas kolleksiya hisoblanadi.

mevalar = (
    "olma",
    "banan",
    "anor"
)

print(
    mevalar
)

Tuple:

Tartibli
O‘zgarmas
Indeks bilan ishlaydi
Takroriy qiymatlarga ruxsat beradi

Tuple indekslari¶

mevalar = (
    "olma",
    "banan",
    "anor"
)

print(
    mevalar[0]
)

print(
    mevalar[-1]
)

Tuple o‘zgarmaydi¶

Quyidagi kod xatolik beradi:

mevalar = (
    "olma",
    "banan",
    "anor"
)

mevalar[0] = "uzum"

Tuple yaratilgandan keyin uning elementlarini o‘zgartirib bo‘lmaydi.

Tuple unpacking¶

Tuple qiymatlarini bir nechta o‘zgaruvchiga ajratish mumkin.

foydalanuvchi = (
    "Softromeda",
    25,
    "Dasturchi"
)

ism, yosh, kasb = foydalanuvchi

print(
    ism
)

print(
    yosh
)

print(
    kasb
)

`*` bilan unpacking¶

sonlar = (
    10,
    20,
    30,
    40,
    50
)

birinchi_son, *qolgan_sonlar = sonlar

print(
    birinchi_son
)

print(
    qolgan_sonlar
)

Natija:

10
[20, 30, 40, 50]

Set¶

Set takrorlanmaydigan elementlar to‘plamidir.

mevalar = {
    "olma",
    "banan",
    "anor"
}

print(
    mevalar
)

Setning asosiy xususiyatlari:

Takroriy elementlarni saqlamaydi
Indeksga ega emas
O‘zgaruvchan
Matematik to‘plam amallarini qo‘llab-quvvatlaydi

Setdagi takroriy qiymatlar¶

sonlar = {
    1,
    2,
    2,
    3,
    3,
    3
}

print(
    sonlar
)

Natijada har bir qiymat faqat bir marta qoladi:

{1, 2, 3}

Bo‘sh set¶

Quyidagisi bo‘sh dictionary yaratadi:

qiymatlar = {}

Bo‘sh set yaratish uchun:

qiymatlar = set()

`add()`¶

Setga element qo‘shadi.

mevalar = {
    "olma",
    "banan"
}

mevalar.add(
    "anor"
)

print(
    mevalar
)

`remove()`¶

Setdan elementni o‘chiradi.

mevalar = {
    "olma",
    "banan",
    "anor"
}

mevalar.remove(
    "banan"
)

print(
    mevalar
)

Element mavjud bo‘lmasa, xatolik beradi.

`discard()`¶

discard() ham elementni o‘chiradi, lekin element mavjud bo‘lmasa xatolik bermaydi.

mevalar = {
    "olma",
    "banan"
}

mevalar.discard(
    "anor"
)

print(
    mevalar
)

Set amallari¶

Setlar bilan matematik to‘plam amallarini bajarish mumkin.

Ikki to‘plam:

birinchi_toplam = {
    1,
    2,
    3,
    4
}

ikkinchi_toplam = {
    3,
    4,
    5,
    6
}

Union¶

Ikki to‘plamning barcha elementlari:

natija = (
    birinchi_toplam
    | ikkinchi_toplam
)

print(
    natija
)

Natija:

{1, 2, 3, 4, 5, 6}

Intersection¶

Ikkalasida ham mavjud elementlar:

natija = (
    birinchi_toplam
    & ikkinchi_toplam
)

print(
    natija
)

Natija:

{3, 4}

Difference¶

Faqat birinchi to‘plamda mavjud elementlar:

natija = (
    birinchi_toplam
    - ikkinchi_toplam
)

print(
    natija
)

Natija:

{1, 2}

Symmetric difference¶

Faqat bittasida mavjud bo‘lgan elementlar:

natija = (
    birinchi_toplam
    ^ ikkinchi_toplam
)

print(
    natija
)

Natija:

{1, 2, 5, 6}

Dictionary¶

Dictionary kalit va qiymat juftliklarini saqlaydi.

foydalanuvchi = {
    "ism": "Softromeda",
    "yosh": 25,
    "kasb": "Dasturchi"
}

print(
    foydalanuvchi
)

Dictionary:

Kalit → qiymat

Masalan:

"ism" → "Softromeda"
"yosh" → 25
"kasb" → "Dasturchi"

Dictionary qiymatini olish¶

foydalanuvchi = {
    "ism": "Softromeda",
    "yosh": 25
}

print(
    foydalanuvchi["ism"]
)

Natija:

Softromeda

`get()`¶

Kalit mavjud bo‘lmasa xatolik bermaslik uchun get() ishlatilishi mumkin.

foydalanuvchi = {
    "ism": "Softromeda",
    "yosh": 25
}

kasb = foydalanuvchi.get(
    "kasb"
)

print(
    kasb
)

Natija:

None

Standart qiymat berish:

kasb = foydalanuvchi.get(
    "kasb",
    "Noma'lum"
)

print(
    kasb
)

Natija:

Noma'lum

Dictionary qiymatini o‘zgartirish¶

foydalanuvchi = {
    "ism": "Softromeda",
    "yosh": 25
}

foydalanuvchi["yosh"] = 26

print(
    foydalanuvchi
)

Dictionaryga yangi qiymat qo‘shish¶

foydalanuvchi = {
    "ism": "Softromeda"
}

foydalanuvchi["kasb"] = "Dasturchi"

print(
    foydalanuvchi
)

`update()`¶

Bir nechta qiymatni birdaniga qo‘shish yoki yangilash:

foydalanuvchi = {
    "ism": "Softromeda"
}

foydalanuvchi.update(
    {
        "yosh": 25,
        "kasb": "Dasturchi"
    }
)

print(
    foydalanuvchi
)

`keys()`¶

Dictionary kalitlarini olish:

foydalanuvchi = {
    "ism": "Softromeda",
    "yosh": 25,
    "kasb": "Dasturchi"
}

print(
    foydalanuvchi.keys()
)

`values()`¶

Qiymatlarni olish:

print(
    foydalanuvchi.values()
)

`items()`¶

Kalit va qiymat juftliklarini olish:

print(
    foydalanuvchi.items()
)

Sikl bilan:

for kalit, qiymat in foydalanuvchi.items():

    print(
        f"{kalit}: {qiymat}"
    )

Dictionarydan o‘chirish¶

pop():

foydalanuvchi = {
    "ism": "Softromeda",
    "yosh": 25
}

yosh = foydalanuvchi.pop(
    "yosh"
)

print(
    yosh
)

print(
    foydalanuvchi
)

`popitem()`¶

Oxirgi kalit-qiymat juftligini olib tashlaydi:

foydalanuvchi = {
    "ism": "Softromeda",
    "yosh": 25,
    "kasb": "Dasturchi"
}

juftlik = foydalanuvchi.popitem()

print(
    juftlik
)

print(
    foydalanuvchi
)

`del`¶

Ma’lum kalitni o‘chirish:

foydalanuvchi = {
    "ism": "Softromeda",
    "yosh": 25
}

del foydalanuvchi["yosh"]

print(
    foydalanuvchi
)

Dictionaryni tozalash¶

foydalanuvchi = {
    "ism": "Softromeda",
    "yosh": 25
}

foydalanuvchi.clear()

print(
    foydalanuvchi
)

Natija:

{}

Ichma-ich kolleksiyalar¶

Kolleksiyalar boshqa kolleksiyalarni o‘z ichiga olishi mumkin.

foydalanuvchilar = [
    {
        "ism": "Softromeda",
        "yosh": 25
    },
    {
        "ism": "Ali",
        "yosh": 30
    }
]

Bu:

list
  └── dictionary

tuzilmasidir.

Murakkab ma’lumotlar¶

Masalan:

dastur = {
    "nomi": "Softromeda",
    "foydalanuvchilar": [
        {
            "ism": "Ali",
            "yosh": 25
        },
        {
            "ism": "Vali",
            "yosh": 30
        }
    ]
}

Foydalanuvchi nomini olish:

birinchi_foydalanuvchi = (
    dastur["foydalanuvchilar"][0]
)

print(
    birinchi_foydalanuvchi["ism"]
)

Natija:

Ali

Kolleksiyalarni solishtirish¶

Listlar qiymatlari bo‘yicha solishtiriladi:

birinchi_royxat = [
    1,
    2,
    3
]

ikkinchi_royxat = [
    1,
    2,
    3
]

print(
    birinchi_royxat == ikkinchi_royxat
)

Natija:

True

`in` bilan kolleksiyalar¶

List:

mevalar = [
    "olma",
    "banan"
]

if "olma" in mevalar:

    print(
        "Olma mavjud."
    )

Set:

mevalar = {
    "olma",
    "banan"
}

if "olma" in mevalar:

    print(
        "Olma mavjud."
    )

Dictionaryda in kalitlarni tekshiradi:

foydalanuvchi = {
    "ism": "Softromeda",
    "yosh": 25
}

if "ism" in foydalanuvchi:

    print(
        "Ism kaliti mavjud."
    )

Kolleksiya tanlash¶

Qaysi kolleksiyani ishlatishni vazifaga qarab tanlash kerak.

list
→ tartibli va o‘zgaruvchan ma’lumotlar

tuple
→ tartibli va o‘zgarmas ma’lumotlar

set
→ noyob qiymatlar va to‘plam amallari

dictionary
→ kalit va qiymat orqali ma’lumot saqlash

Masalan:

mevalar = [
    "olma",
    "banan",
    "anor"
]

Tartib muhim bo‘lsa list.

koordinata = (
    41.31,
    69.28
)

O‘zgarmas juftlik uchun tuple.

noyob_raqamlar = {
    1,
    2,
    3
}

Takrorlanmaydigan qiymatlar uchun set.

foydalanuvchi = {
    "ism": "Softromeda",
    "yosh": 25
}

Nomlangan ma’lumotlar uchun dictionary.

Amaliy mashqlar¶

Mashq 1¶

5 ta meva saqlaydigan list yarating va barcha elementlarni chiqaring.

Mashq 2¶

Listga yangi element qo‘shing va undan bitta elementni o‘chiring.

Mashq 3¶

Listdagi sonlarni o‘sish tartibida tartiblang.

Mashq 4¶

Tuple yordamida foydalanuvchining ism, yosh va kasbini saqlang.

Mashq 5¶

Takroriy sonlardan iborat listni set yordamida noyob qiymatlarga aylantiring.

Mashq 6¶

Ikki setning umumiy elementlarini toping.

Mashq 7¶

Foydalanuvchi ma’lumotlarini dictionaryda saqlang.

Mashq 8¶

Dictionarydagi barcha kalit va qiymatlarni chiqaring.

Mashq 9¶

List ichida bir nechta foydalanuvchi dictionarylarini yarating va ularni sikl bilan chiqaring.

Mashq 10¶

Mahsulot nomi, narxi va miqdorini dictionaryda saqlab, umumiy narxni hisoblang.

Mini loyiha — Softromeda foydalanuvchilar tizimi¶

Bir nechta foydalanuvchini list va dictionary yordamida boshqaramiz.

foydalanuvchilar = [
    {
        "ism": "Softromeda",
        "yosh": 25,
        "kasb": "Dasturchi"
    },
    {
        "ism": "Ali",
        "yosh": 30,
        "kasb": "Muhandis"
    },
    {
        "ism": "Vali",
        "yosh": 22,
        "kasb": "Dizayner"
    }
]

for foydalanuvchi in foydalanuvchilar:

    print(
        "--------------------"
    )

    print(
        f"Ism: {foydalanuvchi['ism']}"
    )

    print(
        f"Yosh: {foydalanuvchi['yosh']}"
    )

    print(
        f"Kasb: {foydalanuvchi['kasb']}"
    )

Natija:

--------------------
Ism: Softromeda
Yosh: 25
Kasb: Dasturchi
--------------------
Ism: Ali
Yosh: 30
Kasb: Muhandis
--------------------
Ism: Vali
Yosh: 22
Kasb: Dizayner

Bob xulosasi¶

Bu bobda Python kolleksiyalarini chuqurroq o‘rgandik.

Asosiy turlar:

list
tuple
set
dictionary

List bilan:

append()
insert()
extend()
remove()
pop()
clear()
index()
count()
sort()
sorted()
reverse()
copy()

Tuple bilan:

indeks
slicing
unpacking

Set bilan:

add()
remove()
discard()
union
intersection
difference
symmetric difference

Dictionary bilan:

get()
keys()
values()
items()
update()
pop()
popitem()
clear()

Shuningdek, murakkab ma’lumotlarni:

list ichida dictionary
dictionary ichida list
dictionary ichida dictionary

kabi shakllarda saqlashni ko‘rdik.

Keyingi bobda Python'da modullar va paketlar yordamida kodni bir nechta faylga ajratish va tayyor funksiyalardan foydalanishni o‘rganamiz.

Tugmalar	Amal
`?`	Yordam oynasini ochish
`n`	Keyingi sahifa
`p`	Oldingi sahifa
`s`	Izlash

8. Kolleksiyalar¶

List¶

List indekslari¶

Manfiy indeks¶

List slicing¶

Listni o‘zgartirish¶

append()¶

insert()¶

extend()¶

remove()¶

pop()¶

clear()¶

index()¶

count()¶

sort()¶

sorted()¶

reverse()¶

Listni nusxalash¶

Tuple¶

Tuple indekslari¶

Tuple o‘zgarmaydi¶

Tuple unpacking¶

* bilan unpacking¶

Set¶

Setdagi takroriy qiymatlar¶

Bo‘sh set¶

add()¶

remove()¶

discard()¶

Set amallari¶

Union¶

Intersection¶

Difference¶

Symmetric difference¶

Dictionary¶

Dictionary qiymatini olish¶

get()¶

Dictionary qiymatini o‘zgartirish¶

Dictionaryga yangi qiymat qo‘shish¶

update()¶

keys()¶

values()¶

items()¶

Dictionarydan o‘chirish¶

popitem()¶

del¶

Dictionaryni tozalash¶

Ichma-ich kolleksiyalar¶

Murakkab ma’lumotlar¶

Kolleksiyalarni solishtirish¶

in bilan kolleksiyalar¶

Kolleksiya tanlash¶

Amaliy mashqlar¶

Mashq 1¶

Mashq 2¶

Mashq 3¶

Mashq 4¶

Mashq 5¶

Mashq 6¶

Mashq 7¶

Mashq 8¶

Mashq 9¶

Mashq 10¶

Mini loyiha — Softromeda foydalanuvchilar tizimi¶

Bob xulosasi¶

`append()`¶

`insert()`¶

`extend()`¶

`remove()`¶

`pop()`¶

`clear()`¶

`index()`¶

`count()`¶

`sort()`¶

`sorted()`¶

`reverse()`¶

`*` bilan unpacking¶

`add()`¶

`remove()`¶

`discard()`¶

`get()`¶

`update()`¶

`keys()`¶

`values()`¶

`items()`¶

`popitem()`¶

`del`¶

`in` bilan kolleksiyalar¶