Impetus Day 1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello\n"
     ]
    }
   ],
   "source": [
    "print ('hello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 'hello'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2345085634352"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1680700224"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "b = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1680700224"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 1111"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2345085514480"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "b = 1111"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2345085514544"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 'hello world'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 'great'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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 key in self.\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __format__(...)\n",
      " |      S.__format__(format_spec) -> str\n",
      " |      \n",
      " |      Return a formatted version of S 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",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __new__(*args, **kwargs) from builtins.type\n",
      " |      Create and return a new object.  See help(type) for accurate signature.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __rmod__(self, value, /)\n",
      " |      Return value%self.\n",
      " |  \n",
      " |  __rmul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __sizeof__(...)\n",
      " |      S.__sizeof__() -> size of S in memory, in bytes\n",
      " |  \n",
      " |  __str__(self, /)\n",
      " |      Return str(self).\n",
      " |  \n",
      " |  capitalize(...)\n",
      " |      S.capitalize() -> str\n",
      " |      \n",
      " |      Return a capitalized version of S, i.e. make the first character\n",
      " |      have upper case and the rest lower case.\n",
      " |  \n",
      " |  casefold(...)\n",
      " |      S.casefold() -> str\n",
      " |      \n",
      " |      Return a version of S suitable for caseless comparisons.\n",
      " |  \n",
      " |  center(...)\n",
      " |      S.center(width[, fillchar]) -> str\n",
      " |      \n",
      " |      Return S centered in a string of length width. Padding is\n",
      " |      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(...)\n",
      " |      S.encode(encoding='utf-8', errors='strict') -> bytes\n",
      " |      \n",
      " |      Encode S using the codec registered for encoding. Default encoding\n",
      " |      is 'utf-8'. errors may be given to set a different error\n",
      " |      handling scheme. Default is 'strict' meaning that encoding errors raise\n",
      " |      a 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(...)\n",
      " |      S.expandtabs(tabsize=8) -> str\n",
      " |      \n",
      " |      Return a copy of S where all tab characters are expanded using spaces.\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",
      " |      Like S.find() but raise ValueError when the substring is not found.\n",
      " |  \n",
      " |  isalnum(...)\n",
      " |      S.isalnum() -> bool\n",
      " |      \n",
      " |      Return True if all characters in S are alphanumeric\n",
      " |      and there is at least one character in S, False otherwise.\n",
      " |  \n",
      " |  isalpha(...)\n",
      " |      S.isalpha() -> bool\n",
      " |      \n",
      " |      Return True if all characters in S are alphabetic\n",
      " |      and there is at least one character in S, False otherwise.\n",
      " |  \n",
      " |  isdecimal(...)\n",
      " |      S.isdecimal() -> bool\n",
      " |      \n",
      " |      Return True if there are only decimal characters in S,\n",
      " |      False otherwise.\n",
      " |  \n",
      " |  isdigit(...)\n",
      " |      S.isdigit() -> bool\n",
      " |      \n",
      " |      Return True if all characters in S are digits\n",
      " |      and there is at least one character in S, False otherwise.\n",
      " |  \n",
      " |  isidentifier(...)\n",
      " |      S.isidentifier() -> bool\n",
      " |      \n",
      " |      Return True if S is a valid identifier according\n",
      " |      to the language definition.\n",
      " |      \n",
      " |      Use keyword.iskeyword() to test for reserved identifiers\n",
      " |      such as \"def\" and \"class\".\n",
      " |  \n",
      " |  islower(...)\n",
      " |      S.islower() -> bool\n",
      " |      \n",
      " |      Return True if all cased characters in S are lowercase and there is\n",
      " |      at least one cased character in S, False otherwise.\n",
      " |  \n",
      " |  isnumeric(...)\n",
      " |      S.isnumeric() -> bool\n",
      " |      \n",
      " |      Return True if there are only numeric characters in S,\n",
      " |      False otherwise.\n",
      " |  \n",
      " |  isprintable(...)\n",
      " |      S.isprintable() -> bool\n",
      " |      \n",
      " |      Return True if all characters in S are considered\n",
      " |      printable in repr() or S is empty, False otherwise.\n",
      " |  \n",
      " |  isspace(...)\n",
      " |      S.isspace() -> bool\n",
      " |      \n",
      " |      Return True if all characters in S are whitespace\n",
      " |      and there is at least one character in S, False otherwise.\n",
      " |  \n",
      " |  istitle(...)\n",
      " |      S.istitle() -> bool\n",
      " |      \n",
      " |      Return True if S is a titlecased string and there is at least one\n",
      " |      character in S, i.e. upper- and titlecase characters may only\n",
      " |      follow uncased characters and lowercase characters only cased ones.\n",
      " |      Return False otherwise.\n",
      " |  \n",
      " |  isupper(...)\n",
      " |      S.isupper() -> bool\n",
      " |      \n",
      " |      Return True if all cased characters in S are uppercase and there is\n",
      " |      at least one cased character in S, False otherwise.\n",
      " |  \n",
      " |  join(...)\n",
      " |      S.join(iterable) -> str\n",
      " |      \n",
      " |      Return a string which is the concatenation of the strings in the\n",
      " |      iterable.  The separator between elements is S.\n",
      " |  \n",
      " |  ljust(...)\n",
      " |      S.ljust(width[, fillchar]) -> str\n",
      " |      \n",
      " |      Return S left-justified in a Unicode string of length width. Padding is\n",
      " |      done using the specified fill character (default is a space).\n",
      " |  \n",
      " |  lower(...)\n",
      " |      S.lower() -> str\n",
      " |      \n",
      " |      Return a copy of the string S converted to lowercase.\n",
      " |  \n",
      " |  lstrip(...)\n",
      " |      S.lstrip([chars]) -> str\n",
      " |      \n",
      " |      Return a copy of the string S with leading whitespace removed.\n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  partition(...)\n",
      " |      S.partition(sep) -> (head, sep, tail)\n",
      " |      \n",
      " |      Search for the separator sep in S, and return the part before it,\n",
      " |      the separator itself, and the part after it.  If the separator is not\n",
      " |      found, return S and two empty strings.\n",
      " |  \n",
      " |  replace(...)\n",
      " |      S.replace(old, new[, count]) -> str\n",
      " |      \n",
      " |      Return a copy of S with all occurrences of substring\n",
      " |      old replaced by new.  If the optional argument count is\n",
      " |      given, only the first count occurrences are 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",
      " |      Like S.rfind() but raise ValueError when the substring is not found.\n",
      " |  \n",
      " |  rjust(...)\n",
      " |      S.rjust(width[, fillchar]) -> str\n",
      " |      \n",
      " |      Return S right-justified in a string of length width. Padding is\n",
      " |      done using the specified fill character (default is a space).\n",
      " |  \n",
      " |  rpartition(...)\n",
      " |      S.rpartition(sep) -> (head, sep, tail)\n",
      " |      \n",
      " |      Search for the separator sep in S, starting at the end of S, and return\n",
      " |      the part before it, the separator itself, and the part after it.  If the\n",
      " |      separator is not found, return two empty strings and S.\n",
      " |  \n",
      " |  rsplit(...)\n",
      " |      S.rsplit(sep=None, maxsplit=-1) -> list of strings\n",
      " |      \n",
      " |      Return a list of the words in S, using sep as the\n",
      " |      delimiter string, starting at the end of the string and\n",
      " |      working to the front.  If maxsplit is given, at most maxsplit\n",
      " |      splits are done. If sep is not specified, any whitespace string\n",
      " |      is a separator.\n",
      " |  \n",
      " |  rstrip(...)\n",
      " |      S.rstrip([chars]) -> str\n",
      " |      \n",
      " |      Return a copy of the string S with trailing whitespace removed.\n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  split(...)\n",
      " |      S.split(sep=None, maxsplit=-1) -> list of strings\n",
      " |      \n",
      " |      Return a list of the words in S, using sep as the\n",
      " |      delimiter string.  If maxsplit is given, at most maxsplit\n",
      " |      splits are done. If sep is not specified or is None, any\n",
      " |      whitespace string is a separator and empty strings are\n",
      " |      removed from the result.\n",
      " |  \n",
      " |  splitlines(...)\n",
      " |      S.splitlines([keepends]) -> list of strings\n",
      " |      \n",
      " |      Return a list of the lines in S, breaking at line boundaries.\n",
      " |      Line breaks are not included in the resulting list unless keepends\n",
      " |      is given and 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(...)\n",
      " |      S.strip([chars]) -> str\n",
      " |      \n",
      " |      Return a copy of the string S with leading and trailing\n",
      " |      whitespace removed.\n",
      " |      If chars is given and not None, remove characters in chars instead.\n",
      " |  \n",
      " |  swapcase(...)\n",
      " |      S.swapcase() -> str\n",
      " |      \n",
      " |      Return a copy of S with uppercase characters converted to lowercase\n",
      " |      and vice versa.\n",
      " |  \n",
      " |  title(...)\n",
      " |      S.title() -> str\n",
      " |      \n",
      " |      Return a titlecased version of S, i.e. words start with title case\n",
      " |      characters, all remaining cased characters have lower case.\n",
      " |  \n",
      " |  translate(...)\n",
      " |      S.translate(table) -> str\n",
      " |      \n",
      " |      Return a copy of the string S in which each character has been mapped\n",
      " |      through the given translation table. The table must implement\n",
      " |      lookup/indexing via __getitem__, for instance a dictionary or list,\n",
      " |      mapping Unicode ordinals to Unicode ordinals, strings, or None. If\n",
      " |      this operation raises LookupError, the character is left untouched.\n",
      " |      Characters mapped to None are deleted.\n",
      " |  \n",
      " |  upper(...)\n",
      " |      S.upper() -> str\n",
      " |      \n",
      " |      Return a copy of S converted to uppercase.\n",
      " |  \n",
      " |  zfill(...)\n",
      " |      S.zfill(width) -> str\n",
      " |      \n",
      " |      Pad a numeric string S with zeros on the left, to fill a field\n",
      " |      of the specified width. The string S is never truncated.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static methods defined here:\n",
      " |  \n",
      " |  maketrans(x, y=None, z=None, /)\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": [
    "help(str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"abc\" < \"def\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Great'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.capitalize()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'great'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = (2,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"hello abc\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "t = a.maketrans(\"aeiou\",\"12345\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'h2ll4 1bc'"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.translate(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = 'i don\"t know'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a,b = 1,2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "b,a = a,b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l = [1,2,3,4,5,1,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "m = l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l[0] = 999"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[999, 2, 3, 4, 5, 1, 3]"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "k = list(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l[0] = 98989"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[98989, 2, 3, 4, 5, 1, 3]"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[999, 2, 3, 4, 5, 1, 3]"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "k"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l = [1,2,[4,5],[6,7,8]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "m = list(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m[-1][-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "m[-1][-1] = 888"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, [4, 5], [6, 7, 888]]"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, [4, 5], [6, 7, 888]]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = \"abcdef\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'abc'"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'def'"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[-3:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'fedcba'"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'fdb'"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a[::-2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[6, 7, 888], [4, 5], 2, 1]"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[::-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "l.reverse()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[6, 7, 888], [4, 5], 2, 1]"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l.append('hello')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[6, 7, 888], [4, 5], 2, 1, 'hello']"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l = [44,2,3,11,66,444]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[44, 2, 3, 11, 66, 444]"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l.sort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 3, 11, 44, 66, 444]"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l = [[1,\"hello\"], [4,\"good\"], [2,\"boy\"]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 'hello'], [4, 'good'], [2, 'boy']]"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l.sort()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 'hello'], [2, 'boy'], [4, 'good']]"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def f(e):\n",
    "    return e[1]\n",
    "\n",
    "l.sort(key=f)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[2, 'boy'], [4, 'good'], [1, 'hello']]"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = lambda x,y:x+y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a(5,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "max_my = lambda x,y: x if x > y else y"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max_my(5,6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-115-9c45b7965cb8>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[1;36m  File \u001b[1;32m\"<ipython-input-115-9c45b7965cb8>\"\u001b[1;36m, line \u001b[1;32m1\u001b[0m\n\u001b[1;33m    m = lambda x,y: \"Equal\" if x == y\u001b[0m\n\u001b[1;37m                                      ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "m = lambda x,y: \"Equal\" if x == y "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l = [1,2,3,4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = map(lambda x:x+5, l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[6, 7, 8, 9]"
      ]
     },
     "execution_count": 114,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "7\n",
      "8\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in m:\n",
    "    print (i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l = ['1','2','3','4','5']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "k = list(map(lambda x:int(x),l))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 122,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "max(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(k)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "db = dict()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [],
   "source": [
    "db = {\n",
    "    'a':1, 'b':2, 'c':3, 'd':4\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "db['a']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Not Present\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print (db['y'])\n",
    "except:\n",
    "    print ('Not Present')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('b', 2), ('c', 3), ('a', 1), ('d', 4)])"
      ]
     },
     "execution_count": 132,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "db.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_keys(['b', 'c', 'a', 'd'])"
      ]
     },
     "execution_count": 133,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "db.keys()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "db = {\n",
    "    'a':1, 'b':2, 'c':3, 'd':{'a':8, 'b':9}\n",
    "}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "db['d']['b']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unhashable type: 'list'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-139-1cd7e7d25323>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mhash\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'a'\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;34m'b'\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: unhashable type: 'list'"
     ]
    }
   ],
   "source": [
    "hash(['a','b'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 'b': 2, 'c': 3, 'd': {'a': 8, 'b': 9}}"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "db"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "db = {'a':1, 'b':1, 'c':3, 'd':4}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: ['a', 'b'], 3: 'c', 4: 'd'}"
      ]
     },
     "execution_count": 142,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{1:['a','b'],3:'c',4:'d'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_db = {}\n",
    "for k,v in db.items():\n",
    "    if v in new_db:\n",
    "        new_db[v].append(k)\n",
    "    else:\n",
    "        new_db[v] = [k]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1: ['b', 'a'], 3: ['c'], 4: ['d']}"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_db"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "341 µs ± 13.8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%timeit sum(range(10000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dict_items([('b', 1), ('c', 3), ('a', 1), ('d', 4)])"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "db.items()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = (1,)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "b = (1,2,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 152,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.count(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b.index(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def f(arg1,arg2):\n",
    "    print (arg1+arg2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "f(1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l = (1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "f(*l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(*args):\n",
    "    print (type(args))\n",
    "    return sum(args)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(1,2,3,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(4,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def f(a,b):\n",
    "    return a+b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "l = [1,2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(*l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "g = f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "g(*l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(name='abc',place='blr'):\n",
    "    print (name,place)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "jhjs hshs\n"
     ]
    }
   ],
   "source": [
    "f(place='hshs',name='jhjs')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def f():\n",
    "    return 1,2,\"hello\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "a = f()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tuple"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def vargs(age, *vargs, **kwargs):\n",
    "    print (age, vargs)\n",
    "    print (kwargs['a'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6 ()\n",
      "['a', 'b']\n"
     ]
    }
   ],
   "source": [
    "vargs(6,a=['a','b'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "77 (1, 2)\n",
      "abc\n"
     ]
    }
   ],
   "source": [
    "vargs(77,1,2,a='abc')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 219,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "db = {'name':'Awantik','age':'10','loc':'Blore'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def f(age:int,name,**args):\n",
    "    print (type(age))\n",
    "    print (age,name,args)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "10 Awantik {'loc': 'Blore'}\n"
     ]
    }
   ],
   "source": [
    "f(**db)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 224,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def f(a:int, b):\n",
    "    print (2*a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "f(4,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 226,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'aaaa'"
      ]
     },
     "execution_count": 226,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2*'aa'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 228,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 228,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[i for i in range(10)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 229,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 2, 4, 6, 8]"
      ]
     },
     "execution_count": 229,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[i for i in range(10) if i%2 == 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 230,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[],\n",
       " [0],\n",
       " [0, 1],\n",
       " [0, 1, 2],\n",
       " [0, 1, 2, 3],\n",
       " [0, 1, 2, 3, 4],\n",
       " [0, 1, 2, 3, 4, 5],\n",
       " [0, 1, 2, 3, 4, 5, 6],\n",
       " [0, 1, 2, 3, 4, 5, 6, 7],\n",
       " [0, 1, 2, 3, 4, 5, 6, 7, 8]]"
      ]
     },
     "execution_count": 230,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[[j for j in range(i)] for i in range(10)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 231,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 234,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 235,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module os:\n",
      "\n",
      "NAME\n",
      "    os - OS routines for NT or Posix depending on what system we're on.\n",
      "\n",
      "DESCRIPTION\n",
      "    This exports:\n",
      "      - all functions from posix, nt or ce, e.g. unlink, stat, etc.\n",
      "      - os.path is either posixpath or ntpath\n",
      "      - os.name is either 'posix', 'nt' or 'ce'.\n",
      "      - os.curdir is a string representing the current directory ('.' or ':')\n",
      "      - os.pardir is a string representing the parent directory ('..' or '::')\n",
      "      - os.sep is the (or a most common) pathname separator ('/' or ':' or '\\\\')\n",
      "      - os.extsep is the extension separator (always '.')\n",
      "      - os.altsep is the alternate pathname separator (None or '/')\n",
      "      - os.pathsep is the component separator used in $PATH etc\n",
      "      - os.linesep is the line separator in text files ('\\r' or '\\n' or '\\r\\n')\n",
      "      - os.defpath is the default search path for executables\n",
      "      - os.devnull is the file path of the null device ('/dev/null', etc.)\n",
      "    \n",
      "    Programs that import and use 'os' stand a better chance of being\n",
      "    portable between different platforms.  Of course, they must then\n",
      "    only use functions that are defined by all platforms (e.g., unlink\n",
      "    and opendir), and leave all pathname manipulation to os.path\n",
      "    (e.g., split and join).\n",
      "\n",
      "CLASSES\n",
      "    builtins.Exception(builtins.BaseException)\n",
      "        builtins.OSError\n",
      "    builtins.tuple(builtins.object)\n",
      "        nt.times_result\n",
      "        nt.uname_result\n",
      "        stat_result\n",
      "        statvfs_result\n",
      "        terminal_size\n",
      "    \n",
      "    error = class OSError(Exception)\n",
      "     |  Base class for I/O related errors.\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      OSError\n",
      "     |      Exception\n",
      "     |      BaseException\n",
      "     |      object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __init__(self, /, *args, **kwargs)\n",
      "     |      Initialize self.  See help(type(self)) for accurate signature.\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      helper for pickle\n",
      "     |  \n",
      "     |  __str__(self, /)\n",
      "     |      Return str(self).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  characters_written\n",
      "     |  \n",
      "     |  errno\n",
      "     |      POSIX exception code\n",
      "     |  \n",
      "     |  filename\n",
      "     |      exception filename\n",
      "     |  \n",
      "     |  filename2\n",
      "     |      second exception filename\n",
      "     |  \n",
      "     |  strerror\n",
      "     |      exception strerror\n",
      "     |  \n",
      "     |  winerror\n",
      "     |      Win32 exception code\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from BaseException:\n",
      "     |  \n",
      "     |  __delattr__(self, name, /)\n",
      "     |      Implement delattr(self, name).\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  __setattr__(self, name, value, /)\n",
      "     |      Implement setattr(self, name, value).\n",
      "     |  \n",
      "     |  __setstate__(...)\n",
      "     |  \n",
      "     |  with_traceback(...)\n",
      "     |      Exception.with_traceback(tb) --\n",
      "     |      set self.__traceback__ to tb and return self.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors inherited from BaseException:\n",
      "     |  \n",
      "     |  __cause__\n",
      "     |      exception cause\n",
      "     |  \n",
      "     |  __context__\n",
      "     |      exception context\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |  \n",
      "     |  __suppress_context__\n",
      "     |  \n",
      "     |  __traceback__\n",
      "     |  \n",
      "     |  args\n",
      "    \n",
      "    class stat_result(builtins.tuple)\n",
      "     |  stat_result: Result from stat, fstat, or lstat.\n",
      "     |  \n",
      "     |  This object may be accessed either as a tuple of\n",
      "     |    (mode, ino, dev, nlink, uid, gid, size, atime, mtime, ctime)\n",
      "     |  or via the attributes st_mode, st_ino, st_dev, st_nlink, st_uid, and so on.\n",
      "     |  \n",
      "     |  Posix/windows: If your platform supports st_blksize, st_blocks, st_rdev,\n",
      "     |  or st_flags, they are available as attributes only.\n",
      "     |  \n",
      "     |  See os.stat for more information.\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      stat_result\n",
      "     |      builtins.tuple\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      helper for pickle\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  st_atime\n",
      "     |      time of last access\n",
      "     |  \n",
      "     |  st_atime_ns\n",
      "     |      time of last access in nanoseconds\n",
      "     |  \n",
      "     |  st_ctime\n",
      "     |      time of last change\n",
      "     |  \n",
      "     |  st_ctime_ns\n",
      "     |      time of last change in nanoseconds\n",
      "     |  \n",
      "     |  st_dev\n",
      "     |      device\n",
      "     |  \n",
      "     |  st_file_attributes\n",
      "     |      Windows file attribute bits\n",
      "     |  \n",
      "     |  st_gid\n",
      "     |      group ID of owner\n",
      "     |  \n",
      "     |  st_ino\n",
      "     |      inode\n",
      "     |  \n",
      "     |  st_mode\n",
      "     |      protection bits\n",
      "     |  \n",
      "     |  st_mtime\n",
      "     |      time of last modification\n",
      "     |  \n",
      "     |  st_mtime_ns\n",
      "     |      time of last modification in nanoseconds\n",
      "     |  \n",
      "     |  st_nlink\n",
      "     |      number of hard links\n",
      "     |  \n",
      "     |  st_size\n",
      "     |      total size, in bytes\n",
      "     |  \n",
      "     |  st_uid\n",
      "     |      user ID of owner\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  n_fields = 17\n",
      "     |  \n",
      "     |  n_sequence_fields = 10\n",
      "     |  \n",
      "     |  n_unnamed_fields = 3\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from builtins.tuple:\n",
      "     |  \n",
      "     |  __add__(self, value, /)\n",
      "     |      Return self+value.\n",
      "     |  \n",
      "     |  __contains__(self, key, /)\n",
      "     |      Return key in self.\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, 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",
      "     |  __mul__(self, value, /)\n",
      "     |      Return self*value.n\n",
      "     |  \n",
      "     |  __ne__(self, value, /)\n",
      "     |      Return self!=value.\n",
      "     |  \n",
      "     |  __rmul__(self, value, /)\n",
      "     |      Return self*value.\n",
      "     |  \n",
      "     |  count(...)\n",
      "     |      T.count(value) -> integer -- return number of occurrences of value\n",
      "     |  \n",
      "     |  index(...)\n",
      "     |      T.index(value, [start, [stop]]) -> integer -- return first index of value.\n",
      "     |      Raises ValueError if the value is not present.\n",
      "    \n",
      "    class statvfs_result(builtins.tuple)\n",
      "     |  statvfs_result: Result from statvfs or fstatvfs.\n",
      "     |  \n",
      "     |  This object may be accessed either as a tuple of\n",
      "     |    (bsize, frsize, blocks, bfree, bavail, files, ffree, favail, flag, namemax),\n",
      "     |  or via the attributes f_bsize, f_frsize, f_blocks, f_bfree, and so on.\n",
      "     |  \n",
      "     |  See os.statvfs for more information.\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      statvfs_result\n",
      "     |      builtins.tuple\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      helper for pickle\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  f_bavail\n",
      "     |  \n",
      "     |  f_bfree\n",
      "     |  \n",
      "     |  f_blocks\n",
      "     |  \n",
      "     |  f_bsize\n",
      "     |  \n",
      "     |  f_favail\n",
      "     |  \n",
      "     |  f_ffree\n",
      "     |  \n",
      "     |  f_files\n",
      "     |  \n",
      "     |  f_flag\n",
      "     |  \n",
      "     |  f_frsize\n",
      "     |  \n",
      "     |  f_namemax\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  n_fields = 10\n",
      "     |  \n",
      "     |  n_sequence_fields = 10\n",
      "     |  \n",
      "     |  n_unnamed_fields = 0\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from builtins.tuple:\n",
      "     |  \n",
      "     |  __add__(self, value, /)\n",
      "     |      Return self+value.\n",
      "     |  \n",
      "     |  __contains__(self, key, /)\n",
      "     |      Return key in self.\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, 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",
      "     |  __mul__(self, value, /)\n",
      "     |      Return self*value.n\n",
      "     |  \n",
      "     |  __ne__(self, value, /)\n",
      "     |      Return self!=value.\n",
      "     |  \n",
      "     |  __rmul__(self, value, /)\n",
      "     |      Return self*value.\n",
      "     |  \n",
      "     |  count(...)\n",
      "     |      T.count(value) -> integer -- return number of occurrences of value\n",
      "     |  \n",
      "     |  index(...)\n",
      "     |      T.index(value, [start, [stop]]) -> integer -- return first index of value.\n",
      "     |      Raises ValueError if the value is not present.\n",
      "    \n",
      "    class terminal_size(builtins.tuple)\n",
      "     |  A tuple of (columns, lines) for holding terminal window size\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      terminal_size\n",
      "     |      builtins.tuple\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      helper for pickle\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  columns\n",
      "     |      width of the terminal window in characters\n",
      "     |  \n",
      "     |  lines\n",
      "     |      height of the terminal window in characters\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  n_fields = 2\n",
      "     |  \n",
      "     |  n_sequence_fields = 2\n",
      "     |  \n",
      "     |  n_unnamed_fields = 0\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from builtins.tuple:\n",
      "     |  \n",
      "     |  __add__(self, value, /)\n",
      "     |      Return self+value.\n",
      "     |  \n",
      "     |  __contains__(self, key, /)\n",
      "     |      Return key in self.\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, 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",
      "     |  __mul__(self, value, /)\n",
      "     |      Return self*value.n\n",
      "     |  \n",
      "     |  __ne__(self, value, /)\n",
      "     |      Return self!=value.\n",
      "     |  \n",
      "     |  __rmul__(self, value, /)\n",
      "     |      Return self*value.\n",
      "     |  \n",
      "     |  count(...)\n",
      "     |      T.count(value) -> integer -- return number of occurrences of value\n",
      "     |  \n",
      "     |  index(...)\n",
      "     |      T.index(value, [start, [stop]]) -> integer -- return first index of value.\n",
      "     |      Raises ValueError if the value is not present.\n",
      "    \n",
      "    class times_result(builtins.tuple)\n",
      "     |  times_result: Result from os.times().\n",
      "     |  \n",
      "     |  This object may be accessed either as a tuple of\n",
      "     |    (user, system, children_user, children_system, elapsed),\n",
      "     |  or via the attributes user, system, children_user, children_system,\n",
      "     |  and elapsed.\n",
      "     |  \n",
      "     |  See os.times for more information.\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      times_result\n",
      "     |      builtins.tuple\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      helper for pickle\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  children_system\n",
      "     |      system time of children\n",
      "     |  \n",
      "     |  children_user\n",
      "     |      user time of children\n",
      "     |  \n",
      "     |  elapsed\n",
      "     |      elapsed time since an arbitrary point in the past\n",
      "     |  \n",
      "     |  system\n",
      "     |      system time\n",
      "     |  \n",
      "     |  user\n",
      "     |      user time\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  n_fields = 5\n",
      "     |  \n",
      "     |  n_sequence_fields = 5\n",
      "     |  \n",
      "     |  n_unnamed_fields = 0\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from builtins.tuple:\n",
      "     |  \n",
      "     |  __add__(self, value, /)\n",
      "     |      Return self+value.\n",
      "     |  \n",
      "     |  __contains__(self, key, /)\n",
      "     |      Return key in self.\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, 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",
      "     |  __mul__(self, value, /)\n",
      "     |      Return self*value.n\n",
      "     |  \n",
      "     |  __ne__(self, value, /)\n",
      "     |      Return self!=value.\n",
      "     |  \n",
      "     |  __rmul__(self, value, /)\n",
      "     |      Return self*value.\n",
      "     |  \n",
      "     |  count(...)\n",
      "     |      T.count(value) -> integer -- return number of occurrences of value\n",
      "     |  \n",
      "     |  index(...)\n",
      "     |      T.index(value, [start, [stop]]) -> integer -- return first index of value.\n",
      "     |      Raises ValueError if the value is not present.\n",
      "    \n",
      "    class uname_result(builtins.tuple)\n",
      "     |  uname_result: Result from os.uname().\n",
      "     |  \n",
      "     |  This object may be accessed either as a tuple of\n",
      "     |    (sysname, nodename, release, version, machine),\n",
      "     |  or via the attributes sysname, nodename, release, version, and machine.\n",
      "     |  \n",
      "     |  See os.uname for more information.\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      uname_result\n",
      "     |      builtins.tuple\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "     |  \n",
      "     |  __reduce__(...)\n",
      "     |      helper for pickle\n",
      "     |  \n",
      "     |  __repr__(self, /)\n",
      "     |      Return repr(self).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  machine\n",
      "     |      hardware identifier\n",
      "     |  \n",
      "     |  nodename\n",
      "     |      name of machine on network (implementation-defined)\n",
      "     |  \n",
      "     |  release\n",
      "     |      operating system release\n",
      "     |  \n",
      "     |  sysname\n",
      "     |      operating system name\n",
      "     |  \n",
      "     |  version\n",
      "     |      operating system version\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  n_fields = 5\n",
      "     |  \n",
      "     |  n_sequence_fields = 5\n",
      "     |  \n",
      "     |  n_unnamed_fields = 0\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from builtins.tuple:\n",
      "     |  \n",
      "     |  __add__(self, value, /)\n",
      "     |      Return self+value.\n",
      "     |  \n",
      "     |  __contains__(self, key, /)\n",
      "     |      Return key in self.\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, 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",
      "     |  __mul__(self, value, /)\n",
      "     |      Return self*value.n\n",
      "     |  \n",
      "     |  __ne__(self, value, /)\n",
      "     |      Return self!=value.\n",
      "     |  \n",
      "     |  __rmul__(self, value, /)\n",
      "     |      Return self*value.\n",
      "     |  \n",
      "     |  count(...)\n",
      "     |      T.count(value) -> integer -- return number of occurrences of value\n",
      "     |  \n",
      "     |  index(...)\n",
      "     |      T.index(value, [start, [stop]]) -> integer -- return first index of value.\n",
      "     |      Raises ValueError if the value is not present.\n",
      "\n",
      "FUNCTIONS\n",
      "    _exit(status)\n",
      "        Exit to the system with specified status, without normal exit processing.\n",
      "    \n",
      "    abort()\n",
      "        Abort the interpreter immediately.\n",
      "        \n",
      "        This function 'dumps core' or otherwise fails in the hardest way possible\n",
      "        on the hosting operating system.  This function never returns.\n",
      "    \n",
      "    access(path, mode, *, dir_fd=None, effective_ids=False, follow_symlinks=True)\n",
      "        Use the real uid/gid to test for access to a path.\n",
      "        \n",
      "          path\n",
      "            Path to be tested; can be string or bytes\n",
      "          mode\n",
      "            Operating-system mode bitfield.  Can be F_OK to test existence,\n",
      "            or the inclusive-OR of R_OK, W_OK, and X_OK.\n",
      "          dir_fd\n",
      "            If not None, it should be a file descriptor open to a directory,\n",
      "            and path should be relative; path will then be relative to that\n",
      "            directory.\n",
      "          effective_ids\n",
      "            If True, access will use the effective uid/gid instead of\n",
      "            the real uid/gid.\n",
      "          follow_symlinks\n",
      "            If False, and the last element of the path is a symbolic link,\n",
      "            access will examine the symbolic link itself instead of the file\n",
      "            the link points to.\n",
      "        \n",
      "        dir_fd, effective_ids, and follow_symlinks may not be implemented\n",
      "          on your platform.  If they are unavailable, using them will raise a\n",
      "          NotImplementedError.\n",
      "        \n",
      "        Note that most operations will use the effective uid/gid, therefore this\n",
      "          routine can be used in a suid/sgid environment to test if the invoking user\n",
      "          has the specified access to the path.\n",
      "    \n",
      "    chdir(path)\n",
      "        Change the current working directory to the specified path.\n",
      "        \n",
      "        path may always be specified as a string.\n",
      "        On some platforms, path may also be specified as an open file descriptor.\n",
      "          If this functionality is unavailable, using it raises an exception.\n",
      "    \n",
      "    chmod(path, mode, *, dir_fd=None, follow_symlinks=True)\n",
      "        Change the access permissions of a file.\n",
      "        \n",
      "          path\n",
      "            Path to be modified.  May always be specified as a str or bytes.\n",
      "            On some platforms, path may also be specified as an open file descriptor.\n",
      "            If this functionality is unavailable, using it raises an exception.\n",
      "          mode\n",
      "            Operating-system mode bitfield.\n",
      "          dir_fd\n",
      "            If not None, it should be a file descriptor open to a directory,\n",
      "            and path should be relative; path will then be relative to that\n",
      "            directory.\n",
      "          follow_symlinks\n",
      "            If False, and the last element of the path is a symbolic link,\n",
      "            chmod will modify the symbolic link itself instead of the file\n",
      "            the link points to.\n",
      "        \n",
      "        It is an error to use dir_fd or follow_symlinks when specifying path as\n",
      "          an open file descriptor.\n",
      "        dir_fd and follow_symlinks may not be implemented on your platform.\n",
      "          If they are unavailable, using them will raise a NotImplementedError.\n",
      "    \n",
      "    close(fd)\n",
      "        Close a file descriptor.\n",
      "    \n",
      "    closerange(fd_low, fd_high, /)\n",
      "        Closes all file descriptors in [fd_low, fd_high), ignoring errors.\n",
      "    \n",
      "    cpu_count()\n",
      "        Return the number of CPUs in the system; return None if indeterminable.\n",
      "    \n",
      "    device_encoding(fd)\n",
      "        Return a string describing the encoding of a terminal's file descriptor.\n",
      "        \n",
      "        The file descriptor must be attached to a terminal.\n",
      "        If the device is not a terminal, return None.\n",
      "    \n",
      "    dup(fd, /)\n",
      "        Return a duplicate of a file descriptor.\n",
      "    \n",
      "    dup2(fd, fd2, inheritable=True)\n",
      "        Duplicate file descriptor.\n",
      "    \n",
      "    execl(file, *args)\n",
      "        execl(file, *args)\n",
      "        \n",
      "        Execute the executable file with argument list args, replacing the\n",
      "        current process.\n",
      "    \n",
      "    execle(file, *args)\n",
      "        execle(file, *args, env)\n",
      "        \n",
      "        Execute the executable file with argument list args and\n",
      "        environment env, replacing the current process.\n",
      "    \n",
      "    execlp(file, *args)\n",
      "        execlp(file, *args)\n",
      "        \n",
      "        Execute the executable file (which is searched for along $PATH)\n",
      "        with argument list args, replacing the current process.\n",
      "    \n",
      "    execlpe(file, *args)\n",
      "        execlpe(file, *args, env)\n",
      "        \n",
      "        Execute the executable file (which is searched for along $PATH)\n",
      "        with argument list args and environment env, replacing the current\n",
      "        process.\n",
      "    \n",
      "    execv(path, argv, /)\n",
      "        Execute an executable path with arguments, replacing current process.\n",
      "        \n",
      "        path\n",
      "          Path of executable file.\n",
      "        argv\n",
      "          Tuple or list of strings.\n",
      "    \n",
      "    execve(path, argv, env)\n",
      "        Execute an executable path with arguments, replacing current process.\n",
      "        \n",
      "        path\n",
      "          Path of executable file.\n",
      "        argv\n",
      "          Tuple or list of strings.\n",
      "        env\n",
      "          Dictionary of strings mapping to strings.\n",
      "    \n",
      "    execvp(file, args)\n",
      "        execvp(file, args)\n",
      "        \n",
      "        Execute the executable file (which is searched for along $PATH)\n",
      "        with argument list args, replacing the current process.\n",
      "        args may be a list or tuple of strings.\n",
      "    \n",
      "    execvpe(file, args, env)\n",
      "        execvpe(file, args, env)\n",
      "        \n",
      "        Execute the executable file (which is searched for along $PATH)\n",
      "        with argument list args and environment env , replacing the\n",
      "        current process.\n",
      "        args may be a list or tuple of strings.\n",
      "    \n",
      "    fdopen(fd, *args, **kwargs)\n",
      "        # Supply os.fdopen()\n",
      "    \n",
      "    fsdecode(filename)\n",
      "        Decode filename from the filesystem encoding with 'surrogateescape' error\n",
      "        handler, return str unchanged. On Windows, use 'strict' error handler if\n",
      "        the file system encoding is 'mbcs' (which is the default encoding).\n",
      "    \n",
      "    fsencode(filename)\n",
      "        Encode filename to the filesystem encoding with 'surrogateescape' error\n",
      "        handler, return bytes unchanged. On Windows, use 'strict' error handler if\n",
      "        the file system encoding is 'mbcs' (which is the default encoding).\n",
      "    \n",
      "    fstat(fd)\n",
      "        Perform a stat system call on the given file descriptor.\n",
      "        \n",
      "        Like stat(), but for an open file descriptor.\n",
      "        Equivalent to os.stat(fd).\n",
      "    \n",
      "    fsync(fd)\n",
      "        Force write of fd to disk.\n",
      "    \n",
      "    ftruncate(fd, length, /)\n",
      "        Truncate a file, specified by file descriptor, to a specific length.\n",
      "    \n",
      "    get_exec_path(env=None)\n",
      "        Returns the sequence of directories that will be searched for the\n",
      "        named executable (similar to a shell) when launching a process.\n",
      "        \n",
      "        *env* must be an environment variable dict or None.  If *env* is None,\n",
      "        os.environ will be used.\n",
      "    \n",
      "    get_handle_inheritable(handle, /)\n",
      "        Get the close-on-exe flag of the specified file descriptor.\n",
      "    \n",
      "    get_inheritable(fd, /)\n",
      "        Get the close-on-exe flag of the specified file descriptor.\n",
      "    \n",
      "    get_terminal_size(...)\n",
      "        Return the size of the terminal window as (columns, lines).\n",
      "        \n",
      "        The optional argument fd (default standard output) specifies\n",
      "        which file descriptor should be queried.\n",
      "        \n",
      "        If the file descriptor is not connected to a terminal, an OSError\n",
      "        is thrown.\n",
      "        \n",
      "        This function will only be defined if an implementation is\n",
      "        available for this system.\n",
      "        \n",
      "        shutil.get_terminal_size is the high-level function which should \n",
      "        normally be used, os.get_terminal_size is the low-level implementation.\n",
      "    \n",
      "    getcwd()\n",
      "        Return a unicode string representing the current working directory.\n",
      "    \n",
      "    getcwdb()\n",
      "        Return a bytes string representing the current working directory.\n",
      "    \n",
      "    getenv(key, default=None)\n",
      "        Get an environment variable, return None if it doesn't exist.\n",
      "        The optional second argument can specify an alternate default.\n",
      "        key, default and the result are str.\n",
      "    \n",
      "    getlogin()\n",
      "        Return the actual login name.\n",
      "    \n",
      "    getpid()\n",
      "        Return the current process id.\n",
      "    \n",
      "    getppid()\n",
      "        Return the parent's process id.\n",
      "        \n",
      "        If the parent process has already exited, Windows machines will still\n",
      "        return its id; others systems will return the id of the 'init' process (1).\n",
      "    \n",
      "    isatty(fd, /)\n",
      "        Return True if the fd is connected to a terminal.\n",
      "        \n",
      "        Return True if the file descriptor is an open file descriptor\n",
      "        connected to the slave end of a terminal.\n",
      "    \n",
      "    kill(pid, signal, /)\n",
      "        Kill a process with a signal.\n",
      "    \n",
      "    link(src, dst, *, src_dir_fd=None, dst_dir_fd=None, follow_symlinks=True)\n",
      "        Create a hard link to a file.\n",
      "        \n",
      "        If either src_dir_fd or dst_dir_fd is not None, it should be a file\n",
      "          descriptor open to a directory, and the respective path string (src or dst)\n",
      "          should be relative; the path will then be relative to that directory.\n",
      "        If follow_symlinks is False, and the last element of src is a symbolic\n",
      "          link, link will create a link to the symbolic link itself instead of the\n",
      "          file the link points to.\n",
      "        src_dir_fd, dst_dir_fd, and follow_symlinks may not be implemented on your\n",
      "          platform.  If they are unavailable, using them will raise a\n",
      "          NotImplementedError.\n",
      "    \n",
      "    listdir(path=None)\n",
      "        Return a list containing the names of the files in the directory.\n",
      "        \n",
      "        path can be specified as either str or bytes.  If path is bytes,\n",
      "          the filenames returned will also be bytes; in all other circumstances\n",
      "          the filenames returned will be str.\n",
      "        If path is None, uses the path='.'.\n",
      "        On some platforms, path may also be specified as an open file descriptor;\\\n",
      "          the file descriptor must refer to a directory.\n",
      "          If this functionality is unavailable, using it raises NotImplementedError.\n",
      "        \n",
      "        The list is in arbitrary order.  It does not include the special\n",
      "        entries '.' and '..' even if they are present in the directory.\n",
      "    \n",
      "    lseek(fd, position, how, /)\n",
      "        Set the position of a file descriptor.  Return the new position.\n",
      "        \n",
      "        Return the new cursor position in number of bytes\n",
      "        relative to the beginning of the file.\n",
      "    \n",
      "    lstat(path, *, dir_fd=None)\n",
      "        Perform a stat system call on the given path, without following symbolic links.\n",
      "        \n",
      "        Like stat(), but do not follow symbolic links.\n",
      "        Equivalent to stat(path, follow_symlinks=False).\n",
      "    \n",
      "    makedirs(name, mode=511, exist_ok=False)\n",
      "        makedirs(name [, mode=0o777][, exist_ok=False])\n",
      "        \n",
      "        Super-mkdir; create a leaf directory and all intermediate ones.  Works like\n",
      "        mkdir, except that any intermediate path segment (not just the rightmost)\n",
      "        will be created if it does not exist. If the target directory already\n",
      "        exists, raise an OSError if exist_ok is False. Otherwise no exception is\n",
      "        raised.  This is recursive.\n",
      "    \n",
      "    mkdir(path, mode=511, *, dir_fd=None)\n",
      "        Create a directory.\n",
      "        \n",
      "        If dir_fd is not None, it should be a file descriptor open to a directory,\n",
      "          and path should be relative; path will then be relative to that directory.\n",
      "        dir_fd may not be implemented on your platform.\n",
      "          If it is unavailable, using it will raise a NotImplementedError.\n",
      "        \n",
      "        The mode argument is ignored on Windows.\n",
      "    \n",
      "    open(path, flags, mode=511, *, dir_fd=None)\n",
      "        Open a file for low level IO.  Returns a file descriptor (integer).\n",
      "        \n",
      "        If dir_fd is not None, it should be a file descriptor open to a directory,\n",
      "          and path should be relative; path will then be relative to that directory.\n",
      "        dir_fd may not be implemented on your platform.\n",
      "          If it is unavailable, using it will raise a NotImplementedError.\n",
      "    \n",
      "    pipe()\n",
      "        Create a pipe.\n",
      "        \n",
      "        Returns a tuple of two file descriptors:\n",
      "          (read_fd, write_fd)\n",
      "    \n",
      "    popen(cmd, mode='r', buffering=-1)\n",
      "        # Supply os.popen()\n",
      "    \n",
      "    putenv(name, value, /)\n",
      "        Change or add an environment variable.\n",
      "    \n",
      "    read(fd, length, /)\n",
      "        Read from a file descriptor.  Returns a bytes object.\n",
      "    \n",
      "    readlink(...)\n",
      "        readlink(path, *, dir_fd=None) -> path\n",
      "        \n",
      "        Return a string representing the path to which the symbolic link points.\n",
      "        \n",
      "        If dir_fd is not None, it should be a file descriptor open to a directory,\n",
      "          and path should be relative; path will then be relative to that directory.\n",
      "        dir_fd may not be implemented on your platform.\n",
      "          If it is unavailable, using it will raise a NotImplementedError.\n",
      "    \n",
      "    remove(path, *, dir_fd=None)\n",
      "        Remove a file (same as unlink()).\n",
      "        \n",
      "        If dir_fd is not None, it should be a file descriptor open to a directory,\n",
      "          and path should be relative; path will then be relative to that directory.\n",
      "        dir_fd may not be implemented on your platform.\n",
      "          If it is unavailable, using it will raise a NotImplementedError.\n",
      "    \n",
      "    removedirs(name)\n",
      "        removedirs(name)\n",
      "        \n",
      "        Super-rmdir; remove a leaf directory and all empty intermediate\n",
      "        ones.  Works like rmdir except that, if the leaf directory is\n",
      "        successfully removed, directories corresponding to rightmost path\n",
      "        segments will be pruned away until either the whole path is\n",
      "        consumed or an error occurs.  Errors during this latter phase are\n",
      "        ignored -- they generally mean that a directory was not empty.\n",
      "    \n",
      "    rename(src, dst, *, src_dir_fd=None, dst_dir_fd=None)\n",
      "        Rename a file or directory.\n",
      "        \n",
      "        If either src_dir_fd or dst_dir_fd is not None, it should be a file\n",
      "          descriptor open to a directory, and the respective path string (src or dst)\n",
      "          should be relative; the path will then be relative to that directory.\n",
      "        src_dir_fd and dst_dir_fd, may not be implemented on your platform.\n",
      "          If they are unavailable, using them will raise a NotImplementedError.\n",
      "    \n",
      "    renames(old, new)\n",
      "        renames(old, new)\n",
      "        \n",
      "        Super-rename; create directories as necessary and delete any left\n",
      "        empty.  Works like rename, except creation of any intermediate\n",
      "        directories needed to make the new pathname good is attempted\n",
      "        first.  After the rename, directories corresponding to rightmost\n",
      "        path segments of the old name will be pruned until either the\n",
      "        whole path is consumed or a nonempty directory is found.\n",
      "        \n",
      "        Note: this function can fail with the new directory structure made\n",
      "        if you lack permissions needed to unlink the leaf directory or\n",
      "        file.\n",
      "    \n",
      "    replace(src, dst, *, src_dir_fd=None, dst_dir_fd=None)\n",
      "        Rename a file or directory, overwriting the destination.\n",
      "        \n",
      "        If either src_dir_fd or dst_dir_fd is not None, it should be a file\n",
      "          descriptor open to a directory, and the respective path string (src or dst)\n",
      "          should be relative; the path will then be relative to that directory.\n",
      "        src_dir_fd and dst_dir_fd, may not be implemented on your platform.\n",
      "          If they are unavailable, using them will raise a NotImplementedError.\"\n",
      "    \n",
      "    rmdir(path, *, dir_fd=None)\n",
      "        Remove a directory.\n",
      "        \n",
      "        If dir_fd is not None, it should be a file descriptor open to a directory,\n",
      "          and path should be relative; path will then be relative to that directory.\n",
      "        dir_fd may not be implemented on your platform.\n",
      "          If it is unavailable, using it will raise a NotImplementedError.\n",
      "    \n",
      "    scandir(...)\n",
      "        scandir(path='.') -> iterator of DirEntry objects for given path\n",
      "    \n",
      "    set_handle_inheritable(handle, inheritable, /)\n",
      "        Set the inheritable flag of the specified handle.\n",
      "    \n",
      "    set_inheritable(fd, inheritable, /)\n",
      "        Set the inheritable flag of the specified file descriptor.\n",
      "    \n",
      "    spawnl(mode, file, *args)\n",
      "        spawnl(mode, file, *args) -> integer\n",
      "        \n",
      "        Execute file with arguments from args in a subprocess.\n",
      "        If mode == P_NOWAIT return the pid of the process.\n",
      "        If mode == P_WAIT return the process's exit code if it exits normally;\n",
      "        otherwise return -SIG, where SIG is the signal that killed it.\n",
      "    \n",
      "    spawnle(mode, file, *args)\n",
      "        spawnle(mode, file, *args, env) -> integer\n",
      "        \n",
      "        Execute file with arguments from args in a subprocess with the\n",
      "        supplied environment.\n",
      "        If mode == P_NOWAIT return the pid of the process.\n",
      "        If mode == P_WAIT return the process's exit code if it exits normally;\n",
      "        otherwise return -SIG, where SIG is the signal that killed it.\n",
      "    \n",
      "    spawnv(mode, path, argv, /)\n",
      "        Execute the program specified by path in a new process.\n",
      "        \n",
      "        mode\n",
      "          Mode of process creation.\n",
      "        path\n",
      "          Path of executable file.\n",
      "        argv\n",
      "          Tuple or list of strings.\n",
      "    \n",
      "    spawnve(mode, path, argv, env, /)\n",
      "        Execute the program specified by path in a new process.\n",
      "        \n",
      "        mode\n",
      "          Mode of process creation.\n",
      "        path\n",
      "          Path of executable file.\n",
      "        argv\n",
      "          Tuple or list of strings.\n",
      "        env\n",
      "          Dictionary of strings mapping to strings.\n",
      "    \n",
      "    startfile(...)\n",
      "        startfile(filepath [, operation])\n",
      "        \n",
      "        Start a file with its associated application.\n",
      "        \n",
      "        When \"operation\" is not specified or \"open\", this acts like\n",
      "        double-clicking the file in Explorer, or giving the file name as an\n",
      "        argument to the DOS \"start\" command: the file is opened with whatever\n",
      "        application (if any) its extension is associated.\n",
      "        When another \"operation\" is given, it specifies what should be done with\n",
      "        the file.  A typical operation is \"print\".\n",
      "        \n",
      "        startfile returns as soon as the associated application is launched.\n",
      "        There is no option to wait for the application to close, and no way\n",
      "        to retrieve the application's exit status.\n",
      "        \n",
      "        The filepath is relative to the current directory.  If you want to use\n",
      "        an absolute path, make sure the first character is not a slash (\"/\");\n",
      "        the underlying Win32 ShellExecute function doesn't work if it is.\n",
      "    \n",
      "    stat(path, *, dir_fd=None, follow_symlinks=True)\n",
      "        Perform a stat system call on the given path.\n",
      "        \n",
      "          path\n",
      "            Path to be examined; can be string, bytes, or open-file-descriptor int.\n",
      "          dir_fd\n",
      "            If not None, it should be a file descriptor open to a directory,\n",
      "            and path should be a relative string; path will then be relative to\n",
      "            that directory.\n",
      "          follow_symlinks\n",
      "            If False, and the last element of the path is a symbolic link,\n",
      "            stat will examine the symbolic link itself instead of the file\n",
      "            the link points to.\n",
      "        \n",
      "        dir_fd and follow_symlinks may not be implemented\n",
      "          on your platform.  If they are unavailable, using them will raise a\n",
      "          NotImplementedError.\n",
      "        \n",
      "        It's an error to use dir_fd or follow_symlinks when specifying path as\n",
      "          an open file descriptor.\n",
      "    \n",
      "    stat_float_times(...)\n",
      "        stat_float_times([newval]) -> oldval\n",
      "        \n",
      "        Determine whether os.[lf]stat represents time stamps as float objects.\n",
      "        \n",
      "        If value is True, future calls to stat() return floats; if it is False,\n",
      "        future calls return ints.\n",
      "        If value is omitted, return the current setting.\n",
      "    \n",
      "    strerror(code, /)\n",
      "        Translate an error code to a message string.\n",
      "    \n",
      "    symlink(src, dst, target_is_directory=False, *, dir_fd=None)\n",
      "        Create a symbolic link pointing to src named dst.\n",
      "        \n",
      "        target_is_directory is required on Windows if the target is to be\n",
      "          interpreted as a directory.  (On Windows, symlink requires\n",
      "          Windows 6.0 or greater, and raises a NotImplementedError otherwise.)\n",
      "          target_is_directory is ignored on non-Windows platforms.\n",
      "        \n",
      "        If dir_fd is not None, it should be a file descriptor open to a directory,\n",
      "          and path should be relative; path will then be relative to that directory.\n",
      "        dir_fd may not be implemented on your platform.\n",
      "          If it is unavailable, using it will raise a NotImplementedError.\n",
      "    \n",
      "    system(command)\n",
      "        Execute the command in a subshell.\n",
      "    \n",
      "    times()\n",
      "        Return a collection containing process timing information.\n",
      "        \n",
      "        The object returned behaves like a named tuple with these fields:\n",
      "          (utime, stime, cutime, cstime, elapsed_time)\n",
      "        All fields are floating point numbers.\n",
      "    \n",
      "    truncate(path, length)\n",
      "        Truncate a file, specified by path, to a specific length.\n",
      "        \n",
      "        On some platforms, path may also be specified as an open file descriptor.\n",
      "          If this functionality is unavailable, using it raises an exception.\n",
      "    \n",
      "    umask(mask, /)\n",
      "        Set the current numeric umask and return the previous umask.\n",
      "    \n",
      "    unlink(path, *, dir_fd=None)\n",
      "        Remove a file (same as remove()).\n",
      "        \n",
      "        If dir_fd is not None, it should be a file descriptor open to a directory,\n",
      "          and path should be relative; path will then be relative to that directory.\n",
      "        dir_fd may not be implemented on your platform.\n",
      "          If it is unavailable, using it will raise a NotImplementedError.\n",
      "    \n",
      "    urandom(size, /)\n",
      "        Return a bytes object containing random bytes suitable for cryptographic use.\n",
      "    \n",
      "    utime(path, times=None, *, ns=None, dir_fd=None, follow_symlinks=True)\n",
      "        Set the access and modified time of path.\n",
      "        \n",
      "        path may always be specified as a string.\n",
      "        On some platforms, path may also be specified as an open file descriptor.\n",
      "          If this functionality is unavailable, using it raises an exception.\n",
      "        \n",
      "        If times is not None, it must be a tuple (atime, mtime);\n",
      "            atime and mtime should be expressed as float seconds since the epoch.\n",
      "        If ns is specified, it must be a tuple (atime_ns, mtime_ns);\n",
      "            atime_ns and mtime_ns should be expressed as integer nanoseconds\n",
      "            since the epoch.\n",
      "        If times is None and ns is unspecified, utime uses the current time.\n",
      "        Specifying tuples for both times and ns is an error.\n",
      "        \n",
      "        If dir_fd is not None, it should be a file descriptor open to a directory,\n",
      "          and path should be relative; path will then be relative to that directory.\n",
      "        If follow_symlinks is False, and the last element of the path is a symbolic\n",
      "          link, utime will modify the symbolic link itself instead of the file the\n",
      "          link points to.\n",
      "        It is an error to use dir_fd or follow_symlinks when specifying path\n",
      "          as an open file descriptor.\n",
      "        dir_fd and follow_symlinks may not be available on your platform.\n",
      "          If they are unavailable, using them will raise a NotImplementedError.\n",
      "    \n",
      "    waitpid(pid, options, /)\n",
      "        Wait for completion of a given process.\n",
      "        \n",
      "        Returns a tuple of information regarding the process:\n",
      "            (pid, status << 8)\n",
      "        \n",
      "        The options argument is ignored on Windows.\n",
      "    \n",
      "    walk(top, topdown=True, onerror=None, followlinks=False)\n",
      "        Directory tree generator.\n",
      "        \n",
      "        For each directory in the directory tree rooted at top (including top\n",
      "        itself, but excluding '.' and '..'), yields a 3-tuple\n",
      "        \n",
      "            dirpath, dirnames, filenames\n",
      "        \n",
      "        dirpath is a string, the path to the directory.  dirnames is a list of\n",
      "        the names of the subdirectories in dirpath (excluding '.' and '..').\n",
      "        filenames is a list of the names of the non-directory files in dirpath.\n",
      "        Note that the names in the lists are just names, with no path components.\n",
      "        To get a full path (which begins with top) to a file or directory in\n",
      "        dirpath, do os.path.join(dirpath, name).\n",
      "        \n",
      "        If optional arg 'topdown' is true or not specified, the triple for a\n",
      "        directory is generated before the triples for any of its subdirectories\n",
      "        (directories are generated top down).  If topdown is false, the triple\n",
      "        for a directory is generated after the triples for all of its\n",
      "        subdirectories (directories are generated bottom up).\n",
      "        \n",
      "        When topdown is true, the caller can modify the dirnames list in-place\n",
      "        (e.g., via del or slice assignment), and walk will only recurse into the\n",
      "        subdirectories whose names remain in dirnames; this can be used to prune the\n",
      "        search, or to impose a specific order of visiting.  Modifying dirnames when\n",
      "        topdown is false is ineffective, since the directories in dirnames have\n",
      "        already been generated by the time dirnames itself is generated. No matter\n",
      "        the value of topdown, the list of subdirectories is retrieved before the\n",
      "        tuples for the directory and its subdirectories are generated.\n",
      "        \n",
      "        By default errors from the os.scandir() call are ignored.  If\n",
      "        optional arg 'onerror' is specified, it should be a function; it\n",
      "        will be called with one argument, an OSError instance.  It can\n",
      "        report the error to continue with the walk, or raise the exception\n",
      "        to abort the walk.  Note that the filename is available as the\n",
      "        filename attribute of the exception object.\n",
      "        \n",
      "        By default, os.walk does not follow symbolic links to subdirectories on\n",
      "        systems that support them.  In order to get this functionality, set the\n",
      "        optional argument 'followlinks' to true.\n",
      "        \n",
      "        Caution:  if you pass a relative pathname for top, don't change the\n",
      "        current working directory between resumptions of walk.  walk never\n",
      "        changes the current directory, and assumes that the client doesn't\n",
      "        either.\n",
      "        \n",
      "        Example:\n",
      "        \n",
      "        import os\n",
      "        from os.path import join, getsize\n",
      "        for root, dirs, files in os.walk('python/Lib/email'):\n",
      "            print(root, \"consumes\", end=\"\")\n",
      "            print(sum([getsize(join(root, name)) for name in files]), end=\"\")\n",
      "            print(\"bytes in\", len(files), \"non-directory files\")\n",
      "            if 'CVS' in dirs:\n",
      "                dirs.remove('CVS')  # don't visit CVS directories\n",
      "    \n",
      "    write(fd, data, /)\n",
      "        Write a bytes object to a file descriptor.\n",
      "\n",
      "DATA\n",
      "    F_OK = 0\n",
      "    O_APPEND = 8\n",
      "    O_BINARY = 32768\n",
      "    O_CREAT = 256\n",
      "    O_EXCL = 1024\n",
      "    O_NOINHERIT = 128\n",
      "    O_RANDOM = 16\n",
      "    O_RDONLY = 0\n",
      "    O_RDWR = 2\n",
      "    O_SEQUENTIAL = 32\n",
      "    O_SHORT_LIVED = 4096\n",
      "    O_TEMPORARY = 64\n",
      "    O_TEXT = 16384\n",
      "    O_TRUNC = 512\n",
      "    O_WRONLY = 1\n",
      "    P_DETACH = 4\n",
      "    P_NOWAIT = 1\n",
      "    P_NOWAITO = 3\n",
      "    P_OVERLAY = 2\n",
      "    P_WAIT = 0\n",
      "    R_OK = 4\n",
      "    SEEK_CUR = 1\n",
      "    SEEK_END = 2\n",
      "    SEEK_SET = 0\n",
      "    TMP_MAX = 2147483647\n",
      "    W_OK = 2\n",
      "    X_OK = 1\n",
      "    __all__ = ['altsep', 'curdir', 'pardir', 'sep', 'pathsep', 'linesep', ...\n",
      "    altsep = '/'\n",
      "    curdir = '.'\n",
      "    defpath = r'.;C:\\bin'\n",
      "    devnull = 'nul'\n",
      "    environ = environ({'HOMEDRIVE': 'C:', 'PAGER': 'cat', 'USE...EVENT': '...\n",
      "    extsep = '.'\n",
      "    linesep = '\\r\\n'\n",
      "    name = 'nt'\n",
      "    pardir = '..'\n",
      "    pathsep = ';'\n",
      "    sep = r'\\'\n",
      "    supports_bytes_environ = False\n",
      "\n",
      "FILE\n",
      "    c:\\users\\zekelabs\\anaconda3-n\\lib\\os.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(os)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 239,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = os.listdir(r'D:\\machine-learning-for-beginners\\data\\train')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['000bec180eb18c7604dcecc8fe0dba07.jpg',\n",
       " '001513dfcb2ffafc82cccf4d8bbaba97.jpg',\n",
       " '001cdf01b096e06d78e9e5112d419397.jpg',\n",
       " '00214f311d5d2247d5dfe4fe24b2303d.jpg',\n",
       " '0021f9ceb3235effd7fcde7f7538ed62.jpg']"
      ]
     },
     "execution_count": 240,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l[:5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "from bs4 import BeautifulSoup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 242,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import requests"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "data = requests.get('http://www.zekelabs.com')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 245,
   "metadata": {},
   "outputs": [],
   "source": [
    "soup = BeautifulSoup(data.text,\"lxml\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 249,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/best-training-and-career-consulting/\n",
      "#\n",
      "/smes\n",
      "/corporate-training/\n",
      "/search\n",
      "/academia\n",
      "/#courses\n",
      "#\n",
      "None\n",
      "None\n",
      "None\n",
      "None\n",
      "None\n",
      "/smes/\n",
      "/courses/data-science-training-in-bangalore/\n",
      "/courses/data-science-training-in-bangalore/\n",
      "/courses/data-science-training-in-bangalore/\n",
      "/courses/machine-learning-tensorflow-training/\n",
      "http://www.zekelabs.com/courses/machine-learning-tensorflow-training/\n",
      "http://www.zekelabs.com/courses/machine-learning-tensorflow-training/\n",
      "/courses/deeplearning-tensorflow-training/\n",
      "/courses/deeplearning-tensorflow-training/\n",
      "/courses/deeplearning-tensorflow-training/\n",
      "/courses/artificial-intelligence-trianing/\n",
      "/courses/artificial-intelligence-trianing/\n",
      "/courses/artificial-intelligence-trianing/\n",
      "http://www.zekelabs.com/courses/h2o-machine-learning-training/\n",
      "http://www.zekelabs.com/courses/h2o-machine-learning-training/\n",
      "http://www.zekelabs.com/courses/h2o-machine-learning-training/\n",
      "http://www.zekelabs.com/courses/best-deep-learning-training-in-bangalore/\n",
      "http://www.zekelabs.com/courses/best-deep-learning-training-in-bangalore/\n",
      "http://www.zekelabs.com/courses/best-deep-learning-training-in-bangalore/\n",
      "http://www.zekelabs.com/courses/data-science-r-training-in-bangalore/\n",
      "http://www.zekelabs.com/courses/data-science-r-training-in-bangalore/\n",
      "http://www.zekelabs.com/courses/data-science-r-training-in-bangalore/\n",
      "http://www.zekelabs.com/courses/best-data-analysis-training-in-bangalore/\n",
      "http://www.zekelabs.com/courses/best-data-analysis-training-in-bangalore/\n",
      "http://www.zekelabs.com/courses/best-data-analysis-training-in-bangalore/\n",
      "http://www.zekelabs.com/courses/best-data-visualization-bokeh-training/\n",
      "http://www.zekelabs.com/courses/best-data-visualization-bokeh-training/\n",
      "http://www.zekelabs.com/courses/best-data-visualization-bokeh-training/\n",
      "#\n",
      "#\n",
      "/courses/r-programming-training-in-bangalore\n",
      "/courses/r-programming-training-in-bangalore\n",
      "/courses/r-programming-training-in-bangalore\n",
      "/courses/data-analysis-using-r-training-bangalore/\n",
      "/courses/data-analysis-using-r-training-bangalore/\n",
      "/courses/data-analysis-using-r-training-bangalore/\n",
      "/courses/machine-learning-using-r-training/\n",
      "/courses/machine-learning-using-r-training/\n",
      "/courses/machine-learning-using-r-training/\n",
      "/courses/data-analytics-for-marketingprofessional/\n",
      "/courses/data-analytics-for-marketingprofessional/\n",
      "/courses/data-analytics-for-marketingprofessional/\n",
      "/courses/amazon-web-services-training-bangalore\n",
      "/courses/amazon-web-services-training-bangalore\n",
      "/courses/amazon-web-services-training-bangalore\n",
      "/courses/best-aws-sysops-training-in-bangalore/\n",
      "/courses/best-aws-sysops-training-in-bangalore/\n",
      "/courses/best-aws-sysops-training-in-bangalore/\n",
      "/courses/best-aws-devops-training-in-bangalore\n",
      "/courses/best-aws-devops-training-in-bangalore/\n",
      "/courses/best-aws-devops-training-in-bangalore/\n",
      "/courses/microsoft-azure-training-in-bangalore/\n",
      "/courses/microsoft-azure-training-in-bangalore/\n",
      "/courses/microsoft-azure-training-in-bangalore/\n",
      "/courses/best-devops-training-in-bangalore/\n",
      "/courses/best-devops-training-in-bangalore/\n",
      "/courses/best-devops-training-in-bangalore/\n",
      "/courses/best-devops-chef-training-in-bangalore\n",
      "/courses/best-devops-chef-training-in-bangalore\n",
      "/courses/best-devops-chef-training-in-bangalore/\n",
      "/courses/docker-training-in-bangalore\n",
      "/courses/docker-training-in-bangalore\n",
      "/courses/docker-training-in-bangalore\n",
      "/courses/devops-training-in-bangalore\n",
      "/courses/devops-training-in-bangalore\n",
      "/courses/devops-training-in-bangalore\n",
      "/courses/big-data-hadoop-training-in-bangalore\n",
      "/courses/big-data-hadoop-training-in-bangalore\n",
      "/courses/big-data-hadoop-training-in-bangalore\n",
      "/courses/spark-with-python-training-in-bangalore\n",
      "/courses/spark-with-python-training-in-bangalore\n",
      "/courses/spark-with-python-training-in-bangalore\n",
      "/courses/machine-learning-using-spark-training\n",
      "/courses/machine-learning-using-spark-training\n",
      "/courses/machine-learning-using-spark-training\n",
      "http://www.zekelabs.com/courses/big-data-with-pyspark-training/\n",
      "http://www.zekelabs.com/courses/big-data-with-pyspark-training/\n",
      "http://www.zekelabs.com/courses/big-data-with-pyspark-training/\n",
      "/courses/html-css-js-training-in-bangalore\n",
      "/courses/html-css-js-training-in-bangalore\n",
      "/courses/html-css-js-training-in-bangalore\n",
      "/courses/angular2-training-in-bangalore\n",
      "/courses/angular2-training-in-bangalore\n",
      "/courses/angular2-training-in-bangalore\n",
      "/courses/best-angular-4-training-in-bangalore\n",
      "/courses/best-angular-4-training-in-bangalore\n",
      "/courses/best-angular-4-training-in-bangalore\n",
      "/courses/best-angular-5-training-in-bangalore/\n",
      "/courses/best-angular-5-training-in-bangalore/\n",
      "/courses/best-angular-5-training-in-bangalore/\n",
      "/courses/java-training-in-bangalore\n",
      "/courses/java-training-in-bangalore\n",
      "/courses/java-training-in-bangalore\n",
      "/courses/python-training-in-bangalore\n",
      "/courses/python-training-in-bangalore\n",
      "/courses/python-training-in-bangalore\n",
      "/courses/scala-training-in-bangalore\n",
      "/courses/scala-training-in-bangalore\n",
      "/courses/scala-training-in-bangalore\n",
      "/courses/plsql-training-in-bangalore\n",
      "/courses/plsql-training-in-bangalore\n",
      "/courses/plsql-training-in-bangalore\n",
      "/courses/spring-training-in-bangalore\n",
      "/courses/spring-training-in-bangalore\n",
      "/courses/spring-training-in-bangalore\n",
      "/courses/android-training-in-bangalore\n",
      "/courses/android-training-in-bangalore\n",
      "/courses/android-training-in-bangalore\n",
      "/courses/django-training-in-bangalore\n",
      "/courses/django-training-in-bangalore\n",
      "/courses/django-training-in-bangalore\n",
      "/courses/iot-training-in-bangalore\n",
      "/courses/iot-training-in-bangalore\n",
      "/courses/iot-training-in-bangalore\n",
      "http://www.zekelabs.com/training-in-bangalore/\n",
      "None\n",
      "None\n",
      "None\n",
      "None\n",
      "/aboutus\n",
      "/#courses\n",
      "/smes/\n",
      "https://msg91.com/startups/?utm_source=startup-banner\n",
      "/campus-to-corporate-bridge-program/\n",
      "/machine-learning-consulting/\n",
      "/best-training-and-career-consulting/\n",
      "/jobs/\n",
      "/privacypolicy/\n",
      "/termsandcondition/\n",
      "https://www.facebook.com/zekeLabs-255057498227660/\n",
      "https://twitter.com/zekeLabs\n",
      "#\n",
      "#demo\n",
      "/courses/big-data-hadoop-training-in-bangalore/\n",
      "/courses/data-science-training-in-bangalore/\n",
      "/courses/machine-learning-python-training/\n",
      "/courses/spark-with-python-training-in-bangalore/\n",
      "/courses/html-css-js-training-in-bangalore/\n",
      "/courses/angular2-training-in-bangalore/\n",
      "/courses/backbonejs-training-in-bangalore/\n",
      "/courses/android-training-in-bangalore/\n",
      "/courses/devops-training-in-bangalore/\n",
      "/courses/amazon-web-services-training-bangalore/\n",
      "/courses/docker-training-in-bangalore/\n",
      "/courses/openstack-training-in-bangalore/\n",
      "/courses/spring-training-in-bangalore/\n",
      "/courses/ruby-on-rails-training-in-bangalore/\n",
      "/courses/django-training-in-bangalore/\n",
      "/courses/mean-stack-training-in-bangalore/\n",
      "/courses/best-devops-training-in-bangalore/\n",
      "/courses/amazon-web-services-training-bangalore/\n",
      "/courses/docker-training-in-bangalore/\n",
      "/courses/openstack-training-in-bangalore/\n",
      "/courses/devops-training-in-bangalore/\n",
      "/courses/devops-training-in-bangalore/\n",
      "/courses/devops-training-in-bangalore/\n",
      "/courses/devops-training-in-bangalore/\n",
      "/courses/machine-learning-python-training/\n",
      "/courses/machine-learning-tensorflow-training/\n",
      "/courses/deeplearning-tensorflow-training/\n",
      "/courses/deeplearning-tensorflow-training/\n",
      "/courses/best-aws-sysops-training-in-bangalore/\n",
      "/courses/best-aws-devops-training-in-bangalore/\n",
      "/courses/best-devops-chef-training-in-bangalore/\n",
      "/courses/best-devops-git-training-in-bangalore/\n",
      "/courses/best-angular-4-training-in-bangalore/\n",
      "/courses/best-data-analysis-training-in-bangalore/\n",
      "/courses/best-data-visualization-bokeh-training/\n",
      "/courses/best-statistics-training-in-bangalore/\n",
      "/courses/artificial-intelligence-trianing/\n"
     ]
    }
   ],
   "source": [
    "for link in soup.find_all('a'):\n",
    "    print (link.get('href'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "import re"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {},
   "outputs": [],
   "source": [
    "mathes = re.search('abc','dabcdef')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 258,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 258,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mathes.start()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 259,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mathes.end()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "mathes = re.search(r'\\w','d*abcdef')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 264,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mathes.start()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 265,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 265,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mathes.end()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 267,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'d'"
      ]
     },
     "execution_count": 267,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mathes.group()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "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.5.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}