{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Funksiyalar\n",
    "\n",
    "Biz shu vaqtgacha bir qancha funksiyalardan foydalanib keldik va ularning hammasi Pythonda mavjud bo'lgan yoki o'zgaruvchi turlarning metodlari edi. Endi biz dasturlarni yozishdan avval o'zimiz ham funksiya e'lon qilishni o'rganamiz, chunki ushbu funksiyalar juda muhim ahamiyatga ega bo'lib, bizga kodlarni qayta qayta yozishdan tejash imkoniyatini beradi. Buning uchun biz `def` kalit so'zidan foydalanamiz quyidagi sinkasis orqali: `def <funksiya nomi>(<parameterlar ro'yxati>): <tanasi>`. Quyida ikkita sondan kattasini bizga qaytaruvchi funksiya berilagi."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# def-kalit so'z\n",
    "# max - funksiya nomi\n",
    "# qavslar ichidagi a va b parameterlar\n",
    "# : belgisi\n",
    "def max(a, b):\n",
    "  # chekinish bilan funksiya bajarishi lozim bo'lgan buyruqlar\n",
    "  # agar a katta bo'lsa, u holda\n",
    "  if a > b:\n",
    "    # return bu kalit so'z\n",
    "    # a ning qiymatini qaytar\n",
    "    return a\n",
    "  # agar a kichik yoki teng bo'lsa\n",
    "  else:\n",
    "    # b ning qiymatini qaytar\n",
    "    return b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Biz yuqorida aytilganidek ikkita soning kattasini topuvchi funksiya yasadik: \n",
    "- bizga ikkita son berilishi kerak shuning uchun paramterda ikkita `a` va `b` o'zgaruvchilari bor;\n",
    "- biz ushbu funksiyadan boshqa joylarda ham foydalanishimiz zarur shuning uchun uning nomi bor, `max`;\n",
    "- `def` kalit so'z, har doim bo'lishi shart;\n",
    "- qavslar ham qoidada mavjud.\n",
    "\n",
    "Funskiyaning tanasini, ya'ni u bajarishi zarur bo'lgan buyruqlar ro'yxatini biz `if` yoki `while` operatoridagi kabi 2 ta bo'sh belgi qo'yib keyin yozamiz, shunda u funkiyasning buyruqlari deb tushuniladi, aks holda xato yuzaga keladi. `return` - ham operator bo'lib, u biror qiymatni funksiyani biz qayerdan chaqirgan bo'lsak shu joyga qaytarib jo'natadi va funksiya shu bilan tugaydi. Quyida qanday qilib yuqoridagi funksiyani chaqirib undan foydalanishga misollar keltirilgan."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kattasi:  89\n"
     ]
    }
   ],
   "source": [
    "a = 89\n",
    "b = 3\n",
    "c = max(a, b)\n",
    "print(\"Kattasi: \", c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Biz funksiya parameterlarida `a` va `b` o'zgaruvchilari deb yozdik, lekin uni chaqirganda biz unga boshqa nomli o'zgaruvchilar bilan ham murojaat qilishimiz mumkin. Quyidagicha:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kattasi:  76\n"
     ]
    }
   ],
   "source": [
    "d = 3\n",
    "r = 76\n",
    "c = max(d, r)\n",
    "print(\"Kattasi: \", c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Eng asosiy narsa bu funksiya parameterlar soni bir xil bo'lishi kerak. Endi biz ushbu funksiyani bemalol qiymatlar bilan ham chaqirishimiz mumkin. Masalan:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Kattasi:  37\n",
      "Kattasi:  93\n",
      "Kattasi:  45\n",
      "Kattasi:  76\n"
     ]
    }
   ],
   "source": [
    "print(\"Kattasi: \", max(4, 37))\n",
    "print(\"Kattasi: \", max(87, 93))\n",
    "print(\"Kattasi: \", max(45, 45))\n",
    "print(\"Kattasi: \", max(76, 3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "E'tibor qilgan bo'lsangiz biz ushbu funksiyaning asosiy qismini yuqorida bir marta yozib qo'yib uni ketma-ket necha marta zarur bo'lsa, shuncha ishlatdik. Bu narsa funksiyalarning keng qo'lanilishiga sabab bo'ladi. Biz ushbu funskiyaga oid qisqa darsimizni shu yerda yakunlaymiz va qolgan qimslarni keyingi Python darslarimizda batafsil yoritamiz. Quyida biz ushbu funksiyalardan foydalanib vektorlar va matritsalar o'rtasidagi amalarni bajarish uchun funksiyalarni yozib chiqamiz va ulardan keyinchalik zarur o'rinlarda qayta-qayta foydalanamiz."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Vektorlar ustida amallar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_vecs(a, b):\n",
    "  assert isinstance(a, list) or isinstance(a, tuple), f\"Birinchi o'zgaruvchining turi list yoki tuple bo'lishi kerak, {type(a)}\"\n",
    "  assert isinstance(b, list) or isinstance(b, tuple), f\"Ikkinchi o'zgaruvchining turi list yoki tuple bo'lishi kerak, {type(b)}\"\n",
    "  assert len(a) == len(b), f\"Ikki o'zgaruvchining turlari teng bo'lishi kerak, {len(a)} != {len(b)}\"\n",
    "  \n",
    "  c = []\n",
    "  i = 0\n",
    "  while i < len(a):\n",
    "    c.append(a[i] + b[i])\n",
    "    i = i + 1\n",
    "  \n",
    "  return c\n",
    "\n",
    "def subtract_vecs(a, b):\n",
    "  assert isinstance(a, list) or isinstance(a, tuple), f\"Birinchi o'zgaruvchining turi list yoki tuple bo'lishi kerak, {type(a)}\"\n",
    "  assert isinstance(b, list) or isinstance(b, tuple), f\"Ikkinchi o'zgaruvchining turi list yoki tuple bo'lishi kerak, {type(b)}\"\n",
    "  assert len(a) == len(b), f\"Ikki o'zgaruvchining turlari teng bo'lishi kerak, {len(a)} != {len(b)}\"\n",
    "  \n",
    "  c = []\n",
    "  i = 0\n",
    "  while i < len(a):\n",
    "    c.append(a[i] - b[i])\n",
    "    i = i + 1\n",
    "  \n",
    "  return c\n",
    "\n",
    "def element_wise_product_vecs(a, b):\n",
    "  assert isinstance(a, list) or isinstance(a, tuple), f\"Birinchi o'zgaruvchining turi list yoki tuple bo'lishi kerak, {type(a)}\"\n",
    "  assert isinstance(b, list) or isinstance(b, tuple), f\"Ikkinchi o'zgaruvchining turi list yoki tuple bo'lishi kerak, {type(b)}\"\n",
    "  assert len(a) == len(b), f\"Ikki o'zgaruvchining turlari teng bo'lishi kerak, {len(a)} != {len(b)}\"\n",
    "  \n",
    "  c = []\n",
    "  i = 0\n",
    "  while i < len(a):\n",
    "    c.append(a[i] * b[i])\n",
    "    i = i + 1\n",
    "  \n",
    "  return c\n",
    "\n",
    "def dot_product_vecs(a, b):\n",
    "  assert isinstance(a, list) or isinstance(a, tuple), f\"Birinchi o'zgaruvchining turi list yoki tuple bo'lishi kerak, {type(a)}\"\n",
    "  assert isinstance(b, list) or isinstance(b, tuple), f\"Ikkinchi o'zgaruvchining turi list yoki tuple bo'lishi kerak, {type(b)}\"\n",
    "  assert len(a) == len(b), f\"Ikki o'zgaruvchining turlari teng bo'lishi kerak, {len(a)} != {len(b)}\"\n",
    "  \n",
    "  s = 0\n",
    "  i = 0\n",
    "  while i < len(a):\n",
    "    s += a[i] * b[i] # s = s + a[i] * b[i]\n",
    "    i = i + 1\n",
    "  \n",
    "  return s\n",
    "\n",
    "def evklid_distance_vecs(a, b):\n",
    "  assert isinstance(a, list) or isinstance(a, tuple), f\"Birinchi o'zgaruvchining turi list yoki tuple bo'lishi kerak, {type(a)}\"\n",
    "  assert isinstance(b, list) or isinstance(b, tuple), f\"Ikkinchi o'zgaruvchining turi list yoki tuple bo'lishi kerak, {type(b)}\"\n",
    "  assert len(a) == len(b), f\"Ikki o'zgaruvchining turlari teng bo'lishi kerak, {len(a)} != {len(b)}\"\n",
    "  \n",
    "  s = 0\n",
    "  i = 0\n",
    "  while i < len(a):\n",
    "    s += (a[i] - b[i]) ** 2\n",
    "    i = i + 1\n",
    "  \n",
    "  return s ** 0.5\n",
    "\n",
    "def manhattan_distance_vecs(a, b):\n",
    "  assert isinstance(a, list) or isinstance(a, tuple), f\"Birinchi o'zgaruvchining turi list yoki tuple bo'lishi kerak, {type(a)}\"\n",
    "  assert isinstance(b, list) or isinstance(b, tuple), f\"Ikkinchi o'zgaruvchining turi list yoki tuple bo'lishi kerak, {type(b)}\"\n",
    "  assert len(a) == len(b), f\"Ikki o'zgaruvchining turlari teng bo'lishi kerak, {len(a)} != {len(b)}\"\n",
    "  \n",
    "  s = 0\n",
    "  i = 0\n",
    "  while i < len(a):\n",
    "    s += abs(a[i] - b[i])\n",
    "    i = i + 1\n",
    "  \n",
    "  return s\n",
    "\n",
    "def product_vec_matrix(a, b):\n",
    "  assert isinstance(a, list) or isinstance(a, tuple), f\"Birinchi o'zgaruvchining turi list yoki tuple bo'lishi kerak, {type(a)}\"\n",
    "  assert isinstance(b, list) or isinstance(b, tuple), f\"Ikkinchi o'zgaruvchining turi list yoki tuple bo'lishi kerak, {type(b)}\"\n",
    "  assert isinstance(b[0], list) or isinstance(b[0], tuple), f\"Ikkinchi o'zgaruvchining elemenlarining turi ham list yoki tuple bo'lishi kerak, {type(b[0])}\"\n",
    "  assert len(a) == len(b), f\"Vektorning uzunligi matritsaning qatorlar soniga teng bo'lishi kerak, {len(a)} != {len(b)}\"\n",
    "\n",
    "  c = []\n",
    "  i = 0\n",
    "  while i < len(b[0]):\n",
    "    temp = []\n",
    "    j = 0\n",
    "    while j < len(b):\n",
    "      temp.append(b[j][i])\n",
    "      j = j + 1\n",
    "    c.append(dot_product_vecs(a, temp))\n",
    "    i = i + 1\n",
    "  return c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "## Matritsalar ustida amallar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_matrices(a, b):\n",
    "  assert isinstance(a, list) or isinstance(a, tuple), f\"Birinchi o'zgaruvchining turi list yoki tuple bo'lishi kerak, {type(a)}\"\n",
    "  assert isinstance(b, list) or isinstance(b, tuple), f\"Ikkinchi o'zgaruvchining turi list yoki tuple bo'lishi kerak, {type(b)}\"\n",
    "  \n",
    "  c = []\n",
    "  i = 0\n",
    "  while i < len(a):\n",
    "    c.append(add_vecs(a[i], b[i]))\n",
    "    i += 1\n",
    "    \n",
    "  return c\n",
    "\n",
    "def subtract_matrices(a, b):\n",
    "  assert isinstance(a, list) or isinstance(a, tuple), f\"Birinchi o'zgaruvchining turi list yoki tuple bo'lishi kerak, {type(a)}\"\n",
    "  assert isinstance(b, list) or isinstance(b, tuple), f\"Ikkinchi o'zgaruvchining turi list yoki tuple bo'lishi kerak, {type(b)}\"\n",
    "  \n",
    "  c = []\n",
    "  i = 0\n",
    "  while i < len(a):\n",
    "    c.append(subtract_vecs(a[i], b[i]))\n",
    "    i += 1\n",
    "    \n",
    "  return c\n",
    "\n",
    "def element_wise_product_matrices(a, b):\n",
    "  assert isinstance(a, list) or isinstance(a, tuple), f\"Birinchi o'zgaruvchining turi list yoki tuple bo'lishi kerak, {type(a)}\"\n",
    "  assert isinstance(b, list) or isinstance(b, tuple), f\"Ikkinchi o'zgaruvchining turi list yoki tuple bo'lishi kerak, {type(b)}\"\n",
    "  \n",
    "  c = []\n",
    "  i = 0\n",
    "  while i < len(a):\n",
    "    c.append(element_wise_product_vecs(a[i], b[i]))\n",
    "    i += 1\n",
    "    \n",
    "  return c\n",
    "\n",
    "def product_matrices(a, b):\n",
    "  assert isinstance(a, list) or isinstance(a, tuple), f\"Birinchi o'zgaruvchining turi list yoki tuple bo'lishi kerak, {type(a)}\"\n",
    "  assert isinstance(b, list) or isinstance(b, tuple), f\"Ikkinchi o'zgaruvchining turi list yoki tuple bo'lishi kerak, {type(b)}\"\n",
    "  \n",
    "  c = []\n",
    "  i = 0\n",
    "  while i < len(a):\n",
    "    j = 0\n",
    "    inner_c = []\n",
    "    while j < len(b[0]):\n",
    "      temp = []\n",
    "      l = 0\n",
    "      while l < len(b):\n",
    "        temp.append(b[l][j])\n",
    "        l += 1\n",
    "      \n",
    "      inner_c.append(dot_product_vecs(a[i], temp))\n",
    "      j += 1\n",
    "    c.append(inner_c)\n",
    "    i += 1\n",
    "    \n",
    "  return c\n",
    "\n",
    "def product_matrix_vector(a, b):\n",
    "  assert isinstance(a, list) or isinstance(a, tuple), f\"Birinchi o'zgaruvchining turi list yoki tuple bo'lishi kerak, {type(a)}\"\n",
    "  assert isinstance(b, list) or isinstance(b, tuple), f\"Ikkinchi o'zgaruvchining turi list yoki tuple bo'lishi kerak, {type(b)}\"\n",
    "\n",
    "  c = []\n",
    "  i = 0\n",
    "  while i < len(a):\n",
    "    c.append(dot_product_vecs(a[i], b))\n",
    "    i = i + 1\n",
    "  return c"
   ]
  }
 ],
 "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
}