{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# O'zgaruvchilar\n",
    "\n",
    "## O'zgaruvchi nima?\n",
    "\n",
    "Agar xotiraga biror qiymatni joylashtirmoqchi bo'lsak, u holda bizga kerakli bo'lgan qismga murojaat qiluvchi nom kerak bo'ladi va bu nomni biz o'zgaruvchi deb ataymiz. Bu o'zgaruvchi mashinaning operativ xotirasi (**RAM: Random Access Memory**)dan joy egallaydi va biz shu o'zgaruvchiga yangi qiymat yuklashimiz bilan eski qiymatni o'chiradi va yangisini ikkilik (ikkilika o'tkazish jarayoni haqida biz umuman bosh qotirmaymiz) ko'rinishga o'tkazib yozadi va bizda boshqa eski qiymatni olishga imkon bo'lmaydi. Pythonda tilida o'zgaruvchi e'loni qilish uning nomini yozish va unga ```=``` belgisidan keyin qiymat berish orqali amalga oshirialdi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python tilida o'zlashtirish amali sifatida tenglik amalidan foydalanamiz, yuqoridagi kod `a` nomli o'zgaruvchi e'lon qildi va unga 4 qiymatni o'zlashtirdi, ya'ni `a`ning qiymati 4 ga teng. Biz o'zgaruvchilarda qanday qiymat saqlanganligini doimiy bilishimiz zarur bo'ladi. Buning uchun eng sodda holatda `print()` funksiyasidan foydalanamiz hamda bu jarayoni chop qilish deb ataymiz. Hamda, biz ba'zi kodning qatorlarni o'zmiz uchun eslatma sifatida yozish uchun va bu eslatmani mashina buyruq sifatida qaramasligi uchun `#` belgisidan foydalanamiz, keyinchalik buni izoh deb ataymiz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "# Bu izoh qatori: bu qatorni mashini buyruq sifatida qabul qilmaydi.\n",
    "# Ushbu kod ishlashi natijasida hech narsa ro'y bermaydi\n",
    "# o'zgaruvchi e'loni va unga 4 qiymat yozildi\n",
    "a = 4\n",
    "# a o'zgaruvchining qiymatni ko'rish uchun print funksiyasidan foydalanish\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "300\n"
     ]
    }
   ],
   "source": [
    "money_of_ali = 100\n",
    "money_of_friend = 200\n",
    "all_money = money_of_ali + money_of_friend\n",
    "print(all_money)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "214748364832793233387329439847\n"
     ]
    }
   ],
   "source": [
    "a = 214748364832793233387329439847\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python tilida bir qator tayyor funksiyalar mavjud va ulardan foydalanish uchun ularning yo'riqnomasini o'qib chiqish zarur bo'ladi. Lekin umumiy bir holat biz funksiya nomidan keyin qavs ichiga unga zarur bo'lgan qiymatlarni berishimiz kerak. Bu qiymatlar o'zgarmaslar ko'rinishida ham bo'lishi mumkin. Misollar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4 14 20\n"
     ]
    }
   ],
   "source": [
    "# o'zgaruvchi e'loni va unga 4 qiymat yozildi\n",
    "a = 4\n",
    "# ushbu funksiya bittadan oshiq qiymatlarni qabul qiladi. Natija: 4 14 20\n",
    "# quyida 14 va 20 sonlari o'zgarmas sonlardir\n",
    "print(a, 14, 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yuqorida butun turdagi o'zgaruvchilar bilan ishladik, bundan tashqari bir qator turlar mavjud:\n",
    "\n",
    "1. `int` - butun\n",
    "2. `float` - haqiqiy\n",
    "3. `str` - matn\n",
    "\n",
    "Matni saqlovchi o'zgaruvchilarni e'lon qilishda, o'zgaruvchiga zarur matn `'` yoki `\"` ichida beriladi. Misollar:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'str'>\n",
      "Abdusamatov Doniyor 14 78.5\n"
     ]
    }
   ],
   "source": [
    "# Yoshi 14\n",
    "age = 14\n",
    "# Familiyasi. Matni ikkita \" (qo'shtirnoq) ichiga yozdik\n",
    "fam = \"Abdusamatov\"\n",
    "print(type(fam))\n",
    "# Ismi. Matni ikkita ' (tirnoq) ichiga yozdik\n",
    "# Diqqat ikkisining ham umuman bir-birdan farqi yo'q.\n",
    "ism = 'Doniyor'\n",
    "print(type(ism))\n",
    "# Og'irligi kgda\n",
    "# sonning butun va haqiqiy qismini ajratish uchun . (nuqta)dan foydalanamiz\n",
    "vazn = 78.5\n",
    "# chop etish\n",
    "print(fam, ism, age, vazn)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yuqoridagi kodga e'tibor bersak, biz umuman o'zgaruvchi turini aytmadik, lekin Python o'zi bu narsani berilgan qiymatga qarab aniqlab oladi. Shuning uchun ham ushbu dinamik turga ega dasturlash tilidir. Bundan tashqari, bitta o'zgaruvchiga dastur ishlash davomida bir nechta har xil qiymat bersa ham oxirgisni olib, qolganlarini unutgan holda ishlayveradi. O'zgaruvchi turini bilmoqchi bo'lsak, biz ```type``` funksiyasidan foydalanamiz. Misollar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# a o'zgaruvchisi e'loni va unga 4 qiymat berildi\n",
    "a = 4\n",
    "# a o'zgaruvchisining turi\n",
    "type(a) # natija int"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Endi shu o'zgaruvchiga boshqa turli xil qiymatlar berib ko'raylik"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Birinchi a turi int\n",
    "a = 4\n",
    "# Endi uning turi float\n",
    "a = 3.14\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Birinchi a turi float\n",
    "a = 3.14\n",
    "# Endi uning turi str\n",
    "a = 'salom'\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bu yerda o'rganish kerak bo'lgan eng zarur narsa, biz o'zgaruvchiga har safar yangi qiymat berganimizda u qaytadan aniqlanadi, ya'ni e'lon qilinadi. Buni ko'rish uchun quyidagi dastur kodida biz `id()` funksiyasidan foydalanib bitta nomli o'zgaruvchiga har safar xar qil qiymat berganda uning xotiradagi yagona aniqlangan **ID**sini chop etamiz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "130350407015920\n",
      "130350378921984\n"
     ]
    }
   ],
   "source": [
    "# Birinchi a turi float\n",
    "a = 3.14\n",
    "print(id(a))\n",
    "# Endi uning turi str\n",
    "a = 'salom'\n",
    "print(id(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yuqorida 3 ta o'zgaruvchi turini e'lon qilishni va ular bilan ishlashni o'rgandik. Lekin ko'pchilik boshlovchilar adashadigan bir holat bor. Masalan quyidagi kodga va uning natijasiga e'tibor beraylik."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "age\n"
     ]
    }
   ],
   "source": [
    "# age o'zgaruvchisiga 25 raqami yozildi\n",
    "age = 25\n",
    "# age matni chop qilinyapti, bu age o'zgaruvchisi emas!!!\n",
    "# Natija: age\n",
    "print('age')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yuqoridagi kodda biz age nomli o'zgaruvchi e'lon qildik va unga 25 qiymatni o'zlashtirdik. Lekin 5-qataorda biz `age` degan matn turidagi qiymatni chop qildik, `age` o'zgaruvchisi emas. Quyida esga ikki holni ham qayta ko'ramiz."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n",
      "age\n"
     ]
    }
   ],
   "source": [
    "# age ga 25 raqami yozildi\n",
    "age = 25\n",
    "# age o'zgaruvchising qiymati chop qilinyapti\n",
    "print(age)\n",
    "# age matni chop qilinyapti\n",
    "print('age')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "del boy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'boy' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[40], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mboy\u001b[49m)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'boy' is not defined"
     ]
    }
   ],
   "source": [
    "print(boy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## O'zgaruvchi nomlarni aniqlashga cheklovlar va tavsiyalar\n",
    "\n",
    "Biz xotiraning bir qismini band qilish va shu qismga o'zimizga kerak bo'ladigan qiymatni yozib qo'yishimiz uchun **o'zgaruvchi** tushunchasi bilan tanishdik. Lekin biz ma'lum bir qattiy qoidalarga ega bo'lgan dasturlash tili bilan ishlar ekanmiz, bizda o'zgaruvchilarni e'lon qilishda albatta cheklovlarga egamiz. Quyida ushbu qoidalarning ba'zilari:\n",
    "\n",
    "1. o'zgaruvchi har doim katta-kichik (masalan, katta harf deb `A`, kichik deb esa `a`) harflar va tag chiziq `_` bilan boshlanadi;\n",
    "2. o'zgaruvchining qolgan belgilari katta-kichik harflar, raqamlar (0, 1, 2, ..., 9) va tag chiziq `_` belgisi bo'lishi mumkin.\n",
    "3. har doim katta va kichik harflardan ikki xil o'zgaruvchi paydo bo'ladi. Masalan, `age`, `Age`, `AGE` lar hammasi alohida o'zgaruvchilar, hattoki ma'nosi bir bo'lsa ham.\n",
    "\n",
    "Quyida birinchi mumkin bo'lgan o'zgaruvchilarga misollarni ko'ramiz, keyin esa uning teskarisiga."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25 22 Abdurahmonov\n"
     ]
    }
   ],
   "source": [
    "# Mumkin bo'lgan o'zgaruvchilar\n",
    "# bolaning yoshi\n",
    "boy_age = 25\n",
    "# o'rtacha yosh\n",
    "mean_age = 22\n",
    "# Uning familiyasi\n",
    "his_familiy = 'Abdurahmonov'\n",
    "print(boy_age, mean_age, his_familiy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9803048 9803368 9803336\n"
     ]
    }
   ],
   "source": [
    "# Katta-kichik harflaridan farq\n",
    "# qiluvchi o'zgaruvchilar\n",
    "# age o'zgaruvchisi\n",
    "age = 15\n",
    "# Bu o'zgaruvchi bilan age o'zgaruvchisi\n",
    "# ikkita alohida o'zgaruvchi\n",
    "Age = 25\n",
    "AGe = 34\n",
    "AGE = 45\n",
    "aGE = 54\n",
    "AGe = 24\n",
    "print(id(age), id(Age), id(AGe))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'AgE' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[44], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mAgE\u001b[49m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'AgE' is not defined"
     ]
    }
   ],
   "source": [
    "AgE"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid decimal literal (3459887114.py, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Cell \u001b[0;32mIn[45], line 2\u001b[0;36m\u001b[0m\n\u001b[0;31m    1boy_age = 25\u001b[0m\n\u001b[0m    ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid decimal literal\n"
     ]
    }
   ],
   "source": [
    "# Taqiqlangan o'zgaruvchilar\n",
    "1boy_age = 25\n",
    "mean age = 22\n",
    "his familiy = 'Abdurahmonov'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Agar oxirgi kod qismini ishga tushursak biz yuqoridagi kabi xatolikni ko'rishimiz aniq. Har doim dastur bajarilishidan oldin, birinchi kiritilgan kod manti sintaktik tahlildan o'zkaziladi. Agar matnda hech qanday sintaktik xato mavjud bo'lmasa, keyingi bajarilish qismlariga o'tkaziladi.\n",
    "\n",
    "> **Tavsiyalar**. Dastur oson o'qilishi va tushunarli bo'lishi uchun biz har doim o'zgaruvchilarga ularning saqlashi mumkin bo'lgan qiymatiga qarab nom berishimiz zarur. Masalan yuqorida, `age` o'zgaruvchisiga doimiy inson (yoki boshqa narsaning) yoshini saqlashimiz maqsadga muvofiq bo'ladi. Agar buning uchun bir nechta so'z zarur bo'lsa, unda tag `_` chiziq bilan yoki har bir so'zning bosh harifini katta harflar orqali ifodalash bilan erishishimiz mumkin. Masalan, `mean_age` - o'rtacha yosh. Yana bir boshqa tavsiya esa, albatta ingliz tilidagi so'zlardan foydalanishdir. Oxirgisi esa agar o'zgaruvchi nomi haddan tashqari uzun bo'lib, qayta yozishga halaqit qilsa unda uni qisqartirib yozish mumkin. Misol uchun, `familiy_name` o'rniga `fam_name` yoki `number_of_objects` o'rniga esa `n_objs`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ".. _sebsec-variables\n",
    "## `int` va `float` o'zgaruvchi turlarida qiymatlarni ifodalash shakllari\n",
    "\n",
    "Dasturlash tillarida ikki xil o'zgaruvchi turlari bo'ladi: \n",
    "1. tilning o'zida mavjud bo'lgan va eng ko'p qo'llaniladigan; \n",
    "2. foydalanuvchi tomonidan aniqlangan turlar.\n",
    "\n",
    "Biz hozir 3 ta o'zgaruvchi turini qisman o'gandik. Shulardan ikkitasini hozir ba'zi qismlarni batafsil o'rganamiz. \n",
    "\n",
    "1. `int` turi bilan ishlashda biz har xil sanoq sistemalaridan foydalanishimiz mumkin bo'ladi. Ikkilik sanoq sistemasida butun son kiritish qilish uchun `0b` (nol va b harfi)ni son oldiga qo'shib yozamiz. Hamda boshqa sanoq sistemalari uchun `b` harfining o'rniga, 8 lik uchun `o`, 16 lik uchun esa `x`. Quyida misollar."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "23\n",
      "23\n",
      "23\n"
     ]
    }
   ],
   "source": [
    "# 23 soni ikkilikda\n",
    "age = 0b10111\n",
    "print(age)\n",
    "# 23 soni sakizlikda\n",
    "age = 0o27\n",
    "print(age)\n",
    "# 23 soni 16 likda\n",
    "age = 0x17\n",
    "print(age)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. `float` turida ham `int` kabi bir qator yo'llar bilan haqiqiy sonlarni tasvirlash mumkin, lekin unda biz sanoq sistemalaridan foydalanish o'rnida soni exponenta ko'rnishida tasvirlaymiz. Masalan, $453.33=4.5333 \\cdot 10^2=0.45333 \\cdot 10^3=4533.3 \\cdot 10^{-1}=45333 \\cdot 10^{-2}$. Ya'ni bitta soni 10 darajalariga ko'raytirish orqali bir ko'plab ko'rinishlarda yozishimiz mumkin. Buni dasturlash tilida soddaroq ko'rnishda ifodalash uchun biz `e` exponenta belgisdan foydalanamiz va 10 soni yozmaymiz. Yuqoridagi misol quyidagicha bo'ladi. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "453.33\n",
      "453.33\n",
      "453.33\n",
      "453.33\n",
      "453.33\n"
     ]
    }
   ],
   "source": [
    "a = 453.33\n",
    "print(a)\n",
    "a = 4.5333e2\n",
    "print(a)\n",
    "a = 0.45333e3\n",
    "print(a)\n",
    "a = 4533.3e-1\n",
    "print(a)\n",
    "a = 45333e-2\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Demak yuqoridagi hamma qiymat bir xil ekan. Faqat 10 ning musbat darajasini yozishda `e` harfidan keyin hech qanday narsa yozmaymiz (yozsa ham to'g'iri), manifiy uchun esa `-` belgisini qo'yish yetarli."
   ]
  }
 ],
 "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
}