tuple, list va str turlari

tuple turi

Ushbu turni oldingi darslarda vektorlarni va matritsalarni Python tasvirlash uchun qisqacha o’rganib chiqdik. Endi ushbu tur haqida chuquroq o’rganib chiqamiz. Chunki ushbu turda bir qator turli xil amallar mavjud. Bu tur yuqorida aytganimzdek o’zida bir nechta qiymatlarni bitta o’zgaruvchi sifatida saqlash imkonini beradi. Biz vektorni ham bitta o’zgaruvchi deb tushunishimiz mumkin va uning elementlariga indeks orqali murojaat qilamiz.

Ushbu turdagi o’zgaruvchilarni e’lon qilishning bir qancha turlari mavjud:

1. Qavs ichida uning qiymatlarini vergul orqali yozib ketish bilan:

# o'quvchilarning ismlari
names = ("Axmad", "Doniyor", "Botir", "Qahramon")
print(names)
print(type(names))

('Axmad', 'Doniyor', 'Botir', 'Qahramon')
<class 'tuple'>

2. Shu qavslarni olib tashlash orqali, ya’ni faqat vergullar yetarli:

# o'quvchilarning ismlari
names = "Axmad", "Doniyor", "Botir", "Qahramon"
print(names)
print(type(names))

('Axmad', 'Doniyor', 'Botir', 'Qahramon')
<class 'tuple'>

Lekin, agar biz faqat bitta elementdan iborat tuple o’zgaruvchisini e’lon qilmoqchi bo’lsak, unda shu bitta qiymatni yozib keyin esa bitta vergul qo’shishimiz kerak bo’ladi, ya’ni:

# o'quvchilarning ismlari
names = ("Axmad", )
print(names)
names = "Axmad",
print(names)

('Axmad',)
('Axmad',)

Yuqoridagi jarayonlarni biz, odatda, inglizda ‘packing’ deb ataymiz, ya’ni bir nechta elementlarni bitta o’zgaruvchiga kiritishdir. Uning teskarisi ham mavjud bo’lib, u jarayonda biz tuple o’zgaruvchisidagi qiymatlarni alohida o’zgaruvchilarga yozib olishimiz mumkin.

# o'quvchilarning ismlari
name1, name2, name3, name4 = "Axmad", "Doniyor", "Botir", "Qahramon"
print(name1, name2, name3, name4)

Axmad Doniyor Botir Qahramon

Indekslash

Biz vektorlar va matritsalar bilan ishlash davomida qanday qilib tuple o’zgaruvchilari bilan ishlashni chuqur o’rgandik. Lekin biz hamma holatlarda ulardan qiymatlarini oldik. Lekin ularning qiymatlarini o’zgartirib ko’rmadik. Chunki ushbu turda elementlarning qiymatini olish mumkin, lekin hech qachon o’zgartirish mumkin emas, ya’ni = belgisi bilan mavjud qiymatni boshqasiga almashtira olmaymiz. Hamda undagi elementlar sonini ham o’zgartira olmaymiz. Ushbu ‘noqulaylik’ dasturlash tilining ba’zi chegaralaridir, lekin bundan boshqa turda, ya’ni list turida bu imkoniyatlar mavjud. Quyida bunga misol ko’ramiz:

# o'quvchilarning ismlari
names = "Axmad", "Doniyor", "Botir", "Qahramon"
# masalan, birinchi ismni, ya'ni
# Axmadni Asqar bilan almashtirib ko'raylik
names[0] = "Asqar"

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
Cell In[5], line 5
      2 names = "Axmad", "Doniyor", "Botir", "Qahramon"
      3 # masalan, birinchi ismni, ya'ni
      4 # Axmadni Asqar bilan almashtirib ko'raylik
----> 5 names[0] = "Asqar"

TypeError: 'tuple' object does not support item assignment

Shuning uchun ushbu turdan biz juda kam foydalanamiz, lekin dasturni tezlik va boshqa jihatlarda juda muhim ahamiyatga ega. Bu kabi narsalarni o’rni kelganda yoritib ketamiz, chunki ularni tushinish yana boshqa narsalarni talab qiladi.

list turi

Ushbu tur tuple turi bilan deyarli bir xil imkoniyatlarga ega bo’lib, qo’shimchasiga bu turdagi o’zgaruvchilarni bemalol elementlarning qiymatlarini yangilash hamda zarur holatlarda yangi element qo’shishmiz mumkin. Bu qulayliklar bizga ushbu turni keng qo’llash imkoniyatini ochadi. Ushbu turda o’zgaruvchi e’lon qilish uchun biz faqat [ va ] qavslaridan foydalanamiz, ya’ni tuple dagi kabi boshqa holatlar yo’q. Lekin indekslash va ichma-ich list turida qiymat e’lon qilishlar bir xil hisoblanadi. Quyida oldingi namunalarni list turidagi ko’rinishi.

# o'quvchilarning ismlari
names = ["Axmad", "Doniyor", "Botir", "Qahramon"]
print(names)
print(type(names))

['Axmad', 'Doniyor', 'Botir', 'Qahramon']
<class 'list'>

Ushbu bobda biz e’tibor qaratmoqchi bo’lgan tur esa list, ya’ni ro’yxat turidir. Ushbu tur oldingi turga nisbatan ancha moslashuvchan bo’lib, u bilan bir qator imkoniyatlarga ega bo’lamiz hamda bundan keyinig o’rinlarda asosan ushbu turdan foydalanamiz. Ko’pchilik dasturlash tillarida bo’lagani kabi, Pythonda ham turlar bilan ishlash bir birga juda o’xshaydi, aytmoqchi bo’lganimiz, bu tur tuple bilan deyarli bir xil ko’rinishda ishlaydi faqat bir qator ustunliklar bilan. Keling, birinchi, qanday e’lon qilish hanmda uning u bilan dastlabki ammalarni ko’rsakda, keyin boshqa uning xususiyatlarni muhokama qilsak.

# list turida a o'zgaruvchisi
a = [3, 6, 2, 9]
# uning hamma elementlari
# chop qilish
print(a)
# elementlarining qiymatlarni olish
# 2-elementi
print("2-elementi:", a[1])
print("a o'zgaruvchisining turi:", type(a))

[3, 6, 2, 9]
2-elementi: 6
a o'zgaruvchisining turi: <class 'list'>

# elementlarining yig'indisini
# topish
a = [3, 6, 2, 9]
s = a[0]
i = 1
n_a = len(a)
while i < n_a:
  s = s + a[i]
  i = i + 1
print("Elementlarining yig'indisi:", s)

Elementlarining yig'indisi: 20

Yuqoridagi ko’rgan ikkita kodimiz bu tuple turi bilan bir xil, faqat yagona farqi bu e’lon qilishda, ya’ni oddiy () qavslarning o’rniga biz to’rburchak [] qavslardan foydalandik. Esda tuting, yuqorida biz len() funksiyasidan foydalandik, ushbu funksiya tuple o’zgaruvchisi uchun qanday ishlasa bu uchun ham shunday vazifada ishlayveradi. Hozir navbat ushbu turning imkoniyatlariga keldi, ulardan ba’zi birlari:

1. dinamik ravishda yangi element qo’shish. Buning uchun list turining append() metodinidan foydalanamiz. O’zgaruvhilarning metodlarga murojaat qilish o’zgaruvchidan keyin nuqta (.) belgisini qo’yamiz va kerakli metod nomni yozib, undan so’ng qavs ichida zarur parameterlarni beramiz. list turida e’lon qilingan o’zgaruvchining append() metodiga murojaat qilish orqali unga yangi element qo’sha,iz. Afsuski, ushbu metod tuple turida mavjud emas.

# bo'sh list
ages = []
# yangi yosh qo'shish
ages.append(22)
print("Yoshlar: ", ages)
# foydalanuvchidan yangi yosh qo'shishni so'rash
# masalan 4 ta insoning yoshini
n = 4
# sanagich
i = 0
# takrorlash bittalab kiritish uchun
while i < n:
  # albatta yosh qiymati butun
  # shuning uchun int() funksiyasi
  # yordamida int turiga o'tkazamiz
  yosh = int(input('inson yoshini kiriting: '))
  # endi append() metodi
  ages.append(yosh)
  # bitta yosh kiritdik
  # shuning uchun sanagichni bittaga oshiramiz
  i = i + 1

print("Siz kiritgan yoshlar:", ages)

Yoshlar:  [22]
Siz kiritgan yoshlar: [22, 44, 33, 22, 55]

2. Element qiymatini o’zgartirish. Bu ish oddiy bajariladi, ya’ni uning mos elementiga murojaat qilinib unga yangi qiymat yoziladi. Quyidagi koda uchta yoshning oxirgisining qiymatini o’zgartiramiz va qayta chop qilamiz.

ages = [22, 33, 44]
print("Boshlang'ich qiymatlar:", ages)
# oxigi element qiymatini o'zgartirish
ages[2] = 55
print("O'zgarishdan keyingi qiymatlar:", ages)

Boshlang'ich qiymatlar: [22, 33, 44]
O'zgarishdan keyingi qiymatlar: [22, 33, 55]

3. Mavjud elementni o’chirish. Yuqordagi misol kabi yoshlardan oxirgi qiymatni o’chiramiz.

ages = [22, 33, 44]
print("Boshlang'ich qiymatlar:", ages)
# oxirgi qiymatni o'chirish
# pop metodi orqali oxirgi qiymatni o'chirish
ages.pop()
print("O'chirishdan keyingi qiymatlar:", ages)

Boshlang'ich qiymatlar: [22, 33, 44]
O'chirishdan keyingi qiymatlar: [22, 33]

4. pop() metodi yordamida element indeksi bo’yicha o’chiramiz, masalan 2-elementni.

ages = [22, 33, 44]
print("Boshlang'ich qiymatlar:", ages)
# oxirgi qiymatni o'chirish
ages.pop(1)
print("O'chirishdan keyingi qiymatlar:", ages)

Boshlang'ich qiymatlar: [22, 33, 44]
O'chirishdan keyingi qiymatlar: [22, 44]

Yuqoridagi ikkita kodning asosiy farqi shuki pop() metodiga, aslida, biz o’chirmoqchi bo’lgan qiymatimizning indeksini berishimiz kerak. Agar shu qiymatni bermasak, u oxirgi elementi o’chirish kerak deb tushunadi hamda o’chirilgan qiymat indeksini qaytaradi. Oxirigi kodda esa biz bu metodga 1 berdik, shuning uchun u 2-elementi o’chirdi. Albattda elementni o’chirishning boshqa usullari ham mavjud, ularni keyinchalik sekin astalik bilan o’ganamiz.

list o’zgaruvchisining metodlari

Ushbu qismda bu tur o’zgaruvchisida mavjud bo’lgan bir qator metodlarni o’rganib chiqamiz, ulardan:

1. clear() metodi, o’zgaruvchidagi hamma elementlarni o’chirib, uni bo’sh holatga o’tkazadi.

ages = [22, 33, 44]
print("Boshlang'ich qiymatlar:", ages)
ages.clear()
print("O'chirishdan keyingi qiymatlar:", ages)

Boshlang'ich qiymatlar: [22, 33, 44]
O'chirishdan keyingi qiymatlar: []

2. Ushbu turdagi bir o’zgaruvchini boshqa turga to’g’iridan-to’g’ir o’zlashtirganda, uning har bir elementi nusxalanishning o’rniga uning xotiradagi manzilini ko’rsatgich sifatida o’zlashtirib qo’yadi. Bu esa ikki o’zgaruvchining bir xiligiga ya’ni elementlari bittaligi olib keladi. Hamda birining elementini o’zgartirsangiz unda boshqasi ham bu o’zgarishni sezadi.

Ta’savur qiling, sizda bitta bank plastik kartasi bor va unda ma’lum bir miqdorda pul turibdi. Siz ushbu kartadan foydalanish uchun ikki xil bank sistemasining ilovasidan foydalanasiz, agar bittasi orqali qandaydir to’lov amalga oshirsangiz ikkinchisiga ham bu o’zgarish ta’sir qiladi, chunki ikkisi ham bir joyni ko’rib turibdi. Xudi shu holat quyida ikkita list turi o’zgaruvchisi ustida sodir bo’ladi.

a = [3, 4, 2, 6]
print("Boshlang'ich qiymatlar:", a)
# to'g'ridan-to'g'iri o'zlashtirish
# endi a bilan b o'zgaruvchilari
# bir joyni ko'rib turibdi
b = a
# b ning elementini o'zgartiraylik
b[1] = 55
# endi a ni chop qilsak
# a ning 1 elementi ham o'zgardi
print("O'chirishdan keyingi qiymatlar:", a)

Boshlang'ich qiymatlar: [3, 4, 2, 6]
O'chirishdan keyingi qiymatlar: [3, 55, 2, 6]

Ushbu holatdan chiqib ketish uchun biz copy() metodidan foydalanamiz. Bu metod har bir elementni alohida xotira manziliga nusxalab, keyin undan list turidagi o’zgaruvchi hosil qilib, oxirida uni alohida o’zgaruvchi sifatida e’lon qiladi. Quyidagi kod oldingi kodning takomillashganidir.

a = [3, 4, 2, 6]
print("Boshlang'ich qiymatlar:", a)
# to'g'ridan-to'g'iri o'zlashtirish
# endi a bilan b o'zgaruvchilari
# bir joyni ko'rib turibdi
b = a.copy()
# b ning elementini o'zgartiraylik
b[1] = 55
# endi a ni chop qilsak
# a ning 1 elementi endi o'zgarmaydi
print("O'chirishdan keyingi qiymatlar:", a)

Boshlang'ich qiymatlar: [3, 4, 2, 6]
O'chirishdan keyingi qiymatlar: [3, 4, 2, 6]

3. insert() metodi yangi elementni ko’rsatilgan indeksdan oldingi o’ringa qo’shadi va undan keyingi hamma elementlar bitta indeksga suriladi.

a = ['A', 'B', 'D', 'F']
print(a)
# Alifbo tartibiga C harfini qo'shamiz
a.insert(2, 'C')
print(a)

# Alifbo tartibiga E harfini qo'shamiz
a.insert(4, 'E')
print(a)

['A', 'B', 'D', 'F']
['A', 'B', 'C', 'D', 'F']
['A', 'B', 'C', 'D', 'E', 'F']

Demak yuqorida biz oxirida ko’rib turgan xatomiz, bu satr turi va butun tur o’rtasida kichik (<) amali mavjud emasligidir.

str turi

Biz ushbu tur haqida juda qisqa ma’lumotga ega bo’ldik va undan asosan natijalarni chop qilishda foydalandik, ya’ni input va print funksiyalari ichida qanday narsa kiritilayotganini va chiqarilayotgani haqida qo’shim ma’lumot berdik. Ushbu funksiyaning ishlashi xudi tuple o’xshaydi, ya’ni unda ham indekslash amallari mavjud bo’lib, lekin ularni o’zgartirish mumkin emas. Ushbu turdagi o’zgaruvchilarning elementlari sifatida biz undag har bir belgini olamiz. Masalan, ushbu Salom olam matnining birinchi elementi S harfi, ikkinchisi esa a hisoblanadi. Quyida while operatori orqali biz ushbu matni alohida qatorlarga ajartib chop qilamiz.

text = "Salom olam"
#  sanagich
i = 0
# takrorlash har bir har bo'yicha
while i < len(text):
  print(text[i])
  i += 1

S
a
l
o
m

o
l
a
m

Yuqoridagi dastur matnida biz len funksiyasidan text o’zgaruvchisida nechta element bor ekanligini tekshirish uchun foydalandik. Demak, ushbu tur ham qolgan ikki turdagi mavjud imkoniyatlarga faqat belgilar to’plami asosida erishar ekan. Ushbu tur ham bir qator o’ziga xos metodlarga ega ular quyidagilar:

Metod	Tasnifi
capitalize()	Birinchi harfni katta harfga almashtiriadi
casefold()	Kichik harfag o’tkazadi

Kesishlar

Ushbu operator, ya’ni, to’plamlarning ma’lum bir qismini kesib olish juda qulay vosita hisoblanadi. Shu orqali biz bir qancha qiyin amallarni tezda va oson bajarish imkoniyatiga ega bo’lamiz. Undan tashqari bu operator ushbu o’rgandan 3 turimizda ham bir xil ishlaydi va boshqa ko’pgina Python dasturlash tili uchun mo’ljallangan vektorlar va matritsalar bilan ishlovchi kutubxonalar uchun ham qo’llash mumkin. Biz quyida ulardan ba’zi bir namunalarni birinchi ko’rib, keyin esa umumiy sinkasisni qarab chiqamiz.

1. Hol

text = "Salom do'stlar"
print(text[6:])

do'stlar

d harfi 6-o’rinda turibdi agar [] ichiga 6 o’zini qo’yasak, u holda bizga faqat d harfini chop qilar edi. Biz 6 elementdn boshlab oxirigacha kesib olmoqchi bo’lsak, u holda indeksdan keyin : belgisini qo’yishimiz kerak bo’ladi. Quyida xudi shu holatni biz boshqa turlar asosida ko’rishimiz mumkin. Masalan, bizda raqamlardan iborat list turida o’zgaruvchi bo’lsin va 5-elementdan boshlab oxirigacha chop qilish uchun quyidagicha kod yozishimiz mumkin.

Eslatma: E’tibor bering ```` bo’sh joy ham belgi hisoblanadi, ya’ni alohida sanaladi va xotiraga yozib chiqiladi.

numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
last_nums = numbers[5:]
print(last_nums)

(5, 6, 7, 8, 9)

2. Hol. Endi ayni shu namunalarda biz shu ko’rsatilgan indeksgacha bo’lgan qismini kesmoqchi bo’lsak, indeksni : belgisidan keyin qo’yamiz. Quyidagicha yuqoridagi ikkita misol:

text = "Salom do'stlar"
print(text[:6])
numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
last_nums = numbers[:5]
print(last_nums)

Salom
(0, 1, 2, 3, 4)

3. Hol. Ushbu holatda Bizda bitta emas 2 ta indeks berilgan bo’lsin, ya’ni elementlarning o’rtasidan ma’lum bir qismni kesib olaylik. Masalan, matndan do'st so’zini va raqamlardan 3 dan 6 gacha bo’lgan qismini. Buning uchun biz birinchi indeskni [] ichiga joylashtirib undan keyin : belgisini qo’yib va oxirida ikkinchi indeksini qo’yamiz. Faqat muhim jihat shundaki, oxirgi kiritgan indeksimizdagi turgan element olinmaydi, ungacha bo’lgani olinadi.

text = "Salom do'stlar"
print(text[6:11])
numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
last_nums = numbers[4:7]
print(last_nums)

do'st
(4, 5, 6)

4. Hol. Ushbu holda eng umumiy ko’rnishni qaraymiz. Ya’ni bizga ikki kesish chegarasi berilishidan tashqari 3-qiymat ham berilam beriladi. Qiymat orqali biz kesilishi kerak elementlardan har nechtasidan bittasini olishimiz kerakligini ko’rsatamiz. Keling tushunarli bo’lishi uchun yuqoridagi raqamlardan faqat toqlarini chiqarishga harakat qilib ko’raylik, oraliq sifatida esa hammasini olamiz.

numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)
start = 1
end = 10
step = 2
last_nums = numbers[start:end:step]
print(last_nums)

(1, 3, 5, 7, 9)

Xulosa qilib quyidagicha umumiy sintaksis yozish mumkin: start:end:step: - start - boshlanishi (kiradi) - end - tugashi (kirmaydi) - step - qadam har nechtasini olish kerakligini ko’rsatadi.

Yuqoridagi parameterlarning hammasi ixtiyoriy bo’lib, biz o’zimiz xohlaganini qo’yishimiz mumkin bo’ladi. Quyida bir nechta turli xil ko’rnishidagi holatlar misol qilib keltirilgan. Umumiy qoida esa agar: - start ga qiymat berilmasa unda boshidan boshlaydi. - end ga qiymat berilmasa unda oxirigacha kesib oladi. - step ga qiymat berilmasa unda uning qiymati 1 bo’ladi.

# list, tuple va str turi uchun har doim o'rinli
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
start = 1
end = 10
step = 2
# start va step bor, end yo'q
last_nums = numbers[start::step]
print(last_nums)
# start bor, end va step yo'q
last_nums = numbers[start::]
print(last_nums)
# start yo'q, end va step bor
last_nums = numbers[:end:step]
print(last_nums)
# birortasi ham bo'lmasa to'liq ro'yxatni qaytaradi
last_nums = numbers[::]
print(last_nums)

(1, 3, 5, 7, 9)
(1, 2, 3, 4, 5, 6, 7, 8, 9)
(0, 2, 4, 6, 8)
(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)

Teskari indekslash

Eng muhim hodisalardan bir bo’lgan teskari indekslash ushbu turlarda juda muhim hisoblanadi. Masalan, indekslash operatoriga -1 ni bersak, unda elementlarning eng oxirigisini qaytaradi, agar u -2 bo’lsa, u holda oxiridan bitta oldingisi va shu tarizda davom etadi.

text = "Salom do'stlar"
# l harfi chop qilinadi
print(text[-1])
# a harfi chop qilinadi
print(text[-2])
# va shu tarzda
# S harfi chop qilinadi
print(text[-14])

r
a
S

Ushbu teskari indekslash orqali bir qator imkoniyatlarga erishish mumkin. Ularni amaliy darslarda va kod yozish davomida bosqichma-bosqich o’rganib boramiz.

Funksiyalar

Biz 3 ta o’zgaruvchi turi bilan tanishdik va ular ustida amallarni o’rgandik. Barchasi o’zida ketma-ketlik saqlagani uchun ularning umumiy metodlari mavjud va ular hammasi uchun bir xil ishlaydi. Quyida ulardan bir nechtasini bilan tanishamiz, albatta ularning hammasini ko’rib tushinish shart emas. Zarur xolatlarda o’rganib boramiz.

1. sort() metodi listdagi elementlarni tartiblaydi agar ular o’rtasida taqqoslash amali mavjud bo’lsa. Tartiblash jarayonida agar ‘str’ o’zgaruvchisi bo’lsa, biz har bir belgining kodidan foydalanamiz, masalan, A harfi 65. Kodini biz chr funksiyasi orqali bilishimiz mumkin.

a = [3, 4, 2, 6, 2, 3, 2]
print('Tartiblanmagan: ', a)
a.sort()
print('Tartiblangan: ', a)

# lekin quyida list elemenlari
# o'rtasida taqqoslash amali mavjud emas
# shuning uchun tartiblash xatolik
# yuzaga chiqarad
a = ['A', 3, 5, 'B']
print(a)
a.sort()
print(a)

Tartiblanmagan:  [3, 4, 2, 6, 2, 3, 2]
Tartiblangan:  [2, 2, 2, 3, 3, 4, 6]
['A', 3, 5, 'B']

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

Cell In[12], line 12

     10 a = ['A', 3, 5, 'B']

     11 print(a)

---> 12 a.sort()

     13 print(a)



TypeError: '<' not supported between instances of 'int' and 'str'

2. reverse() metodi ro’yxatning elementlarini teskari tartibda joylashtiradi.

a = ['A', 'B', 'D', 'F']
# boshlang'ich tartib
print(a)
# teskari tartib
a.reverse()
print(a)

['A', 'B', 'D', 'F']
['F', 'D', 'B', 'A']

3. index() metodi ro’yxatdagi elementlar ichidan berilgan songa teng bo’lgan birinchi elementning o’rnini (indeksni qaytaradi.)

a = [3, 4, 2, 6, 2, 3, 2]
# 2 ning indexsi
n_2 = a.index(2)
# chop qilish
print(n_2)

# 3 ning indeksi
n_3 = a.index(3)
# chop qilish
print(n_3)

2
0

4. count() metodi orqali biz ro’yxatdagi elementlarning qiymati biror berilgan songa teng bo’lganlarining nechta ekanligini aniqlashimiz mumkin.

a = [3, 4, 2, 6, 2, 3, 2]
# 2 lar soni
n_2 = a.count(2)
# chop qilish
print(n_2)

# 3 lar soni
n_3 = a.count(3)
# chop qilish
print(n_3)

3
2

Namunalar

Keling birinchi navbatda biz ikki vektor ustida qo’shish va ayirish amallarini ko’raylik, chunki bu amallarni umumiy holda bajara olmagan edik. Buning asosiy sababi esa, tuple turining cheklovlari edi. Hozir biz list turini o’rgandik va shu tur asosida bu masalani qayta ko’ramiz. Buning uchun bizga \(a, b \in Z^n\) vektorlar berilgan deb hisoblaymiz. Hamda ularning yig’indisi va ayirmasini \(c=a+b\) va \(d=a-b\) o’zgaruvchilariga mos ravishda yuklaymiz. Buning uchun birinchi qilishimiz zarur bo’lgan narsa, foydalanuvchi tomonidan ushbu vektorlarni xotiraga kiritib olamiz. Keyin esa ushbu amallarni bajarib, eng so’ngida natijalarni chop qilamiz.

# foydalanuvchidan vektor
# o'lchamini kiritishini so'raylik
n = int(input("Vektor o'lchamini: "))
# ikkita bo'sh vektorlar e'lon qilamiz
a = []
b = []
# kiritishlarni sanash uchun
i = 0
while i < n:
  # a uchun yangi element kiritishni so'raymiz
  a_elem = int(input("a: "))
  # b uchun yangi element kiritishni so'raymiz
  b_elem = int(input("b: "))
  # kiritilgan elementlarni
  # most listlarga qo'shamiz
  a.append(a_elem)
  b.append(b_elem)
  # sanagichni oshiramiz
  i = i + 1
# ikkinchi qism
# amallarni bajarish
# qo'shish va ayirish
# uchun ikkita bo'sh list
c = []
d = []
# sanash qiymatni yana 0 ga
# qaytaramiz
i = 0
while i < n:
  # qo'shish amali natijasini
  # c list qo'shamiz
  c.append(a[i] + b[i])
  # ayirish natijasni esa
  # d list qo'shamiz
  d.append(a[i] - b[i])
  # sanagichni oshiramiz
  i = i + 1

# natijalarni chop qilamiz
print(a, b, 'a+b=', c)
print(a, b, 'a-b=', d)

[4, 3, 5] [5, 4, 4] a+b= [9, 7, 9]
[4, 3, 5] [5, 4, 4] a-b= [-1, -1, 1]

Matritsalarni Pythonda saqlash

Garchi biz oldingi boblarda list turini o’rganib chiqqan bo’lsakda, lekin ularda biz bir o’lchamli vektorlar saqlashni o’rgandik holos. Endi biz o’sha o’rganishdan hosil bo’lgan bilimlarimizni matrtisalarni saqlash uchun ishlatamiz. Birinchi mavzularda aytib o’tganimizdek Python dasturlash tili yuqori darajali va dinamik turga ega dasturlash tilidir. Bu esa bizga murakkab ko’rinishdagi list turidagi o’zgaruvchilarni osongina xotirada saqlash va ular ustida amallar bajarishimizni osonlashtiradi. Ochiqroq qilib aytsak hozir biz list turidagi o’zgaruvchi e’lon qilib, uning elementlarini ham list turida qilamiz. Agar buni sodda qilib matritsaga qiyoslaydigan bo’lsak, unda matrtisaning ixtiyoriy qatori yoki ustini bu vekotrdir. Demak biz list turidagi o’zgaruvchining elementini yana list turida bo’ladigan qilib dasturni yozamiz.

Keling buning uchun quyidagi jadvalda keltirilgan inson haqidagi ma’lumotlarni saqlashni amalga oshiraylik.

Familiyasi	Ismi	Yoshi	Bo’yi	Vazni
Samandarov	Baxtiryor	22	159	63
Axmadov	Doston	19	180	85
Qarshiyev	Baxrom	20	190	100
Davronov	Akmal	25	175	80

Aval soddalik uchun yuqoridagi jadvalda berilgan 4 ta insoni alohida list turidagi o’zgaruvchilarga saqlab olaylik.

# 1-inson (human ingliz tilida)
human1 = ['Samandarov', 'Baxtiyor', 22, 159, 63]
# 2-inson
human2 = ['Axmadov', 'Doston', 19, 180, 85]
# 3-inson
human3 = ['Qarshiyev', 'Baxrom', 20, 190, 100]
# 4-inson
human4 = ['Davronov', 'Akmal', 25, 175, 80]

Yuqoridagi kodning davomi sifatida quyida, keling ularni bitta asosiy listga birlashtiraylik. Qisqalik uchun yuqoridagi kodni qayta yozmaymiz.

# hamma insonlarni saqlovchi
# list turida o'zgaruvchi
# boshida bo'sh
humans = []
# bo'sh listga ketma-ket
# insonlarni qo'shamiz
humans.append(human1)
humans.append(human2)
humans.append(human3)
humans.append(human4)
# va natijani xom ko'rinishda
# chop qilamiz
print(humans)

[['Samandarov', 'Baxtiyor', 22, 159, 63], ['Axmadov', 'Doston', 19, 180, 85], ['Qarshiyev', 'Baxrom', 20, 190, 100], ['Davronov', 'Akmal', 25, 175, 80]]

Yuqoridagi natijaga e’tibor qararsak, unda list ichida yana list turidagi qiymatlar turganiga guvoh bo’lamiz. Keyingi qatorlarda qanday qilib ushbu ichma-ich joylashgan list lardan bizga kerakli qiymatni chiqarib olishni indekslash amali orqali o’rganamiz. Ta’savur qilaylik, ikkinchi insonning yoshini chop qilishmiz kerak. Buning uchun birinchi asosiy list dan ikkinchi odamga o’tishimiz kerak, buning uchun humans[1] yozamiz. Ushbu kodning qiymatining turi list bu esa bizga bu indekslashdan hosil bo’lgan o’zgaruvchiga yana bir bor inkekslash amallini qo’llash imkonini yaratadi.

# agar shu insoni to'liq chop qilsak
# unda uning turi list
print(humans[1])
# listga ikki marta indeks qo'llasak
print('Ikkinchi insonning yoshi: ', humans[1][2])

['Axmadov', 'Doston', 19, 180, 85]
Ikkinchi insonning yoshi:  19

Ushbu ko’rsatilgan misoldan quyidagi umumiy xulosaning olsak bo’ladi: agar listning elementi ham list turida bo’lsa, u holda yana indekslash amalini qo’llash mumkin va ushbu jarayoni istalgancha davom ettirishimiz mumkin, ya’ni list turidagi o’zgaruvchida 2, 3, 4, … indekslash mumkin, agar list shunday tarzda ichma-ich joylashgan bo’lsa. Ushbu namunada biz faqat dinamik bo’lmagan dastur holatini ko’rdik, ya’ni foydalanuvchi bizga o’zining ma’lumotlarini kiritmadi, shuning uchun quyidagi kod ushbu dasturning to’liq kodi hisoblanib, unda quyidagi imkoniyatlar mavjud:

1. jadvaldagi ma’lumotlar soni o’zgaruvchan;

2. Undagi har bir qiymatni foydalanuvchi kiritadi;

3. hamda kiritilgan ma’lumotlar kiritilgan tartibda chop e’tiladi.

# ma'lumotlar sonini
n = int(input("Nechta ma'lumotlar soni: "))
# bo'sh list
humans = []
# sanash uchun o'zgaruvchi
i = 0
# takrorlash sharti
while i < n:
  # sanagichni oshirish
  i = i + 1
  # i- odam ma'lotlarini kiritish
  print(i, "-odam ma'lumotlarini kiriting: ")
  # familiyasi
  last_name = input('Familiya:')
  # ismi
  first_name = input('Ismi: ')
  # yoshi
  age = int(input('Yoshi: '))
  # bo'yi
  height = int(input("Bo'yi: "))
  # vazni
  weight = int(input("Vazni: "))
  # i-odamni to'liq bitta o'zgaruvchi
  # sifatida ifodalovchi list
  human = [last_name, first_name, age, height, weight]
  # umumiy listga qo'shish
  humans.append(human)

# chop qilish
i = 0
# sarlavha chop qilish
print("Familiya   |   Ism   |   Yosh   |   Bo'y  |   Vazn")
while i < n:
  print(humans[i][0], "   |   ", humans[i][1],
  "   |   ", humans[i][2],
  "   |   ", humans[i][3],
  "   |   ", humans[i][4])
  i = i + 1

1 -odam ma'lumotlarini kiriting:
2 -odam ma'lumotlarini kiriting:
3 -odam ma'lumotlarini kiriting:
Familiya   |   Ism   |   Yosh   |   Bo'y  |   Vazn
Davronova    |    Shahzoda    |    23    |    156    |    56
Otabekov    |    Mansur    |    32    |    187    |    98
Qodirov    |    Yodgor    |    22    |    167    |    76

Yuqoridagi kodni diqqat bilan o’rganib chiqishimiz zarur chunki, unda bir qancha oldingi kodlarga nisbatan mantiqiy o’zgarishlar yuz berdi. Hamda biz dasturlashni ham bosqichma-bosqich o’rganishni maqsad qilib qo’yganmiz va shu maqsadda ba’zi takomillashtirishlarni kiritayabmiz. Biz sanagichning qiymatini while takrorlash operatoridan keyin oshirdik. Lekin, buni oldingi holarda va ushbu kodagi ikkinchi while da hamma kod bajarilib bo’lgandan so’ng oshirgan edik. Aslida uni while takrorlash operatorining qayerida oshirish muhim emas, eng asosiysi bu - takrorlashning mantiqi yuqolmasligi zarur. Keling shu o’zgarish qadam va qadam shuni o’rganib chiqaylik. Birinchi takrorlash operatorida i o’zgaruvchisi (sanagich) ikki narsa uchun xizmat qilyabdi: takrorlashlar sonini tekshirib turish va nechanchi odam ma’lumotini kiritayotganimizni foydalanuvchiga bidirish uchun, ya’ni ushbu kod orqali print(i, "-odam ma'lumotlarini kiriting: "). Biz odatda sanashni 1 dan boshlaymiz, noldan emas, shuning uchun ham biz uning qiymatini birinchi oshirib qo’ydik, oxirida emas. Agar oxirida oshirsak, biz ma’lumotlarni kiritish jarayonida quyidagicha noto’g’iri bo’lgan matni ko’rishimiz mumkin edi: 0-odam ma'lumotlarini kiriting:. Buni to’g’irlash uchun esa print(i, "-odam ma'lumotlarini kiriting: ") kodini print(i+1, "-odam ma'lumotlarini kiriting: ") kabi yozish yetarli. O’zgarish faqat i ning o’rniga biz i+1 chop qildik. Masalan, i ning qiymati 0 bo’lgan joyda, unga bir qo’shdik bu esa bizga 0-odam ma'lumotlarini kiriting: matnini 1-odam ma'lumotlarini kiriting: ko’rinishda chop qilish imkonini beradi. Bundan birinchi while takrorlashning boshqa joyda hech qanday ta’siri yo’q.

Ikkinchi takrorlashda esa biz i o’zgaruvchisini while takrorlashni sanash bilan bir vaqtda, qaysi (nechanchi) odamni chop qilayotgan ekanligimizni bildirish uchun ishlatayabmiz. Agar ushbu holda biz i = i + 1 ifodani while dan keyingi qatorga qo’ysak, u holda biz IndexError xatoligini qayidagi koddagi kabi ko’ramiz.

# birinchi qism bor deb tassavur qilaylik
i = 0
print("Familiya   |   Ism   |   Yosh   |   Bo'y  |   Vazn")
while i < n:
  i =i + 1
  print(humans[i][0], "   |   ", humans[i][1],
  "   |   ", humans[i][2],
  "   |   ", humans[i][3],
  "   |   ", humans[i][4])

Familiya   |   Ism   |   Yosh   |   Bo'y  |   Vazn
Otabekov    |    Mansur    |    32    |    187    |    98
Qodirov    |    Yodgor    |    22    |    167    |    76

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
Cell In[23], line 6
      4 while i < n:
      5   i =i + 1
----> 6   print(humans[i][0], "   |   ", humans[i][1],
      7   "   |   ", humans[i][2],
      8   "   |   ", humans[i][3],
      9   "   |   ", humans[i][4])

IndexError: list index out of range

Xo’sh, nega bunday bo’ldi? Chunki Pythonda indekslash 0 dan boshlanadi va i = i + 1 ifodasi i ning qiymati 0 bo’lganda uning (i ning) qiymatini birga oshirib qo’yadi. Natijada esa biz indekslashni noldan emas bir dan boshlab qo’yamiz, hamda oxirigi takrorlashda humans dan mavjud bo’lmagan indeksni kiritib qo’yamiz. Shu sababdan ham ushbu xatoliklar paydo bo’laybdi. Bu kabi xatoliklarni ham ushbu qo’llanma davomida ko’rib boramiz. Sal chuquroq tushunish uchun, keling shunday qildik ham deylik, qolgan kodlarga qanday o’zgartirish kiritsak yuqoridagi koda to’g’iri ishlaydi? Buning uchun har safar, i ning qiymatini 1 ga kamaytirib ishlatishimiz kerak, ya’ni i-1 kabi. Keyingi kod yuqoridagi kodning o’zgartirilgan ko’rinishi. Lekin bu ma’qullangan yondoshuv emas.

# birinchi qism bor deb tassavur qilaylik
i = 0
print("Familiya   |   Ism   |   Yosh   |   Bo'y  |   Vazn")
while i < n:
  i =i + 1
  print(humans[i-1][0], "   |   ", humans[i-1][1],
  "   |   ", humans[i-1][2],
  "   |   ", humans[i-1][3],
  "   |   ", humans[i-1][4])

Familiya   |   Ism   |   Yosh   |   Bo'y  |   Vazn
Davronova    |    Shahzoda    |    23    |    156    |    56
Otabekov    |    Mansur    |    32    |    187    |    98
Qodirov    |    Yodgor    |    22    |    167    |    76

Ushbu ko’rinishda biz turli xildagi bizga berilgan topshiriqlarni bajarishimiz mumkin. Masalan, ismi bo’yicha qidiruv, yoshi bo’yicha saralash va hakozo. Demak asosiy mantiq bu biz masalamizga va yondoshuvimizga qarab turli xil ko’rinishdagi ichma-ich joylashgan ro’yxatlarni hosil qilishimiz va ular ustida kerakli amalarni bajarishimiz mumkin ekan.