07. Modules in Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modules in Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sections\n",
    "\n",
    "- [Modules](#Modules)\n",
    "- [Packages](#Packages)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A module is basically a file with python code\n",
    "\n",
    "We can separate our Python file in multiple files, and it is a very common practice. Each file becomes a module."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# help(\"modules\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4142135623730951"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "type(math)\n",
    "dir(math)\n",
    "math.pi\n",
    "math.sqrt(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# We can use an alias\n",
    "import math as matematicas\n",
    "matematicas.pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import pi\n",
    "pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import pi as mypi\n",
    "mypi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " El volumen de la unidad C no tiene etiqueta.\n",
      " El n£mero de serie del volumen es: 0CDC-AF0E\n",
      "\n",
      " Directorio de C:\\Users\\jmlom\\Documents\\GitHubRepositories\\python_practice\\files\\modules\n",
      "\n",
      "09/11/2020  09:20    <DIR>          .\n",
      "09/11/2020  09:20    <DIR>          ..\n",
      "09/11/2020  09:22               149 utility.py\n",
      "               1 archivos            149 bytes\n",
      "               2 dirs  65,590,747,136 bytes libres\n"
     ]
    }
   ],
   "source": [
    "%ls files\\modules"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "%more files\\modules\\utility.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "import files.modules.utility as utility"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<module 'files.modules.utility' from 'C:\\\\Users\\\\jmlom\\\\Documents\\\\GitHubRepositories\\\\python_practice\\\\files\\\\modules\\\\utility.py'>\n"
     ]
    }
   ],
   "source": [
    "print(utility)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " El volumen de la unidad C no tiene etiqueta.\n",
      " El n£mero de serie del volumen es: 0CDC-AF0E\n",
      "\n",
      " Directorio de C:\\Users\\jmlom\\Documents\\GitHubRepositories\\python_practice\\files\\testing\\__pycache__\n",
      "\n",
      "02/11/2020  15:46    <DIR>          .\n",
      "02/11/2020  15:46    <DIR>          ..\n",
      "02/11/2020  15:46               382 main.cpython-37.pyc\n",
      "               1 archivos            382 bytes\n",
      "               2 dirs  65,595,576,320 bytes libres\n"
     ]
    }
   ],
   "source": [
    "# If you doenloaded to your local machine, you can uncomment the following line\n",
    "# %ls files\\testing\\__pycache__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__builtins__',\n",
       " '__cached__',\n",
       " '__doc__',\n",
       " '__file__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " 'divide',\n",
       " 'multiply',\n",
       " 'substract']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(utility)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.5\n"
     ]
    }
   ],
   "source": [
    "print(utility.divide(3,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "print(utility.multiply(3,2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n"
     ]
    }
   ],
   "source": [
    "print(utility.substract(3,2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Packages"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In order to create a package, we need to create a new folder, and add an extra file that is empty:\n",
    "- `__init__.py`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There are two options to reduce the importing of pacakges, such as \n",
    "\n",
    "import bla-bla-bla-bla-bla as bla\n",
    "\n",
    "Or\n",
    "\n",
    "from bla-bla-bla-bla-bla-bla import bla"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "12\n"
     ]
    }
   ],
   "source": [
    "from files.modules.utility import multiply, divide\n",
    "print(multiply(3,4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "## What about "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "# the name variable is the name of the module, when it is run in the main file, the name is just __main__\n",
    "print(__name__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "# that is the reason that these lines are in sevreal programs, it means that coode has to be run only in the main file\n",
    "if __name__ == \"__main__\":\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Just prints the variable __name__: files.modules.where\n"
     ]
    }
   ],
   "source": [
    "# This module prints only the name of the variebale __name__, it is just the name of the module\n",
    "import files.modules.where as where\n",
    "print(where.where())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Just prints the variable __name__: files.modules.where\n"
     ]
    }
   ],
   "source": [
    "print(where.where())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Built-in Modules"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Examples of some useful Python Standard Libraries"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1604981079.8198562\n"
     ]
    }
   ],
   "source": [
    "# The time() function returns the number of seconds passed since epoch.\n",
    "# For Unix system, January 1, 1970, 00:00:00 at UTC is epoch (the point where time begins).import time\n",
    "print(time.time())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Local time: Mon Nov  9 22:06:21 2020\n"
     ]
    }
   ],
   "source": [
    "# The time.ctime() function takes seconds passed since epoch as an argument and returns a string representing local time.\n",
    "seconds = time.time()\n",
    "local_time = time.ctime(seconds)\n",
    "print(\"Local time:\", local_time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2020-11-09\n"
     ]
    }
   ],
   "source": [
    "import datetime\n",
    "print(datetime.date.today())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<module 'random' from 'C:\\\\Users\\\\jmlom\\\\Anaconda3\\\\lib\\\\random.py'>\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "print(random)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " El volumen de la unidad C no tiene etiqueta.\n",
      " El n£mero de serie del volumen es: 0CDC-AF0E\n",
      "\n",
      " Directorio de C:\\Users\\jmlom\\Anaconda3\\lib\n",
      "\n",
      "08/02/2020  14:24    <DIR>          .\n",
      "08/02/2020  14:24    <DIR>          ..\n",
      "08/07/2019  12:03             5,101 __future__.py\n",
      "08/07/2019  12:03                64 __phello__.foo.py\n",
      "08/02/2020  14:24    <DIR>          __pycache__\n",
      "08/07/2019  12:03             1,801 _bootlocale.py\n",
      "08/07/2019  12:03            26,424 _collections_abc.py\n",
      "08/07/2019  12:03             8,749 _compat_pickle.py\n",
      "08/07/2019  12:03             5,340 _compression.py\n",
      "08/07/2019  12:03             6,027 _dummy_thread.py\n",
      "08/07/2019  12:03            14,598 _markupbase.py\n",
      "04/10/2019  10:18            11,143 _nsis.py\n",
      "08/07/2019  12:03            19,138 _osx_support.py\n",
      "08/07/2019  12:03             6,186 _py_abc.py\n",
      "08/07/2019  12:03           228,535 _pydecimal.py\n",
      "08/07/2019  12:03            91,476 _pyio.py\n",
      "08/07/2019  12:03             3,115 _sitebuiltins.py\n",
      "08/07/2019  12:03            25,504 _strptime.py\n",
      "04/10/2019  10:18             8,051 _system_path.py\n",
      "08/07/2019  12:03             7,214 _threading_local.py\n",
      "08/07/2019  12:03             5,679 _weakrefset.py\n",
      "08/07/2019  12:03             5,580 abc.py\n",
      "08/07/2019  12:03            32,814 aifc.py\n",
      "08/07/2019  12:03               477 antigravity.py\n",
      "08/07/2019  12:03            95,103 argparse.py\n",
      "08/07/2019  12:03            12,575 ast.py\n",
      "08/07/2019  12:03            11,328 asynchat.py\n",
      "08/02/2020  14:24    <DIR>          asyncio\n",
      "08/07/2019  12:03            20,118 asyncore.py\n",
      "08/07/2019  12:03            20,380 base64.py\n",
      "08/07/2019  12:03            31,926 bdb.py\n",
      "08/07/2019  12:03            13,954 binhex.py\n",
      "08/07/2019  12:03             2,557 bisect.py\n",
      "08/07/2019  12:03            12,410 bz2.py\n",
      "08/07/2019  12:03            24,826 calendar.py\n",
      "08/07/2019  12:03            34,549 cgi.py\n",
      "08/07/2019  12:03            12,018 cgitb.py\n",
      "08/07/2019  12:03             5,435 chunk.py\n",
      "08/07/2019  12:03            14,860 cmd.py\n",
      "08/07/2019  12:03            10,619 code.py\n",
      "08/07/2019  12:03            36,538 codecs.py\n",
      "08/07/2019  12:03             5,994 codeop.py\n",
      "08/02/2020  14:24    <DIR>          collections\n",
      "08/07/2019  12:03             4,064 colorsys.py\n",
      "08/07/2019  12:03            13,649 compileall.py\n",
      "08/02/2020  14:24    <DIR>          concurrent\n",
      "08/07/2019  12:03            54,283 configparser.py\n",
      "08/07/2019  12:03            24,762 contextlib.py\n",
      "08/07/2019  12:03               129 contextvars.py\n",
      "08/07/2019  12:03             8,815 copy.py\n",
      "08/07/2019  12:03             7,017 copyreg.py\n",
      "08/07/2019  12:03             6,242 cProfile.py\n",
      "08/07/2019  12:03             3,346 crypt.py\n",
      "08/07/2019  12:03            16,180 csv.py\n",
      "08/02/2020  14:24    <DIR>          ctypes\n",
      "08/02/2020  14:24    <DIR>          curses\n",
      "08/07/2019  12:03            48,508 dataclasses.py\n",
      "08/07/2019  12:03            86,298 datetime.py\n",
      "08/02/2020  14:24    <DIR>          dbm\n",
      "08/07/2019  12:03               320 decimal.py\n",
      "08/07/2019  12:03            84,387 difflib.py\n",
      "08/07/2019  12:03            19,888 dis.py\n",
      "08/02/2020  14:24    <DIR>          distutils\n",
      "08/07/2019  12:03           104,284 doctest.py\n",
      "08/07/2019  12:03             2,815 dummy_threading.py\n",
      "08/02/2020  14:24    <DIR>          email\n",
      "08/02/2020  14:24    <DIR>          encodings\n",
      "08/02/2020  14:24    <DIR>          ensurepip\n",
      "08/07/2019  12:03            34,778 enum.py\n",
      "08/07/2019  12:03             9,830 filecmp.py\n",
      "08/07/2019  12:03            14,625 fileinput.py\n",
      "08/07/2019  12:03             4,056 fnmatch.py\n",
      "08/07/2019  12:03            15,143 formatter.py\n",
      "08/07/2019  12:03            23,639 fractions.py\n",
      "08/07/2019  12:03            35,257 ftplib.py\n",
      "08/07/2019  12:03            32,916 functools.py\n",
      "08/07/2019  12:03             4,756 genericpath.py\n",
      "08/07/2019  12:03             7,489 getopt.py\n",
      "08/07/2019  12:03             5,994 getpass.py\n",
      "08/07/2019  12:03            21,967 gettext.py\n",
      "08/07/2019  12:03             5,638 glob.py\n",
      "08/07/2019  12:03            20,338 gzip.py\n",
      "08/07/2019  12:03             9,534 hashlib.py\n",
      "08/07/2019  12:03            23,017 heapq.py\n",
      "08/07/2019  12:03             6,517 hmac.py\n",
      "08/02/2020  14:24    <DIR>          html\n",
      "08/02/2020  14:24    <DIR>          http\n",
      "08/02/2020  14:24    <DIR>          idlelib\n",
      "08/07/2019  12:03            53,292 imaplib.py\n",
      "08/07/2019  12:03             3,795 imghdr.py\n",
      "08/07/2019  12:03            10,536 imp.py\n",
      "08/02/2020  14:24    <DIR>          importlib\n",
      "08/07/2019  12:03           117,615 inspect.py\n",
      "08/07/2019  12:03             3,517 io.py\n",
      "08/07/2019  12:03            75,316 ipaddress.py\n",
      "08/02/2020  14:24    <DIR>          json\n",
      "08/07/2019  12:03             2,245 keyword.py\n",
      "08/02/2020  14:24    <DIR>          lib2to3\n",
      "15/01/2019  16:47         1,828,906 LIEF.lib\n",
      "15/01/2019  16:56        61,355,296 LIEF-static.lib\n",
      "08/07/2019  12:03             5,312 linecache.py\n",
      "08/07/2019  12:03            78,027 locale.py\n",
      "08/02/2020  14:24    <DIR>          logging\n",
      "08/07/2019  12:03            12,983 lzma.py\n",
      "08/07/2019  12:03             6,123 macpath.py\n",
      "08/07/2019  12:03            78,654 mailbox.py\n",
      "08/07/2019  12:03             8,104 mailcap.py\n",
      "08/07/2019  12:03            20,880 mimetypes.py\n",
      "08/07/2019  12:03            23,035 modulefinder.py\n",
      "08/02/2020  14:24    <DIR>          msilib\n",
      "08/02/2020  14:24    <DIR>          multiprocessing\n",
      "08/07/2019  12:03             5,566 netrc.py\n",
      "08/07/2019  12:03            43,088 nntplib.py\n",
      "08/07/2019  12:03            22,340 ntpath.py\n",
      "08/07/2019  12:03             2,584 nturl2path.py\n",
      "08/07/2019  12:03            10,244 numbers.py\n",
      "08/07/2019  12:03             5,824 opcode.py\n",
      "08/07/2019  12:03            10,863 operator.py\n",
      "08/07/2019  12:03            60,371 optparse.py\n",
      "08/07/2019  12:03            37,756 os.py\n",
      "08/07/2019  12:03            49,707 pathlib.py\n",
      "08/07/2019  12:03            62,605 pdb.py\n",
      "08/07/2019  12:03            57,994 pickle.py\n",
      "08/07/2019  12:03            91,220 pickletools.py\n",
      "08/07/2019  12:03             8,916 pipes.py\n",
      "08/07/2019  12:03            21,461 pkgutil.py\n",
      "09/08/2019  16:47            47,001 platform.py\n",
      "08/07/2019  12:03            29,885 plistlib.py\n",
      "08/07/2019  12:03            14,964 poplib.py\n",
      "08/07/2019  12:03            15,771 posixpath.py\n",
      "08/07/2019  12:03            20,884 pprint.py\n",
      "08/07/2019  12:03            22,483 profile.py\n",
      "08/07/2019  12:03            27,315 pstats.py\n",
      "08/07/2019  12:03             4,763 pty.py\n",
      "08/07/2019  12:03             8,001 py_compile.py\n",
      "08/07/2019  12:03            15,137 pyclbr.py\n",
      "08/07/2019  12:03           106,731 pydoc.py\n",
      "08/02/2020  14:24    <DIR>          pydoc_data\n",
      "08/07/2019  12:03            11,359 queue.py\n",
      "08/07/2019  12:03             7,254 quopri.py\n",
      "08/07/2019  12:03            27,557 random.py\n",
      "08/07/2019  12:03            15,192 re.py\n",
      "08/07/2019  12:03             5,267 reprlib.py\n",
      "08/07/2019  12:03             7,097 rlcompleter.py\n",
      "08/07/2019  12:03            11,959 runpy.py\n",
      "08/07/2019  12:03             6,442 sched.py\n",
      "08/07/2019  12:03             2,038 secrets.py\n",
      "08/07/2019  12:03            18,561 selectors.py\n",
      "08/07/2019  12:03             8,527 shelve.py\n",
      "08/07/2019  12:03            12,956 shlex.py\n",
      "08/07/2019  12:03            41,950 shutil.py\n",
      "08/07/2019  12:03             2,123 signal.py\n",
      "08/07/2019  12:03            21,307 site.py\n",
      "08/11/2020  14:42    <DIR>          site-packages\n",
      "08/07/2019  12:03            34,711 smtpd.py\n",
      "08/07/2019  12:03            44,210 smtplib.py\n",
      "08/07/2019  12:03             7,086 sndhdr.py\n",
      "08/07/2019  12:03            27,363 socket.py\n",
      "08/07/2019  12:03            26,922 socketserver.py\n",
      "08/02/2020  14:24    <DIR>          sqlite3\n",
      "08/07/2019  12:03            26,872 sre_compile.py\n",
      "08/07/2019  12:03             7,177 sre_constants.py\n",
      "08/07/2019  12:03            39,305 sre_parse.py\n",
      "08/07/2019  12:03            45,495 ssl.py\n",
      "08/07/2019  12:03             5,038 stat.py\n",
      "08/07/2019  12:03            20,651 statistics.py\n",
      "08/07/2019  12:03            11,564 string.py\n",
      "08/07/2019  12:03            12,917 stringprep.py\n",
      "08/07/2019  12:03               257 struct.py\n",
      "08/07/2019  12:03            70,004 subprocess.py\n",
      "08/07/2019  12:03            18,375 sunau.py\n",
      "08/07/2019  12:03             2,131 symbol.py\n",
      "08/07/2019  12:03             7,274 symtable.py\n",
      "09/08/2019  16:47            24,649 sysconfig.py\n",
      "08/07/2019  12:03            11,408 tabnanny.py\n",
      "08/07/2019  12:03            92,617 tarfile.py\n",
      "08/07/2019  12:03            23,135 telnetlib.py\n",
      "08/07/2019  12:03            26,710 tempfile.py\n",
      "08/02/2020  14:24    <DIR>          test\n",
      "08/07/2019  12:03            19,494 textwrap.py\n",
      "08/07/2019  12:03             1,003 this.py\n",
      "08/07/2019  12:03            49,065 threading.py\n",
      "08/07/2019  12:03            13,444 timeit.py\n",
      "08/02/2020  14:24    <DIR>          tkinter\n",
      "08/07/2019  12:03             3,763 token.py\n",
      "08/07/2019  12:03            27,031 tokenize.py\n",
      "08/07/2019  12:03            28,978 trace.py\n",
      "08/07/2019  12:03            23,438 traceback.py\n",
      "08/07/2019  12:03            17,076 tracemalloc.py\n",
      "08/07/2019  12:03               879 tty.py\n",
      "08/07/2019  12:03           143,602 turtle.py\n",
      "08/02/2020  14:24    <DIR>          turtledemo\n",
      "08/07/2019  12:03             9,897 types.py\n",
      "08/07/2019  12:03            54,655 typing.py\n",
      "08/02/2020  14:24    <DIR>          unittest\n",
      "08/02/2020  14:24    <DIR>          urllib\n",
      "08/07/2019  12:03             6,816 uu.py\n",
      "08/07/2019  12:03            29,449 uuid.py\n",
      "08/02/2020  14:24    <DIR>          venv\n",
      "08/07/2019  12:03            20,242 warnings.py\n",
      "08/07/2019  12:03            18,229 wave.py\n",
      "08/07/2019  12:03            21,504 weakref.py\n",
      "08/07/2019  12:03            23,097 webbrowser.py\n",
      "08/02/2020  14:24    <DIR>          wsgiref\n",
      "08/07/2019  12:03             5,913 xdrlib.py\n",
      "08/02/2020  14:24    <DIR>          xml\n",
      "08/02/2020  14:24    <DIR>          xmlrpc\n",
      "08/07/2019  12:03             7,535 zipapp.py\n",
      "08/07/2019  12:03            80,522 zipfile.py\n",
      "             175 archivos     67,516,889 bytes\n",
      "              34 dirs  61,417,574,400 bytes libres\n"
     ]
    }
   ],
   "source": [
    "%ls C:\\Users\\jmlom\\Anaconda3\\lib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module random:\n",
      "\n",
      "NAME\n",
      "    random - Random variable generators.\n",
      "\n",
      "DESCRIPTION\n",
      "        integers\n",
      "        --------\n",
      "               uniform within range\n",
      "    \n",
      "        sequences\n",
      "        ---------\n",
      "               pick random element\n",
      "               pick random sample\n",
      "               pick weighted random sample\n",
      "               generate random permutation\n",
      "    \n",
      "        distributions on the real line:\n",
      "        ------------------------------\n",
      "               uniform\n",
      "               triangular\n",
      "               normal (Gaussian)\n",
      "               lognormal\n",
      "               negative exponential\n",
      "               gamma\n",
      "               beta\n",
      "               pareto\n",
      "               Weibull\n",
      "    \n",
      "        distributions on the circle (angles 0 to 2pi)\n",
      "        ---------------------------------------------\n",
      "               circular uniform\n",
      "               von Mises\n",
      "    \n",
      "    General notes on the underlying Mersenne Twister core generator:\n",
      "    \n",
      "    * The period is 2**19937-1.\n",
      "    * It is one of the most extensively tested generators in existence.\n",
      "    * The random() method is implemented in C, executes in a single Python step,\n",
      "      and is, therefore, threadsafe.\n",
      "\n",
      "CLASSES\n",
      "    _random.Random(builtins.object)\n",
      "        Random\n",
      "            SystemRandom\n",
      "    \n",
      "    class Random(_random.Random)\n",
      "     |  Random(x=None)\n",
      "     |  \n",
      "     |  Random number generator base class used by bound module functions.\n",
      "     |  \n",
      "     |  Used to instantiate instances of Random to get generators that don't\n",
      "     |  share state.\n",
      "     |  \n",
      "     |  Class Random can also be subclassed if you want to use a different basic\n",
      "     |  generator of your own devising: in that case, override the following\n",
      "     |  methods:  random(), seed(), getstate(), and setstate().\n",
      "     |  Optionally, implement a getrandbits() method so that randrange()\n",
      "     |  can cover arbitrarily large ranges.\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      Random\n",
      "     |      _random.Random\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  __getstate__(self)\n",
      "     |      # Issue 17489: Since __reduce__ was defined to fix #759889 this is no\n",
      "     |      # longer called; we leave it here because it has been here since random was\n",
      "     |      # rewritten back in 2001 and why risk breaking something.\n",
      "     |  \n",
      "     |  __init__(self, x=None)\n",
      "     |      Initialize an instance.\n",
      "     |      \n",
      "     |      Optional argument x controls seeding, as for Random.seed().\n",
      "     |  \n",
      "     |  __reduce__(self)\n",
      "     |      Helper for pickle.\n",
      "     |  \n",
      "     |  __setstate__(self, state)\n",
      "     |  \n",
      "     |  betavariate(self, alpha, beta)\n",
      "     |      Beta distribution.\n",
      "     |      \n",
      "     |      Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "     |      Returned values range between 0 and 1.\n",
      "     |  \n",
      "     |  choice(self, seq)\n",
      "     |      Choose a random element from a non-empty sequence.\n",
      "     |  \n",
      "     |  choices(self, population, weights=None, *, cum_weights=None, k=1)\n",
      "     |      Return a k sized list of population elements chosen with replacement.\n",
      "     |      \n",
      "     |      If the relative weights or cumulative weights are not specified,\n",
      "     |      the selections are made with equal probability.\n",
      "     |  \n",
      "     |  expovariate(self, lambd)\n",
      "     |      Exponential distribution.\n",
      "     |      \n",
      "     |      lambd is 1.0 divided by the desired mean.  It should be\n",
      "     |      nonzero.  (The parameter would be called \"lambda\", but that is\n",
      "     |      a reserved word in Python.)  Returned values range from 0 to\n",
      "     |      positive infinity if lambd is positive, and from negative\n",
      "     |      infinity to 0 if lambd is negative.\n",
      "     |  \n",
      "     |  gammavariate(self, alpha, beta)\n",
      "     |      Gamma distribution.  Not the gamma function!\n",
      "     |      \n",
      "     |      Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "     |      \n",
      "     |      The probability distribution function is:\n",
      "     |      \n",
      "     |                  x ** (alpha - 1) * math.exp(-x / beta)\n",
      "     |        pdf(x) =  --------------------------------------\n",
      "     |                    math.gamma(alpha) * beta ** alpha\n",
      "     |  \n",
      "     |  gauss(self, mu, sigma)\n",
      "     |      Gaussian distribution.\n",
      "     |      \n",
      "     |      mu is the mean, and sigma is the standard deviation.  This is\n",
      "     |      slightly faster than the normalvariate() function.\n",
      "     |      \n",
      "     |      Not thread-safe without a lock around calls.\n",
      "     |  \n",
      "     |  getstate(self)\n",
      "     |      Return internal state; can be passed to setstate() later.\n",
      "     |  \n",
      "     |  lognormvariate(self, mu, sigma)\n",
      "     |      Log normal distribution.\n",
      "     |      \n",
      "     |      If you take the natural logarithm of this distribution, you'll get a\n",
      "     |      normal distribution with mean mu and standard deviation sigma.\n",
      "     |      mu can have any value, and sigma must be greater than zero.\n",
      "     |  \n",
      "     |  normalvariate(self, mu, sigma)\n",
      "     |      Normal distribution.\n",
      "     |      \n",
      "     |      mu is the mean, and sigma is the standard deviation.\n",
      "     |  \n",
      "     |  paretovariate(self, alpha)\n",
      "     |      Pareto distribution.  alpha is the shape parameter.\n",
      "     |  \n",
      "     |  randint(self, a, b)\n",
      "     |      Return random integer in range [a, b], including both end points.\n",
      "     |  \n",
      "     |  randrange(self, start, stop=None, step=1, _int=<class 'int'>)\n",
      "     |      Choose a random item from range(start, stop[, step]).\n",
      "     |      \n",
      "     |      This fixes the problem with randint() which includes the\n",
      "     |      endpoint; in Python this is usually not what you want.\n",
      "     |  \n",
      "     |  sample(self, population, k)\n",
      "     |      Chooses k unique random elements from a population sequence or set.\n",
      "     |      \n",
      "     |      Returns a new list containing elements from the population while\n",
      "     |      leaving the original population unchanged.  The resulting list is\n",
      "     |      in selection order so that all sub-slices will also be valid random\n",
      "     |      samples.  This allows raffle winners (the sample) to be partitioned\n",
      "     |      into grand prize and second place winners (the subslices).\n",
      "     |      \n",
      "     |      Members of the population need not be hashable or unique.  If the\n",
      "     |      population contains repeats, then each occurrence is a possible\n",
      "     |      selection in the sample.\n",
      "     |      \n",
      "     |      To choose a sample in a range of integers, use range as an argument.\n",
      "     |      This is especially fast and space efficient for sampling from a\n",
      "     |      large population:   sample(range(10000000), 60)\n",
      "     |  \n",
      "     |  seed(self, a=None, version=2)\n",
      "     |      Initialize internal state from hashable object.\n",
      "     |      \n",
      "     |      None or no argument seeds from current time or from an operating\n",
      "     |      system specific randomness source if available.\n",
      "     |      \n",
      "     |      If *a* is an int, all bits are used.\n",
      "     |      \n",
      "     |      For version 2 (the default), all of the bits are used if *a* is a str,\n",
      "     |      bytes, or bytearray.  For version 1 (provided for reproducing random\n",
      "     |      sequences from older versions of Python), the algorithm for str and\n",
      "     |      bytes generates a narrower range of seeds.\n",
      "     |  \n",
      "     |  setstate(self, state)\n",
      "     |      Restore internal state from object returned by getstate().\n",
      "     |  \n",
      "     |  shuffle(self, x, random=None)\n",
      "     |      Shuffle list x in place, and return None.\n",
      "     |      \n",
      "     |      Optional argument random is a 0-argument function returning a\n",
      "     |      random float in [0.0, 1.0); if it is the default None, the\n",
      "     |      standard random.random will be used.\n",
      "     |  \n",
      "     |  triangular(self, low=0.0, high=1.0, mode=None)\n",
      "     |      Triangular distribution.\n",
      "     |      \n",
      "     |      Continuous distribution bounded by given lower and upper limits,\n",
      "     |      and having a given mode value in-between.\n",
      "     |      \n",
      "     |      http://en.wikipedia.org/wiki/Triangular_distribution\n",
      "     |  \n",
      "     |  uniform(self, a, b)\n",
      "     |      Get a random number in the range [a, b) or [a, b] depending on rounding.\n",
      "     |  \n",
      "     |  vonmisesvariate(self, mu, kappa)\n",
      "     |      Circular data distribution.\n",
      "     |      \n",
      "     |      mu is the mean angle, expressed in radians between 0 and 2*pi, and\n",
      "     |      kappa is the concentration parameter, which must be greater than or\n",
      "     |      equal to zero.  If kappa is equal to zero, this distribution reduces\n",
      "     |      to a uniform random angle over the range 0 to 2*pi.\n",
      "     |  \n",
      "     |  weibullvariate(self, alpha, beta)\n",
      "     |      Weibull distribution.\n",
      "     |      \n",
      "     |      alpha is the scale parameter and beta is the shape parameter.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors defined here:\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |      dictionary for instance variables (if defined)\n",
      "     |  \n",
      "     |  __weakref__\n",
      "     |      list of weak references to the object (if defined)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes defined here:\n",
      "     |  \n",
      "     |  VERSION = 3\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from _random.Random:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  getrandbits(...)\n",
      "     |      getrandbits(k) -> x.  Generates an int with k random bits.\n",
      "     |  \n",
      "     |  random(...)\n",
      "     |      random() -> x in the interval [0, 1).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods inherited from _random.Random:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "    \n",
      "    class SystemRandom(Random)\n",
      "     |  SystemRandom(x=None)\n",
      "     |  \n",
      "     |  Alternate random number generator using sources provided\n",
      "     |  by the operating system (such as /dev/urandom on Unix or\n",
      "     |  CryptGenRandom on Windows).\n",
      "     |  \n",
      "     |   Not available on all systems (see os.urandom() for details).\n",
      "     |  \n",
      "     |  Method resolution order:\n",
      "     |      SystemRandom\n",
      "     |      Random\n",
      "     |      _random.Random\n",
      "     |      builtins.object\n",
      "     |  \n",
      "     |  Methods defined here:\n",
      "     |  \n",
      "     |  getrandbits(self, k)\n",
      "     |      getrandbits(k) -> x.  Generates an int with k random bits.\n",
      "     |  \n",
      "     |  getstate = _notimplemented(self, *args, **kwds)\n",
      "     |  \n",
      "     |  random(self)\n",
      "     |      Get the next random number in the range [0.0, 1.0).\n",
      "     |  \n",
      "     |  seed(self, *args, **kwds)\n",
      "     |      Stub method.  Not used for a system random number generator.\n",
      "     |  \n",
      "     |  setstate = _notimplemented(self, *args, **kwds)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from Random:\n",
      "     |  \n",
      "     |  __getstate__(self)\n",
      "     |      # Issue 17489: Since __reduce__ was defined to fix #759889 this is no\n",
      "     |      # longer called; we leave it here because it has been here since random was\n",
      "     |      # rewritten back in 2001 and why risk breaking something.\n",
      "     |  \n",
      "     |  __init__(self, x=None)\n",
      "     |      Initialize an instance.\n",
      "     |      \n",
      "     |      Optional argument x controls seeding, as for Random.seed().\n",
      "     |  \n",
      "     |  __reduce__(self)\n",
      "     |      Helper for pickle.\n",
      "     |  \n",
      "     |  __setstate__(self, state)\n",
      "     |  \n",
      "     |  betavariate(self, alpha, beta)\n",
      "     |      Beta distribution.\n",
      "     |      \n",
      "     |      Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "     |      Returned values range between 0 and 1.\n",
      "     |  \n",
      "     |  choice(self, seq)\n",
      "     |      Choose a random element from a non-empty sequence.\n",
      "     |  \n",
      "     |  choices(self, population, weights=None, *, cum_weights=None, k=1)\n",
      "     |      Return a k sized list of population elements chosen with replacement.\n",
      "     |      \n",
      "     |      If the relative weights or cumulative weights are not specified,\n",
      "     |      the selections are made with equal probability.\n",
      "     |  \n",
      "     |  expovariate(self, lambd)\n",
      "     |      Exponential distribution.\n",
      "     |      \n",
      "     |      lambd is 1.0 divided by the desired mean.  It should be\n",
      "     |      nonzero.  (The parameter would be called \"lambda\", but that is\n",
      "     |      a reserved word in Python.)  Returned values range from 0 to\n",
      "     |      positive infinity if lambd is positive, and from negative\n",
      "     |      infinity to 0 if lambd is negative.\n",
      "     |  \n",
      "     |  gammavariate(self, alpha, beta)\n",
      "     |      Gamma distribution.  Not the gamma function!\n",
      "     |      \n",
      "     |      Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "     |      \n",
      "     |      The probability distribution function is:\n",
      "     |      \n",
      "     |                  x ** (alpha - 1) * math.exp(-x / beta)\n",
      "     |        pdf(x) =  --------------------------------------\n",
      "     |                    math.gamma(alpha) * beta ** alpha\n",
      "     |  \n",
      "     |  gauss(self, mu, sigma)\n",
      "     |      Gaussian distribution.\n",
      "     |      \n",
      "     |      mu is the mean, and sigma is the standard deviation.  This is\n",
      "     |      slightly faster than the normalvariate() function.\n",
      "     |      \n",
      "     |      Not thread-safe without a lock around calls.\n",
      "     |  \n",
      "     |  lognormvariate(self, mu, sigma)\n",
      "     |      Log normal distribution.\n",
      "     |      \n",
      "     |      If you take the natural logarithm of this distribution, you'll get a\n",
      "     |      normal distribution with mean mu and standard deviation sigma.\n",
      "     |      mu can have any value, and sigma must be greater than zero.\n",
      "     |  \n",
      "     |  normalvariate(self, mu, sigma)\n",
      "     |      Normal distribution.\n",
      "     |      \n",
      "     |      mu is the mean, and sigma is the standard deviation.\n",
      "     |  \n",
      "     |  paretovariate(self, alpha)\n",
      "     |      Pareto distribution.  alpha is the shape parameter.\n",
      "     |  \n",
      "     |  randint(self, a, b)\n",
      "     |      Return random integer in range [a, b], including both end points.\n",
      "     |  \n",
      "     |  randrange(self, start, stop=None, step=1, _int=<class 'int'>)\n",
      "     |      Choose a random item from range(start, stop[, step]).\n",
      "     |      \n",
      "     |      This fixes the problem with randint() which includes the\n",
      "     |      endpoint; in Python this is usually not what you want.\n",
      "     |  \n",
      "     |  sample(self, population, k)\n",
      "     |      Chooses k unique random elements from a population sequence or set.\n",
      "     |      \n",
      "     |      Returns a new list containing elements from the population while\n",
      "     |      leaving the original population unchanged.  The resulting list is\n",
      "     |      in selection order so that all sub-slices will also be valid random\n",
      "     |      samples.  This allows raffle winners (the sample) to be partitioned\n",
      "     |      into grand prize and second place winners (the subslices).\n",
      "     |      \n",
      "     |      Members of the population need not be hashable or unique.  If the\n",
      "     |      population contains repeats, then each occurrence is a possible\n",
      "     |      selection in the sample.\n",
      "     |      \n",
      "     |      To choose a sample in a range of integers, use range as an argument.\n",
      "     |      This is especially fast and space efficient for sampling from a\n",
      "     |      large population:   sample(range(10000000), 60)\n",
      "     |  \n",
      "     |  shuffle(self, x, random=None)\n",
      "     |      Shuffle list x in place, and return None.\n",
      "     |      \n",
      "     |      Optional argument random is a 0-argument function returning a\n",
      "     |      random float in [0.0, 1.0); if it is the default None, the\n",
      "     |      standard random.random will be used.\n",
      "     |  \n",
      "     |  triangular(self, low=0.0, high=1.0, mode=None)\n",
      "     |      Triangular distribution.\n",
      "     |      \n",
      "     |      Continuous distribution bounded by given lower and upper limits,\n",
      "     |      and having a given mode value in-between.\n",
      "     |      \n",
      "     |      http://en.wikipedia.org/wiki/Triangular_distribution\n",
      "     |  \n",
      "     |  uniform(self, a, b)\n",
      "     |      Get a random number in the range [a, b) or [a, b] depending on rounding.\n",
      "     |  \n",
      "     |  vonmisesvariate(self, mu, kappa)\n",
      "     |      Circular data distribution.\n",
      "     |      \n",
      "     |      mu is the mean angle, expressed in radians between 0 and 2*pi, and\n",
      "     |      kappa is the concentration parameter, which must be greater than or\n",
      "     |      equal to zero.  If kappa is equal to zero, this distribution reduces\n",
      "     |      to a uniform random angle over the range 0 to 2*pi.\n",
      "     |  \n",
      "     |  weibullvariate(self, alpha, beta)\n",
      "     |      Weibull distribution.\n",
      "     |      \n",
      "     |      alpha is the scale parameter and beta is the shape parameter.\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data descriptors inherited from Random:\n",
      "     |  \n",
      "     |  __dict__\n",
      "     |      dictionary for instance variables (if defined)\n",
      "     |  \n",
      "     |  __weakref__\n",
      "     |      list of weak references to the object (if defined)\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Data and other attributes inherited from Random:\n",
      "     |  \n",
      "     |  VERSION = 3\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Methods inherited from _random.Random:\n",
      "     |  \n",
      "     |  __getattribute__(self, name, /)\n",
      "     |      Return getattr(self, name).\n",
      "     |  \n",
      "     |  ----------------------------------------------------------------------\n",
      "     |  Static methods inherited from _random.Random:\n",
      "     |  \n",
      "     |  __new__(*args, **kwargs) from builtins.type\n",
      "     |      Create and return a new object.  See help(type) for accurate signature.\n",
      "\n",
      "FUNCTIONS\n",
      "    betavariate(alpha, beta) method of Random instance\n",
      "        Beta distribution.\n",
      "        \n",
      "        Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "        Returned values range between 0 and 1.\n",
      "    \n",
      "    choice(seq) method of Random instance\n",
      "        Choose a random element from a non-empty sequence.\n",
      "    \n",
      "    choices(population, weights=None, *, cum_weights=None, k=1) method of Random instance\n",
      "        Return a k sized list of population elements chosen with replacement.\n",
      "        \n",
      "        If the relative weights or cumulative weights are not specified,\n",
      "        the selections are made with equal probability.\n",
      "    \n",
      "    expovariate(lambd) method of Random instance\n",
      "        Exponential distribution.\n",
      "        \n",
      "        lambd is 1.0 divided by the desired mean.  It should be\n",
      "        nonzero.  (The parameter would be called \"lambda\", but that is\n",
      "        a reserved word in Python.)  Returned values range from 0 to\n",
      "        positive infinity if lambd is positive, and from negative\n",
      "        infinity to 0 if lambd is negative.\n",
      "    \n",
      "    gammavariate(alpha, beta) method of Random instance\n",
      "        Gamma distribution.  Not the gamma function!\n",
      "        \n",
      "        Conditions on the parameters are alpha > 0 and beta > 0.\n",
      "        \n",
      "        The probability distribution function is:\n",
      "        \n",
      "                    x ** (alpha - 1) * math.exp(-x / beta)\n",
      "          pdf(x) =  --------------------------------------\n",
      "                      math.gamma(alpha) * beta ** alpha\n",
      "    \n",
      "    gauss(mu, sigma) method of Random instance\n",
      "        Gaussian distribution.\n",
      "        \n",
      "        mu is the mean, and sigma is the standard deviation.  This is\n",
      "        slightly faster than the normalvariate() function.\n",
      "        \n",
      "        Not thread-safe without a lock around calls.\n",
      "    \n",
      "    getrandbits(...) method of Random instance\n",
      "        getrandbits(k) -> x.  Generates an int with k random bits.\n",
      "    \n",
      "    getstate() method of Random instance\n",
      "        Return internal state; can be passed to setstate() later.\n",
      "    \n",
      "    lognormvariate(mu, sigma) method of Random instance\n",
      "        Log normal distribution.\n",
      "        \n",
      "        If you take the natural logarithm of this distribution, you'll get a\n",
      "        normal distribution with mean mu and standard deviation sigma.\n",
      "        mu can have any value, and sigma must be greater than zero.\n",
      "    \n",
      "    normalvariate(mu, sigma) method of Random instance\n",
      "        Normal distribution.\n",
      "        \n",
      "        mu is the mean, and sigma is the standard deviation.\n",
      "    \n",
      "    paretovariate(alpha) method of Random instance\n",
      "        Pareto distribution.  alpha is the shape parameter.\n",
      "    \n",
      "    randint(a, b) method of Random instance\n",
      "        Return random integer in range [a, b], including both end points.\n",
      "    \n",
      "    random(...) method of Random instance\n",
      "        random() -> x in the interval [0, 1).\n",
      "    \n",
      "    randrange(start, stop=None, step=1, _int=<class 'int'>) method of Random instance\n",
      "        Choose a random item from range(start, stop[, step]).\n",
      "        \n",
      "        This fixes the problem with randint() which includes the\n",
      "        endpoint; in Python this is usually not what you want.\n",
      "    \n",
      "    sample(population, k) method of Random instance\n",
      "        Chooses k unique random elements from a population sequence or set.\n",
      "        \n",
      "        Returns a new list containing elements from the population while\n",
      "        leaving the original population unchanged.  The resulting list is\n",
      "        in selection order so that all sub-slices will also be valid random\n",
      "        samples.  This allows raffle winners (the sample) to be partitioned\n",
      "        into grand prize and second place winners (the subslices).\n",
      "        \n",
      "        Members of the population need not be hashable or unique.  If the\n",
      "        population contains repeats, then each occurrence is a possible\n",
      "        selection in the sample.\n",
      "        \n",
      "        To choose a sample in a range of integers, use range as an argument.\n",
      "        This is especially fast and space efficient for sampling from a\n",
      "        large population:   sample(range(10000000), 60)\n",
      "    \n",
      "    seed(a=None, version=2) method of Random instance\n",
      "        Initialize internal state from hashable object.\n",
      "        \n",
      "        None or no argument seeds from current time or from an operating\n",
      "        system specific randomness source if available.\n",
      "        \n",
      "        If *a* is an int, all bits are used.\n",
      "        \n",
      "        For version 2 (the default), all of the bits are used if *a* is a str,\n",
      "        bytes, or bytearray.  For version 1 (provided for reproducing random\n",
      "        sequences from older versions of Python), the algorithm for str and\n",
      "        bytes generates a narrower range of seeds.\n",
      "    \n",
      "    setstate(state) method of Random instance\n",
      "        Restore internal state from object returned by getstate().\n",
      "    \n",
      "    shuffle(x, random=None) method of Random instance\n",
      "        Shuffle list x in place, and return None.\n",
      "        \n",
      "        Optional argument random is a 0-argument function returning a\n",
      "        random float in [0.0, 1.0); if it is the default None, the\n",
      "        standard random.random will be used.\n",
      "    \n",
      "    triangular(low=0.0, high=1.0, mode=None) method of Random instance\n",
      "        Triangular distribution.\n",
      "        \n",
      "        Continuous distribution bounded by given lower and upper limits,\n",
      "        and having a given mode value in-between.\n",
      "        \n",
      "        http://en.wikipedia.org/wiki/Triangular_distribution\n",
      "    \n",
      "    uniform(a, b) method of Random instance\n",
      "        Get a random number in the range [a, b) or [a, b] depending on rounding.\n",
      "    \n",
      "    vonmisesvariate(mu, kappa) method of Random instance\n",
      "        Circular data distribution.\n",
      "        \n",
      "        mu is the mean angle, expressed in radians between 0 and 2*pi, and\n",
      "        kappa is the concentration parameter, which must be greater than or\n",
      "        equal to zero.  If kappa is equal to zero, this distribution reduces\n",
      "        to a uniform random angle over the range 0 to 2*pi.\n",
      "    \n",
      "    weibullvariate(alpha, beta) method of Random instance\n",
      "        Weibull distribution.\n",
      "        \n",
      "        alpha is the scale parameter and beta is the shape parameter.\n",
      "\n",
      "DATA\n",
      "    __all__ = ['Random', 'seed', 'random', 'uniform', 'randint', 'choice',...\n",
      "\n",
      "FILE\n",
      "    c:\\users\\jmlom\\anaconda3\\lib\\random.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(random)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['BPF',\n",
       " 'LOG4',\n",
       " 'NV_MAGICCONST',\n",
       " 'RECIP_BPF',\n",
       " 'Random',\n",
       " 'SG_MAGICCONST',\n",
       " 'SystemRandom',\n",
       " 'TWOPI',\n",
       " '_BuiltinMethodType',\n",
       " '_MethodType',\n",
       " '_Sequence',\n",
       " '_Set',\n",
       " '__all__',\n",
       " '__builtins__',\n",
       " '__cached__',\n",
       " '__doc__',\n",
       " '__file__',\n",
       " '__loader__',\n",
       " '__name__',\n",
       " '__package__',\n",
       " '__spec__',\n",
       " '_acos',\n",
       " '_bisect',\n",
       " '_ceil',\n",
       " '_cos',\n",
       " '_e',\n",
       " '_exp',\n",
       " '_inst',\n",
       " '_itertools',\n",
       " '_log',\n",
       " '_os',\n",
       " '_pi',\n",
       " '_random',\n",
       " '_sha512',\n",
       " '_sin',\n",
       " '_sqrt',\n",
       " '_test',\n",
       " '_test_generator',\n",
       " '_urandom',\n",
       " '_warn',\n",
       " 'betavariate',\n",
       " 'choice',\n",
       " 'choices',\n",
       " 'expovariate',\n",
       " 'gammavariate',\n",
       " 'gauss',\n",
       " 'getrandbits',\n",
       " 'getstate',\n",
       " 'lognormvariate',\n",
       " 'normalvariate',\n",
       " 'paretovariate',\n",
       " 'randint',\n",
       " 'random',\n",
       " 'randrange',\n",
       " 'sample',\n",
       " 'seed',\n",
       " 'setstate',\n",
       " 'shuffle',\n",
       " 'triangular',\n",
       " 'uniform',\n",
       " 'vonmisesvariate',\n",
       " 'weibullvariate']"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(random)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.randint(0,10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'e'"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "random.choice([\"a\", \"b\", \"c\", \"d\", \"e\"])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 5, 3, 4, 1]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_list = [1,2,3,4,5]\n",
    "random.shuffle(my_list)\n",
    "my_list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<module 'sys' (built-in)>\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "print(sys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on list object:\n",
      "\n",
      "class list(object)\n",
      " |  list(iterable=(), /)\n",
      " |  \n",
      " |  Built-in mutable sequence.\n",
      " |  \n",
      " |  If no argument is given, the constructor creates a new empty list.\n",
      " |  The argument must be an iterable if specified.\n",
      " |  \n",
      " |  Methods defined here:\n",
      " |  \n",
      " |  __add__(self, value, /)\n",
      " |      Return self+value.\n",
      " |  \n",
      " |  __contains__(self, key, /)\n",
      " |      Return key in self.\n",
      " |  \n",
      " |  __delitem__(self, key, /)\n",
      " |      Delete self[key].\n",
      " |  \n",
      " |  __eq__(self, value, /)\n",
      " |      Return self==value.\n",
      " |  \n",
      " |  __ge__(self, value, /)\n",
      " |      Return self>=value.\n",
      " |  \n",
      " |  __getattribute__(self, name, /)\n",
      " |      Return getattr(self, name).\n",
      " |  \n",
      " |  __getitem__(...)\n",
      " |      x.__getitem__(y) <==> x[y]\n",
      " |  \n",
      " |  __gt__(self, value, /)\n",
      " |      Return self>value.\n",
      " |  \n",
      " |  __iadd__(self, value, /)\n",
      " |      Implement self+=value.\n",
      " |  \n",
      " |  __imul__(self, value, /)\n",
      " |      Implement self*=value.\n",
      " |  \n",
      " |  __init__(self, /, *args, **kwargs)\n",
      " |      Initialize self.  See help(type(self)) for accurate signature.\n",
      " |  \n",
      " |  __iter__(self, /)\n",
      " |      Implement iter(self).\n",
      " |  \n",
      " |  __le__(self, value, /)\n",
      " |      Return self<=value.\n",
      " |  \n",
      " |  __len__(self, /)\n",
      " |      Return len(self).\n",
      " |  \n",
      " |  __lt__(self, value, /)\n",
      " |      Return self<value.\n",
      " |  \n",
      " |  __mul__(self, value, /)\n",
      " |      Return self*value.\n",
      " |  \n",
      " |  __ne__(self, value, /)\n",
      " |      Return self!=value.\n",
      " |  \n",
      " |  __repr__(self, /)\n",
      " |      Return repr(self).\n",
      " |  \n",
      " |  __reversed__(self, /)\n",
      " |      Return a reverse iterator over the list.\n",
      " |  \n",
      " |  __rmul__(self, value, /)\n",
      " |      Return value*self.\n",
      " |  \n",
      " |  __setitem__(self, key, value, /)\n",
      " |      Set self[key] to value.\n",
      " |  \n",
      " |  __sizeof__(self, /)\n",
      " |      Return the size of the list in memory, in bytes.\n",
      " |  \n",
      " |  append(self, object, /)\n",
      " |      Append object to the end of the list.\n",
      " |  \n",
      " |  clear(self, /)\n",
      " |      Remove all items from list.\n",
      " |  \n",
      " |  copy(self, /)\n",
      " |      Return a shallow copy of the list.\n",
      " |  \n",
      " |  count(self, value, /)\n",
      " |      Return number of occurrences of value.\n",
      " |  \n",
      " |  extend(self, iterable, /)\n",
      " |      Extend list by appending elements from the iterable.\n",
      " |  \n",
      " |  index(self, value, start=0, stop=9223372036854775807, /)\n",
      " |      Return first index of value.\n",
      " |      \n",
      " |      Raises ValueError if the value is not present.\n",
      " |  \n",
      " |  insert(self, index, object, /)\n",
      " |      Insert object before index.\n",
      " |  \n",
      " |  pop(self, index=-1, /)\n",
      " |      Remove and return item at index (default last).\n",
      " |      \n",
      " |      Raises IndexError if list is empty or index is out of range.\n",
      " |  \n",
      " |  remove(self, value, /)\n",
      " |      Remove first occurrence of value.\n",
      " |      \n",
      " |      Raises ValueError if the value is not present.\n",
      " |  \n",
      " |  reverse(self, /)\n",
      " |      Reverse *IN PLACE*.\n",
      " |  \n",
      " |  sort(self, /, *, key=None, reverse=False)\n",
      " |      Stable sort *IN PLACE*.\n",
      " |  \n",
      " |  ----------------------------------------------------------------------\n",
      " |  Static 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",
      " |  ----------------------------------------------------------------------\n",
      " |  Data and other attributes defined here:\n",
      " |  \n",
      " |  __hash__ = None\n",
      "\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Pyhon Package Index"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python has several external libraries like pandas, "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "in order to install external libraries, from you terminal console you have to use\n",
    "- pip install\n",
    "- conda install\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can search for external libraries documentation in.\n",
    "pypi.org"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pip 19.1 from C:\\Users\\jmlom\\AppData\\Roaming\\Python\\Python37\\site-packages\\pip (python 3.7)\n",
      "\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "# Ib a console winddow\n",
    "# Display Python version\n",
    "pip --version\n",
    "# Upgrade pip\n",
    "python -m pip install -upgrade pip\n",
    "# Donload and install a package\n",
    "pip install <package-name>\n",
    "pip install <package-name==2.1.9>\n",
    "pip install <package-name>=2.1.9>\n",
    "# Upgrade a package\n",
    "pip install --upgrade <package-name>\n",
    "# Unistall a package\n",
    "pip unistall a package\n",
    "# Show information of the package\n",
    "pip show <package-name>\n",
    "# Search for a package\n",
    "pip search <package-name>\n",
    "# show the list of the packages installed\n",
    "pip freeze\n",
    "# One useful case\n",
    "pip freeze > requirements.txt\n",
    "pip install -r requirements.txt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can create also your own Python libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "%pip -V"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Collecting pyjokes\n",
      "  Using cached https://files.pythonhosted.org/packages/6a/0e/4a824a4fc93b9725a985fcea7115927b72f2ca6966008300a982cb869720/pyjokes-0.6.0-py2.py3-none-any.whl\n",
      "Installing collected packages: pyjokes\n",
      "Successfully installed pyjokes-0.6.0\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: You are using pip version 19.1, however version 20.2.4 is available.\n",
      "You should consider upgrading via the 'python -m pip install --upgrade pip' command.\n"
     ]
    }
   ],
   "source": [
    "%pip install pyjokes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "How do you generate a random string? Put a first year Computer Science student in Vim and ask them to save and exit.\n"
     ]
    }
   ],
   "source": [
    "import pyjokes\n",
    "\n",
    "joke = pyjokes.get_joke(\"en\", \"neutral\")\n",
    "print(joke)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip uninstall pyjokes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "%pip list"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['C:\\\\Users\\\\jmlom\\\\Anaconda3\\\\lib\\\\site-packages\\\\spyder\\\\utils\\\\help',\n",
       " 'C:\\\\Users\\\\jmlom\\\\Documents\\\\GitHubRepositories\\\\python-notes',\n",
       " 'C:\\\\Users\\\\jmlom\\\\Anaconda3\\\\python37.zip',\n",
       " 'C:\\\\Users\\\\jmlom\\\\Anaconda3\\\\DLLs',\n",
       " 'C:\\\\Users\\\\jmlom\\\\Anaconda3\\\\lib',\n",
       " 'C:\\\\Users\\\\jmlom\\\\Anaconda3',\n",
       " '',\n",
       " 'C:\\\\Users\\\\jmlom\\\\AppData\\\\Roaming\\\\Python\\\\Python37\\\\site-packages',\n",
       " 'C:\\\\Users\\\\jmlom\\\\AppData\\\\Roaming\\\\Python\\\\Python37\\\\site-packages\\\\win32',\n",
       " 'C:\\\\Users\\\\jmlom\\\\AppData\\\\Roaming\\\\Python\\\\Python37\\\\site-packages\\\\win32\\\\lib',\n",
       " 'C:\\\\Users\\\\jmlom\\\\AppData\\\\Roaming\\\\Python\\\\Python37\\\\site-packages\\\\Pythonwin',\n",
       " 'C:\\\\Users\\\\jmlom\\\\Anaconda3\\\\lib\\\\site-packages',\n",
       " 'C:\\\\Users\\\\jmlom\\\\Anaconda3\\\\lib\\\\site-packages\\\\win32',\n",
       " 'C:\\\\Users\\\\jmlom\\\\Anaconda3\\\\lib\\\\site-packages\\\\win32\\\\lib',\n",
       " 'C:\\\\Users\\\\jmlom\\\\Anaconda3\\\\lib\\\\site-packages\\\\Pythonwin',\n",
       " 'C:\\\\Users\\\\jmlom\\\\Anaconda3\\\\lib\\\\site-packages\\\\IPython\\\\extensions',\n",
       " 'C:\\\\Users\\\\jmlom\\\\.ipython',\n",
       " 'C:\\\\Users\\\\jmlom\\\\AppData\\\\Roaming\\\\Python\\\\Python37\\\\site-packages\\\\astroid\\\\brain']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "· Python checks for modules in the path variable\n",
    "import sys\n",
    "sys.path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Virtual Environments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It is recommended to create a new virtual environment per project."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}