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",
    "for i in range(n):\n",
    "    for j in range(n-1):\n",
    "        if(arr[j] > arr[j+1]):\n",
    "            temp = arr[j]\n",
    "            arr[j] = arr[j+1]\n",
    "            arr[j+1] = temp\n",
    "            \n",
    "\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",
    "for i in range(n):\n",
    "    key = arr[i]\n",
    "    j = i - 1\n",
    "    while j >= 0 and key < arr[j]:\n",
    "        arr[j+1] = arr[j]\n",
    "        j = j-1\n",
    "    arr[j+1] = key\n",
    "\n",
    "for i in range(n):\n",
    "    print(arr[i], end=\" \")"
   ]
  },
  {
   "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": [
    "# 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
}