{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `for` takrorlash operatori\n",
    "## Operatorning sintaksisi\n",
    "\n",
    "Ushbu takrorlash operatori ham `while` operatori kabi amallar uchun ishlatiladi. Faqat, asosiy farqi ularning ishlash tamoyilida. Biz `while` takrorlash operatoriga biror shartni bog‘lab shu shart bajarilguncha ushbu operatorning tanasidagi kod qayta-qayta bajarilishini ko‘rdik. Qachonki, ushbu shart bajarilmasa, `while` operatorining ishlashi tugatilib, undan keyingi qatordagi dastur matnlari ishga tushiriladi. `while` operatorida biz asosan biror shartni tekshirgan bo‘lsak, ushbu operatorda esa biror takrorlanadigan(masalan, `list` yoki `tuple` turi) obyektdan elementlarni birma-bir ko‘rib chiqish asosida takrorlash jarayoni hosil qilinadi. Quyida, faraz qilamiz, mevalardan iborat `fruits` `list` obyekti berilgan bo‘lsin, uning elementlarini bitalab chop qiluvchi dastur matni keltirilgan:\n",
    "\n",
    "> **Eslatma**. Ingliz tilidagi *Iterable* so‘zini biz O‘zbek tilida *takrorlanadigan* deb tarjima qildik."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "olma\n",
      "banan\n",
      "behi\n"
     ]
    }
   ],
   "source": [
    "# uchta elementdan iborat ro‘yxat\n",
    "fruits = [\"olma\", \"banan\", \"behi\"]\n",
    "# for opertatori va shu ro‘yxatdagi\n",
    "# elementlarni ko‘rib chiquvchi\n",
    "# x o‘zgaruvchisi va in kalit so‘zi\n",
    "# hamda ro‘yxat va nuqta\n",
    "for x in fruits:\n",
    "  # bu takrorlash operatorining\n",
    "  print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ushbu dastur matnida biz birinchi `fruits` o‘zgaruvchisini e'lon qildik. Undan so‘ng esa `for` kalit so‘zi, biror ixtiyoriy o‘zgaruvchi (hozirgi holda `x`), `fruits` obyekti hamda har doimgidek ikki nuqta va oxirida esa ushbu operatorning asosiy tansi `print(x)` keltirilgan. Ushbu matni, sodda qilibm quyidagicha o‘qish mumkin: `x` o‘zgaruvchisi `fruits` ro‘yxatining elementlarini birma-bir oladi: 1-holda `x = \"olma\"`, 2-holda `x = \"bana\"`, 3-holda esa `x = \"behi\"`, hamda ularni chop etadi. Quyida yana shunga o‘xshash sodda namuna keltirilgan: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0,1,2,3,4,5,6,7,8,9,"
     ]
    }
   ],
   "source": [
    "nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "for num in nums:\n",
    "  print(num, end=',')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ushbu hol ham oldingisi bilan deyarli bir xil, ya'ni `nums` ro‘yxatida raqamlarni saqladik hamda ularni birma-bir `num` o‘zgaruvchisiga olish orqali qiymatlarni chop qildik. E'tirbor bering `nums` bu ro‘yxat, `num` esa o‘zgaruvchi(ikki o‘zgaruvchining nomlari faqat `s` harfi bilan farqlanadi). Shuning uchun quyidagi dastur matni natijasi ham yuqoridagi bilan bir xil hisoblanadi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0,1,2,3,4,5,6,7,8,9,"
     ]
    }
   ],
   "source": [
    "raqamlar = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
    "for raqam in raqamlar:\n",
    "  print(raqam, end=',')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Natija bir xil bo‘lishi nuqtai nazaridan, ushbu o‘zgaruvchilarni qanday nomlash umuman ahamiyatga ega emas. Ammo, imkon qadar o‘zgaruvchi nomlari dasturdagi bajaryotgan vazifasiga mutanosib bo‘lishi qat'iy tavsiya etiladi. Oxirgi ikki dastur matni bir xil natija hosil qiladi, faqat o‘zgaruvchi nomlarini Ingliz va O‘zbek tilida yozdik. Tajribamizdan kelib chiqib, siz o‘quvchilarga o‘zgaruvchi nomlarini Ingliz tilida nomlashni hamda iloji bo‘lsa, imkon qadar qisqartirib belgilashni maslahat beramiz."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Takrorlanadigan o‘zgaruvchi turlari\n",
    "\n",
    "Python dasturlash tilida bir qancha ichki takrorlanadigan turlar mavjud bo‘lib, ularni turli maqsadlarda ishlatganimiz uchun ham `for` operatori bilan ushbu turlarni ishlatganimizda har xil holatlar mavjud bo‘lishi mumkin. Shu sababdan ulardan bir qanchalarini ko‘rib chiqamiz.\n",
    "\n",
    "1. `str`(satr) turi o‘zgaruvchisining har bir elementi, ya'ni belgisi `for` uchun bitta takrorlash amalini bajarishga xizmat qiladi. Quyidagi misolda, "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "S\n",
      "a\n",
      "l\n",
      "o\n",
      "m\n",
      ",\n",
      " \n",
      "O\n",
      "l\n",
      "a\n",
      "m\n"
     ]
    }
   ],
   "source": [
    "matn = \"Salom, Olam\"\n",
    "for belgi in matn:\n",
    "    print(belgi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E'tibor bering, biz har safar takrorlanadigan o‘zgaruvchilarning elementlarini chop qilyabmiz. Ammo, haqiqiy dastur yozganimizda, biz boshqa amallarni ham bajarishimiz mumkin. Masalan, quyidagi dastur matni berilgan satrdagi harflar va raqamlar sonini topadi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Harflar soni: 11\n",
      "Raqamlar soni: 9\n"
     ]
    }
   ],
   "source": [
    "satr = \"2jsdk39sie3ujis40540\"\n",
    "num_letters = 0\n",
    "num_digits = 0\n",
    "for belgi in satr:\n",
    "    if belgi.isalpha():\n",
    "        num_letters += 1\n",
    "    elif belgi.isdigit():\n",
    "        num_digits += 1\n",
    "print(\"Harflar soni:\", num_letters)\n",
    "print(\"Raqamlar soni:\", num_digits)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yuqordagi kodda biz ikkita `.isalpha()` va `.isdigit()` metodlarini ishlatdik. Ushbu metodlar obyektlarga tegishli bo‘lgani uchun, aslida funksiya bo‘lsada, metod deb nomlandi. Chunki biz ularni biror obyekt nomidan keyin nuqta orqali chaqirishimiz mumkin. Bu kabi metodlarni keyinchalik obyektga yo‘naltirilgan dasturlash bo‘lmida o‘rganib chiqamiz."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. `tuple` turi bilan `list` turi o‘rtasida deyarli farqlanish yo‘q shuning uchun bu turga misol keltirmaymiz.\n",
    "\n",
    "Bundan tashqari biz hali o‘rganib chiqmagan bir qancha turlar mavjud, shuning uchun ham biz ushbu qismda boshqa turlarga to‘xtalmaymiz."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Takrorlash hosil qiluvchi funksiyalar\n",
    "\n",
    "Takrorlanadigan turlardan tashqari, bir nechta Python funksiyalari mavjud bo‘lib, ular bizga takrorlanadigan obyektlarni hosil qilib berish uchun xizmat qiladi.\n",
    "\n",
    "1. `range(start, stop, step)` funksiyasi `list` turidagi kesish amaliga o‘xshash tarizda uchta agument qabul qilib, takrorlanadigan obyekt qaytaradi. Uning argumentlari quyidagicha o‘zini tutadi: `start` va `stop` argumentining kelishuv bo‘yicha qiymati `0` va `1` ga teng. Agar bitta argumentga qiymat berilsa, u holda bu argument `stop` bo‘ladi. Hamda `stop` qiymati element sifatida qaytarilmaydi. Quyida ba'zi namunalar keltirilgan:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# start=0, stop=5, step=1\n",
    "for i in range(5): # range(0, 5, 1)\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# start=2, stop=5, step=1\n",
    "for i in range(2, 5): # range(0, 5, 1)\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# start=0, stop=5, step=2\n",
    "for i in range(2, 5, 2): # range(0, 5, 1)\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. `enumerate(iterable, start=0)` funksiyasi takrorlanadigan turdagi obyektni qabul qilib, ushbu obyektning elementiga qo‘shib uning o‘rnini ham qaytaradi. Agar `start=0` argumentiga biror qiymat bersak, u holda elementlarni sanashni shu sondan boshlaydi. Quyida namunalar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a harf o'rni: 0\n",
      "b harf o'rni: 1\n",
      "c harf o'rni: 2\n",
      "d harf o'rni: 3\n",
      "e harf o'rni: 4\n"
     ]
    }
   ],
   "source": [
    "# masalan, list obyekti\n",
    "letters = ['a', 'b', 'c', 'd', 'e']\n",
    "for i, letter in enumerate(letters):\n",
    "    print(letter, \"harf o'rni:\", i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a harf o'rni: 2\n",
      "b harf o'rni: 3\n",
      "c harf o'rni: 4\n",
      "d harf o'rni: 5\n",
      "e harf o'rni: 6\n"
     ]
    }
   ],
   "source": [
    "# masalan, list obyekti\n",
    "letters = ['a', 'b', 'c', 'd', 'e']\n",
    "for i, letter in enumerate(letters, 2):\n",
    "    print(letter, \"harf o'rni:\", i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. `zip()` funksiyasi bittadan ortiq takrorlanadigan obyektlarni mos elementlarini bitta `tuple` obyekti sifatida jamlab, takrorlash hosil qiladi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 nol\n",
      "1 bir\n",
      "2 ikki\n",
      "3 uch\n",
      "4 to'rt\n",
      "5 besh\n"
     ]
    }
   ],
   "source": [
    "digit_nums = [0, 1, 2, 3, 4, 5]\n",
    "letter_nums = ['nol', 'bir', 'ikki', 'uch', \"to'rt\", 'besh']\n",
    "for digit, letter in zip(digit_nums, letter_nums):\n",
    "    print(digit, letter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Aloqador operatorlar\n",
    "\n",
    "### `for-else` operatori\n",
    "\n",
    "Ushbu operator juda sodda hisoblanib, qachon `for` operatori tugasa bir marta bajariladi holos. Masalan, quyidagicha:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "Finally finished!\n"
     ]
    }
   ],
   "source": [
    "for x in range(6):\n",
    "  print(x)\n",
    "else:\n",
    "  print(\"Oxiri tugadi\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E'tibor qilgan bo‘lsangiz, ushbu dastur `0` dan `5` bo‘lgan sonlarni chop qilib, undan so‘ng bir marta `else` operatori tanasidagi qismni bajardi. Xuddi shunday operatorni `while` uchun ham qo‘llash mumkin:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "Oxiri tugadi\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "while x < 6:\n",
    "  print(x)\n",
    "  x += 1\n",
    "else:\n",
    "  print(\"Oxiri tugadi\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `break` operatori\n",
    "\n",
    "Bu operator ixtiyoriy takrorlashni to‘lig‘icha to‘xtatishni ta'minlaydi. Ba'zi hollarda, takrorlash jarayoni tugamasada dasturda takrorlashni majburan tugatish zarurati yuzaga keladi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "olma\n",
      "banan\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"olma\", \"banan\", \"qulupnay\"]\n",
    "for x in fruits:\n",
    "  print(x)\n",
    "  if x == \"banan\":\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "olma\n",
      "banan\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"olma\", \"banan\", \"qulupnay\"]\n",
    "x = 0\n",
    "while x < len(fruits):\n",
    "  print(fruits[x])\n",
    "  if fruits[x] == \"banan\":\n",
    "    break\n",
    "  x += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yuqorida birinchi navbatdagi ro‘yxat elementi qiymat chop qilinib, undan so‘ng shart amali orqali shu qiymat `banan` ga tengligi tekshirilyabdi. Agar teng bo‘lsa, dastur to‘xtatilyabdi va undan so‘ng umuman takrorlanish davom etmaydi. Quyida esa navbatdagi element `break` operatori qo‘llanilishidan so‘ng chop qilinayotgani sababli, natijada faqat `olma` qiymatigina chop qilindi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "olma\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"olma\", \"banan\", \"qulupnay\"]\n",
    "for x in fruits:\n",
    "  if x == \"banan\":\n",
    "    break\n",
    "  print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agar takrorlash `break` operatori ishga tushishi natijasida to‘xtatilsa, u holda uning `else` operatori bajarilmaydi. Quyidagi takrorlashda ham `0` dan  `6` gacha bo‘lgan sonlarni chop qilinyapti, lekin `3` ga kelganda `break` operatori ishga tushib, takrorlashni to‘xtatayabdi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "for x in range(6):\n",
    "  if x == 3: break\n",
    "  print(x)\n",
    "else:\n",
    "  print(\"Oxiri tugadi\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "x = 0\n",
    "while x < 6:\n",
    "  if x == 3: break\n",
    "  print(x)\n",
    "  x += 1\n",
    "else:\n",
    "  print(\"Oxiri tugadi\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `continue` operatori\n",
    "\n",
    "Bu operator bilan `break` operatorining o‘rtasidagi asosiy farq. ushbu operator qo‘llanganda takrorlash tugamasda, balki shu operator qo‘llangan joydan boshlab qolgan hamma takrorlash amalning tanasidagi buyruqlar ishga tushirilmaydi yoki qisqa qilib, keyingisiga o‘tkazib yuboriladi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "olma\n",
      "qulupnay\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"olma\", \"banan\", \"qulupnay\"]\n",
    "for x in fruits:\n",
    "  if x == \"banan\":\n",
    "    continue\n",
    "  print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "olma\n",
      "qulupnay\n"
     ]
    }
   ],
   "source": [
    "fruits = [\"olma\", \"banan\", \"qulupnay\"]\n",
    "x = 0\n",
    "while x < len(fruits):\n",
    "  if fruits[x] == \"banan\":\n",
    "    x += 1\n",
    "    continue\n",
    "  print(fruits[x])\n",
    "  x += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yuqorida aynan navbatdagi element qiymati `banan`ga teng bo‘lganda, undan keyingi ammallar tashlab ketilyabdi hamda natijada ushbu `banan` qiymati chop etilmayabdi."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `pass` operatori\n",
    "\n",
    "Ushbu operator ko‘plab boshqa operatorlar bilan birga kelishi mumkin hamda ularning tanasida hech qanday narsa mavjud emasligiga ishora qiladi. Albatta siz o‘quvchilarda, unda bunday mantiqqa ega bo‘lmagan qismlarni yozish nimaga zarur degan savollar tug‘ilishi turgan gap. Bundan savollarga keyinchalik javob olishingiz mumkin bo‘ladi, hozir esa buni ham bir qulaylik sifatida qabul qilish yetarli."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9\n"
     ]
    }
   ],
   "source": [
    "for x in range(10):\n",
    "  pass\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yuqoridagi dastur matnida biz `for` takrorlash operatorining to‘liq tanasi sifatida `pass` operatorini yozdik, bu operator hech qanday tana mavjud emasligini bildiradi, lekin ushbu holatda ham `x` o‘zgaruvchisi 9 qiymatiga yetib boradi, ya'ni takrorlash bajariladi."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Ichma-ich `for` operatori\n",
    "\n",
    "Ixtiyoriy amallar ichma-ich bo‘lishi mumkin, bunday hollatlar algoritmlarni qanday yozishdan kelib chiqadi. Quyida mevalar va ularning sifatlarini chop etuvchi dastur matni keltirilgan."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "qizil olma\n",
      "qizil banan\n",
      "qizil qulupnay\n",
      "katta olma\n",
      "katta banan\n",
      "katta qulupnay\n",
      "shirin olma\n",
      "shirin banan\n",
      "shirin qulupnay\n"
     ]
    }
   ],
   "source": [
    "adj = [\"sariq\", \"katta\", \"shirin\"]\n",
    "fruits = [\"olma\", \"banan\", \"qulupnay\"]\n",
    "\n",
    "for x in adj:\n",
    "  for y in fruits:\n",
    "    print(x, y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Namunalar\n",
    "\n",
    "Odatda, `while` operatoridan ham `for` operatorini ko‘proq ishlatamiz. Shuning uchun quyida turli holatlar uchun bir nechta namunaviy masalalarni ko‘rib chiqamiz.\n",
    "\n",
    "1. Masala. 1 dan n gacha bo‘lgan sonlarning yig‘indisini toping. **Yechish**. Odatda, agar biror sonlarning yig‘indisini topmoqchi bo‘lsak, unda biz har doim ularni biror umumiy o‘zgaruvchiga yig‘ib borishimizga to‘g‘iri keladi va u o‘zgaruvchining boshlang‘ich qiymati har doim 0 bo‘ladi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Yig‘indi: 45\n"
     ]
    }
   ],
   "source": [
    "s = 0\n",
    "n = 10\n",
    "for i in range(1, n):\n",
    "  s += i\n",
    "print(\"Yig‘indi:\", s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Masala. 1 dan n gacha bo‘lgan toq va juft sonlarning yig‘indisini alohida toping. **Yechish**. Buni masalani yechish uchun `if-else` operatoridan foydalanamiz hamda agar son juft bo‘lsa, u holda shu sonni ikkiga bo‘lganimizda, qoldik nol chiqish kerak. Masalan, juft bo‘lsa `14 % 2 = 0` va toq bo‘lsa `13 % 2 = 1`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Toq yig‘indi: 25\n",
      "Juft yig‘indi: 20\n"
     ]
    }
   ],
   "source": [
    "s_odd = 0\n",
    "s_even = 0\n",
    "n = 10\n",
    "for i in range(1, n):\n",
    "  if i % 2 == 1: s_odd += i\n",
    "  else: s_even += i\n",
    "print(\"Toq yig‘indi:\", s_odd)\n",
    "print(\"Juft yig‘indi:\", s_even)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Masala. Quyidagi jadvalni o‘zida saqlovchi dastur matnini `for` takrorlash operatori bilan hosil qiling. Ushbu masalani oldingi `while` takrorlash operatori mavzusidagi kabi yechamiz.\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 |"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "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",
      "4 -odam ma'lumotlarini kiriting: \n",
      "Familiya   |   Ism   |   Yosh   |   Bo‘y  |   Vazn\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"
     ]
    }
   ],
   "source": [
    "n = 4\n",
    "humans = []\n",
    "for i in range(n):\n",
    "  print(i+1, \"-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",
    "# sarlavha chop qilish\n",
    "print(\"Familiya   |   Ism   |   Yosh   |   Bo‘y  |   Vazn\")\n",
    "for i in range(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"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "ai-intro",
   "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.10.16"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}