<jupyter_start><jupyter_text>![Banner del curso](https://docs.google.com/uc?export=download&id=1v9oXzOC5J_zT3_QLaVC47qIy67U1CO6b)Tutorial de como usar Colab e Repaso de Numpy y Pandas  Como usar Colab  Celdas - ApuntesUn notebook es una lista de celdas. Cada celda contiene un texto explicativo o un codigo ejecutable y su salida. Dale click a una celda para seleccionarla  Celdas de codigoAbajo hay un código de celda. Una vez que el botón de la barra de herramientas indique CONNECTED, haga clic en la celda para seleccionarla y ejecutar los contenidos de las siguientes maneras:* Haga clic en el **Icono de reproducción** en el canal izquierdo de la celda;* Escriba **Cmd/Ctrl+Enter** para ejecutar la celda en su lugar;* Escriba **Shift+Enter** para ejecutar la celda y mover el foco a la siguiente celda (agregando una si no existe ninguna); o* Escriba **Alt+Enter** para ejecutar la celda e insertar una nueva celda de código justo debajo de ella.Hay opciones adicionales para ejecutar algunas o todas las celdas en el menu **Entorno de ejecución**.   Codigo python<jupyter_code>a = 10 
b = 'algo'
a + b<jupyter_output><empty_output><jupyter_text>Codigo maquina (Linux)<jupyter_code>!pwd
!cd / #Comando que se ejecuta pero no afecta la maquina
!pwd
#Comando que se ejecuta y afecta la maquina
%cd /
!pwd
!ls
%pwd<jupyter_output><empty_output><jupyter_text>Celdas de textoEsta es una **celda de texto**. Puede **hacer doble clic** para editar esta celda. Las celdas de texto usan la sintaxis de markdown. Para obtener más información, consulte nuestra [Guia de Markdown](/notebooks/markdown_guide.ipynb).También puede agregar formulas matemáticas a las celdas de texto usando [LaTeX](http://www.latex-project.org/) y ser renderizado por [MathJax] (https://www.mathjax.org). Sólo coloque la declaración dentro de un par de **\$**. Por ejemplo `$\sqrt{3x-1}+(1+x)^2$` se convierte en $\sqrt{3x-1}+(1+x)^2.$  Trabajando con NotebooksColaboratory esta construido sobre [Jupyter Notebook](https://jupyter.org/). Debajo se muestran algunos ejemplos de uso de python:En el caso de colaboratory debemos estar conectados a internet y enlazado a la maquina virtual que nos provee google con dos nucleos y 12 GB de RAM, tambien podras usar una tarjeta grafica gratis.<jupyter_code>import time
print("Sleeping")
time.sleep(3) # sleep for a while; interrupt me!
print("Done Sleeping")<jupyter_output>Sleeping
Done Sleeping<jupyter_text>Autocompletacion con Ctrl + espacio o Tab*   Elemento de lista*   Elemento de listaEn los notebook de Colab puedes autocompletar tu codigo con Ctrl + Espacio para explorar atributos, metodos y parametros de funciones de tu codigo en Python.<jupyter_code>import numpy as np
np.random.rand()
np.random.randint<jupyter_output><empty_output><jupyter_text>Restricciones de las herramientas- Para el uso de Colab tienes una restriccion de 12 horas de uso diario.**Nota importante:** En colab una vez la herramienta se cierre perderas las variables y archivos guardados en la maquina virtual, para eso podemos enlazar la carpeta del drive con nuestro notebook y no perder datos.  Montar Drive en ColabPara montar tu carpeta de Drive en Colab debes ejecutar la siguiente celda y seguir los pasos que te indica.<jupyter_code>from google.colab import drive
drive.mount('/content/drive')<jupyter_output>Go to this URL in a browser: https://accounts.google.com/o/oauth2/auth?client_id=947318989803-6bn6qk8qdgf4n4g3pfee6491hc0brc4i.apps.googleusercontent.com&redirect_uri=urn%3aietf%3awg%3aoauth%3a2.0%3aoob&response_type=code&scope=email%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdocs.test%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive%20https%3a%2f%2fwww.googleapis.com%2fauth%2fdrive.photos.readonly%20https%3a%2f%2fwww.googleapis.com%2fauth%2fpeopleapi.readonly

Enter your authorization code:
··········
Mounted at /content/drive<jupyter_text>Cargar Datos a las MaquinasEn Colab tienes en el lado izquierdo superior una flecha que se apunta a la derecha para visualizar la tabla de contenidos del notebook, fragmentos de codigo y archivos de la maquina virtual, ahi mismo puedes subir datos sin necesidad de activar el drive.  Escojer tipo de entorno o maquinaPara Colab puedes dirigirte en entorno de ejecucion > Cambiar tipo de entorno de ejecucion > Seleccionamos el acelerador de Hardware que puede ser GPU y TPU (Asi es, totalmente gratis :D) y listo.**Ya con todo esto has completado el tutorial de Colab y Jupyter para trabajar con estas herramientas**  Repaso de Numpy y Pandas  Importacion de libreriasEn esta sección importaremos las dependencias básicas de nuestro notebook.<jupyter_code>import numpy as np
import pandas as pd
from IPython.display import clear_output<jupyter_output><empty_output><jupyter_text>Tipos de Datos de Numpy y PandasEstos describen como los bytes en el bloque de tamaño fijo de memoria correspondiente a un array deberia ser interpretado. Los diferentes tipos son:- int- float- bool- np.float32- np.float64- np.uint8- np.int32- np.complex128 **Actividad del estudiante**¿Porque es importante conocer los diferentes tipos de datos que hay en los equipos?   Creacion de matrices y arreglos de numpy<jupyter_code>#Creacion manual de una matriz
a = np.array([[1,2,3,4,5],
              [5,4,3,2,1],
              [9,8,7,6,5],
              [7,6,5,6,7],
              [2,2,2,3,3],
              [4,3,4,3,4],
              [5,1,1,4,1]])
print ("Dimensiones de A", a.shape)
print ("Numero de dimensiones de A", a.ndim)
print ("Filas de A", a.shape[0])
print ("Columnas de A", a.shape[1])

v = np.array([2,3,4,5,6,7,3,12])
print ("Forma de v", v.shape)
print ("Elementos de v", v.shape[0])

#Creacion aleatoria de una matriz
b = np.ones(a.shape)
c = np.zeros((10,10,10), dtype=np.float64)
print ("Dimensiones de B", b.shape)
print ("Numero de dimensiones de B", b.ndim)
print ("Dimensiones de C", c.shape)
print ("Numero de dimensiones de C", c.ndim)<jupyter_output>Dimensiones de A (7, 5)
Numero de dimensiones de A 2
Filas de A 7
Columnas de A 5
Forma de v (8,)
Elementos de v 8
Dimensiones de B (7, 5)
Numero de dimensiones de B 2
Dimensiones de C (10, 10, 10)
Numero de dimensiones de C 3<jupyter_text>Acceso a los elementos de un array de numpyCon la notación de índices accedemos a columas o filas enteras, rangos de columnas o filas, elementos individuales o porciones de una matriz o un vector.<jupyter_code>print ("una fila 2d       " ,a[2])
print ("una fila 2d       ",a[2,2:2:2])
print ("una columna 2d    ",a[:,2])
print ("un elemento 2d    ",a[2,2])
print ("varias filas 2d   \n",a[2:5])
print ("varias columnas 2d \n",a[:,1:3])
print ("una porcion 2d     \n",a[2:5,1:3])
print ("una porcion 3d    \n",c[2:5,1:3,:])<jupyter_output>una fila 2d        [9 8 7 6 5]
una fila 2d        [9 8 7 6 5]
una columna 2d     [3 3 7 5 2 4 1]
un elemento 2d     7
varias filas 2d   
 [[9 8 7 6 5]
 [7 6 5 6 7]
 [2 2 2 3 3]]
varias columnas 2d 
 [[2 3]
 [4 3]
 [8 7]
 [6 5]
 [2 2]
 [3 4]
 [1 1]]
una porcion 2d     
 [[8 7]
 [6 5]
 [2 2]]
una porcion 3d    
 [[[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]

 [[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]

 [[0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
  [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]]]<jupyter_text>Operaciones sobre los elementos de un array de numpyMuchas funciones de la librería `numpy` operan sobre una matriz completa, o de forma separada por columnas o filas según el valor del argumento axis.  Funciones tipicamente usadas de la libreria numpy<jupyter_code>print ("suma total", np.sum(b))
print ("suma eje 0", np.sum(b, axis=0))
print ("suma eje 1", np.sum(b, axis=1))
print ("promedio total", np.mean(a))
print ("promedio eje 0", np.mean(a, axis=0))
print ("promedio eje 1", np.mean(a, axis=1))<jupyter_output>suma total 35.0
suma eje 0 [7. 7. 7. 7. 7.]
suma eje 1 [5. 5. 5. 5. 5. 5. 5.]
promedio total 3.942857142857143
promedio eje 0 [4.71428571 3.71428571 3.57142857 4.         3.71428571]
promedio eje 1 [3.  3.  7.  6.2 2.4 3.6 2.4]<jupyter_text>Operaciones vectorizadas<jupyter_code>a = np.array([[1,2,3],[4,5,6]])
b = np.array([[6,5,4],[3,2,1]])

print (a)
print (b)
print ("--")

print ("a+b\n",a+b)
print ("a**2\n", a**2)
print ("a*b\n",a*b)
print ("a x b'\n",a.dot(b.T))
print ("a' x b\n",a.T.dot(b))<jupyter_output>[[1 2 3]
 [4 5 6]]
[[6 5 4]
 [3 2 1]]
--
a+b
 [[7 7 7]
 [7 7 7]]
a**2
 [[ 1  4  9]
 [16 25 36]]
a*b
 [[ 6 10 12]
 [12 10  6]]
a x b'
 [[28 10]
 [73 28]]
a' x b
 [[18 13  8]
 [27 20 13]
 [36 27 18]]<jupyter_text>Generacion de matrices y vectores con Numpy<jupyter_code>print ("matrix identidad\n", np.eye(3))
print ("vector de ceros", np.zeros(4))
print ("matriz de ceros\n", np.zeros((3,2)))
print ("matriz de unos\n", np.ones((2,3)))
print ("vector rango", np.arange(10))
print ("vector rango", np.arange(5,10))
print ("vector espacio lineal", np.linspace(-10,5,7))
print ("matriz aleatoria según distribución uniforme [0,1]\n", np.random.random(size=(3,5)))
print ("vector aleatorio de enteros entre 0 y 5", np.random.randint(5, size=10))<jupyter_output>matrix identidad
 [[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
vector de ceros [0. 0. 0. 0.]
matriz de ceros
 [[0. 0.]
 [0. 0.]
 [0. 0.]]
matriz de unos
 [[1. 1. 1.]
 [1. 1. 1.]]
vector rango [0 1 2 3 4 5 6 7 8 9]
vector rango [5 6 7 8 9]
vector espacio lineal [-10.   -7.5  -5.   -2.5   0.    2.5   5. ]
matriz aleatoria según distribución uniforme [0,1]
 [[0.37477626 0.77279471 0.04758115 0.70178904 0.63060016]
 [0.8863465  0.31880025 0.14383698 0.37297815 0.54078226]
 [0.95281625 0.34689014 0.71815465 0.10149141 0.24637823]]
vector aleatorio de enteros entre 0 y 5 [4 1 1 4 1 1 4 3 2 0]<jupyter_text>Creacion de DataFrames con Pandas  Por medio de Numpy Arrays<jupyter_code>a = np.random.randint(10,size=(20,5))
a
k = pd.DataFrame(a, columns=["uno", "dos", "tres", "cuatro", "cinco"], index=range(10,10+len(a)))
k<jupyter_output><empty_output><jupyter_text>Por medio de Datos en CSV- Preferiblemente es mejor usar CSV aunque tambien podemos usar archivos de Excel para ser cargados por medio de Pandas  Descargamos los datos<jupyter_code>!wget --no-check-certificate 'https://docs.google.com/uc?export=download&id=1Y1rf0rk_6xmO-OU7Jkcv5l7PXFKEZijO' -O data.csv
clear_output()
!wget --no-check-certificate 'https://docs.google.com/uc?export=download&id=1iStYnyyUwXPSUyIdmVRenAAkE99ZzEBb' -O data.xlsx
clear_output()
df_csv = pd.read_csv('data.csv')
df_excel = pd.read_excel('data.xlsx')<jupyter_output><empty_output><jupyter_text>Inspeccion de los Datos<jupyter_code>df_csv.head(2)
df_excel.head()
df_csv.columns
df_csv.shape<jupyter_output><empty_output><jupyter_text>Acceso a columnas y elementos del datasetEn el dataset que estamos trabajando tenemos algunas columnas como: "Ciclo de vida" que posee espacios y queremos acceder a todos los datos de este, para hacerlo podemos hacer lo siguiente: Acceso a columnas de un dataset- d.``- d`["nombre_columna"]` o d`[]`- d.at`[]` Acceso a filas de un dataset- d.loc(``)- d.iloc(``) Acceso a una celda del dataset- d.at`[,]`- d.iloc(``)`[]`- d.``.iloc(``)<jupyter_code>df_csv.iloc[0]["Berri1"]
type(df_csv), type(df_csv["Berri1"])
df_csv.iloc[100:110:2]
df_csv.index
#Cambiamos los indices de los datos
df_csv.index = pd.to_datetime(df_csv.Date)
df_csv.loc["2009-10-01":"2009-10-10"]
df_csv.drop(df_csv['Berri1'], axis=1)
#Elimino dos columnas que ya tengo y luego les cambio el nombre
del(df_csv["Date"])
del(df_csv["Unnamed: 1"])
df_csv.columns = ["Berri", "Mneuve1", "Mneuve2", "Brebeuf"]
df_csv.head()
df_csv = df_csv.drop(columns=["Berri"], axis=1)
df_csv.head()<jupyter_output><empty_output><jupyter_text>Metodos de los Dataframes  Filtracion<jupyter_code>df_csv[df_csv.Berri>6000]
df_csv[(df_csv.Berri>6000) & (df_csv.Brebeuf<7000)]
df_csv[df_csv.Berri>5500].sort_index(axis=0)<jupyter_output><empty_output><jupyter_text>Valores invalidos<jupyter_code>df_csv.isna().sum()
df_csv.isna().sum().values.sum()<jupyter_output><empty_output><jupyter_text>Agregar nuevas columnas<jupyter_code>df_csv["nueva_columna"] = np.zeros(df_csv.shape[0])
df_csv.head()<jupyter_output><empty_output><jupyter_text>Concatenacion de Dataframes<jupyter_code>a = np.random.randint(10,size=(1500,3))
b = np.random.randint(10,size=(1500,3))
a = pd.DataFrame(a, columns=["ejemplo_1a","ejemplo_2a","ejemplo_3a"])
b = pd.DataFrame(b, columns=["ejemplo_1b","ejemplo_2b","ejemplo_3b"])
nuevo_df = pd.concat([b, a], axis=1)
nuevo_df.head()<jupyter_output><empty_output><jupyter_text>Convertir Dataframe a Numpy array<jupyter_code>df_csv.values.shape<jupyter_output><empty_output><jupyter_text>Agrupacion sobre los dataframes<jupyter_code>df_csv["month"] = [i.month for i in df_csv.index]
df_csv.head()
df_csv.groupby(df_csv.month == 1).count()
df_csv.groupby("month").max()<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.13136224609834524, 'fraction_numerical': 0.06266175201944946, 'mean_word_length': 4.736392262708052, 'pattern_counts': {'":': 1, '<': 79, '<?xml version=': 0, '>': 83, 'https://': 6, 'lorem ipsum': 0, 'www.': 6, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 5, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '21', 'dir': 'jupyter-structured-clean-dedup', 'id': '126308', 'license': 'MIT', 'n_tokens_mistral': 5599, 'n_tokens_neox': 5163, 'n_words': 1537, 'path': '01.Como_usar_Colaboratory.ipynb', 'repo_name': 'JefeLitman/Curso_Analisis_Datos_Basico_Python', 'size': '12751'}