Exercise/codebasics.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Variable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Create a variable named pi and store the value 22/7 in it. Now check the data type of this variable.\n",
    "2. Create a variable called for and assign it a value 4. See what happens and find out the reason behind the behavior that you see.\n",
    "3. Store the principal amount, rate of interest and time in different variables and then calculate the Simple Interest for 3 years "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#1\n",
    "pi=22/7\n",
    "type(pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (3639871942.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  Cell \u001b[1;32mIn[2], line 1\u001b[1;36m\u001b[0m\n\u001b[1;33m    for=4\u001b[0m\n\u001b[1;37m       ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "for=4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "#2\n",
    "for_=4\n",
    "print(for_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "360.0\n"
     ]
    }
   ],
   "source": [
    "#3\n",
    "p=1000\n",
    "r=12\n",
    "t=3\n",
    "\n",
    "si=(p*r*t)/100\n",
    "print(si)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(si)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Numbers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Remember the format() function we have used in the last video?? Now pass 145 and ‘o’ in the function and see what it returned. Try to find out which representation it is.\n",
    "2. There is a circular pond in a village. This pond has a radius of 84 meter. Can you find the area of the pond? (Bonus: If there is exactly 1.4 liter of water in a square meter, what is the total amount of the water in the pond?)\n",
    "\n",
    "    Hint:   \n",
    "`Circle Area = πr2`\n",
    "3. If you cross a 490-meter-long street in 7 minutes, then what is your speed in meters per second? Print your answer without any decimal point in it.\n",
    "Hint:**\n",
    "Speed = Distance / Time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'221'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#1\n",
    "format(145,'o')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Area of pond: 22155.84\n",
      "Total amount of the water in the pond: 31018.176\n"
     ]
    }
   ],
   "source": [
    "#2\n",
    "r=84\n",
    "a=3.14*r*r\n",
    "print(f\"Area of pond: {a}\")\n",
    "print(f\"Total amount of the water in the pond: {a*1.4}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "#3\n",
    "d=490\n",
    "t=7*60\n",
    "print(round(d/t))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. String"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Open the Jupyter notebook and type this code `help(str)` in the code cell and press CTRL+enter. Now see what it returns? Go through these string methods and try to practice them.\n",
    "2. Create two variables to store how many fruits and vegetables you eat in a day. Now Print \"I eat x vegetables and y fruits daily\" where x and y present vegetables and fruits that you eat every day. Use python f string for this.\n",
    "\n",
    "3. Create a variable and store the string “The Himalayas are one of the youngest mountain ranges on the planet.”\n",
    "    1. Print ‘The Himalayas’ using slice operator\n",
    "    2. Print “mountain range” using a negative index\n",
    "    3. Print “The Himalayas on the planet” using slice as well as f-string\n",
    "\n",
    "4. You have created a string variable called string= ”There are 9 planets in the solar system”. After some time, you have realized that your sentence is incorrect and there are only 8 planets, now correct your sentence by replacing the incorrect words. (Bonus: Try to do it in one line)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on class str in module builtins:\n",
      "\n",
      "class str(object)\n",
      " |  str(object='') -> str\n",
      " |  str(bytes_or_buffer[, encoding[, errors]]) -> str\n",
      " |\n",
      " |  Create a new string object from the given object. If encoding or\n",
      " |  errors is specified, then the object must expose a data buffer\n",
      " |  that will be decoded using the given encoding and error handler.\n",
      " |  Otherwise, returns the result of object.__str__() (if defined)\n",
      " |  or repr(object).\n",
      " |  encoding defaults to sys.getdefaultencoding().\n",
      " |  errors defaults to 'strict'.\n",
      " |\n",
      " |  Methods defined here:\n",
      " |\n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |\n",
      " |  __contains__(self, key, /)\n",
      " |      Return bool(key in self).\n",
      " |\n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |\n",
      " |  __format__(self, format_spec, /)\n",
      " |      Return a formatted version of the string as described by format_spec.\n",
      " |\n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |\n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |\n",
      " |  __getitem__(self, key, /)\n",
      " |      Return self[key].\n",
      " |\n",
      " |  __getnewargs__(...)\n",
      " |\n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |\n",
      " |  __hash__(self, /)\n",
      " |      Return hash(self).\n",
      " |\n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |\n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |\n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |\n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |\n",
      " |  __mod__(self, value, /)\n",
      " |      Return self%value.\n",
      " |\n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |\n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |\n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |\n",
      " |  __rmod__(self, value, /)\n",
      " |      Return value%self.\n",
      " |\n",
      " |  __rmul__(self, value, /)\n",
      " |      Return value*self.\n",
      " |\n",
      " |  __sizeof__(self, /)\n",
      " |      Return the size of the string in memory, in bytes.\n",
      " |\n",
      " |  __str__(self, /)\n",
      " |      Return str(self).\n",
      " |\n",
      " |  capitalize(self, /)\n",
      " |      Return a capitalized version of the string.\n",
      " |\n",
      " |      More specifically, make the first character have upper case and the rest lower\n",
      " |      case.\n",
      " |\n",
      " |  casefold(self, /)\n",
      " |      Return a version of the string suitable for caseless comparisons.\n",
      " |\n",
      " |  center(self, width, fillchar=' ', /)\n",
      " |      Return a centered string of length width.\n",
      " |\n",
      " |      Padding is done using the specified fill character (default is a space).\n",
      " |\n",
      " |  count(...)\n",
      " |      S.count(sub[, start[, end]]) -> int\n",
      " |\n",
      " |      Return the number of non-overlapping occurrences of substring sub in\n",
      " |      string S[start:end].  Optional arguments start and end are\n",
      " |      interpreted as in slice notation.\n",
      " |\n",
      " |  encode(self, /, encoding='utf-8', errors='strict')\n",
      " |      Encode the string using the codec registered for encoding.\n",
      " |\n",
      " |      encoding\n",
      " |        The encoding in which to encode the string.\n",
      " |      errors\n",
      " |        The error handling scheme to use for encoding errors.\n",
      " |        The default is 'strict' meaning that encoding errors raise a\n",
      " |        UnicodeEncodeError.  Other possible values are 'ignore', 'replace' and\n",
      " |        'xmlcharrefreplace' as well as any other name registered with\n",
      " |        codecs.register_error that can handle UnicodeEncodeErrors.\n",
      " |\n",
      " |  endswith(...)\n",
      " |      S.endswith(suffix[, start[, end]]) -> bool\n",
      " |\n",
      " |      Return True if S ends with the specified suffix, False otherwise.\n",
      " |      With optional start, test S beginning at that position.\n",
      " |      With optional end, stop comparing S at that position.\n",
      " |      suffix can also be a tuple of strings to try.\n",
      " |\n",
      " |  expandtabs(self, /, tabsize=8)\n",
      " |      Return a copy where all tab characters are expanded using spaces.\n",
      " |\n",
      " |      If tabsize is not given, a tab size of 8 characters is assumed.\n",
      " |\n",
      " |  find(...)\n",
      " |      S.find(sub[, start[, end]]) -> int\n",
      " |\n",
      " |      Return the lowest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |\n",
      " |      Return -1 on failure.\n",
      " |\n",
      " |  format(...)\n",
      " |      S.format(*args, **kwargs) -> str\n",
      " |\n",
      " |      Return a formatted version of S, using substitutions from args and kwargs.\n",
      " |      The substitutions are identified by braces ('{' and '}').\n",
      " |\n",
      " |  format_map(...)\n",
      " |      S.format_map(mapping) -> str\n",
      " |\n",
      " |      Return a formatted version of S, using substitutions from mapping.\n",
      " |      The substitutions are identified by braces ('{' and '}').\n",
      " |\n",
      " |  index(...)\n",
      " |      S.index(sub[, start[, end]]) -> int\n",
      " |\n",
      " |      Return the lowest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |\n",
      " |      Raises ValueError when the substring is not found.\n",
      " |\n",
      " |  isalnum(self, /)\n",
      " |      Return True if the string is an alpha-numeric string, False otherwise.\n",
      " |\n",
      " |      A string is alpha-numeric if all characters in the string are alpha-numeric and\n",
      " |      there is at least one character in the string.\n",
      " |\n",
      " |  isalpha(self, /)\n",
      " |      Return True if the string is an alphabetic string, False otherwise.\n",
      " |\n",
      " |      A string is alphabetic if all characters in the string are alphabetic and there\n",
      " |      is at least one character in the string.\n",
      " |\n",
      " |  isascii(self, /)\n",
      " |      Return True if all characters in the string are ASCII, False otherwise.\n",
      " |\n",
      " |      ASCII characters have code points in the range U+0000-U+007F.\n",
      " |      Empty string is ASCII too.\n",
      " |\n",
      " |  isdecimal(self, /)\n",
      " |      Return True if the string is a decimal string, False otherwise.\n",
      " |\n",
      " |      A string is a decimal string if all characters in the string are decimal and\n",
      " |      there is at least one character in the string.\n",
      " |\n",
      " |  isdigit(self, /)\n",
      " |      Return True if the string is a digit string, False otherwise.\n",
      " |\n",
      " |      A string is a digit string if all characters in the string are digits and there\n",
      " |      is at least one character in the string.\n",
      " |\n",
      " |  isidentifier(self, /)\n",
      " |      Return True if the string is a valid Python identifier, False otherwise.\n",
      " |\n",
      " |      Call keyword.iskeyword(s) to test whether string s is a reserved identifier,\n",
      " |      such as \"def\" or \"class\".\n",
      " |\n",
      " |  islower(self, /)\n",
      " |      Return True if the string is a lowercase string, False otherwise.\n",
      " |\n",
      " |      A string is lowercase if all cased characters in the string are lowercase and\n",
      " |      there is at least one cased character in the string.\n",
      " |\n",
      " |  isnumeric(self, /)\n",
      " |      Return True if the string is a numeric string, False otherwise.\n",
      " |\n",
      " |      A string is numeric if all characters in the string are numeric and there is at\n",
      " |      least one character in the string.\n",
      " |\n",
      " |  isprintable(self, /)\n",
      " |      Return True if the string is printable, False otherwise.\n",
      " |\n",
      " |      A string is printable if all of its characters are considered printable in\n",
      " |      repr() or if it is empty.\n",
      " |\n",
      " |  isspace(self, /)\n",
      " |      Return True if the string is a whitespace string, False otherwise.\n",
      " |\n",
      " |      A string is whitespace if all characters in the string are whitespace and there\n",
      " |      is at least one character in the string.\n",
      " |\n",
      " |  istitle(self, /)\n",
      " |      Return True if the string is a title-cased string, False otherwise.\n",
      " |\n",
      " |      In a title-cased string, upper- and title-case characters may only\n",
      " |      follow uncased characters and lowercase characters only cased ones.\n",
      " |\n",
      " |  isupper(self, /)\n",
      " |      Return True if the string is an uppercase string, False otherwise.\n",
      " |\n",
      " |      A string is uppercase if all cased characters in the string are uppercase and\n",
      " |      there is at least one cased character in the string.\n",
      " |\n",
      " |  join(self, iterable, /)\n",
      " |      Concatenate any number of strings.\n",
      " |\n",
      " |      The string whose method is called is inserted in between each given string.\n",
      " |      The result is returned as a new string.\n",
      " |\n",
      " |      Example: '.'.join(['ab', 'pq', 'rs']) -> 'ab.pq.rs'\n",
      " |\n",
      " |  ljust(self, width, fillchar=' ', /)\n",
      " |      Return a left-justified string of length width.\n",
      " |\n",
      " |      Padding is done using the specified fill character (default is a space).\n",
      " |\n",
      " |  lower(self, /)\n",
      " |      Return a copy of the string converted to lowercase.\n",
      " |\n",
      " |  lstrip(self, chars=None, /)\n",
      " |      Return a copy of the string with leading whitespace removed.\n",
      " |\n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |\n",
      " |  partition(self, sep, /)\n",
      " |      Partition the string into three parts using the given separator.\n",
      " |\n",
      " |      This will search for the separator in the string.  If the separator is found,\n",
      " |      returns a 3-tuple containing the part before the separator, the separator\n",
      " |      itself, and the part after it.\n",
      " |\n",
      " |      If the separator is not found, returns a 3-tuple containing the original string\n",
      " |      and two empty strings.\n",
      " |\n",
      " |  removeprefix(self, prefix, /)\n",
      " |      Return a str with the given prefix string removed if present.\n",
      " |\n",
      " |      If the string starts with the prefix string, return string[len(prefix):].\n",
      " |      Otherwise, return a copy of the original string.\n",
      " |\n",
      " |  removesuffix(self, suffix, /)\n",
      " |      Return a str with the given suffix string removed if present.\n",
      " |\n",
      " |      If the string ends with the suffix string and that suffix is not empty,\n",
      " |      return string[:-len(suffix)]. Otherwise, return a copy of the original\n",
      " |      string.\n",
      " |\n",
      " |  replace(self, old, new, count=-1, /)\n",
      " |      Return a copy with all occurrences of substring old replaced by new.\n",
      " |\n",
      " |        count\n",
      " |          Maximum number of occurrences to replace.\n",
      " |          -1 (the default value) means replace all occurrences.\n",
      " |\n",
      " |      If the optional argument count is given, only the first count occurrences are\n",
      " |      replaced.\n",
      " |\n",
      " |  rfind(...)\n",
      " |      S.rfind(sub[, start[, end]]) -> int\n",
      " |\n",
      " |      Return the highest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |\n",
      " |      Return -1 on failure.\n",
      " |\n",
      " |  rindex(...)\n",
      " |      S.rindex(sub[, start[, end]]) -> int\n",
      " |\n",
      " |      Return the highest index in S where substring sub is found,\n",
      " |      such that sub is contained within S[start:end].  Optional\n",
      " |      arguments start and end are interpreted as in slice notation.\n",
      " |\n",
      " |      Raises ValueError when the substring is not found.\n",
      " |\n",
      " |  rjust(self, width, fillchar=' ', /)\n",
      " |      Return a right-justified string of length width.\n",
      " |\n",
      " |      Padding is done using the specified fill character (default is a space).\n",
      " |\n",
      " |  rpartition(self, sep, /)\n",
      " |      Partition the string into three parts using the given separator.\n",
      " |\n",
      " |      This will search for the separator in the string, starting at the end. If\n",
      " |      the separator is found, returns a 3-tuple containing the part before the\n",
      " |      separator, the separator itself, and the part after it.\n",
      " |\n",
      " |      If the separator is not found, returns a 3-tuple containing two empty strings\n",
      " |      and the original string.\n",
      " |\n",
      " |  rsplit(self, /, sep=None, maxsplit=-1)\n",
      " |      Return a list of the substrings in the string, using sep as the separator string.\n",
      " |\n",
      " |        sep\n",
      " |          The separator used to split the string.\n",
      " |\n",
      " |          When set to None (the default value), will split on any whitespace\n",
      " |          character (including \\n \\r \\t \\f and spaces) and will discard\n",
      " |          empty strings from the result.\n",
      " |        maxsplit\n",
      " |          Maximum number of splits.\n",
      " |          -1 (the default value) means no limit.\n",
      " |\n",
      " |      Splitting starts at the end of the string and works to the front.\n",
      " |\n",
      " |  rstrip(self, chars=None, /)\n",
      " |      Return a copy of the string with trailing whitespace removed.\n",
      " |\n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |\n",
      " |  split(self, /, sep=None, maxsplit=-1)\n",
      " |      Return a list of the substrings in the string, using sep as the separator string.\n",
      " |\n",
      " |        sep\n",
      " |          The separator used to split the string.\n",
      " |\n",
      " |          When set to None (the default value), will split on any whitespace\n",
      " |          character (including \\n \\r \\t \\f and spaces) and will discard\n",
      " |          empty strings from the result.\n",
      " |        maxsplit\n",
      " |          Maximum number of splits.\n",
      " |          -1 (the default value) means no limit.\n",
      " |\n",
      " |      Splitting starts at the front of the string and works to the end.\n",
      " |\n",
      " |      Note, str.split() is mainly useful for data that has been intentionally\n",
      " |      delimited.  With natural text that includes punctuation, consider using\n",
      " |      the regular expression module.\n",
      " |\n",
      " |  splitlines(self, /, keepends=False)\n",
      " |      Return a list of the lines in the string, breaking at line boundaries.\n",
      " |\n",
      " |      Line breaks are not included in the resulting list unless keepends is given and\n",
      " |      true.\n",
      " |\n",
      " |  startswith(...)\n",
      " |      S.startswith(prefix[, start[, end]]) -> bool\n",
      " |\n",
      " |      Return True if S starts with the specified prefix, False otherwise.\n",
      " |      With optional start, test S beginning at that position.\n",
      " |      With optional end, stop comparing S at that position.\n",
      " |      prefix can also be a tuple of strings to try.\n",
      " |\n",
      " |  strip(self, chars=None, /)\n",
      " |      Return a copy of the string with leading and trailing whitespace removed.\n",
      " |\n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |\n",
      " |  swapcase(self, /)\n",
      " |      Convert uppercase characters to lowercase and lowercase characters to uppercase.\n",
      " |\n",
      " |  title(self, /)\n",
      " |      Return a version of the string where each word is titlecased.\n",
      " |\n",
      " |      More specifically, words start with uppercased characters and all remaining\n",
      " |      cased characters have lower case.\n",
      " |\n",
      " |  translate(self, table, /)\n",
      " |      Replace each character in the string using the given translation table.\n",
      " |\n",
      " |        table\n",
      " |          Translation table, which must be a mapping of Unicode ordinals to\n",
      " |          Unicode ordinals, strings, or None.\n",
      " |\n",
      " |      The table must implement lookup/indexing via __getitem__, for instance a\n",
      " |      dictionary or list.  If this operation raises LookupError, the character is\n",
      " |      left untouched.  Characters mapped to None are deleted.\n",
      " |\n",
      " |  upper(self, /)\n",
      " |      Return a copy of the string converted to uppercase.\n",
      " |\n",
      " |  zfill(self, width, /)\n",
      " |      Pad a numeric string with zeros on the left, to fill a field of the given width.\n",
      " |\n",
      " |      The string is never truncated.\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |\n",
      " |  __new__(*args, **kwargs)\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |\n",
      " |  maketrans(...)\n",
      " |      Return a translation table usable for str.translate().\n",
      " |\n",
      " |      If there is only one argument, it must be a dictionary mapping Unicode\n",
      " |      ordinals (integers) or characters to Unicode ordinals, strings or None.\n",
      " |      Character keys will be then converted to ordinals.\n",
      " |      If there are two arguments, they must be strings of equal length, and\n",
      " |      in the resulting dictionary, each character in x will be mapped to the\n",
      " |      character at the same position in y. If there is a third argument, it\n",
      " |      must be a string, whose characters will be mapped to None in the result.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "#1\n",
    "help(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = \"Python is Easy.\"\n",
    "s.endswith(\".\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I eat potato & tomato and apple, banana fruits daily.\n"
     ]
    }
   ],
   "source": [
    "#2\n",
    "fruits = \"apple, banana\"\n",
    "vegetables = \"potato & tomato\"\n",
    "print(f\"I eat {vegetables} and {fruits} fruits daily.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'The Himalayas are one of the youngest mountain range on the planet.'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#3\n",
    "string = \"The Himalayas are one of the youngest mountain range on the planet.\"\n",
    "string"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Himalayas\n"
     ]
    }
   ],
   "source": [
    "print(string[0:13])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mountain range\n"
     ]
    }
   ],
   "source": [
    "print(string[-29:-15])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Himalayas on the planet.\n"
     ]
    }
   ],
   "source": [
    "print(string[0:13] + string[-15:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Himalayas on the planet.\n"
     ]
    }
   ],
   "source": [
    "print(f\"{string[0:13]} {string[-14:]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'There are 9 planet in the solar system'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#4\n",
    "str = \"There are 9 planet in the solar system\"\n",
    "str"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 8 planet in the solar system\n"
     ]
    }
   ],
   "source": [
    "print(str.replace('9','8'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 8 planets in the solar system\n"
     ]
    }
   ],
   "source": [
    "print(str.replace(\"planet\",\"planets\").replace('9','8'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 8 planet in the solar system\n"
     ]
    }
   ],
   "source": [
    "print(str.replace(\"9 planet\",\"8 planet\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. Lists"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You are a Marvel fan and created a list of superheroes.\n",
    "\n",
    "​​​​​​​avengers  = [\"Iron Man\", \"Captain America\", \"Black Widow\", \"Hulk\", \"Thor\", \"Hawkeye\"]\n",
    "\n",
    "Using this list, do the following:\n",
    "1. Calculate how many members are in the Avengers team?\n",
    "2. Iron Man made Spider-Man a new member of the Avengers, add him to your list.\n",
    "3. Captain America is the leader of the Avengers, you need to add him before Iron Man, so remove him from the list and add him before Iron Man.\n",
    "4. You don’t like Thor and Hulk together because they get angry easily and fight with each other. So you have to separate them from each other. To separate them, either move “Black Widow” or “Hawkeye” in between them.\n",
    "5. After Avengers: End Game the original six avengers are retired, now you need to remove them from your list and add new superheroes like Doctor Strange, Vision, Wanda, Kate Bishop, and Ant-Man.\n",
    "6. As “Captain America” is also retired and now currently, no one is the leader, so sort the list in alphabetical order. Whoever will come at the 0th index will become the Leader. (BONUS: can you guess who will become the leader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Iron Man', 'Captain America', 'Black Widow', 'Hulk', 'Thor', 'Hawkeye']"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avengers  = [\"Iron Man\", \"Captain America\", \"Black Widow\", \"Hulk\", \"Thor\", \"Hawkeye\"]\n",
    "avengers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(avengers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Iron Man',\n",
       " 'Captain America',\n",
       " 'Black Widow',\n",
       " 'Hulk',\n",
       " 'Thor',\n",
       " 'Hawkeye',\n",
       " 'Spider-Man']"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avengers.append(\"Spider-Man\")\n",
    "avengers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Iron Man', 'Black Widow', 'Hulk', 'Thor', 'Hawkeye', 'Spider-Man']"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avengers.remove(\"Captain America\")\n",
    "avengers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Capitan America',\n",
       " 'Iron Man',\n",
       " 'Black Widow',\n",
       " 'Hulk',\n",
       " 'Thor',\n",
       " 'Hawkeye',\n",
       " 'Spider-Man']"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avengers.insert(0,\"Capitan America\")\n",
    "avengers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Capitan America', 'Iron Man', 'Hulk', 'Thor', 'Hawkeye', 'Spider-Man']"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avengers.pop(2)\n",
    "avengers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Capitan America',\n",
       " 'Iron Man',\n",
       " 'Hulk',\n",
       " 'Black Widow',\n",
       " 'Thor',\n",
       " 'Hawkeye',\n",
       " 'Spider-Man']"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avengers.insert(3,\"Black Widow\")\n",
    "avengers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on list object:\n",
      "\n",
      "class list(object)\n",
      " |  list(iterable=(), /)\n",
      " |\n",
      " |  Built-in mutable sequence.\n",
      " |\n",
      " |  If no argument is given, the constructor creates a new empty list.\n",
      " |  The argument must be an iterable if specified.\n",
      " |\n",
      " |  Methods defined here:\n",
      " |\n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |\n",
      " |  __contains__(self, key, /)\n",
      " |      Return bool(key in self).\n",
      " |\n",
      " |  __delitem__(self, key, /)\n",
      " |      Delete self[key].\n",
      " |\n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |\n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |\n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |\n",
      " |  __getitem__(self, index, /)\n",
      " |      Return self[index].\n",
      " |\n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |\n",
      " |  __iadd__(self, value, /)\n",
      " |      Implement self+=value.\n",
      " |\n",
      " |  __imul__(self, value, /)\n",
      " |      Implement self*=value.\n",
      " |\n",
      " |  __init__(self, /, *args, **kwargs)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |\n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |\n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |\n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |\n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |\n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |\n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |\n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |\n",
      " |  __reversed__(self, /)\n",
      " |      Return a reverse iterator over the list.\n",
      " |\n",
      " |  __rmul__(self, value, /)\n",
      " |      Return value*self.\n",
      " |\n",
      " |  __setitem__(self, key, value, /)\n",
      " |      Set self[key] to value.\n",
      " |\n",
      " |  __sizeof__(self, /)\n",
      " |      Return the size of the list in memory, in bytes.\n",
      " |\n",
      " |  append(self, object, /)\n",
      " |      Append object to the end of the list.\n",
      " |\n",
      " |  clear(self, /)\n",
      " |      Remove all items from list.\n",
      " |\n",
      " |  copy(self, /)\n",
      " |      Return a shallow copy of the list.\n",
      " |\n",
      " |  count(self, value, /)\n",
      " |      Return number of occurrences of value.\n",
      " |\n",
      " |  extend(self, iterable, /)\n",
      " |      Extend list by appending elements from the iterable.\n",
      " |\n",
      " |  index(self, value, start=0, stop=9223372036854775807, /)\n",
      " |      Return first index of value.\n",
      " |\n",
      " |      Raises ValueError if the value is not present.\n",
      " |\n",
      " |  insert(self, index, object, /)\n",
      " |      Insert object before index.\n",
      " |\n",
      " |  pop(self, index=-1, /)\n",
      " |      Remove and return item at index (default last).\n",
      " |\n",
      " |      Raises IndexError if list is empty or index is out of range.\n",
      " |\n",
      " |  remove(self, value, /)\n",
      " |      Remove first occurrence of value.\n",
      " |\n",
      " |      Raises ValueError if the value is not present.\n",
      " |\n",
      " |  reverse(self, /)\n",
      " |      Reverse *IN PLACE*.\n",
      " |\n",
      " |  sort(self, /, *, key=None, reverse=False)\n",
      " |      Sort the list in ascending order and return None.\n",
      " |\n",
      " |      The sort is in-place (i.e. the list itself is modified) and stable (i.e. the\n",
      " |      order of two equal elements is maintained).\n",
      " |\n",
      " |      If a key function is given, apply it once to each list item and sort them,\n",
      " |      ascending or descending, according to their function values.\n",
      " |\n",
      " |      The reverse flag can be set to sort in descending order.\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Class methods defined here:\n",
      " |\n",
      " |  __class_getitem__(...)\n",
      " |      See PEP 585\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |\n",
      " |  __new__(*args, **kwargs)\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |\n",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |\n",
      " |  __hash__ = None\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(avengers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Capitan America',\n",
       " 'Iron Man',\n",
       " 'Hulk',\n",
       " 'Black Widow',\n",
       " 'Thor',\n",
       " 'Hawkeye',\n",
       " 'Spider-Man']"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avengers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "pop index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[30], line 3\u001b[0m\n\u001b[0;32m      1\u001b[0m avengers\n\u001b[0;32m      2\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m i \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mrange\u001b[39m(\u001b[38;5;28mlen\u001b[39m(avengers)\u001b[38;5;241m-\u001b[39m\u001b[38;5;241m1\u001b[39m):\n\u001b[1;32m----> 3\u001b[0m     \u001b[43mavengers\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpop\u001b[49m\u001b[43m(\u001b[49m\u001b[43mi\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m      5\u001b[0m avengers\n",
      "\u001b[1;31mIndexError\u001b[0m: pop index out of range"
     ]
    }
   ],
   "source": [
    "avengers\n",
    "for i in range(len(avengers)-1):\n",
    "    avengers.pop(i)\n",
    "\n",
    "avengers\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Doctor Strange', 'Vision', 'Wanda', 'Kate Bishop', 'Ant Man']"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_superheroes = ['Doctor Strange', 'Vision', 'Wanda', 'Kate Bishop', 'Ant Man']\n",
    "new_superheroes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Iron Man',\n",
       " 'Black Widow',\n",
       " 'Hawkeye',\n",
       " 'Doctor Strange',\n",
       " 'Vision',\n",
       " 'Wanda',\n",
       " 'Kate Bishop',\n",
       " 'Ant Man']"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avengers.extend(new_superheroes)\n",
    "avengers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(avengers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "avengers.sort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['Black Widow', 'Hawkeye', 'Iron Man']"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "avengers"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 5. if, if-else, elif"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Write a program that can tell you your BMI Category.\n",
    "\n",
    "+ Ask user to enter height\n",
    "+ Ask user to enter weight\n",
    "+ Calculate the BMI(Body Mass Index = wight / height^2) and store it in a variable\n",
    "+ If the BMI is 30 or greater, print “Obesity”\n",
    "+ If the BMI is in between 25 and 29, print “Over Weight”\n",
    "+ If the BMI is in between 18.5 and 25, print “Normal”\n",
    "+ If the BMI is less than 18.5, print “Under Weight”\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: ''",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[34], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m h \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;28;43minput\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mEnter the height: \u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\u001b[43m)\u001b[49m\n\u001b[0;32m      2\u001b[0m w \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mint\u001b[39m(\u001b[38;5;28minput\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mEnter the weight: \u001b[39m\u001b[38;5;124m\"\u001b[39m))\n\u001b[0;32m      4\u001b[0m bmi \u001b[38;5;241m=\u001b[39m w\u001b[38;5;241m/\u001b[39mh\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m\u001b[38;5;241m2\u001b[39m\n",
      "\u001b[1;31mValueError\u001b[0m: invalid literal for int() with base 10: ''"
     ]
    }
   ],
   "source": [
    "h = int(input(\"Enter the height: \"))\n",
    "w = int(input(\"Enter the weight: \"))\n",
    "\n",
    "bmi = w/h**2\n",
    "if bmi>=30:\n",
    "    print(\"Obesity\")\n",
    "elif bmi>25 and bmi<29:\n",
    "    print(\"Over Weight\")\n",
    "elif bmi>18.5 and bmi<=25:\n",
    "    print(\"Normal\")\n",
    "else:\n",
    "    print(\"Under Weight\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Using the following list of cities per country,\n",
    "```python\n",
    "India = [\"Mumbai\", \"Bangalore\", \"Chennai\", \"Delhi\"]\n",
    "USA = [\"New York\",\"Chicago\",\"Las Vegas\", “San Francisco”]\n",
    "UK = [“London”, “Manchester”, “Liverpool”, “Nottingham”]\n",
    "```\n",
    "- Write a program that asks the user to enter a city name, and it should tell which country the city belongs to\n",
    "- Write a program that asks user to enter two cities, and it tells you if they both are in the same country or not. For example, if I enter Mumbai and Chennai, it will print \"Both cities are in India\" but if I enter Mumbai and New York it should print \"They don't belong to the same country\"\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "india = [\"Mumbai\", \"Bangalore\", \"Chennai\", \"Delhi\"]\n",
    "usa = [\"New York\", \"Chicago\", \"Las Vegas\",\"San-Francisco\"]\n",
    "uk = [\"London\", \"Manchester\", \"Liverpool\", \"Nottingham\"]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " is not present\n"
     ]
    }
   ],
   "source": [
    "city = input(\"Enter the city name: \")\n",
    "\n",
    "if city in india:\n",
    "    print(f\"{city} is in India\")\n",
    "elif city in usa:\n",
    "    print(f\"{city} is in USA\")\n",
    "elif city in uk:\n",
    "    print(f\"{city} is in UK\")\n",
    "else:\n",
    "    print(f\"{city} is not present\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Both cities belongs to different countries\n"
     ]
    }
   ],
   "source": [
    "c1 = input(\"Enter the city: \")\n",
    "c2 = input(\"Enter the another city: \")\n",
    "\n",
    "if c1 in india and c2 in india:\n",
    "    print(\"Both city belongs to INDIA\")\n",
    "elif c1 in usa and c2 in usa:\n",
    "    print(\"Both city belongs to USA\")\n",
    "elif c1 in uk and c2 in uk:\n",
    "    print(\"Both city belongs to UK\")\n",
    "else:\n",
    "    print(\"Both cities belongs to different countries\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 6. Loops"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Write a Python program to print the following pattern.\n",
    "\n",
    "        1 2 3 4 5\n",
    "        1 2 3 4 \n",
    "        1 2 3\n",
    "        1 2\n",
    "        1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 \n",
      "1 2 3 4 \n",
      "1 2 3 \n",
      "1 2 \n",
      "1 \n"
     ]
    }
   ],
   "source": [
    "for i in range (5):\n",
    "    for j in range (1, 6-i):\n",
    "        print(j, end=\" \")\n",
    "    print() "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Write a Python program to find the sum of all the numbers except odd numbers between 1 to 20 using a loop. Can you also do this using a while loop?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "110\n"
     ]
    }
   ],
   "source": [
    "i=1\n",
    "s=0\n",
    "while i<=20:\n",
    "    if i%2!=0:\n",
    "        pass\n",
    "    else:\n",
    "        s=s+i\n",
    "    i += 1\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. After throwing the dice several times, you got this result,\n",
    "\tdice_result  = [5,6,4,2,5,4,4,5,3,3,2,6,1,2,1,1,6,5]\n",
    "\n",
    "Using a for loop find out the followings:\n",
    "\n",
    "+ How many times you got 6s\n",
    "+ How many times you got 1s\n",
    "+ How many times you got 6s two times in row\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6s: 3, 1s: 3, 6s two times: 0\n"
     ]
    }
   ],
   "source": [
    "dice_result  = [5,6,4,2,5,4,4,5,3,3,2,6,1,2,1,1,6,5]\n",
    "\n",
    "i, six, one, dsix = 0,0,0,0\n",
    "for i in dice_result:\n",
    "    if i==6:\n",
    "        six +=1\n",
    "    elif i==1:\n",
    "        one +=1\n",
    "    elif i==6 and i+1==6:\n",
    "        dsix +=1\n",
    "\n",
    "print(f\"6s: {six}, 1s: {one}, 6s two times: {dsix}\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Let's say you are doing push-ups and you have to complete 50 push-ups daily, write a program that,\n",
    "\n",
    "+ Upon completing 10 push-ups in a go, asks you, “Are you tired?”\n",
    "+ If you reply “yes” or “y” then it should break and print “You did total push-ups.” For example: If you did only 30  push-ups and answered “yes” to your program. It will break the loop and print “You did a total of 30 push-ups**”**\n",
    "+ If you reply “no” or “n” then it should continue and display how many push-ups are remaining  now after that ask you again “Are you tired?” For Example: if you answered “no” then it should display that 20 push-ups are remaining and ask you again “Are you tired?”\n",
    "+ If you complete all 50 push-ups, then it should print the “Congratulations! You made it” and stopped the program."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You have done 10 push-ups.\n",
      "Invalid response. Please answer with 'yes/y' or 'no/n'.\n",
      "You have done 20 push-ups.\n",
      "Invalid response. Please answer with 'yes/y' or 'no/n'.\n",
      "You have done 30 push-ups.\n",
      "Invalid response. Please answer with 'yes/y' or 'no/n'.\n",
      "You have done 40 push-ups.\n",
      "Invalid response. Please answer with 'yes/y' or 'no/n'.\n",
      "Congratulations! You made it\n"
     ]
    }
   ],
   "source": [
    "def push_ups():\n",
    "    total_push_ups = 50\n",
    "    push_ups_done = 0\n",
    "    increment = 10\n",
    "\n",
    "    while push_ups_done < total_push_ups:\n",
    "        push_ups_done += increment\n",
    "        if push_ups_done >= total_push_ups:\n",
    "            print(\"Congratulations! You made it\")\n",
    "            break\n",
    "        print(f\"You have done {push_ups_done} push-ups.\")\n",
    "        \n",
    "        response = input(\"Are you tired? (yes/y or no/n): \").strip().lower()\n",
    "        if response in [\"yes\", \"y\"]:\n",
    "            print(f\"You did a total of {push_ups_done} push-ups.\")\n",
    "            break\n",
    "        elif response in [\"no\", \"n\"]:\n",
    "            remaining_push_ups = total_push_ups - push_ups_done\n",
    "            print(f\"{remaining_push_ups} push-ups remaining.\")\n",
    "        else:\n",
    "            print(\"Invalid response. Please answer with 'yes/y' or 'no/n'.\")\n",
    "\n",
    "# Run the program\n",
    "push_ups()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 7. Functions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Write a python function to check if any given number is prime number and odd number?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ODD & Prime Number\n"
     ]
    }
   ],
   "source": [
    "def prime_odd_check(num):\n",
    "    c=0\n",
    "    flag=0\n",
    "    if num%2!=0:\n",
    "        flag=1\n",
    "        \n",
    "    \n",
    "    for i in range(1,num+1):\n",
    "        if num%i==0:\n",
    "            c=c+1\n",
    "    \n",
    "    if c==2 and flag==1:\n",
    "        return \"ODD & Prime Number\"\n",
    "    elif c==2 and flag!=1:\n",
    "        return \"Prime Number BUT not ODD\"\n",
    "    else:\n",
    "        return \"ODD Number\"\n",
    "    \n",
    "n = int(input(\"Enter the number: \"))\n",
    "print(prime_odd_check(n))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2. Write a python function which will take n as input and print the pattern of n rows. If the n is even, then print it flipped.\n",
    "\n",
    "Example: n=3\n",
    "        \n",
    "        *\n",
    "        * *\n",
    "        * * *\n",
    "\n",
    "n=4\n",
    "\n",
    "        * * * *\n",
    "        * * *\n",
    "        * *\n",
    "        *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* * * * \n",
      "* * * \n",
      "* * \n",
      "* \n",
      "\n"
     ]
    }
   ],
   "source": [
    "def is_even(num):\n",
    "    if num%2==0:\n",
    "        return True\n",
    "    else:\n",
    "        return False\n",
    "    \n",
    "def print_awesome_pattern(n):\n",
    "    if is_even(n):\n",
    "\n",
    "        for i in range(n+1):\n",
    "            for j in range(n-i):\n",
    "                print(\"*\", end=\" \")\n",
    "            print()\n",
    "\n",
    "    else:\n",
    "\n",
    "        for i in range(n+1):\n",
    "            for j in range(i):\n",
    "                print(\"*\", end=\" \")\n",
    "            print()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "* \n",
      "* * \n",
      "* * * \n"
     ]
    }
   ],
   "source": [
    "print_awesome_pattern(3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "* * * * \n",
      "* * * \n",
      "* * \n",
      "* \n",
      "\n"
     ]
    }
   ],
   "source": [
    "print_awesome_pattern(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "3. Master Yoda speaks a sentence in a different order. Let's say you want to convert a sentence to Yoda’s speak.  Write a function named master_yoda which will take a string as input and return the output after reversing the words of the sentence."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "' Python learning am I '"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def master_yoda(sentence):\n",
    "    str=\" \"\n",
    "    words=sentence.split()\n",
    "    words.reverse()\n",
    "    \n",
    "    for i in words:\n",
    "        str+=i+' '\n",
    "    return str\n",
    "\n",
    "master_yoda(\"I am learning Python\")    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python learning am I\n"
     ]
    }
   ],
   "source": [
    "def master_yoda(sentence):\n",
    "    str=\" \"\n",
    "    words=sentence.split()\n",
    "    words.reverse()\n",
    "\n",
    "    str=' '.join(words)\n",
    "    print(str)\n",
    "\n",
    "master_yoda(\"I am learning Python\")    "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "4. Write a function pay_bill which will take list of expenses, percent commission, and a special offer amount\n",
    "* If you don’t pass percent_comission it should be always 9.8%\n",
    "* The Last argument special_offer_amount is not a required argument, you don’t need to pass is. Make it an optional parameter.\n",
    "* If you want to give a special offer to the user, then you have to pass the third argument special_offer_amount. If user makes the purchase of greater than special_offer_amount, then give him extra  commission of 1.2%.\n",
    "* Calculate the final payable price of the bill and return it from the function.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22.680000000000064"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def pay_bill(expenses, percent_commission=0.98, special_offer_amt=None):\n",
    "\n",
    "    bill=0\n",
    "    for i in expenses:\n",
    "        bill+=i\n",
    "\n",
    "    extra_commission=0\n",
    "    if special_offer_amt:\n",
    "        if bill>special_offer_amt:\n",
    "            extra_commission=0.012\n",
    "\n",
    "    amt= bill*(percent_commission+extra_commission)\n",
    "    final_amt= bill-amt\n",
    "    return final_amt\n",
    "\n",
    "\n",
    "\n",
    "pay_bill([100, 145, 567, 322])\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8. Dictionary, Tuples"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. Create a list of your friend’s name and now create a list of tuples. The tuple should contain the friend’s name and length of the name. For Example: if someone’s name is Aditya, the tuple would be: (‘Aditya’, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Ajay', 4), ('Akash', 5), ('Sanjana', 7), ('Sudhir', 6), ('Vijay Kumar', 11)]"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def name_len(friends_list):\n",
    "    my_list=[]\n",
    "    for i in friends_list:\n",
    "        f_tuple =(i, len(i))\n",
    "        my_list.append(f_tuple)\n",
    "    return my_list \n",
    "\n",
    "\n",
    "\n",
    "friends = ['Ajay', 'Akash', 'Sanjana', 'Sudhir', 'Vijay Kumar']\n",
    "name_len(friends)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('Vivek', 5), ('Raj', 3), ('James', 5)]"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name_len(['Vivek', 'Raj', 'James'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2.  You and your wife argued upon expenses last night. You both want to know who is spending more in a month. Now you both go to the Little Yoda he is a good python programmer, he suggested both of you to add an entry in a dictionary when next time you spent money. So that you can have clear picture about your expenses and plan to reduce it. Both dictionaries are as below- \n",
    "Your expenses - \n",
    "* Clothes - 1100\n",
    "* Shoes - 1000\n",
    "* Watch - 900\n",
    "* Mobile Recharge - 699\n",
    "* Petrol - 1980\n",
    "\n",
    "Your Wife’s expenses - \n",
    "* Mobile Recharge - 799\n",
    "* DTH recharge - 999\n",
    "* Clothes - 2310\n",
    "* Makeup - 3670\n",
    "* Shoes - 999\n",
    "\n",
    "A) Find out total expenses of each of you.\\\n",
    "B) Find out who spending more\\\n",
    "C) Find out in which thing you and your wife spending more "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "My total expense: 5679\n",
      "My wife's total expense: 5679\n",
      "\n",
      "My wife's expense is more than mine\n"
     ]
    }
   ],
   "source": [
    "your_expense={\n",
    "            'clothes':1100,\n",
    "            'shoes':1000,\n",
    "            'watch':900,\n",
    "            'mobile recharge':699,\n",
    "            'petrol':1980\n",
    "}\n",
    "\n",
    "your_wife={\n",
    "            'mobile recharge':799,\n",
    "            'dth recharge': 999,\n",
    "            'clothes': 2310,\n",
    "            'makeup': 3670,\n",
    "            'shoes': 999\n",
    "}\n",
    "\n",
    "tot, tot1=0,0\n",
    "for i in your_expense:\n",
    "    tot+=your_expense[i]\n",
    "print(f\"My total expense: {tot}\")\n",
    "for i in your_wife:\n",
    "    tot1+=your_wife[i]\n",
    "print(f\"My wife's total expense: {tot}\")\n",
    "\n",
    "print()\n",
    "if tot>tot1:\n",
    "    print(\"My expense is more than my wife\")\n",
    "elif tot<tot1:\n",
    "    print(\"My wife's expense is more than mine\")\n",
    "else:\n",
    "    print(\"BOTH ARE SAME\")\n",
    "\n",
    "\n",
    "def sort_the_dict(dictionary):\n",
    "    # because we need to sord the dictionary according to the values\n",
    "    sorted_dict = sorted(dictionary.items(), key=lambda kv:kv[1])\n",
    "    \n",
    "    return sorted_dict\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('mobile recharge', 699),\n",
       " ('watch', 900),\n",
       " ('shoes', 1000),\n",
       " ('clothes', 1100),\n",
       " ('petrol', 1980)]"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sort_the_dict(your_expense)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[('mobile recharge', 799),\n",
       " ('dth recharge', 999),\n",
       " ('shoes', 999),\n",
       " ('clothes', 2310),\n",
       " ('makeup', 3670)]"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sort_the_dict(your_wife)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You spent more on: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "('petrol', 1980)"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"You spent more on: \")\n",
    "sort_the_dict(your_expense)[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Your wife spent more on: \n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "('makeup', 3670)"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(\"Your wife spent more on: \")\n",
    "sort_the_dict(your_wife)[-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9. Modules, Pip"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 10. File Handling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Teacher: Why are you late, raghu?\n",
      "\n",
      "Raghu: Because of the sign\n",
      "\n",
      "Teacher: What sign?\n",
      "\n",
      "Raghu: The one that says \"School Ahead, Go slow\"\n"
     ]
    }
   ],
   "source": [
    "f= open(\"D:\\\\365datascience\\\\Python\\\\codebasics_python\\\\1_python_basics_code\\\\10_file_handling\\\\funny.txt\",'r')\n",
    "\n",
    "for i in f:\n",
    "    print(i)\n",
    "\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Teacher: Why are you late, raghu?\n",
      "\n",
      "Raghu: Because of the sign\n",
      "\n",
      "Teacher: What sign?\n",
      "\n",
      "Raghu: The one that says \"School Ahead, Go slow\"\n"
     ]
    }
   ],
   "source": [
    "with open(\"D:\\\\365datascience\\\\Python\\\\codebasics_python\\\\1_python_basics_code\\\\10_file_handling\\\\funny.txt\",'r') as f:\n",
    "    for i in f:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Teacher: Why are you late, raghu?\\n', 'Raghu: Because of the sign\\n', 'Teacher: What sign?\\n', 'Raghu: The one that says \"School Ahead, Go slow\"']\n"
     ]
    }
   ],
   "source": [
    "f= open(\"D:\\\\365datascience\\\\Python\\\\codebasics_python\\\\1_python_basics_code\\\\10_file_handling\\\\funny.txt\",'r')\n",
    "print(f.readlines())\n",
    "\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [],
   "source": [
    "f=open(\"D:\\\\365datascience\\\\Python\\\\codebasics_python\\\\1_python_basics_code\\\\10_file_handling\\\\love.txt\",'w')\n",
    "f.write(\"I love python\")\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "f=open(\"D:\\\\365datascience\\\\Python\\\\codebasics_python\\\\1_python_basics_code\\\\10_file_handling\\\\love.txt\",'w')\n",
    "f.writelines([\"I love python\\n\",\n",
    "\"I love Java\\n\", \"I love C++\"\n",
    "])\n",
    "f.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'rohit': [9, 120, 105, 140, 130], 'shakib': [56, 78, 102, 72], 'babar': [56, 45, 120, 5, 67]}\n",
      "rohit==>Min:9, Max:140, Avg:100.8\n",
      "shakib==>Min:56, Max:102, Avg:77.0\n",
      "babar==>Min:5, Max:120, Avg:58.6\n"
     ]
    }
   ],
   "source": [
    "player_scores = {}\n",
    "with open(\"D:\\\\365datascience\\\\Python\\\\codebasics_python\\\\1_python_basics_code\\\\10_file_handling\\\\scores.csv\",\"r\") as f:\n",
    "    for line in f:\n",
    "        tokens = line.split(',')\n",
    "        player = tokens[0]\n",
    "        score = int(tokens[1])\n",
    "        if player in player_scores:\n",
    "            player_scores[player].append(score)\n",
    "        else:\n",
    "            player_scores[player] = [score]\n",
    "\n",
    "print(player_scores)\n",
    "\n",
    "for player, score_list in player_scores.items():\n",
    "    min_score=min(score_list)\n",
    "    max_score=max(score_list)\n",
    "    avg_score=sum(score_list)/len(score_list)\n",
    "\n",
    "    print(f\"{player}==>Min:{min_score}, Max:{max_score}, Avg:{avg_score}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. student_marks.csv contains the marks and other details for some students. Write a python program to:\n",
    "- Open the file in read mode\n",
    "- Create dictionary from the given data\n",
    "- Add a new field to the dictionary `total_marks` and store total marks of the students.\n",
    "- Add new field to the dictionary `Average` and store average marks of the students\n",
    "- Sort the data according to the average marks of the students\n",
    "- Create a new file and write this information to the new file\n",
    "\t(https://www.kaggle.com/arunkumar413/student-marks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open(\"D:\\\\365datascience\\\\Python\\\\codebasics_python\\\\1_python_basics_code\\\\10_file_handling\\\\student_marks.csv\", 'r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "',Gender,DOB,Maths,Physics,Chemistry,English,Biology,Economics,History,Civics\\nJohn,M,05/04/1988,55,45,56,87,21,52,89,65\\nSuresh,M,4/5/1987,75,55,,64,90,61,58,2\\nRamesh,M,25/5/1989,25,54,89,76,95,87,56,74\\nJessica,F,12/8/1990,78,55,86,63,54,89,75,45\\nJennifer,F,2/9/1989,58,96,78,46,96,77,83,53'"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "',Gender,DOB,Maths,Physics,Chemistry,English,Biology,Economics,History,Civics\\n'"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.seek(0)\n",
    "d={}\n",
    "keys = f.readline()\n",
    "keys\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['',\n",
       " 'Gender',\n",
       " 'DOB',\n",
       " 'Maths',\n",
       " 'Physics',\n",
       " 'Chemistry',\n",
       " 'English',\n",
       " 'Biology',\n",
       " 'Economics',\n",
       " 'History',\n",
       " 'Civics\\n']"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "keys = keys.split(',')\n",
    "keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'': [], 'Gender': [], 'DOB': [], 'Maths': [], 'Physics': [], 'Chemistry': [], 'English': [], 'Biology': [], 'Economics': [], 'History': [], 'Civics\\n': []}\n"
     ]
    }
   ],
   "source": [
    "for key in keys:\n",
    "    d[key]=[]\n",
    "\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'': ['John', 'Suresh', 'Ramesh', 'Jessica', 'Jennifer'], 'Gender': ['M', 'M', 'M', 'F', 'F'], 'DOB': ['05/04/1988', '4/5/1987', '25/5/1989', '12/8/1990', '2/9/1989'], 'Maths': ['55', '75', '25', '78', '58'], 'Physics': ['45', '55', '54', '55', '96'], 'Chemistry': ['56', '', '89', '86', '78'], 'English': ['87', '64', '76', '63', '46'], 'Biology': ['21', '90', '95', '54', '96'], 'Economics': ['52', '61', '87', '89', '77'], 'History': ['89', '58', '56', '75', '83'], 'Civics\\n': ['65\\n', '2\\n', '74\\n', '45\\n', '53']}\n"
     ]
    }
   ],
   "source": [
    "for line in f.readlines():\n",
    "    data=line.split(',')\n",
    "    j=0\n",
    "    for i in d:\n",
    "        d[i].append(data[j])\n",
    "        j += 1\n",
    "\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'': ['John', 'Suresh', 'Ramesh', 'Jessica', 'Jennifer'],\n",
      " 'Biology': ['21', '90', '95', '54', '96'],\n",
      " 'Chemistry': ['56', '', '89', '86', '78'],\n",
      " 'Civics\\n': ['65\\n', '2\\n', '74\\n', '45\\n', '53'],\n",
      " 'DOB': ['05/04/1988', '4/5/1987', '25/5/1989', '12/8/1990', '2/9/1989'],\n",
      " 'Economics': ['52', '61', '87', '89', '77'],\n",
      " 'English': ['87', '64', '76', '63', '46'],\n",
      " 'Gender': ['M', 'M', 'M', 'F', 'F'],\n",
      " 'History': ['89', '58', '56', '75', '83'],\n",
      " 'Maths': ['55', '75', '25', '78', '58'],\n",
      " 'Physics': ['45', '55', '54', '55', '96']}\n"
     ]
    }
   ],
   "source": [
    "import pprint\n",
    "pprint.pprint(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_values([['John', 'Suresh', 'Ramesh', 'Jessica', 'Jennifer'], ['M', 'M', 'M', 'F', 'F'], ['05/04/1988', '4/5/1987', '25/5/1989', '12/8/1990', '2/9/1989'], ['55', '75', '25', '78', '58'], ['45', '55', '54', '55', '96'], ['56', '', '89', '86', '78'], ['87', '64', '76', '63', '46'], ['21', '90', '95', '54', '96'], ['52', '61', '87', '89', '77'], ['89', '58', '56', '75', '83'], ['65\\n', '2\\n', '74\\n', '45\\n', '53']])"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d.values()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[940, 810, 1112, 1090, 1174]\n"
     ]
    }
   ],
   "source": [
    "# Calculating the total marks\n",
    "d['Total Marks'] = [0]*5\n",
    "for i in range(5):\n",
    "    for key in d:\n",
    "        try:\n",
    "            d['Total Marks'][i] += int(d[key][i])\n",
    "        except:\n",
    "            pass\n",
    "print(d['Total Marks'])\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "  print(1)\n",
    "  print(20 / 0)\n",
    "  print(2)\n",
    "except ZeroDivisionError:\n",
    "  print(3)\n",
    "finally:\n",
    "  print(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 11. Class & Object"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<__main__.Avenger object at 0x000001FFEA902A50>\n",
      "\n",
      "    Avenger Profile:\n",
      "\n",
      "    Name: Black Widow\n",
      "    Age: 35\n",
      "    Gender: F\n",
      "\n",
      "    has Batons weapon & superhuman super power.\n",
      "    \n"
     ]
    }
   ],
   "source": [
    "class Avenger:\n",
    "\n",
    "  def __init__(self, name, age, gender, superpower, weapon):\n",
    "    self.name = name\n",
    "    self.age = age\n",
    "    self.gender = gender\n",
    "    self.superpower = superpower\n",
    "    self.weapon = weapon\n",
    "\n",
    "  def get_name(self):\n",
    "    return self.name\n",
    "\n",
    "  def get_age(self):\n",
    "    return self.age\n",
    "\n",
    "  def get_superpower(self):\n",
    "    return self.superpower\n",
    "\n",
    "  def get_info(self):\n",
    "    return f\"\"\"\n",
    "    Avenger Profile:\n",
    "\n",
    "    Name: {self.name}\n",
    "    Age: {self.age}\n",
    "    Gender: {self.gender}\n",
    "\n",
    "    has {self.weapon} weapon & {self.superpower} super power.\n",
    "    \"\"\"\n",
    "\n",
    "\n",
    "Super_heroes = ['Captain America', 'Iron Man', 'Black Widow', 'Hulk', 'Thor', 'Hawkeye']\n",
    "super_powers = ['Super strength', 'Technology', 'superhuman', 'Unlimited Strength', 'super Energy', 'fighting skills']\n",
    "weapons = [\"Shield\", \"Armor\", \"Batons\", \"No Weapon\", \"Mjölnir\", \"Bow and Arrows\"]\n",
    "\n",
    "ages = [110, 40, 35, 34, 10000, 30]\n",
    "genders = ['M', 'M', 'F', 'M', 'M', 'M']\n",
    "\n",
    "avengers = []\n",
    "for name, age, gender, power, weapon in zip(Super_heroes, ages, genders, super_powers, weapons):\n",
    "    avengers.append(\n",
    "        Avenger(name, age, gender, power, weapon)\n",
    "    )\n",
    "\n",
    "print(avengers[0])\n",
    "print(avengers[2].get_info())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 12. Inheritance"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Creating the base class\n",
    "\n",
    "class MobilePhone:\n",
    "\n",
    "    def __init__(self, screenType, networkType, dualSim, frontCamera, camera, RAM, storage):\n",
    "        self.screenType = screenType\n",
    "        self.networkType = networkType\n",
    "        self.dualSim = dualSim\n",
    "        self.frontCamera = frontCamera\n",
    "        self.camera = camera\n",
    "        self.RAM = RAM\n",
    "        self.storage = storage\n",
    "\n",
    "    def make_call(self):\n",
    "        pass\n",
    "\n",
    "    def recieve_call(self):\n",
    "        pass\n",
    "\n",
    "    def take_a_picture(self):\n",
    "        pass\n",
    "\n",
    "     \n",
    "# Let's create Apple Class\n",
    "class Apple(MobilePhone):\n",
    "\n",
    "    def __init__(self, productName, networkType, RAM, storage):\n",
    "        self.productName = productName\n",
    "        super().__init__(screenType='Touch Screen',\n",
    "                         camera=\"12MP\",\n",
    "                         frontCamera=\"8MP\",\n",
    "                         dualSim=False,\n",
    "                         networkType=networkType,\n",
    "                         RAM=RAM,\n",
    "                         storage=storage)\n",
    "        \n",
    "    def make_call(self):\n",
    "        print(f\"Making a call from {self.productName} Apple mobile phone.\")\n",
    "\n",
    "    def recieve_call(self):\n",
    "        print(f\"Recieving a call on {self.productName} Apple mobile phone.\")\n",
    "\n",
    "    def take_a_picture(self):\n",
    "        return f\"Taking Picture on {self.productName} with {self.camera} camera\"\n",
    "\n",
    "    def get_info(self):\n",
    "        return f\"\"\"Product Name: {self.productName}\n",
    "        Camera: {self.camera}\n",
    "        Network Type: {self.networkType}\n",
    "        ...\n",
    "        \"\"\"\n",
    "        # etc\n",
    "\n",
    "\n",
    "    def __str__(self) -> str:\n",
    "        return f\"Apple({self.productName}, {self.storage}, ...)\"\n",
    "    \n",
    "\n",
    "# creating samsung Class\n",
    "class Samsung(MobilePhone):\n",
    "\n",
    "    def __init__(self, productName, networkType, dualSim, frontCamera, camera, RAM, storage):\n",
    "        self.productName = productName\n",
    "        super().__init__(screenType='Touch Screen',\n",
    "                         camera=camera,\n",
    "                         frontCamera=frontCamera,\n",
    "                         dualSim=dualSim,\n",
    "                         networkType=networkType,\n",
    "                         RAM=RAM,\n",
    "                         storage=storage)\n",
    "        \n",
    "    def make_call(self):\n",
    "        print(f\"Making a call from {self.productName} Samsung mobile phone.\")\n",
    "\n",
    "    def recieve_call(self):\n",
    "        print(f\"Recieving a call on {self.productName} Samsung mobile phone.\")\n",
    "\n",
    "    def take_a_picture(self):\n",
    "        return f\"Taking Picture on {self.productName} with {self.camera} camera\"\n",
    "\n",
    "    def get_info(self):\n",
    "        return f\"\"\"Product Name: {self.productName}\n",
    "        Camera: {self.camera}\n",
    "        Network Type: {self.networkType}\n",
    "        ...\n",
    "        \"\"\"\n",
    "        # etc\n",
    "\n",
    "\n",
    "    def __str__(self) -> str:\n",
    "        return f\"Samsung({self.productName}, {self.storage}, ...)\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# apple phones\n",
    "\n",
    "apple1 = Apple(\"Iphone6\", \"4G\", \"4GB\", \"64GB\")\n",
    "apple2 = Apple(\"Iphone8\", \"5G\", \"6GB\", \"128GB\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Samsung Phones\n",
    "\n",
    "samsung1 = Samsung(\"Samsung1\", \"4G\", True, \"16MP\", \"32MP\", \"4GB\", \"64GB\")\n",
    "samsung2 = Samsung(\"Samsung2\", \"3G\", True, \"8MP\", \"16MP\", \"3GB\", \"16GB\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Apple(Iphone6, 64GB, ...)\n",
      "Making a call from Iphone8 Apple mobile phone.\n"
     ]
    }
   ],
   "source": [
    "print(apple1)\n",
    "apple2.make_call()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recieving a call on Samsung1 Samsung mobile phone.\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'Taking Picture on Iphone6 with 12MP camera'"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "samsung1.recieve_call()\n",
    "apple1.take_a_picture()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Product Name: Samsung2\n",
      "        Camera: 16MP\n",
      "        Network Type: 3G\n",
      "        ...\n",
      "        \n"
     ]
    }
   ],
   "source": [
    "print(samsung2.get_info())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 13. Exception Handling"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1. You have the following python code.\n",
    "\n",
    "```py\n",
    "\tlst = [int(x) for x in input().split()]\n",
    "\ti = int(input(“Enter Index: “)\n",
    "    print(lst[i])\n",
    "```\n",
    "Use Exception Handling to handle the exception which will occur in this program.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndexError",
     "evalue": "list index out of range",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mIndexError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[8], line 3\u001b[0m\n\u001b[0;32m      1\u001b[0m lst \u001b[38;5;241m=\u001b[39m [\u001b[38;5;28mint\u001b[39m(x) \u001b[38;5;28;01mfor\u001b[39;00m x \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28minput\u001b[39m()\u001b[38;5;241m.\u001b[39msplit()]\n\u001b[0;32m      2\u001b[0m i \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mint\u001b[39m(\u001b[38;5;28minput\u001b[39m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mEnter Index: \u001b[39m\u001b[38;5;124m\"\u001b[39m))\n\u001b[1;32m----> 3\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mlst\u001b[49m\u001b[43m[\u001b[49m\u001b[43mi\u001b[49m\u001b[43m]\u001b[49m)\n",
      "\u001b[1;31mIndexError\u001b[0m: list index out of range"
     ]
    }
   ],
   "source": [
    "lst = [int(x) for x in input().split()]\n",
    "i = int(input(\"Enter Index: \"))\n",
    "print(lst[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 3. You have certain employee records as a list of dictionaries. The dictionary contains the following information.\n",
    "`Employee = {“id”: id, “first_name”: fname, “middle_name”: mname, “last_name”: lname}`\n",
    "\n",
    "You are using this code to print the full name of each employee:\n",
    "\n",
    "    for employee in employees:\n",
    "        full_name  = employee[‘first_name’] + employee[‘middle_name’] + employee[‘last_name’]\n",
    "\t    print(full_name)\n",
    "\n",
    "But some employees don’t have a middle_name, so the `middle_name` key will not be present in the dictionary. Use Exception handling to correctly print the full names of your employees.\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "employees = [\n",
    "    {\"id\": 1, \"first_name\": \"Karan \", \"middle_name\": \"Rama \", \"last_name\": \"Reddy\"},\n",
    "    {\"id\": 2, \"first_name\": \"Alex \", \"last_name\": \"Gorge\"},\n",
    "    {\"id\": 3, \"first_name\": \"Alice \", \"middle_name\": \"M \", \"last_name\": \"Warner\"},\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Karan Rama Reddy\n"
     ]
    },
    {
     "ename": "KeyError",
     "evalue": "'middle_name'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[10], line 2\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m employee \u001b[38;5;129;01min\u001b[39;00m employees:\n\u001b[1;32m----> 2\u001b[0m     full_name \u001b[38;5;241m=\u001b[39m employee[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mfirst_name\u001b[39m\u001b[38;5;124m'\u001b[39m] \u001b[38;5;241m+\u001b[39m \u001b[43memployee\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mmiddle_name\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m]\u001b[49m \u001b[38;5;241m+\u001b[39m employee[\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mlast_name\u001b[39m\u001b[38;5;124m'\u001b[39m]\n\u001b[0;32m      3\u001b[0m     \u001b[38;5;28mprint\u001b[39m(full_name)\n",
      "\u001b[1;31mKeyError\u001b[0m: 'middle_name'"
     ]
    }
   ],
   "source": [
    "for employee in employees:\n",
    "    full_name = employee['first_name'] + employee['middle_name'] + employee['last_name']\n",
    "    print(full_name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Karan Rama Reddy\n",
      "Alex Gorge\n",
      "Alice M Warner\n"
     ]
    }
   ],
   "source": [
    "for employee in employees:\n",
    "    try:\n",
    "        full_name = employee['first_name'] + employee['middle_name'] + employee['last_name']\n",
    "    except KeyError:\n",
    "        full_name = employee['first_name'] + employee['last_name']\n",
    "    finally:\n",
    "        print(full_name)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "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.12.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}