Los Mejores Trucos para el Lenguaje de Programación Python

Hola Resumen de trucos de Python

1. Python: Los básicos
Variables ampliadas por text
(CONCATENATION)
Para encadenartexto
categoria1 = "verde"
color_detalle= categoria1 + ' ' + 'oscuro"
print(categoria1 + ' oscuro')
print(categoria1, 'oscuro')
type() and isinstance()
float/int/str(variable)cambia eltipode data/type
type(variable)devuelve: class 'float/int/str'
isinstance(variable, float/int/str) comprobareltipo
de dato(devuelveTrue/False)
OperacionesAlgebraicas
+ sumar
-restar
* multiplicar
** elevar
/ dividir
//divider y redondear(modulus)
%resto de unadivision (floor
division)
round(x) redondearnúmerox
OperacionesBinarias
==comprobarsivalorescoinciden
iscomprobarsivaloresson exacamenteigual
!=comprobarsivaloresson diferentes
is not comprobarsivaloresno son exactamente
iguales
> (>=) mayor que (mayor o igualque)
< (<=)menorque (menoro igualque)
andambas verdaderas
orambas o solo unaverdadera
in/not in comprobarsihay un valorenunalistaetc.
MetodosString
string.upper()zMAYUSCULAS
string.lower()minusculas
string.capitalize()Primera letrade la fraseenmay.
string.title()Primera LetraDe CadaPalabra En May.
string.swapcase()mINUSCULASA mAYUSCULASO vICEVERSA
string.strip()quitaespaciosdel principio y final
string.split() divide string enlista–porespacios
pordefecto, o especificaotrodivisor en()
string.replace("frase", "frase")remplazala primera
frasedel string porelotro
" ".join(string)uneloselementosde unalistaen
unastring con elseparadorespificadoen" "
list(string) convierteun variable string enuna
lista
string.find("substring")encuentraelindiceenque
empieceelsubstring/'-1' sino existeelsubstring
string[i]devuelveelelementoenla indicei
string[i:j] devuelveun rangode caracteres
Listas [ ] Metodosno permanentes
lista= [] creaunalistavacia
len(lista)devuelveelno. de elementos
min(lista)/max(lista)sacaelvalorminimoy maximo
lista.count()devuelveelno. de elementosque hay en
la listade un valordeterminadoenlos()
sorted(lista)ordenarunalistade menora mayor
lista.copy()hacerunacopiade la lista
Metodoscon indices
list.index(x)devuelvela indicede x enla lista
lista[i]devuelveelelementoenla indicei
[start:stop:step]
lista[i:j:x]devuelveloselementosporelrangode i
a j (incluyeiperono j) saltandoporx
lista[-i:-j]devuelveloselementosporlosindices
negativos(incluye–j perono –i)
Listas–AccionesPermanentes
Ampliarunalista
[lista1, lista2] junta listasperose mantienencomo
listasseparadas
lista1 + lista2 haceunalistamas larga
.append()
lista.append(x)#añadeunsolo elemento(lista,
string, integer o tuple) a la lista
.extend()
lista.extend(lista2)#añadeloselementosde una
listaal final de la lista
.insert()
.insert(i, x)#mete un elemento (x) en un índice(i)
Ordenarunalista
.sort()
lista.sort()#ordenade menora mayor, usar con
(reverse=True) para ordenarde mayor a menor
lista.reverse()# ordenaloselementosal revesdel
ordenguardado
Quitarelementosde unalista
.pop()
lista.pop(i)# quitaelelementoenindiceiy
devuelvesuvalor
.remove()
lista.remove(x)#quitaelprimer elementode la lista
con valorx
lista.clear()# vaciala lista
del lista# borra la lista
del lista[i]# borra elelementoenindicei
# metodospermanentes(cambia elvariable, no devuelvenada)
Diccionarios { key: value, }
diccionario= {x:y} compuestosporun key(x) unica
y un valor(y) (cualquiertipode datos)
dict()
variable = dict(x=y, m=n)crearun diccionario
dicc.copy()crearunacopia
len(dicc)devuelveelno. de elementos(x:y) hay en
eldiccionario
sorted(dicc)ordenaloskeys; usar con .items()
para ordenartuplasde loselementoso .values()
para ordenarlosvalues solos
Diccionarios–Metodos
Obtenerinformacionde un diccionario
dicc.keys()devuelvetodaslas keys
dicc.values()devuelvetodoslosvalues
dicc.items()devuelvetuplasde loskey:value
in/not in comprobarsiexisteunaclave
dicc.get(x, y)devuelveelvalorasociadoal key x,
o sino existedevuelveeloutput y
dicc["key"]devuelveelvalordel key (verabajo
que tienemas usos)
Ampliarun diccionario
.update()
dicc.update({x:y})# para insertarnuevoselementos
dicc["key"] = valor# para inserter un nuevo key o
valor, o cambiarelvalorde un key
dicc. setdefault(x, y)# devuelveelvalue del key
x, o sino existela key x, la creay asignael
valory pordefecto
Quitarelementosde un diccionario
dicc.pop(x)# eliminala key x (y lo devuelve)
dicc.popitem()# eliminaelultimo par de key:value
dicc.clear()# vaciaeldiccionario
Tuplas (,) inmutables, indexados
tupla= (x,y) tuplasse definencon () y , o solo ,
tupla1 + tupla2 juntartuplas
tuple(lista) creartuplasde unalista
tuple(dicc)creartuplasde loskeys de un
diccionario
tuple(dicc.values())creartuplasde losvalues
tuple(dicc.items())creartuplasde loskey:values
len(tupla)devuelveelno. de elementos
in/not in comprobarsihay un elemento
tupla.index(x)devuelveelindicede x
tupla.count(x)devuelveelno. de elementoscon
valorx enla tupla
*para cambiarelcontenidode unatuplahay que
convertirlaenunalistay luego a tupla*
zip()
zip(iterable1, iterable2)creaunalistade tuplasde
parejas de loselementosde las dos listas(mientrasse
puede)
listzip.sort() ordenalas tuplasdel zip porelprimer
elemento
Sets {}
no permitenduplicados, no tienenorden
set = {x,y}
set(iterable)solo permiteun argumentoiterable; elimina
duplicados
in/not in comprobarsihay un elemento
len(set)devuelveelno. de elementos
Ampliarun set
set.add(x)# añadir un elemento
set.update(set o lista)# añadir uno o mas elementos con
[] o {} o un variable tipo lista o set
Quitarelementosde un set
set.pop()# eliminaun elementoal azar
set.remove(x)# eliminaelelementox
set.discard(x)# eliminaelelementox (y nodevuelve
error sino existe)
set.clear()# vaciaelset
Operacionescon dos Sets
set1.union(set2) devuelvela union de losdos sets: todos
loselementosmenosdupl.
set1.intersection(set2) devuelveloselementoscomunesde
losdos sets
set1.difference(set2) devuelvelossets que estanenset1
perono enset2 (restar)
set1.symmetric_difference(set2) devuelvetodoslos
elementosque no estanenambos
set1.isdisjoint(set2) comprobarsitodosloselementosde
dos sets son diferentes
set1.issubset(set2) comprobarsitodosloselementosde
set1 estanenset2
set1.superset(set2) comprobarsitodosloselementosde
set2 estanenset1
input()
•permiteobtenertextoescritoportecladodel usuario
input("el textoque quieresmostraral usuario")
•se puedeguardarenun variable
•pordefectose guardacomoun string
x = int(input("escribe un número") para usar elvariable
comointeger o float se puedeconvertirenelvariable
Sentenciasde control
if ... elif... else
ifestablecauna condición para que se ejecute el código que
esta debajo del if. *tiene que estar indentado*
elifpara chequear mas condiciones después de un if
elseagrupa las condiciones que no se han cumplido; no puede
llevar condiciones nuevas
ifx > y:
print("x es mayor que y")
elifx == y:
print("x es igual que y")
else:
print("x e y son iguales")
while
•repite el código mientras la condición sea True, o sea se
parará cuando la condición sea False
•se pueden incluir condiciones con if... elif... else
•*pueden ser infinitos* (si la condición no llega a ser
False)
whilex < 5:
print("x es mayor que 5")
For loops
•sirven para iterar por todos los elementos de un variable
que tiene que ser un iterable (lista, diccionario, tupla,
set, orstring)
•se pueden combinar con if... elif... else, while, u otro
forloop
•en diccionarios por defecto interapor las keys; podemos
usar dicc.values() para acceder a los values
fori in lista:
print("hola mundo")
List comprehension
•su principal uso es para crear una lista nueva de un un for
loopen una sola línea de codigo
[ lo que queremos obtener iterablecondición(opcional) ]
try ... except
Se usan para evitar que nuestro código se pare debido a un error
en el código. Se puede imprimir un mensaje que avisa del error.
try:
print("2.split())
except:
print("no funciona")
range()
•nosdevuelveunalistade númerosque pordefectose
aumentande uno enuno empezandopor0
range(start:stop:step)
•se puedeespecificarpordondeempiezay ellimite(que debe
ser +1 porque se para uno antes del limiteque ponemoscomo
stop)
•tambiense puedeespecificarsaltos

2. Funciones y Clases; Librerías
Funciones
Definirunafuncion:
def nombre_funcion(parametro1, parametro2, ...):
return valor_del_return
Llamarunafuncion:
nombre_funcion(argumento1, argumento2, ...)
return: es opcional, perosin return devuelveNone
parametrospordefecto: –siempredebenser lo
ultimo
*args: unatuplade argumentossin limite
**kwargs: diccionarioscuyaskeys se convierten en
parámetros y sus valores en los argumentos de los
parámetros
def nombre_funcion(parametros, *args, **kwargs,
parametro_por_defecto= valor)
arg/kwarg: sin */** dentrode la funcion
arg[0]
Llamarunafuncioncon *args:
nombre_funcion(argumento, argumento, argumento, ...)
o
nombre_funcion(*[lista_o_tupla_de_args])
Llamarunafuncioncon **kwargs:
nombre_funcion(**diccionario)
Clases
Definirunaclase:
class NombreClase:
def __init__(self, atributo1, atributo2):
self.atributo1 = atributo1
self.atributo2 = atributo2
self.atributo_por_defecto= 'valor'
def nombre_funcion1(self, parametros)
self.atributo+= 1
return f"el nuevo valores {self.atributo}"
Definirunaclasehija:
class NombreClaseHija(NombreClaseMadre):
def __init__(self, atributo1, atributo2):
super().__init__(atributo_heredado1, ...)
def nombre_funcion_hija(self, parametros):
Crearun objetode la clase:
variable_objeto= NombreClase(valor_atributo1,
valor_atributo2)instanciar(crear) un objeto
variable_objeto.atributodevuelveelvalordel
atributoguardadopara ese objeto
variable_objeto.atributo= nuevo_valorpara cambiar
elvalordel atributo
variable_objeto.nombre_funcion()llamarunafuncion
print(help(NombreClase)imprimeinformacionsobrela
clase
Regex
-una abreviatura de `expresión regular`,
`regex` es una cadena de texto que permite
crear patrones que ayudan a emparejar,
localizar y gestionar strings
import repara podertrabajarcon regex
Operadorescommunes de regex
+coincide con el carácter precedente una o más
veces
*coincide con el carácter precedente cero o
más veces u opcional
?indica cero o una ocurrencia del elemento
precedente
.coincide con cualquier carácter individual
^coincide con la posición inicial de cualquier
string
$coincide con la posición final de cualquier
string
Sintaxis básica de regex
\wcualquier caracterde tipo alfabético
\dcualquier caracterde tipo númerico
\sespacios
\nsaltos de línea
\Wcualquier caracterque no sea una letra
\Dcualquier caracterque no sea un dígitos
\Scualquier elemento que no sea un espacio
()aísla sólo una parte de nuestro patrón de
búsqueda que queremos devolver
[]incluye todos los caracteres que queremos
que coincidan e incluso incluye rangos como
este: a-z y 0-9
|es comoeloperador'or'
\señala una secuencia especial ( escapar
caracteres especiales)
{}Exactamente el número especificado de
ocurrencias
{n}Exactamente n veces
{n,}Al menos n veces
{n,m}Entre n y m veces
Métodos Regex
re.findall("patron", string)buscaentodoel
string y devuelveunalistacon todaslas
coincidenciasennuestrostring
re.search("patron", string_original)buscaen
todoelstring y devuelveun objetocon la
primeracoincidenciaennuestrostring
re.match("patron", "string_original)buscaen
la primeralineadel string y devuelveun
objetocon la primeracoincidenciaennuestro
string
resultado_match.span()devuelvela referencia
de las posicionesdondehizoel"match"
resultado_match.group()devuelveelelement
resultandode la coincidenciadel "match"
re.split("patron", "string_original")buscaen
todoelstring y devuelveunalistacon los
elementosseparadosporelpatron
re.sub("patron", "string_nuevo",
"string_original")buscaentodoelstring y
devuelveun string con elelement que coincide
Modulos/Librerias(paquetesde funciones)
Importary usar modulosy sus funciones
import modulopara importarun modulo
from modulo import funcionimportarsolo unafuncion
modulo.funcion()usar unafuncionde un modulo
modulo.clase.funcion()para usar unafuncionde unaclase
import modulo as mdasignar un alias a un modulo
Libreriaos
os.getcwd()devuelvela rutade dondeestamostrabajando; se
puedeguardarenun variable e.g. ruta= os.getcwd()
os.listdir()devuelveunalistade losarchivosy carpetas
dondeestamostrabajando
os.listdir('carpeta')devuelveloscontenidosde otracarpeta
os.chdir('ruta') cambia la carpetaenla que estes
os.mkdir('nueva_carpeta')crearunanuevacarpeta
os.rename('nombre_carpeta', 'nueva_nombre')cambia elnombre
de unacarpeta
os.rmdir('carpeta')borra la carpeta
Libreriashutil
from shutilinmportrmtree
rmtree('carpeta')borra la carpetay subcarpetas
Abriry cerrarficheros
Primero hay que guardarla rutadel archivo:
ubicacion_carpeta= os.getcwd()
nombre_archivo= "text.txt"
ubicacion_archivo= ubicacion_carpeta+ "/" + nombre_archivo
f = open(ubicacion_archivo)abrirun archivoenvariable f
f.close() cerrarun archivo* IMPORTANTE *
with open(ubicacion_archivo) as f:
codigo e.g. variable = f.read()abreelarchivosolo para
ejecutarelcodigo indicado(y despueslo deja)
Encoding
from locale import getpreferredencoding
getpreferredencoding()para saberque sistemade encoding
estamosusando
f = open(ubicacion_archivo, encoding="utf-8")abrirun archivo
y leerlocon elencoding usado; guardarcon .read()
mode: argumentoopcionalal abrirun archivo
r–read
w–write -sobreescribe
x–exclusive creation, sólo crearlo si no existe todavía
a–appending, añadir texto al archivo sin manipular el texto
que ya había
hay que anadirotraletra:
t–texto–leer entexto
b–bytes –leer enbytes (no se puedeusar con encoding)
f = open(ubicacion_archivo, mode = "rt")
Leer ficheros
f.read()leer elcontenidode un archivo
f.read(n)leer losprimerosn caracteresde un archivo
variable = f.read()guardarelcontenidodel archivo(o n
caracteresde un archivo) enun variable
f.readline(n)pordefectodevuelvela primeralineao n lineas
f.readlines()devuelveunalistade todaslas lineasdel
archivo(cadalineaes un elemento); se usavaciosin n y
list_name[x:] para seleccionarlineasespecificas
Escribirenficheros
with open(ubicacion_archivo, "w") as f:
f.write("Texto que vaenelfichero.")para escribir
with open(ubicacion_archivo, "a") as f:
f.write("Texto que vaenelfichero.")para anadirtexto
f.writelines('lista')para anadirlineasde textode unalista
Ficherosxml
importxml.etree.ElementTreeas ETimporta la librería xml
variable_tree= ET.parse('ruta/archivo.xml')abre el
archivo
variable_root= variable_tree.getroot()saca el elemento
que envuelve todo (el elemento raíz) en una lista
<root>
<child_tagatributo1="valor" atributo2=valor>
<subchild_tag> elemento </subchild_tag>
</child_tag>
</root>
variable_root.tagdevuelve el nombre del tag del raiz
variable_root.attribdevuelve los atributos del fichero
variable_root.find("tag").find("childtag").textdevuelve
la primera ocasión en que el tag de un elemento coincida
con el string
variable_root.findall("tag").findall("childtag").text
devuelve todos los elementos cuyos tag coincide
MySQL Connector/Python
Conectar a una base de datos
importmysql.connectorpara importar MySQL Connector
pip install mysql-connector
pip install mysql-connector-Python
connect()para conectar a una base de datos:
variable_cnx= mysql.connector.connect(user='root',
password='AlumnaAdalab',
host='127.0.0.1',
database='nombre_BBDD')
from mysql.connectorimport errorcodeimportarerrores
mysql.connector.Errorse puede usar en un try/except
cnx.close()desconectar de la base de datos
Realizar queries
variable_cursor= cnx.cursor()crear el objeto cursor que
nos permite comunicar con la base de datos
variable_cursor.close()desconectar el cursor
variable_query= ("SQL Query")guardar un queryen un
variable
variable_cursor.execute(variable_query)ejecutar el query;
devuelve una lista de tuplas
importdatetimesacar fechas en el formato AAAA-MM-DD
datetime.date(AAAA, M, D)devuelve el formato de fecha
variable_query= "SQL Query... %s AND %s")querydinamica
variable_cursor.execute(query, (variable1, variable2))
valores que van en lugar de los %s
variable_cursor.execute("SHOW DATABASES")mostrar las BBDD
variable_cursor.execute("SHOW TABLES")mostrar las tablas
de la BBDD indicado en la conexión
variable_cursor.execute("SHOW TABLES")
variable_cursor.execute("SHOW COLUMNS FROM bbdd.table")
mostrar las columnas de la tabla especificada; hay que
conectarse a la bbddinformation_schema
Argumentos cursor:
variable_cursor= cnx.cursor([arg=value[, arg=value]...])
buffered=Truedevuelve todas las filas de la bbdd
raw=Trueel cursor no realizará las conversiones
automáticas entre tipos de datos
dictionary=Truedevuelve las filas como diccionarios
named_tuple=Truedevuelve las filas como namedtuples
cursor_classun argumento que se puede usar para indicar
que subclase queremos usar para instanciar el nuevo cursor
MySQL Connector/Python
Obtener resultados de una query
variable_cursor.fetchone()devuelve el primer resultado
variable_cursor.fetchall()devuelve todos los resultados
como iterable –cada fila es una tupla
Pandas dataframewithSQL
importpandas as pd
variable_df= pd.DataFrame(variable_resultado_fetchall,
columns = ['columna1', 'columna2', ...]) crearun
dataframecon losresultadosde unaquery enunavariable
variable_df.head(n)devuelvelas n primerasfilasdel df,
o 5 pordefecto
variable_df= pd.read_sql_query(variable_query,
variable_cnx)convertirlosresultadosde la query endf
pd.read_sql(variable_query, variable_cnx)
variable_df.to_csv("nombre_archivo.csv")guardar en csv
variable_df.to_string()formatear el dato en string
variable_df.to_latex()formatear el dato en un stringque
facilite la inserción en un documento latex
Crear y alterar una base de datos
variable_cursor.execute("CREATE DATABASE nombre_BBDD")
variable_cursor.execute("CREATE TABLE nombre_tabla
(nombre_columnaTIPO, nombre_columna2 TIPO2)")
variable_cursor.execute("ALTER TABLE nombre_tabla
ALTERACIONES")
Insertar datos
variable_query= "INSERT INTO nombre_tabla(columna1,
columna2) VALUES (%s, %s)"
variable_valores= (valor1, valor2)
variable_cursor.execute(variable_query, variable_valores)
otro método:
variable_query= "UPDATE nombre_tablaSET nombre_columna=
"nuevo_valor" WHERE nombre_columna= "valor"
Insertar múltiples filas a una tabla
variable_valores_en_tuplas = ((valor1columna1,
valor1columna2), (valor2columna1, valor2columna2))
variable_cursor.executemany(variable_query,
variable_valores_en_tuplas)
variable_conexion.commit()después de ejecutar la
inserción, para que los cambios efectúen en la BBDD
variable_conexion.rollback()se puede usar después de
executey antes de commitpara deshacer los cambios
print(variable_cursor.rowcount, "mensaje")imprimir el
número de filas en las cuales se han tomado la accion
Eliminar registros
variable_query= "DROP TABLE nombre_tabla"
Añadir errores
importar errorcodey usar try/except:
try:
accion
except mysql.connector.Erroras err:
print(err)
print("Error Code:", err.errno)
print("SQLSTATE", err.sqlstate)
print("Message", err.msg)

3. Python: Pandas
Series: estructurasenunadimension
Crearseries
serie= pd.Series()crearserievacía
serie= pd.Series(array)crearseriea partirde un
array con elindicepordefecto
serie= pd.Series(array, index = ['a', 'b', 'c'...])
crearunaseriecon indicedefinida; debeser listade
la mismalongitude del array
serie= pd.Series(lista)crearunaseriaa partirde
unalista
serie= pd.Series(número, indice)crearunaseriea
partirde un escalarcon la longitude igualal número
de indices
serie= pd.Series(diccionario)crearunaseriea
partirde un diccionario
Acceder a informacionde unaserie
serie.indexdevuelvelosindices
serie.valuesdevuelvelosvalores
serie.shapedevuelvela forma (no. filas)
serie.sizedevuelveeltamaño
serie.dtypesdevuelveeltipode dato
serie[i]devuelveelvalordel elementoenindicei
serie[[i,j]]devuelveelvalorde losdos elementos
serie[i:m]devuelveelvalorde un rango
serie["etiqueta"]devuelveelvalorde loselementos
enindices iy j
Operacionescon series
serie1 +-*/ serie2suma/resta/multiplica/divide las
filascon indices comunesentre las dos series
serie1.add(serie2, fill_value= número)sumalas filas
con indices comunes, y sumaelfill value a los
valoressin indicecomun
serie1.sub(serie2, fill_value= número)restanlas
filasde la seria2 de la serie1 cuandotienenindices
comunes, y restaelfill value de las otrasindices de
serie1
serie1.mul(serie2, fill_value= número)multiplicalas
filascon indices comunesy multiplicaelfill value
con las otras*usar 1 para conservarelvalor*
serie1.mul(serie2, fill_value= número)dividalas
filasde la serie1 entre las de la serie2 cuando
tienenindices comunes, y divide las otrasporelfill
value
serie1.mod(serie2, fill_value= número)devuelveel
modulo (division sin resta)
serie1.pow(serie2, fill_value= número)calculael
exponencial
serie1.ge(serie2)comparasiserie1 es mayorque
serie2 y devuelveTrue o False
serie1.le(serie2)comparasiserie1 es menorque
serie2 y devuelveTrue o False
Filtradobooleanos
serie< > >= <= == valordevuelveTrue o False segun
sicadacondicióncumplela condición
serie1[serie1 < > >= <= == valor]devuelvesolo los
valoresque cumplenla condición
np.nancrearvalornulo(NaN)
serie.isnull()devuelveTrue o False segunsilos
valoresexisteno son nulos("" no cuentacomonulo)
serie.notnull()devuelveTrue o False segunsilos
valoresexisteno son nulos("" no cuentacomonulo)
DataFrames
CrearDataFrames
df= pd.DataFrame(data, index, columns)
data: NumPy Array, diccionario, listade diccionarios
index: indiceque pordefectose asignacomo0-(n-1), n
siendoelnúmerode filas;
index = [lista]para asignar"etiquetas" (nombresde
filas)
column: nombrede las columnas; pordefecto0-(n-1);
columns =[lista]para ponermas nombres
df= pd.DataFrame(array)crearun dataframea partirde un
array con indices y columnaspordefecto
df= pd.DataFrame(diccionario)crearun dataframea partir
de un diccionario–loskeys son losnombresde las
columnas
DataFrames: cargade datos
Cargade datos
df= pd.read_csv("ruta/nombre_archivo.csv") crearun
dataframede un archivode Comma Separated Values
df= pd.read_csv("ruta/nombre_archivo", sep= ";")crearun
dataframede un csv sielseparadores ;
df= pd.read_csv("ruta/nombre_archivo", index_col= 0)
crearun dataframede un csv sielarchivoyatieneuna
columnaindice
df= pd.read_excel("ruta/nombre_archivo.xlsx") crearun
dataframede un archivode Excel
-sisale "ImportError:... openpyxl...",enelterminal:
pip3 install openpyxlo pip install openpyxl
df= pd.read_json("ruta/nombre_archivo.json")crearun
dataframede un archivode JavaScript Object Notation
(formatocrudo)
df= df['data'].apply(pd.Series)convertireldataframede
jsonenun formatolegible
df= pd.read_clipboard(sep='\t')crearun dataframede
datosenforma de dataframeenelclipboard; elseparador
podriaser \n ; , etc.
with open('ruta/nombre_archivo.pkl', 'wb') as f:
pickle.dump(df,f)pone losdatosde un dataframeen
elarchivopkl
pd.read_pickle('ruta/nombre_archivo.csv').head(n) leer n
filasy 5 columnasdel archivopickle
pd.read_parquet('ruta/nombre_archivo.parquet')leer un
archivoparquet
Guardadode datos
df.to_csv('ruta/nombre_archivo.csv') guardardataframe
comoarchivocsv
df.to_excel('ruta/nombre_archivo.xlsx') guardardataframe
comoarchivode Excel
df.to_json('ruta/nombre_archivo.json')guardardataframe
comoarchivode JSON
df.to_parquet('ruta/nombre_archivo.parquet')guardar
dataframecomoarchivode parquet
df.to_pickle('ruta/nombre_archivo.pkl')guardardataframe
comoarchivode pickle
ExcelWriter
withpd.ExcelWriter("ruta/archivo.ext") as writer:
df.to_Excel(writer, nombre_hoja= 'nombre')
guardar un dataframeen una hoja de Excel
Metodosde exploracion
df.head(n)devuelvelas primerasn lineasdel dataframe
df.tail(n)devuelvelas últimasn lineasdel dataframe
df.sample(n)devuelven filasaleatoriasde nuestro
dataframe, o uno pordefecto
df.shapedevuelveelnúmerode filas y columnas
df.dtypesdevuelveeltipode datosque hay encada
columna
df.columnsdevuelvelos nombres de las columnas
df.describedevuelveun dataframecon un resumen de los
principales estadísticos de las columnas numéricas
df.info()devuelveun resumensobreelno. de columnas,
nombresde columnas, numerode valoresno nulosy los
tiposde datosdf["nombre_columna"].unique()o
df.nombre_columna.unique()devuelveun array con los
valoresúnicos de la columna
df["nombre_columna"].value_counts()o
df.nombre_columna.value_counts()devuelveunaseriecon
elrecuentode valoresúnicos en orden descendente
df.duplicated().sum()devuelveelnumerode filas
duplicadas
Eliminarfilasduplicadas
df.drop_duplicates(inplace= True, ignore_index=True)
eliminafilasduplicadas; ignore_indexpara no tenerel
indiceencuenta
Tiposde datos
Tiposde datosenPandas:
-object
-int64
-float64
-datetime, timedelta[ns]
-category
-bool
df.dtypesdevuelveeltipode datosque hay
encadacolumna
df_tipo= df.select_dtypes(include = "tipo")
creaun dataframede las columnasdel tipode
datosespecificado
df['columna'] = df['columna'].astype('tipo',
copy = True, errors = 'ignore') convierteuna
columnaeneltipode datoespecificado
copy = True devuelveunacopia
copy = False*cuidado: loscambiosenlos
valorespuedenpropagarsea otrosobjetos
pandas*
errors = ignoreomitaexcepciones; encasode
error devuelveelobjetooriginal
errors = raisepermiteque se generen
excepciones
pd.options.display.max_columns = Noneejecutar
antes del df.head() para podervertodaslas
columnas
pd.set_option("display.precision", 2)
Sidetable: frecuenciasde datos
df.stb.freq(['columna'])devuelveun dataframecon
informacionsobrela frecuenciade ocurrenciade cada
categoríade un variable categorica
parametros:
thresh = nlimitalosvaloresmostradosa losmás
frecuentes hasta un umbral de n% cumulative y agrupando
los restantes bajo la etiqueta "other"
other_label= 'etiqueta'cambia la etiqueta'other'
value = 'columna'ordenalosresultadosporla columna
especificada
df.stb.freq(['columna1', 'columna2']) combinados
columnasy devuelelas frecuenciasde las subcategories
df.stb.missing(['columna']devuelveinformacionsobrela
frequenciade datosnulos
Valoresnulos
Identificarnulos
df.isnull()o df.isna()devuelveTrue o False segúnsi cada
valor es nulo o no
df.isnull().sum()o df.isna().sum()devuelveunaseriecon el
númerode valoresnulosporcolumnas
df_%_nulos= ((df.isnull().sum() / df.shape[0] *
100).reset_index()
df_%_nulos.columns= ['columna', '% nulos'] creaun dataframe
de losporcentajesde losvaloresnulos
Eliminarnulos
df.dropna(inplace= True, axis=b, subset=[lista_de_columnas],
how=)quitarnulos
how = 'any' | 'all' pordefecto'any': sihay algunvalorNA,
se eliminala fila o columna; all: sitodoslosvaloresson NA,
se eliminala fila o columna
subsetunacolumnao listade columnas
Tiposde nulos
np.nansignifica"not a number"; es un tiponumérico
Nonevalores nulos en columnas tipo string
NaTvalores nulos tipo datetime
valorestexto: "n/a", "NaN", "nan", "null" strings que
normalmentese conviertenautomaticamentea np.nan
99999 o00000 integers que se puedenconvertira nulos
Reemplazarnulos
df= pd.read_csv('archivo.csv', na_values= ['n/a'])
.fillna(np.nan)reemplazalosstrings 'n/a' con np.nanal
cargareldataframe
df.fillna(df[value=n, axis=b, inplace=True)reemplazar todos
los NaNdel dataframecon el valor que especifiquemos
df['columna'].fillna(df['columna'].median, axis=b,
inplace=True)reemplazar los nulos de una columna por la
mediana de esa columna
value=npordefectoNaN; es elvalorporelque queremos
reemplazarlosvaloresnulosque puedeser un escalar,
diccionario, serieo dataframe
axispordefecto0 (filas)
df.replace(valor_nulo, valor_nuevo, inplace=True, regex=False)
reemplazarlosnulosporelvalornuevo
Imputacionde nulos
from sklearn.imputeimport SimpleImputer
imputer = SimpleImputer(strategy='mean', missing_values=
np.nan)iniciala instanciadel metodo, especificandoque
queremosreemplazarlosnulosporla media
imputer = imputer.fit(df['columna1'])aplicamoselimputer
df['media_columna1'] = imputer.transform(df[['price']])rellena
losvaloresnulosseguncomohemosespecificado
from sklearn.experimentalimport enable_iterative_imputer
from sklearn.imputeimport IterativeImputer
imputer = IterativeImputer(n_nearest_features=n,
imputation_order='ascending')creala instancia
n_nearest_featurespordefectoNone; numerode columnasa
utilizarpara estimarlosvaloresnulos
imputation_orderpordefectoascendente; elordende imputacion
imputer.fit(df_numericas) aplicamoselimputer
df_datos_trans= pd.DataFrame(imputer.transform(df_numericas),
columns = df_numericas.columns)creaun dataframede losdatos
transformados; metemosestascolumnaseneldataframeoriginal
from sklearn.imputeimport KNNImputer
imputerKNN= KNNImputer(n_neighbors=5) creala instancia
imputerKNN.fit(df_numericas)
df_knn_imp= pd.DataFrame(imputerKNN.transform(df_numericas),
columns = numericas.columns)creaun dataframede losdatos
transformados; metemosestascolumnaseneldataframeoriginal
Metodosde estadistica
df['columna'].mean() | mode() | median() | var() | std()
calcula la media/moda/mediana/variación/desviación
estándar de los valores de una columna
df['columna1'].corr(df['columna2']calculala
correlacionentre dos variables
matriz_correlacion= df.corr()creaunamatrizmostrando
las correlacionesentre todoslosvariables
df_crosstab= pd.crosstab(df['columna1'],
df['columna2'], normalize= True, margins= True)
normalizemuestra los valores en porcentajes (por uno)
marginsmuestra los totales y subtotales
media_ponderada= np.average(df['columna'], weights= w)
calcula la media ponderada según los pesos
percentil_n= np.percentile(df['columna'], n)saca el
valor en el percentil n
q3, q1 = np.percentile(df["columna"], [75, 25])saca los
tercer y primer cuartiles
Outliers
Calculartresdesviacionesestandares:
media = df.column.mean()
desviacion= df.column.std()
lcb= media –desviacion* 3
ucb= media + desviacion* 3
EliminarOutliers
outlier_step= 1.5 * IQRcalcularoutlier step
outliers_data= df[(df['columna'] < Q1 –
outlier_step) | (df['columna'] > Q3 +
outlier_step)] identificardatosfueradel
rangodel maximohasta elminimo
lista_outliers_index= list(outliers_data.
index)crearunalistade losindices de las
filascon outliers
if outliers_data.shape[0] > 0:
dicc_indices[key] =
(list(outliers_data.index))crearun
diccionariode losindices de las filascon
nulos; se puedehaceriterandoporcolumnas
valores= dicc_indices.values()sacartodos
losvalorese.g. todoslosindices
valores= {indicefor sublistain valoresfor
indicein sublista}set comprehension para
eliminarduplicados
df_sin_outliers= df.drop(df.index[list
(valores)])crearnuevo dataframesin outliers
ReemplazarOutliers
fork, v in dicc_indices.items():
media = df[k].mean()
fori in v:
df.loc[i,k] = media reemplazar
outlierspor la media

4. Pandas
Union de datos
.concat()unirdataframescon columnasencomun
df_union= pd.concat([df1, df2, df3], axis=b, join =
'inner/outer', ignore_index= True/False)
parametros:
axis = 0uneporcolumnas–losdataframesvan uno encimadel
otro; las columnastienenque ser de formatoscompatible
axis = 1uneporfilas–losdataframesvan uno al ladodel otro;
losdatosdebenser relacionadospara que tengasentido
join = 'inner'solo se quedanelementosque aparecenentodoslos
dataframes
join = 'outer'se quedatodolosdatosde todoslosdataframes
ignore_index= True/Falsepordefectoes False; sies True no usa
las índicespara la union (porejemplopara union porelaxis 0)
.merge()unirlas columnasde un dataframea otro
df_nuevo= df1.merge(df2, on = 'columna') inner merge
df_nuevo= pd.merge(left = df1, right = df2, how='left', left_on=
'columna_df1', right_on= 'columna_df2')left merge
parametros:
how = 'left' | 'right' | 'outer' | 'inner' | 'cross'
on= columna| [columna1, columna2, etc]silas columnasse llaman
igualenlosdos dataframes
left_on= columna_df1| right_on= columna_df2 para especificar
pordondehacerelmerge
suffixes = ['left', 'right'] pordefectonada, elsufijoque
apareceraencolumnasduplicadas
.join()unirdataframesporlosindices
df_nuevo= df1.join(df2, on = 'columna', how = 'left') inner merge
parametros:
how = 'left' | 'right' | 'outer' | 'inner' pordefectoleft
on= columnala columnao indiceporelque queremoshacerel
union; tienenque tenerelmismonombreenlosdos dataframes
lsuffix= 'string'| rsuffix= 'string'pordefectonada, el
sufijoque apareceraencolumnasduplicadas
Apply
apply() toma una función como argumento y la aplica a lo
largo de un eje del DataFrame
df['columna_nueva'] = df['col_1'].apply(función)
crea una columna nueva con los valores de otra columna
transformados según la función indicada
df['columna_nueva'] = df['col_1'].apply(lambda x:
x.método() ifx > 1)
crea una columna nueva con los valores de otra columna
transformados según la lambda indicada
df['columna_nueva'] = df.apply(lambda nombre:
función(nombre['columna1'], nombre['columna2']), axis =
b)crea una columna nueva usando una función que coge dos
parámetros (columna 1 y columna2)
df.applymap(funcion, na_action=None, **kwargs)acepta y
devuelve un escalar a cada elemento de un dataframe; se
tiene que aplicar a todo el DataFrame
df['columna'] = df['columna'].map(mapa, na_action=
'ignore) reemplaza valores de la columna según el mapa,
que puede ser un diccionario o una serie; solo se puede
aplicar a una columaen particular.
apply() con datetime
df['columna_fecha'] = df['columna_fecha']
.apply(pd.to_datetime)cambia una columna de datos tipo
fecha en el formato datetime
defsacar_año(x):
returnx.strftime("%Y")
df['columna_año'] = (df['columna_fecha'] .apply
(sacar_año)crea una columna nueva del año solo usando un
método de la librería datetime; ("%B") para meses
Cambiarvalores
Reemplazarvaloresbasadosenindices y condiciones:
indices_filtrados= df.index[df["columna"] == "valor"]
for indicein indices_filtrados:
df["nombre_columna"].iloc[indice] = "valor_nuevo"
ReemplazarvaloresbasadosenmetodosNumPy:
df.replace(to_replace= valor, value = valor_nuevo,
inplace= True)reemplazaciertovalorporotroque
especificamos
df["nombre_columna"].replace(to_replace= valor,
value = valor_nuevo, inplace= True)reemplazacierto
valorenunacolumnaporotroque especificamos
df[["columna1", "columna2"]] = df[["columna1",
"columna2"]].replace(r"string", "string", regex=True)
cambiarun patron/string porotroenmultiples
columnas
df["nombre_columna"] = df["nombre_columna"] + x
reemplazalosvaloresde la columnaporelvalor+ x
(o otrovalorque indicamos)
Filtradosde datos
Metodosde pandas de filtrar
df_filtrado=
df[df["nombre_columna"].isin(iterable)]extraelas
filascuyasvaloresde la columnanombradaestánen
eliterable(unalista, serie, dataframeo
diccionario)
df_filtrado= df[df["nombre_columna"].str.contains
(patron, regex = True, na= False)]extraelas filas
cuyasvaloresde la columnanombradacontenienenel
patron de regex
df_filtrado= df[df["nombre_columna"].str.contains
("substring", case = False, regex = False)] extrae
las filascuyasvaloresde la columnanombrada
contienenelsubstring, no siendocase sensitive
df_filtrado= df[df["nombre_columna"].str.contains
("substring", case = False, regex = False)] extrae
las filascuyasvaloresde la columnanombrada
contienenelsubstring, no siendocase sensitive
df[pd.notnull(df["nombre_columna"])]devuelvelas
filasque no tienevaloresnulosenla columna
especificada
Cambiarcolumnas
lista_columnas= df.columns.to_list()creaunalista
de losnombresde las columnasdel dataframe
df.set_index(["nombre_columna"], inplace= True)
estableceelíndiceutilizandouno o mas columnas;
puedesustituiro ampliarun índiceexistente
inplace= Trueloscambiossobreescribensobreeldf
* cuandounacolumnase cambia a índiceyano es
columna*
df.reset_index(inplace= True)quitarunacolumna
comoindicepara que vuelvaa ser columna; creaun
dataframede unaserie
Renombrarcolumnas
df.rename(columns = {"nombre_columna":
"nombre_nueva"}, inplace= True)cambia losnombres
de unao mas columnas
ejemplode dictcomprehension para creardiccionario
sobrelas columnasexistentesde un dataframe:
diccionario= {col : col.upper() for col in
df.columns}
df.rename(columns = diccionario, inplace= True)
cambia losnombresde las columnassegúnel
diccionario
Eliminarcolumnas
df.drop(columns = ["columna1", "columna2"], axis =
b, inplace=True)eliminarunao mas columnaso filas
segunlo que especificamos
Reordenarcolumnas
df= df.reindex(columns = lista_reordenada)cambia el
ordende las columnasdel dataframesegunelordende
la listareordenada
Subsets: loc e iloc
df.loc["etiqueta_fila", "etiqueta_columna"]
devuelveelcontenidode un campo enunacolumna
de unafila
df.loc["etiqueta_fila",:]devuelvelosvalores
de todaslas columnasde unafila
df.loc[:,"etiqueta_columna"]devuelvelos
valoresde todaslas filasde unacolumna
df.iloc[indice_fila, indice_columna]devuelveel
contenidode un campo enunacolumnade unafila
df.iloc[indice_fila, :]devuelvelosvaloresde
todaslas columnasde unafila
df.iloc[:,indice_columna]devuelveelcontenido
de un campo enunacolumnade unafila
df.loc[[lista_etiquetas_filas],
[lista_etiquetas_columnas]]devuelveel
contenidode variasfilas/ variascolumnas
df.loc[[lista_indices_filas],
[lista_indices_columnas]]devuelveelcontenido
de variasfilas/ variascolumnas
-se puedeusar losindices/rangosde las listas
[start:stop:step] dentrode losloc/iloc
df.loc[df.etiqueta> x]seleccionardatosbasado
enunacondiciónusandooperadorescomparativos
df.loc[(df.etiqueta> x) & (df.etiqueta== y)]
seleccionardatosque tienenque cumplirlas dos
condiciónes(and)
df.loc[(df.etiqueta> x) | (df.etiqueta== y)]
seleccionardatosque tienenque debencumplir
unade las dos condiciones(or)
df.iloc[list(df.etiqueta> x), :]ilocno acepta
unaSerie booleana; hay que convertirlaenlista
variable_df.head(n)devuelvelas n primeras
filasdel df, o 5 pordefecto
Crearcolumnas
Creacionde ratios
df["columna?ratio"] = df.apply(lambda df: df["columna1"]
/ df["columna2"], axis = 1)
Creacionde porcentajes
def porcentaje(columna1, columna2):
return (columna1 * 100) / columna2
df["columna_%"] = df.apply(lambda df:
porcentaje(df["columna1"], datos["columna2"]), axis = 1)
df["nueva_columna"] = np.where(df["nombre_columna"] > n,
"categoria_if_true", "categoria_if_false")creaunanueva
columnabasadaenunacondición
df["nueva_columna"] = np.select(lista_de_condiciones,
lista_de_opciones)creaunanuevacolumnacon losvalores
basadosenmultiples condiciones
df["columna_nueva"] = pd.cut(x = df["nombre_columna"],
bins = [n,m,l..], labels = ['a', ‘b’, ‘c’]) separalos
elementosde un dataframeendiferentesintervalos(n-m,
m-l, etc), creandounacolumnanuevaque indica encual
intervalocaeelvalor; con labels se puedeasignarun
string a cadaintervalo
Crearcolumnas
df["nueva_columna"] = (df["etiqueta_columna"] + x)crea
unanuevacolumnabasadaenotra
df= df.assign(nueva_columna= df["etiqueta_columna] + x)
creaunanuevabasadaenotra
df= df.assign(nueva_columna= [lista_valores])creauna
nuevacolumnade unalistade valores*tieneque ser de
la mismalongitudcomoelnúmerode filasdel dataframe*
df.insert(indice_nueva_columna, "nombre_columna",
valores) creaunanuevacolumnaenla indiceindicada
allow_duplicates= Trueparametrocuandoqueremos
permitircolumnasduplicadas(pordefectoes False)
Group By
df_groupby= df.groupby("columna_categoría")creaun objeto
DataFrameGroupBy; agrupalosvaloressegunlas categoríasde los
valores de la columna indicada (o múltiples columnas en una lista)
df_groupby.ngroupsdevuelveelnumerode grupos
df_groupby.groupsdevuelveun diccionariodondeloskeys son las
categoríasy losvaloresson listasde losíndicesde cada
elementoenla categoría
df_grupo1 = df_groupby.get_group("grupo1")devuelveun dataframe
con losresultadosde un grupo(la categoriaindicadacomogrupo1)
Cálculoscon groupby:
df_nuevo= df.groupby("columna_categoría").mean()devuelveun
dataframecon la media de todaslas columnasde valoresnuméricos,
por categoría
df_nuevo= df.groupby("columna_categoría")["columna1"].mean()
devuelveun dataframecon la media de la columnaespecificada
count()número de observaciones
no nulas
describe()resumen de los
principales estadísticos
sum()suma de todos los valores
mean()media de los valores
df_nuevo= df.groupby("columna_categoría", dropna= False)
["columna_valores"].agg([nombre_columna= ‘estadistico1’,
nombre_columna2 = ‘estadistico2’]) añadecolumnas con los cálculos
de los estadísticos especificados
dropna= Falsepara tener en cuenta los Nanen los cálculos (por
defecto es True)
Filtradosde datos
Filtradoporunacolumnacon operadoresde
comparación
df_filtrado= df[df["nombre_columna"] == valor]
extraelas filasdondeelvalorde la columna
igualal valordado
Filtradopormultiples columnascon operadores
logicos
df_filtrado= df[(df["columna1"] == valor) &
(df["columna2"] == valor) & (df["columna3"] > n
valor)]extraelas filasdondelosvaloresde
las columnascumplanlas condiciónesen
parentesis
df_filtrado= df[(df["columna1"] == valor) |
(df["columna1"] == valor)extraelas filasdonde
losvaloresde las columnascumplancon una
condiciónu otra
df_filtrado= ~(df[df["columna1"] == valor])
extraelas filasdondelosvaloresde las
columnasNO cumplancon la condición
datetime
importdatetime
datetime.now()o datetime.today()devuelve la fecha
actual
timedelta(n)representa una duración la diferencia
entre dos instancias; n es un numero de días pero se
puede especificar days, seconds o microseconds
ayer = datetime.now() -timedelta(1)
ayer = datetime.strftime(ayer, '%Y-%m-%d')
df["fecha"] = ayercrea una columna con la fecha de
ayer
strftime()nos permite crear formatos mas legibles de
datos de tipo datetime
datetime.strftime(variable_fecha, '%Y-%m-%d')formatea
la fecha al formato indicado
Sintaxis de strftime()
%adía de la semana abreviada (Sun)
%Adía de la semana (Sunday)
%wdía de la semana de 0 (domingo) a 6 (sábado)
%bmes abreviada (Sep)
%Bmes (September)
%mmes con un zero (09)
%-mmes como float
%ddía del mes con un zero (08)
%-ddía del mes como float (8)
%yaño sin siglo (99)
%Yañocon siglo (1999)
%Zzona horaria (UTC)
%pAM o PM
%cfecha y hora
%xfecha
%Xhora (07:06:05)
%Hhora con zero (07)
%-Hhora como float (7)
%Mminuto con zero (06)
%-Mminuto como float (6)
%Ssegundos con zero (05)
%-Ssegundos como float (5)

5. Matplotlib y Seaborn
Matplotlib
Gráficas
import matplotlib.pyplotas plt
plt.rcParams["figure.figsize"] = (10,8)
plt.figure(figsize= (n,m))iniciaunagrafica
dibujandoelmarcode la figura; n es la anchuray
m es la altura, enpulgadas
plt.show()muestrala figura
Gráficasbásicas
Bar plot
plt.bar(df["columna1"], df["columna2"])creaun
diagramade barras dondelosejesson: columna1 –
x, columna2 –y
Horizontal bar plot
plt.barh(df["columna1"], df["columna2"])creauna
diagrammade barras horizontalesdondelosejes
son: columna1 –x, columna2 –y
Stackedbar plot
plt.bar(x, y, label = 'etiqueta')
plt.bar(x2, y2, bottom = y, label = 'etiqueta2')
creaunadiagramade barras apiladaspara
visualizardos variables juntas; y indica la barra
de referencia
Scatter plot
plt.scatter(df["columna1"], df["columna2"])crea
unagráficade dispersióndondelosejesson:
columna1 –x, columna2 –y
Gráficasestadísticas
Histogram
plt.hist(x = df['columna1'], bins = n)creauna
histogramaque muestrala frecuenciasde una
distribuciónde datos; dondex es la variable de
interésy n es elnúmerode barras
Box Plot
plt.boxplot(x = df['columna1'])creaun diagramade
cajaspara estudiarlas caracteristicasde una
variable numerica; x es la variable de interés
-el mínimo es lo mismo que Q1 -1.5 * IQR
-el máximo es lo mismo que Q3 + 1.5 * IQR
Pie Chart
plt.pie(x, labels = categorias, radius = n)creaun
gráficode sectores dondex es la variable de
interés(debeestaagrupadoporcategorias); n es
eltamaño
Violin Plot
plt.violinplot(x, showmedians= True, showmeans=
True)creaun diagramade violin dondex es la
variable de interésy muestrala medianay la media
Personalización
Colores
color= "color"estableceelcolorde la grafica
facecolor= "color"estableceelcolordel relleno
edgecolor= "color"estableceelcolorde losbordes
ColoresenScatter Plots:
c= df['columna'].map(diccionario)
diccionario= {"valor1": "color1", "valor1": "color1"}
listade colores
Paletas Seaborn:
Accent', 'Accent_r', 'Blues', 'Blues_r', 'BrBG', 'BrBG_r',
'BuGn', 'BuGn_r', 'BuPu', 'BuPu_r', 'CMRmap', 'CMRmap_r',
'Dark2', 'Dark2_r', 'GnBu', 'GnBu_r', 'Greens',
'Greens_r', 'Greys', 'Greys_r', 'OrRd', 'OrRd_r',
'Oranges', 'Oranges_r', 'PRGn', 'PRGn_r', 'Paired',
'Paired_r', 'Pastel1', 'Pastel1_r', 'Pastel2',
'Pastel2_r', 'PiYG', 'PiYG_r', 'PuBu', 'PuBuGn',
'PuBuGn_r', 'PuBu_r', 'PuOr', 'PuOr_r', 'PuRd', 'PuRd_r',
'Purples', 'Purples_r', 'RdBu', 'RdBu_r', 'RdGy',
'RdGy_r', 'RdPu', 'RdPu_r', 'RdYlBu', 'RdYlBu_r',
'RdYlGn', 'RdYlGn_r', 'Reds', 'Reds_r', 'Set1', 'Set1_r',
'Set2', 'Set2_r', 'Set3', 'Set3_r', 'Spectral',
'Spectral_r', 'Wistia', 'Wistia_r', 'YlGn', 'YlGnBu',
'YlGnBu_r', 'YlGn_r', 'YlOrBr', 'YlOrBr_r', 'YlOrRd',
'YlOrRd_r', 'afmhot', 'afmhot_r', 'autumn', 'autumn_r',
'binary', 'binary_r', 'bone', 'bone_r', 'brg', 'brg_r',
'bwr', 'bwr_r', 'cividis', 'cividis_r', 'cool', 'cool_r',
'coolwarm', 'coolwarm_r', 'copper', 'copper_r', 'crest',
'crest_r', 'cubehelix', 'cubehelix_r', 'flag', 'flag_r',
'flare', 'flare_r', 'gist_earth', 'gist_earth_r',
'gist_gray', 'gist_gray_r', 'gist_heat', 'gist_heat_r',
'gist_ncar', 'gist_ncar_r', 'gist_rainbow',
'gist_rainbow_r', 'gist_stern', 'gist_stern_r',
'gist_yarg', 'gist_yarg_r', 'gnuplot', 'gnuplot2',
'gnuplot2_r', 'gnuplot_r', 'gray', 'gray_r', 'hot',
'hot_r', 'hsv', 'hsv_r', 'icefire', 'icefire_r',
'inferno', 'inferno_r', 'jet', 'jet_r', 'magma',
'magma_r', 'mako', 'mako_r', 'nipy_spectral',
'nipy_spectral_r', 'ocean', 'ocean_r', 'pink', 'pink_r',
'plasma', 'plasma_r', 'prism', 'prism_r', 'rainbow',
'rainbow_r', 'rocket', 'rocket_r', 'seismic', 'seismic_r',
'spring', 'spring_r', 'summer', 'summer_r', 'tab10',
'tab10_r', 'tab20', 'tab20_r', 'tab20b', 'tab20b_r',
'tab20c', 'tab20c_r', 'terrain', 'terrain _r', 'turbo',
'turbo_r', 'twilight', 'twilight_r', 'twilight_shifted',
'twilight_shifted_r', 'viridis', 'viridis_r', 'vlag',
'vlag_r', 'winter', 'winter_r
palette='light:nombre_paleta'|'dark:nombre_paleta'
Marcadores
marker = 'tipo'estableceeltipode marcador; se usacon
plt.scattery plt.plot
"." Punto
"," Pixel
"o" Circulo
"v" Triánguloabajo
"^" Triánguloarriba
"<" Triánguloizquierda
">" Triánguloderecha
"8" Octágono
"s" Cuadrado
"p" Pentágono
"P" Más (relleno)
"*" Estrella
"h" Hexágono1
"H" Hexágono2
"+" Más
"x" x
"X" x (relleno)
"D" Diamante
"d" Diamante fino
Seaborn gráficas
Line plot
fig = sns.lineplot(x = 'columna1', y = 'columna2', data =
df, ci = None)creaunagráficalineal dondelosejesson:
columna1 –x, columna2 –y
ci = Nonepara que no muestraelintervalode confianzade
losdatos
hue = columnaopcional; muestralineasendiferentes
coloresporcategoriassegununavariable
Scatter plot
fig = sns.scatterplot(x = 'columna1', y = 'columna2', data
= df, hue = 'columna')creaunagráficade dispersión
Swarmplot
fig = sns.swarmplot(x = 'columna1', y = 'columna2', data =
df, hue = 'columna')creaunagráficade dispersión donde
los marcadores no se solapan
Count plot
fig = sns.countplot(x = 'columna1', data = df, hue =
'columna')creaunagráficade barras con la cuentade una
variable categórica; se puedeespecificarsolo una
variable enla ejex o y, mas unavariable opcionalcon
hue
Histogram
fig = sns.histplot(x = 'columna1', data = df, hue =
'columna3', kde= True, bins = n)creaunahistogramaque
muestrala frecuenciasde unadistribuciónde datos; donde
x es la variable de interésy n es elnúmerode barras
kde= True muestraunacurvade la distribucion
Box Plot
fig = sns.boxplot(x = 'columna1', data = df, hue =
'columna')creaun diagramade cajas; x es la variable de
interés; por defecto se muestra con orientación horizontal
–usar eje y para orientación vertical
Catplot
fig = sns.catplot(x = 'columna1', y = 'columna2', data =
df, hue = 'columna', kind = 'tipo') creaunagráficaque
muestrala relacionentre unavariable categoricay una
variable numerica
kind= 'box' | 'bar' | 'violín' | 'boxen' | 'point' por
defecto es stripplot
Pairplot
fig = sns.pairplot(data = df, hue = 'columna', kind =
'tipo')crealos histogramas y diagramas de dispersión de
todas las variables numéricas de las que disponga el
datasetcon el que estemos trabajando; huees opcional
kind= 'scatter' | 'kde' | 'hist' | 'reg' | 'point' por
defecto es scatter
Heatmap
sns.heatmap(df.corr(), cmap= 'color_palette', annot=
True, vmin= -1, vmax= 1)creaun heatmap con unaescala
de coloresque reflejalosvaloresde correlacion
annot= True para que aparezcanlosvalores
vmin/vmaxestablecen la escala de color
Regplot
fig = sns.regplot(x = 'columna1', y = 'columna2', data =
df, scatter_kws= {'color':'blue'}, line_kws= {'color';
'blue'})creaun scatterplotmas la línea de regresión; nos
permite encontrar la mejor función de la recta que permite
predecir el valor de una variable sabiendo los valores de
otra variable
Jointplot
sns.jointplot(x = 'columna1', y = 'columna2', data = df,
color= 'blue', kind = 'tipo')creaun scatterploto
regplotcon histogramas pegados en los lados para cada
variable
Exportarfiguras
plt.savefig('nombre_de_la_figura.extension')
Usosde lostiposde gráficas
Datoscategóricos
Barras
-muestrala relaciónentre una variable numérica y
categórica
-barplotsi tienes una variable numérica
-countplotpara contar registros/filasporcategoría
Pie chart/quesitos
-determinaciónde frecuencias
Datos numéricos
Líneas
-tendencias/evoluciónde unao másvariables numéricas
(normalmentesobreun periódode tiempo)
Histograma
-distribución de una variable numérica
Boxplot
-representación de las medidas de posición más usadas:
mediana, IQR, outliers
Scatterplot
-muestra la relación entre dos variables numéricas
Regplot
-scatterplotcon una línea de regresión
Swarmplot
-tipo de gráfica de dispersión para representar
variables categóricas; evita que se solapan los
marcadores
Violinplot
-para visualizar la distribución de los datos y su
densidad de probabilidad
Pairplot
-para representar múltiples relaciones entre dos
variables
Heatmap
-evaluar la correlación entre las variables en una
matriz de correlación
Personalización
Titulos
plt.title(label = "titulo")asignarun tituloa
la gráfica
Ejes
plt.xlabel("etiqueta_eje_x")asignarnombreal ejex
plt.ylabel("etiqueta_eje_y")asignarnombreal ejey
plt.xlim([n,m]estableceelrangodel ejex; donden es
elmínimoy m es el máximo
plt.ylim([n,m])estableceelrangodel ejey; donden
es elmínimoy m es el máximo
fig.set(xlabel= 'etiqueta_eje_x', ylabel=
'etiqueta_eje_y')asignarnombrea losejes
fig.set_title('titulo')asignarun tituloa la gráfica
fig.set_xlabel(xlabel= "etiqueta_eje_x", fontsize= n)
fig.set_ylabel(ylabel= "etiqueta_eje_y", fontsize= n)
fig.set(xticks= [1, 2, 3])
fig.set(yticks= [1, 2, 3, 4, 5])
fig.set(xticklabels= ['0%','20%', '40%', '60%', '80%',
'100%'])
fig.set(yticklabels= ['cat1', 'cat2', 'cat3'])
fig.set_xticklabels(labels = [0, 500, 1000, 1500],
size=n)
fig.set_yticklabels(labels = fig.get_yticklabels(),
size=n)
Para poneretiquetasencimade las barras
for indice, valorin enumerate(df["col"]):
plt.text(valor+1, indice, valor,
horizontalalignment='left', fontsize= 16)
order= df.sort_values('columnay', ascending=False)
['columnax']
sns.set(font_scale=2)
plt.rcParams.update({'font.size': 22}) font size
general
Leyendas
plt.legend(labels = ['label1', 'label2', etc) muestra
la leyendacuandomostramosla figura
plt.legend(bbox_to_anchor= (1, 1)colocala leyendaen
relacióncon losejes
Quitarbordes
fig.spines[["top", "right"]].set_visible(False)
Linea de tresdesviacionesestandares:
fig.axvline(x=valor, c='color', label='valor')
fig.axvline(x=valor, c='color', label='valor')
Cuadricula
plt.grid()creaunacuadrículaal fondo de la figura;
cogelosparámetros:
color= "color"
linestyle= "solid"| "dashed"| "dashdot" | "dotted"
linewidth = nestablecela anchurade la linea
Multigráficas
fig, ax= plt.subplots(numero_filas, numero_columnas)
crearunafiguracon multiples graficas; fig es la
figuray axes un array con subplots comoelementos
se establececomoes cadagraficacon losindices:
ax[indice].tipo_grafica(detallesde la grafica)
ax[indice].set_title('titulo')
ax[indice].set_xlabel('xlabel')
ax[indice].set_ylabel('ylabel')
ax[indice].set_xlim(min, max
ax[indice].set_ylim(min, max)
ax[indice].set_xticklabels(labels = df['column'],
rotation = n)para cambiarlosnombresy/o la rotacion
de las etiquetasde losvaloresenlosejes
Crear subplots enun for loop
fig, axes = plt.subplots(numero_filas, numero_columnas,
figsize= (n, m))
axes = axes.flatten()
for col in df.columns:
fig = sns.plot(x=col, data=df, ax=axes[i]
Crear subplots en un for loop
fig, axes = plt.subplots(numero_filas, numero_columnas,
figsize = (n, m))

6. NumPy (Numerical Python)
Creararrays
Creararrays de listas
array = np.array(lista, dtype= tipo)creaun array
unidimensional de unalista
array = np.array([lista1, lista2])creaun array
bidimensional de dos listas
array = np.array([listadelistas1, listadelistas2]) crea
un array bidimensional de dos listas
Crearotrostiposde arrays
array = np.arange(valor_inicio, valor_final, saltos)crea
un array usandoelformato[start:stop:step]
array = np.ones(z,y,x)creaun array de todounosde la
forma especificada
array2 = np.ones_like(array1)creaun array de todounos
de la forma basadaenotraarray
array = np.zeros(z,y,x)creaun array de todozeros de la
forma especificada
array2 = np.zeros_like(array1)creaun array de todo
zeros de la forma basadaenotraarray
array = np.empty((z,y,x), tipo)creaun array vaciocon
datospordefectotipofloat
array2 = np.empty_like(array1)creaun array vaciacon la
forma basadaenotraarray
array = np.eye(z,y,x, k = n)creaun array con unosen
diagonal empezandoenla posicionk
array = np.identity(x)creaunamatrizde identidadcon
ceros enfilasy unosenla diagonal, de forma cuadrada
Indices, Subsets, Metodosde Arrays
Indices de arrays
array[i]devuelvela indicei; las indices de los
arrays unidimensionalesfuncionanigualque las listas
array[i, j]o array[i][j]devuelveelelementode la
columnaj de la fila i
array[:,:n]seleccionartodaslas filasy las columnas
hasta n-1
array[h, i, j]o array[h][i][j]devuelveelelementode
la columnaj de la fila idel array h
array[h][i][j] = ncambiarelvalordel elementoen
estaposicional valorn
Subsets
array > ndevuelvela forma del array con True o False
segúnsielelementocumplecon la condicióno no
array[array > n]devuelveun subset: todoslosvalores
que cumplenla condiciónenunalistadentrode un
array
array[(array > n) & (array < m)] devuelveun subset:
todoslosvaloresque cumplenlas condicionesenuna
listadentrode un array; se puedeusar | para "or"
Metodosde arrays
nuevo_array= array.copy()creaun a copiadel array
np.transpose(array_bidimensional)cambia losfilasdel
array a columnasy las columnasa filas
np.transpose(array_multidimensional)cambia elnúmero
de columnasal númerode arrays y viceversa; elnúmero
de filasno cambia
np.transpose(array_multidimensional, (z,y,x))hacela
transposicionsegunlo que especificemosusandolas
posicionesde la tupla(0,1,2) de la forma original
array = np.arange(n).reshape((y,x))creaun array
usandoreshape para definirla forma
array = np.reshape(array, (z,y,x))creaun array con
losvaloresde otroarray usandoreshape para definir
la forma
array = np.swapaxes(array, posicion, posicion)
intercambiados ejesde unamatrizusandolas
posiciones(z=0,y=1,x=2) de la forma original
Otrasoperaciones
np.sort(array)devuelve un array con los valores de
cada fila ordenados en orden ascendente por defecto
np.sort(array, axis = 0)devuelve un array con los
valores de cada columna ordenados en orden ascendente
np.sort(-array)devuelve un array con los valores de
cada fila ordenados en orden descendente
np.round(array, decimals = x)devuelve un array con los
valoresdel array redondeadosa x decimales
np.round(array, decimals = x)devuelve un array con los
valoresdel array redondeadosa x decimales
np.where(array > x)devuelve losindices de losvalores
que cumplanla condición, porfila y columna
Operacionescon arrays
np.add(array1, array2)sumados arrays
np.subtract(array1, array2)restaelarray2 del array1
np.multiply(array1, array2)multiplicados arrays
np.divide(array1, array2)divide elarray1 porel
array2
array + n, n * array, etc. -operadoresalgebraicos
Operacionesestadísticasy matemáticas
Operacionesestadísticasy matemáticas
El parametroaxis enarrays bidimensionales:
axis = 0columnas
axis = 1filas
-siespecificamoselaxis, la operacióndevuelveel
resultadoporcadafila o columna.
Por ejemplo:
np.sum(array, axis = 0)devuelve un array con la
suma de cadafila
El parametroaxis enarrays multidimensionales:
axis = 0dimensión
axis = 1columnas
axis = 2filas
-siespecificamoselaxis, la operacióndevuelveel
resultadoporcadadimensión, fila o columna.
Por ejemplo:
np.sum(array_3D, axis = 0)devuelveun array de una
matrizcon la sumade todaslas matrices
np.sum(array_3D, axis = 1)devuelveun array donde
las filascontienenlas sumasde las columnasde
cadamatriz
Operaciones con parámetro del axis:
np.sum(array_3D)devuelvela sumade todoslos
elementosde losmatrices
np.mean(array)devuelvela media de todoelarray
np.std(array)devuelvela desviaciónestándar de
todo
np.var(array)devuelvela varianzade valoresde
todo
np.min(array)devuelveel valor mínimo del array
np.max(array)devuelveel valor máximo del array
np.sum(array)devuelve la suma de los elementos del
array
np.cumsum(array)devuelve un array con la suma
acumulada de los elementos a lo largo del array
np.cumprod(array)devuelve un array con la
multiplicación acumulada de los elementos a lo largo
del array
Operaciones sin parámetro del axis:
np.sqrt(array)devuelve un array con la raíz
cuadrada no negativa de cada elemento del array
np.exp(array)devuelve un array con el exponencial
de cada elemento del array
np.mod(array1, array2)devuelve un array con el
resto de la división entre dos arrays
np.mod(array1, n)devuelve un array con el resto de
la división entre el array y el valor de n
np.cos(array)devuelveun array con elcosenode
cadaelementodel array
np.sin(array)devuelveun array con elsenode cada
elementodel array
np.sin(array)devuelveun array con la tangentede
cadaelementodel array
Operacionesde comparaciónenarrays
bidimensionales
np.any(array > n)devuelveTrue o False segunsi
cualquiervalordel array cumplacon la condicion
np.any(array > n, axis = b)devuelveun array con
True o False porcadacolumnao fila segúnsialgún
valorde la fila o columnacumplacon la condición
np.all(array > n)devuelveTrue o False segunsi
todoslosvaloresdel array cumplacon la condicion
np.all(array > n, axis = b)devuelveun array con
True o False porcadacolumnao fila segúnsitodos
losvaloresde la fila o columnacumplancon la
condición
Funcionesde conjuntos
np.unique(array)devuelveun array con losvaloresúnicos
del array ordenados
np.unique(array, return_index=True)devuelveun array con
losvaloresúnicosdel array ordenadosy un array con la
posiciónde la primera instancia de cada valor
np.unique(array, return_inverse=True)devuelveun array con
losvaloresúnicosdel array ordenadosy un array con las
posicionesde cadaelementode cadavalor
np.unique(array, return_counts=True)devuelveun array con
losvaloresúnicosdel array ordenadosy un array con el
númerode vecesque aparececadavalor
np.unique(array, axis = b)devuelveun array con los
valoresúnicosordenadosde las filaso columnas
Funcionespara arrays unidimensionales
np.intersect1d(array1, array2) devuelveun array con los
valoresúnicosde loselementosencomúnde dos arrays
np.intersect1d(array1, array2, return_indices=True)
devuelveun array con losvaloresúnicosde loselementos
encomúnde dos arrays y arrays con losíndices de cada
valor, por array
np.union1d(array1, array2) devuelveun array ordenado con
los elementos resultantes de unir dos arrays(valores
únicos)
np.in1d(array1, array2)devuelveun array con True o False
porcadaelementode array1 segúnsiapareceelmismovalor
enarray2
np.setdiff1d(array1, array2) devuelveun array ordenadocon
losvaloresúnicosque estánenarray1 perono enarray2
np.setxor1d(array1, array2) devuelveun array ordenadocon
losvaloresúnicosque NO estánencomúnde losdos arrays
NumPy Random
np.random.seed(x)establecela semillaaleatoriadel
generadorde númerosaleatorios, para que las funciones
random que van despuéssiemprecogeránlosmismosvalores
"aleatorios"
Creararrays con valoresaleatorios
array = np.random.randint(inicio, final, forma_matriz)
creaun array de númerosaleatoriosentre dos valores;
forma_matriz: (z,y,x)
z: númerode arrays
y: númerode filas
x: númerode columnas
array = np.random.randint(inicio, final)devuelveun
númeroaleatorioenelrango
array = np.random.rand(z,y,x)creaun array de floats
aleatoriascon la forma que le especificemos; pordefecto
genera númerosaleatoriosentre 0-1
array = np.random.random_sample((z,y,x))creaun array de
floats aleatoriascon la forma que le especificemos; por
defectogenera númerosaleatoriosentre 0-0.9999999...
array = np.random.z,y,x=None)devuelveun número
aleatorioen0 y 0.999999999999...
np.round(np.random.rand(z,y,x), n) creararray con floats
de n decimales
np.random.uniform(n,m, size = (z,y,x))genera muestras
aleatoriasde unadistribuciónuniformeenelintervalo
entre n y m
np.random.binomial(n,m, size = (z,y,x))genera muestras
con unadistribuciónbinomial; n es el numero total de
pruebas; m es la probabilidad de éxito
np.random.normal(loc = n, scale = m, size = (z,y,x))
genera números aleatorios de una distribución normal
(curva de campana); loces la media; scalees la
desviación estándar
np.random.permutation(array)devuelve un array con los
mismos valores mezclados aleatoriamente
Estadística
Tablasde frecuencias
Frecuenciasabsolutas
el número de veces que se repite un número en un
conjunto de datos
df= df.groupby('columna').count().reset_index()
Frecuenciasrelativas
las veces que se repite un número o categoría en un
conjunto de datos respecto al total, en porcentajes
df_group_sin_str= df_group.drop('columna_str',
axis=1)
frecuencia_relativa= df_group_sin_str/ df.shape[0] *
100
columnas= df_group_sin_strings.columns
df_group[columnas] = frecuencia_relativa
Tablasde contingencia
tabla de frecuencias que cuenta todas las
combinaciones posibles de cada pareja de valores de
las columnas que estamos intentando comparar
df_crosstab= pd.crosstab(df['columna1'],
df['columna2'], normalize= True, margins= True)
normalizemuestra los valores en porcentajes (por uno)
marginsmuestra los totales y subtotales
Coeficientede correlaciónde Pearson
-nos permite conocer la intensidad y dirección de la
relación entre las dos variables
-coeficiente > 0: correlación positiva
-coeficiente < 0: correlación negativa
-coeficiente = 1 o -1: correlación total
-coeficiente = 0: no existe relación lineal
df['columna1'].corr(df['columna2']calculala
correlacionentre dos variables
matriz_correlacion= df.corr()creaunamatriz
mostrandolas correlacionesentre todoslosvariables
sns.heatmap(df.corr()[['column1', 'column2']], cmap=
'color_palette', annot= True, vmin= -1, vmax= 1)
creaunagraficaheatmap de la matrizde correlaciones
Sesgos(skewness)
medida de la asimetría de la distribución de los
valores de una variable alrededor de su valor medio
-valor de sesgo positivo: sesgado a la derecha
-valor de sesgo negativo: sesgado a la izquierda
-valor de sesgo igual a 0: valores simetricos
sns.displot(df['columna'], kde= True)crea un
histograma que muestra la distributionde los valores
import scipy.statsimport skew
skew(df['columna']muestra el valor del sesgo de una
variable
Intervalosde confianza
describe la variabilidad entre la medida obtenida en
un estudio y la medida real de la población (el valor
real)
import scipy.statsas st
st.t.interval(alpha = n, df= len(df['columna']-1, loc
= np.mean(df['columna']), scale =
st.sem(df['columna']))
devuelve el rango de valores para lo cual hay un n% de
probabilidad que un valor real cae en ese rango
alpha: porcentaje de confianza (p.ej. 90%, 95%, o 99%)
df: los datos
loc: la media
scale: la desviación estándar
Estadística
Medidas de dispersión
Desviación respecto a la media
la diferencia en valor absoluto entre cada valor de los
datos y su media aritmética
diferencias = df['columna'] -df['columna'].mean()
desviación_media= np.abs(diferencias)
Varianza
medida de dispersión; la variabilidad respecto a la media
df['columna'].var()
Desviación estándar o desviación típica
la raíz cuadrada de la varianza; cuanto mayor sea, mayor
será la dispersión o variabilidad en nuestros datos
df['columna'].std()
Robustez
-cuanto más cantidad de datos, más robustos
1/n donde n es el numero de registros
Coeficiente de variación
el cociente entre la desviación típica y la media; cuanto
mayor sea, mayor será la dispersión en nuestros datos
df['columna'].std() / df['columna'].mean()
Percentiles
divide datos ordenados de menor a mayor en cien partes;
muestra la proporción de datos por debajo de su valor
percentil_n= np.percentile(df['columna'], n)saca el valor
en el percentil n
Rangos intercuartílicos
medida de dispersión: diferencia entre cuartiles 75 y 25
q3, q1 = np.percentile(df["columna"], [75, 25])saca los
tercer y primer cuartiles
rango_intercuartílico= q3 -q1

7. EDA y ETL
EDA: Análisis exploratoriode datos
El Análisis Exploratorio de Datos se refiere al
proceso de realizar una serie de investigaciones
incialessobre los datos que tenemos para poder
descubrir patrones, detectar anomalías, probar
hipótesis y comprobar suposiciones con la ayuda de
estadísticas y representaciones gráficas.
1. Entenderlas variables
-que variables temenos
.head(), .tail(), .describe(), .info(), .shape
-que tiposde datos
.dtypes(), .info()
-sitemenos nuloso duplicados
.isnull().sum()
.duplicated().sum()
-que valoresunicostemenos
.unique(), .value_counts()
librería sidetable:
stb.freq() devuelve el value_countsde variables
categóricas, mas el porcentaje, cuenta cumulativa y
porcentaje cumulativa
stb.missing() tabla de cuenta de nulos y el
porcentaje del total
2. Limpiareldataset
-quitarduplicados(filaso columnas)
-cambiarnombresde columnas
-cambiartipode datosde columnas
-ordenarcolumnas
-separarcolumnaendos con str.split()
-crearintervaloscon pd.cut()
-crearporcentajeso ratios
-decidircomotrataroutliers: mantenerlos,
eliminarlos, o reemplazarloscon la media,
medianao moda; o aplicarunaimputacion
-decidircomotratarnulos:
-eliminarfilaso columnascon nulosdrop.na()
-imputarvaloresperdidos:
-reemplazarloscon la media, medianao moda
usando.fillna() o .replace()
-imputer con metodosde machine learning
usandola libreriasklearn: Simple-Imputer,
Iterative-Imputer, o KNN Imputer
3. Analizarrelacionesentre variables
Analizarrelacionesentre las variables
-para encontrarpatrones, relacioneso anomalias
Relaciones entre dos variables numéricas:
-scatterplot
-regplot–scatterplotcon línea de regresion
-matriz de correlación y heatmap
-joinplot–permite emparejar dos gráficas –una
histograma con scattero regplotpor ejemplo
Relaciones entre dos variables categóricas:
-countplot
Relaciones entre variables numéricas y categóricas:
-swarmplot
-violinplot
-pointplot
-boxplot
ETL: Extract, Transform, Load
Extraccion
-obtenerdatoscrudos y almacenarlos
-Tablas de bases de datos SQL o NoSQL
-Ficheros de texto plano
-Emails
-Información de páginas web
-Hojas de cálculo
-Ficheros obtenidos de API's
Transformación
-procesar los datos, unificarlos, limpiarlos,
validarlos, filtrarlos, etc.
-Formetearfechas
-Reordenar filas o columnas
-Unir o separar datos
-Combinar las fuentes de datos
-Limpiar y estandarizar los datos
-Verificar y validar los datos
-Eliminar duplicados o datos erroneos
-Filtrado, realización de calculoso agrupaciones
Carga
-cargar los datos en su formato de destino, el tipo
de lo cual dependerá de la naturaleza, el tamaño y la
complejidad de los datos. Los sistemas más comunes
suelen ser:
-Ficheros csv
-Ficheros json
-Bases de datos
-Almacenes de datos (Data Warehouse)
-Lagos de datos (Data Lakes)
Tests estadísticos
Independenciaentre variables predictoras
-las variables predictorastienenque ser independientes para
poder crear un modelo de regresión lineal
Variables numéricas: Correlaciones
-pairplot
sns.pairplot(df)
-covarianza
df_numéricas.cov()
-correlación de Pearson (relación lineal)
df_numéricas.corr()
-correlación de Spearman (relación no lineal)
df_numéricas.corr(method= 'spearman')
-correlación de Kendall (datos numéricos pero
categóricos y ordinales)
df_numéricas.corr(method= 'kendall')
Variables categóricas: Chi-cuadrado
-V-Cramer: varía entre 0 y 1
-más cerca a 1 más dependientes
-resultado < 0,7 para hacer ML ✔️
importresearchpyas rp
crosstab, test_results, expected = rp.crosstab
(df["col1"], df["col2"], test= "chi-square",
expected_freqs= True, prop= "cell")
test_resultsdevuelvelosresultadosdel test enun
dataframe
Homocedasticidad(homogeneidadde varianzas)
-las variables predictoras tienen que tener homogeneidad de
varianzas en comparación con la variable respuesta
Visualmente:
-violinplot
-boxplot
-regplot(columnas numéricas vs variable respuesta)
Metodosanaliticos:
-test de Levene (más robusto ante falta de
normalidad) o Bartlett
fromscipyimportstats
from scipy.statsimport levene
Variables categóricas:
-hay que crearun dataframepara cadavalorúnico de
las columnas categóricas
df_valor1 = df[df['col1'] == 'valor1']['col_VR']
df_valor2 = df[df['col1'] == 'valor2']['col_VR']
levene_test= stats.levene(df_valor1, df_valor2,
center='median')
bartlett_test= stats.bartlett(df_valor1, df_valor2,
center='median')
Variables numéricas:
-hay que crearun dataframede las columnas numéricas
sin la variable respuesta
for col in df_numericas.columns:
statistic, p_val= levene(df[col], df['col_VR'],
center='median')
resultados[col] = p_val
devuelve los p-valores en un diccionario
-p-valor del test > 0.05: varianzas iguales,
homocedasticidad ✔️
-p-valor del test < 0.05: varianzas diferentes,
heterocedasticidad
Machine Learning: Preparación
HipotesisNula y ErroresTipo I y II
Hipótesis nula (H0)
-en general es la afirmación contraria a la que queremos probar
Hipótesis alternativa (H1)
-en general la afirmación que queremos comprobar
p-valor
-medida de la probabilidad de que una hipótesis nula sea cierta
-valor entre 0 y 1
-si *p-valor* < 0.05 ❌Rechazamos la hipótesis nula.
-si *p-valor* > 0.05 ✔️Aceptamos la hipótesis nula.
Error Tipo I:
-rechazar la hipótesis nula cuando es verdadera
Error Tipo II:
-aceptar la hipótesis nula cuando es falsa
Tests estadísticos
Normalidad
-la variable respuestatieneque tenerunadistribuciónnormal para poder
crear un modelo de regresión lineal
Visualmente:
-histograma o distribución
-grafico de cuantiles teóricos (Q-Q)
más alineados están los puntos entorno a la recta, más normales
serán nuestros datos
importstatsmodels.apias sm
sm.qqplot(datos, line ='45')
Metodosanaliticos:
Asimetría
-distribuciones asimétricas positivas: media > mediana y moda
-distribuciones asimétricas negativas: media < mediana y moda
from scipy.statsimport skew
skew(datos_normales)método de scipyque calcula el sesgo
df['columna'].skew()método de pandas que calcula el sesgo
Curtosis
-leptocurtosis: valor de curtosis mayor que 0 (pico alto)
-mesocurtosis: valor de curtosis igual a 0 (pico medio)
-platicurtosis: valor de curtosis menor que 0 (plana)
fromscipy.statsimport kurtosistest
kurtosistest(datos)devuelve un p-valor
-p-valor del test > 0.05: datos normales ✔️
-p-valor del test < 0.05: datos NO normales
Test de Shapiro-Wilk
-para muestras < 5000
-hipótesis nula: distribución normal
fromscipyimportstats
stats.shapiro(df["datos"])
-p-valor del test > 0.05: datos normales ✔️
-p-valor del test <) 0.05: datos NO normales
Test de Kolmogorov-Smirnov
-para muestras > 5000
-hipótesis nula: distribución normal
fromscipyimportkstest
kstest(df["datos"], 'norm')
-p-valor del test > 0.05: datos normales ✔️
-p-valor del test < p-valor (alfa) 0.05: datos NO normales
APIs
import requestslibreriapara realizarpeticionsHTTP
a unaURL, para hacerweb scraping
url= 'enlace'elenlace de la que queremosextraer
datos
header = {}opcional; contieneinformacionsobrelas
peticionesrealizadas(tipode ficheros, credenciales)
response = requests.get(url=url, header = header)
pedimosa la API que nosde losdatos
variables = {'parametro1':'valor1',
'parametro2':'valor2'}
response = request.get(url=url, params=variables)
pedimosa la API que nosde losdatoscon los
parametrosseguneldiccionariode parametrosque le
pasamos
response.status_codedevuelveelstatus de la peticion
response.reasondevuelveelmotive de codigode estado
response.textdevuelvelosdatosenformatostring
response.json()devuelvelosdatosenformatojson
df= pd.json_normalize(response.json)devuelvelos
datosenun dataframe
Codigosde respuestade HTTP
1XX informade una
respuestacorrecta
2XX codigode exito
200 OK
201 creado
202 aceptado
204 sin contenido
3XX redireccion
4XX error durantepeticion
401 peticionincorrecta
402 sin autorizacion
403 prohibido
404 no encontrado
5XX error del servidor
501 error internodel servidor
503 serviciono disponible
Normalización
Métodomanual
-cogemos el valor que queremos normalizar y
restamos la media de la columna, y dividimos el
resultado por el maximo restado por el minimo de la
columna
df["col_norm"] = (df["col_VR"] -
df["col_VR"].media()) / (df["col_VR"].max() -
df["col_VR"].min())
Métodologarítmica
*no se puedehacersialgúnvalorsea 0*
df["col_norm"] = df["col_VR"].apply(lambda x:
np.log(x) ifx > 0 else0)
Métodoraizcuadrada
importmath
df["col_norm"] = df["col_VR"].apply(lambda x:
math.sqrt(x))
Métodostats.boxcox()
aplica una transformación logarítmica para los
valores positivos y exponencial para valores
negativos de nuestra columna
from scipyimportstats
df["col_norm"], lambda ajustada =
stats.boxcox(df["col_VR"])
MétodoMinMaxScaler
fromsklearn.preprocessingimportMinMaxScaler
modelo = MinMaxScaler(feature_range=(0,1),
copy=True)
modelo.fit(df["col_VR"])
datos_normalizados= modelo.transform(df["col_VR"])
df_datos_norm= pd.DataFrame(datos_normalizados,
columns = ['col_norm'])
df['col_norm'] = df_datos_norm
ANOVA
import statsmodels.api as sm
from statsmodels.formula.api import ols
lm = ols('col_VR ~ col_VP1 + col_VP2 + col_VP3',
data=df).fit()
devuelve un dataframe de los resultados:
df (degrees of freedom): para variables categóricas
será el número de valores únicos menos 1; para
variables numéricas será siempre 1
sum_sq: medida de variación/desviación de la media
mean_sq: es el resultado de dividir la suma de
cuadrados entre el número de grados de libertad.
F: un test que se utiliza para evaluar la capacidad
explicativa que tiene la variable predictora sobre
la variación de la variable respuestae
-PR(>F): si el p-valor < 0.05 es una variable
significativa; que puede afectar a la VR
lm.summary()devuelve una resumen de los
resultados:
coef: representa los cambios medios en la VR para
una unidad de cambio en la VP mientras se mantienen
constantes el resto de las VP; los signos nos
indican si esta relación es positiva o negativa
std err: cuanto menor sea el error estándar, más
precisa será la estimación
t: es el resultado de dividir el coeficiente entre
su error estándar

8. RegresiónLineal: Métricas
from sklearn.metrics import r2_score, mean_squared_error,
mean_absolute_error
R2: representa la proporción de la varianza que puede ser
explicada por las VP del modelo; mayor R2=mejor modelo
r2_score(y_train,y_predict_train)
r2_score(y_test,y_predict_test)
MAE (Mean absolute error): medida de la diferencia entre los
valores predichos vs los reales; menor MAE=mejor modelo
mean_absolute_error(y_train,y_predict_train)
mean_absolute_error(y_test,y_predict_test)
MSE (Mean Squared Error): mide el promedio(media) de los
errores al cuadrado; menor MSE=mejor modelo
mean_squared_error(y_train,y_predict_train)
mean_squared_error(y_test,y_predict_test)
RMSE (Root Mean Squared Error): distancia promedio entre los
valores predichos y los reales; menor RMSE=mejor modelo
np.sqrt(mean_squared_error(y_train,y_predict_train))
np.sqrt(mean_squared_error(y_test,y_predict_test))
Machine Learning
Encoding
Variables categóricas
Ordinaria: no requiere números pero sí consta de un orden
o un puesto; diferencias de medianas entre categor ías
Nominal: variable que no es representada por números, no
tiene algún tipo de orden, y por lo tanto es
matemáticamente menos precisa; no habrá grandes
diferencias de medianas entre categorías
Binaria: dos posibilidades; puede tener orden o no
Variables sin orden: creamos una columna nueva por valor
único, asignando unos y zeros
One-Hot Encoding
from sklearn.preprocessing import OneHotEncoder
oh = OneHotEncoder()
df_transformados = oh.fit_transform(df[ ['columna']])
oh_df = pd.DataFrame(df_transformados.toarray())
oh_df.columns = oh.get_feature_names_out()
df_final = pd.concat([df, oh_df], axis=1)
get_dummies
df_dum = pd.get_dummies(df['col'], prefix='prefijo',
dtype=int)
df[df_dum.columns] = df.dum
df.drop('col', axis=1, inplace=True)
Variables que tienen orden:
Label Encodingasigna un número a cada valor único de una
variable
from sklearn.preprocessing import LabelEncoder
le = LabelEncoder()
df['col_VR_le'] = le.fit_transform(df[col_VR'])
map() asigna el valor que queramos según el mapa que
creamos
df['col_VR_map'] = df[col_VR'].map(diccionario)
Ordinal-Encoding asignamos etiquetas basadas en un orden o
jerarquía
from sklearn.preprocessing import OrdinalEncoder
GridSearch y best_estimator_
Despues de hacer las predicciones de un modelo
Decision Tree, examinamos lás métricas de los
resultados:
-si temenos overfitting hay que reducir la
profundidad del modelo
-si temenos underfitting hay que aumentar la
profundidad del modelo
max_features = np.sqrt(len(x_train.columns))
podemos calcular el valor de max_features siendo la
raíz cuadrada del número de variables predictoras
arbol.tree_.max_depth nos muestra el max depth
usado por defecto, para poder ajustarlo; deber íamos
usar la mitado como mucho
-GridSearch ejecuta todas las posibles
combinaciones de hiperparámetros que le damos con
el parámetro 'param' y best_estimator_ devuelve la
major combinacion encontrado
1. Definimos un diccionario de los hiperparametros
param = {"max_depth": [n,m,l], "max_features":
[a,b,c,d], "min_samples_split": [x,y,z],
"min_samples_leaf": [r,s,t]} from
sklearn.model_selection import GridSearchCV
2. Iniciamos el modelo con GridSearch
gs = GridSearchCV(estimator =
DecisionTreeRegressor(), param_grid = param, cv=10,
verbose=-1, return_train_score = True, scoring =
"neg_mean_squared_error")
3. Ajustamos el modelo en el GridSearch
gs.fit(x_train, y_train)
4. Aplicamos el método de best_estimator_
mejor_modelo = gs.best_estimator_
devuelve la mejor combinación de hiperparámetros
5. Volvemos a sacar las predicciones
y_pred_test_dt2 = mejor_modelo.predict(x_test)
y_pred_train_dt2 = mejor_modelo.predict(x_train)
Importancia de los predictores
importancia_predictores = pd.DataFrame(
{'predictor': x_train.columns, 'importancia':
mejor_modelo.feature_importances_})
importancia_predictores.sort_values(by=["importanci
a"], ascending=False, inplace = True) crea un
dataframe con la relativa importancia de cada VP
-para los variables categóricas nominales a los
cuales se ha aplicado encoding, hay que sumar los
resultados de las columnas divididas:
df_sum= importancia_predictores_esta.iloc[[n, m]]
importancia_predictores_esta.drop(df_sum.index,
inplace = True)
importancia_predictores_esta.loc[n] =
["nombre_col", df_sum["importancia"].sum()]
Random Forest: Modelo
seguir los mismos pasos como para el Decision Tree
pero con RandomForestRegressor()o
RandomForestClassifer()
from sklearn.ensemble import RandomForestRegressor
-se puede usar los mismos hiperparámetros del
best_estimator_ o volver a ejecutar el GridSearch
Balanceo para Regresión Logística
Downsampling
ajustar la cantidad de datos de la categoría mayoritaria a
la minoritaria
Método manual
df_minoritaria = df[df['col'] == valor_min]
df_muestra= df[df['col'] == valor_max].sample
(num_minoritarios, random_state = 42)
df_balanceado = pd.concat([df_minoritaria,
df_muestra],axis = 0)
Método RandomUnderSample
import imblearn
X = df.drop('col_VR', axis=1)
y = df['col_VR']
down_sampler = RandomUnderSampler()
X_down, y_down = down_sampler.fit_resample(X,y)
df_balanceado = pd.concat([X_down, y_down], axis = 1)
Método Tomek
x = df.drop('col_VR', axis=1)
y = df['col_VR']
x_train, x_test, y_train, y_test = train_test_split(x, y,
test_size = 0.2, random_state = 42)
tomek_sampler = SMOTETomek()
X_train_res, y_train_res =
tomek_sampler.fit_resample(X_train, y_train)
Upsampling
ajustar la cantidad de datos de la categoría minoritaria a
la mayoritaria
Método manual
df_mayoritaria = df[df['col'] == valor_may]
df_muestra= df[df['col'] == valor_min].sample
(num_mayoritarias, random_state = 42)
df_balanceado = pd.concat([df_mayoritaria,
df_muestra],axis = 0)
Método RandomOverSample
import imblearn
X = df.drop('col_VR', axis=1)
y = df['col_VR']
down_sampler = RandomUnderSampler()
X_down, y_down = down_sampler.fit_resample(X,y)
df_balanceado = pd.concat([X_down, y_down], axis = 1)
Regresión Logística: Métricas
Matriz de confusión
para crear un heatmap de una matriz de confusión:
from sklearn.metrics import confusion_matrix
mat_lr = confusion_matrix(y_test, y_pred_test)
plt.figure(figsize = (n,m))
sns.heatmap(mat_lr, square=True, annot=True=
plt.xlabel('valor predicho')
plt.ylabel('valor real')
plt.show()
Métricas
from sklearn.metrics import confusion_matrix,
accuracy_score, precision_score, recall_score,
f1_score , cohen_kappa_score,
roc_curve,roc_auc_score
Accuracy (exactitud): porcentaje de los valores
predichos están bien predichos
accuracy_score(y_train,y_predict_train)
accuracy_score(y_test,y_predict_test)
Recall: porcentaje de casos positivos capturados
*si preferimos FP, queremos recall alta*
recall_score(y_train,y_predict_train)
recall_score(y_test,y_predict_test)
Precisión (sensibilidad): porcentaje de
predicciones positivas correctas
*si preferimos FN, queremos precisión alta*
precision_score(y_train,y_predict_train)
presicion_score(y_test,y_predict_test)
Especificidad: porcentaje de los casos negativos
capturados
F1: la media de la precisión y el recall
f1_score(y_train,y_predict_train)
f1_score(y_test,y_predict_test)
kappa: una medida de concordancia que se basa en
comparar la concordancia observada en un conjunto
de datos, respecto a la que podría ocurrir por mero
azar
-<0 No acuerdo
-0.0-0.2 Insignificante
-0.2-0.4 Bajo
-0.4-0.6 Moderado
-0.6-0.8 Bueno
-0.8-1.0 Muy bueno
cohen_kappa_score(y_train,y_predict_train)
cohen_kappa_score(y_test,y_predict_test)
curva ROC: forma gráfica de ver la kappa; la
sensibilidad vs. la especificidad
AUC (área under curve): la área bajo la curva ROC;
cuanto más cerca a 1, mejor será nuestro modelo
clasificando los VP
Matriz de
confusión
Predicción
Positivo Negativo
Realidad
PositivoVerdadero
positivo
Falso negativo
NegativoFalso
positivo
Verdadero
negativo
Logistic Regression: Modelo
seguir los mismos pasos como para la Regresión Lineal pero
con LogisticRegression()
from sklearn.linear_model import LogisticRegression
Linear Regression: Modelo
1. separar los datos de las variables predictoras (x) de la
variable respuesta (y)
X = df.drop('col_VR', axis=1)
y = df['col_VR']
2. dividimos los datos en datos de entrenamiento y datos de
test con train_test_split()
from sklearn.model_selection import train_test_split
x_train, x_test, y_train, y_test = train_test_split(X, y,
test_size = 0.2, random_state = 42)
3. Ajustamos el modelo
from sklearn.linear_model import LinearRegression
lr = LinearRegression(n_jobs=-1)
lr.fit(x_train, y_train)
4. Hacemos las predicciones
y_predict_train = lr.predict(x_train)
y_predict_test = lr.predict(x_test)
5. Guardamos los resultados en dataframes y los concatenamos
train_df = pd.DataFrame({'Real': y_train, 'Predicted':
y_predict_train, 'Set': ['Train']*len(y_train)})
test_df = pd.DataFrame({'Real': y_test, 'Predicted':
y_predict_test, 'Set': ['Test']*len(y_test)})
resultados = pd.concat([train_df,test_df], axis = 0)
6. creamos una columna de los residuos: la diferencia entre
los valores observados y los de la predicción
resultados['residuos'] = resultados['Real'] -
resultados['Predicted']
Cross-validation
from sklearn.model_selection import cross_val_score
from sklearn.model_selection import cross_validate
cv_scores = cross_val_score(estimator = LinearRegression(),
X = X, y = y, scoring = 'neg_root_mean_squared_error', cv =
10)
cv_scores.mean()
calcula la media de los resultados de CV de una métrica
cv_scores = cross_validate(estimator = LinearRegression(), X
= X, y = y, scoring ='r2','neg_root_mean_squared_error', cv
= 10)
cv_scores["test_r2"].mean()
cv_scores["test_neg_root_mean_squared_error"].mean() calcula
las medias de los resultados de validación de múltiples
métricas
Estandarización
-cambiar los valores de nuestras columnas de manera que
la desviación estándar de la distribución sea igual a 1 y
la media igual a 0; para que las VP sean comparables
Método manual
df["col_esta"] = (df["col_VR"] –df["col_VR"].media()) /
(df["col_VR"].std()
SklearnStandardScaler
from sklearn.preprocessingimport StandardScaler
scaler= StandardScaler()
scaler.fit(df_num_sin_VR)
datos_estandarizados= scaler.transform(df_num_sin_VR)
df_datos_esta= pd.DataFrame(datos_estandarizados, columns
= df_num_sin_VR.columns)
SklearnRobustScaler
from sklearn.preprocessingimport RobustScaler
scaler= RobustScaler()
scaler.fit(df_num_sin_VR)
datos_estandarizados= scaler.transform(df_num_sin_VR)
df_datos_esta= pd.DataFrame(datos_estandarizados, columns
= df_num_sin_VR.columns)
Decision Tree: Modelo
from sklearn.model_selection import train_test_split
from sklearn.ensemble import DecisionTreeRegressor
from sklearn import tree
seguir los mismos pasos como para la Regresión Lineal pero
con DecisionTreeRegressor()o DecisionTreeClassifier()
arbol = DecisionTreeRegressor(random_state=42)
Para dibujar el árbol:
fig = plt.figure(figsize = (10,6))
tree.plot_tree(arbol, feature_names = x_train.columns,
filled = True)
plt.show()