Phase1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python Basic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 1: Input and Output"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "name = input(\"Enter Your Name:\")\n",
    "age = int(input(\"Enter Your Age:\"))\n",
    "print(name,'\\n', age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = 1\n",
    "x = 1.3\n",
    "b = 12\n",
    "\n",
    "y = m*x+b\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alpha = 1.69\n",
    "cofactor = alpha*x*x\n",
    "order1st = 1.0/cofactor\n",
    "order2nd = 2.0**order1st\n",
    "\n",
    "print(cofactor,'\\n',order1st,'\\n',order2nd)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = '85'\n",
    "x = float(x)\n",
    "print(type(x))\n",
    "x = int(x)\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 2: Data Handling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = int(2 + 7)\n",
    "t = str('cream' + 'pie')\n",
    "x = str(['catfood'])\n",
    "l = [1,22,45, 98, 2] #.sort() #none\n",
    "l.sort()\n",
    "if 2>3: m = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print((10+3)*2)\n",
    "\n",
    "print(11/2)\n",
    "\n",
    "x = 25\n",
    "print(x*2==50)\n",
    "\n",
    "a = 'Honda'\n",
    "b = 'Audi'\n",
    "print(a+b)\n",
    "\n",
    "c = len(a)+ len(b)\n",
    "print(c)\n",
    "\n",
    "print(a)\n",
    "print(a[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 9000\n",
    "print(\"It's a\", type(a))\n",
    "a = float(a)\n",
    "print(\"Now It's a\", type(a))\n",
    "a =str(a)\n",
    "print(\"Now It's a\", type(a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 4\n",
    "y = 8\n",
    "\n",
    "z = x/y*y\n",
    "print(z)\n",
    "\n",
    "z = x/(y*y)\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import fabs \n",
    "print(5/2)\n",
    "print(5.0/2)\n",
    "print((int)(5.0/2)) # print(int((5.0/2)))\n",
    "print(fabs(-5.0/2))\n",
    "print(fabs(-5.0//2))\n",
    "print(fabs(-3//2))\n",
    "print(-5/2)\n",
    "print(-5//2)\n",
    "print(-5.0/2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(type([1,2]))\n",
    "# print(type(1,2)) # Error\n",
    "print(type((1,2)))\n",
    "print(type(1/2))\n",
    "print(type([1/2]))\n",
    "print(type((1/2)))\n",
    "print(type((1/2,)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = True\n",
    "y = False\n",
    "z = False\n",
    "\n",
    "print(x or y and z) # print(x or (y and z))\n",
    "print((x or y) and z)\n",
    "print(not x or y)\n",
    "print(not x or y or not y and x) # print((not (x or y)) or (not (y and x)))\n",
    "print('ant'>'amoeba') # checks the unicode of letters i.e a = 63, b = 64 ....."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question & Answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WAP to calculate 1056 feet in terms of yards and miles. (1 mile = 1760 yards and 1 yard = 3 feet)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1056\n",
    "yard = 1056/3\n",
    "print(f'{x} feet is {yard} yards')\n",
    "mile = yard/1760\n",
    "print(f'{x} feet is {mile} mile')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WAP to calculate many rounds a person runs completed if he ran 560m of a park of sides 30m, 25m and 35m."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "primeter = 30 + 25 + 35\n",
    "rounds = 560/primeter\n",
    "print(rounds)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WAP to calculate the number of seconds in a year (365 days)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "days = 365\n",
    "hours = 24\n",
    "seconds = 3600\n",
    "print(f'Number of seconds in a year of {days} days is {days*hours*seconds}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 3: Control Flow Statements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0\n",
    "while i < 6:\n",
    "    j = 0 # i runs 6 times\n",
    "    while j < i:\n",
    "        print(\"*\", end=' ') # i runs 6 times and j runs 0, 1, 2, 3, 4, 5 represented by number of \"*\"\n",
    "        j += 1\n",
    "    i += 1\n",
    "    print(' ') # to make a new line"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x= 7\n",
    "y= 8\n",
    "if x < 7 or x <= 10 and y > 8: # x < 7 or (x <= 10 and y > 8)\n",
    "#  False or (True and False) == False or False --> else\n",
    "    print(\"It is!\")\n",
    "else:\n",
    "    print(\"Oh no!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "score = 40\n",
    "while score > 1:\n",
    "    score = score/2 - 1\n",
    "    # 40/2 = 20 - 1 = 19\n",
    "    # 19/2 = 9.5 - 1 = 8.5\n",
    "    # 8.5/2 = 4.25 - 1 = 3.25 ...\n",
    "    print(score)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 7\n",
    "if x > 3: # x > 3 to make this code true\n",
    "    if x <= 5: # x > 5 to make this code false\n",
    "        y = 1\n",
    "    elif x != 6: # x > 6 to make this code true\n",
    "        y = 2\n",
    "    else:\n",
    "        y = 3\n",
    "else:\n",
    "    y = 4\n",
    "\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if x == 5:\n",
    "    x += 1\n",
    "else: # same as if x != 5\n",
    "    x = 8\n",
    "    \n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question & Answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WAP to print a table of 0 to 100 ºF and ºC both"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0\n",
    "while i <= 100:\n",
    "    fahrenheit = i\n",
    "    celsius = (fahrenheit - 32) * 5/9\n",
    "    print(f'Temperature {fahrenheit}ºF = {celsius}ºC')\n",
    "    i += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WAP to print the pattern of 'z'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 8\n",
    "print('* '*9)\n",
    "while i > 0:\n",
    "    j = 0 \n",
    "    while j < i:\n",
    "        print(\" \", end=' ') \n",
    "        j += 1\n",
    "    i -= 1\n",
    "    print('*')\n",
    "print('* '*9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WAP to print an inverted right angled triangle "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 7\n",
    "while i>=0:\n",
    "    j = 0\n",
    "    while j<=i:\n",
    "        print(\"* \", end='')\n",
    "        j+=1\n",
    "    i-=1\n",
    "    print(\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WAP to print a pattern of 2 small sqaure"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 0\n",
    "while i < 4:\n",
    "    j = 0\n",
    "    while j < 4:\n",
    "        print('* ', end='')\n",
    "        j += 1\n",
    "    print()\n",
    "    i += 1\n",
    "\n",
    "i = 0\n",
    "while i < 4:\n",
    "    print(' '*(4*2-1), end='')\n",
    "    j = 0\n",
    "    while j < 4:\n",
    "        print('* ', end='')\n",
    "        j += 1\n",
    "    print()\n",
    "    i += 1\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WAP to make a diamond pattern"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = 5\n",
    "i = 0\n",
    "while i < n:\n",
    "    j = 0\n",
    "    while j < (n - i):\n",
    "        print(\"* \", end=\"\")\n",
    "        j += 1\n",
    "    j = 0\n",
    "    while j < (2 * i):\n",
    "        print(\"  \", end=\"\")\n",
    "        j += 1\n",
    "    j = 0\n",
    "    while j < (n - i):\n",
    "        print(\"* \", end=\"\")\n",
    "        j += 1\n",
    "    print(\"\")\n",
    "    i += 1\n",
    "\n",
    "\n",
    "i = 1\n",
    "while i < n:\n",
    "    j = 0\n",
    "    while j <= i:\n",
    "        print(\"* \", end=\"\")\n",
    "        j += 1\n",
    "    j = 0\n",
    "    while j < (2 * (n - i - 1)):\n",
    "        print(\"  \", end=\"\")\n",
    "        j += 1\n",
    "    j = 0\n",
    "    while j <= i:\n",
    "        print(\"* \", end=\"\")\n",
    "        j += 1\n",
    "    print(\"\")\n",
    "    i += 1\n",
    "\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 4: Data Types - Strings, Lists, Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Strings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 'blueberry'\n",
    "\n",
    "print(a[2:3]) # index 2 to (3-1) = 2 \n",
    "print(a[2:]) # index 2 to last\n",
    "print(a[:3]) # index start to (3-1) = 2\n",
    "print(a[:])  # index start to last\n",
    "print(a[-3:-1]) # index -3{6} to -1-1 = -2{7}\n",
    "print(a[:-1]) # index start to (last{8} - 1) = 7 \n",
    "print(a[1:1]) # index start to 1-1 = 0 [Nothing Prints]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myStr = \"Python Coding\"\n",
    "\n",
    "myStr = myStr + ' is great'\n",
    "# del myStr[0] # Error: 'str' object doesn't support item deletion\n",
    "\n",
    "print(myStr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 'nectarine'\n",
    "vowels = 'aeiou'\n",
    "\n",
    "result = ''\n",
    "i = 0\n",
    "\n",
    "while i < len(x):\n",
    "    if x[i] not in vowels:\n",
    "        result += x[i]\n",
    "    i += 1\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 'nectarine'\n",
    "vowels = 'aeiou'\n",
    "\n",
    "result = ''\n",
    "i = 0\n",
    "\n",
    "while i < len(x):\n",
    "    if x[i] in vowels:\n",
    "        result += f'({x[i]})'\n",
    "    else: \n",
    "        result += x[i]\n",
    "    i+=1\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 'blueberry'\n",
    "vowels = 'aeiou'\n",
    "\n",
    "result = ''\n",
    "\n",
    "for i in range(0,len(x)):\n",
    "    if x[i] not in vowels:\n",
    "        result += x[i]\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 'blueberry'\n",
    "vowels = 'aeiou'\n",
    "\n",
    "result = ''\n",
    "\n",
    "for i in range(0,len(x)):\n",
    "    if x[i] in vowels:\n",
    "        result += f'({x[i]})'\n",
    "    else: \n",
    "        result += x[i]\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lists & Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myTuple = (0,3,4,1)\n",
    "myTuple1 = (1,2,3)\n",
    "myTuple2 = (1,2,3)\n",
    "myTuple3 = (4)\n",
    "\n",
    "myTuple = myTuple + (4,) # myTuple = myTuple1 + myTuple3 # Error: You cannot add tuples like this\n",
    "# myTuple1.append(4) # Error: You cannnot append to a tuple\n",
    "# del myTuple[0] # Error: You cannnot delete from a tuple\n",
    "\n",
    "print(myTuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "(n1, n2) = tuple(\"25\") # n1 = '2', n2 = '5'\n",
    "t1 = ((1, 2), (3, 4), (9,))\n",
    "t2 = ((((1, 2, 3, 4), \"z\", \"m\"), \"h\", 1, 3), \"computer\")\n",
    "t3 = (\"HaVe\", \"A\", \"GoOd\", \"LuCk\")\n",
    "result = n2+n1, max(t1), max(t3)\n",
    "\n",
    "print(result)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "t = (\"Computer\", \"Is\", (\"An\", \"Electronic\"), \"Device\")\n",
    "a = (\"prosperity\", (\"luck\", \"faith\"), (\"health\", \"head\"), \"health\", \"Be\", \"happy\", \"enjoy\")\n",
    "\n",
    "print(t[2][0])\n",
    "print(\"pr\" in a[4]) # a[4] = 'Be'\n",
    "print(a[2][1][:2])\n",
    "print(a[1]+a[2])\n",
    "print('happy' in a[4:6][1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myList = [0, 3, 4, 1, 3, 6]\n",
    "\n",
    "myList.remove(6)\n",
    "newlist = myList.copy() # Makes a seperate copy of the list\n",
    "newlist = newlist + [4] # 4 added to copied list, actual list is uneffected\n",
    "myList.append(4) # Same as myList = myList + [4] \n",
    "del myList[3] # myList.pop(3) # removes an elements\n",
    "\n",
    "print(myList)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "LList = [\"Cats\", \"rule\", \"!\", \"?\", \"!\", \"?\"]\n",
    "LList.remove('!') # removes the first '!'\n",
    "LList = [item for item in LList if item != \"!\"] # removes all '!'\n",
    "LList.insert(1, 'may') \n",
    "\n",
    "print(LList.count(\"Cats\")) # how many elements\n",
    "print(LList.index(\"Cats\")) # index of the element\n",
    "\n",
    "print(LList.count(\"Dogs\"))\n",
    "# print(LList.index(\"Dogs\")) # Error: \"Dogs\" do not exist\n",
    "LList.append(\"Dogs\")\n",
    "\n",
    "print(LList)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1,2,3]\n",
    "\n",
    "a[2] = 0\n",
    "a[a[2]] = 5\n",
    "a[1:2] = []\n",
    "\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [[[1, 2, 3, 4, 5], [6, 7, 8]], 9]\n",
    "a[-1] = 200\n",
    "b = a[:]\n",
    "b[0][0][3] = 17\n",
    "\n",
    "print(a)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question & Answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WAP that takes 2 tuples and create a third one with all elemnts of first the tuple followed by all elemnts of the second tuple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "tuple1 = tuple(input(\"Enter the elements of the 1st tuple separated by spaces: \").split())\n",
    "tuple2 = tuple(input(\"Enter the elements of the 2nd tuple separated by spaces: \").split())\n",
    "\n",
    "tuple3 = tuple1 + tuple2\n",
    "\n",
    "print(\"First Tuple:\", tuple1)\n",
    "print(\"Second Tuple:\", tuple2)\n",
    "print(\"Concatenated Tuple:\", tuple3)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WAP to sort an array of integers in ascending order"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2, 4, 5, 63, 8, 0]\n",
    "\n",
    "a.sort()\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WAP that reverses a 2-D array of integers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [[1, 2, 3], [4, 5, 6]]\n",
    "\n",
    "sorted(a, reverse=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WAP to delete 10, 35, 43 from the given array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array1 = [3, 78, 106, 42, 10, 27, 33, 35, 43, 69, 1, 2, 4, 5, 63, 8, 0, 100, 1, 3200, 8, 6, 3, 9, 1300, 400,1, 3, 500]\n",
    "\n",
    "items = [10, 35, 43]\n",
    "\n",
    "for item in items: array1.remove(item)\n",
    "    \n",
    "print(array1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WAP to find the highest runs lowest runs and the total number of runs scored by Rohit Sharma in an over, data is given below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "runs = [[0, 6, 4, 1, 0, 0], [3, 0, 2, 0, 0, 0], [0, 0, 4, 4, 0, 1], [1, 2, 1, 0, 4, 6], [6, 0, 4, 4, 2, 1], [6, 6, 4, 4, 6, 1]]\n",
    "\n",
    "highest_runs = 0\n",
    "lowest_runs = float('inf')\n",
    "total_runs = 0\n",
    "\n",
    "for overs in runs:\n",
    "    runs_in_over = sum(overs)\n",
    "    \n",
    "    highest_runs = max(highest_runs, runs_in_over)\n",
    "    lowest_runs = min(lowest_runs, runs_in_over)\n",
    "    \n",
    "    total_runs += runs_in_over\n",
    "    \n",
    "print(f\"Highest runs scored in an over: {highest_runs}\")\n",
    "print(f\"Lowest runs scored in an over: {lowest_runs}\")\n",
    "print(f\"Total runs scored: {total_runs}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find the output of this code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = (3, 78, 106, 42, 69)\n",
    "length = len(l)\n",
    "a, b = (), ()\n",
    "c = i = 0\n",
    "m = l[0]\n",
    "while i < (length-2):\n",
    "    e = l[i]\n",
    "    c = 1\n",
    "    i += 2\n",
    "    for j in range (i, length*2):\n",
    "        if l[i] <= m:\n",
    "            c = i\n",
    "\n",
    "print(c, m, l, i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find the output of this code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = (100, 200, 300, 400, 500)\n",
    "length = len(l)\n",
    "a, b = [], []\n",
    "c = i = 0\n",
    "m = l[0]\n",
    "while i < length:\n",
    "    e = l[i]\n",
    "    c = 1\n",
    "    i += 1\n",
    "    for j in range (i, length):\n",
    "        if l[i] < m:\n",
    "            m = l[i]\n",
    "            c = i\n",
    "\n",
    "print(c, m, l, i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Find the output of this code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = (8, 6, 3, 9, 1)\n",
    "length = len(l)\n",
    "a, b = [], []\n",
    "c = i = 0\n",
    "while i < length:\n",
    "    e = l[i]\n",
    "    c = 1\n",
    "    i += 2\n",
    "    for j in range (i, length):\n",
    "        if e == l[j]:\n",
    "            c += 1\n",
    "        else:\n",
    "            pass\n",
    "        if c == 1:\n",
    "            a.append(e)\n",
    "        else:\n",
    "            b.append(e)\n",
    "    else:\n",
    "        i += 1\n",
    "\n",
    "print(a, end=' ')\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 5: Data Types - Dictionaries and Sorting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Dictonaries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "myDictionary = {\"a\": 1, \"b\": 2, \"c\": 3}\n",
    "myDictionary2 = {10: 1, 20: 2, 30: 3}\n",
    "myDictionary[\"d\"] = 4\n",
    "\n",
    "print(myDictionary)\n",
    "print(myDictionary2[20])\n",
    "print(\"a\" in myDictionary)\n",
    "print(1 in myDictionary) # in only checks for keys and not values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mydict = {\"cat\": 12, \"dog\": 6, \"elephant\": 23, \"zebra\": 22}\n",
    "\n",
    "mydict[\"mouse\"] = mydict[\"cat\"] + mydict[\"dog\"]\n",
    "answer = mydict.get(\"cat\")//mydict.get(\"dog\") # Same as mydict[\"cat\"]//mydict[\"dog\"]\n",
    "\n",
    "print(answer)\n",
    "print(mydict)\n",
    "print(mydict.keys())\n",
    "print(mydict.values())\n",
    "\n",
    "sorted_by_keys = dict(sorted(mydict.items()))\n",
    "print(sorted_by_keys)\n",
    "\n",
    "sorted_by_values = dict(sorted(mydict.items(), key=lambda item: item[1]))\n",
    "print(sorted_by_values)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "total = 0\n",
    "mydict = {\"cat\": 12, \"dog\": 6, \"elephant\": 23, \"bear\":20}\n",
    "\n",
    "for key in mydict:\n",
    "    if len(key) > 3:\n",
    "        total = total + mydict[key] \n",
    "        # total = 0 + mydict[elephant] = 0 + 23 \n",
    "        # total = 23 + mydict[bear] = 23 + 20\n",
    "        \n",
    "print(total)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sorting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sorting Method 1 - Bubble Sort technique\n",
    "In this, every element is compared with its next adjacent element and if the element is not in proper order, the two elements are swapped.\n",
    "If there are *n* elements in total, then *n* comparisons will place the largest element at the last position. Next time, beginning with first two elements and finishing with next elements, *n-1* comparisons will place the the 2nd largest element at the second place and so on..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = [24, 27, 22, 32, 29, 1, 2, 3, 4, 5, 6, 85, 90, 12, 6, 23, 18, 95, 80, 88, 0, 10, 100, 12, 25, 300, 41]\n",
    "n = len(arr)\n",
    "\n",
    "# Bubble sort algorithm\n",
    "for i in range(n):\n",
    "    # Last i elements are already in place\n",
    "    for j in range(n - 1):\n",
    "        # Swap if the element found is greater than the next element\n",
    "        if arr[j] > arr[j + 1]:\n",
    "            temp = arr[j]\n",
    "            arr[j] = arr[j + 1]\n",
    "            arr[j + 1] = temp\n",
    "\n",
    "# Print the sorted array\n",
    "print(arr, end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sorting Method 2 - Insertion Sort technique\n",
    "In this, we divide the array in 2 parts: _a) sorted part(which has no element in the beginning)_, _b) unsorted part(which has all the elements in the beginning_.\n",
    "Every iteration is performed with the aim of putting the first element of the unsorted part at the correct position in sorted part. Each such iteration adds 1 element in the sorted parts and removes 1 element from the unsorted part"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = [24, 27, 22, 32, 29, 1, 2, 3, 4, 5, 6, 85, 90, 12, 6, 23, 18, 95, 80, 88, 0, 10, 100, 12, 25, 300, 41]\n",
    "n = len(arr)\n",
    "\n",
    "# Insertion sort algorithm\n",
    "for i in range(n):\n",
    "    key = arr[i]  # Select the element to be inserted\n",
    "    j = i - 1\n",
    "    # Move elements of arr[0..i-1], that are greater than key, to one position ahead of their current position\n",
    "    while j >= 0 and key < arr[j]:\n",
    "        arr[j + 1] = arr[j]\n",
    "        j = j - 1\n",
    "    arr[j + 1] = key  # Insert the key at the correct position\n",
    "\n",
    "# Print the sorted array\n",
    "for i in range(n):\n",
    "    print(arr[i], end=\" \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sorting Method 3 - Merge Sort technique\n",
    "In this, we use divide-and-conquer algorithm that sorts an array by recursively dividing it into two halves (recusion), sorting each half, and then merging the sorted halves back together."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def merge_sort(arr):\n",
    "\n",
    "    # Step 1: Split the array into two halves\n",
    "    mid = len(arr) // 2\n",
    "    left_half = merge_sort(arr[:mid])  # Recursively sort the left half\n",
    "    right_half = merge_sort(arr[mid:])  # Recursively sort the right half\n",
    "\n",
    "    # Step 2: Merge the sorted halves\n",
    "    merged = []\n",
    "    i = j = 0  # Pointers for left and right halves\n",
    "\n",
    "    # Compare elements from both halves and add the smallest to the merged array\n",
    "    while i < len(left_half) and j < len(right_half):\n",
    "        if left_half[i] <= right_half[j]:\n",
    "            merged.append(left_half[i])\n",
    "            i += 1\n",
    "        else:\n",
    "            merged.append(right_half[j])\n",
    "            j += 1\n",
    "\n",
    "    # Append any remaining elements from the left half\n",
    "    while i < len(left_half):\n",
    "        merged.append(left_half[i])\n",
    "        i += 1\n",
    "\n",
    "    # Append any remaining elements from the right half\n",
    "    while j < len(right_half):\n",
    "        merged.append(right_half[j])\n",
    "        j += 1\n",
    "\n",
    "    return merged\n",
    "\n",
    "# Example array\n",
    "arr = [24, 27, 22, 32, 29, 1, 2, 3, 4, 5, 6, 85, 90, 12, 6, 23, 18, 95, 80, 88, 0, 10, 100, 12, 25, 300, 41]\n",
    "\n",
    "# Sort the array using the merge_sort function\n",
    "sorted_arr = merge_sort(arr)\n",
    "\n",
    "# Print the sorted array\n",
    "for num in sorted_arr:\n",
    "    print(num, end=\" \")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sorting Method 4 - Quick Sort technique\n",
    "In this, we use divide-and-conquer algorithm that sorts an array by recursively dividing it into partitions, sorting each partitions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def quicksort_inplace(arr, low, high):\n",
    "    # Base case: if the array has one or zero elements, it is already sorted\n",
    "    if low < high:\n",
    "        # Partition the array and get the pivot index\n",
    "        pi = partition(arr, low, high)\n",
    "        # Recursively apply quicksort to the left sub-array\n",
    "        quicksort_inplace(arr, low, pi - 1)\n",
    "        # Recursively apply quicksort to the right sub-array\n",
    "        quicksort_inplace(arr, pi + 1, high)\n",
    "\n",
    "def partition(arr, low, high):\n",
    "    pivot = arr[high]  # Choose the last element as the pivot\n",
    "    i = low - 1  # Index of the smaller element\n",
    "    for j in range(low, high):\n",
    "        # If the current element is smaller than the pivot\n",
    "        if arr[j] < pivot:\n",
    "            i += 1  # Increment the index of the smaller element\n",
    "            arr[i], arr[j] = arr[j], arr[i]  # Swap the elements\n",
    "    # Place the pivot in its correct position\n",
    "    arr[i + 1], arr[high] = arr[high], arr[i + 1]\n",
    "    return i + 1  # Return the pivot index\n",
    "\n",
    "\n",
    "arr = [24, 27, 22, 32, 29, 1, 2, 3, 4, 5, 6, 85, 90, 12, 6, 23, 18, 95, 80, 88, 0, 10, 100, 12, 25, 300, 41]\n",
    "quicksort_inplace(arr, 0, len(arr) - 1)\n",
    "\n",
    "print(arr)  # Print the sorted array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sorting Method 5 - Shell Sort technique\n",
    "It is an extension of insertion sort that compares elements that are far apart and reduce the gap gradually to 1."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = [24, 27, 22, 32, 29, 1, 2, 3, 4, 5, 6, 85, 90, 12, 6, 23, 18, 95, 80, 88, 0, 10, 100, 12, 25, 300, 41]\n",
    "\n",
    "n = len(arr)\n",
    "gap = n // 2  # Initialize the gap\n",
    "\n",
    "# Start with a large gap, then reduce the gap\n",
    "while gap > 0:\n",
    "    # Perform a gapped insertion sort for this gap size\n",
    "    for i in range(gap, n):\n",
    "        temp = arr[i]\n",
    "        j = i\n",
    "        \n",
    "        # Shift earlier gap-sorted elements up until the correct location for arr[i] is found\n",
    "        while j >= gap and arr[j - gap] > temp:\n",
    "            arr[j] = arr[j - gap]\n",
    "            j -= gap\n",
    "        arr[j] = temp\n",
    "    gap //= 2  # Reduce the gap for the next iteration\n",
    "\n",
    "\n",
    "print(arr)  # Print the sorted array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sorting Method 6 - Selection Sort technique\n",
    "In this, we use repeatedly select the smallest element and move it to the front."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = [24, 27, 22, 32, 29, 1, 2, 3, 4, 5, 6, 85, 90, 12, 6, 23, 18, 95, 80, 88, 0, 10, 100, 12, 25, 300, 41]\n",
    "\n",
    "n = len(arr)\n",
    "\n",
    "# Traverse through all array elements\n",
    "for i in range(n):\n",
    "    # Find the minimum element in the remaining unsorted array\n",
    "    min_idx = i\n",
    "    for j in range(i + 1, n):\n",
    "        if arr[j] < arr[min_idx]:\n",
    "            min_idx = j\n",
    "    \n",
    "    # Swap the found minimum element with the first unsorted element\n",
    "    arr[i], arr[min_idx] = arr[min_idx], arr[i]\n",
    "\n",
    "print(arr)  # Print the sorted array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Sorting Method 7 - Heap Sort technique\n",
    "Heapsort is a comparison-based sorting algorithm that uses a binary heap data structure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def heapify(arr, n, i):\n",
    "    largest = i  # Initialize largest as root\n",
    "    left = 2 * i + 1  # Left child\n",
    "    right = 2 * i + 2  # Right child\n",
    "\n",
    "    # If left child is larger than root\n",
    "    if left < n and arr[left] > arr[largest]:\n",
    "        largest = left\n",
    "\n",
    "    # If right child is larger than largest so far\n",
    "    if right < n and arr[right] > arr[largest]:\n",
    "        largest = right\n",
    "\n",
    "    # If largest is not root\n",
    "    if largest != i:\n",
    "        arr[i], arr[largest] = arr[largest], arr[i]  # Swap\n",
    "        # Recursively heapify the affected sub-tree\n",
    "        heapify(arr, n, largest)\n",
    "\n",
    "def heapsort(arr):\n",
    "    n = len(arr)\n",
    "\n",
    "    # Build a max heap\n",
    "    for i in range(n // 2 - 1, -1, -1):\n",
    "        heapify(arr, n, i)\n",
    "\n",
    "    # One by one extract elements\n",
    "    for i in range(n - 1, 0, -1):\n",
    "        arr[i], arr[0] = arr[0], arr[i]  # Swap\n",
    "        heapify(arr, i, 0)\n",
    "\n",
    "# Example usage\n",
    "arr = [24, 27, 22, 32, 29, 1, 2, 3, 4, 5, 6, 85, 90, 12, 6, 23, 18, 95, 80, 88, 0, 10, 100, 12, 25, 300, 41]\n",
    "heapsort(arr)\n",
    "print(arr)  # Print the sorted array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question & Answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WAP to create a dictionary/object to take enteries of name and phone hnumber from the user, eg: \"Javin\":8500000003"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "phonebook = {\"Javin\":8500000003}\n",
    "\n",
    "while True:\n",
    "    name = input(\"Enter a name (or type 'q' to stop): \")\n",
    "\n",
    "    if name.lower() == 'q':\n",
    "        break\n",
    "    \n",
    "    phone_number = input(f\"Enter the phone number for {name}: \")\n",
    "    phonebook[name] = phone_number\n",
    "\n",
    "\n",
    "print(\"\\nPhonebook entries:\")\n",
    "for name, number in phonebook.items():\n",
    "    print(f\"{name}: {number}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WAP to sort the given dictonary in acending order of marks obtained by students"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "result = {\"Ayan\":56, \"Banerjee\":34, \"Chunnu\": 45, \"Diya\":88, \"Golu\": 13, \"Kallia\": 73, \"Kirmada\": 99, \"Mohan\": 67, \"Sohan\": 43}\n",
    "\n",
    "result = dict(sorted(result.items(), key=lambda x: x[1]))\n",
    "\n",
    "print(\"Sorted result (by marks in ascending order):\")\n",
    "for name, marks in result.items():\n",
    "    print(f\"{name}: {marks}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 6: Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sub1(a, b):\n",
    "    print(f\"{b} - {a} = {b-a}\")\n",
    "    return # returns nothing\n",
    "\n",
    "def greeting():\n",
    "    print(\"Welcome to Python\")\n",
    "    # return # returns nothing so may not be written\n",
    "    \n",
    "def cube2(x):\n",
    "    x * x * x\n",
    "    return x * x * x - x\n",
    "\n",
    "def cube1(x):\n",
    "    return x * x * x\n",
    "\n",
    "x, y = 1, 3\n",
    "num = 54\n",
    "greeting()\n",
    "sub1(x, y)\n",
    "sub1(5,6)\n",
    "\n",
    "print(cube2(num)) # cube2 does not print anything\n",
    "print(cube1(x)) # cube1 does not print anything"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def lastDigitCube(n):\n",
    "    d = n%10\n",
    "    c= d**3\n",
    "    return c\n",
    "\n",
    "number = int(input(\"Enter a number: \"))\n",
    "cube = lastDigitCube(number)\n",
    "\n",
    "print(f\"The cube of the last Digit of {number} i.e '{number%10}' = {cube}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fun(a, b=5, c=10):\n",
    "    poly = 2 * a ** - 5 * b + c\n",
    "    print(f'with values {a, b, c} = {poly}')\n",
    "    \n",
    "fun(3,7) # a = 3, b = 7,  c = 10{default}\n",
    "fun(3, c = 7) # a = 3, b = 5{default},  c = 7\n",
    "fun(c = 7, a = 3) # a = 3, b = 5{default},  c = 7\n",
    "# fun(c = 7, b = 3) # Error: 'a' not found"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sqr(x):\n",
    "    return x * x\n",
    "    \n",
    "def sumOfSqr(x,y):\n",
    "    # function can use other functions\n",
    "    return sqr(x) + sqr(y)\n",
    "\n",
    "print(sumOfSqr(2, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def myFunc(l, v):\n",
    "    l[0] += 2 \n",
    "    v += 2\n",
    "    print(f\"Values/Variables within first called function: {l}, {v}\")\n",
    "    return\n",
    "\n",
    "def myFunc2(list1, var1):\n",
    "    list1[0] += 2\n",
    "    var1 += 2\n",
    "    print(f\"Values/Variables within second called function: {list1}, {var1}\")\n",
    "    return\n",
    "\n",
    "list1 = [1]\n",
    "var1 = 1\n",
    "list2 = [1]\n",
    "var2 = 1\n",
    "\n",
    "print(f\"Values/Variables before calling the functions: {list1}, {var1}, {list2}, {var2}\")\n",
    "\n",
    "myFunc(list1, var1) # list's value is changed, variable's value is not changed \n",
    "myFunc2(list2.copy(), var2) # list's copy's item is changed list is unchanged, variable's value is not changed \n",
    "\n",
    "print(f\"Values/Variables before calling the functions: {list1}, {var1}, {list2}, {var2}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "add = lambda x, y: x + y\n",
    "multiply = lambda a, b: a * b\n",
    "\n",
    "print(add(5, 3))\n",
    "print(multiply(4, 6))\n",
    "\n",
    "# Lambda functions are often used with higher-order functions like map(), filter(), and reduce().\n",
    "numbers = [1, 2, 3, 4]\n",
    "squares = list(map(lambda x: x**2, numbers))\n",
    "\n",
    "numbers = [1, 2, 3, 4, 5, 6, 7]\n",
    "even_numbers = list(filter(lambda x: x % 2 == 0, numbers))\n",
    "\n",
    "students = [(\"Ayan\", 56), (\"Banerjee\", 34), (\"Chunnu\", 45), (\"Diya\", 88)]\n",
    "sorted_students = sorted(students, key=lambda x: x[1])\n",
    "\n",
    "print(squares)\n",
    "print(even_numbers)\n",
    "print(sorted_students)\n",
    "\n",
    "from functools import reduce\n",
    "\n",
    "numbers = [1, 2, 3, 4, 5]\n",
    "product = reduce(lambda x, y: x * y, numbers)\n",
    "\n",
    "print(product) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question & Answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WAP to find the absolute value of a number given by user"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def absolute(x):\n",
    "    if x>=0:\n",
    "        return x\n",
    "    else:\n",
    "        return (-x)\n",
    "\n",
    "a = float(input(\"Enter a number: \"))\n",
    "\n",
    "print(absolute(a))\n",
    "# print(abs(x)) # abs is a pre-defined function"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WAP to find whether the input string is vowel or not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def vowelChk(x):\n",
    "    vowellist = [\"a\", \"e\", \"i\", \"o\", \"u\"]\n",
    "    if x in vowellist:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "a = input(\"Enter a letter: \")\n",
    "\n",
    "print(f\"{a} is a vowel\") if vowelChk(a) else print(f\"{a} is not a vowel\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WAP to find the Mersennes of the first *n* number  i.e *2ⁿ -1*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def mersenne(n):\n",
    "    mersennes = []\n",
    "    for n in range(5):\n",
    "        mersennes.append(2**n - 1)\n",
    "    return mersennes\n",
    "        \n",
    "a = 5\n",
    "\n",
    "print(mersenne(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WAP to find the sum of the sqaure of the first 2 digit and the sqaure of the last 2 digit of a 4 digit number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum_of_square(number):\n",
    "    first_two_digits = number // 100\n",
    "    last_two_digits = number % 100\n",
    "    first_square = first_two_digits**2\n",
    "    last_square = last_two_digits**2\n",
    "    return first_square + last_square\n",
    "\n",
    "\n",
    "x = 2000\n",
    "ans = sum_of_square(x)\n",
    "\n",
    "print(f\"The sum of the sqaure of the first 2 digit and the sqaure of the last 2 digit of a {x} = {ans}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WAP to find if the given number is prime or not"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prime(x):\n",
    "    i = 2\n",
    "    while i<a:\n",
    "        if a%i == 0:\n",
    "            return False\n",
    "        i+=1\n",
    "    else:\n",
    "        return True\n",
    "    \n",
    "a = 71\n",
    "\n",
    "print(f\"{a} is a Prime Number\") if prime(a) else print(f\"{a} is not a Prime Number\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 7: Modules and Packages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Math and Random Module"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math # import math module\n",
    "\n",
    "arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n",
    "\n",
    "print(math.gcd(12, 3, 6)) # Greatest Common Divisor of numbers\n",
    "print(math.factorial(3)) # Factorial of a number\n",
    "print(math.sqrt(64)) # Square Root of a number\n",
    "print(math.fsum(arr)) # Sum of an array\n",
    "print(math.prod(arr)) # Product of an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "\n",
    "choices = [1, 2, 3, 4, 5, 6, \"Heads\", \"Tails\"]\n",
    "\n",
    "print(random.randbytes(8)) # Generate n random bytes\n",
    "print(random.randint(1, 100)) # Generates random integer in range [a, b]\n",
    "print(random.choice(choices)) # Choose a random element from an array"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Custom Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Make sure to have a welcome.py file with a greet(name) function that return a Greeting {name} text."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import welcome\n",
    "# from welcome import *\n",
    "import welcome as greeting\n",
    "\n",
    "print(f\"{help(greeting)} \\n\") # Details of the module\n",
    "print(greeting.greet(\"Anmol\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Packages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Make sure to have a dictory like this: \n",
    "\n",
    "```\n",
    "mypackage/\n",
    "├── __init__.py/\n",
    "├── math_operations.py/\n",
    "├── string_operations.py/"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### math_operations.py\n",
    "\n",
    "write the following code in this file:\n",
    "\n",
    "```\n",
    "def add(a, b):\n",
    "    return a + b\n",
    "\n",
    "def subtract(a, b):\n",
    "    return a - b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### string_operations.py\n",
    "write the following code in this file:\n",
    "\n",
    "```\n",
    "def to_uppercase(s):\n",
    "    return s.upper()\n",
    "\n",
    "def to_lowercase(s):\n",
    "    return s.lower()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### ```__init__.py```\n",
    "\n",
    "write the following code in this file:\n",
    "\n",
    "```\n",
    "from .math_operations import add, subtract\n",
    "from .string_operations import to_uppercase, to_lowercase\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from mypackage import add, subtract, to_uppercase, to_lowercase\n",
    "\n",
    "print(add(5, 3))\n",
    "print(subtract(15, 3))\n",
    "print(to_uppercase(\"python\"))\n",
    "print(to_lowercase(\"PythoN\"))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 8: Data Files in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Make sure you have a .txt with some content for the following code."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "file = open(\"./data/first.txt\", \"r\") # this file should exist.\n",
    "text = file.readlines()\n",
    "file.close()\n",
    "\n",
    "newFile = open(\"./data/new.txt\", \"w\") # this file may/maynot exist: if it don't exist, it will be created\n",
    "newFile.writelines(\"Hello There\")\n",
    "newFile.close()\n",
    "\n",
    "newFile = open(\"./data/new.txt\", \"a\") # this file should exist.\n",
    "newFile.writelines(\"\\nHello There 2\")\n",
    "newFile.close()\n",
    "\n",
    "print(text)\n",
    "print(type(text))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "file = open(\"./data/first.txt\", \"r\")\n",
    "text = file.readlines()\n",
    "file.close()\n",
    " \n",
    "total_lines = 0\n",
    "empty_lines = 0\n",
    "word_count = 0\n",
    "character_count = 0\n",
    "\n",
    "for line in text:\n",
    "    total_lines += 1\n",
    "    if line.strip() == \"\":\n",
    "        empty_lines += 1\n",
    "    else:\n",
    "        words = line.split()\n",
    "        word_count += len(words)\n",
    "        \n",
    "    for word in line:\n",
    "        character_count += 1\n",
    "\n",
    "print(f\"Total number of lines: {total_lines}\")\n",
    "print(f\"Total number of empty lines: {empty_lines}\")\n",
    "print(f\"Total number of words: {word_count}\")\n",
    "print(f\"Total number of characters: {character_count}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Chapter 9: Recursion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    if n == 0 or n == 1:\n",
    "        return 1\n",
    "    else:\n",
    "        return n * factorial(n-1)\n",
    "\n",
    "print(factorial(5))\n",
    "\n",
    "# For factorial(5):\n",
    "\n",
    "# factorial(5) calls factorial(4)\n",
    "# factorial(4) calls factorial(3)\n",
    "# factorial(3) calls factorial(2)\n",
    "# factorial(2) calls factorial(1)\n",
    "# factorial(1) hits the base case and returns 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fibonacci(n):\n",
    "    if n == 0:\n",
    "        return 0\n",
    "    elif n == 1:\n",
    "        return 1\n",
    "    else:\n",
    "        return fibonacci(n-1) + fibonacci(n-2)\n",
    "\n",
    "print(fibonacci(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Question & Answer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WAP to find the first digit of a number by dividing by 10 using recursion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def div10(x):\n",
    "    digit = x//10\n",
    "    if digit<10:\n",
    "        return digit\n",
    "    else:\n",
    "        return div10(digit)\n",
    "    \n",
    "num = 78454412\n",
    "\n",
    "print(f\"The First digit of {num} = {div10(num)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "WAP to find the largest number in an array using recursion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def find_largest(arr, n):\n",
    "    if n == 1:\n",
    "        return arr[0]\n",
    "    return max(arr[n-1], find_largest(arr, n-1))\n",
    "\n",
    "arr = [3, 1, 4, 1, 5, 9, 2, 6, 5, 33]\n",
    "n = len(arr)\n",
    "\n",
    "largest = find_largest(arr, n)\n",
    "print(f\"The largest number in the array is: {largest}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## OOPs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Person:\n",
    "\n",
    "    # Dunder Methods: Pre-defined functions for any class, starts and ends with \"__\"\n",
    "    # __init__ # Constructor: Initializes the class\n",
    "    def __init__(self, full_name: str, occ: str, age: int,networth: int) -> None:\n",
    "        self.name = Name(full_name)  # Using the Name class to split the name this is called Composition of classes (defined below)\n",
    "        self.occ = occ\n",
    "        self.age = age\n",
    "        self.networth = networth\n",
    "\n",
    "    # __setattr__ # Setter: Sets the value of an attribute\n",
    "    def __setattr__(self, name, value) -> None:\n",
    "        # Define expected types for each attribute\n",
    "        type_hints = {\n",
    "            \"name\": Name, # compare the type of value \"name\" with the type of Name class\n",
    "            \"occ\": str, # compare the type of value \"occ\" with the type of str\n",
    "            \"age\": int, # compare the type of value \"age\" with the type of int\n",
    "            \"networth\": int, # compare the type of value \"networth\" with the type of int\n",
    "        } \n",
    "\n",
    "        if name in type_hints:  # Check if the attribute has a type hint\n",
    "            expected_type = type_hints[name]\n",
    "            if not isinstance(value, expected_type):\n",
    "                raise TypeError(f\"Attribute '{name}' must be of type {expected_type.__name__}, got {type(value).__name__}\")\n",
    "            \n",
    "        super().__setattr__(name, value) # Use this as the default behavior to set the attribute\n",
    "\n",
    "    # __str__ # String representation of the class\n",
    "    def __str__(self):\n",
    "        return f\"{self.name}, Age: {self.age}\"\n",
    "\n",
    "    # __eq__ # Equality: Compares two objects made from this class\n",
    "    def __eq__(self, other):\n",
    "        return self.name == other.name and self.age == other.age\n",
    "\n",
    "    # Decorators: Modify a function\n",
    "    def hello(fx):\n",
    "        def mfx(*args, **kwargs):\n",
    "            print(f\"Hello from {fx.__name__}\")\n",
    "            func = fx(*args, **kwargs)\n",
    "            return func\n",
    "        return mfx\n",
    "\n",
    "    # Functions of class\n",
    "    @hello # Decorator modifing a function\n",
    "    def info(self) -> str:\n",
    "        return f\"I am {self.name.name} {self.name.surname}, I am a {self.occ}\"\n",
    "    \n",
    "    # Function without a decorator \n",
    "    def actualincome(self) -> str:\n",
    "        taxslab = round(self.networth, 2) if (self.networth < 250000) else round(self.networth * 0.2, 2) if (self.networth > 250000 and self.networth) < 500000 else round(self.networth * 0.3, 2)\n",
    "        ipa = round(self.networth - taxslab, 2)\n",
    "        ipm = round(ipa/12, 2)\n",
    "        return f\"{self.name.name} {self.name.surname} earns {self.networth}\\n\\t pays {taxslab}\\n\\t accounting to {ipa} per annum \\n\\t accounting to {ipm} per month\"\n",
    "    \n",
    "    # Getter and Setter\n",
    "    @property # Getter: Gets networth in a function \"income\"\n",
    "    def income(self) -> int:\n",
    "        return self.networth\n",
    "\n",
    "    @income.setter # Setter: Sets newnetworth to self.networth using a function \"newincome\"\n",
    "    def newincome(self, newnetworth) -> None:\n",
    "        self.networth = newnetworth\n",
    "\n",
    "    @property # Getter: Gets name in a function \"name\" \n",
    "    def name(self) -> str: \n",
    "        return self._name\n",
    "\n",
    "    @name.setter # Setter: Sets name to self.name using a function \"name\" used as name.name from \".name\" Name class then \".name\" Person class\n",
    "    def name(self, value: str) -> None:\n",
    "        self._name = value\n",
    "\n",
    "    @property # Getter: Gets surname in a function \"surname\" \n",
    "    def surname(self) -> str:\n",
    "        return self._surname\n",
    "\n",
    "    @surname.setter # Setter: Sets surname to self.surname using a function \"surname\" used as name.surname from \".name\" Name Person class then \".surname \"Name class\n",
    "    def surname(self, value: str) -> None:\n",
    "        self._surname = value\n",
    "\n",
    "\n",
    "\n",
    "# Helping Class\n",
    "\n",
    "# Name class to split the name and use it in Person class\n",
    "class Name:\n",
    "    def __init__(self, full_name: str) -> None:\n",
    "        name_parts = full_name.split()\n",
    "        self._name = name_parts[0]\n",
    "        self._surname = name_parts[1] if len(name_parts) > 1 else \"\"\n",
    "\n",
    "    @property\n",
    "    def name(self) -> str:\n",
    "        return self._name\n",
    "\n",
    "    @name.setter\n",
    "    def name(self, value: str) -> None:\n",
    "        self._name = value\n",
    "\n",
    "    @property\n",
    "    def surname(self) -> str:\n",
    "        return self._surname\n",
    "\n",
    "    @surname.setter\n",
    "    def surname(self, value: str) -> None:\n",
    "        self._surname = value\n",
    "\n",
    "    def __str__(self) -> str:\n",
    "        return f\"{self._name} {self._surname}\".strip()  # Handles cases with missing surname"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Subclass Employee inherits from Person\n",
    "class Employee(Person):\n",
    "    def __init__(self, full_name: str, occ: str, age: int, networth: int, position: str) -> None:\n",
    "        # Call the parent class's constructor to initialize inherited attributes\n",
    "        super().__init__(full_name, occ, age, networth)\n",
    "        self.position = position\n",
    "\n",
    "    # Overriding __setattr__ to include type checking for 'position'\n",
    "    def __setattr__(self, name, value) -> None:\n",
    "        # Extend the type hints from the parent class\n",
    "        type_hints = {\n",
    "            \"position\": str,  # Add type checking for 'position'\n",
    "        }\n",
    "\n",
    "        # Combine parent type hints with the current class's type hints\n",
    "        parent_type_hints = getattr(super(), \"__setattr__\").__annotations__ if hasattr(super(), \"__setattr__\") else {}\n",
    "        type_hints.update(parent_type_hints)\n",
    "\n",
    "        # Check for type validation\n",
    "        if name in type_hints:\n",
    "            expected_type = type_hints[name]\n",
    "            if not isinstance(value, expected_type):\n",
    "                raise TypeError(f\"Attribute '{name}' must be of type {expected_type.__name__}, got {type(value).__name__}\")\n",
    "\n",
    "        # Call the parent class's __setattr__ to set the attribute\n",
    "        super().__setattr__(name, value)\n",
    "\n",
    "    # Overriding the __str__ method to include position\n",
    "    def __str__(self):\n",
    "        return f\"{self.name}, Age: {self.age}, Position: {self.position}\"\n",
    "\n",
    "    # Adding a new method specific to Employee\n",
    "    def promote(self, new_position: str) -> None:\n",
    "        old_position = self.position\n",
    "        self.position = new_position\n",
    "        print(f\"{self.name.name} {self.name.surname} has been promoted from {old_position} to {new_position}.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Making an object a using class Person\n",
    "a = Person(\"Anmol\", \"Developer\", 16,  150)\n",
    "\n",
    "# Using getter and setter to get and set a value\n",
    "print(f\"Using getter to see networth, Networth is {a.income} before Setter\")\n",
    "a.newincome = 70000000\n",
    "\n",
    "a.name.surname = \"Raj\"\n",
    "\n",
    "print(dir(a)) # shows all function of a class\n",
    "\n",
    "# Using methods of class\n",
    "print(a.info())\n",
    "print(a.actualincome())\n",
    "\n",
    "# Dunder Methods\n",
    "p1 = Person(\"Ujjwal\", \"Developer\", 15, 150)\n",
    "p2 = Person(\"Joy\", \"Developer\", 15, 150)\n",
    "\n",
    "print(p1)                # Calls __str__\n",
    "print(p1 == p2)          # Calls __eq__\n",
    "\n",
    "# Create an instance of Employee\n",
    "employee = Employee(\"Anmol Raj\", \"Developer\", 16, 7000000, \"Junior Developer\")\n",
    "\n",
    "# Demonstrate the new functionality\n",
    "print(employee)  # Calls overridden __str__\n",
    "\n",
    "# Promote the employee\n",
    "employee.promote(\"Senior Developer\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array( [[ 1, 2, 3],[ 4, 2, 5]] )\n",
    "\n",
    "print(\"array is of type: \", type(arr))\n",
    "print(\"No. of dimensions: \", arr.ndim)\n",
    "print(\"Shape of array: \", arr.shape)\n",
    "print(\"Size of array: \", arr.size)\n",
    "print(\"arr stores elements of type: \", arr.dtype) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = np.zeros((3, 4)) # Creating a 3X4 array with all zeros\n",
    "e = np.random.random((3, 2)) # Create an array with random values\n",
    "f = np.arange(0, 30, 5) # Create a sequence of integers from 0 to 30 with steps of 5\n",
    "\n",
    "print (\"An array initialized with all zeros:\\n\", c) \n",
    "print (\"A random array:\\n\", e)\n",
    "print (\"A sequential array with steps of 5:\\n\", f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dtypes = [ ('year', int), ('rank', float) ]# set names for dtypes\n",
    "values = [( 2009, 8.5), ( 2008, 8.7), ( 2008, 7.9), ( 2009, 9.0)] # Values to be put in array    \n",
    "\n",
    "arr = np.array(values, dtype = dtypes)\n",
    "\n",
    "print(arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iterable = (a for a in range(8))\n",
    "\n",
    "arr = np.fromiter(iterable, int)\n",
    "\n",
    "print(\"fromiter() array :\",arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "empa = np.empty((3, 4)) # Creating an empty 3X4 array\n",
    "full_array_2d = np.full((3, 4), 5) # Creating a 3X4 array with all elements as 5\n",
    "\n",
    "print(empa)\n",
    "print(full_array_2d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([2, 4, 6, 8, 10]) \n",
    "\n",
    "c = arr.copy() \n",
    "  \n",
    "print(\"id of arr\", id(arr)) \n",
    "print(\"id of c\", id(c)) \n",
    "\n",
    "arr[0] = 12 # changing original array this will not effect copy \n",
    "\n",
    "print(\"original array- \", arr) \n",
    "print(\"copy- \", c) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Manupilation of an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([[1, 2, 3, 4],[5, 2, 4, 2],[1, 2, 0, 1]])\n",
    "\n",
    "newarr = arr.reshape(2, 2, 3) # Reshaping 3X4 array to 2X2X3 array\n",
    "flat_arr = arr.flatten() # Reshaping 3X4 array to 1X12 array\n",
    "\n",
    "print(newarr)\n",
    "print(flat_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([[1, 2, 3], [3, 4, 5], [9, 6, 0]])\n",
    "\n",
    "print (\"\\nOriginal array:\\n\", a)\n",
    "print (\"Transpose of array:\\n\", a.T) # transpose of array x and y axis changes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1 = np.array([[ 1, 2, 3], [ -1, -2, -3]] ) \n",
    "arr2 = np.array([[ 4, 5, 6], [ -4, -5, -6]] ) \n",
    "\n",
    "arr = np.hstack((arr1, arr2))\n",
    "\n",
    "print(arr) # added 2 arrays together horizontally"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr1 = np.array([[ 1, 2, 3], [ -1, -2, -3]] ) \n",
    "arr2 = np.array([[ 4, 5, 6], [ -4, -5, -6]] ) \n",
    "\n",
    "arr = np.vstack((arr1, arr2)) \n",
    "\n",
    "print (arr) # added 2 arrays together vertically"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "array_1 = np.array([[1, 2], [3, 4]]) \n",
    "array_2 = np.array([[5, 6], [7, 8]]) \n",
    "  \n",
    "array_new = np.concatenate((array_1, array_2), axis=1) \n",
    "print(array_new) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Slicing an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([[-1, 2, 0, 4],[4, -0.5, 6, 0], [2.6, 0, 7, 8],[3, -7, 4, 2.0]])\n",
    "\n",
    "temp = arr[:2, ::2] # Slicing array\n",
    "i = arr[[0, 1, 2, 3], [3, 2, 1, 0]] # Indexing \n",
    "cond = arr > 0 # removing 0s from the array\n",
    "arr_with_0_removed = arr[cond]\n",
    "\n",
    "\n",
    "print (temp)\n",
    "print (\"\\nElements at indices (0, 3), (1, 2), (2, 1), (3, 0):\\n\", i)\n",
    "print (\"\\nElements greater than 0:\\n\", arr_with_0_removed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([1, 2, 3, 4, 5, 6])\n",
    "arr2 = np.arange([1, 2, 3, 4, 5])\n",
    "array = np.array_split(arr, 3) # Split the array in 3 parts (equal)\n",
    "result = np.array_split(array, 4) # Splitting the array into 4 unequal parts\n",
    "\n",
    "print(array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operations on an array "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([1, 2, 5, 3])\n",
    "\n",
    "\n",
    "print (\"Adding 1 to every element:\", a+1) # add 1 to every element\n",
    "print (\"Subtracting 3 from each element:\", a-3) # subtract 3 from each element\n",
    "print (\"Multiplying each element by 10:\", a*2) # multiply each element by 2\n",
    "print (\"Squaring each element:\", a**2) # square each element\n",
    "\n",
    "a *= 2 # modify existing array \n",
    "print (\"Doubled each element of original array:\", a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "arr = np.array([[1, 5, 6], [4, 7, 2], [3, 1, 9]])\n",
    "\n",
    "print (\"Largest element is:\", arr.max()) # maximum element of array\n",
    "print (\"Sum of all array elements:\", arr.sum()) # sum of array elements\n",
    "\n",
    "print (\"Row-wise maximum elements:\",arr.max(axis = 1))\n",
    "print (\"Column-wise minimum elements:\", arr.min(axis = 0)) # minimum element of array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([[1, 2], [3, 4]])\n",
    "b = np.array([[4, 3],[2, 1]])\n",
    "\n",
    "print (\"Array sum:\\n\", a + b) # add arrays\n",
    "print (\"Array multiplication:\\n\", a*b) # multiply arrays (elementwise multiplication)\n",
    "print (\"Matrix multiplication:\\n\", a.dot(b)) # matrix multiplication => [[(1×4)+(2×2)=4+4=8 (1×3)+(2×1)=3+2=5],[(3×4)+(4×2)=12+8=20 (3×3)+(4×1)=9+4=13]]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sorting an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([[1, 4, 2],[3, 4, 6],[0, -1, 5]])\n",
    "\n",
    "\n",
    "print (\"Array elements in sorted order:\\n\",np.sort(a, axis = None)) # sorted array\n",
    "print (\"Row-wise sorted array:\\n\",np.sort(a, axis = 1)) # sort array row-wise\n",
    "print (\"Column wise sort by applying merge-sort:\\n\", np.sort(a, axis = 0, kind = 'mergesort')) # sort all items in the array\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Indexing an array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = np.array([[1, 4, 2],[3, 4, 6],[0, -1, 5]])\n",
    "\n",
    "print(a[0][2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Pandas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Creating a DataFrame"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = {\n",
    "    \"Name\": [\"Alice\", \"Bob\", \"Charlie\", \"David\", \"Eve\"],\n",
    "    \"Age\": [24, 27, 22, 32, 29],\n",
    "    \"City\": [\"NY\", \"LA\", \"SF\", \"DC\", \"CHI\"],\n",
    "}\n",
    "\n",
    "df = pd.DataFrame(data)\n",
    "\n",
    "print(\"DataFrame:\\n\", df)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using a csv file as data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pd.read_csv(\"data/nba-sample.csv\") \n",
    "n = 10\n",
    "data_top = data.head(n) # display first n elements\n",
    "data_bottom = data.tail(n) # display last n elements\n",
    "\n",
    "print(data_top)\n",
    "print(data_top.to_string())\n",
    "print(data_bottom)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('data/nba-sample.csv')\n",
    "\n",
    "new_df = df.dropna() # Removes all element with 1 or more empty cell\n",
    "\n",
    "print(new_df.to_string())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('data/nba-sample.csv')\n",
    "\n",
    "df.fillna('x', inplace=True) # Replaces all empty cell with 'x'\n",
    "df[\"Age\"].fillna('20+', inplace = True) # Replaces all Age column's empty cell with '20+'\n",
    "\n",
    "print(df.to_string())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Adding a new column\n",
    "df = pd.read_csv('data/nba-sample.csv')\n",
    "\n",
    "df['Country'] = 'America'  # You can also add computed or other values\n",
    "df.to_csv('data/nba-sample.csv', index=False)\n",
    "\n",
    "print(df.to_string())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### DataFrame operations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.read_csv('data/nba-sample.csv')\n",
    "\n",
    "x = df[\"Age\"].mean()\n",
    "y = df[\"Number\"].median()\n",
    "z = df[\"College\"].mode()[0]\n",
    "\n",
    "print(x, y, z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Names column:\\n\", df['Name'])\n",
    "print(\"Rows where age is greater than 25:\\n\", df[df['Age'] > 25])\n",
    "print(df.duplicated()) # check for duplicate: True or False "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}