Day1_Python_basics-checkpoint.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5077de82",
   "metadata": {},
   "source": [
    "# Session-1: Python basics"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "045ff05c",
   "metadata": {},
   "source": [
    "Functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "e2fb3f2f",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Function performs a particular task\n",
    "# identification ----> function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "965b4085",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world\n"
     ]
    }
   ],
   "source": [
    "print('Hello world')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "02ae472b",
   "metadata": {},
   "source": [
    "Variables"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "6b2797a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Variables are used to store the values\n",
    "# Variables are case sensitive and can be any text with a special character. However, we can oly use '_' as the special charcter.\n",
    "# Variables should always be in the form of text preceding the number and not vice-versa"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "507e91fa",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 12\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "787e1167",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "17e15eae",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "d6c8cccb",
   "metadata": {},
   "outputs": [],
   "source": [
    "d = a+ b\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "8b959809",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "8ea50e4a",
   "metadata": {},
   "outputs": [],
   "source": [
    "D = 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "7c21acc6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "fa61fe7d",
   "metadata": {},
   "outputs": [],
   "source": [
    "a9 = 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "43be03f7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a9\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2a809daf",
   "metadata": {},
   "source": [
    "Data types in Python"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "3d62673c",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Integer ------> int -----------> 1,2,3,4,..\n",
    "#Float ------> float -----------> 1.0, 2.0, 3.5, 4.7....\n",
    "#Boolean ------> bool-----------> True, False\n",
    "#String ------> str ------------> \"abc\",'abc'\n",
    "\n",
    "# Type function : type() returns the data type of the entered input."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "82da4617",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n"
     ]
    }
   ],
   "source": [
    "print(type(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "27e6bb99",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'bool'>\n"
     ]
    }
   ],
   "source": [
    "print(type(True))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "864d6fa7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    }
   ],
   "source": [
    "print(type('abc'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "3fc40c95",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'float'>\n"
     ]
    }
   ],
   "source": [
    "print(type(1.2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0e91952",
   "metadata": {},
   "source": [
    "Sequential Data types"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "518c9e2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# tuple ------> ()\n",
    "# list ------>  []\n",
    "# set ------>   {}\n",
    "# dict ------>  {}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "f42fd419",
   "metadata": {},
   "outputs": [],
   "source": [
    "# List\n",
    "# List can contain any data type as well as another list in itself.\n",
    "mylist = [23, 23.5, \"abc\",[1,2], True]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "0d2bfc71",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[23, 23.5, 'abc', [1, 2], True]\n"
     ]
    }
   ],
   "source": [
    "print(mylist)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5286bcbc",
   "metadata": {},
   "source": [
    "Indexing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "0b1da539",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Indexing can be of 2 type positive and negative indexing.\n",
    "# Positive Indexing in Python starts from 0 (left to right) while negative starts from -1 (right to left)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "d5c3685b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[23, 23.5, 'abc', [1, 2], True]\n"
     ]
    }
   ],
   "source": [
    "print(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "9f12fd36",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abc'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist [2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "b53c4f03",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mylist [3][1]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f92c11c4",
   "metadata": {},
   "source": [
    "Slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "e2da8c9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Slicing is displaying the range of values\n",
    "# For slicing one needs to put the start value and stop +1 value\n",
    "# start: stop +1\n",
    "# Here : represents the range"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "5c2e3be9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[23, 23.5, 'abc']\n"
     ]
    }
   ],
   "source": [
    "print(mylist[0:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "1e0ffd8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[23, 23.5, 'abc'] [1, 2]\n"
     ]
    }
   ],
   "source": [
    "print(mylist[0:3], mylist [3])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b271cac7",
   "metadata": {},
   "source": [
    "Mutable and Immutable "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "f3256e91",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Mutlable objects can be changed ,while immutable are fixed once assigned.\n",
    "# Lists are mutable and Tuple are immutable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "d098e0e2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[23, 23.5, 'abc', [1, 2], True]\n"
     ]
    }
   ],
   "source": [
    "print(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "833eadf8",
   "metadata": {},
   "outputs": [],
   "source": [
    "mylist[0]= 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "b2a1386e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 23.5, 'abc', [1, 2], True]\n"
     ]
    }
   ],
   "source": [
    "print(mylist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "13a8587a",
   "metadata": {},
   "outputs": [],
   "source": [
    "mytuple = (23, 23.5, 'abc', [1, 2], True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "66c9a038",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(23, 23.5, 'abc', [1, 2], True)\n"
     ]
    }
   ],
   "source": [
    "print(mytuple)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "cd50904e",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[40], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m mytupple[\u001b[38;5;241m0\u001b[39m]\u001b[38;5;241m=\u001b[39m \u001b[38;5;241m10\u001b[39m\n",
      "\u001b[1;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "mytuple[0]= 10    #will display an error"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2563416",
   "metadata": {},
   "source": [
    "Sets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "cf51edae",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Sets return only unique values"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "857166c5",
   "metadata": {},
   "outputs": [],
   "source": [
    "d = [1,1,1,2,2,2,3,3,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "0942d7f8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3}"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "76107320",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Conversion of Sets to List "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "31c954f8",
   "metadata": {},
   "outputs": [],
   "source": [
    " e = set(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "f4a1e5d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "f = list(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "7dfc9edf",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "af683fd9",
   "metadata": {},
   "source": [
    "Dictionary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "26d05330",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Dictionary are in the form of key and value\n",
    "mydict = {\"name\":\"Ninad\",\"age\":26,\"place\":\"Mumbai\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "82f14755",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ninad'"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict[\"name\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "9ac413e8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "26"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mydict[\"age\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "3246269e",
   "metadata": {},
   "outputs": [],
   "source": [
    "list2 = [mydict[\"name\"],mydict[\"age\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "2306953a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Ninad', 26]"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "56b3811c",
   "metadata": {},
   "source": [
    "Append, Insert and Length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "df645fcc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Append --------> Appends the value at the end \n",
    "# Insert --------> Insert the value at the sepcified index \n",
    "# Length --------> Returns the length (total no of elements) in the list/tuple/set/dict\n",
    "abc = [1,2,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "56fccbe7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "a525bc8f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(\"abc\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "66e1b1b9",
   "metadata": {},
   "outputs": [],
   "source": [
    "abc.append(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "f5742a9e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4]"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "d626799f",
   "metadata": {},
   "outputs": [],
   "source": [
    "abc.insert(1,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "29eb89ce",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 5, 2, 3, 4]"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abc"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e3220833",
   "metadata": {},
   "source": [
    "if elif & else"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "0f73e891",
   "metadata": {},
   "outputs": [],
   "source": [
    "var = 12"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "149dcec1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "yes\n"
     ]
    }
   ],
   "source": [
    "#While writing if, elif and else we always type ':' after writing if, elif and else and also one has to make sure\n",
    "#to keep the induntation (space)\n",
    "if var > 13:\n",
    "    print('Hello!')   \n",
    "elif var == 12:\n",
    "        print('yes')\n",
    "else:\n",
    "        print('bye')\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "95227947",
   "metadata": {},
   "source": [
    "input function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "ef9645ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "#input function will ask the user to input a value\n",
    "#However, since input function is by default a string data-type we have to make sure to use the desire data type before it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "2472818b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter 1st no: 10\n",
      "Enter 2nd no: 20\n"
     ]
    }
   ],
   "source": [
    "a = int(input(\"Enter 1st no: \"))\n",
    "b = int(input(\"Enter 2nd no: \"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "e7ee604b",
   "metadata": {},
   "outputs": [],
   "source": [
    "c = a+b "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "63b1db48",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "id": "40d84aee",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Question: \n",
    "# Assign grades as per the criteria"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "id": "06bf0c5a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter your marks: 101\n"
     ]
    }
   ],
   "source": [
    "inputMarks= int(input(\"Enter your marks: \"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "id": "2b4bb4fa",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Invalid marks\n"
     ]
    }
   ],
   "source": [
    "\n",
    "if inputMarks >= 75 and inputMarks <= 100 :\n",
    "    print('Grade A')   \n",
    "elif inputMarks >= 50 and inputMarks < 75:\n",
    "    print('Grade B')\n",
    "elif inputMarks >= 35 and inputMarks < 50:\n",
    "    print('Grade C')\n",
    "elif inputMarks >= 0 and inputMarks < 35:\n",
    "    print('Fail')\n",
    "else:\n",
    "    print('Invalid marks')\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c4bddc33",
   "metadata": {},
   "source": [
    "for loop"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "id": "d88a9dd1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range(0,10):\n",
    "    print(i)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "d37aba68",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 * 1 = 2\n",
      "2 * 2 = 4\n",
      "2 * 3 = 6\n",
      "2 * 4 = 8\n",
      "2 * 5 = 10\n",
      "2 * 6 = 12\n",
      "2 * 7 = 14\n",
      "2 * 8 = 16\n",
      "2 * 9 = 18\n",
      "2 * 10 = 20\n"
     ]
    }
   ],
   "source": [
    "#print the table of 2 using for loop\n",
    "\n",
    "for i in range(1,11):\n",
    "\n",
    "    print(\"2\",\"*\",i,\"=\",2*i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "5a4b17d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Seggreggate the following my_list into different data types\n",
    "\n",
    "my_list= [23, 'hello','hi',45.9,'bye',12,76,'zero',0,99,[23,'one',12.7],77,11,(6,2,0),11.0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "2a1fea66",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[23,\n",
       " 'hello',\n",
       " 'hi',\n",
       " 45.9,\n",
       " 'bye',\n",
       " 12,\n",
       " 76,\n",
       " 'zero',\n",
       " 0,\n",
       " 99,\n",
       " [23, 'one', 12.7],\n",
       " 77,\n",
       " 11,\n",
       " (6, 2, 0),\n",
       " 11.0]"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "2a79406f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[23, 12, 76, 0, 99, 77, 11]\n",
      "['hello', 'hi', 'bye', 'zero']\n",
      "[45.9, 11.0]\n",
      "[(6, 2, 0)]\n",
      "[[23, 'one', 12.7]]\n"
     ]
    }
   ],
   "source": [
    "list_of_integers1=[]\n",
    "list_of_string1=[]\n",
    "list_of_float1=[]\n",
    "list_of_tuple1=[]\n",
    "list_of_list1=[]\n",
    "\n",
    "for i in my_list:\n",
    "    if type(i)==int:\n",
    "        list_of_integers1.append(i)\n",
    "    elif type(i)==str:\n",
    "        list_of_string1.append(i)\n",
    "    elif type(i)==float:\n",
    "        list_of_float1.append(i)\n",
    "    elif type(i)==tuple:\n",
    "        list_of_tuple1.append(i)\n",
    "    elif type(i)==list:\n",
    "        list_of_list1.append(i)\n",
    "        \n",
    "print(list_of_integers1)\n",
    "print(list_of_string1)\n",
    "print(list_of_float1)\n",
    "print(list_of_tuple1)\n",
    "print(list_of_list1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8d36ebc",
   "metadata": {},
   "source": [
    "Defining a Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f85e7334",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining a function with no argument.\n",
    "# Function can be called separtely to reduce the line of codes.\n",
    "\n",
    "#Single argument\n",
    "def myfunction():\n",
    "    a= 10*10\n",
    "    return a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "c9caffd3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfunction()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "471698aa",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining a function with a single argument.\n",
    "\n",
    "#Single argument\n",
    "def myfunction(no1):\n",
    "    a= no1*10\n",
    "    return a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "5b6c563c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfunction(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "7fc620e5",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Defining a function with multiple arguments.\n",
    "\n",
    "#Single argument\n",
    "def myfunction(no1,no2):\n",
    "    a= no1*no2\n",
    "    return a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "1c449d8a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "myfunction(2,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c004bdd",
   "metadata": {},
   "source": [
    "Task: Return a table for the value inputed by user "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "d1f6545e",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Return a table for the value inputed by user\n",
    "\n",
    "def gettable(number1):\n",
    "    for i in range(1,11):\n",
    "        print(number1,\"*\",i,\"=\",number1*i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "6aeaa930",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3 * 1 = 3\n",
      "3 * 2 = 6\n",
      "3 * 3 = 9\n",
      "3 * 4 = 12\n",
      "3 * 5 = 15\n",
      "3 * 6 = 18\n",
      "3 * 7 = 21\n",
      "3 * 8 = 24\n",
      "3 * 9 = 27\n",
      "3 * 10 = 30\n"
     ]
    }
   ],
   "source": [
    "gettable(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "6f7da393",
   "metadata": {},
   "outputs": [],
   "source": [
    "#Return a table for the value inputed by user by using append function.\n",
    "\n",
    "def gettable(number1):\n",
    "    out=[]\n",
    "    for i in range(1,11):\n",
    "        a = number1,\"*\",i,\"=\",number1*i\n",
    "        out.append(a)\n",
    "    return out \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "f79476d8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(3, '*', 1, '=', 3),\n",
       " (3, '*', 2, '=', 6),\n",
       " (3, '*', 3, '=', 9),\n",
       " (3, '*', 4, '=', 12),\n",
       " (3, '*', 5, '=', 15),\n",
       " (3, '*', 6, '=', 18),\n",
       " (3, '*', 7, '=', 21),\n",
       " (3, '*', 8, '=', 24),\n",
       " (3, '*', 9, '=', 27),\n",
       " (3, '*', 10, '=', 30)]"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gettable(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd9f0828",
   "metadata": {},
   "source": [
    "Try and except block"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "2318be18",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Try and except block is used for eliminating errors\n",
    "\n",
    "def gettable(number):\n",
    "    try:\n",
    "        out=()\n",
    "        for i in range(1,11):\n",
    "            a=number,\"*\",i,\"=\",i*number\n",
    "            out.append(a)\n",
    "        return out\n",
    "    except:\n",
    "        print(\"error in gettable fn!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "30c8aa24",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "error in gettable fn!\n"
     ]
    }
   ],
   "source": [
    "gettable(\"65\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2bbdff4d",
   "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}