Python: Los básicos Listas [ ] Metodos no permanentes Diccionarios { key : value , } zip() Sentencias de control

lista = [] crea una lista vacia diccionario = {x:y} compuestos por un key(x) unica zip(iterable1, iterable2) crea una lista de tuplas de if ... elif ... else
Variables ampliadas por text y un valor(y) (cualquier tipo de datos) parejas de los elementos de las dos listas (mientras se if estableca una condición para que se ejecute el código que
puede) esta debajo del if. *tiene que estar indentado*
(CONCATENATION) len(lista) devuelve el no. de elementos dict() elif para chequear mas condiciones después de un if
min(lista)/max(lista) saca el valor minimo y maximo variable = dict(x=y, m=n) crear un diccionario listzip.sort() ordena las tuplas del zip por el primer else agrupa las condiciones que no se han cumplido; no puede
Para encadenar texto elemento llevar condiciones nuevas
lista.count() devuelve el no. de elementos que hay en dicc.copy() crear una copia
categoria1 = "verde" la lista de un valor determinado en los() if x > y:
color_detalle = categoria1 + ' ' + 'oscuro" len(dicc) devuelve el no. de elementos (x:y) hay en
sorted(lista) ordenar una lista de menor a mayor el diccionario
Sets {} print("x es mayor que y")
elif x == y:
print(categoria1 + ' oscuro') no permiten duplicados, no tienen orden print("x es igual que y")
lista.copy() hacer una copia de la lista sorted(dicc) ordena los keys; usar con .items()
print(categoria1, 'oscuro') para ordenar tuplas de los elementos o .values() else:
set = {x,y}
para ordenar los values solos print("x e y son iguales")
set(iterable) solo permite un argumento iterable; elimina
type() and isinstance() Metodos con indices duplicados while
float/int/str(variable) cambia el tipo de data/type list.index(x) devuelve la indice de x en la lista Diccionarios – Metodos • repite el código mientras la condición sea True, o sea se
lista[i] devuelve el elemento en la indice i in/not in comprobar si hay un elemento parará cuando la condición sea False
type(variable) devuelve: class 'float/int/str' • se pueden incluir condiciones con if... elif... else
[start:stop:step] Obtener informacion de un diccionario len(set) devuelve el no. de elementos
• *pueden ser infinitos* (si la condición no llega a ser
lista[i:j:x] devuelve los elementos por el rango de i dicc.keys() devuelve todas las keys False)
isinstance(variable, float/int/str) comprobar el tipo
a j (incluye i pero no j) saltando por x dicc.values() devuelve todos los values Ampliar un set
de dato (devuelve True/False)
lista[-i:-j] devuelve los elementos por los indices while x < 5:
dicc.items() devuelve tuplas de los key:value set.add(x)# añadir un elemento
negativos (incluye –j pero no –i) print("x es mayor que 5")
in/not in comprobar si existe una clave set.update(set o lista)# añadir uno o mas elementos con
Operaciones Algebraicas [] o {} o un variable tipo lista o set
dicc.get(x, y) devuelve el valor asociado al key x,
+ sumar / dividir o si no existe devuelve el output y For loops
- restar // divider y redondear (modulus) Listas – Acciones Permanentes dicc["key"] devuelve el valor del key (ver abajo Quitar elementos de un set • sirven para iterar por todos los elementos de un variable
* multiplicar % resto de una division (floor que tiene mas usos)
** elevar division) set.pop()# elimina un elemento al azar que tiene que ser un iterable (lista, diccionario, tupla,
Ampliar una lista set, or string)
round(x) redondear número x set.remove(x)# elimina el elemento x
[lista1, lista2] junta listas pero se mantienen como Ampliar un diccionario • se pueden combinar con if ... elif ... else, while, u otro
listas separadas set.discard(x)# elimina el elemento x (y no devuelve
Operaciones Binarias lista1 + lista2 hace una lista mas larga
.update() error si no existe) for loop
dicc.update({x:y})# para insertar nuevos elementos set.clear()# vacia el set • en diccionarios por defecto intera por las keys; podemos
== comprobar si valores coinciden usar dicc.values() para acceder a los values
.append() dicc["key"] = valor# para inserter un nuevo key o
is comprobar si valores son exacamente igual valor, o cambiar el valor de un key for i in lista:
!= comprobar si valores son diferentes lista.append(x)# añade un solo elemento (lista, Operaciones con dos Sets
dicc. setdefault(x, y)# devuelve el value del key print("hola mundo")
is not comprobar si valores no son exactamente string, integer o tuple) a la lista
x, o si no existe la key x, la crea y asigna el
iguales set1.union(set2) devuelve la union de los dos sets: todos
.extend() valor y por defecto
> (>=) mayor que (mayor o igual que)
lista.extend(lista2)# añade los elementos de una
los elementos menos dupl. List comprehension
< (<=) menor que (menor o igual que) lista al final de la lista set1.intersection(set2) devuelve los elementos comunes de
and ambas verdaderas Quitar elementos de un diccionario los dos sets • su principal uso es para crear una lista nueva de un un for
or ambas o solo una verdadera .insert() dicc.pop(x)# elimina la key x (y lo devuelve) loop en una sola línea de codigo
set1.difference(set2) devuelve los sets que estan en set1
in/not in comprobar si hay un valor en una lista etc. .insert(i, x)# mete un elemento (x) en un índice(i) dicc.popitem()# elimina el ultimo par de key:value pero no en set2 (restar) [ lo que queremos obtener iterable condición (opcional) ]
dicc.clear()# vacia el diccionario
Ordenar una lista set1.symmetric_difference(set2) devuelve todos los
elementos que no estan en ambos
Metodos String .sort() try ... except
set1.isdisjoint(set2) comprobar si todos los elementos de
string.upper()z MAYUSCULAS lista.sort()# ordena de menor a mayor, usar con Tuplas (,) inmutables, indexados dos sets son diferentes
(reverse=True) para ordenar de mayor a menor Se usan para evitar que nuestro código se pare debido a un error
string.lower() minusculas set1.issubset(set2) comprobar si todos los elementos de
lista.reverse()# ordena los elementos al reves del en el código. Se puede imprimir un mensaje que avisa del error.
string.capitalize() Primera letra de la frase en may. tupla = (x,y) tuplas se definen con () y , o solo , set1 estan en set2
string.title() Primera Letra De Cada Palabra En May. orden guardado try:
tupla1 + tupla2 juntar tuplas
string.swapcase() mINUSCULAS A mAYUSCULAS O vICEVERSA set1.superset(set2) comprobar si todos los elementos de
print("2.split())
Quitar elementos de una lista set2 estan en set1
string.strip() quita espacios del principio y final tuple(lista) crear tuplas de una lista except:
.pop() tuple(dicc) crear tuplas de los keys de un print("no funciona")
string.split() divide string en lista – por espacios
lista.pop(i)# quita el elemento en indice i y diccionario
por defecto, o especifica otro divisor en ()
devuelve su valor input()
string.replace("frase", "frase") remplaza la primera tuple(dicc.values()) crear tuplas de los values
frase del string por el otro .remove() tuple(dicc.items()) crear tuplas de los key:values • permite obtener texto escrito por teclado del usuario range()
" ".join(string) une los elementos de una lista en lista.remove(x)# quita el primer elemento de la lista input("el texto que quieres mostrar al usuario")
una string con el separador espificado en " " con valor x len(tupla) devuelve el no. de elementos
• se puede guardar en un variable • nos devuelve una lista de números que por defecto se
list(string) convierte un variable string en una in/not in comprobar si hay un elemento aumentan de uno en uno empezando por 0
lista.clear()# vacia la lista • por defecto se guarda como un string
lista tupla.index(x) devuelve el indice de x range(start:stop:step)
string.find("substring") encuentra el indice en que tupla.count(x) devuelve el no. de elementos con x = int(input("escribe un número") para usar el variable
del lista# borra la lista • se puede especificar por donde empieza y el limite (que debe
empiece el substring/'-1' si no existe el substring valor x en la tupla como integer o float se puede convertir en el variable
del lista[i]# borra el elemento en indice i ser +1 por que se para uno antes del limite que ponemos como
stop)
string[i] devuelve el elemento en la indice i *para cambiar el contenido de una tupla hay que
• tambien se puede especificar saltos
string[i:j] devuelve un rango de caracteres convertirla en una lista y luego a tupla*

# metodos permanentes (cambia el variable, no devuelve nada)

Funciones y Clases; Librerías Regex Modulos/Librerias (paquetes de funciones) Ficheros xml MySQL Connector/Python
- una abreviatura de `expresión regular`, Importar y usar modulos y sus funciones import xml.etree.ElementTree as ET importa la librería xml Obtener resultados de una query
Funciones `regex` es una cadena de texto que permite import modulo para importar un modulo variable_tree = ET.parse('ruta/archivo.xml') abre el
variable_cursor.fetchone() devuelve el primer resultado
crear patrones que ayudan a emparejar, from modulo import funcion importar solo una funcion archivo
localizar y gestionar strings variable_root = variable_tree.getroot() saca el elemento variable_cursor.fetchall() devuelve todos los resultados
Definir una funcion: modulo.funcion() usar una funcion de un modulo
como iterable – cada fila es una tupla
modulo.clase.funcion() para usar una funcion de una clase que envuelve todo (el elemento raíz) en una lista
def nombre_funcion(parametro1, parametro2, ...): import re para poder trabajar con regex
import modulo as md asignar un alias a un modulo <root>
return valor_del_return Pandas dataframe with SQL
Operadores communes de regex <child_tag atributo1="valor" atributo2=valor>
<subchild_tag> elemento </subchild_tag> import pandas as pd
Llamar una funcion: + coincide con el carácter precedente una o más Libreria os
</child_tag>
nombre_funcion(argumento1, argumento2, ...) veces os.getcwd() devuelve la ruta de donde estamos trabajando; se variable_df = pd.DataFrame(variable_resultado_fetchall,
</root>
* coincide con el carácter precedente cero o puede guardar en un variable e.g. ruta = os.getcwd() columns = ['columna1', 'columna2', ...]) crear un
variable_root.tag devuelve el nombre del tag del raiz
return: es opcional, pero sin return devuelve None más veces u opcional os.listdir() devuelve una lista de los archivos y carpetas dataframe con los resultados de una query en una variable
variable_root.attrib devuelve los atributos del fichero
parametros por defecto: – siempre deben ser lo donde estamos trabajando
? indica cero o una ocurrencia del elemento variable_df.head(n) devuelve las n primeras filas del df,
ultimo os.listdir('carpeta') devuelve los contenidos de otra carpeta
precedente variable_root.find("tag").find("childtag").text devuelve o 5 por defecto
os.chdir('ruta') cambia la carpeta en la que estes
. coincide con cualquier carácter individual la primera ocasión en que el tag de un elemento coincida variable_df = pd.read_sql_query(variable_query,
*args: una tupla de argumentos sin limite os.mkdir('nueva_carpeta') crear una nueva carpeta
con el string variable_cnx) convertir los resultados de la query en df
**kwargs: diccionarios cuyas keys se convierten en ^ coincide con la posición inicial de cualquier os.rename('nombre_carpeta', 'nueva_nombre') cambia el nombre
variable_root.findall("tag").findall("childtag").text
parámetros y sus valores en los argumentos de los string de una carpeta pd.read_sql(variable_query, variable_cnx)
devuelve todos los elementos cuyos tag coincide
parámetros $ coincide con la posición final de cualquier os.rmdir('carpeta') borra la carpeta
variable_df.to_csv("nombre_archivo.csv") guardar en csv
string
def nombre_funcion(parametros, *args, **kwargs, Libreria shutil MySQL Connector/Python variable_df.to_string() formatear el dato en string
Sintaxis básica de regex from shutil inmport rmtree
parametro_por_defecto = valor) variable_df.to_latex() formatear el dato en un string que
arg/kwarg: sin */** dentro de la funcion \w cualquier caracter de tipo alfabético rmtree('carpeta') borra la carpeta y subcarpetas Conectar a una base de datos facilite la inserción en un documento latex
arg[0] \d cualquier caracter de tipo númerico import mysql.connector para importar MySQL Connector
\s espacios Abrir y cerrar ficheros Crear y alterar una base de datos
pip install mysql-connector
Llamar una funcion con *args: \n saltos de línea Primero hay que guardar la ruta del archivo:
pip install mysql-connector-Python variable_cursor.execute("CREATE DATABASE nombre_BBDD")
nombre_funcion(argumento, argumento, argumento, ...) ubicacion_carpeta = os.getcwd()
\W cualquier caracter que no sea una letra connect() para conectar a una base de datos: variable_cursor.execute("CREATE TABLE nombre_tabla
o nombre_archivo = "text.txt"
\D cualquier caracter que no sea un dígitos ubicacion_archivo = ubicacion_carpeta + "/" + nombre_archivo variable_cnx = mysql.connector.connect(user='root', (nombre_columna TIPO, nombre_columna2 TIPO2)")
nombre_funcion(*[lista_o_tupla_de_args])
\S cualquier elemento que no sea un espacio password='AlumnaAdalab', variable_cursor.execute("ALTER TABLE nombre_tabla
f = open(ubicacion_archivo) abrir un archivo en variable f host='127.0.0.1', ALTERACIONES")
Llamar una funcion con **kwargs: () aísla sólo una parte de nuestro patrón de
database='nombre_BBDD')
búsqueda que queremos devolver f.close() cerrar un archivo * IMPORTANTE *
nombre_funcion(**diccionario)
with open(ubicacion_archivo) as f: from mysql.connector import errorcode importar errores Insertar datos
[] incluye todos los caracteres que queremos
codigo e.g. variable = f.read() abre el archivo solo para variable_query = "INSERT INTO nombre_tabla (columna1,
que coincidan e incluso incluye rangos como mysql.connector.Error se puede usar en un try/except
ejecutar el codigo indicado (y despues lo deja) columna2) VALUES (%s, %s)"
este: a-z y 0-9
Clases | es como el operador 'or'
cnx.close() desconectar de la base de datos
variable_valores = (valor1, valor2)
Encoding Realizar queries
Definir una clase: \ señala una secuencia especial ( escapar from locale import getpreferredencoding variable_cursor.execute(variable_query, variable_valores)
caracteres especiales) variable_cursor = cnx.cursor() crear el objeto cursor que
class NombreClase: getpreferredencoding() para saber que sistema de encoding otro método:
{} Exactamente el número especificado de nos permite comunicar con la base de datos
estamos usando
variable_query = "UPDATE nombre_tabla SET nombre_columna =
ocurrencias f = open(ubicacion_archivo, encoding="utf-8") abrir un archivo variable_cursor.close() desconectar el cursor
def __init__(self, atributo1, atributo2): "nuevo_valor" WHERE nombre_columna = "valor"
{n} Exactamente n veces y leerlo con el encoding usado; guardar con .read() variable_query = ("SQL Query") guardar un query en un
self.atributo1 = atributo1
self.atributo2 = atributo2 {n,} Al menos n veces variable Insertar múltiples filas a una tabla
{n,m} Entre n y m veces
mode: argumento opcional al abrir un archivo variable_cursor.execute(variable_query) ejecutar el query;
self.atributo_por_defecto = 'valor' variable_valores_en_tuplas = ((valor1columna1,
r – read devuelve una lista de tuplas valor1columna2), (valor2columna1, valor2columna2))
w – write - sobreescribe
def nombre_funcion1(self, parametros) import datetime sacar fechas en el formato AAAA-MM-DD variable_cursor.executemany(variable_query,
Métodos Regex x – exclusive creation, sólo crearlo si no existe todavía
self.atributo += 1 variable_valores_en_tuplas)
a – appending, añadir texto al archivo sin manipular el texto datetime.date(AAAA, M, D) devuelve el formato de fecha
re.findall("patron", string) busca en todo el que ya había
return f"el nuevo valor es {self.atributo}" variable_query = "SQL Query... %s AND %s") query dinamica
string y devuelve una lista con todas las hay que anadir otra letra:
coincidencias en nuestro string variable_conexion.commit() después de ejecutar la
t – texto – leer en texto variable_cursor.execute(query, (variable1, variable2))
Definir una clase hija: inserción, para que los cambios efectúen en la BBDD
b – bytes – leer en bytes (no se puede usar con encoding) valores que van en lugar de los %s
class NombreClaseHija(NombreClaseMadre): re.search("patron", string_original) busca en variable_conexion.rollback() se puede usar después de
todo el string y devuelve un objeto con la variable_cursor.execute("SHOW DATABASES") mostrar las BBDD
def __init__(self, atributo1, atributo2): f = open(ubicacion_archivo, mode = "rt") execute y antes de commit para deshacer los cambios
primera coincidencia en nuestro string variable_cursor.execute("SHOW TABLES") mostrar las tablas
super().__init__(atributo_heredado1, ...) print(variable_cursor.rowcount, "mensaje") imprimir el
de la BBDD indicado en la conexión
re.match("patron", "string_original) busca en Leer ficheros número de filas en las cuales se han tomado la accion
def nombre_funcion_hija (self, parametros): la primera linea del string y devuelve un variable_cursor.execute("SHOW TABLES")
f.read() leer el contenido de un archivo
objeto con la primera coincidencia en nuestro f.read(n) leer los primeros n caracteres de un archivo variable_cursor.execute("SHOW COLUMNS FROM bbdd.table") Eliminar registros
string variable = f.read() guardar el contenido del archivo (o n mostrar las columnas de la tabla especificada; hay que variable_query = "DROP TABLE nombre_tabla"
Crear un objeto de la clase:
caracteres de un archivo) en un variable conectarse a la bbdd information_schema
variable_objeto = NombreClase(valor_atributo1, resultado_match.span() devuelve la referencia
de las posiciones donde hizo el "match"
f.readline(n) por defecto devuelve la primera linea o n lineas
Argumentos cursor: Añadir errores
valor_atributo2) instanciar (crear) un objeto
f.readlines() devuelve una lista de todas las lineas del importar errorcode y usar try/except:
variable_objeto.atributo devuelve el valor del archivo (cada linea es un elemento); se usa vacio sin n y variable_cursor = cnx.cursor([arg=value[, arg=value]...])
resultado_match.group() devuelve el element
atributo guardado para ese objeto list_name[x:] para seleccionar lineas especificas try:
resultando de la coincidencia del "match" buffered=True devuelve todas las filas de la bbdd
variable_objeto.atributo = nuevo_valor para cambiar accion
el valor del atributo re.split("patron", "string_original") busca en raw=True el cursor no realizará las conversiones except mysql.connector.Error as err:
Escribir en ficheros automáticas entre tipos de datos
variable_objeto.nombre_funcion() llamar una funcion todo el string y devuelve una lista con los print(err)
with open(ubicacion_archivo, "w") as f:
elementos separados por el patron dictionary=True devuelve las filas como diccionarios print("Error Code:", err.errno)
f.write("Texto que va en el fichero.") para escribir
print(help(NombreClase) imprime informacion sobre la print("SQLSTATE", err.sqlstate)
re.sub("patron", "string_nuevo", with open(ubicacion_archivo, "a") as f: named_tuple=True devuelve las filas como named tuples
clase print("Message", err.msg)
"string_original") busca en todo el string y f.write("Texto que va en el fichero.") para anadir texto
cursor_class un argumento que se puede usar para indicar
devuelve un string con el element que coincide f.writelines('lista') para anadir lineas de texto de una lista
que subclase queremos usar para instanciar el nuevo cursor
Python: Pandas DataFrames Metodos de exploracion Tipos de datos Valores nulos
Crear DataFrames df.head(n) devuelve las primeras n lineas del dataframe Tipos de datos en Pandas: Identificar nulos
Series: estructuras en una dimension df = pd.DataFrame(data, index, columns) df.tail(n) devuelve las últimas n lineas del dataframe - object
df.isnull() o df.isna() devuelve True o False según si cada
data: NumPy Array, diccionario, lista de diccionarios - int64
df.sample(n) devuelve n filas aleatorias de nuestro - float64 valor es nulo o no
Crear series index: indice que por defecto se asigna como 0-(n-1), n
dataframe, o uno por defecto - datetime, timedelta[ns] df.isnull().sum() o df.isna().sum() devuelve una serie con el
serie = pd.Series() crear serie vacía siendo el número de filas;
index = [lista] para asignar "etiquetas" (nombres de df.shape devuelve el número de filas y columnas - category número de valores nulos por columnas
serie = pd.Series(array) crear serie a partir de un - bool
filas) df_%_nulos = ((df.isnull().sum() / df.shape[0] *
array con el indice por defecto df.dtypes devuelve el tipo de datos que hay en cada
column: nombre de las columnas; por defecto 0-(n-1); df.dtypes devuelve el tipo de datos que hay 100).reset_index()
serie = pd.Series(array, index = ['a', 'b', 'c'...]) columna
columns =[lista] para poner mas nombres en cada columna df_%_nulos.columns = ['columna', '% nulos'] crea un dataframe
crear una serie con indice definida; debe ser lista de
df.columns devuelve los nombres de las columnas df_tipo = df.select_dtypes(include = "tipo") de los porcentajes de los valores nulos
la misma longitude del array
df = pd.DataFrame(array) crear un dataframe a partir de un crea un dataframe de las columnas del tipo de
serie = pd.Series(lista) crear una seria a partir de df.describe devuelve un dataframe con un resumen de los
array con indices y columnas por defecto datos especificado Eliminar nulos
una lista principales estadísticos de las columnas numéricas
df = pd.DataFrame(diccionario) crear un dataframe a partir df['columna'] = df['columna'].astype('tipo', df.dropna(inplace = True, axis=b, subset=[lista_de_columnas],
serie = pd.Series(número, indice) crear una serie a
de un diccionario – los keys son los nombres de las df.info() devuelve un resumen sobre el no. de columnas, copy = True, errors = 'ignore') convierte una how=) quitar nulos
partir de un escalar con la longitude igual al número
columnas nombres de columnas, numero de valores no nulos y los columna en el tipo de dato especificado
de indices how = 'any' | 'all' por defecto 'any': si hay algun valor NA,
tipos de datos df["nombre_columna"].unique() o copy = True devuelve una copia
serie = pd.Series(diccionario) crear una serie a se elimina la fila o columna; all: si todos los valores son NA,
df.nombre_columna.unique() devuelve un array con los copy = False *cuidado: los cambios en los
partir de un diccionario se elimina la fila o columna
DataFrames: carga de datos valores únicos de la columna valores pueden propagarse a otros objetos
pandas* subset una columna o lista de columnas
Acceder a informacion de una serie df["nombre_columna"].value_counts() o errors = ignore omita excepciones; en caso de Tipos de nulos
serie.index devuelve los indices Carga de datos df.nombre_columna.value_counts() devuelve una serie con error devuelve el objeto original
serie.values devuelve los valores df = pd.read_csv("ruta/nombre_archivo.csv") crear un el recuento de valores únicos en orden descendente np.nan significa "not a number"; es un tipo numérico
errors = raise permite que se generen None valores nulos en columnas tipo string
serie.shape devuelve la forma (no. filas) dataframe de un archivo de Comma Separated Values excepciones
df = pd.read_csv("ruta/nombre_archivo", sep= ";") crear un df.duplicated().sum() devuelve el numero de filas NaT valores nulos tipo datetime
serie.size devuelve el tamaño
dataframe de un csv si el separador es ; duplicadas valores texto: "n/a", "NaN", "nan", "null" strings que
serie.dtypes devuelve el tipo de dato
df = pd.read_csv("ruta/nombre_archivo", index_col= 0) normalmente se convierten automaticamente a np.nan
Eliminar filas duplicadas 99999 o 00000 integers que se pueden convertir a nulos
serie[i] devuelve el valor del elemento en indice i crear un dataframe de un csv si el archivo ya tiene una pd.options.display.max_columns = None ejecutar
df.drop_duplicates(inplace = True, ignore_index=True)
serie[[i,j]] devuelve el valor de los dos elementos columna indice antes del df.head() para poder ver todas las Reemplazar nulos
serie[i:m] devuelve el valor de un rango elimina filas duplicadas; ignore_index para no tener el
columnas
df = pd.read_excel("ruta/nombre_archivo.xlsx") crear un indice en cuenta df = pd.read_csv('archivo.csv', na_values = ['n/a'])
serie["etiqueta"] devuelve el valor de los elementos dataframe de un archivo de Excel .fillna(np.nan) reemplaza los strings 'n/a' con np.nan al
pd.set_option("display.precision", 2)
en indices i y j - si sale "ImportError:... openpyxl...", en el terminal: Metodos de estadistica cargar el dataframe
pip3 install openpyxl o pip install openpyxl
Operaciones con series
Outliers df.fillna(df[value=n, axis=b, inplace=True) reemplazar todos
los NaN del dataframe con el valor que especifiquemos
df['columna'].mean() | mode() | median() | var() | std()
serie1 +-*/ serie2 suma/resta/multiplica/divide las df = pd.read_json("ruta/nombre_archivo.json") crear un
calcula la media/moda/mediana/variación/desviación Calcular tres desviaciones estandares: df['columna'].fillna(df['columna'].median, axis=b,
filas con indices comunes entre las dos series dataframe de un archivo de JavaScript Object Notation
estándar de los valores de una columna media = df.column.mean() inplace=True) reemplazar los nulos de una columna por la
serie1.add(serie2, fill_value = número) suma las filas (formato crudo)
desviacion = df.column.std() mediana de esa columna
con indices comunes, y suma el fill value a los df = df['data'].apply(pd.Series) convertir el dataframe de df['columna1'].corr(df['columna2'] calcula la
value=n por defecto NaN; es el valor por el que queremos
valores sin indice comun json en un formato legible correlacion entre dos variables
lcb = media – desviacion * 3 reemplazar los valores nulos que puede ser un escalar,
serie1.sub(serie2, fill_value = número) restan las matriz_correlacion = df.corr() crea una matriz mostrando diccionario, serie o dataframe
df = pd.read_clipboard(sep='\t') crear un dataframe de las correlaciones entre todos los variables ucb = media + desviacion * 3
filas de la seria2 de la serie1 cuando tienen indices axis por defecto 0 (filas)
comunes, y resta el fill value de las otras indices de datos en forma de dataframe en el clipboard; el separador
df_crosstab = pd.crosstab(df['columna1'], df.replace(valor_nulo, valor_nuevo, inplace=True, regex=False)
serie1 podria ser \n ; , etc.
df['columna2'], normalize = True, margins = True)
Eliminar Outliers reemplazar los nulos por el valor nuevo
serie1.mul(serie2, fill_value = número) multiplica las outlier_step = 1.5 * IQR calcular outlier step
with open('ruta/nombre_archivo.pkl', 'wb') as f: normalize muestra los valores en porcentajes (por uno)
filas con indices comunes y multiplica el fill value outliers_data = df[(df['columna'] < Q1 – Imputacion de nulos
con las otras *usar 1 para conservar el valor* pickle.dump(df,f) pone los datos de un dataframe en margins muestra los totales y subtotales outlier_step) | (df['columna'] > Q3 +
el archivo pkl from sklearn.impute import SimpleImputer
serie1.mul(serie2, fill_value = número) divida las media_ponderada = np.average(df['columna'], weights = w) outlier_step)] identificar datos fuera del
rango del maximo hasta el minimo imputer = SimpleImputer(strategy='mean', missing_values =
filas de la serie1 entre las de la serie2 cuando calcula la media ponderada según los pesos
pd.read_pickle('ruta/nombre_archivo.csv').head(n) leer n lista_outliers_index = list(outliers_data. np.nan) inicia la instancia del metodo, especificando que
tienen indices comunes, y divide las otras por el fill percentil_n = np.percentile(df['columna'], n) saca el
filas y 5 columnas del archivo pickle index) crear una lista de los indices de las queremos reemplazar los nulos por la media
value valor en el percentil n
serie1.mod(serie2, fill_value = número) devuelve el filas con outliers imputer = imputer.fit(df['columna1']) aplicamos el imputer
pd.read_parquet('ruta/nombre_archivo.parquet') leer un q3, q1 = np.percentile(df["columna"], [75, 25]) saca los
modulo (division sin resta) df['media_columna1'] = imputer.transform(df[['price']]) rellena
archivo parquet tercer y primer cuartiles if outliers_data.shape[0] > 0:
serie1.pow(serie2, fill_value = número) calcula el los valores nulos segun como hemos especificado
exponencial dicc_indices[key] =
from sklearn.experimental import enable_iterative_imputer
serie1.ge(serie2) compara si serie1 es mayor que Guardado de datos (list(outliers_data.index)) crear un
serie2 y devuelve True o False df.to_csv('ruta/nombre_archivo.csv') guardar dataframe Sidetable: frecuencias de datos diccionario de los indices de las filas con from sklearn.impute import IterativeImputer
serie1.le(serie2) compara si serie1 es menor que como archivo csv nulos; se puede hacer iterando por columnas imputer = IterativeImputer(n_nearest_features=n,
df.to_excel('ruta/nombre_archivo.xlsx') guardar dataframe df.stb.freq(['columna']) devuelve un dataframe con imputation_order='ascending') crea la instancia
serie2 y devuelve True o False
como archivo de Excel informacion sobre la frecuencia de ocurrencia de cada valores = dicc_indices.values() sacar todos n_nearest_features por defecto None; numero de columnas a
df.to_json('ruta/nombre_archivo.json') guardar dataframe categoría de un variable categorica los valores e.g. todos los indices utilizar para estimar los valores nulos
Filtrado booleanos parametros:
como archivo de JSON valores = {indice for sublista in valores for imputation_order por defecto ascendente; el orden de imputacion
serie < > >= <= == valor devuelve True o False segun thresh = n limita los valores mostrados a los más
df.to_parquet('ruta/nombre_archivo.parquet') guardar indice in sublista} set comprehension para
si cada condición cumple la condición frecuentes hasta un umbral de n% cumulative y agrupando imputer.fit(df_numericas) aplicamos el imputer
dataframe como archivo de parquet eliminar duplicados
serie1[serie1 < > >= <= == valor] devuelve solo los los restantes bajo la etiqueta "other" df_datos_trans = pd.DataFrame(imputer.transform(df_numericas),
df.to_pickle('ruta/nombre_archivo.pkl') guardar dataframe df_sin_outliers = df.drop(df.index[list
valores que cumplen la condición other_label = 'etiqueta' cambia la etiqueta 'other' columns = df_numericas.columns) crea un dataframe de los datos
como archivo de pickle (valores)]) crear nuevo dataframe sin outliers
np.nan crear valor nulo (NaN) value = 'columna' ordena los resultados por la columna transformados; metemos estas columnas en el dataframe original
serie.isnull() devuelve True o False segun si los especificada
valores existen o son nulos ("" no cuenta como nulo) ExcelWriter Reemplazar Outliers from sklearn.impute import KNNImputer
with pd.ExcelWriter("ruta/archivo.ext") as writer: df.stb.freq(['columna1', 'columna2']) combina dos
serie.notnull() devuelve True o False segun si los for k, v in dicc_indices.items(): imputerKNN = KNNImputer(n_neighbors=5) crea la instancia
df.to_Excel(writer, nombre_hoja = 'nombre') columnas y devuele las frecuencias de las subcategories
valores existen o son nulos ("" no cuenta como nulo) media = df[k].mean() imputerKNN.fit(df_numericas)
guardar un dataframe en una hoja de Excel for i in v:
df.stb.missing(['columna'] devuelve informacion sobre la df_knn_imp = pd.DataFrame(imputerKNN.transform(df_numericas),
df.loc[i,k] = media reemplazar
frequencia de datos nulos columns = numericas.columns) crea un dataframe de los datos
outliers por la media
transformados; metemos estas columnas en el dataframe original
Pandas Subsets: loc e iloc Filtrados de datos Crear columnas Cambiar valores
df.loc["etiqueta_fila", "etiqueta_columna"] Metodos de pandas de filtrar Creacion de ratios Reemplazar valores basados en indices y condiciones:
Union de datos devuelve el contenido de un campo en una columna df_filtrado = df["columna?ratio"] = df.apply(lambda df: df["columna1"] indices_filtrados = df.index[df["columna"] == "valor"]
de una fila df[df["nombre_columna"].isin(iterable)] extrae las / df["columna2"], axis = 1)
.concat()unir dataframes con columnas en comun
filas cuyas valores de la columna nombrada están en
for indice in indices_filtrados:
df_union = pd.concat([df1, df2, df3], axis=b, join = df.loc["etiqueta_fila",:] devuelve los valores el iterable (una lista, serie, dataframe o Creacion de porcentajes df["nombre_columna"].iloc[indice] = "valor_nuevo"
'inner/outer', ignore_index = True/False) de todas las columnas de una fila diccionario) def porcentaje(columna1, columna2): Reemplazar valores basados en metodos NumPy:
parametros:
df.loc[:,"etiqueta_columna"] devuelve los return (columna1 * 100) / columna2
axis = 0 une por columnas – los dataframes van uno encima del df.replace(to_replace = valor, value = valor_nuevo,
valores de todas las filas de una columna df_filtrado= df[df["nombre_columna"].str.contains
otro; las columnas tienen que ser de formatos compatible inplace = True) reemplaza cierto valor por otro que
(patron, regex = True, na = False)] extrae las filas df["columna_%"] = df.apply(lambda df:
axis = 1 une por filas – los dataframes van uno al lado del otro; especificamos
df.iloc[indice_fila, indice_columna] devuelve el cuyas valores de la columna nombrada contenienen el porcentaje(df["columna1"], datos["columna2"]), axis = 1)
los datos deben ser relacionados para que tenga sentido
contenido de un campo en una columna de una fila patron de regex df["nueva_columna"] = np.where(df["nombre_columna"] > n, df["nombre_columna"].replace(to_replace = valor,
join = 'inner' solo se quedan elementos que aparecen en todos los
dataframes "categoria_if_true", "categoria_if_false") crea una nueva value = valor_nuevo, inplace = True) reemplaza cierto
df.iloc[indice_fila, :] devuelve los valores de
join = 'outer' se queda todo los datos de todos los dataframes df_filtrado = df[df["nombre_columna"].str.contains columna basada en una condición valor en una columna por otro que especificamos
todas las columnas de una fila
ignore_index = True/False por defecto es False; si es True no usa ("substring", case = False, regex = False)] extrae
df[["columna1", "columna2"]] = df[["columna1",
las índices para la union (por ejemplo para union por el axis 0) df.iloc[:,indice_columna] devuelve el contenido las filas cuyas valores de la columna nombrada df["nueva_columna"] = np.select(lista_de_condiciones,
contienen el substring, no siendo case sensitive "columna2"]].replace(r"string", "string", regex=True)
de un campo en una columna de una fila lista_de_opciones) crea una nueva columna con los valores cambiar un patron/string por otro en multiples
.merge() unir las columnas de un dataframe a otro
basados en multiples condiciones
df_nuevo = df1.merge(df2, on = 'columna') inner merge df.loc[[lista_etiquetas_filas], columnas
df_filtrado = df[df["nombre_columna"].str.contains df["columna_nueva"] = pd.cut(x = df["nombre_columna"],
df_nuevo = pd.merge(left = df1, right = df2, how='left', left_on = [lista_etiquetas_columnas]] devuelve el ("substring", case = False, regex = False)] extrae df["nombre_columna"] = df["nombre_columna"] + x
contenido de varias filas / varias columnas bins = [n,m,l..], labels = ['a', ‘b’, ‘c’]) separa los
'columna_df1', right_on = 'columna_df2') left merge las filas cuyas valores de la columna nombrada reemplaza los valores de la columna por el valor + x
elementos de un dataframe en diferentes intervalos (n-m,
parametros: contienen el substring, no siendo case sensitive (o otro valor que indicamos)
df.loc[[lista_indices_filas], m-l, etc), creando una columna nueva que indica en cual
how = 'left' | 'right' | 'outer' | 'inner' | 'cross'
[lista_indices_columnas]] devuelve el contenido intervalo cae el valor; con labels se puede asignar un
on = columna | [columna1, columna2, etc] si las columnas se llaman
igual en los dos dataframes de varias filas / varias columnas
df[pd.notnull(df["nombre_columna"])] devuelve las string a cada intervalo datetime
filas que no tiene valores nulos en la columna
left_on = columna_df1 | right_on = columna_df2 para especificar - se puede usar los indices/rangos de las listas especificada Crear columnas import datetime
por donde hacer el merge [start:stop:step] dentro de los loc/iloc df["nueva_columna"] = (df["etiqueta_columna"] + x) crea datetime.now() o datetime.today() devuelve la fecha
suffixes = ['left', 'right'] por defecto nada, el sufijo que una nueva columna basada en otra actual
aparecera en columnas duplicadas df.loc[df.etiqueta > x] seleccionar datos basado Cambiar columnas df = df.assign(nueva_columna= df["etiqueta_columna] + x) timedelta(n) representa una duración la diferencia
en una condición usando operadores comparativos crea una nueva basada en otra
.join()unir dataframes por los indices entre dos instancias; n es un numero de días pero se
lista_columnas = df.columns.to_list() crea una lista df = df.assign(nueva_columna= [lista_valores]) crea una puede especificar days, seconds o microseconds
df_nuevo = df1.join(df2, on = 'columna', how = 'left') inner merge df.loc[(df.etiqueta > x) & (df.etiqueta == y)] de los nombres de las columnas del dataframe nueva columna de una lista de valores *tiene que ser de
parametros: seleccionar datos que tienen que cumplir las dos ayer = datetime.now() - timedelta(1)
la misma longitud como el número de filas del dataframe*
how = 'left' | 'right' | 'outer' | 'inner' por defecto left condiciónes (and) df.insert(indice_nueva_columna, "nombre_columna", ayer = datetime.strftime(ayer, '%Y-%m-%d')
on = columna la columna o indice por el que queremos hacer el df.set_index(["nombre_columna"], inplace = True)
df.loc[(df.etiqueta > x) | (df.etiqueta == y)] valores) crea una nueva columna en la indice indicada df["fecha"] = ayer crea una columna con la fecha de
union; tienen que tener el mismo nombre en los dos dataframes establece el índice utilizando uno o mas columnas;
seleccionar datos que tienen que deben cumplir allow_duplicates = True parametro cuando queremos ayer
lsuffix = 'string' | rsuffix = 'string' por defecto nada, el puede sustituir o ampliar un índice existente
una de las dos condiciones (or) permitir columnas duplicadas (por defecto es False)
sufijo que aparecera en columnas duplicadas inplace = True los cambios sobreescriben sobre el df
strftime() nos permite crear formatos mas legibles de
df.iloc[list(df.etiqueta > x), :] iloc no acepta * cuando una columna se cambia a índice ya no es Apply datos de tipo datetime
Group By una Serie booleana; hay que convertirla en lista columna *
datetime.strftime(variable_fecha, '%Y-%m-%d') formatea
variable_df.head(n) devuelve las n primeras df.reset_index(inplace = True) quitar una columna apply() toma una función como argumento y la aplica a lo
la fecha al formato indicado
df_groupby = df.groupby("columna_categoría") crea un objeto largo de un eje del DataFrame
filas del df, o 5 por defecto como indice para que vuelva a ser columna; crea un
DataFrameGroupBy; agrupa los valores segun las categorías de los
dataframe de una serie df['columna_nueva'] = df['col_1'].apply(función) Sintaxis de strftime()
valores de la columna indicada (o múltiples columnas en una lista) %a día de la semana abreviada (Sun)
crea una columna nueva con los valores de otra columna
df_groupby.ngroups devuelve el numero de grupos Renombrar columnas %A día de la semana (Sunday)
transformados según la función indicada
df_groupby.groups devuelve un diccionario donde los keys son las Filtrados de datos df.rename(columns = {"nombre_columna": df['columna_nueva'] = df['col_1'].apply(lambda x: %w día de la semana de 0 (domingo) a 6 (sábado)
categorías y los valores son listas de los índices de cada "nombre_nueva"}, inplace = True) cambia los nombres x.método() if x > 1) %b mes abreviada (Sep)
elemento en la categoría Filtrado por una columna con operadores de de una o mas columnas
crea una columna nueva con los valores de otra columna %B mes (September)
df_grupo1 = df_groupby.get_group("grupo1") devuelve un dataframe comparación ejemplo de dict comprehension para crear diccionario transformados según la lambda indicada %m mes con un zero (09)
con los resultados de un grupo (la categoria indicada como grupo1) sobre las columnas existentes de un dataframe:
df_filtrado = df[df["nombre_columna"] == valor] df['columna_nueva'] = df.apply(lambda nombre: %-m mes como float
Cálculos con groupby: extrae las filas donde el valor de la columna diccionario = {col : col.upper() for col in función(nombre['columna1'], nombre['columna2']), axis =
%d día del mes con un zero (08)
df_nuevo = df.groupby("columna_categoría").mean() devuelve un igual al valor dado df.columns} b) crea una columna nueva usando una función que coge dos
dataframe con la media de todas las columnas de valores numéricos, parámetros (columna 1 y columna2) %-d día del mes como float (8)
por categoría df.rename(columns = diccionario, inplace = True)
Filtrado por multiples columnas con operadores df.applymap(funcion, na_action=None, **kwargs) acepta y %y año sin siglo (99)
cambia los nombres de las columnas según el
df_nuevo = df.groupby("columna_categoría")["columna1"].mean() logicos diccionario devuelve un escalar a cada elemento de un dataframe; se %Y año con siglo (1999)
devuelve un dataframe con la media de la columna especificada tiene que aplicar a todo el DataFrame %Z zona horaria (UTC)
df_filtrado = df[(df["columna1"] == valor) & Eliminar columnas
count() número de observaciones (df["columna2"] == valor) & (df["columna3"] > n df['columna'] = df['columna'].map(mapa, na_action = %p AM o PM
no nulas valor)] extrae las filas donde los valores de df.drop(columns = ["columna1", "columna2"], axis = 'ignore) reemplaza valores de la columna según el mapa, %c fecha y hora
las columnas cumplan las condiciónes en b, inplace=True) eliminar una o mas columnas o filas que puede ser un diccionario o una serie; solo se puede
describe() resumen de los %x fecha
parentesis segun lo que especificamos aplicar a una columa en particular.
principales estadísticos
%X hora (07:06:05)
sum() suma de todos los valores Reordenar columnas apply() con datetime
df_filtrado = df[(df["columna1"] == valor) | %H hora con zero (07)
mean() media de los valores df['columna_fecha'] = df['columna_fecha']
(df["columna1"] == valor) extrae las filas donde df = df.reindex(columns = lista_reordenada) cambia el %-H hora como float (7)
.apply(pd.to_datetime) cambia una columna de datos tipo
df_nuevo = df.groupby("columna_categoría", dropna = False) los valores de las columnas cumplan con una orden de las columnas del dataframe segun el orden de
fecha en el formato datetime %M minuto con zero (06)
["columna_valores"].agg([nombre_columna = ‘estadistico1’, condición u otra la lista reordenada
def sacar_año(x): %-M minuto como float (6)
nombre_columna2 = ‘estadistico2’]) añade columnas con los cálculos
de los estadísticos especificados df_filtrado = ~(df[df["columna1"] == valor]) return x.strftime("%Y") %S segundos con zero (05)
dropna = False para tener en cuenta los Nan en los cálculos (por extrae las filas donde los valores de las df['columna_año'] = (df['columna_fecha'] .apply %-S segundos como float (5)
defecto es True) columnas NO cumplan con la condición (sacar_año) crea una columna nueva del año solo usando un
método de la librería datetime; ("%B") para meses
Matplotlib y Seaborn Seaborn gráficas Multigráficas Personalización Personalización
Line plot fig, ax = plt.subplots(numero_filas, numero_columnas) Titulos Colores
Matplotlib fig = sns.lineplot(x = 'columna1', y = 'columna2', data = crear una figura con multiples graficas; fig es la
df, ci = None) crea una gráfica lineal donde los ejes son: figura y ax es un array con subplots como elementos plt.title(label = "titulo") asignar un titulo a color = "color" establece el color de la grafica
columna1 – x, columna2 – y la gráfica facecolor = "color" establece el color del relleno
Gráficas ci = None para que no muestra el intervalo de confianza de
se establece como es cada grafica con los indices:
edgecolor = "color" establece el color de los bordes
ax[indice].tipo_grafica(detalles de la grafica)
los datos Colores en Scatter Plots:
import matplotlib.pyplot as plt hue = columna opcional; muestra lineas en diferentes
ax[indice].set_title('titulo') Ejes
ax[indice].set_xlabel('xlabel') c= df['columna'].map(diccionario)
colores por categorias segun una variable plt.xlabel("etiqueta_eje_x") asignar nombre al eje x
plt.rcParams["figure.figsize"] = (10,8) ax[indice].set_ylabel('ylabel') diccionario = {"valor1": "color1", "valor1": "color1"}
Scatter plot plt.ylabel("etiqueta_eje_y") asignar nombre al eje y
plt.figure(figsize = (n,m)) inicia una grafica lista de colores
fig = sns.scatterplot(x = 'columna1', y = 'columna2', data ax[indice].set_xlim(min, max plt.xlim([n,m] establece el rango del eje x; donde n es
dibujando el marco de la figura; n es la anchura y
m es la altura, en pulgadas = df, hue = 'columna') crea una gráfica de dispersión ax[indice].set_ylim(min, max) el mínimo y m es el máximo Paletas Seaborn:
plt.show() muestra la figura Swarm plot ax[indice].set_xticklabels(labels = df['column'], plt.ylim([n,m]) establece el rango del eje y; donde n Accent', 'Accent_r', 'Blues', 'Blues_r', 'BrBG', 'BrBG_r',
fig = sns.swarmplot(x = 'columna1', y = 'columna2', data = rotation = n) para cambiar los nombres y/o la rotacion es el mínimo y m es el máximo 'BuGn', 'BuGn_r', 'BuPu', 'BuPu_r', 'CMRmap', 'CMRmap_r',
df, hue = 'columna') crea una gráfica de dispersión donde de las etiquetas de los valores en los ejes 'Dark2', 'Dark2_r', 'GnBu', 'GnBu_r', 'Greens',
Gráficas básicas los marcadores no se solapan 'Greens_r', 'Greys', 'Greys_r', 'OrRd', 'OrRd_r',
Crear subplots en un for loop fig.set(xlabel = 'etiqueta_eje_x', ylabel =
Bar plot Count plot 'Oranges', 'Oranges_r', 'PRGn', 'PRGn_r', 'Paired',
fig, axes = plt.subplots(numero_filas, numero_columnas, 'etiqueta_eje_y') asignar nombre a los ejes
plt.bar(df["columna1"], df["columna2"]) crea un 'Paired_r', 'Pastel1', 'Pastel1_r', 'Pastel2',
fig = sns.countplot(x = 'columna1', data = df, hue = figsize = (n, m)) fig.set_title('titulo') asignar un titulo a la gráfica
diagrama de barras donde los ejes son: columna1 – 'Pastel2_r', 'PiYG', 'PiYG_r', 'PuBu', 'PuBuGn',
'columna') crea una gráfica de barras con la cuenta de una axes = axes.flatten()
x, columna2 – y 'PuBuGn_r', 'PuBu_r', 'PuOr', 'PuOr_r', 'PuRd', 'PuRd_r',
variable categórica; se puede especificar solo una
Horizontal bar plot for col in df.columns: fig.set_xlabel(xlabel = "etiqueta_eje_x", fontsize = n) 'Purples', 'Purples_r', 'RdBu', 'RdBu_r', 'RdGy',
variable en la eje x o y, mas una variable opcional con
plt.barh(df["columna1"], df["columna2"]) crea una fig = sns.plot(x=col, data=df, ax=axes[i] 'RdGy_r', 'RdPu', 'RdPu_r', 'RdYlBu', 'RdYlBu_r',
hue fig.set_ylabel(ylabel = "etiqueta_eje_y", fontsize = n)
diagramma de barras horizontales donde los ejes 'RdYlGn', 'RdYlGn_r', 'Reds', 'Reds_r', 'Set1', 'Set1_r',
Histogram Crear subplots en un for loop
son: columna1 – x, columna2 – y 'Set2', 'Set2_r', 'Set3', 'Set3_r', 'Spectral',
fig = sns.histplot(x = 'columna1', data = df, hue = fig, axes = plt.subplots(numero_filas, numero_columnas, fig.set(xticks = [1, 2, 3]) 'Spectral_r', 'Wistia', 'Wistia_r', 'YlGn', 'YlGnBu',
Stacked bar plot 'columna3', kde = True, bins = n) crea una histograma que figsize = (n, m))
fig.set(yticks = [1, 2, 3, 4, 5]) 'YlGnBu_r', 'YlGn_r', 'YlOrBr', 'YlOrBr_r', 'YlOrRd',
plt.bar(x, y, label = 'etiqueta') muestra la frecuencias de una distribución de datos; donde 'YlOrRd_r', 'afmhot', 'afmhot_r', 'autumn', 'autumn_r',
plt.bar(x2, y2, bottom = y, label = 'etiqueta2') fig.set(xticklabels = ['0%','20%', '40%', '60%', '80%',
x es la variable de interés y n es el número de barras 'binary', 'binary_r', 'bone', 'bone_r', 'brg', 'brg_r',
'100%'])
crea una diagrama de barras apiladas para kde = True muestra una curva de la distribucion Usos de los tipos de gráficas fig.set(yticklabels = ['cat1', 'cat2', 'cat3'])
'bwr', 'bwr_r', 'cividis', 'cividis_r', 'cool', 'cool_r',
visualizar dos variables juntas; y indica la barra 'coolwarm', 'coolwarm_r', 'copper', 'copper_r', 'crest',
Box Plot
de referencia Datos categóricos 'crest_r', 'cubehelix', 'cubehelix_r', 'flag', 'flag_r',
fig = sns.boxplot(x = 'columna1', data = df, hue =
Scatter plot 'columna') crea un diagrama de cajas; x es la variable de fig.set_xticklabels(labels = [0, 500, 1000, 1500], 'flare', 'flare_r', 'gist_earth', 'gist_earth_r',
Barras 'gist_gray', 'gist_gray_r', 'gist_heat', 'gist_heat_r',
plt.scatter(df["columna1"], df["columna2"]) crea interés; por defecto se muestra con orientación horizontal size=n)
una gráfica de dispersión donde los ejes son: – usar eje y para orientación vertical - muestra la relación entre una variable numérica y 'gist_ncar', 'gist_ncar_r', 'gist_rainbow',
fig.set_yticklabels(labels = fig.get_yticklabels(),
columna1 – x, columna2 – y categórica 'gist_rainbow_r', 'gist_stern', 'gist_stern_r',
Catplot size=n)
- barplot si tienes una variable numérica 'gist_yarg', 'gist_yarg_r', 'gnuplot', 'gnuplot2',
fig = sns.catplot(x = 'columna1', y = 'columna2', data = 'gnuplot2_r', 'gnuplot_r', 'gray', 'gray_r', 'hot',
Gráficas estadísticas df, hue = 'columna', kind = 'tipo') crea una gráfica que - countplot para contar registros/filas por categoría
Para poner etiquetas encima de las barras 'hot_r', 'hsv', 'hsv_r', 'icefire', 'icefire_r',
Histogram muestra la relacion entre una variable categorica y una Pie chart/quesitos 'inferno', 'inferno_r', 'jet', 'jet_r', 'magma',
for indice, valor in enumerate(df ["col"]):
plt.hist(x = df['columna1'], bins = n) crea una variable numerica 'magma_r', 'mako', 'mako_r', 'nipy_spectral',
- determinación de frecuencias plt.text(valor+1, indice, valor,
histograma que muestra la frecuencias de una kind = 'box' | 'bar' | 'violín' | 'boxen' | 'point' por 'nipy_spectral_r', 'ocean', 'ocean_r', 'pink', 'pink_r',
distribución de datos; donde x es la variable de defecto es strip plot Datos numéricos horizontalalignment='left', fontsize= 16)
'plasma', 'plasma_r', 'prism', 'prism_r', 'rainbow',
interés y n es el número de barras Pairplot Líneas 'rainbow_r', 'rocket', 'rocket_r', 'seismic', 'seismic_r',
Box Plot fig = sns.pairplot(data = df, hue = 'columna', kind = - tendencias/evolución de una o más variables numéricas order = df.sort_values('columnay', ascending=False) 'spring', 'spring_r', 'summer', 'summer_r', 'tab10',
plt.boxplot(x = df['columna1']) crea un diagrama de 'tipo') crea los histogramas y diagramas de dispersión de (normalmente sobre un periódo de tiempo) ['columnax'] 'tab10_r', 'tab20', 'tab20_r', 'tab20b', 'tab20b_r',
cajas para estudiar las caracteristicas de una todas las variables numéricas de las que disponga el sns.set(font_scale=2) 'tab20c', 'tab20c_r', 'terrain', 'terrain_r', 'turbo',
variable numerica; x es la variable de interés dataset con el que estemos trabajando; hue es opcional Histograma 'turbo_r', 'twilight', 'twilight_r', 'twilight_shifted',
plt.rcParams.update({'font.size': 22}) font size
- el mínimo es lo mismo que Q1 - 1.5 * IQR kind = 'scatter' | 'kde' | 'hist' | 'reg' | 'point' por - distribución de una variable numérica 'twilight_shifted_r', 'viridis', 'viridis_r', 'vlag',
general
- el máximo es lo mismo que Q3 + 1.5 * IQR defecto es scatter 'vlag_r', 'winter', 'winter_r
Boxplot
Heatmap -representación de las medidas de posición más usadas:
palette='light:nombre_paleta'|'dark:nombre_paleta'
sns.heatmap(df.corr(), cmap = 'color_palette', annot = Leyendas
mediana, IQR, outliers
True, vmin = -1, vmax = 1) crea un heatmap con una escala plt.legend(labels = ['label1', 'label2', etc) muestra Marcadores
de colores que refleja los valores de correlacion Scatterplot la leyenda cuando mostramos la figura marker = 'tipo' establece el tipo de marcador; se usa con
annot = True para que aparezcan los valores - muestra la relación entre dos variables numéricas plt.legend(bbox_to_anchor = (1, 1) coloca la leyenda en plt.scatter y plt.plot
vmin/vmax establecen la escala de color Regplot relación con los ejes
- scatterplot con una línea de regresión "." Punto "P" Más (relleno)
Regplot "," Pixel "*" Estrella
fig = sns.regplot(x = 'columna1', y = 'columna2', data = Swarmplot Quitar bordes "o" Circulo "h" Hexágono 1
df, scatter_kws = {'color':'blue'}, line_kws = {'color'; - tipo de gráfica de dispersión para representar fig.spines[["top", "right"]].set_visible(False) "v" Triángulo abajo "H" Hexágono 2
'blue'})crea un scatterplot mas la línea de regresión; nos variables categóricas; evita que se solapan los "^" Triángulo arriba "+" Más
permite encontrar la mejor función de la recta que permite marcadores "<" Triángulo izquierda "x" x
predecir el valor de una variable sabiendo los valores de Linea de tres desviaciones estandares: ">" Triángulo derecha "X" x (relleno)
Pie Chart otra variable Violinplot fig.axvline(x=valor, c='color', label='valor') "8" Octágono "D" Diamante
plt.pie(x, labels = categorias, radius = n) crea un - para visualizar la distribución de los datos y su fig.axvline(x=valor, c='color', label='valor')
Jointplot "s" Cuadrado "d" Diamante fino
gráfico de sectores donde x es la variable de densidad de probabilidad
sns.jointplot(x = 'columna1', y = 'columna2', data = df, "p" Pentágono
interés (debe esta agrupado por categorias); n es Cuadricula
el tamaño color = 'blue', kind = 'tipo') crea un scatterplot o Pairplot
regplot con histogramas pegados en los lados para cada - para representar múltiples relaciones entre dos plt.grid() crea una cuadrícula al fondo de la figura;
variable variables coge los parámetros:
Violin Plot
plt.violinplot(x, showmedians = True, showmeans = color = "color"
Heatmap
True) crea un diagrama de violin donde x es la Exportar figuras linestyle = "solid" | "dashed" | "dashdot" | "dotted"
plt.savefig('nombre_de_la_figura.extension') - evaluar la correlación entre las variables en una
variable de interés y muestra la mediana y la media linewidth = n establece la anchura de la linea
matriz de correlación
NumPy (Numerical Python) Indices, Subsets, Metodos de Arrays Operaciones estadísticas y matemáticas Funciones de conjuntos Estadística
Indices de arrays Operaciones estadísticas y matemáticas np.unique(array) devuelve un array con los valores únicos Tablas de frecuencias
Crear arrays del array ordenados
array[i] devuelve la indice i; las indices de los El parametro axis en arrays bidimensionales: np.unique(array, return_index=True) devuelve un array con Frecuencias absolutas
Crear arrays de listas arrays unidimensionales funcionan igual que las listas axis = 0 columnas los valores únicos del array ordenados y un array con la el número de veces que se repite un número en un
array = np.array(lista, dtype= tipo) crea un array array[i, j] o array[i][j] devuelve el elemento de la axis = 1 filas posición de la primera instancia de cada valor conjunto de datos
unidimensional de una lista columna j de la fila i - si especificamos el axis, la operación devuelve el np.unique(array, return_inverse=True) devuelve un array con df = df.groupby('columna').count().reset_index()
array = np.array([lista1, lista2]) crea un array array[:,:n] seleccionar todas las filas y las columnas resultado por cada fila o columna. los valores únicos del array ordenados y un array con las
Frecuencias relativas
bidimensional de dos listas hasta n-1 Por ejemplo: posiciones de cada elemento de cada valor
las veces que se repite un número o categoría en un
array = np.array([listadelistas1, listadelistas2]) crea array[h, i, j] o array[h][i][j] devuelve el elemento de np.sum(array, axis = 0) devuelve un array con la np.unique(array, return_counts=True) devuelve un array con
conjunto de datos respecto al total, en porcentajes
un array bidimensional de dos listas la columna j de la fila i del array h suma de cada fila los valores únicos del array ordenados y un array con el
número de veces que aparece cada valor df_group_sin_str = df_group.drop('columna_str',
array[h][i][j] = n cambiar el valor del elemento en np.unique(array, axis = b) devuelve un array con los axis=1)
Crear otros tipos de arrays esta posicion al valor n
El parametro axis en arrays multidimensionales:
axis = 0 dimensión valores únicos ordenados de las filas o columnas frecuencia_relativa = df_group_sin_str / df.shape[0] *
array = np.arange(valor_inicio, valor_final, saltos) crea
axis = 1 columnas 100
un array usando el formato [start:stop:step]
array = np.ones(z,y,x) crea un array de todo unos de la Subsets axis = 2 filas Funciones para arrays unidimensionales columnas = df_group_sin_strings.columns
forma especificada - si especificamos el axis, la operación devuelve el df_group[columnas] = frecuencia_relativa
array > n devuelve la forma del array con True o False np.intersect1d(array1, array2) devuelve un array con los
array2 = np.ones_like(array1) crea un array de todo unos resultado por cada dimensión, fila o columna.
según si el elemento cumple con la condición o no valores únicos de los elementos en común de dos arrays
de la forma basada en otra array
array[array > n] devuelve un subset: todos los valores
Por ejemplo:
np.intersect1d(array1, array2, return_indices=True) Tablas de contingencia
array = np.zeros(z,y,x) crea un array de todo zeros de la np.sum(array_3D, axis = 0) devuelve un array de una tabla de frecuencias que cuenta todas las
que cumplen la condición en una lista dentro de un devuelve un array con los valores únicos de los elementos
forma especificada matriz con la suma de todas las matrices combinaciones posibles de cada pareja de valores de
array en común de dos arrays y arrays con los índices de cada
array2 = np.zeros_like(array1) crea un array de todo np.sum(array_3D, axis = 1) devuelve un array donde las columnas que estamos intentando comparar
array[(array > n) & (array < m)] devuelve un subset: valor, por array
zeros de la forma basada en otra array las filas contienen las sumas de las columnas de
np.union1d(array1, array2) devuelve un array ordenado con df_crosstab = pd.crosstab(df['columna1'],
array = np.empty((z,y,x), tipo) crea un array vacio con todos los valores que cumplen las condiciones en una cada matriz
los elementos resultantes de unir dos arrays (valores df['columna2'], normalize = True, margins = True)
datos por defecto tipo float lista dentro de un array; se puede usar | para "or"
únicos) normalize muestra los valores en porcentajes (por uno)
array2 = np.empty_like(array1) crea un array vacia con la Operaciones con parámetro del axis: np.in1d(array1, array2) devuelve un array con True o False
forma basada en otra array np.sum(array_3D) devuelve la suma de todos los margins muestra los totales y subtotales
Metodos de arrays por cada elemento de array1 según si aparece el mismo valor
array = np.eye(z,y,x, k = n) crea un array con unos en elementos de los matrices
nuevo_array = array.copy() crea un a copia del array en array2 Coeficiente de correlación de Pearson
diagonal empezando en la posicion k np.mean(array) devuelve la media de todo el array
np.setdiff1d(array1, array2) devuelve un array ordenado con - nos permite conocer la intensidad y dirección de la
array = np.identity(x) crea una matriz de identidad con np.transpose(array_bidimensional) cambia los filas del np.std(array) devuelve la desviación estándar de
los valores únicos que están en array1 pero no en array2 relación entre las dos variables
ceros en filas y unos en la diagonal, de forma cuadrada array a columnas y las columnas a filas todo
np.setxor1d(array1, array2) devuelve un array ordenado con
np.transpose(array_multidimensional) cambia el número np.var(array) devuelve la varianza de valores de - coeficiente > 0: correlación positiva
los valores únicos que NO están en común de los dos arrays
de columnas al número de arrays y viceversa; el número todo - coeficiente < 0: correlación negativa
de filas no cambia np.min(array) devuelve el valor mínimo del array
- coeficiente = 1 o -1: correlación total
NumPy Random np.transpose(array_multidimensional, (z,y,x)) hace la
np.max(array) devuelve el valor máximo del array Estadística - coeficiente = 0: no existe relación lineal
np.sum(array) devuelve la suma de los elementos del
transposicion segun lo que especificemos usando las df['columna1'].corr(df['columna2'] calcula la
np.random.seed(x) establece la semilla aleatoria del array Medidas de dispersión
posiciones de la tupla (0,1,2) de la forma original correlacion entre dos variables
generador de números aleatorios, para que las funciones np.cumsum(array) devuelve un array con la suma
array = np.arange(n).reshape((y,x)) crea un array acumulada de los elementos a lo largo del array
Desviación respecto a la media
random que van después siempre cogerán los mismos valores matriz_correlacion = df.corr() crea una matriz
usando reshape para definir la forma la diferencia en valor absoluto entre cada valor de los
"aleatorios" np.cumprod(array) devuelve un array con la mostrando las correlaciones entre todos los variables
array = np.reshape(array, (z,y,x)) crea un array con datos y su media aritmética
multiplicación acumulada de los elementos a lo largo sns.heatmap(df.corr()[['column1', 'column2']], cmap =
los valores de otro array usando reshape para definir del array diferencias = df['columna'] - df['columna'].mean()
Crear arrays con valores aleatorios 'color_palette', annot = True, vmin = -1, vmax = 1)
la forma desviación_media = np.abs(diferencias)
array = np.random.randint(inicio, final, forma_matriz) crea una grafica heatmap de la matriz de correlaciones
crea un array de números aleatorios entre dos valores; array = np.swapaxes(array, posicion, posicion) Operaciones sin parámetro del axis: Varianza
forma_matriz: (z,y,x) intercambia dos ejes de una matriz usando las np.sqrt(array) devuelve un array con la raíz medida de dispersión; la variabilidad respecto a la media Sesgos (skewness)
z: número de arrays posiciones (z=0,y=1,x=2) de la forma original cuadrada no negativa de cada elemento del array medida de la asimetría de la distribución de los
np.exp(array) devuelve un array con el exponencial df['columna'].var()
y: número de filas valores de una variable alrededor de su valor medio
x: número de columnas de cada elemento del array Desviación estándar o desviación típica - valor de sesgo positivo: sesgado a la derecha
Otras operaciones np.mod(array1, array2) devuelve un array con el la raíz cuadrada de la varianza; cuanto mayor sea, mayor
array = np.random.randint(inicio, final) devuelve un - valor de sesgo negativo: sesgado a la izquierda
número aleatorio en el rango np.sort(array) devuelve un array con los valores de resto de la división entre dos arrays será la dispersión o variabilidad en nuestros datos - valor de sesgo igual a 0: valores simetricos
array = np.random.rand(z,y,x) crea un array de floats cada fila ordenados en orden ascendente por defecto np.mod(array1, n) devuelve un array con el resto de df['columna'].std() sns.displot(df['columna'], kde = True) crea un
aleatorias con la forma que le especificemos; por defecto np.sort(array, axis = 0) devuelve un array con los la división entre el array y el valor de n histograma que muestra la distribution de los valores
valores de cada columna ordenados en orden ascendente np.cos(array) devuelve un array con el coseno de Robustez
genera números aleatorios entre 0-1 import scipy.stats import skew
cada elemento del array - cuanto más cantidad de datos, más robustos
array = np.random.random_sample((z,y,x)) crea un array de np.sort(-array) devuelve un array con los valores de skew(df['columna'] muestra el valor del sesgo de una
floats aleatorias con la forma que le especificemos; por np.sin(array) devuelve un array con el seno de cada 1/n donde n es el numero de registros variable
cada fila ordenados en orden descendente
elemento del array
defecto genera números aleatorios entre 0-0.9999999... np.round(array, decimals = x) devuelve un array con los Coeficiente de variación
array = np.random.z,y,x=None) devuelve un número np.sin(array) devuelve un array con la tangente de
el cociente entre la desviación típica y la media; cuanto
Intervalos de confianza
valores del array redondeados a x decimales cada elemento del array describe la variabilidad entre la medida obtenida en
aleatorio en 0 y 0.999999999999... mayor sea, mayor será la dispersión en nuestros datos
np.round(np.random.rand(z,y,x), n) crear array con floats np.round(array, decimals = x) devuelve un array con los un estudio y la medida real de la población (el valor
valores del array redondeados a x decimales Operaciones de comparación en arrays df['columna'].std() / df['columna'].mean() real)
de n decimales
np.random.uniform(n,m, size = (z,y,x)) genera muestras np.where(array > x) devuelve los indices de los valores bidimensionales Percentiles import scipy.stats as st
aleatorias de una distribución uniforme en el intervalo que cumplan la condición, por fila y columna np.any(array > n) devuelve True o False segun si st.t.interval(alpha = n, df = len(df['columna']-1, loc
divide datos ordenados de menor a mayor en cien partes;
entre n y m cualquier valor del array cumpla con la condicion = np.mean(df['columna']), scale =
muestra la proporción de datos por debajo de su valor
np.random.binomial(n,m, size = (z,y,x)) genera muestras np.any(array > n, axis = b) devuelve un array con st.sem(df['columna']))
con una distribución binomial; n es el numero total de
Operaciones con arrays True o False por cada columna o fila según si algún percentil_n = np.percentile(df['columna'], n) saca el valor
en el percentil n devuelve el rango de valores para lo cual hay un n% de
pruebas; m es la probabilidad de éxito np.add(array1, array2) suma dos arrays valor de la fila o columna cumpla con la condición probabilidad que un valor real cae en ese rango
np.random.normal(loc = n, scale = m, size = (z,y,x)) np.subtract(array1, array2) resta el array2 del array1 np.all(array > n) devuelve True o False segun si
genera números aleatorios de una distribución normal todos los valores del array cumpla con la condicion Rangos intercuartílicos alpha: porcentaje de confianza (p.ej. 90%, 95%, o 99%)
np.multiply(array1, array2) multiplica dos arrays medida de dispersión: diferencia entre cuartiles 75 y 25 df: los datos
(curva de campana); loc es la media; scale es la np.all(array > n, axis = b) devuelve un array con
np.divide(array1, array2) divide el array1 por el True o False por cada columna o fila según si todos q3, q1 = np.percentile(df["columna"], [75, 25]) saca los loc: la media
desviación estándar
array2 los valores de la fila o columna cumplan con la tercer y primer cuartiles
np.random.permutation(array) devuelve un array con los scale: la desviación estándar
mismos valores mezclados aleatoriamente array + n, n * array, etc. - operadores algebraicos condición rango_intercuartílico = q3 - q1
EDA y ETL ETL: Extract, Transform, Load Machine Learning: Preparación Tests estadísticos Normalización
Extraccion Independencia entre variables predictoras Método manual
EDA: Análisis exploratorio de datos - obtener datos crudos y almacenarlos
Hipotesis Nula y Errores Tipo I y II
- las variables predictoras tienen que ser independientes para - cogemos el valor que queremos normalizar y
- Tablas de bases de datos SQL o NoSQL restamos la media de la columna, y dividimos el
El Análisis Exploratorio de Datos se refiere al
- Ficheros de texto plano
Hipótesis nula (H0) poder crear un modelo de regresión lineal
proceso de realizar una serie de investigaciones - en general es la afirmación contraria a la que queremos probar resultado por el maximo restado por el minimo de la
inciales sobre los datos que tenemos para poder - Emails Variables numéricas: Correlaciones columna
descubrir patrones, detectar anomalías, probar - Información de páginas web Hipótesis alternativa (H1) - pairplot
- Hojas de cálculo df["col_norm"] = (df["col_VR"] -
hipótesis y comprobar suposiciones con la ayuda de - en general la afirmación que queremos comprobar sns.pairplot(df)
- Ficheros obtenidos de API's df["col_VR"].media()) / (df["col_VR"].max() -
estadísticas y representaciones gráficas. df["col_VR"].min())
p-valor - covarianza
Transformación - medida de la probabilidad de que una hipótesis nula sea cierta df_numéricas.cov() Método logarítmica
1. Entender las variables - procesar los datos, unificarlos, limpiarlos, - valor entre 0 y 1 - correlación de Pearson (relación lineal) *no se puede hacer si algún valor sea 0*
validarlos, filtrarlos, etc. - si *p-valor* < 0.05 ❌ Rechazamos la hipótesis nula. df_numéricas.corr()
- que variables temenos - Formetear fechas df["col_norm"] = df["col_VR"].apply(lambda x:
- si *p-valor* > 0.05 ✔️ Aceptamos la hipótesis nula. - correlación de Spearman (relación no lineal) np.log(x) if x > 0 else 0)
.head(), .tail(), .describe(), .info(), .shape - Reordenar filas o columnas
- Unir o separar datos df_numéricas.corr(method = 'spearman')
- que tipos de datos Error Tipo I: Método raiz cuadrada
.dtypes(), .info() - Combinar las fuentes de datos - rechazar la hipótesis nula cuando es verdadera - correlación de Kendall (datos numéricos pero
- si temenos nulos o duplicados - Limpiar y estandarizar los datos categóricos y ordinales) import math
.isnull().sum() - Verificar y validar los datos Error Tipo II: df_numéricas.corr(method = 'kendall') df["col_norm"] = df["col_VR"].apply(lambda x:
.duplicated().sum() - Eliminar duplicados o datos erroneos - aceptar la hipótesis nula cuando es falsa math.sqrt(x))
- que valores unicos temenos - Filtrado, realización de calculos o agrupaciones
.unique(), .value_counts() Variables categóricas: Chi-cuadrado Método stats.boxcox()
Carga
Tests estadísticos - V-Cramer: varía entre 0 y 1
aplica una transformación logarítmica para los
librería sidetable: - más cerca a 1 más dependientes
- cargar los datos en su formato de destino, el tipo valores positivos y exponencial para valores
stb.freq() devuelve el value_counts de variables
de lo cual dependerá de la naturaleza, el tamaño y la Normalidad - resultado < 0,7 para hacer ML ✔️ negativos de nuestra columna
categóricas, mas el porcentaje, cuenta cumulativa y
porcentaje cumulativa
complejidad de los datos. Los sistemas más comunes - la variable respuesta tiene que tener una distribución normal para poder import researchpy as rp from scipy import stats
suelen ser: crear un modelo de regresión lineal crosstab, test_results, expected = rp.crosstab df["col_norm"], lambda ajustada =
stb.missing() tabla de cuenta de nulos y el
- Ficheros csv stats.boxcox(df["col_VR"])
porcentaje del total Visualmente: (df["col1"], df["col2"], test= "chi-square",
- Ficheros json
expected_freqs= True, prop= "cell")
- Bases de datos - histograma o distribución Método MinMaxScaler
2. Limpiar el dataset - Almacenes de datos (Data Warehouse) - grafico de cuantiles teóricos (Q-Q) test_results devuelve los resultados del test en un
from sklearn.preprocessing import MinMaxScaler
- Lagos de datos (Data Lakes) más alineados están los puntos entorno a la recta, más normales dataframe
modelo = MinMaxScaler(feature_range=(0,1),
serán nuestros datos
- quitar duplicados (filas o columnas) Homocedasticidad (homogeneidad de varianzas) copy=True)
- cambiar nombres de columnas import statsmodels.api as sm modelo.fit(df["col_VR"])
- cambiar tipo de datos de columnas - las variables predictoras tienen que tener homogeneidad de
sm.qqplot(datos, line ='45') datos_normalizados = modelo.transform(df["col_VR"])
- ordenar columnas varianzas en comparación con la variable respuesta
- separar columna en dos con str.split() APIs Metodos analiticos:
Visualmente: df_datos_norm = pd.DataFrame(datos_normalizados,
- crear intervalos con pd.cut() Asimetría columns = ['col_norm'])
- violinplot
- crear porcentajes o ratios import requests libreria para realizar peticions HTTP df['col_norm'] = df_datos_norm
- distribuciones asimétricas positivas: media > mediana y moda - boxplot
- decidir como tratar outliers: mantenerlos, a una URL, para hacer web scraping
url = 'enlace' el enlace de la que queremos extraer - distribuciones asimétricas negativas: media < mediana y moda - regplot (columnas numéricas vs variable respuesta)
eliminarlos, o reemplazarlos con la media,
mediana o moda; o aplicar una imputacion datos from scipy.stats import skew
ANOVA
Metodos analiticos:
header = {} opcional; contiene informacion sobre las skew(datos_normales) método de scipy que calcula el sesgo import statsmodels.api as sm
- decidir como tratar nulos: peticiones realizadas (tipo de ficheros, credenciales) - test de Levene (más robusto ante falta de
df['columna'].skew() método de pandas que calcula el sesgo normalidad) o Bartlett from statsmodels.formula.api import ols
- eliminar filas o columnas con nulos drop.na() response = requests.get(url=url, header = header)
- imputar valores perdidos: pedimos a la API que nos de los datos Curtosis from scipy import stats lm = ols('col_VR ~ col_VP1 + col_VP2 + col_VP3',
- reemplazarlos con la media, mediana o moda variables = {'parametro1':'valor1', - leptocurtosis: valor de curtosis mayor que 0 (pico alto) from scipy.stats import levene data=df).fit()
usando .fillna() o .replace() 'parametro2':'valor2'} Variables categóricas: devuelve un dataframe de los resultados:
- mesocurtosis: valor de curtosis igual a 0 (pico medio)
- imputer con metodos de machine learning response = request.get(url=url, params=variables) df (degrees of freedom): para variables categóricas
- platicurtosis: valor de curtosis menor que 0 (plana) - hay que crear un dataframe para cada valor único de
usando la libreria sklearn: Simple-Imputer, pedimos a la API que nos de los datos con los será el número de valores únicos menos 1; para
parametros segun el diccionario de parametros que le from scipy.stats import kurtosistest las columnas categóricas
Iterative-Imputer, o KNN Imputer variables numéricas será siempre 1
pasamos kurtosistest(datos) devuelve un p-valor df_valor1 = df[df['col1'] == 'valor1']['col_VR']
sum_sq: medida de variación/desviación de la media
response.status_code devuelve el status de la peticion - p-valor del test > 0.05: datos normales ✔️ df_valor2 = df[df['col1'] == 'valor2']['col_VR']
response.reason devuelve el motive de codigo de estado mean_sq: es el resultado de dividir la suma de
3. Analizar relaciones entre variables response.text devuelve los datos en formato string - p-valor del test < 0.05: datos NO normales levene_test = stats.levene(df_valor1, df_valor2,
center='median')
cuadrados entre el número de grados de libertad.
response.json() devuelve los datos en formato json Test de Shapiro-Wilk F: un test que se utiliza para evaluar la capacidad
Analizar relaciones entre las variables bartlett_test = stats.bartlett(df_valor1, df_valor2,
df = pd.json_normalize(response.json) devuelve los - para muestras < 5000 explicativa que tiene la variable predictora sobre
- para encontrar patrones, relaciones o anomalias center='median')
datos en un dataframe la variación de la variable respuestae
Relaciones entre dos variables numéricas: - hipótesis nula: distribución normal Variables numéricas:
- scatterplot - PR(>F): si el p-valor < 0.05 es una variable
Codigos de respuesta de HTTP from scipy import stats - hay que crear un dataframe de las columnas numéricas significativa; que puede afectar a la VR
- regplot – scatterplot con línea de regresion stats.shapiro(df["datos"]) sin la variable respuesta
- matriz de correlación y heatmap lm.summary() devuelve una resumen de los
1XX informa de una 4XX error durante peticion - p-valor del test > 0.05: datos normales ✔️ for col in df_numericas.columns:
- joinplot – permite emparejar dos gráficas – una resultados:
respuesta correcta 401 peticion incorrecta - p-valor del test <) 0.05: datos NO normales statistic, p_val = levene(df[col], df['col_VR'],
histograma con scatter o reg plot por ejemplo coef: representa los cambios medios en la VR para
2XX codigo de exito 402 sin autorizacion
Relaciones entre dos variables categóricas: Test de Kolmogorov-Smirnov center='median') una unidad de cambio en la VP mientras se mantienen
200 OK 403 prohibido
- countplot - para muestras > 5000 resultados[col] = p_val constantes el resto de las VP; los signos nos
201 creado 404 no encontrado
Relaciones entre variables numéricas y categóricas: indican si esta relación es positiva o negativa
202 aceptado 5XX error del servidor - hipótesis nula: distribución normal devuelve los p-valores en un diccionario
- swarmplot std err: cuanto menor sea el error estándar, más
204 sin contenido 501 error interno del servidor - p-valor del test > 0.05: varianzas iguales,
- violinplot from scipy import kstest precisa será la estimación
3XX redireccion 503 servicio no disponible homocedasticidad ✔️
- pointplot kstest(df["datos"], 'norm')
t: es el resultado de dividir el coeficiente entre
- boxplot - p-valor del test > 0.05: datos normales ✔️ - p-valor del test < 0.05: varianzas diferentes,
su error estándar
- p-valor del test < p-valor (alfa) 0.05: datos NO normales heterocedasticidad
Machine Learning Regresión Lineal: Métricas Regresión Logística: Métricas Balanceo para Regresión Logística GridSearch y best_estimator_
from sklearn.metrics import r2_score, mean_squared_error, Matriz de confusión Downsampling Despues de hacer las predicciones de un modelo
Estandarización mean_absolute_error
ajustar la cantidad de datos de la categoría mayoritaria a
Decision Tree, examinamos lás métricas de los
Predicción resultados:
R2: representa la proporción de la varianza que puede ser Matriz de la minoritaria
- cambiar los valores de nuestras columnas de manera que explicada por las VP del modelo; mayor R2=mejor modelo - si temenos overfitting hay que reducir la
la desviación estándar de la distribución sea igual a 1 y r2_score(y_train,y_predict_train)
confusión Positivo Negativo Método manual profundidad del modelo
la media igual a 0; para que las VP sean comparables df_minoritaria = df[df['col'] == valor_min]
r2_score(y_test,y_predict_test) - si temenos underfitting hay que aumentar la
Método manual MAE (Mean absolute error): medida de la diferencia entre los Positivo Verdadero Falso negativo df_muestra = df[df['col'] == valor_max].sample profundidad del modelo
valores predichos vs los reales; menor MAE=mejor modelo positivo (num_minoritarios, random_state = 42) max_features = np.sqrt(len(x_train.columns))
df["col_esta"] = (df ["col_VR"] – df ["col_VR"].media()) /
mean_absolute_error(y_train,y_predict_train) Realidad df_balanceado = pd.concat([df_minoritaria,
(df ["col_VR"].std() podemos calcular el valor de max_features siendo la
Negativo Falso Verdadero df_muestra],axis = 0)
mean_absolute_error(y_test,y_predict_test) raíz cuadrada del número de variables predictoras
Sklearn StandardScaler positivo negativo Método RandomUnderSample
MSE (Mean Squared Error): mide el promedio(media) de los arbol.tree_.max_depth nos muestra el max depth
from sklearn.preprocessing import StandardScaler errores al cuadrado; menor MSE=mejor modelo import imblearn usado por defecto, para poder ajustarlo; deberíamos
scaler = StandardScaler() mean_squared_error(y_train,y_predict_train) para crear un heatmap de una matriz de confusión: X = df.drop('col_VR', axis=1) usar la mitado como mucho
scaler.fit(df_num_sin_VR) mean_squared_error(y_test,y_predict_test) from sklearn.metrics import confusion_matrix y = df['col_VR'] - GridSearch ejecuta todas las posibles
datos_estandarizados = scaler.transform (df_num_sin_VR) RMSE (Root Mean Squared Error): distancia promedio entre los mat_lr = confusion_matrix(y_test, y_pred_test) down_sampler = RandomUnderSampler() combinaciones de hiperparámetros que le damos con
df_datos_esta = pd.DataFrame(datos_estandarizados, columns valores predichos y los reales; menor RMSE=mejor modelo plt.figure(figsize = (n,m)) X_down, y_down = down_sampler.fit_resample(X,y) el parámetro 'param' y best_estimator_ devuelve la
= df_num_sin_VR.columns) major combinacion encontrado
np.sqrt(mean_squared_error(y_train,y_predict_train)) sns.heatmap(mat_lr, square=True, annot=True= df_balanceado = pd.concat([X_down, y_down], axis = 1)
np.sqrt(mean_squared_error(y_test,y_predict_test)) plt.xlabel('valor predicho') 1. Definimos un diccionario de los hiperparametros
Sklearn RobustScaler Método Tomek
from sklearn.preprocessing import RobustScaler plt.ylabel('valor real') param = {"max_depth": [n,m,l], "max_features":
x = df.drop('col_VR', axis=1) [a,b,c,d], "min_samples_split": [x,y,z],
scaler = RobustScaler() Linear Regression: Modelo plt.show()
y = df['col_VR'] "min_samples_leaf": [r,s,t]} from
scaler.fit(df_num_sin_VR) Métricas x_train, x_test, y_train, y_test = train_test_split(x, y, sklearn.model_selection import GridSearchCV
datos_estandarizados = scaler.transform (df_num_sin_VR) 1. separar los datos de las variables predictoras (x) de la test_size = 0.2, random_state = 42)
from sklearn.metrics import confusion_matrix, 2. Iniciamos el modelo con GridSearch
df_datos_esta = pd.DataFrame(datos_estandarizados, columns variable respuesta (y) tomek_sampler = SMOTETomek()
accuracy_score, precision_score, recall_score,
= df_num_sin_VR.columns) X = df.drop('col_VR', axis=1) gs = GridSearchCV(estimator =
f1_score , cohen_kappa_score, X_train_res, y_train_res =
DecisionTreeRegressor(), param_grid = param, cv=10,
y = df['col_VR'] roc_curve,roc_auc_score tomek_sampler.fit_resample(X_train, y_train)
verbose=-1, return_train_score = True, scoring =
Encoding 2. dividimos los datos en datos de entrenamiento y datos de Accuracy (exactitud): porcentaje de los valores
Upsampling "neg_mean_squared_error")
test con train_test_split() predichos están bien predichos
Variables categóricas ajustar la cantidad de datos de la categoría minoritaria a 3. Ajustamos el modelo en el GridSearch
from sklearn.model_selection import train_test_split accuracy_score(y_train,y_predict_train)
la mayoritaria gs.fit(x_train, y_train)
Ordinaria: no requiere números pero sí consta de un orden x_train, x_test, y_train, y_test = train_test_split(X, y, accuracy_score(y_test,y_predict_test)
o un puesto; diferencias de medianas entre categorías test_size = 0.2, random_state = 42) Recall: porcentaje de casos positivos capturados Método manual 4. Aplicamos el método de best_estimator_
Nominal: variable que no es representada por números, no 3. Ajustamos el modelo *si preferimos FP, queremos recall alta* df_mayoritaria = df[df['col'] == valor_may] mejor_modelo = gs.best_estimator_
tiene algún tipo de orden, y por lo tanto es from sklearn.linear_model import LinearRegression df_muestra = df[df['col'] == valor_min].sample
recall_score(y_train,y_predict_train) devuelve la mejor combinación de hiperparámetros
matemáticamente menos precisa; no habrá grandes (num_mayoritarias, random_state = 42)
lr = LinearRegression(n_jobs=-1) recall_score(y_test,y_predict_test)
diferencias de medianas entre categorías 5. Volvemos a sacar las predicciones
lr.fit(x_train, y_train) Precisión (sensibilidad): porcentaje de df_balanceado = pd.concat([df_mayoritaria,
Binaria: dos posibilidades; puede tener orden o no df_muestra],axis = 0) y_pred_test_dt2 = mejor_modelo.predict(x_test)
4. Hacemos las predicciones predicciones positivas correctas
Variables sin orden: creamosuna columna nueva por valor *si preferimos FN, queremos precisión alta* Método RandomOverSample y_pred_train_dt2 = mejor_modelo.predict(x_train)
y_predict_train = lr.predict(x_train)
único, asignando unos y zeros
y_predict_test = lr.predict(x_test) precision_score(y_train,y_predict_train) import imblearn Importancia de los predictores
One-Hot Encoding X = df.drop('col_VR', axis=1)
5. Guardamos los resultados en dataframes y los concatenamos presicion_score(y_test,y_predict_test) importancia_predictores = pd.DataFrame(
from sklearn.preprocessing import OneHotEncoder y = df['col_VR']
train_df = pd.DataFrame({'Real': y_train, 'Predicted': Especificidad: porcentaje de los casos negativos {'predictor': x_train.columns, 'importancia':
oh = OneHotEncoder() capturados down_sampler = RandomUnderSampler()
y_predict_train, 'Set': ['Train']*len(y_train)}) mejor_modelo.feature_importances_})
df_transformados = oh.fit_transform(df[['columna']]) F1: la media de la precisión y el recall X_down, y_down = down_sampler.fit_resample(X,y)
test_df = pd.DataFrame({'Real': y_test, 'Predicted': importancia_predictores.sort_values(by=["importanci
oh_df = pd.DataFrame(df_transformados.toarray()) y_predict_test, 'Set': ['Test']*len(y_test)}) df_balanceado = pd.concat([X_down, y_down], axis = 1)
f1_score(y_train,y_predict_train) a"], ascending=False, inplace = True) crea un
oh_df.columns = oh.get_feature_names_out() resultados = pd.concat([train_df,test_df], axis = 0) f1_score(y_test,y_predict_test) dataframe con la relativa importancia de cada VP
df_final = pd.concat([df, oh_df], axis=1) 6. creamos una columna de los residuos: la diferencia entre kappa: una medida de concordancia que se basa en Logistic Regression: Modelo
get_dummies los valores observados y los de la predicción comparar la concordancia observada en un conjunto - para los variables categóricas nominales a los
df_dum = pd.get_dummies(df['col'], prefix='prefijo', resultados['residuos'] = resultados['Real'] - de datos, respecto a la que podría ocurrir por mero seguir los mismos pasos como para la Regresión Lineal pero cuales se ha aplicado encoding, hay que sumar los
dtype=int) resultados['Predicted'] azar con LogisticRegression() resultados de las columnas divididas:
df[df_dum.columns] = df.dum - <0 No acuerdo from sklearn.linear_model import LogisticRegression df_sum = importancia_predictores_esta.iloc[[n, m]]
Cross-validation
df.drop('col', axis=1, inplace=True) - 0.0-0.2 Insignificante
from sklearn.model_selection import cross_val_score importancia_predictores_esta.drop(df_sum.index,
Variables que tienen orden: from sklearn.model_selection import cross_validate
- 0.2-0.4 Bajo Decision Tree: Modelo inplace = True)
- 0.4-0.6 Moderado
Label Encoding asigna un número a cada valor único de una cv_scores = cross_val_score(estimator = LinearRegression(), from sklearn.model_selection import train_test_split importancia_predictores_esta.loc[n] =
variable X = X, y = y, scoring = 'neg_root_mean_squared_error', cv = - 0.6-0.8 Bueno
["nombre_col", df_sum["importancia"].sum()]
10) - 0.8-1.0 Muy bueno from sklearn.ensemble import DecisionTreeRegressor
from sklearn.preprocessing import LabelEncoder
from sklearn import tree
le = LabelEncoder() cv_scores.mean() cohen_kappa_score(y_train,y_predict_train)
seguir los mismos pasos como para la Regresión Lineal pero
Random Forest: Modelo
df['col_VR_le'] = le.fit_transform(df[col_VR']) calcula la media de los resultados de CV de una métrica cohen_kappa_score(y_test,y_predict_test) con DecisionTreeRegressor() o DecisionTreeClassifier()
map() asigna el valor que queramos según el mapa que cv_scores = cross_validate(estimator = LinearRegression(), X curva ROC: forma gráfica de ver la kappa; la seguir los mismos pasos como para el Decision Tree
= X, y = y, scoring ='r2', 'neg_root_mean_squared_error', cv sensibilidad vs. la especificidad arbol = DecisionTreeRegressor(random_state=42) pero con RandomForestRegressor() o
creamos
= 10) AUC (área under curve): la área bajo la curva ROC; Para dibujar el árbol: RandomForestClassifer()
df['col_VR_map'] = df[col_VR'].map(diccionario)
cv_scores["test_r2"].mean() cuanto más cerca a 1, mejor será nuestro modelo fig = plt.figure(figsize = (10,6)) from sklearn.ensemble import RandomForestRegressor
Ordinal-Encoding asignamos etiquetas basadas en un orden o
cv_scores["test_neg_root_mean_squared_error"].mean() calcula clasificando los VP tree.plot_tree(arbol, feature_names = x_train.columns,
jerarquía - se puede usar los mismos hiperparámetros del
las medias de los resultados de validación de múltiples filled = True) best_estimator_ o volver a ejecutar el GridSearch
from sklearn.preprocessing import OrdinalEncoder
métricas plt.show()