Sec V Video 37 Useful Operators.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Built - in operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# range Operator - it gives a range of numbers (Using 'for loop' method)\n",
    "\n",
    "for diff_nums in range(5):\n",
    "    print(diff_nums)\n",
    "# it gives int upto 5 but not 5. Also it automatically starts from 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "# It can also have a starting point and ending point \n",
    "\n",
    "for nums in range(5, 10):\n",
    "    print(nums)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "10\n",
      "15\n",
      "20\n",
      "25\n"
     ]
    }
   ],
   "source": [
    "# It can also have a skipping number \n",
    "\n",
    "for characters in range(5, 30, 5):\n",
    "    print(characters)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 5, 8, 11, 14, 17]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# to get a list from range \n",
    "# You can do the same functions as above within list\n",
    "\n",
    "list(range(2,20,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Index Count - To know how many letters are there in a str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 a\n",
      "2 s\n",
      "3 d\n",
      "4 f\n",
      "5  \n",
      "6 g\n",
      "7 h\n",
      "8 j\n",
      "9 k\n"
     ]
    }
   ],
   "source": [
    "# through 'for loop' method\n",
    "\n",
    "index = 1 \n",
    "for all_letters in 'asdf ghjk':\n",
    "    print(f\"{index} {all_letters}\")\n",
    "    \n",
    "    index +=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, ' ')\n",
      "(1, 'H')\n",
      "(2, 'i')\n",
      "(3, ' ')\n",
      "(4, 'T')\n",
      "(5, 'h')\n",
      "(6, 'e')\n",
      "(7, 'r')\n",
      "(8, 'e')\n",
      "(9, '.')\n"
     ]
    }
   ],
   "source": [
    "# How to ENUMERATE with built in function\n",
    "\n",
    "# ENUMERATE - To mention a number of things One by One\n",
    "\n",
    "sentence = \" Hi There.\"\n",
    "\n",
    "for numbers in enumerate(sentence):\n",
    "    print (numbers)\n",
    "    \n",
    "# The output is in the form of Tuples"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "H\n",
      "\n",
      "\n",
      "1\n",
      "i\n",
      "\n",
      "\n",
      "2\n",
      " \n",
      "\n",
      "\n",
      "3\n",
      "T\n",
      "\n",
      "\n",
      "4\n",
      "h\n",
      "\n",
      "\n",
      "5\n",
      "e\n",
      "\n",
      "\n",
      "6\n",
      "r\n",
      "\n",
      "\n",
      "7\n",
      "e\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# We can now do Tuple Unpacking\n",
    "\n",
    "sentence = \"Hi There\"\n",
    "\n",
    "for index, output in enumerate(sentence):\n",
    "    print (index)\n",
    "    print (output)\n",
    "    print('\\n')\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 'ram', 'love')\n",
      "(2, 'sam', 50)\n",
      "(3, 'jadhu', 'dove')\n"
     ]
    }
   ],
   "source": [
    "# Using 'zip' built in function - It zips many sets. It stops at the smallest list.\n",
    "\n",
    "a = [ 1,2,3,4, 8, 9, 33, 'jhuj']\n",
    "z = [\"ram\", \"sam\", 'jadhu', 'madhu']\n",
    "l = ['love', 50, 'dove']\n",
    "\n",
    "for all_together in zip(a,z,l):\n",
    "    print (all_together)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# To have a list of all items together\n",
    "\n",
    "all_together = list(zip(a,z,l))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(1, 'ram', 'love'), (2, 'sam', 50), (3, 'jadhu', 'dove'), (4, 'madhu', 43)]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "all_together"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 'ram', 'love')\n",
      "(2, 'sam', 50)\n",
      "(3, 'jadhu', 'dove')\n",
      "(4, 'madhu', 43)\n"
     ]
    }
   ],
   "source": [
    "for index, output in enumerate(all_together):\n",
    "  \n",
    "    print(output)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "ram\n",
      "love\n",
      "\n",
      "\n",
      "2\n",
      "sam\n",
      "50\n",
      "\n",
      "\n",
      "3\n",
      "jadhu\n",
      "dove\n",
      "\n",
      "\n",
      "4\n",
      "madhu\n",
      "43\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "for x,y,c in zip(a,z,l):\n",
    "    print(x)\n",
    "    print(y)\n",
    "    print(c)\n",
    "    print('\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In Operators"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# To check if there is something in a list\n",
    "\n",
    "a = [1,23,45,67,89,9,87,65,43,21,56]\n",
    "z = [\"Rama\", \"Shama\", \"Radha\", \"Priya\"]\n",
    "c = \" I Love You\"\n",
    "d = {'Orange': 4.55 , 'Apple': 3.99, \"Beat\":0.59, 'Parsley':0.32}\n",
    "\n",
    "'I' in c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "23 in a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Because z is a list searching a single word will make it false\n",
    "\n",
    "\"Rama\" in z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"S\" in z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# As c is a str it can search one word\n",
    "\"L\" in c"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Search either keys or values in dict or the whole dict\n",
    "\n",
    "'Orange' in d.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# In dict they keys are searched by default. so, 3.99 is coming False where as 'Apple' is returning True\n",
    "\n",
    "3.99 in d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'Apple' in d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4.55 in d.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# As dict search 'keys' by default , 'robots' will return True , where as 500 will return False\n",
    "\n",
    "'robots' in {'machine':500, 'robots':1000}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "descriptor 'values' for 'dict' objects doesn't apply to a 'int' object",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-8-e7a6891499bf>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mdict\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mvalues\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m500\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32min\u001b[0m \u001b[1;33m{\u001b[0m\u001b[1;34m'machine'\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;36m500\u001b[0m \u001b[1;33m,\u001b[0m \u001b[1;34m'robots'\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;36m1000\u001b[0m\u001b[1;33m}\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: descriptor 'values' for 'dict' objects doesn't apply to a 'int' object"
     ]
    }
   ],
   "source": [
    "500 in {'machine':500 , 'robots':1000}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Min, Max and Random Library"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Min numbers, max Numbers and random numbers\n",
    "\n",
    "z = [ 2, 45, 98, -43, -55, -.98765]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-55"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "98"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "# random library - everytime you shuffle you get different numbers\n",
    "\n",
    "from random import shuffle"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "shuffle(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-55, -0.98765, 45, 98, -43, 2]"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "shuffle(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[98, 45, -0.98765, -55, 2, -43]"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "164"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# randint selects a random number from a lower range and upper range\n",
    "\n",
    "from random import randint\n",
    "\n",
    "randint(-1000, 1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Input Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "What's Your Name: Debasis Sil\n"
     ]
    }
   ],
   "source": [
    "name = input (\"What's Your Name: \")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Debasis Sil'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Can I know your age please ? 43\n"
     ]
    }
   ],
   "source": [
    "age = input ('Can I know your age please ? ')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'43'"
      ]
     },
     "execution_count": 135,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 139,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# input always gives output in str. It can converted though\n",
    "\n",
    "type(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "43.0"
      ]
     },
     "execution_count": 141,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "float(age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "43"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int(age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Can I know your age please ? 43\n"
     ]
    }
   ],
   "source": [
    "# to change to int or float\n",
    "\n",
    "age = int(input ('Can I know your age please ? '))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "43"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "age"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(age)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}