{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# `tuple`, `list` va `str` turlari" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## `tuple` turi\n", "\n", "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.\n", "\n", "Ushbu turdagi o'zgaruvchilarni e'lon qilishning bir qancha turlari mavjud:\n", "\n", "1. Qavs ichida uning qiymatlarini vergul orqali yozib ketish bilan:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "('Axmad', 'Doniyor', 'Botir', 'Qahramon')\n", "\n" ] } ], "source": [ "# o'quvchilarning ismlari\n", "names = (\"Axmad\", \"Doniyor\", \"Botir\", \"Qahramon\")\n", "print(names)\n", "print(type(names))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "2. Shu qavslarni olib tashlash orqali, ya'ni faqat vergullar yetarli:" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "('Axmad', 'Doniyor', 'Botir', 'Qahramon')\n", "\n" ] } ], "source": [ "# o'quvchilarning ismlari\n", "names = \"Axmad\", \"Doniyor\", \"Botir\", \"Qahramon\"\n", "print(names)\n", "print(type(names))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "('Axmad',)\n", "('Axmad',)\n" ] } ], "source": [ "# o'quvchilarning ismlari\n", "names = (\"Axmad\", )\n", "print(names)\n", "names = \"Axmad\", \n", "print(names)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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. " ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Axmad Doniyor Botir Qahramon\n" ] } ], "source": [ "# o'quvchilarning ismlari\n", "name1, name2, name3, name4 = \"Axmad\", \"Doniyor\", \"Botir\", \"Qahramon\"\n", "print(name1, name2, name3, name4)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Indekslash\n", "\n", "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:" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "'tuple' object does not support item assignment", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", "Cell \u001b[0;32mIn[5], line 5\u001b[0m\n\u001b[1;32m 2\u001b[0m names \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAxmad\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mDoniyor\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mBotir\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mQahramon\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;66;03m# masalan, birinchi ismni, ya'ni\u001b[39;00m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;66;03m# Axmadni Asqar bilan almashtirib ko'raylik\u001b[39;00m\n\u001b[0;32m----> 5\u001b[0m \u001b[43mnames\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mAsqar\u001b[39m\u001b[38;5;124m\"\u001b[39m\n", "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment" ] } ], "source": [ "# o'quvchilarning ismlari\n", "names = \"Axmad\", \"Doniyor\", \"Botir\", \"Qahramon\"\n", "# masalan, birinchi ismni, ya'ni\n", "# Axmadni Asqar bilan almashtirib ko'raylik\n", "names[0] = \"Asqar\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## `list` turi\n", "\n", "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." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['Axmad', 'Doniyor', 'Botir', 'Qahramon']\n", "\n" ] } ], "source": [ "# o'quvchilarning ismlari\n", "names = [\"Axmad\", \"Doniyor\", \"Botir\", \"Qahramon\"]\n", "print(names)\n", "print(type(names))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[3, 6, 2, 9]\n", "2-elementi: 6\n", "a o'zgaruvchisining turi: \n" ] } ], "source": [ "# list turida a o'zgaruvchisi\n", "a = [3, 6, 2, 9]\n", "# uning hamma elementlari\n", "# chop qilish\n", "print(a)\n", "# elementlarining qiymatlarni olish\n", "# 2-elementi\n", "print(\"2-elementi:\", a[1])\n", "print(\"a o'zgaruvchisining turi:\", type(a))" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Elementlarining yig'indisi: 20\n" ] } ], "source": [ "# elementlarining yig'indisini\n", "# topish\n", "a = [3, 6, 2, 9]\n", "s = a[0]\n", "i = 1\n", "n_a = len(a)\n", "while i < n_a:\n", " s = s + a[i]\n", " i = i + 1\n", "print(\"Elementlarining yig'indisi:\", s)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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:\n", "\n", "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." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Yoshlar: [22]\n", "Siz kiritgan yoshlar: [22, 44, 33, 22, 55]\n" ] } ], "source": [ "# bo'sh list\n", "ages = []\n", "# yangi yosh qo'shish\n", "ages.append(22)\n", "print(\"Yoshlar: \", ages)\n", "# foydalanuvchidan yangi yosh qo'shishni so'rash\n", "# masalan 4 ta insoning yoshini\n", "n = 4\n", "# sanagich\n", "i = 0\n", "# takrorlash bittalab kiritish uchun\n", "while i < n:\n", " # albatta yosh qiymati butun\n", " # shuning uchun int() funksiyasi\n", " # yordamida int turiga o'tkazamiz\n", " yosh = int(input('inson yoshini kiriting: '))\n", " # endi append() metodi\n", " ages.append(yosh)\n", " # bitta yosh kiritdik\n", " # shuning uchun sanagichni bittaga oshiramiz\n", " i = i + 1\n", "\n", "print(\"Siz kiritgan yoshlar:\", ages)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Boshlang'ich qiymatlar: [22, 33, 44]\n", "O'zgarishdan keyingi qiymatlar: [22, 33, 55]\n" ] } ], "source": [ "ages = [22, 33, 44]\n", "print(\"Boshlang'ich qiymatlar:\", ages)\n", "# oxigi element qiymatini o'zgartirish\n", "ages[2] = 55\n", "print(\"O'zgarishdan keyingi qiymatlar:\", ages)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "3. Mavjud elementni o'chirish. Yuqordagi misol kabi yoshlardan oxirgi qiymatni o'chiramiz." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Boshlang'ich qiymatlar: [22, 33, 44]\n", "O'chirishdan keyingi qiymatlar: [22, 33]\n" ] } ], "source": [ "ages = [22, 33, 44]\n", "print(\"Boshlang'ich qiymatlar:\", ages)\n", "# oxirgi qiymatni o'chirish\n", "# pop metodi orqali oxirgi qiymatni o'chirish\n", "ages.pop()\n", "print(\"O'chirishdan keyingi qiymatlar:\", ages)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "4. `pop()` metodi yordamida element indeksi bo'yicha o'chiramiz, masalan 2-elementni." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Boshlang'ich qiymatlar: [22, 33, 44]\n", "O'chirishdan keyingi qiymatlar: [22, 44]\n" ] } ], "source": [ "ages = [22, 33, 44]\n", "print(\"Boshlang'ich qiymatlar:\", ages)\n", "# oxirgi qiymatni o'chirish\n", "ages.pop(1)\n", "print(\"O'chirishdan keyingi qiymatlar:\", ages)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### `list` o'zgaruvchisining metodlari\n", "\n", "Ushbu qismda bu tur o'zgaruvchisida mavjud bo'lgan bir qator metodlarni o'rganib chiqamiz, ulardan: \n", "\n", "1. `clear()` metodi, o'zgaruvchidagi hamma elementlarni o'chirib, uni bo'sh holatga o'tkazadi." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Boshlang'ich qiymatlar: [22, 33, 44]\n", "O'chirishdan keyingi qiymatlar: []\n" ] } ], "source": [ "ages = [22, 33, 44]\n", "print(\"Boshlang'ich qiymatlar:\", ages)\n", "ages.clear()\n", "print(\"O'chirishdan keyingi qiymatlar:\", ages)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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. \n", "\n", "> 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." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Boshlang'ich qiymatlar: [3, 4, 2, 6]\n", "O'chirishdan keyingi qiymatlar: [3, 55, 2, 6]\n" ] } ], "source": [ "a = [3, 4, 2, 6]\n", "print(\"Boshlang'ich qiymatlar:\", a)\n", "# to'g'ridan-to'g'iri o'zlashtirish\n", "# endi a bilan b o'zgaruvchilari \n", "# bir joyni ko'rib turibdi\n", "b = a\n", "# b ning elementini o'zgartiraylik\n", "b[1] = 55\n", "# endi a ni chop qilsak\n", "# a ning 1 elementi ham o'zgardi\n", "print(\"O'chirishdan keyingi qiymatlar:\", a)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Boshlang'ich qiymatlar: [3, 4, 2, 6]\n", "O'chirishdan keyingi qiymatlar: [3, 4, 2, 6]\n" ] } ], "source": [ "a = [3, 4, 2, 6]\n", "print(\"Boshlang'ich qiymatlar:\", a)\n", "# to'g'ridan-to'g'iri o'zlashtirish\n", "# endi a bilan b o'zgaruvchilari \n", "# bir joyni ko'rib turibdi\n", "b = a.copy()\n", "# b ning elementini o'zgartiraylik\n", "b[1] = 55\n", "# endi a ni chop qilsak\n", "# a ning 1 elementi endi o'zgarmaydi\n", "print(\"O'chirishdan keyingi qiymatlar:\", a)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "3. `insert()` metodi yangi elementni ko'rsatilgan indeksdan oldingi o'ringa qo'shadi va undan keyingi hamma elementlar bitta indeksga suriladi." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['A', 'B', 'D', 'F']\n", "['A', 'B', 'C', 'D', 'F']\n", "['A', 'B', 'C', 'D', 'E', 'F']\n" ] } ], "source": [ "a = ['A', 'B', 'D', 'F']\n", "print(a)\n", "# Alifbo tartibiga C harfini qo'shamiz\n", "a.insert(2, 'C')\n", "print(a)\n", "\n", "# Alifbo tartibiga E harfini qo'shamiz\n", "a.insert(4, 'E')\n", "print(a)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Demak yuqorida biz oxirida ko'rib turgan xatomiz, bu satr turi va butun tur o'rtasida kichik (<) amali mavjud emasligidir." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## `str` turi\n", "\n", "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." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "S\n", "a\n", "l\n", "o\n", "m\n", " \n", "o\n", "l\n", "a\n", "m\n" ] } ], "source": [ "text = \"Salom olam\"\n", "# sanagich\n", "i = 0\n", "# takrorlash har bir har bo'yicha\n", "while i < len(text):\n", " print(text[i])\n", " i += 1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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:\n", "\n", "|Metod|Tasnifi|\n", "|-----|------|\n", "|capitalize()|Birinchi harfni katta harfga almashtiriadi|\n", "|casefold()|Kichik harfag o'tkazadi|" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Kesishlar\n", "\n", "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.\n", "\n", "1. Hol" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "do'stlar\n" ] } ], "source": [ "text = \"Salom do'stlar\"\n", "print(text[6:])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "`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.\n", "\n", "> **Eslatma**: E'tibor bering ` ` bo'sh joy ham belgi hisoblanadi, ya'ni alohida sanaladi va xotiraga yozib chiqiladi." ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(5, 6, 7, 8, 9)\n" ] } ], "source": [ "numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)\n", "last_nums = numbers[5:]\n", "print(last_nums)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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: " ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Salom \n", "(0, 1, 2, 3, 4)\n" ] } ], "source": [ "text = \"Salom do'stlar\"\n", "print(text[:6])\n", "numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)\n", "last_nums = numbers[:5]\n", "print(last_nums)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "do'st\n", "(4, 5, 6)\n" ] } ], "source": [ "text = \"Salom do'stlar\"\n", "print(text[6:11])\n", "numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)\n", "last_nums = numbers[4:7]\n", "print(last_nums)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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." ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(1, 3, 5, 7, 9)\n" ] } ], "source": [ "numbers = (0, 1, 2, 3, 4, 5, 6, 7, 8, 9)\n", "start = 1\n", "end = 10\n", "step = 2\n", "last_nums = numbers[start:end:step]\n", "print(last_nums)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Xulosa qilib quyidagicha umumiy sintaksis yozish mumkin: `start:end:step`:\n", "- `start` - boshlanishi (kiradi)\n", "- `end` - tugashi (kirmaydi)\n", "- `step` - qadam har nechtasini olish kerakligini ko'rsatadi.\n", "\n", "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:\n", "- `start` ga qiymat berilmasa unda boshidan boshlaydi.\n", "- `end` ga qiymat berilmasa unda oxirigacha kesib oladi.\n", "- `step` ga qiymat berilmasa unda uning qiymati `1` bo'ladi." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(1, 3, 5, 7, 9)\n", "(1, 2, 3, 4, 5, 6, 7, 8, 9)\n", "(0, 2, 4, 6, 8)\n", "(0, 1, 2, 3, 4, 5, 6, 7, 8, 9)\n" ] } ], "source": [ "# list, tuple va str turi uchun har doim o'rinli\n", "numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "start = 1\n", "end = 10\n", "step = 2\n", "# start va step bor, end yo'q\n", "last_nums = numbers[start::step]\n", "print(last_nums)\n", "# start bor, end va step yo'q\n", "last_nums = numbers[start::]\n", "print(last_nums)\n", "# start yo'q, end va step bor\n", "last_nums = numbers[:end:step]\n", "print(last_nums)\n", "# birortasi ham bo'lmasa to'liq ro'yxatni qaytaradi\n", "last_nums = numbers[::]\n", "print(last_nums)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Teskari indekslash\n", "\n", "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. " ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "r\n", "a\n", "S\n" ] } ], "source": [ "text = \"Salom do'stlar\"\n", "# l harfi chop qilinadi\n", "print(text[-1])\n", "# a harfi chop qilinadi\n", "print(text[-2])\n", "# va shu tarzda\n", "# S harfi chop qilinadi\n", "print(text[-14])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ushbu teskari indekslash orqali bir qator imkoniyatlarga erishish mumkin. Ularni amaliy darslarda va kod yozish davomida bosqichma-bosqich o'rganib boramiz." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Funksiyalar\n", "\n", "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.\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Tartiblanmagan: [3, 4, 2, 6, 2, 3, 2]\n", "Tartiblangan: [2, 2, 2, 3, 3, 4, 6]\n", "['A', 3, 5, 'B']\n" ] }, { "ename": "TypeError", "evalue": "'<' not supported between instances of 'int' and 'str'", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m\n", "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)\n", "Cell \u001b[0;32mIn[12], line 12\u001b[0m\n", "\u001b[1;32m 10\u001b[0m a \u001b[38;5;241m=\u001b[39m [\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mA\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;241m3\u001b[39m, \u001b[38;5;241m5\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mB\u001b[39m\u001b[38;5;124m'\u001b[39m]\n", "\u001b[1;32m 11\u001b[0m \u001b[38;5;28mprint\u001b[39m(a)\n", "\u001b[0;32m---> 12\u001b[0m \u001b[43ma\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msort\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n", "\u001b[1;32m 13\u001b[0m \u001b[38;5;28mprint\u001b[39m(a)\n", "\n", "\u001b[0;31mTypeError\u001b[0m: '<' not supported between instances of 'int' and 'str'" ] } ], "source": [ "a = [3, 4, 2, 6, 2, 3, 2]\n", "print('Tartiblanmagan: ', a)\n", "a.sort()\n", "print('Tartiblangan: ', a)\n", "\n", "# lekin quyida list elemenlari\n", "# o'rtasida taqqoslash amali mavjud emas\n", "# shuning uchun tartiblash xatolik\n", "# yuzaga chiqarad\n", "a = ['A', 3, 5, 'B']\n", "print(a)\n", "a.sort()\n", "print(a)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "2. `reverse()` metodi ro'yxatning elementlarini teskari tartibda joylashtiradi." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['A', 'B', 'D', 'F']\n", "['F', 'D', 'B', 'A']\n" ] } ], "source": [ "a = ['A', 'B', 'D', 'F']\n", "# boshlang'ich tartib\n", "print(a)\n", "# teskari tartib\n", "a.reverse()\n", "print(a)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "3. `index()` metodi ro'yxatdagi elementlar ichidan berilgan songa teng bo'lgan birinchi elementning o'rnini (indeksni qaytaradi.)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "2\n", "0\n" ] } ], "source": [ "a = [3, 4, 2, 6, 2, 3, 2]\n", "# 2 ning indexsi \n", "n_2 = a.index(2)\n", "# chop qilish\n", "print(n_2)\n", "\n", "# 3 ning indeksi\n", "n_3 = a.index(3)\n", "# chop qilish\n", "print(n_3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "4. `count()` metodi orqali biz ro'yxatdagi elementlarning qiymati biror berilgan songa teng bo'lganlarining nechta ekanligini aniqlashimiz mumkin." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3\n", "2\n" ] } ], "source": [ "a = [3, 4, 2, 6, 2, 3, 2]\n", "# 2 lar soni \n", "n_2 = a.count(2)\n", "# chop qilish\n", "print(n_2)\n", "\n", "# 3 lar soni \n", "n_3 = a.count(3)\n", "# chop qilish\n", "print(n_3)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Namunalar\n", "\n", "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." ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[4, 3, 5] [5, 4, 4] a+b= [9, 7, 9]\n", "[4, 3, 5] [5, 4, 4] a-b= [-1, -1, 1]\n" ] } ], "source": [ "# foydalanuvchidan vektor \n", "# o'lchamini kiritishini so'raylik\n", "n = int(input(\"Vektor o'lchamini: \"))\n", "# ikkita bo'sh vektorlar e'lon qilamiz\n", "a = []\n", "b = []\n", "# kiritishlarni sanash uchun\n", "i = 0\n", "while i < n:\n", " # a uchun yangi element kiritishni so'raymiz\n", " a_elem = int(input(\"a: \"))\n", " # b uchun yangi element kiritishni so'raymiz\n", " b_elem = int(input(\"b: \"))\n", " # kiritilgan elementlarni\n", " # most listlarga qo'shamiz\n", " a.append(a_elem)\n", " b.append(b_elem)\n", " # sanagichni oshiramiz\n", " i = i + 1\n", "# ikkinchi qism\n", "# amallarni bajarish\n", "# qo'shish va ayirish\n", "# uchun ikkita bo'sh list\n", "c = []\n", "d = []\n", "# sanash qiymatni yana 0 ga\n", "# qaytaramiz\n", "i = 0\n", "while i < n:\n", " # qo'shish amali natijasini \n", " # c list qo'shamiz\n", " c.append(a[i] + b[i])\n", " # ayirish natijasni esa\n", " # d list qo'shamiz\n", " d.append(a[i] - b[i])\n", " # sanagichni oshiramiz\n", " i = i + 1\n", "\n", "# natijalarni chop qilamiz\n", "print(a, b, 'a+b=', c)\n", "print(a, b, 'a-b=', d)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Matritsalarni Pythonda saqlash\n", "\n", "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.\n", "\n", "Keling buning uchun quyidagi jadvalda keltirilgan inson haqidagi ma'lumotlarni saqlashni amalga oshiraylik.\n", "\n", "| Familiyasi | Ismi | Yoshi | Bo'yi | Vazni |\n", "| :--- | :----: | ---: | ---: | ---: |\n", "| Samandarov | Baxtiryor | 22 | 159 | 63 |\n", "| Axmadov | Doston | 19 | 180 | 85 |\n", "| Qarshiyev | Baxrom | 20 | 190 | 100 |\n", "| Davronov | Akmal | 25 | 175 | 80 |\n", "\n", "Aval soddalik uchun yuqoridagi jadvalda berilgan 4 ta insoni alohida `list` turidagi o'zgaruvchilarga saqlab olaylik." ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [], "source": [ "# 1-inson (human ingliz tilida)\n", "human1 = ['Samandarov', 'Baxtiyor', 22, 159, 63]\n", "# 2-inson\n", "human2 = ['Axmadov', 'Doston', 19, 180, 85]\n", "# 3-inson\n", "human3 = ['Qarshiyev', 'Baxrom', 20, 190, 100]\n", "# 4-inson\n", "human4 = ['Davronov', 'Akmal', 25, 175, 80]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Yuqoridagi kodning davomi sifatida quyida, keling ularni bitta asosiy listga birlashtiraylik. Qisqalik uchun yuqoridagi kodni qayta yozmaymiz." ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[['Samandarov', 'Baxtiyor', 22, 159, 63], ['Axmadov', 'Doston', 19, 180, 85], ['Qarshiyev', 'Baxrom', 20, 190, 100], ['Davronov', 'Akmal', 25, 175, 80]]\n" ] } ], "source": [ "# hamma insonlarni saqlovchi\n", "# list turida o'zgaruvchi\n", "# boshida bo'sh\n", "humans = []\n", "# bo'sh listga ketma-ket\n", "# insonlarni qo'shamiz\n", "humans.append(human1)\n", "humans.append(human2)\n", "humans.append(human3)\n", "humans.append(human4)\n", "# va natijani xom ko'rinishda\n", "# chop qilamiz\n", "print(humans)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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." ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['Axmadov', 'Doston', 19, 180, 85]\n", "Ikkinchi insonning yoshi: 19\n" ] } ], "source": [ "# agar shu insoni to'liq chop qilsak\n", "# unda uning turi list\n", "print(humans[1])\n", "# listga ikki marta indeks qo'llasak\n", "print('Ikkinchi insonning yoshi: ', humans[1][2])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Ushbu ko'rsatilgan misoldan quyidagi umumiy xulosaning olsak bo'ladi: agar `list`ning 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:\n", "\n", "1. jadvaldagi ma'lumotlar soni o'zgaruvchan;\n", "2. Undagi har bir qiymatni foydalanuvchi kiritadi;\n", "3. hamda kiritilgan ma'lumotlar kiritilgan tartibda chop e'tiladi. " ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1 -odam ma'lumotlarini kiriting: \n", "2 -odam ma'lumotlarini kiriting: \n", "3 -odam ma'lumotlarini kiriting: \n", "Familiya | Ism | Yosh | Bo'y | Vazn\n", "Davronova | Shahzoda | 23 | 156 | 56\n", "Otabekov | Mansur | 32 | 187 | 98\n", "Qodirov | Yodgor | 22 | 167 | 76\n" ] } ], "source": [ "# ma'lumotlar sonini\n", "n = int(input(\"Nechta ma'lumotlar soni: \"))\n", "# bo'sh list\n", "humans = []\n", "# sanash uchun o'zgaruvchi\n", "i = 0\n", "# takrorlash sharti\n", "while i < n:\n", " # sanagichni oshirish\n", " i = i + 1\n", " # i- odam ma'lotlarini kiritish\n", " print(i, \"-odam ma'lumotlarini kiriting: \")\n", " # familiyasi\n", " last_name = input('Familiya:')\n", " # ismi\n", " first_name = input('Ismi: ')\n", " # yoshi\n", " age = int(input('Yoshi: '))\n", " # bo'yi\n", " height = int(input(\"Bo'yi: \"))\n", " # vazni\n", " weight = int(input(\"Vazni: \"))\n", " # i-odamni to'liq bitta o'zgaruvchi \n", " # sifatida ifodalovchi list\n", " human = [last_name, first_name, age, height, weight]\n", " # umumiy listga qo'shish\n", " humans.append(human)\n", "\n", "# chop qilish\n", "i = 0\n", "# sarlavha chop qilish\n", "print(\"Familiya | Ism | Yosh | Bo'y | Vazn\")\n", "while i < n:\n", " print(humans[i][0], \" | \", humans[i][1], \n", " \" | \", humans[i][2], \n", " \" | \", humans[i][3], \n", " \" | \", humans[i][4])\n", " i = i + 1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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.\n", "\n", "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." ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Familiya | Ism | Yosh | Bo'y | Vazn\n", "Otabekov | Mansur | 32 | 187 | 98\n", "Qodirov | Yodgor | 22 | 167 | 76\n" ] }, { "ename": "IndexError", "evalue": "list index out of range", "output_type": "error", "traceback": [ "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", "\u001b[0;31mIndexError\u001b[0m Traceback (most recent call last)", "Cell \u001b[0;32mIn[23], line 6\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m i \u001b[38;5;241m<\u001b[39m n:\n\u001b[1;32m 5\u001b[0m i \u001b[38;5;241m=\u001b[39mi \u001b[38;5;241m+\u001b[39m \u001b[38;5;241m1\u001b[39m\n\u001b[0;32m----> 6\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mhumans\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m[\u001b[38;5;241m0\u001b[39m], \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m | \u001b[39m\u001b[38;5;124m\"\u001b[39m, humans[i][\u001b[38;5;241m1\u001b[39m], \n\u001b[1;32m 7\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m | \u001b[39m\u001b[38;5;124m\"\u001b[39m, humans[i][\u001b[38;5;241m2\u001b[39m], \n\u001b[1;32m 8\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m | \u001b[39m\u001b[38;5;124m\"\u001b[39m, humans[i][\u001b[38;5;241m3\u001b[39m], \n\u001b[1;32m 9\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m | \u001b[39m\u001b[38;5;124m\"\u001b[39m, humans[i][\u001b[38;5;241m4\u001b[39m])\n", "\u001b[0;31mIndexError\u001b[0m: list index out of range" ] } ], "source": [ "# birinchi qism bor deb tassavur qilaylik\n", "i = 0\n", "print(\"Familiya | Ism | Yosh | Bo'y | Vazn\")\n", "while i < n:\n", " i =i + 1\n", " print(humans[i][0], \" | \", humans[i][1], \n", " \" | \", humans[i][2], \n", " \" | \", humans[i][3], \n", " \" | \", humans[i][4])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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." ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Familiya | Ism | Yosh | Bo'y | Vazn\n", "Davronova | Shahzoda | 23 | 156 | 56\n", "Otabekov | Mansur | 32 | 187 | 98\n", "Qodirov | Yodgor | 22 | 167 | 76\n" ] } ], "source": [ "# birinchi qism bor deb tassavur qilaylik\n", "i = 0\n", "print(\"Familiya | Ism | Yosh | Bo'y | Vazn\")\n", "while i < n:\n", " i =i + 1\n", " print(humans[i-1][0], \" | \", humans[i-1][1], \n", " \" | \", humans[i-1][2], \n", " \" | \", humans[i-1][3], \n", " \" | \", humans[i-1][4])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "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." ] } ], "metadata": { "kernelspec": { "display_name": "ai_courses", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.12.0" } }, "nbformat": 4, "nbformat_minor": 2 }