conditional statement - if , elif, else.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d7af73d2",
   "metadata": {},
   "source": [
    "## Conditional Statement- if, elif, else"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9a248916",
   "metadata": {},
   "source": [
    "The if statement checks if condition_1 is true. If it is, the code block indented under if is executed, and then the program moves on.\n",
    "\n",
    "If condition_1 is false, the program checks the next condition, condition_2, after the elif keyword. If condition_2 is true, the code block under elif is executed.\n",
    "\n",
    "If none of the conditions specified in the if and elif statements are true, the code block under the else statement is executed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "47dfa61c",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10 \n",
    "if a == 11 :\n",
    "    print(\"this is my first condition\")\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "9088d5af",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "if a >5 :\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "f756b59e",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10 \n",
    "if a <8:\n",
    "    print(\"print this if condition is true \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "5e2b1a15",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "print this \n"
     ]
    }
   ],
   "source": [
    "a = 10\n",
    "if a == 11:\n",
    "    print(\"my condition is false\")\n",
    "else :\n",
    "    print(\"print this \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "7b2c470f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "we are trying to compare 10 with 11\n"
     ]
    }
   ],
   "source": [
    "a = 10 \n",
    "if a == 12 :\n",
    "    print(\"here we are trying to compare 10 with 12\")\n",
    "elif a ==10:\n",
    "    print(\"we are trying to compare 10 with 11\")\n",
    "else :\n",
    "    print(\"if all the blocks wil fail then do this \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d0aa62b1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "for sure i will be able to buy\n"
     ]
    }
   ],
   "source": [
    "price = 500\n",
    "\n",
    "if price > 500 : \n",
    "    print(\" may b i wont be able to buy a jacket \")\n",
    "elif price < 500 :\n",
    "    print(\"i will be able to buy a jacket\")\n",
    "elif  price == 500 :\n",
    "    print(\"for sure i will be able to buy\")\n",
    "\n",
    "else  :\n",
    "    print(\"i dont know\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "8f8b1ea6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "price > 500"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "79ceb39a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "price < 500"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "2a9c47d8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    " price == 500"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "23412b8d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [1,2,3,4,5,6]\n",
    "2 in l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "8f80888e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "do not perform this task\n"
     ]
    }
   ],
   "source": [
    "if 60 in l :\n",
    "    print(\"try to perform a task \")\n",
    "else :\n",
    "    print(\"do not perform this task\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "ba394a08",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "60 in l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "63a6b617",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "30e9871c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "try to do sub\n",
      "this is new statement\n"
     ]
    }
   ],
   "source": [
    "if 10 in l :\n",
    "    print(\"thy to do a addition\")\n",
    "elif 2 in l :\n",
    "    print(\"try to do sub\")\n",
    "elif 3 in l :\n",
    "    print(\"try to do mul\")\n",
    "if 4 in l :\n",
    "    print(\"this is new statement\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "0e9b3997",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 400"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "4f5bc1f8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "200\n",
      "i will be able to buy something\n",
      "i will be able to buy a jacket\n"
     ]
    }
   ],
   "source": [
    "price  = int(input())\n",
    "if price  <500 :\n",
    "    print(\"i will be able to buy something\")\n",
    "    if price < 400 :\n",
    "        print(\"i will be able to buy a jacket\")\n",
    "    elif price < 300 :\n",
    "        \n",
    "        print(\"i will be able to buy a shirt\")\n",
    "        if price < 200 :\n",
    "            print(\"i would like to do sometign\")\n",
    "    else :\n",
    "        print(\"i wont be able to buy anyting\")\n",
    "else :\n",
    "     print(\"i wont be able to buy anything with this price tag\")\n",
    "     if price >500:\n",
    "        print(\"lets try someting else \")\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "f7031d13",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "500\n",
      "NO GRE\n",
      "YOU GOT TOFEL\n"
     ]
    }
   ],
   "source": [
    "marks = int(input())\n",
    "if marks < 600:\n",
    "    print(\"NO GRE\")\n",
    "    if marks < 500:\n",
    "        print(\"TOFEL\")\n",
    "        if marks < 400:\n",
    "            print(\"Try something else\")\n",
    "    else:\n",
    "        print(\"YOU GOT TOFEL\")\n",
    "else:\n",
    "    print(\"You got GRE congratulations\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "6b31a639",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter a floating point number3.6\n",
      "enter value is a positive number \n"
     ]
    }
   ],
   "source": [
    "val  = float(input(\"enter a floating point number\"))\n",
    "if val >= 0 :\n",
    "    if val == 0 :\n",
    "        print(\"entered value is zero\")\n",
    "    else :\n",
    "        print(\"enter value is a positive number \")\n",
    "else :\n",
    "    print(\"entered number is a negative number\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "9e261669",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10\n",
    "if a <10  and a == 10 :\n",
    "    print(\"try to do someting \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "23f3aa02",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is tejal \n"
     ]
    }
   ],
   "source": [
    "a = \"tejal\"\n",
    "if a == \"tejal\" or a == \"tejal\":\n",
    "    print(\"this is tejal \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "6e41c137",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lets do something\n"
     ]
    }
   ],
   "source": [
    "a = 10 \n",
    "b = 11\n",
    "c = 12\n",
    "d = 13\n",
    "if a == 9 or b == 11 and c == 12 and d ==13:\n",
    "    print(\"lets do something\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "20851960",
   "metadata": {},
   "outputs": [],
   "source": [
    "d = {'key1' :\"value\" , \"key2\" : \"tejal\" , \"key3\" : \"Ram\"}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "586a90dd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "all the values are not verified \n"
     ]
    }
   ],
   "source": [
    "if d['key1'] == \"value\" and d['key2'] == \"Sudh\" and d['key3'] == \"iNeuron\":\n",
    "    print(\"all the values are verified \")\n",
    "    print(d.values())\n",
    "else :\n",
    "    print(\"all the values are not verified \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "21d5b430",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'value'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d['key1']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "6ca58f68",
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1,2,3,4,5,\"tejal\" ,234.45]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "285d674b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "9791ed15",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "2fc100d6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[3, 4, 5]"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[2:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "c313e85b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 'tejal', 234.45]"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "99abff74",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "tejal1\n",
      "235.45\n"
     ]
    }
   ],
   "source": [
    "for i in l :\n",
    "    if type(i) == int or type(i) == float:\n",
    "        print(i+1)\n",
    "    elif type(i) == str:\n",
    "        print(i + str(1))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "fce2335c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 'tejal', 234.45]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "069178b9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "9 8 7 6 5 4 3 2 10 "
     ]
    }
   ],
   "source": [
    "a=[9, 8,7,6,5,4,3,2,10]\n",
    "for i in a :\n",
    "       print(i ,end=' ') "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "11384ca8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 'tejal', 234.45]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "0e1189d5",
   "metadata": {},
   "outputs": [],
   "source": [
    "l1 = []\n",
    "for i in l :\n",
    "    if type(i) == int:\n",
    "        l1.append(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "967b977d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "b26dd08c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "tejal1\n",
      "235.45\n"
     ]
    }
   ],
   "source": [
    "for a in l:\n",
    "    if type(a)==int:\n",
    "        print(a+1)\n",
    "    elif type(a)==str:\n",
    "        print(a+str(1))\n",
    "    elif type(a)==float:\n",
    "        print(a+float(1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "a41b4b76",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "tejal1\n",
      "235.45\n"
     ]
    }
   ],
   "source": [
    "for i in l:\n",
    "    if type(i)==int  or type(i) == float:\n",
    "        print(i+1)\n",
    "    elif type(i)== str:    \n",
    "        print(i+ str(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "798e773e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "tejal1\n",
      "235.45\n"
     ]
    }
   ],
   "source": [
    "for i in l :\n",
    "    if type(i) ==  int or type(i) == float :\n",
    "        print(i+1) \n",
    "    elif type(i) == str:\n",
    "        print(i + str(1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "a0160cb1",
   "metadata": {},
   "outputs": [],
   "source": [
    "if d['key1']==\"value\" and d['key2']==\"amrit\" and d['key3']==\"ineuron\":\n",
    "    print (\"all the values aree verified\")\n",
    "    print(d.value())\n",
    "if d['key1']==\"value\" and d['key2']==\"amrit\" and d['key3']==\"ineuron\":\n",
    "    print (\"all the values aree verified\")\n",
    "    print(d.value())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "0d71843b",
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1,2,3,4,5465,67,\"tejal\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "bdea9014",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tejal\n"
     ]
    }
   ],
   "source": [
    "for i in l:\n",
    "    if type(i)==str:\n",
    "        if i=='d':\n",
    "            break\n",
    "        print(i)\n",
    "        \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "a7cf2d57",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "CK1\n",
      "2021.12\n"
     ]
    }
   ],
   "source": [
    "l = [1,2,3,4,'CK',2020.12]\n",
    "for i in l:\n",
    "    if type(i) == int :\n",
    "        print(i+1)\n",
    "    elif type(i) == str:\n",
    "        print(i +str(1))\n",
    "    elif type(i) == float:\n",
    "        print(i + float(1))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "1a88035f",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 10 \n",
    "if a < 8 :\n",
    "    print(\"print this if condition is true\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "7070f802",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "lets do something 1\n",
      "lets do something 2\n",
      "lets do something 3\n",
      "lets do something 4\n",
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a,b,c,d=10,11,12,13\n",
    "####### Question 01 #######\n",
    "if a==10 or b==11 and c==12 and d==113: #### Case 1\n",
    "    # this is equal to a==10 or (b==11 and c==12 and d==113)\n",
    "    print('lets do something 1')\n",
    "if (a==10 and b==11 ) or (c==12 and d==113):  #### Case 2\n",
    "    # this is equal to (a==10 and b==11) or (c==12 and d==113)\n",
    "    print('lets do something 2')\n",
    "if a==10 and b==11 and c==12 and d==13 or a==9:   #### Case 3\n",
    "    # this is equal to (a==10 and b==11 and c==12 and d==13) or a==9\n",
    "    print('lets do something 3')\n",
    "if a==9 or b==11 and c==12 and d==13:   #### Case 4\n",
    "    print('lets do something 4')\n",
    "############# Question 2 #########\n",
    "# What is the difference between:\n",
    "print(type(a) == int)\n",
    "print(type(a) is int)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "34869cb8",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "type(a) == int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "f4b5557e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "bc6630c1",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a) is int"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "1b89edf9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "We have an active alarm Number: 1324\n",
      "No alarm\n"
     ]
    }
   ],
   "source": [
    "l = [0,0,0,0,0,0,0,1324,0,0,0,0,0]\n",
    "\n",
    "for i in l:\n",
    "    if i > 0 :\n",
    "        print(\"We have an active alarm Number:\",i)         \n",
    "else:\n",
    "    print (\"No alarm\")\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "f44e49f3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5]\n"
     ]
    }
   ],
   "source": [
    "l=[1,2,3,4,5,\"tejal\",234.45]\n",
    "\n",
    "a=0\n",
    "l1=[]\n",
    "for i in l:\n",
    "    if type(i) == int:\n",
    "          l1 = l1 + [i]\n",
    "print(l1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "bbd7dd2c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "f1f30ae2",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "tejal1\n",
      "235.45\n"
     ]
    }
   ],
   "source": [
    "for i in l :\n",
    "    if type(i) == int or type(i) == float :\n",
    "        print(i+1)\n",
    "    elif type(i) == str :\n",
    "        print(i + str(1))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "93502c1f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "4\n",
      "5\n",
      "6\n",
      "tejal1\n",
      "235.45\n"
     ]
    }
   ],
   "source": [
    "for i in l :\n",
    "    if type(i) == int or type(i) == float :\n",
    "        print(i+1)\n",
    "    elif type(i) == str :\n",
    "        print(i+ str(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "5340a491",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enter an integer11111\n",
      "I can buy 2 pairs\n"
     ]
    }
   ],
   "source": [
    "price = int(input(\"enter an integer\"))\n",
    "if price < 5000 :\n",
    "    print(\"I can buy a Jacket\")\n",
    "elif price > 5000 and price <= 10000 :\n",
    "    print(\"I can buy a shirt and Jacket\")\n",
    "elif price > 10000 :\n",
    "    print(\"I can buy 2 pairs\")\n",
    "else :\n",
    "    print(\"leave it\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "2d5cf857",
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2, 56, 43], ['sad', 'sad', 234, 'forty', 'rest', 734], [12, 39, 67], [(2-8j), 3.065, 7, 'tinku'], 'welcome'] \n",
      "\n",
      "Q1\n",
      "Sublist : ['sad', 'sad', 234, 'forty', 'rest', 734] \n",
      " index=  0 , value =  sad \n",
      "\n",
      "Sublist : ['sad', 'sad', 234, 'forty', 'rest', 734] \n",
      " index=  1 , value =  sad \n",
      "\n",
      "Sublist : ['sad', 'sad', 234, 'forty', 'rest', 734] \n",
      " index=  3 , value =  forty \n",
      "\n",
      "Sublist : ['sad', 'sad', 234, 'forty', 'rest', 734] \n",
      " index=  4 , value =  rest \n",
      "\n",
      "Sublist : [(2-8j), 3.065, 7, 'tinku'] \n",
      " index=  3 , value =  tinku \n",
      "\n",
      "[[2, 56, 43], ['sad', 'sad', 234, 'forty', 'rest', 734], [12, 39, 67], [(2-8j), 3.065, 7, 'tinku'], 'welcome'] \n",
      "\n",
      "Q2\n",
      "final list after removing all str in nested list: [[2, 56, 43], [' ', ' ', 234, ' ', ' ', 734], [12, 39, 67], [(2-8j), 3.065, 7, ' '], 'welcome']\n"
     ]
    }
   ],
   "source": [
    "l=[[2,56,43],['sad','sad',234,'forty','rest',734],[2-8j,3.065,7,'tinku'],'welcome']\n",
    "l.insert(2,[12,39,67])\n",
    "\n",
    "print(l,'\\n')\n",
    "print('Q1')\n",
    "for i in l :\n",
    "    if type(i) == list :\n",
    "        \n",
    "        for j in range(len(i)) :\n",
    "            if type(i[j]) == str :\n",
    "                print('Sublist :',i,'\\n','index= ',j,', value = ',i[j],'\\n')\n",
    "                \n",
    "print(l,'\\n' )\n",
    "print('Q2')\n",
    "for i in l :\n",
    "    if type(i) == list :\n",
    "        for j in range(len(i)) :\n",
    "            if type(i[j]) == str :\n",
    "                i[j]=' '\n",
    "                \n",
    "                \n",
    "print('final list after removing all str in nested list:',l)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "fa88e0ff",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Type 1 for monthly calendar or Type 2 for yearly calendar2\n",
      "Enter the Year: 2001\n",
      "    January 2001\n",
      "Mo Tu We Th Fr Sa Su\n",
      " 1  2  3  4  5  6  7\n",
      " 8  9 10 11 12 13 14\n",
      "15 16 17 18 19 20 21\n",
      "22 23 24 25 26 27 28\n",
      "29 30 31\n",
      "\n",
      "   February 2001\n",
      "Mo Tu We Th Fr Sa Su\n",
      "          1  2  3  4\n",
      " 5  6  7  8  9 10 11\n",
      "12 13 14 15 16 17 18\n",
      "19 20 21 22 23 24 25\n",
      "26 27 28\n",
      "\n",
      "     March 2001\n",
      "Mo Tu We Th Fr Sa Su\n",
      "          1  2  3  4\n",
      " 5  6  7  8  9 10 11\n",
      "12 13 14 15 16 17 18\n",
      "19 20 21 22 23 24 25\n",
      "26 27 28 29 30 31\n",
      "\n",
      "     April 2001\n",
      "Mo Tu We Th Fr Sa Su\n",
      "                   1\n",
      " 2  3  4  5  6  7  8\n",
      " 9 10 11 12 13 14 15\n",
      "16 17 18 19 20 21 22\n",
      "23 24 25 26 27 28 29\n",
      "30\n",
      "\n",
      "      May 2001\n",
      "Mo Tu We Th Fr Sa Su\n",
      "    1  2  3  4  5  6\n",
      " 7  8  9 10 11 12 13\n",
      "14 15 16 17 18 19 20\n",
      "21 22 23 24 25 26 27\n",
      "28 29 30 31\n",
      "\n",
      "     June 2001\n",
      "Mo Tu We Th Fr Sa Su\n",
      "             1  2  3\n",
      " 4  5  6  7  8  9 10\n",
      "11 12 13 14 15 16 17\n",
      "18 19 20 21 22 23 24\n",
      "25 26 27 28 29 30\n",
      "\n",
      "     July 2001\n",
      "Mo Tu We Th Fr Sa Su\n",
      "                   1\n",
      " 2  3  4  5  6  7  8\n",
      " 9 10 11 12 13 14 15\n",
      "16 17 18 19 20 21 22\n",
      "23 24 25 26 27 28 29\n",
      "30 31\n",
      "\n",
      "    August 2001\n",
      "Mo Tu We Th Fr Sa Su\n",
      "       1  2  3  4  5\n",
      " 6  7  8  9 10 11 12\n",
      "13 14 15 16 17 18 19\n",
      "20 21 22 23 24 25 26\n",
      "27 28 29 30 31\n",
      "\n",
      "   September 2001\n",
      "Mo Tu We Th Fr Sa Su\n",
      "                1  2\n",
      " 3  4  5  6  7  8  9\n",
      "10 11 12 13 14 15 16\n",
      "17 18 19 20 21 22 23\n",
      "24 25 26 27 28 29 30\n",
      "\n",
      "    October 2001\n",
      "Mo Tu We Th Fr Sa Su\n",
      " 1  2  3  4  5  6  7\n",
      " 8  9 10 11 12 13 14\n",
      "15 16 17 18 19 20 21\n",
      "22 23 24 25 26 27 28\n",
      "29 30 31\n",
      "\n",
      "   November 2001\n",
      "Mo Tu We Th Fr Sa Su\n",
      "          1  2  3  4\n",
      " 5  6  7  8  9 10 11\n",
      "12 13 14 15 16 17 18\n",
      "19 20 21 22 23 24 25\n",
      "26 27 28 29 30\n",
      "\n",
      "   December 2001\n",
      "Mo Tu We Th Fr Sa Su\n",
      "                1  2\n",
      " 3  4  5  6  7  8  9\n",
      "10 11 12 13 14 15 16\n",
      "17 18 19 20 21 22 23\n",
      "24 25 26 27 28 29 30\n",
      "31\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#3. Write a Python program to display calendar?\n",
    "\n",
    "import calendar\n",
    "n=int(input('Type 1 for monthly calendar or Type 2 for yearly calendar'))\n",
    "\n",
    "if n==1 :\n",
    "    yy=int(input('Enter the Year: '))\n",
    "    mm=int(input('Enter the month number: '))\n",
    "    print(calendar.month(yy,mm))\n",
    "elif n==2:\n",
    "    yy=int(input('Enter the Year: '))\n",
    "    for m in range(1,13):\n",
    "        print(calendar.month(yy,m))\n",
    "        \n",
    "#Doubt: Can i change the layout of the o/p?for example, 3 months in a row\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "18093c87",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "550\n",
      "I am pass in TOFEL\n"
     ]
    }
   ],
   "source": [
    "Marks = int(input())\n",
    "if Marks > 600 :\n",
    "    print(\"I am pass in GRE\")\n",
    "elif Marks<600 or Marks>=500:\n",
    "        print(\"I am pass in TOFEL\")\n",
    "elif Marks<=500 or Marks>=400:\n",
    "        print(\"I am pass in Python\")\n",
    "else :\n",
    "    print(\"please try further examination\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "a3fb481d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "350\n",
      "No Gre admission\n",
      "TOEFL\n"
     ]
    }
   ],
   "source": [
    "marks = int(input())\n",
    "\n",
    "if marks < 600:\n",
    "    print('No Gre admission')\n",
    "    if marks < 500:\n",
    "        print('TOEFL')\n",
    "    elif marks < 400:\n",
    "        print('try something else')\n",
    "    else:\n",
    "        print('got ')\n",
    "else:\n",
    "    print('gre admission')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "a34e33f7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'sudh'"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l = [3,4,5,6,7 , [23,456,67,8,78,78] , [345,56,87,8,98,9] , (234,6657,6) , {\"key1\" :\"sudh\" , 234:[23,45,656]}]\n",
    "\n",
    "l[-1]['key1']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "5dfde019",
   "metadata": {},
   "outputs": [],
   "source": [
    "l=[1,2,3,4,5,\"sudh\",23.55]\n",
    "l1 = []\n",
    "for i in l:\n",
    "    if type(i)==int:\n",
    "        l1.append(i)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "a8839538",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "5a91c392",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "nothing \n"
     ]
    }
   ],
   "source": [
    "a=10\n",
    "b=11\n",
    "c=12\n",
    "d=12\n",
    "if a==9 or (b==11 and c==12 and d==13):\n",
    "    print(\"lets do something\")\n",
    "else :\n",
    "    print(\"nothing \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "6ae5304a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "all the values are verified\n",
      "dict_values(['value', 'sudh', 'ineuron'])\n"
     ]
    }
   ],
   "source": [
    "d ={\"key1\": \"value\", \"key2\":\"sudh\",\"key3\":\"ineuron\"}\n",
    "if d['key1'] == \"value\" and d['key2'] == \"sudh\" and d['key3'] == \"ineuron\":\n",
    "    print(\"all the values are verified\")\n",
    "    print(d.values())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "04a5fa63",
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [{'key1': 'sudh', 234: [23, 45, 656]},\n",
    " (234, 6657, 6),\n",
    " [345, 56, 87, 8, 98, 9],\n",
    " [23, 456, 67, 8, 78, 78],\n",
    " 7,\n",
    " 6,\n",
    " 5,\n",
    " 4,\n",
    " 3]\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "cea00d22",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['key1', 234]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(l[0].keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "ed55bf61",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['key1', 234]\n"
     ]
    }
   ],
   "source": [
    "for i in l :\n",
    "    if type(i) == dict :\n",
    "        print(list(i.keys()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "06c18e15",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The original list : [3, 5, 6, 8, 10]\n",
      "The list of missing elements : [0, 1, 2, 4, 7, 9]\n"
     ]
    }
   ],
   "source": [
    "test_list = [3, 5, 6, 8, 10]\n",
    "  \n",
    "# printing original list\n",
    "print(\"The original list : \" + str(test_list))\n",
    "  \n",
    "# using list comprehension\n",
    "# Finding missing elements in List\n",
    "res = [ele for ele in range(max(test_list)+1) if ele not in test_list]\n",
    "  \n",
    "# print result\n",
    "print(\"The list of missing elements : \" + str(res))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "37097b11",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values(['surendra', 'sudh', 'ineuron'])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d={'key1':\"surendra\", 'key2':\"sudh\", 'key3':\"ineuron\"}\n",
    "\n",
    "d.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "19241af3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "450\n",
      "i will be able to buy somthing\n",
      "i wont be able to buy anything\n"
     ]
    }
   ],
   "source": [
    "price = int(input())\n",
    "if price < 500:\n",
    "    print(\"i will be able to buy somthing\")\n",
    "    if price < 300 :\n",
    "        print(\"i will be able to buy a shirt\")    \n",
    "    elif price < 400 :\n",
    "        print(\"i will be able to buy a jacket\")\n",
    "        if price < 200 :\n",
    "            print(\"i would like to do somthig\")\n",
    "    else :\n",
    "        print(\"i wont be able to buy anything\")\n",
    "else :\n",
    "    print(\"i wont be able to buy anything with this price tag\")\n",
    "    if price > 500:\n",
    "        print(\"lets try something else\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "6192a456",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "450\n",
      "no GRE\n",
      "ToFEl\n"
     ]
    }
   ],
   "source": [
    "marks=int(input())\n",
    "if marks>600:\n",
    "    print('i would get admission in GRE')\n",
    "elif marks< 600:\n",
    "    print(\"no GRE\")\n",
    "    if marks< 500:\n",
    "        print(\"ToFEl\")\n",
    "    elif marks<400:\n",
    "        print(\"try something else\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "98e4de1c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " this is Tejal\n"
     ]
    }
   ],
   "source": [
    "a = \"Tejal\"\n",
    "if a == \"Tejal\" or a == \"Tejal\":\n",
    "    print (\" this is Tejal\")\n",
    "else:\n",
    "    print (\"nothing\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "f6463972",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "int\n",
      "invalid\n"
     ]
    }
   ],
   "source": [
    "i = int(input())\n",
    "if type(i) == int : \n",
    "    print(\"int\")\n",
    "if type(i) == float : \n",
    "    print(\"float\") \n",
    "else :\n",
    "    print (\"invalid\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "id": "53bb9f30",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "450\n",
      " you can use metro train service\n"
     ]
    }
   ],
   "source": [
    "travel_allowance=int(input()) \n",
    "if travel_allowance>1000 :\n",
    "    print (\"you can use petrol cab\")\n",
    "elif travel_allowance < 500 :\n",
    "    print (\" you can use metro train service\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "id": "9b6fb245",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter the marks  580\n",
      "no gre\n"
     ]
    }
   ],
   "source": [
    "x=int(input(\"Enter the marks  \"))\n",
    "if x<600:\n",
    "    print(\"no gre\")\n",
    "elif x<500 or x>400:\n",
    "    print(\"tofel\")\n",
    "elif x<400:\n",
    "    print(\"try something else\")\n",
    "else:\n",
    "    print(\"you got tofel\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "id": "288d6b51",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 100\n",
    "y = 100\n",
    "x is y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "id": "aa83d17e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z = 1000\n",
    "m = 1000\n",
    "m is z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "id": "2483e019",
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1,2,3,4,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "id": "37631f96",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "id": "82271ffd",
   "metadata": {},
   "outputs": [],
   "source": [
    "t = (\"a\", 658, \"sudh\", 23.45) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "id": "81074838",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Enter a floating point number 3.6\n",
      "Entered values is positive number\n"
     ]
    }
   ],
   "source": [
    "val = float(input(\"Enter a floating point number \"))\n",
    "\n",
    "if val >=0:\n",
    "    if val ==0:\n",
    "        print(\"Entered value is zero\")\n",
    "    elif val < 0:\n",
    "        print(\"Number is smaller than zero\")\n",
    "    else:\n",
    "        print(\"Entered values is positive number\")\n",
    "else:\n",
    "    print(\"None\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "1ecd3b09",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sum 500\n"
     ]
    }
   ],
   "source": [
    "d = {\"a\":200,\"b\":300}\n",
    "s =sum(d.values())\n",
    "print(\"sum\",s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "195c295c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "this is an interger\n"
     ]
    }
   ],
   "source": [
    "def number(i):\n",
    "    if type(i) == int:\n",
    "        print(\"this is an interger\")\n",
    "    elif type(i) == float:\n",
    "        print(\"this is a float\")\n",
    "    else:\n",
    "        print(\"Invalid\")\n",
    "\n",
    "number(5)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "id": "9a7f00ec",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "460\n",
      "Didn't clear Gre\n",
      "Tofel\n"
     ]
    }
   ],
   "source": [
    "\n",
    "m=int(input())\n",
    "if m>600:\n",
    "    print(\"I will be able to clear Gre\")\n",
    "elif m<=600:\n",
    "    print(\"Didn't clear Gre\")\n",
    "    if m<500 and m>=400:\n",
    "        print(\"Tofel\")\n",
    "    elif m<400:\n",
    "        print(\"try something else\")\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "366ea14a",
   "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.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}