Dinamik tiplashtirilgan

LUG’ATLAR ISHLASH ASOSLARI
Pyton tilida turli tipdagi ma`lumotlarni saqlash uchun turli tuzilmalar ishlab chiqilgan. Ana shunday tuzilmalardan biri lug’at (dict) bo`lib, u ma`lumotlarni qalit-qiymat shaklida saqlash imkonini beradi. Lug’atdagi qiymatlarga ularning kaliti yordamida murojaat qilish mumkin.
Lug’atlar { } (figurali qavslar) orasida ko`rsatiladigan va bir-biridan vergul bilan ajratilgan elementlar ketma-ketligi tarzida e`lon qilinadi. Lug’atning har bir elementi “qiymat: kalit” juftligi orqali ifodalanadi. Lug’atning qiymatlari takrorlanishi mumkin, ammo ularning kalitlari betakror bo`lishi lozim.
Quyida lug’atlarni tashkil qilish uchun bir qator namunalar keltirilmoqda.
dict_namuna = { } # bo`sh lug’at
dict_namuna = {1:'kitob', 2:'daftar'} # kaliti butun son bo`lgan lug’at
dict_namuna = {'meva':'olma', 1:[4, 6, 8]} # turli tipdagi kalitli lug’at. Shuningdek, lug’atlarni dict() funktsiyasi yordamida yaratish mumkin :
dict_namuna = dict({1:'kitob', 2:'daftar'})
yoki
dict_namuna = dict([(1,'kitob'), (2,'daftar')])
Lug’atlar ichma-ich joylashgan bo`lishi ham mumkin: bu shuni anglatadiki, bir lug’at boshqa lug’at ichida e`lon qilinadi. Masalan:
dict_namuna = {
1: {'talaba1': 'Aliyev', 'talaba2': 'Valiyev', 'talaba3': 'Qodirova'},
2: {'kurs1': 'Informatika', 'kurs2': 'Matematika', 'kurs3': 'Geometriya'}
}
Lug’at elementlarini print operatori yordamida odatiy usul bilan chop qilish mumkin. CHop qilishdan avval interpretator lug’at elementlarini tasodifiy ravishda joylashtiradi. Masalan:
dict_namuna = {"Companiya":"Toyota", "model":"Premio", "yili":2012}
print(dict_namuna)

Lug’at elementlari bilan ishlash uchun kalitlarini []-kvadrat qavslar orasida ko`rsatib murojaat qilinadi:
dict_namuna = {"Companiya":"Toyota", "model":"Premio", "yili":2012}
x = dict_namuna["model"]
print(x)

Quyidagi namunaga e`tibor bering:
dict = {'Familiyasi': 'aliyev', 'Yoshi': 23, 'Fani': 'Geometriya'}
print("Talaba familiyasi:", dict['Familiyasi'])
print("Fani:", dict['Fani'])
print("Yoshi:", dict['yoshi'])

Shuningdek lug’at elementlari bilan ishlash uchun get() funktsiyasi ham nazarda tutilgan. Bu funktsiya umumiy ko`rinishi
lug’at_nomi.get(kalit)
bo`lgan ko`rsatma shaklida qo`llaniladi. Masalan:
dict_namuna = {"Companiya":"Toyota", "model":"Premio", "yili":2012}
x = dict_namuna.get("model")
print(x)

Lug’atga yangi elementlarni bir nechta usullar bilan qo`shish mumkin. Quyida ularning ayrimlari bayon qilinadi.
dict_namuna = {"Companiya":"Toyota", "model":"Premio", "yili":2012}
dict_namuna["Quvvati "] = "85 ot kuchi"
print(dict_namuna)

Navbatdagi usulda bo`sh lug’at olib, unga yangi elementlar ketma-ket qo`shiladi:
Yangi = {}
Yangi[0] = 'Olma'
Yangi[2] = 'Nok'
Yangi[5] = 20
print("3 ta element qo’shildi: ")
print(Yangi)

Keltirilgan namunada “Olma”, “Nok” va “20” qiymatlarga 0, 2 va 5 kalitlar mos qo`yilgan.
Zarur hollarda bitta kalit bilan bir nechta qiymatlarni e`lon qilish mumkin:
Yangi [2] = 1, "Uzum", 4
print(Yangi)

Bu yerda 2 kalitga (1, "Uzum", 4) qiymatlar mos qo`yilgan.
Lug’at elementlarini kalitlar yordamida tahrirlash mumkin.
dict_namuna["yili"] = 2014
Lug’at elementlarini bir necha usullar bilan o`chirish mumkin.
Ko`rsatilgan kalitli element lug’atdan del buyrug’i yordamida o`chirilishi mumkin. Masalan:
dict_namuna = {"Companiya":"Toyota", "model":"Premio", "yili":2012}
del dict_namuna["yili"]
print(dict_namuna)

Yana bir usul argumentida kalit ko`rsatiladigan pop() funktsiyasi bilan bog’liq. Masalan:
dict_namuna = {"Companiya":"Toyota", "model":"Premio", "yili":2012}
dict_namuna.pop("yili")
popitem() funktsiyasi lug’atning oxirgi elementini o`chiradi. Bu funktsiya uchun argumentni ko`rsatish shart emas.
dict_namuna = {"Companiya":"Toyota", "model":"Premio", "yili":2012}
dict_namuna.popitem()
print(dict_namuna)

Bu yerda interpretator lug’at elementlarini tasodifiy joylashtirganda “model” kaliti lug’at oxiriga joylashtirilgan va shu sababli o`chirilgan.
Lug’atdagi barcha elementlarni to`laligicha o`chirish uchun del operatoridan foydalanish mumkin:
dict_namuna = {"Companiya":"Toyota", "model":"Premio","yili":2012}
del dict_namuna
print(dict_namuna)

Ayrim hollarda lug’atni bo`sh qoldirgan holda, uning elementlarini o`chirishga to`g’ri kelishi mumkin. Bu muammoni clear() funktsiyasi yordamida hal qilinadi:
dict_namuna.clear()
print(dict_namuna)

items() metodi lug’at elementlarini ob`ektlar shaklida birma-bir ko`rib chiqish uchun qo`llaniladi. Bu ob`ekt “kalit-qiymat” juftligi shaklida ifodalanadi.
dict_namuna = {"Companiya":"Toyota","model": "Premio", "yili":2012}
for k, v in dict_namuna.items():
print(k, v)

items() funktsiyasi qaytarayotgan ob`ektlardan lug’atdagi o`zgarishlarni ko`rsatish uchun ham foydalanish mumkin:
dict_namuna = {"Companiya":"Toyota", "model":"Premio", "yili":2012}
dict_namuna['model']='Klassic'
x=dict_namuna.items()
print(x)

Ko`rsatilgan kalit va qiymatli lug’atlarni tashkil qilish uchun fromkeys() metodidan foydalanish mumkin. Bu metod umumiy ko`rinishda quyidagicha yoziladi:
dictionary.fromkeys(kalit, qiymat),
bu yerda kalit - takrorlanuvchi ob`ekt kalitlari; qiymat parametri barcha kalitlar uchun qiymat bo`lib xizmat qiladi. Agar bu parametr ko`rsatilmasa, qiymat sifatida to`g’ridan-to`g’ri — None olinadi. Bu metod kalitlarni birma-bir ko`rib chiqadi va ularni ko`rsatilgan qiymatlar bilan bog’laydi.
Faraz qilaylik, uchta kalitli va bir xil qiymatli lug’atni tashkil qilish talab qilingan bo`lsin. Bu muammoni quyidagicha hal qilish mumkin:
familiyasi=('Aliyev', 'Valiyev', 'soliyev')
yoshi=18
dict_namuna = dict.fromkeys(familiyasi, yoshi)

Ko`rsatilgan kalitga taalluqli bo`lgan qiymatni olish uchun setdefault() metodi hizmat qiladi. Agar kalit mavjud bo`lmasa, lug’atga qiymati bilan birga qo`shib qo`yiladi. Bu metod umumiy ko`rinishda quyidagicha yoziladi:
dictionary.setdefault(keyname, value),
bu yerda keyname parametri majburiy va u qiymatini qaytarish lozim bo`lgan kalit nomini anglatadi; value parametri esa majburiy emas. Agar kalit mavjud bo`lmasa, u holda funktsiyaning qiymati kalitga qiymat qilib beriladi. Bu qiymat to`g’ridan-to`g’ri — None.
dict_namuna = {"Companiya": "Toyota", "model": "Premio", "yili": 2012}
y=dict_namuna.setdefault("model")
x = dict_namuna.setdefault("color", "Yashil")
print(x, y)
print(dict_namuna)

keys() metodi lug’atdagi barcha kalitlar ro`yhatidan iborat bo`lib, o`zida takrorlanuvchi ob`ektlarni mujassamlashtiradi. SHuningdek, items() metodi kabi lug’atdagi o`zgarishlarni qayd etadi. keys() metodi umumiy ko`rinishda quyidagicha yoziladi:
dictionary.keys()
Masalan:
dict_namuna = {"Companiya":"Toyota", "model":"Premio", "yili": 2012}
x = dict_namuna.keys()
print(x)

Odatda bu metod lug’atdagi barcha kalitlarni birma-bir ko`rib chiqish uchun qo`llaniladi:
dict_namuna = {"Companiya": "Toyota", "model": "Premio", "yili": 2012}
for k in dict_namuna.keys():
print(k)

Yuqoridagi metodlardan tashqari lug’atlar bilan ishlash uchun len() (lug’atdagi elementlar sonini aniqlaydi) hamda copy() (lug’atdan nusxa olish) kabi metodlardan ham foydalanish mumkin.