2CAP_Python_Standard_Librar.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Machine Learning practico con la ayuda de Python\n",
    "# Capitulo 2: Introduccion a las librerias estandar de Python\n",
    "\n",
    "## Aldo Humberto Romero \n",
    "\n",
    "### BUAP, Marzo, 2022"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Setup"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "%load_ext watermark"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Last updated: 2022-02-27T17:46:24.833951+01:00\n",
      "\n",
      "Python implementation: CPython\n",
      "Python version       : 3.9.7\n",
      "IPython version      : 8.0.1\n",
      "\n",
      "Compiler    : Clang 11.1.0 \n",
      "OS          : Darwin\n",
      "Release     : 21.3.0\n",
      "Machine     : arm64\n",
      "Processor   : arm\n",
      "CPU cores   : 10\n",
      "Architecture: 64bit\n",
      "\n"
     ]
    }
   ],
   "source": [
    "%watermark"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduccion\n",
    "\n",
    "En este tutorial hablaremos de los siguientes modulos estadar, en los siguientes notebooks hablaremos de otros y ya dejamos al usuario para que investigue sobre otros mas. \n",
    "\n",
    "* sys\n",
    "* math y cmath\n",
    "* os and os.path\n",
    "* shutil\n",
    "* itertools\n",
    "* json\n",
    "* subprocess\n",
    "* multiprocessing\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Las librerias estandar de Python (llamadas PSL por sus siglas en ingles) son un conjunto de modulos y que estan incluidos en la mayoria de implementaciones. Con muy pocas excepciones, ustedes pueden asumir que la maquina donde ustedes estan y estan usando Python puede tambien hacer uso de estos modulos.\n",
    "\n",
    "La PSL es muy extensa. Las librerias contienen modulos incorporados (escritos en C) que dan access a la funcionalidad del sistema que esta usando, como lectura y escritura de archivos (I/O), asi que una gran cantidad de utileria que generalmente usa casi todo programador. La idea basica es que todo programador recicle estos modulos de tal manera que la implementacion que haga sea mucho mas facil.\n",
    "\n",
    "La documentacion completa de estos modulos la puedes encontrar [aqui](https://docs.python.org/3/library/index.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# sys"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este modulo da accesso a algunas variables usadas o mantenidas por el interpretador (el que le habla a la computadora). Este modulo siempre esta disponible y el detalle lo puede encontrar en [sys](https://docs.python.org/3/library/sys.html) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'3.9.7 | packaged by conda-forge | (default, Sep 29 2021, 19:24:02) \\n[Clang 11.1.0 ]'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys.version"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sys.version_info(major=3, minor=9, micro=7, releaselevel='final', serial=0)"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys.version_info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para saber la informacion acerca de los tipos de \"numeros reales\". \n",
    "`sys.float_info` contiene esta informacion basados en 1999 ISO/IEC C standard."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys.float_info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cada valor se puede obtener independientemente "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.7976931348623157e+308"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys.float_info.max"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Igual para los enteros:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sys.int_info(bits_per_digit=30, sizeof_digit=4)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys.int_info"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para ver el tamaño de un objeto en \"bytes\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8056"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a=list(range(1000))\n",
    "sys.getsizeof(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "48"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b=range(1000)\n",
    "sys.getsizeof(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para sabes \"el path\" y buscar donde estan los modulos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['/Users/aldoromero/BUAP/CourseML/BUAP_ML',\n",
       " '/Users/aldoromero/BUAP/CourseML/BUAP_ML',\n",
       " '/Users/aldoromero/Python/TSASE/tsase',\n",
       " '/Users/aldoromero/Python/ase/3.11.0/ase',\n",
       " '/Users/aldoromero/MiguelMarques/ase',\n",
       " '/Applications/vtkpython/bin/vtk/opt/local/Library/Frameworks/Python.framework/Versions/3.7/lib',\n",
       " '/Users/aldoromero/miniforge3/lib/python39.zip',\n",
       " '/Users/aldoromero/miniforge3/lib/python3.9',\n",
       " '/Users/aldoromero/miniforge3/lib/python3.9/lib-dynload',\n",
       " '',\n",
       " '/Users/aldoromero/miniforge3/lib/python3.9/site-packages',\n",
       " '/Users/aldoromero/miniforge3/lib/python3.9/site-packages/pyxtal-0.4.3-py3.9.egg',\n",
       " '/Users/aldoromero/miniforge3/lib/python3.9/site-packages/SMACT-2.3.1-py3.9.egg',\n",
       " '/Users/aldoromero/miniforge3/lib/python3.9/site-packages/pathos-0.2.8-py3.9.egg',\n",
       " '/Users/aldoromero/miniforge3/lib/python3.9/site-packages/ppft-1.6.6.4-py3.9.egg',\n",
       " '/Users/aldoromero/miniforge3/lib/python3.9/site-packages/pox-0.3.0-py3.9.egg',\n",
       " '/Users/aldoromero/miniforge3/lib/python3.9/site-packages/multiprocess-0.70.12.2-py3.9.egg',\n",
       " '/Users/aldoromero/miniforge3/lib/python3.9/site-packages/dill-0.3.4-py3.9.egg']"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys.path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Prefijo donde la version de Python que se esta usando:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/Users/aldoromero/miniforge3'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys.prefix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para \"hacer uso\" de los argumentos cuando hacemos llamado de un script\n",
    "\n",
    "myscript.py arg1 arg2 arg3\n",
    "    \n",
    "    \n",
    "de la linea `sys.argv` se pueden obtener."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['/Users/aldoromero/miniforge3/lib/python3.9/site-packages/ipykernel_launcher.py',\n",
       " '-f',\n",
       " '/Users/aldoromero/Library/Jupyter/runtime/kernel-0cc82f0d-e82c-4f48-b7bb-9da44f05b2d9.json']"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sys.argv"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Sin embargo `sys.argv` es muy primitiva para propositos practicos y es mejor usar el modulo  `argparse` "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# math and cmath"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este modulo da acceso a las funciones matematicas que estan dentro del estandar de C. De manera similar para numeros complejos se usa `cmath`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "import cmath"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Los argumentos para las funciones en  `math` y `cmath` deben ser numeros. Si lo que vamos a hacer es sobre un vector o matrices de numeros, `numpy` es mucho mas eficiente como veremos en el siguiente notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.ceil(2.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.7"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.fabs(-3.7)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`fabs` solo trabaja para numeros reales y siempre regresa un numero real, aunque el argumento dado sea un entero. En el caso de numeros complejos la funcion `abs()` regresa la magnitud del mumero complejo. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.810405388322278"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(-1.7+4.5j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "GCD se refiere al `Greatest Common Divisor of the integers a and b`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.gcd(91, 133)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16.0"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sqrt(256)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5000000000000001"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.cos(math.pi/3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## cmath"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "16j"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cmath.sqrt(-256)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.600286857702386-0j)"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "cmath.cos(1j*math.pi/3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# os and os.path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pronto tendras que interactuar con archivos y directorios. EL modulo `os` no solo nos da operatividad dentro del systema de archivos pero tambien nos da la posibilidad de ganar informacion acerca del sistema operativo. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Algunas funciones no estan disponibles en todos los sistemas operativos y en dado caso se regresa  `os.OSError` "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'posix'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "environ{'PROJ_LIB': '/Users/aldoromero/miniforge3/share/proj',\n",
       "        'MANPATH': '/opt/homebrew/share/man:/opt/local/share/man:/usr/local/opt/gnu-sed/libexec/gnuman::',\n",
       "        'ASE_GULP_COMMAND': '/Users/aldoromero/Gulp/GULP5.2/gulp-5.2/Src/gulp < PREFIX.gin > PREFIX.got',\n",
       "        'TERM_PROGRAM': 'Apple_Terminal',\n",
       "        'TERM': 'xterm-color',\n",
       "        'SHELL': '/bin/bash',\n",
       "        'HOMEBREW_REPOSITORY': '/opt/homebrew',\n",
       "        'BINDIR': '/opt/local/bin',\n",
       "        'TMPDIR': '/var/folders/sd/7rq2vwcx7fd8stfzsvfnz9980000gq/T/',\n",
       "        'CONDA_SHLVL': '1',\n",
       "        'INCLUDEDIR': '/opt/local/include/p4vasp',\n",
       "        'CONDA_PROMPT_MODIFIER': '(base) ',\n",
       "        'DFTB_COMMAND': '/Users/aldoromero/DFTB+/dftb+_1.2.2/dftb+_1.2.2_src/prg_dftb/_obj_macos/dftb+',\n",
       "        'TERM_PROGRAM_VERSION': '443',\n",
       "        'GSETTINGS_SCHEMA_DIR_CONDA_BACKUP': '',\n",
       "        'MKDIR_P': '/bin/mkdir -p',\n",
       "        'OLDPWD': '/Users/aldoromero/BUAP/CourseML',\n",
       "        'TERM_SESSION_ID': '06A6C5C6-1614-41D1-B22B-FA0AFD6B7A73',\n",
       "        'LC_ALL': 'en_US.UTF-8',\n",
       "        'P4VASP_HOME': '/opt/local/lib/p4vasp',\n",
       "        'USER': 'aldoromero',\n",
       "        'LD_LIBRARY_PATH': ':/Applications/vtkpython/lib:/usr/local/lib',\n",
       "        'ASE_TAGS': 'https://svn.fysik.dtu.dk/projects/ase/tags/',\n",
       "        'CONDA_EXE': '/Users/aldoromero/miniforge3/bin/conda',\n",
       "        'ABINIT_PP_PATH': '/Users/aldoromero/Abinit/Pseudopotentials/GGA_PAW:/Users/aldoromero/Abinit/Pseudopotentials/GGA_HGHK:/Users/aldoromero/Abinit/Pseudopotentials/GGA_FHI:/Users/aldoromero/Abinit/Pseudopotentials/LDA_TM:/Users/aldoromero/Abinit/Pseudopotentials/LDA_PAW:/Users/aldoromero/Abinit/Pseudopotentials/LDA_HGH:/Users/aldoromero/Abinit/Pseudopotentials/GGA_FHI:/Users/aldoromero/Abinit/Pseudopotentials/LDA_FHI',\n",
       "        'SSH_AUTH_SOCK': '/private/tmp/com.apple.launchd.F17tZciSYE/Listeners',\n",
       "        'GPAW_SETUP_PATH': '/Users/aldoromero/GPAW/gpaw-setups-0.9.11271',\n",
       "        'LIBDIR': '/opt/local/lib/p4vasp',\n",
       "        '_CE_CONDA': '',\n",
       "        'PATH': '/opt/homebrew/bin:/opt/homebrew/sbin:/Users/aldoromero/miniforge3/bin:/Users/aldoromero/miniforge3/condabin:/opt/local/libexec/gnubin:/usr/local/texlive/2019/bin/x86_64-darwin:/opt/local/bin:/opt/local/sbin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/Library/TeX/texbin:/opt/X11/bin:/Library/Apple/usr/bin:/Users/aldoromero/.local/bin:/Users/aldoromero/miniforge3/bin:/opt/local/Library/Frameworks/Python.framework/Versions/3.7/bin:/Users/aldoromero/tsase/tsase/bin:/Users/aldoromero/bin:/Library/TeX/Distributions/.DefaultTeX/Contents/Programs/texbin:/Users/aldoromero/Vasp/Olle/tdep-devel/bin:/Users/aldoromero/Vasp/SOD/sod/bin:/Users/aldoromero/bin',\n",
       "        'PROJ_NETWORK': 'ON',\n",
       "        'GSETTINGS_SCHEMA_DIR': '/Users/aldoromero/miniforge3/share/glib-2.0/schemas',\n",
       "        'MAPI_KEY': 'cwlbQ7fOT9CIWguq',\n",
       "        'LaunchInstanceID': 'EC9E4E9D-0EC2-4F27-B5FD-00497568BEED',\n",
       "        'CONDA_PREFIX': '/Users/aldoromero/miniforge3',\n",
       "        'GULP_LIB': '/Users/aldoromero/Gulp/GULP5.2/gulp-5.2/Libraries',\n",
       "        'C_INCLUDE_PATH': ':/usr/include:usr/local/include:',\n",
       "        '__CFBundleIdentifier': 'com.apple.Terminal',\n",
       "        'PWD': '/Users/aldoromero/BUAP/CourseML/BUAP_ML',\n",
       "        'LANG': 'en_US.UTF-8',\n",
       "        'DFTB_PREFIX': '/Users/aldoromero/DFTB+/Parameters/mio-1-1/',\n",
       "        'XPC_FLAGS': '0x0',\n",
       "        '_CE_M': '',\n",
       "        'XPC_SERVICE_NAME': '0',\n",
       "        'HOME': '/Users/aldoromero',\n",
       "        'SHLVL': '1',\n",
       "        'LANGUAGE': 'en_US:en',\n",
       "        'HOMEBREW_PREFIX': '/opt/homebrew',\n",
       "        'XBANDPATH': '/Users/aldoromero/SPRKK/xband',\n",
       "        'CONDA_PYTHON_EXE': '/Users/aldoromero/miniforge3/bin/python',\n",
       "        'PYTHONPATH': ':/Users/aldoromero/Python/TSASE/tsase/:/Users/aldoromero/Python/ase/3.11.0/ase:/Users/aldoromero/MiguelMarques/ase:/Applications/vtkpython/bin/vtk/opt/local/Library/Frameworks/Python.framework/Versions/3.7/lib',\n",
       "        'LOGNAME': 'aldoromero',\n",
       "        'LC_CTYPE': 'en_US.UTF-8',\n",
       "        'GILP_LIP': '/Users/aldoromero/Gulp/GULP5.2/gulp-5.2/Libraries',\n",
       "        'CONDA_DEFAULT_ENV': 'base',\n",
       "        'SITE_PACKAGES': '/opt/local/lib/python2.7/site-packages/p4vasp/',\n",
       "        'IMAGEIO_FFMPEG_EXE': '/usr/local/anaconda/bin/ffmpeg',\n",
       "        'INFOPATH': '/opt/homebrew/share/info:',\n",
       "        'HOMEBREW_CELLAR': '/opt/homebrew/Cellar',\n",
       "        'ARCHFLAGS': '-arch x86_64',\n",
       "        'DISPLAY': ':0',\n",
       "        'ASE_ABINIT_COMMAND': 'abinit < PREFIX.files > PREFIX.log',\n",
       "        'SECURITYSESSIONID': '186b3',\n",
       "        '_': '/Users/aldoromero/miniforge3/bin/jupyter',\n",
       "        'PYDEVD_USE_FRAME_EVAL': 'NO',\n",
       "        'JPY_PARENT_PID': '11597',\n",
       "        'CLICOLOR': '1',\n",
       "        'PAGER': 'cat',\n",
       "        'GIT_PAGER': 'cat',\n",
       "        'MPLBACKEND': 'module://matplotlib_inline.backend_inline'}"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.environ"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variables especificas tambien se pueden obtener"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'aldoromero'"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.getenv('USER')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/Users/aldoromero/BUAP/CourseML/BUAP_ML'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# pwd en linux\n",
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# mkdir en linux\n",
    "if not os.path.exists('test_folder'):\n",
    "    os.mkdir('test_folder')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "# cd en linux\n",
    "os.chdir('test_folder')\n",
    "os.chdir('..')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# ls linux\n",
    "os.listdir(\"test_folder\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "# rmdir en linux\n",
    "os.rmdir('test_folder')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "La siguiente funcion es util en HPC para determinar cuantos cores tienes acceso. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.cpu_count()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## os.path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Este modulo implementa algunas funciones utiles sobre ``pathnames``.  Por ejemplo para saber si un archivo o un directorio existing. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os.path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para saber si un archivo o directorio existe"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists('test_folder'):\n",
    "    os.mkdir('test_folder')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.path.isfile('test_folder')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.path.isdir('test_folder')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/Users/aldoromero/BUAP/CourseML/BUAP_ML/test_folder\n"
     ]
    }
   ],
   "source": [
    "fullpath=os.path.abspath('test_folder')\n",
    "print(fullpath)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('/Users/aldoromero/BUAP/CourseML/BUAP_ML', 'test_folder')"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.path.split(fullpath)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# shutil"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para operaciones de alto nivel en uno o mas archivos. La mayoria de funciones de `shutil` pueden copies o remover uno o muchos archivos en una sola llamada. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "import shutil"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'test_folder/newfile1'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "wf=open('newfile1','w')\n",
    "wf.close()\n",
    "if not os.path.exists('test_folder'):\n",
    "    os.mkdir('test_folder')\n",
    "shutil.copy2('newfile1', 'test_folder')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "shutil.rmtree('test_folder')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# itertools"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Combinaciones y permutaciones que usamos frecuentemente en diferentes problemas. EL modulo `itertools` ofrece funciones eficientes para crear operaciones que dan objetos que son iterables, inclusive hasta infinitas y usa menos memoria que una lista."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13\n",
      "14\n",
      "15\n",
      "16\n",
      "17\n",
      "18\n",
      "19\n",
      "20\n",
      "21\n",
      "22\n"
     ]
    }
   ],
   "source": [
    "index=0\n",
    "# itertools.count genera numers comenzando desde el 13 y si no se le dice nada, son infinitos\n",
    "for i in itertools.count(13):\n",
    "    print(i)\n",
    "    index=index+1\n",
    "    if index>9:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "e\n",
      "i\n",
      "o\n",
      "u\n",
      "a\n",
      "e\n",
      "i\n",
      "o\n",
      "u\n"
     ]
    }
   ],
   "source": [
    "index=0\n",
    "for i in itertools.cycle('aeiou'):\n",
    "    print(i)\n",
    "    index=index+1\n",
    "    if index>9:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "one\n",
      "one\n",
      "one\n",
      "one\n",
      "one\n"
     ]
    }
   ],
   "source": [
    "for i in itertools.repeat('one',5):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Para iteraciones mas grandes, la siguiente es mas eficiente por memoria y es equivalente "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "one\n",
      "one\n",
      "one\n",
      "one\n",
      "one\n"
     ]
    }
   ],
   "source": [
    "for i in 5*['one']:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Iterators para combinaciones y permutaciones pueden ser creados como: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('A', 'B', 'C')\n",
      "('A', 'B', 'D')\n",
      "('A', 'C', 'B')\n",
      "('A', 'C', 'D')\n",
      "('A', 'D', 'B')\n",
      "('A', 'D', 'C')\n",
      "('B', 'A', 'C')\n",
      "('B', 'A', 'D')\n",
      "('B', 'C', 'A')\n",
      "('B', 'C', 'D')\n",
      "('B', 'D', 'A')\n",
      "('B', 'D', 'C')\n",
      "('C', 'A', 'B')\n",
      "('C', 'A', 'D')\n",
      "('C', 'B', 'A')\n",
      "('C', 'B', 'D')\n",
      "('C', 'D', 'A')\n",
      "('C', 'D', 'B')\n",
      "('D', 'A', 'B')\n",
      "('D', 'A', 'C')\n",
      "('D', 'B', 'A')\n",
      "('D', 'B', 'C')\n",
      "('D', 'C', 'A')\n",
      "('D', 'C', 'B')\n"
     ]
    }
   ],
   "source": [
    "for i in itertools.permutations('ABCD',3):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('A', 'B', 'C')\n",
      "('A', 'B', 'D')\n",
      "('A', 'C', 'D')\n",
      "('B', 'C', 'D')\n"
     ]
    }
   ],
   "source": [
    "for i in itertools.combinations('ABCD',3):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('A', 'A')\n",
      "('A', 'B')\n",
      "('A', 'C')\n",
      "('A', 'D')\n",
      "('B', 'A')\n",
      "('B', 'B')\n",
      "('B', 'C')\n",
      "('B', 'D')\n",
      "('C', 'A')\n",
      "('C', 'B')\n",
      "('C', 'C')\n",
      "('C', 'D')\n",
      "('D', 'A')\n",
      "('D', 'B')\n",
      "('D', 'C')\n",
      "('D', 'D')\n"
     ]
    }
   ],
   "source": [
    "for i in itertools.product('ABCD',repeat=2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# json"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "JSON es un tipo de formato de datos, de poco uso de memoria e inspirado por la sintaxis de JavaScript. Es una manera muy efectiva y estandar para guardar datos estructurados. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [],
   "source": [
    "polygons={'triangle': 3, 'square': 4, 'pentagon': 5, 'hexagon': 6}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'{\"triangle\": 3, \"square\": 4, \"pentagon\": 5, \"hexagon\": 6}'"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "js=json.dumps(polygons)\n",
    "js"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Como ven, esta una cadena que puede ser leida muy facilmente por humanos y que se puede convertir facilmente a un diccionario de Python. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'triangle': 3, 'square': 4, 'pentagon': 5, 'hexagon': 6}"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "poly=json.loads(js)\n",
    "poly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Podemos hacerlo mas legible, usando algunos argumentos. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{\n",
      "    \"hexagon\": 6,\n",
      "    \"pentagon\": 5,\n",
      "    \"square\": 4,\n",
      "    \"triangle\": 3\n",
      "}\n"
     ]
    }
   ],
   "source": [
    "print(json.dumps(polygons, sort_keys=True, indent=4))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Similar a `json.dumps` y `json.loads` hay funciones para escribir y leer el contenido directo de JSON. Las funciones `json.dump(obj, fp, ...)` y `json.load(fp, ...)` trabajan sobre objetos de tip archivo. "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}