02 - Python/Week 02 - Python Basics/2. Intro to Python .ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7c03ce7a",
   "metadata": {},
   "source": [
    "1. Conditional Statement (if, elif, else, nested if, pass)\n",
    "2. Control Statement (for, while, nested, break, continue, pass)\n",
    "3. Functions (task, argument, Recursion, global, local, nested, Anonymous(lambda), Package)\n",
    "4. Data Type (List, Tuple, Set, Dictionary)\n",
    "5. lambda + comprehension + map,filter,reduce"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f079e41",
   "metadata": {},
   "source": [
    "# Conditional Statement"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d9e0a9d",
   "metadata": {},
   "source": [
    "if the rank is below 20k then Grade is A\n",
    "if the rank is below 30k and above 20k then grade is B\n",
    "if the rank is below 90k and above 30k then grade is C"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a294cf93",
   "metadata": {},
   "source": [
    "if condition:\n",
    "    #code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 209,
   "id": "d1e83ff8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Grade is A\n"
     ]
    }
   ],
   "source": [
    "# Interview Question: What are the conditional statements in Python?\n",
    "# Answer:\n",
    "# Conditional statements in Python allow us to execute different code blocks based on different conditions.\n",
    "# The main conditional statements are: if, elif, and else.\n",
    "# Here's an example:\n",
    "rank = 19000\n",
    "if rank < 20000:\n",
    "    print(\"The Grade is A\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 210,
   "id": "8a5a5613",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "79\n"
     ]
    }
   ],
   "source": [
    "# Interview Question: What is the purpose of the pass statement in Python?\n",
    "# Answer:\n",
    "# The pass statement is a placeholder statement in Python. It is used when a statement is syntactically required but no action is needed.\n",
    "# It allows you to write empty code blocks that can be filled in later.\n",
    "# Here's an example:\n",
    "if rank <= 20000:\n",
    "    pass\n",
    "a = 34\n",
    "b = 45\n",
    "print(a + b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f13acdc0",
   "metadata": {},
   "outputs": [],
   "source": [
    "rank = 25000\n",
    "if rank<20000:\n",
    "    print(\"The Grade is A\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9ca31010",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "rank<20000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "3f45e14d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You are fail\n"
     ]
    }
   ],
   "source": [
    "rank = 25000\n",
    "if rank<20000:\n",
    "    print(\"You are Pass\")\n",
    "else:\n",
    "    print(\"You are fail\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "ea4ce4f4",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Grade is B\n"
     ]
    }
   ],
   "source": [
    "rank = 25000\n",
    "if rank<20000:\n",
    "    print(\"The Grade is A\")\n",
    "elif rank>20000 and rank<30000 :\n",
    "    print(\"The Grade is B\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "0c0fc960",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Grade is A\n"
     ]
    }
   ],
   "source": [
    "# Interview Question: What is the difference between the if statement and the elif statement?\n",
    "# Answer:\n",
    "# The if statement is used to execute a block of code if a condition is true.\n",
    "# The elif statement is short for \"else if\" and is used to check additional conditions after the initial if statement.\n",
    "# If the condition in the if statement is not true, the code inside the elif block will be executed if its condition is true.\n",
    "# Here's an example:\n",
    "rank = 20000\n",
    "if rank <= 20000:\n",
    "    print(\"The Grade is A\")\n",
    "elif rank > 20000 and rank <= 30000:\n",
    "    print(\"The Grade is B\")\n",
    "elif rank > 30000 and rank <= 90000:\n",
    "    print(\"The Grade is C\")\n",
    "else:\n",
    "    print(\"The Grade is not A, B, or C\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "19fe0482",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "even\n"
     ]
    }
   ],
   "source": [
    "num = 0\n",
    "if num>0:\n",
    "    if num%2==0:\n",
    "        print(\"even\")\n",
    "    else:\n",
    "        print(\"odd\")\n",
    "elif num<0:\n",
    "    if num%2==0:\n",
    "        print(\"even\")\n",
    "    else:\n",
    "        print(\"odd\")\n",
    "else:\n",
    "    print(\"even\")\n",
    "    \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "85eabb1d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "79\n"
     ]
    }
   ],
   "source": [
    "if rank<=20000:\n",
    "    pass\n",
    "    \n",
    "a = 34\n",
    "b = 45\n",
    "print(a+b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "fce12736",
   "metadata": {},
   "outputs": [],
   "source": [
    "if rank<=20000:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "b6e262cc",
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1,10):\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "33c6252f",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test():\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "68654b47",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0cf1bca8",
   "metadata": {},
   "source": [
    "# Control Statement"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "b70c634b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1,2,3,4,5,6,7,8,9,10\n",
    "#sum of natural numbers till 1000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "5a4730ac",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1+2+3+4+5+6+7+8+9+10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "be8e1ff8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "print(list(range(1,5)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "424e7a12",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Iteration :  1\n",
      "Iteration :  2\n",
      "Iteration :  3\n",
      "Iteration :  4\n",
      "Iteration :  five\n",
      "Iteration :  6.0\n"
     ]
    }
   ],
   "source": [
    "for num in [1, 2, 3, 4, 'five', 6.0]:\n",
    "    print(\"Iteration : \",num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "97363719",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sum_n + num =  0 + 1\n",
      "sum_n + num =  1 + 2\n",
      "sum_n + num =  3 + 3\n",
      "sum_n + num =  6 + 4\n",
      "sum_n + num =  10 + 5\n",
      "sum_n + num =  15 + 6\n",
      "sum_n + num =  21 + 7\n",
      "sum_n + num =  28 + 8\n",
      "sum_n + num =  36 + 9\n",
      "sum_n + num =  45 + 10\n",
      "Sum of first  10  Natural Number =  55\n"
     ]
    }
   ],
   "source": [
    "n = 10\n",
    "sum_n = 0\n",
    "for num in range(1,n+1):\n",
    "    #num is a temporary variable\n",
    "    #print(\"Iteration = \",num)\n",
    "    #print(\"Previous Sum = \",sum_n)\n",
    "    print(\"sum_n + num = \",sum_n, \"+\", num)\n",
    "    sum_n = sum_n + num\n",
    "    \n",
    "    #print(\"Current Sum = \",sum_n)\n",
    "print(\"Sum of first \", n, \" Natural Number = \", sum_n)\n",
    "    \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce3180a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Infinite loop\n",
    "num = 1\n",
    "while True:\n",
    "    print(num)\n",
    "    num = num + 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "8a4d7d05",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please Enter a Choice to Perform : \n",
      "1. Addition\n",
      "2. Subtraction\n",
      "3. Exit\n",
      "Enter your choice: 6\n"
     ]
    }
   ],
   "source": [
    "loop_continue = True\n",
    "while loop_continue:\n",
    "    print(\"Please Enter a Choice to Perform : \")\n",
    "    print(\"1. Addition\")\n",
    "    print(\"2. Subtraction\")\n",
    "    print(\"3. Exit\")\n",
    "\n",
    "    choice = int(input(\"Enter your choice: \"))\n",
    "\n",
    "    if choice ==1:\n",
    "        a = int(input(\"Enter a first number : \"))\n",
    "        b = int(input(\"Enter a second number : \"))\n",
    "        c = a+b\n",
    "        print(\" The Sum of two numbers you have entered = \", c)\n",
    "\n",
    "    elif choice ==2:\n",
    "        a = int(input(\"Enter a first number : \"))\n",
    "        b = int(input(\"Enter a second number : \"))\n",
    "        c = a-b\n",
    "        print(\" The Subtraction of two numbers you have entered = \", c)\n",
    "\n",
    "    else:\n",
    "        loop_continue = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35f0a95c",
   "metadata": {},
   "outputs": [],
   "source": [
    "1. The for loop is used when the number of iterations is known\n",
    "2. The while loop is used when we dont know the number of iteration"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c7a16be8",
   "metadata": {},
   "source": [
    "### Break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "id": "13a0a2da",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Please Enter a Choice to Perform:\n",
      "1. Addition\n",
      "2. Subtraction\n",
      "3. Exit\n",
      "Enter your choice: 1\n",
      "Enter the first number: 3\n",
      "Enter the second number: 2\n",
      "The sum of the two numbers you have entered is: 5\n",
      "Please Enter a Choice to Perform:\n",
      "1. Addition\n",
      "2. Subtraction\n",
      "3. Exit\n",
      "Enter your choice: 4\n"
     ]
    }
   ],
   "source": [
    "# Interview Question: What is the purpose of the break statement in Python?\n",
    "# Answer:\n",
    "# The break statement is used to exit or terminate a loop prematurely. It is commonly used in loops to stop further iterations when a certain condition is met.\n",
    "# Here's an example:\n",
    "loop_continue = True\n",
    "while loop_continue:\n",
    "    print(\"Please Enter a Choice to Perform:\")\n",
    "    print(\"1. Addition\")\n",
    "    print(\"2. Subtraction\")\n",
    "    print(\"3. Exit\")\n",
    "    choice = int(input(\"Enter your choice: \"))\n",
    "\n",
    "    if choice == 1:\n",
    "        a = int(input(\"Enter the first number: \"))\n",
    "        b = int(input(\"Enter the second number: \"))\n",
    "        c = a + b\n",
    "        print(\"The sum of the two numbers you have entered is:\", c)\n",
    "    elif choice == 2:\n",
    "        a = int(input(\"Enter the first number: \"))\n",
    "        b = int(input(\"Enter the second number: \"))\n",
    "        c = a - b\n",
    "        print(\"The subtraction of the two numbers you have entered is:\", c)\n",
    "    else:\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5c54ef9",
   "metadata": {},
   "source": [
    "### Continue"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "ec91272c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,10):\n",
    "    if i == 3:\n",
    "        break\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 212,
   "id": "aa961acd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# Interview Question: What is the purpose of the continue statement in Python?\n",
    "# Answer:\n",
    "# The continue statement is used to skip the rest of the code within a loop for the current iteration and move to the next iteration.\n",
    "# It is commonly used in loops to bypass certain iterations based on specific conditions.\n",
    "# Here's an example:\n",
    "for i in range(1, 10):\n",
    "    if i == 3:\n",
    "        continue\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "9e6a5827",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,11):\n",
    "    if i % 2 == 0:\n",
    "        continue\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "id": "b6ff6125",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(i, j) =  1 1\n",
      "(i, j) =  1 2\n",
      "(i, j) =  1 3\n",
      "(i, j) =  1 4\n",
      "(i, j) =  2 1\n",
      "(i, j) =  2 2\n",
      "(i, j) =  2 3\n",
      "(i, j) =  2 4\n",
      "(i, j) =  3 1\n",
      "(i, j) =  3 2\n",
      "(i, j) =  3 3\n",
      "(i, j) =  3 4\n",
      "(i, j) =  4 1\n",
      "(i, j) =  4 2\n",
      "(i, j) =  4 3\n",
      "(i, j) =  4 4\n"
     ]
    }
   ],
   "source": [
    "for i in range(1,5):\n",
    "    for j in range(1,5):\n",
    "        print(\"(i, j) = \", i,j)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba316b17",
   "metadata": {},
   "outputs": [],
   "source": [
    "= -> assignment\n",
    "== ->contioning"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7834d21",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "417cda2f",
   "metadata": {},
   "source": [
    "# Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "id": "0124f769",
   "metadata": {},
   "outputs": [],
   "source": [
    "def test():\n",
    "    print(\"test\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "id": "2a5cd3c6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "test\n"
     ]
    }
   ],
   "source": [
    "test()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "id": "0d042661",
   "metadata": {},
   "outputs": [],
   "source": [
    "def add_num(a,b):\n",
    "    sum = a+b\n",
    "    print(\"Addition = \",a+b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "id": "2cd804fb",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Addition =  4\n"
     ]
    }
   ],
   "source": [
    "add_num(3,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "id": "1ea2c550",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "add_num() missing 2 required positional arguments: 'a' and 'b'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/cv/kmsppstx0d9281mtbqrrgl6c0000gn/T/ipykernel_18069/4061970034.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0madd_num\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: add_num() missing 2 required positional arguments: 'a' and 'b'"
     ]
    }
   ],
   "source": [
    "add_num()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "id": "e7089d1d",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Default Variables\n",
    "def add_num_default_variable(a = 21,b = 23):\n",
    "    sum = a+b\n",
    "    print(\"Addition = \",a+b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "04e8337a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Addition =  11\n"
     ]
    }
   ],
   "source": [
    "add_num_default_variable(2,9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "e13c4e62",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Addition =  25\n"
     ]
    }
   ],
   "source": [
    "add_num_default_variable(a = 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "id": "3545a145",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Addition =  25\n"
     ]
    }
   ],
   "source": [
    "add_num_default_variable( 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "id": "a5df9760",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Addition =  23\n"
     ]
    }
   ],
   "source": [
    "add_num_default_variable(b = 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "013cedb2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Addition =  44\n"
     ]
    }
   ],
   "source": [
    "add_num_default_variable()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "f45dbf25",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Addition =  6.0\n"
     ]
    }
   ],
   "source": [
    "add_num_default_variable(2,4.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "3e7bba15",
   "metadata": {},
   "outputs": [],
   "source": [
    "### Arbitary Variables\n",
    "\n",
    "def get_sum(*num):\n",
    "    sum = 0\n",
    "    for n in num:\n",
    "        sum = sum+n\n",
    "    print(\"Total Sum = \", sum)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "b1a99f1f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Sum =  5\n"
     ]
    }
   ],
   "source": [
    "get_sum(2,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "id": "e87a9844",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total Sum =  366\n"
     ]
    }
   ],
   "source": [
    "get_sum(2,3,2,4,5,6,344)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3833a8f",
   "metadata": {},
   "source": [
    "### Scope of Variable\n",
    "1. Local\n",
    "2. Global\n",
    "3. Non Local Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "a453aab2",
   "metadata": {},
   "outputs": [],
   "source": [
    "#1. Local Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "3d72f173",
   "metadata": {},
   "outputs": [],
   "source": [
    "def wishing():\n",
    "    message = 'Hello'\n",
    "    print('Local variable: ', message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "8a048870",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Local variable:  Hello\n"
     ]
    }
   ],
   "source": [
    "wishing()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "e0736b95",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'message' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/cv/kmsppstx0d9281mtbqrrgl6c0000gn/T/ipykernel_18069/3463849412.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmessage\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'message' is not defined"
     ]
    }
   ],
   "source": [
    "print(message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "e24bb372",
   "metadata": {},
   "outputs": [],
   "source": [
    "message = 'Hello'\n",
    "def wishing_modified():\n",
    "    message = 'Hi'\n",
    "    print('Inside Function Global: ', message)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "635d0ff7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inside Function Global:  Hi\n"
     ]
    }
   ],
   "source": [
    "wishing_modified()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "86241e78",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Global :  Hello\n"
     ]
    }
   ],
   "source": [
    "print('Global : ',message)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "id": "f1c1fe4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Interview Question: What is the purpose of a nested function in Python?\n",
    "# Answer:\n",
    "# A nested function is a function defined inside another function. It can access variables from its enclosing function and can be used to perform specific tasks within the scope of the outer function.\n",
    "# Nested functions are commonly used for code organization, encapsulation, and reducing code redundancy.\n",
    "# Here's an example:\n",
    "def outside():\n",
    "    text = 'hello'\n",
    "    print(text)\n",
    "    \n",
    "    def inside():\n",
    "        text = 'hi'\n",
    "        print(text)\n",
    "    inside()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "id": "8b44812c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n",
      "hi\n"
     ]
    }
   ],
   "source": [
    "outside()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "e5a5c57c",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'inside' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/cv/kmsppstx0d9281mtbqrrgl6c0000gn/T/ipykernel_18069/3751132780.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0minside\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'inside' is not defined"
     ]
    }
   ],
   "source": [
    "inside()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b313455f",
   "metadata": {},
   "source": [
    "# Recursive Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "e0debf2b",
   "metadata": {},
   "outputs": [],
   "source": [
    "def sum(x):\n",
    "    sum(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "id": "53b464b3",
   "metadata": {},
   "outputs": [
    {
     "ename": "RecursionError",
     "evalue": "maximum recursion depth exceeded",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mRecursionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/cv/kmsppstx0d9281mtbqrrgl6c0000gn/T/ipykernel_18069/2046539775.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m9\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m/var/folders/cv/kmsppstx0d9281mtbqrrgl6c0000gn/T/ipykernel_18069/411213001.py\u001b[0m in \u001b[0;36msum\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "... last 1 frames repeated, from the frame below ...\n",
      "\u001b[0;32m/var/folders/cv/kmsppstx0d9281mtbqrrgl6c0000gn/T/ipykernel_18069/411213001.py\u001b[0m in \u001b[0;36msum\u001b[0;34m(x)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0msum\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mRecursionError\u001b[0m: maximum recursion depth exceeded"
     ]
    }
   ],
   "source": [
    "sum(9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "bd072ce6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum of first  10  Natural Number =  55\n"
     ]
    }
   ],
   "source": [
    "n = 10\n",
    "sum_n = 0\n",
    "for num in range(1,n+1):\n",
    "    sum_n = sum_n + num\n",
    "print(\"Sum of first \", n, \" Natural Number = \", sum_n)\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "id": "dd47e92a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 215,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "# Interview Question: What is recursion in Python?\n",
    "# Answer:\n",
    "# Recursion is the process in which a function calls itself directly or indirectly. It allows a function to solve a complex problem by breaking it down into smaller sub-problems.\n",
    "# Recursive functions have a base case that determines when the function stops calling itself, and a recursive case that calls the function again with a smaller input.\n",
    "# Here's an example of a recursive function that calculates the sum of the first n natural numbers:\n",
    "def sum_n_natural_num(n):\n",
    "    if n == 1:\n",
    "        return n\n",
    "    else:\n",
    "        return (n + sum_n_natural_num(n-1))\n",
    "\n",
    "sum_n_natural_num(5)  # Output: 15\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c0f12bda",
   "metadata": {},
   "outputs": [],
   "source": [
    "sum_n_natural_num(5)\n",
    "\n",
    "5 + sum_n_natural_num(4)\n",
    "\n",
    "5 + 4 + sum_n_natural_num(3)\n",
    "\n",
    "5 + 4 + 3 + sum_n_natural_num(2)\n",
    "\n",
    "5 + 4 + 3 + 2 + sum_n_natural_num(1)\n",
    "\n",
    "5 + 4 + 3 + 2 + 1 = 15"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "id": "5b4688a3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "else loop :  5\n",
      "else loop :  4\n",
      "else loop :  3\n",
      "else loop :  2\n",
      "if loop :  1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum_n_natural_num(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b3398a7",
   "metadata": {},
   "source": [
    "# Anonymous (Lambda) Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "id": "bbfb226c",
   "metadata": {},
   "outputs": [],
   "source": [
    "greet = lambda : print('hi')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "id": "73005338",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi\n"
     ]
    }
   ],
   "source": [
    "greet()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "id": "2ad529a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "sum = lambda x,y: print(x+y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "id": "fdd10aae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "sum(2,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e807d589",
   "metadata": {},
   "outputs": [],
   "source": [
    "without using a def. can we write a function? yes, using lambda"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "id": "0cc61a0e",
   "metadata": {},
   "outputs": [],
   "source": [
    "greet = lambda x : print('hi, ',x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "id": "85480c50",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi,  batch 21\n"
     ]
    }
   ],
   "source": [
    "greet('batch 21')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 205,
   "id": "57ea176a",
   "metadata": {},
   "outputs": [],
   "source": [
    "sum = lambda *x: print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "id": "ada9884c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 5, 6)\n"
     ]
    }
   ],
   "source": [
    "sum(1,2,3,5,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 216,
   "id": "48af6ac9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hi\n",
      "7\n",
      "hi, batch 21\n",
      "(1, 2, 3, 5, 6)\n"
     ]
    }
   ],
   "source": [
    "# Interview Question: What is an anonymous function (lambda function) in Python?\n",
    "# Answer:\n",
    "# An anonymous function, also known as a lambda function, is a function that is defined without a name. It is used for small, one-time operations and doesn't require the use of the def keyword.\n",
    "# Lambda functions are typically used in combination with built-in functions like map(), filter(), and reduce(), or in situations where a small function is needed as an argument to another function.\n",
    "# Here's an example:\n",
    "greet = lambda: print('hi')\n",
    "greet()  # Output: hi\n",
    "\n",
    "sum = lambda x, y: print(x + y)\n",
    "sum(2, 5)  # Output: 7\n",
    "\n",
    "greet = lambda x: print('hi,', x)\n",
    "greet('batch 21')  # Output: hi, batch 21\n",
    "\n",
    "sum = lambda *x: print(x)\n",
    "sum(1, 2, 3, 5, 6)  # Output: (1, 2, 3, 5, 6)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "617f73c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Package - operation.py - Package.ipynb"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "35d8000e",
   "metadata": {},
   "source": [
    "# Data Type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b526c21c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Interview Question: What are the different data types in Python?\n",
    "# Answer:\n",
    "# Python has several built-in data types, including:\n",
    "# - Lists: Ordered, mutable collections of items.\n",
    "# - Tuples: Ordered, immutable collections of items.\n",
    "# - Sets: Unordered collections of unique items.\n",
    "# - Dictionaries: Unordered collections of key-value pairs.\n",
    "# Here's an example of creating and using these data types:\n",
    "my_list = [1, 2, 3, 4, 5]\n",
    "my_tuple = (1, 2, 3, 4, 5)\n",
    "my_set = {1, 2, 3, 4, 5}\n",
    "my_dict = {'key1': 'value1', 'key2': 'value2'}\n",
    "print(my_list)  # Output: [1, 2, 3, 4, 5]\n",
    "print(my_tuple)  # Output: (1, 2, 3, 4, 5)\n",
    "print(my_set)  # Output: {1, 2, 3, 4, 5}\n",
    "print(my_dict)  # Output: {'key1': 'value1', 'key2': 'value2'}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3a31a512",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b958a488",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ccae76b3",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1fdb67ce",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3337ea68",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6be5e42f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}