<jupyter_start><jupyter_text>MAT281 Aplicaciones de la Matemática en la Ingeniería  Módulo 1 Clase 02: Data Science Toolkit   ¿Qué contenidos aprenderemos?* [Sistema Operativo](so)* [Interfaz de Línea de Comandos](cli)* [Entorno Virtual](venv)* [Python](python)* [Project Jupyter](jupyter)* [Git](git)  Objetivos de la clase* Instalación y uso de herramientas computacionales.* Utilizar Jupyter Notebook/Lab.* Recordar Python  Sistema Operativo* Personalmente recomiendo **Linux**, en particular distribuciones como Ubuntu, Mint o Fedora por su facilidad a la hora de instalar.* En ocasiones las implementaciones en **Windows** no están completamente integradas e inclusive en ocasiones no están disponibles.    - Una alternativa es [**Windows Subsystem for Linux**](https://docs.microsoft.com/en-us/windows/wsl/about), pero lamentablemente no se asegura un 100% de compatibilidad.* En el caso que poseas un equipo con **macOS** no debería haber problema.  Interfaz de Línea de Comandos (*Command Line Interface* / CLI)* Es un método que permite a los usuarios interactuar con algún programa informático por medio de líneas de texto.* Típicamente se hace uso de una terminal/*shell* (ver imagen).* En el día a día dentro de la oficina facilita flujo de trabajo.* Permite moverse entre manipular directorios y ficheros, instalar/actualizar herramientas, aplicaciones, softwares, etc. *Screenshot of a sample bash session in GNOME Terminal 3, Fedora 15. [Wikipedia](https://en.wikipedia.org/wiki/Command-line_interface)*   Entorno Virtual__Problemas recurrentes:__- Dependencias de librerías (*packages*) incompatibles.- Dificultad a la hora de compartir y reproducir resultados, e.g. no conocer las versiones de las librerías instaladas.- Tener una máquina virtual para cada desarrollo es tedioso y costoso.- Miedo constante a instalar algo nuevo y tu script vuelva a funcionar.  Solución Aislar el desarrollo con tal de mejorar la compatibilidad y reproducibilidad de resultados.    ¿Cómo? Utilizando entornos virtuales.   Para el curso (es recomendable)![Conda](https://conda.io/docs/_images/conda_logo.svg)*Package, dependency and environment management for any language—Python, R, Ruby, Lua, Scala, Java, JavaScript, C/ C++, FORTRAN.* [(Link)](https://conda.io/docs/)  ¿Por qué Conda?* Open Source* Gestor de librerías __y__ entornos virtuales. * Compatible con Linux, Windows y macOS.* Es agnóstico al lenguaje de programación (inicialmente fue desarrollado para Python).* Es de fácil instalación y uso.  InstalaciónToda la documentación se encuentra en este [link](https://docs.conda.io/projects/conda/en/latest/user-guide/install/index.html), pero en resumen:* Existe Anaconda y Miniconda, ambas contienen conda.    - Anaconda es una distribución que incluye una artillería de librerías científicas.    - Miniconda es para realizar una instalación mínima de conda sin adicionales (recomendada).* Descarga e instala **Miniconda3** (Python3) según tu sistena operativo.* En la instalación se te preguntará: __Do you wish the installer to initialize Anaconda3 by running conda init?__ Recomiendo aceptar, luego cerrar la terminal, abrir una nueva y ejecutar:`conda config --set auto_activate_base false`* Test:     ```conda --version```<jupyter_code>!conda --version<jupyter_output>conda 4.7.10<jupyter_text>Otras alternativas:* ```pip``` + ```virtualenv```, el primero es el gestor favorito de librerías de Python y el segundo es un gestos de entornos virtuales, el contra es que es exclusivo de Python.     - Ojo! En Conda también puedes instalar por  ```pip```.* __Dockers__ es una herramienta muy de moda en grandes proyectos debido a ser, en palabras simples, un intermedio entre entornos virtuales y máquinas virtuales.  PythonLas principales librerías científicas a instalar y que ocuparemos durante el curso son:* [Numpy](http://www.numpy.org/): Computación científica.* [Pandas](https://pandas.pydata.org/): Análisis de datos.* [Matplotlib](https://matplotlib.org/): Visualización.* [Altair](https://altair-viz.github.io/): Visualización Declarativa.* [Scikit-Learn](http://scikit-learn.org/stable/): Machine Learning  Project Jupyter *[Project Jupyter](https://jupyter.org/index.html) exists to develop open-source software, open-standards, and services for interactive computing across dozens of programming languages.*  Jupyter NotebookEs una aplicación web que permite crear y compartir documentos que contienen código, ecuaciones, visualizaciones y texto. Entre sus usos se encuentra:* Limpieza de datos* Transformación de datos* Simulaciones numéricas* Modelamiendo Estadístico* Visualización de Datos* Machine Learning* Mucho más. ![Jupyter Notebook Example](https://jupyter.org/assets/jupyterpreview.png)  Jupyter Lab* Es la siguiente generación de la interfaz de usuario de *Project Jupyter*.* Similar a Jupyter Notebook cuenta con la facilidad de editar archivos .ipynb (notebooks) y heramientas como una terminal, editor de texto, explorador de archivos, etc.* Eventualmente Jupyter Lab reemplazará a Jupyter Notebok (aunque la versión estable fue liberada hace algunos meses).* Cuenta con una serie de extensiones que puedes instalar (y desarrollar inclurisve.Puedes probar Jupyter Lab con solo dos clicks!1. Ingresar a este link: https://github.com/jupyterlab/jupyterlab-demo2. Hacer click en el icono de binder:  ![Binder](https://mybinder.org/badge_logo.svg)  Git_[__Git__](https://git-scm.com/) is a free and open source distributed version control system designed to handle everything from small to very large projects with speed and efficiency._  Instalación de GitNo es nada del otro mundo, basta con seguir las instrucciones de la página oficial en este [link](https://git-scm.com/book/en/v2/Getting-Started-Installing-Git).   Configuración de GitNo es un paso crucial, pero si en el futuro quieres tener tu propio repositorio o contribuir en otros proyectos, debes tener una identidad. Lo primero es configurar git, la [documentación oficial](https://git-scm.com/book/es/v1/Empezando-Configurando-Git-por-primera-vez) incluso está en español. Con configurar tu ```email``` y ```username``` debería bastar en una primera instancia.Lo siguiente es tener una cuenta en la plataforma que utilizarás. Algunas de ellas son:* GitHub* GitLab* Bitbucket  GitHub_[GitHub](https://github.com/) is a development platform inspired by the way you work. From open source to business, you can host and review code, manage projects, and build software alongside 30 million developers._Es decir, es una plataforma para alojar proyectos que utilizan Git como sistema de control. El **material del curso** estará disponible a través de GitHub en el siguiente link: https://github.com/aLoNsolml/mat281_2019S2. Uno de los objetivos del curso es que familiarices con git y un buen punto de partida es configurar tu computador personal para interactuar con GitHub.1. Crea una cuenta en GitHub.    1. Con tu correo UTFSM puedes reclamar un Student Pack de GitHub, uno de los beneficios es que te permite acceder a una membresía Pro y así tener repositorios privados. El link: https://education.github.com/students2. En tu terminal configurar tu usuario y correo electrónico global de git (más adelante puedes modificar repositorios localmente).    1. `$ git config --global user.name "<NAME>"`    2. `$ git config --global user.email "<EMAIL>"`3. Conectar tu entorno de trabajo (computador) con tu cuenta de GitHub a través de SSH:    1. https://help.github.com/en/articles/connecting-to-github-with-ssh  Manos a la obra1. Tener paciencia.2. En la terminal (de git si es el caso) debes `moverte` hasta donde quieras guardar el material del curso. En lo personal me gusta crear una carpeta llamada __git__ en __Documents__. Los pasos serían:    * Abrir terminal    * ```cd ~/Documents```    * ```mkdir git```     * `cd git`    3. Clonar el repositorio del curso, ejecutando la siguiente línea de comando en la ruta deseada (en mi caso *~/Documents/git*):     1. Si utilizas SSH: ```git clone git@github.com:aLoNsolml/mat281_2019S2.git```     2. Si utilizas HTTPS: `git clone https://github.com/aLoNsolml/mat281_2019S2.git`    3. Descargar el repositorio como ZIP y descomprimir        1. Esta alternativa no es muy recomendable, porque no te va a permitir descargar los cambios utilizando git, tendrás que descargar completamente el repositorio cada vez.4. En la terminal moverse hacia la carpeta del repositorio utilizando ```cd mat281_2019S2``` (__tip__: Puedes usar ```TAB``` para autocompletar).5. En la terminal (Anaconda Prompt si estás utilizando Windows) crear un entorno virtual de conda a partir de un archivo de requisitos (llamado *mat281_modulo1*), ejecutando la siguiente línea de comando:    ```conda env create -f environment.yml```6. Activar el entorno: `conda activate mat281` 7. Ejecutar:    - ```jupyter lab```, o    - ```jupyter notebook```8. Si no se abre atuomáticamente una nueva pestaña en tu navegador, copiar el link del token que se muestra en la terminal en tu navegador.9. Abrir el archivo ```m01_c02_data_science_toolkit.ipynb``` ubicado en el directorio 02_data_science_toolkit. ![Ejemplo terminal jupyter lab](http://i.imgur.com/w3tb35S.png)  Recordando Python * Números y operaciones* Listas, tuplas, conjuntos y diccionarios.* Control flow* Importar librerías  Hola Mundo!<jupyter_code>print('Hello World!')
name = '<NAME>'
print("Hola {}!".format(name))<jupyter_output>Hola <NAME>!<jupyter_text>Números y operaciones<jupyter_code>1 + 2
100 - 99
3 * 4
42 / 4  # En python 2 la división por defecto es entera
43 // 4
14 % 4<jupyter_output><empty_output><jupyter_text>Listas, tuplas, conjuntos y diccionarios<jupyter_code>range(2, 10, 3)
type(range(10))
a = range(10)
l = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for x in a:
    print(x)
for x in l:
    print(x)
l[1]
a[3]
# Listas
my_list = [1, 2, 3, 4, 5]
print(my_list[0])
# Tuplas
my_tuple = (1, 2, 3, 4, 5)
print(my_tuple[4])
type(my_list)
# Las listas pueden ser modificadas
my_list.append(100)  
print(my_list)
# Las tuplas son objetos inmutables!
try:
    my_tuple.append(50)
except Exception as e:
    print(e)
my_list
# Accediendo a valores
print(my_list[0])
print(my_list[-1])
print(my_list[0:2])
print(my_list[2:])
print(my_list[::2])
print(my_list[:-2])
# Conjuntos
my_set = {1, 1, 1, 2, 2, 3}
print(my_set)
# Diccionarios
my_dict = {
    'llave': 'corazón',
    'sonrisa': 'corazones'
}
print(my_dict['sonrisa'])
age_dict = {"alonso": "hfjdsafhks", "pedro": 29, "quentin": 22}
my_dict.values()
try:
    my_dict.values()[0]
except:
    print("ocurrió un error")<jupyter_output>ocurrió un error<jupyter_text>Control Flow<jupyter_code># Condicionales If, Elif, Else
x = 7
cota_inferior = 5
cota_superior = 10
if x < cota_inferior:
    print('{} es menor que {}'.format(x, cota_inferior))
elif x < cota_superior:
    print('{} es mayor igual que {} y menor que {}'.format(x, cota_inferior, cota_superior))
else:
    print('{} es mayor igual que {}'.format(x, cota_superior))
# Cilo While
i = 0
while i < 10:
    print(i)
    i += 1
# Ciclo For
for i in range(1, 10, 2):
    if i < 5:
        print('{} es menor que 5'.format(i))
    else:
        print('{} es mayor igual que 5'.format(i))<jupyter_output>1 es menor que 5
3 es menor que 5
5 es mayor igual que 5
7 es mayor igual que 5
9 es mayor igual que 5<jupyter_text>Range no es una lista!<jupyter_code>my_range = range(1, 10, 2)
type(my_range)
range?
# Presione TAB en el punto de la lína
my_range.start
my_range.start
my_range.stop
my_range.step<jupyter_output><empty_output><jupyter_text>Librerías<jupyter_code>import math # Librería instalada
import testFunction as tf  # Librería local
math.floor(2.6)
floor(2.6)
# En Jupyter podemos ver el código de fuente inclusive
tf.testFunction??
tf.testFunction(10, 2.5)
# La librería math no está cargada!
math.floor(2.5)<jupyter_output><empty_output><jupyter_text>Pro-TipJupyter está basado en ```IPython```, por lo que puedes hacer uso de los comandos mágicos.<jupyter_code># Un poco de documentación
%magic
# %load testFunction.py
import math


def testFunction(x, y):
    """ Retorna la diferencia entera entre dos valores."""
    diff = abs(x - y)
    value = math.floor(diff)
    return value
%run testFunction.py
%lsmagic
%pwd<jupyter_output><empty_output><jupyter_text>Existen comando mágicos de línea (```%```)y de celda completa (```%%```)<jupyter_code>%timeit comprehension_list = [i*2 for i in range(1000)]
%%timeit

no_comprehension_list = []
for i in range(1000):
    no_comprehension_list.append(i * 2)
len(comprehension_list)<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.0968871905103097, 'fraction_numerical': 0.017196083114401718, 'mean_word_length': 4.959203036053131, 'pattern_counts': {'":': 3, '<': 41, '<?xml version=': 0, '>': 37, 'https://': 20, 'lorem ipsum': 0, 'www.': 1, 'xml': 0}, 'pii_count': 1, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '9', 'dir': 'jupyter-structured-clean-dedup', 'id': '29937', 'license': 'MIT', 'n_tokens_mistral': 4425, 'n_tokens_neox': 4227, 'n_words': 1517, 'path': 'm01_introduction/02_data_science_toolkit/m01_c02_data_science_toolkit.ipynb', 'repo_name': 'Taz-Ricardo/mat281_portafolio', 'size': '12592'}