Manejo y análisis de datos con Pandas

13 de agosto de 2022

Libro electrónico gratis:<br>Rubén Darío Azul
Libro electrónico gratis:
Rubén Darío
Azul
Libro electrónico gratis:<br>Charles Perrault Cuentos
Libro electrónico gratis:
Charles Perrault
Cuentos
Libro electrónico gratis:<br>Marco Polo los viajes de marco polo
Libro electrónico gratis:
Marco Polo
los viajes de marco polo

Pandas es una librería de python que nos permite analizar grandes cantidades  de datos, nos permite hacer análisis de bigdata. Con Pandas es posible realizar tareas que ni en sueños podríamos hacer en hojas de cálculo como excel u openoffice calc o en motores de bases de datos como mysql o sql. Cuando excel colapsa o se tarda demasiado, es la hora de pandas.

Pandas fué creado por Wes McKinney para hacer análisis cuantitativo en el sector financiero, sector en el  que él trabaja.

Pandas y python son software libre y gratuito.

Contenido

  • Instalación de Pandas en Ubuntu
  • Instalación de Pandas en Windows
  • Iniciar Pandas desde python
  • Los dataframes
  • Creación de dataframe de forma manual
  • Crear un dataframe a partir de una list
  • Crear un dataframe a partir de un dictionary
  • Copiar y pegar para crear un dataframe
  • Creación un dataframe desde un archivo de excel
  • Creación de dataframe desde un archivo csv
  • Creación de dataframe desde un archivo de open office calc
  • Creación de dataframe desde una base de datos mysql
  • Guardar un dataframe en disco
  • Exportar un dataframe a excel
  • Agregar columnas en un dataframe
  • Eliminar columnas en un dataframe
  • Eliminar filas en un dataframe
  • Eliminar duplicados
  • Hacer una iteración en un dataframe
  • Concatenar dataframes
  • Funciones aritméticas y estadísticas de pandas
  • Merge, combinar, dataframes
  • Extraer datos de acciones de la bolsa de valores
  • Instalación de Pandas en Ubuntu

    Para trabajar con Pandas, primero tenemos que instalarlo. En python para instalar librerías utilizaremos el programa pip. 

    Versiones recientes de Ubuntu  vienen con dos versiones python preinstaladas: la 3 y la 2.7.

    En Ubuntu pip para python 3 no viene instalado, por lo que hay que instalarlo. Para instalarlo utilizaremos  en la línea de comandos el comando:

    sudo apt install python3-pip

    Instalar pip para python3 en Ubuntu

    Tras instalarlo es recomendable actualizarlo, para ello utilizaremos  en la línea de comandos el comando:

    sudo pip3 install --upgrade pip

    Actualizar pip para python3 en Ubuntu

    Una vez instalado pip, debemos instalar Pandas, para ello utilizaremos  en la línea de comandos el comando:

    sudo pip3 install pandas

    Instalar pandas para python3 en Ubuntu

    Es recomendable instalar también Numpy (una librería para hacer análisis matemático), para ello utilizaremos  en la línea de comandos el comando:

    sudo pip3 install numpy

    Instalar numpy para python3 en Ubuntu

    Si queremos crear gráficas, podríamos instalar también la lbrería Matplotlib, para ello utilizaremos  en la línea de comandos el comando:

    sudo pip3 install matplotlib

    Instalar matplotlib para python3 en Ubuntu

    Instalación de Pandas en Windows

    En windows para instalar pandas en la línea de comandos usaremos el comando:

    pip install pandas

    Instalar pandas para python3 en Windows

    Es recomendable instalar también Numpy (una librería para hacer análisis matemático), para ello utilizaremos  en la línea de comandos el comando:

    pip install numpy

    Instalar numpy para python3 en Windows

    Si queremos crear gráficas, podríamos instalar también la lbrería Matplotlib, para ello utilizaremos  en la línea de comandos el comando:

    pip install matplotlib

    Instalar matplotlib para python3 en Windows

    Iniciar Pandas desde python

    Una vez instalado pandas, procederemos a abrir python 3.  Ubuntu viene desde fábrica con python 2.7 y 3 instalados...  Para iniciar python 3 utilizaremos  en la línea de comandos el comando:

    python3

    En ubuntu para iniciar python 3 utilizaremos  en la línea de comandos el comando python3

    En windows no viene pre-instalado python, por lo que   debemos instalarlo. Una vez instalado  para  iniciarlo  utilizaremos  en la línea de comandos el comando:

    python

    En windows para iniciar python 3 utilizaremos  en la línea de comandos el comando python

    Una vez  iniciado python, procederemos a importar la librería pandas desde python con el comando:

    import pandas as pd

    Importar la librería pandas para python

    Si no marca error, es una buena señal. En caso de que no esté instalado Pandas, aparecerá un mensaje de error señalando que el módulo no está instalado:

    Error: pandas no está instalado

    Para importar la librería numpy utilizaremos el comando:

    import numpy as np

    Importar la librería numpy para python

    Para importar la librería matplotlib utilizaremos los comandos:

    import matplotlib 
    import matplotlib.pyplot as plt
    

    Importar la librería matplotlib para python

    ¡Estamos listos para comenzar a trabajar con Pandas!

    Los dataframes

    Para trabajar con Pandas regularmente utilizaremos dataframes.

    Un  dataframe nos permite almacenar datos. El dataframe es como un array (matriz), una hoja de cálculo, una base datos, un dictionary multidimensional o una list multidimensional.

    Un dataframe almacena registros en filas o tuples como en la bases de datos . Y cada registro puede tener diferentes atributos, que se almacena en columnas. En las columnas de un dataframe podemos almacenar números enteros, números decimales, strings, lists, dictionaries, sets, objetos, arrays, otros dataframes...

    Suponamos que queremos registrar la información de jugadores de fútbol. Para cada jugador se registrará estos datos:

    La información de cada jugador se almacenará en filas, tuples,  y  cada atributo en columnas. Gráficamente se puede representar esta información así:

    En un dataframe la información se almacenará en filas, tuples,  y  cada atributo en columnas

    ¡Como una hoja de cálculo! Podemos tener registros prácticamente infinitos y cada registro puede tener atributos prácticamente infinitos.

    Hay varias formas de crear dataframes. Veamos algunas a continuación.

    Creación de dataframe de forma manual

    Podemos crear un dataframe vacío con el comando:

    mi_dataframe = pd.DataFrame()

    crear un dataframe vacío con el comando

    ¡Hemos creado nuestro primer dataframe! Podemos verificar que es un datraframe con el comando:

    type(mi_dataframe)

    Podemos verificar que es un datraframe con el comando type(mi_dataframe)

    Un dataframe vacío no sirve de mucho... Podemos crear un dataframe con datos almacenados en  filas y columnas  con este comando:

    nombre_dataframe = pd.DataFrame(
    {
    'columna_01': [10, 20, 30],
    
    'columna_02':[100, 200, 300]
    })
    
    
    # nombre_dataframe es el nombre de la variable que almacenará mi dataframe
    # pd.DataFrame() creara un dataframe
    # entre llaves {} estarán las filas  y columnas de nuestro datrafame
    # 'columna_01' crea una columna con el nombre  columna_01
    # con :[] definimos los valores a guardar en la columna
    # en este caso almacenamos los valores 10,20 y 30
    # cada columna creada la separamos con una  ,
    # 'columna_02' crea una columna con el nombre  columna_02
    # con :[] definimos los valores a guardar en la columna
    # en este caso almacenamos los valores 100,200 y 300    
    

    Al escribir el nombre del dataframe en la línea de comandos y presionar la tecla enter, aparecerá un resúmen de nuestro dataframe:

    Al escribir el nombre del dataframe en la línea de comandos y presionar la tecla enter, aparecerá un resúmen de nuestro dataframe

    Como verán, aparecerán unos número que nadie creó: 0, 1 y 2. Esos números corresponden al index / índice de nuestro dataframe. El index de un dataframe puede ser un número o una string y nos permitira hacer operaciones con nuestro dataframe.

    Como verán, aparecerán unos número que nadie creó: 0, 1 y 2. Esos números corresponden al index / índice de nuestro dataframe.

    Un comando muy útil para analizar el contenido de nuestro dataframe es info()

    nombre_dataframe.info()

    El comando info  nos mostará la cantidad de columnas que tiene nuestro dataframe, el tipo de datos que almacena cada columna, la cantidad de registros almacenados y el tamaño en memoria que ocupa nuestro dataframe.

    El comando info  nos mostará la cantidad de columnas que tiene nuestro dataframe, el tipo de datos que almacena cada columna, la cantidad de registros almacenados y el tamaño en memoria que ocupa nuestro dataframe.

    Para practicar, vamos a crear un dataframe de forma manual que almacene los nombres de los Estados de México, con el nombre de su capital, su población, su superficie territorial y la fecha en que se incorporaron a la federación:

    estados = pd.DataFrame( 
    { 
    'nombre':['Aguascalientes',
    'Baja California',
    'Baja California Sur',
    'Campeche',
    'Chiapas',
    'Ciudad de México',
    'Chihuahua',
    'Coahuila de Zaragoza',
    'Colima',
    'Durango',
    'Guanajuato',
    'Guerrero',
    'Hidalgo',
    'Jalisco',
    'México',
    'Michoacán de Ocampo',
    'Morelos',
    'Nayarit',
    'Nuevo León',
    'Oaxaca',
    'Puebla',
    'Querétaro de Arteaga',
    'Quintana Roo',
    'San Luis Potosí',
    'Sinaloa',
    'Sonora',
    'Tabasco',
    'Tamaulipas',
    'Tlaxcala',
    'Veracruz',
    'Yucatán',
    'Zacatecas'],
     
    'capital':['Aguascalientes',
    'Mexicali',
    'La Paz',
    'Campeche',
    'Tuxtla Gutiérrez',
    'Ciudad de México',
    'Chihuahua',
    'Saltillo',
    'Colima',
    'Durango',
    'Guanajuato',
    'Chilpancingo',
    'Pachuca',
    'Guadalajara',
    'Toluca',
    'Morelia',
    'Cuernavaca',
    'Tepic',
    'Monterrey',
    'Oaxaca',
    'Puebla',
    'Querétaro',
    'Chetumal',
    'San Luis Potosí',
    'Culiacán',
    'Hermosillo',
    'Villahermosa',
    'Ciudad Victoria',
    'Tlaxcala',
    'Xalapa',
    'Mérida',
    'Zacatecas'],
     
    'superficie':[5618,
    71446,
    73922,
    57924,
    73289,
    1495,
    247455,
    151563,
    5625,
    123451,
    30608,
    63621,
    20846,
    78599,
    22357,
    58643,
    4893,
    27815,
    64220,
    93793,
    34290,
    11684,
    42361,
    60983,
    58200,
    179503,
    24738,
    80175,
    3991,
    71820,
    39612,
    75539],
     
    'poblacion':[1184996,
    3155070,
    637026,
    822441,
    4796580,
    8918653,
    3406465,
    2748391,
    650555,
    1632934,
    5486372,
    3388768,
    2665018,
    7350682,
    15175862,
    4351037,
    1777227,
    1084979,
    4653458,
    3801962,
    5779829,
    1827937,
    1325578,
    2585518,
    3216000,
    2662480,
    2238603,
    3268554,
    1169936,
    7643194,
    1955577,
    1490668],
     
    'fecha':['1857-02-05',
    '1952-01-16',
    '1974-10-08',
    '1863-04-29',
    '1824-09-14',
    '2016-01-29',
    '1824-07-06',
    '1824-05-07',
    '1856-09-12',
    '1824-05-22',
    '1823-12-20',
    '1849-10-27',
    '1869-01-16',
    '1823-12-23',
    '1823-12-20',
    '1823-12-22',
    '1869-04-17',
    '1917-01-26',
    '1824-05-07',
    '1823-12-21',
    '1823-12-21',
    '1823-12-23',
    '1974-10-08',
    '1823-12-22',
    '1830-10-14',
    '1824-01-10',
    '1824-02-07',
    '1824-02-07',
    '1856-12-09',
    '1823-12-22',
    '1823-12-23',
    '1823-12-23'] 
    } 
    ) 
    

    Este es el resultado:

    Dataframe creado de forma manual

    Crear un dataframe a partir de una list

    Es también posible crear un dataframe a partir de una list unidimensional.

    Para ello usaremos el comando:

    mi_dataframe = pd.DataFrame(mi_lista)

    Ejemplo:

    #creamos una list
    mi_lista = [ 
    "Andres", 
    "Manuel", 
    "Lopez", 
    "Obrador" 
    ] 
    #creamos una dataframe a partir de una list
    mi_dataframe = pd.DataFrame(mi_lista)
    

    Y este es el resultado:

    Dataframe creado a partir de una list

    Como verán, la columna no tiene nombre... 

    la columna del dataframe no tiene nombre

    ¿Cómo ponerle nombre a la columna? Usando el parámetro columns

    mi_dataframe = pd.DataFrame(mi_lista, columns=["nombres"])

    Y este es el resultado:

    usando el parametro columns para bautizar una columna

    De igual forma podemos crear un dataframe a partir de una lista multidimensional , por ejemplo:

    mi_lista = [ 
     ["Jorge Campos",34,1.63,"Palo Alto ","044-55-28-43-76-28"], 
    ["Cuauhtémoc Blanco",32,1.68,"Jesús María ","044-55-28-43-76-27"], 
    ["Joel Sánchez Ramos",28,1.92,"Pabellón de Arteaga ","044-55-28-43-76-26"], 
    ["Duilio Davino",38,1.80,"Rincón de Romos ","044-55-28-43-76-25"], 
    ["Alberto García Aspe",27,1.94,"San Francisco de los Romo ","044-55-28-43-76-24"], 
    ["Raúl Rodrigo Lara",32,1.90,"San José de Gracia ","044-55-28-43-76-23"], 
    ["Jaime Ordiales",35,1.73,"Tepezalá ","044-55-28-43-76-22"], 
    ["Germán Villa",27,1.94,"Xpujil ","044-55-28-43-76-21"], 
    ["Pável Pardo",22,1.84,"Calkiní ","044-55-28-43-76-20"], 
    ["Francisco Palencia",32,1.86,"Campeche ","044-55-28-43-76-19"], 
    ["Jesús Arellano",19,1.97,"Candelaria ","044-55-28-43-76-18"], 
    ["Luis Hernández",37,1.63,"Ciudad del Carmen ","044-55-28-43-76-17"], 
    ["Ramón Ramírez",26,1.70,"Champotón ","044-55-28-43-76-16"], 
    ["Claudio Suárez",25,1.62,"Escárcega ","044-55-28-43-76-15"] 
    ] 
    
    mi_dataframe = pd.DataFrame(mi_lista, columns=["nombre","edad","estatura","lugar_nacimiento", "telefono"])
    

    Y este es el resultado:

    creando un dataframe a partir de una list multidimensional

    Crear un dataframe a partir de un dictionary

    Es también posible crear un dataframe a partir de un dictionary multidimensional .

    Para ello usaremos el comando:

    mi_dataframe = pd.DataFrame(mi_dictionary)

    Ejemplo:

    mi_diccionario = { 
    'portero':["Jorge Campos",34,1.63,"Palo Alto ","044-55-28-43-76-28"], 
    'lateral_izquierdo':["Joel Sánchez Ramos",28,1.92,"Pabellón de Arteaga ","044-55-28-43-76-26"], 
    'contencion':["Duilio Davino",38,1.80,"Rincón de Romos ","044-55-28-43-76-25"], 
    'defensa_central':["Claudio Suárez",25,1.62,"Escárcega ","044-55-28-43-76-15"], 
    'lateral_derecho':["Raúl Rodrigo Lara",32,1.90,"San José de Gracia ","044-55-28-43-76-23"], 
    'mediocampo':["Alberto García Aspe",27,1.94,"San Francisco de los Romo ","044-55-28-43-76-24"], 
    'volante_derecho':["Germán Villa",27,1.94,"Xpujil ","044-55-28-43-76-21"], 
    'volante_izquierdo':["Pável Pardo",22,1.84,"Calkiní ","044-55-28-43-76-20"], 
    'volante_de_enganche':["Ramón Ramírez",26,1.70,"Champotón ","044-55-28-43-76-16"], 
    'delantero':["Cuauhtémoc Blanco",32,1.68,"Jesús María ","044-55-28-43-76-27"], 
    'extremo_derecho':["Francisco Palencia",32,1.86,"Campeche ","044-55-28-43-76-19"], 
    'extremo_izquierdo':["Luis Hernández",37,1.63,"Ciudad del Carmen ","044-55-28-43-76-17"] 
    }
    
    mi_dataframe = pd.DataFrame(mi_diccionario)
    

    Y este es el resultado:

    creando un dataframe a partir de un dictionary

    Si el resultado no nos satisface, podemos hacer una iteración en nuestro dictionary para reorganizarlo y acomodarlo acorde a nuestras necesidades. 

    En este ejemplo reorganizaremos este dictionary para que quede de esta manera:

    podemos hacer una iteración en nuestro dictionary para reorganizarlo y acomodarlo acorde a nuestras necesidades

    Para ello crearemos una list multidimensional a partir de nuestro diccionario con una iteración:

    nueva_lista =  [] 
    # creamos una list vacia 
    # sera una list multidimensional 
    # cada elemento de la list sera otra list con los datos de cada jugador 
    
    #haremos una iteración en el dictionary 
    for i in mi_diccionario: 
     lista_temporal = [] 
     # creamos una list con los datos de cada jugador 
     lista_temporal.append(mi_diccionario[i][0]) 
     # extraemos el nombre y lo almacenamos en la list 
     lista_temporal.append(mi_diccionario[i][1]) 
     # extraemos la edad y la almacenamos en la list 
     lista_temporal.append(mi_diccionario[i][2]) 
     # extraemos la estatura y la almacenamos en la list 
     lista_temporal.append(mi_diccionario[i][3]) 
     # extraemos la ciudad y la almacenamos en la list 
     lista_temporal.append(mi_diccionario[i][4]) 
     # extraemos el telefono y lo almacenamos en la list 
     lista_temporal.append(i) 
     # extraemos la posición y la almacenamos en la list 
     nueva_lista.append(lista_temporal) 
     # agregamos los datos del jugador a nuestra lista
    

    podemos hacer una iteración en nuestro dictionary para reorganizarlo y acomodarlo acorde a nuestras necesidades

    Con ello hemos creado una lista multidimensional:

    hemos creado una lista multidimensional

    Y como hemos visto anteriormente podemos convertir una lista multidimensional  en un dataframe con el comando:

    mi_dataframe = pd.DataFrame(mi_lista)

    Ejemplo:

    mi_dataframe = pd.DataFrame(nueva_lista, 
    columns=["nombre","edad","estatura","lugar_nacimiento", "telefono", "posicion"])

    Copiar y pegar para crear un dataframe

    Es posible crear también un dataframe copiando y pegando datos separados por tabulaciones, como cuando se copian datos desde un archivo de excel, un archivo de open office o un archivo de texto.

    Para ello utilizaremos el comando:

    mi_dataframe = pd.read_clipboard()

    Python pandas: Copiar y pegar para crear un dataframe

    Creación un dataframe desde un archivo de excel

    Es posible crear también un dataframe a partir de un archivo de excel 2007 (archivos .xlsx).  Para ello es necesario instalar la librería openpyxl .

    En Ubuntu para instalar la librería openpyxl para python3 utilizaremos el comando:

    pip3 install openpyxl 

    Python pandas: instalar la librería openpyxl para python3

    En Windows para instalar la librería openpyxl utilizaremos el comando:

    pip install openpyxl 

    Importar datos desde excel es bastante sencillo. Para ello utilizaremos el comando:

    mi_dataframe = pd.read_excel("nombre_archivo.xlsx")

    ¡Con sólo una línea de código!

    Para este ejemplo usaremos el archivo jugadores.xlsx

    Y lo importaremos con el comando:

    mi_dataframe = pd.read_excel("jugadores.xlsx")

    El resultado es:

    Python pandas: Creación un dataframe desde un archivo de excel

    Automáticamente pandas toma la primera fila del archivo de excel como el nombre de nuestras columnas. Podemos desactivar esa opción con el parámetro  header=None

    Ejemplo:

    mi_dataframe = pd.read_excel("jugadores.xlsx", header=None)

    Como podemos ver, la primera fila la considera como una fila más de datos.

    Python pandas: pd.read_excel(header=None)

    Como hemos visto anteriormente podemos rebautizar el nombre de las columnas. Pero al importar desde excel debemos utilizar el parámetro names. 

    Ejemplo:

    mi_dataframe = pd.read_excel("jugadores.xlsx", names=["nombre", "edad", "estatura", "ciudad", "telefono", "posicion" ])

    Y el resultado:

    Python pandas: rebautizar el nombre de las columnas

    Creación de dataframe desde un archivo csv

    Los archivos csv son archivos de texto que almacenan información que se exporta desde una hoja de cálculo o una base de datos. Permiten el intercambio de datos. Actualmente muchas instituciones y órganos del gobierno intercambian información con archivos .csv. Este es un ejemplo de un archivo csv:

    Python pandas: Creación de dataframe desde un archivo csv

    Importar datos desde un archivo csv es bastante sencillo. Para ello utilizaremos el comando:

    mi_dataframe = pd.read_csv("nombre_archivo.csv")

    ¡Con sólo una línea de código!

    Para este ejemplo usaremos el archivo jugadores.csv

    Y lo importaremos con el comando:

    mi_dataframe = pd.read_csv("jugadores.csv")

    El resultado es:

    Python pandas:

    Creación de dataframe desde un archivo de open office calc

    Extrañamente, pese a ser software libre, no se pueden importar archivos .ods de open office calc...

    ¿La solución? Para ello podemos copiar y pegar los datos para crear un dataframe o exportar el archivo .ods como un archivos .csv

    Creación de dataframe desde una base de datos mysql

    Python se puede conectar a una base de datos mysql y extaer datos y almacenarlos en un dataframe. Para ello se utiliza el comando:

    mi_dataframe = pd.read_sql_query(sql, cnx)

    Previamente debimos establecer una conexión a la base de datos y hacer una consulta.

    El código completo es:

    import mysql.connector
    #importamos la librería para hacer la conexión a mysql
    
    cnx = mysql.connector.connect(user='root', password='escribe_tu_contrasena', host='127.0.0.1',database='jugadores')
    #creamos una conexión a la base de datos
    
    sql = """SELECT 
    
    nombre,
    edad,
    estatura,
    lugar_nacimiento,
    telefono,
    posicion,
    
    FROM
    
    seleccion_mexicana
    """
    # escribimos nuestra consulta
    
    mi_dataframe = pd.read_sql_query(sql, cnx)
    # ejectuamos la consulta en la base de datos
    # el resultado de nuesta consulta lo almacenamos en un dataframe
    

    Guardar un dataframe en disco

    Una vez que hemos construído nuestro dataframe, si cerramos la línea de comandos nuestro dataframe desaparecerá para siempre... Si apagamos la computadora nuestro dataframe desaparecerá para siempre...

    Pero podemos guardar en disco a nuestro dataframe para continuar trabajando en él posteriormente. Para ello usaremos el comando:

    mi_dataframe.to_pickle("nombre_de_archivo.pkl")

    Ejemplo:

    mi_dataframe.to_pickle("nombre_de_archivo.pkl")

    Tras ejecutar ese comando se creará un archivo .pkl en nuestra computadora.

    Python pandas: Guardar un dataframe en disco

    Para importar ese archivo .pkl y reconstruir nuestro dataframe usaremos el comando:

    mi_dataframe = pd.read_pickle("nombre_de_archivo.pkl")

    Exportar un dataframe a excel

    Es posible exportar un dataframe a un archivo de excel 2007 (archivos .xlsx).

    Para ello utilizaremos los comandos:

    mi_archivo_de_excel = pd.ExcelWriter("nombre_archivo.xlsx")
    #creamos nuestro archivo de excel y lo bautizamos
    
    mi_dataframe.to_excel(mi_archivo_de_excel)
    # exportamos el dataframe a excel
    
    mi_archivo_de_excel.save()
    #guardamos el archivo
    

    Ejemplo:

    Python pandas: Exportar un dataframe a excel

    Y el resultado:

    Python pandas: Exportar un dataframe a excel

    Como podemos ver, el index del dataframe también se exportó. ¿Como eliminarlo? Con el parámetro index=False en la función to_excel()

    Ejemplo:

    mi_archivo_de_excel = pd.ExcelWriter("nombre_archivo.xlsx")
    #creamos nuestro archivo de excel y lo bautizamos
    
    mi_dataframe.to_excel(mi_archivo_de_excel, index=False)
    # exportamos el dataframe a excel
    
    mi_archivo_de_excel.save()
    #guardamos el archivo
    

    Python pandas:

    Y el resultado:

    Python pandas: Exportar un dataframe a excel sin index

    Agregar columnas en un dataframe

    Es posible modificar un dataframe para agregarle una columna. La columna puede estar vacía, con datos o  puede alimentarse a partir de datos en el propio dataframe o una lista.

    Para este ejemplo usaremos el archivo jugadores.xlsx

    Y lo importaremos con el comando:

    mi_dataframe = pd.read_excel("jugadores.xlsx")

    El resultado es:

    Python pandas: Agregar columnas en un dataframe

    Agregaremos la columna peso y asignaremos el valor 0 a todos los registros.  Para ello usaremos  el comando:

    mi_dataframe["nombre_columna"] = valor_a_asignar
    

    Ejemplo:

    mi_dataframe["peso"] = 0 

    El resultado es:

    Python pandas: Agregaremos la columna peso y asignaremos el valor 0 a todos los registros

    Ahora agregaremos la columna nacionalidad y la dejaremos en blanco, sin datos, para todos los registros.  Para ello usaremos  el comando:

    mi_dataframe["nombre_columna"] = ""

    Ejemplo:

    mi_dataframe["nacionalidad"] = ""

    El resultado es:

    Python pandas: Ahora agregaremos la columna nacionalidad y la dejaremos en blanco, sin datos

    Ahora agregaremos la columna peso y usaremos una list  para alimentar los datos de esa columna.  Para ello usaremos  el comando:

    mi_dataframe["nombre_columna"] = mi_lista

    Ejemplo:

    mi_lista = [72,74,70,84,69,69,85,70,77,79,78,87]
    
    mi_dataframe["peso"] = mi_lista
    

    El resultado es:

    Python pandas: Ahora agregaremos la columna peso y usaremos una list  para alimentar los datos de esa columna

    Como puede verse los valores se asignaron a cada registro acorde a su posición en la list.

    Supongamos que necesitamos agregar una columna con el peso de los jugadores en libras... Tenemos que agregar una columna que se alimente a partir de datos en el propio dataframe.

     Para ello usaremos  el comando:

    mi_dataframe["peso_libras"] = mi_dataframe["peso"]  / .453592
    

    El resultado es:

    Python pandas: agregar una columna que se alimente a partir de datos en el propio dataframe

    Otro ejemplo  de agregar una columna que se alimente a partir de datos en el propio dataframe: en México se modificó la marcación a teléfonos celulares, por lo que el prefijo 044 ya no es necesario. Actualizaremos ahora nuestro dataframe para eliminar el prefijo 044.

     Para ello usaremos  el comando:

    mi_dataframe["nuevo_telefono"] =  mi_dataframe["telefono"].str[:-13]
    

    El resultado es:

    Python pandas: agregar una columna que se alimente a partir de datos en el propio dataframe

    Supongamos que ahora necesitamos agregar el índice de masa corporal... Ese valor será resultado del valor de dos columnas que existen en nuestro dataframe:  peso y estatura.

     Para ello usaremos  el comando:

    mi_dataframe["imc"] = mi_dataframe["peso"]  / (mi_dataframe["estatura"]*(mi_dataframe["estatura"]))
    

    Y el resultado será:

    Python pandas: agregar una columna cuyo valor depende de dos columnas que existen en nuestro dataframe

    Eliminar columnas en un dataframe

    Es posible eliminar una o más columnas de un dataframe. 

    Para este ejemplo usaremos el archivo jugadores.xlsx

    Y lo importaremos con el comando:

    mi_dataframe = pd.read_excel("jugadores.xlsx")

    El resultado es:

    Python pandas: Eliminar columnas en un dataframe

    Para eliminar una o más columnas de un dataframe   utilizaremos el comando:

    mi_dataframe = mi_dataframe.drop(["columna_a_borrar", "otra_columna"], axis=1)
    

    Ejemplo:

    mi_dataframe =  mi_dataframe.drop(["telefono",  "posicion"], axis=1)
    

    El resultado es:

    Python pandas: Eliminar columnas en un dataframe

    El parámetro axis=1 le indica a pandas eliminar una columna.  El parámetro axis=0  le indica a pandas eliminar un index.

    Otra manera de eliminar una columna es utilizar el parámetro columns. Ejemplo:

    mi_dataframe = mi_dataframe.drop(columns=["columna_a_borrar", "otra_columna"])
    

    Ejemplo:

    mi_dataframe =  mi_dataframe.drop(columns=["estatura",  "edad"])
    

    El resultado es:

    Python pandas: Otra manera de eliminar una columna es utilizar el parámetro columns

    Eliminar filas en un dataframe

    Es posible eliminar una o más filas de un dataframe. 

    Para este ejemplo usaremos el archivo jugadores.xlsx

    Y lo importaremos con el comando:

    mi_dataframe = pd.read_excel("jugadores.xlsx")
    

    El resultado es:

    Python pandas: Eliminar filas en un dataframe

    Es posible eliminar una o más filas tomando como referencia su index, para ello usamos el comando

    mi_dataframe =  mi_dataframe.drop([index_elemento_a_borrar, index_elemento_a_borrar])
    

    Ejemplo:

    mi_dataframe =  mi_dataframe.drop([0,10])
    # eliminaremos el elemento 0 y 10 de nuestro dataframe

    El resultado es:

    Python pandas: Es posible eliminar una o más filas tomando como referencia su index

    Es posible eliminar una o más filas tomando como referencia el valor en una de las columnas y si cumple o no una condición, para ello usamos el comando

    mi_dataframe = mi_dataframe[mi_dataframe.columna condicion]
    

    Ejemplo:

    mi_dataframe = mi_dataframe[mi_dataframe.edad == 27]
    # eliminaremos los registros cuya edad no sea 27
    

    El resultado es:

    Python pandas: Es posible eliminar una o más filas tomando como referencia el valor en una de las columnas y si cumple o no una condición

    Reconstruyamos nuestro dataframe para poner otro ejemplo. Para este ejemplo usaremos el archivo jugadores.xlsx

    Y lo importaremos con el comando:

    mi_dataframe = pd.read_excel("jugadores.xlsx")

    El resultado es:

    Python pandas:

    Ahora queremos eliminar a  todos los que tengan una edad de  27. Ejemplo:

    mi_dataframe = mi_dataframe[mi_dataframe.edad != 27]
    # eliminaremos los registros cuya edad sea 27
    

    El resultado es:

    Python pandas: queremos eliminar a  todos los que tengan una edad de  27

    Reconstruyamos nuestro dataframe para poner otro ejemplo.Para este ejemplo usaremos el archivo jugadores.xlsx

    Y lo importaremos con el comando:

    mi_dataframe = pd.read_excel("jugadores.xlsx")

    El resultado es:

    Python pandas:

    Ahora queremos eliminar a  todos los que tengan una edad menor de 27. Ejemplo:

    mi_dataframe = mi_dataframe[mi_dataframe.edad > 27]
    # eliminaremos los registros cuya edad sea 27 o menos
    

    El resultado es:

    Python pandas: Ahora queremos eliminar a  todos los que tengan una edad menor de 27

    Eliminar duplicados

    Es posible eliminar eliminar registros duplicados en un dataframe.  Para ello utilizaremos el comando:

    mi_dataframe = mi_dataframe.drop_duplicates()
    

    Sí. ¡Con una línea de código!

    Hacer una iteración en un dataframe

    Es posible hacer una iteración en un dataframe. Para ello usaremos el comando:

    for registro in range(0, len(mi_dataframe)): 
     print mi_dataframe.iloc[registro]['columna_a_mostrar']; 
     print mi_dataframe.iloc[registro]['columna_a_mostrar_02']; 
    

    Para este ejemplo usaremos el archivo jugadores.xlsx

    Y lo importaremos con el comando:

    mi_dataframe = pd.read_excel("jugadores.xlsx")

    El resultado es:

    Python pandas:

    Haremos una iteración en el dataframe y mostraremos el nombre y la edad. Para ello usaremos el comando:

    for registro in range(len(mi_dataframe)): 
     print(mi_dataframe.iloc[registro]['nombre']); 
     print(mi_dataframe.iloc[registro]['edad']);
    

    El resultado es:

    Python pandas: Haremos una iteración en el dataframe y mostraremos el nombre y la edad.

    Concatenar dataframes

    Es muy común que datos los tengamos dispersados en varias hojas de excel, bases de datos, archivos csv, etc.

    Es posible importar cada uno de esos archivos en un dataframe y luego concatenarlos en un dataframe que tenga la información de TODOS LOS ARCHIVOS para su posterior análisis...

    Supongamos que tenemos varios archivos de excel con el registro de la ventas de varios productos por mes para cada año:

    Python pandas: Supongamos que tenemos varios archivos de excel con el registro de la ventas de varios productos por mes para cada año

    Los archivos de excel para este ejemplo pueden descargarse aquí

    Una opción es copiar y pegar los datos... Pero es posible que se cometan errores.

    Mejor podemos invocar al poder de python y pandas para hacerlo. Más aún, usaremos una iteración que busque todos los archivos de excel, cree un dataframe a partir de cada archivo de excel y finalmente  los concatene en un dataframe que contenga toda la información.

    Para ello podemos usar el siguiente código:

    mi_dataframe_final = pd.DataFrame() 
    # creamos un dataframe donde almacenaremos la información de todos los archivos de excel 
    
    import os 
    # importamos la librería os para tener acceso al file system 
    
    #hacemos una iteración en el directorio actual 
    for archivo in os.listdir("."): 
     # buscamos archivos de excel 
     if archivo.endswith(".xlsx"): 
     print(archivo) 
     # mostramos en pantalla el nombre del archivo que importaremos 
     mi_dataframe_temporal = pd.DataFrame() 
     # creamos un dataframe vacio 
     mi_dataframe_temporal = pd.read_excel(archivo) 
     # creamos un dataframe a partir del archivo de excel 
     mi_dataframe_final = mi_dataframe_final.append(mi_dataframe_temporal, ignore_index=True) 
     # concatenemos el dataframe al datraframe final
    

    Y el resultado, un dataframe con los datos de todos los archivo de excel en la carpeta:

    Python pandas: el resultado, un dataframe con los datos de todos los archivo de excel en la carpeta

    Funciones aritméticas y estadísticas de pandas

    Bueno... hasta ahora casi no hemos visto nada fuera de lo común y extraordinario... Nada que no podamos hacer con una hoja de excel.  Comencemos a ver algunas de las funciones aritméticas y estadísticas que pandas tiene incluidas.

    Para ello vamos a crear un dataframe de forma manual que almacene los nombres de los Estados de México, con el nombre de su capital, su población, su superficie territorial y la fecha en que se incorporaron a la federación:

    estados = pd.DataFrame( 
    { 
    
    'nombre':['Aguascalientes','Baja California','Baja California Sur','Campeche','Chiapas',
    'Ciudad de México','Chihuahua','Coahuila de Zaragoza','Colima','Durango','Guanajuato','Guerrero',
    'Hidalgo','Jalisco','México','Michoacán de Ocampo','Morelos','Nayarit','Nuevo León','Oaxaca',
    'Puebla','Querétaro de Arteaga','Quintana Roo','San Luis Potosí','Sinaloa','Sonora','Tabasco',
    'Tamaulipas','Tlaxcala','Veracruz','Yucatán','Zacatecas'], 
    
    'capital':['Aguascalientes','Mexicali','La Paz','Campeche','Tuxtla Gutiérrez','Ciudad de México',
    'Chihuahua','Saltillo','Colima','Durango','Guanajuato','Chilpancingo','Pachuca','Guadalajara',
    'Toluca','Morelia','Cuernavaca','Tepic','Monterrey','Oaxaca','Puebla','Querétaro','Chetumal',
    'San Luis Potosí','Culiacán','Hermosillo','Villahermosa','Ciudad Victoria','Tlaxcala','Xalapa',
    'Mérida','Zacatecas'], 
    
    'superficie':[5618,71446,73922,57924,73289,1495,247455,151563,5625,123451,30608,63621,20846,
    78599,22357,58643,4893,27815,64220,93793,34290,11684,42361,60983,58200,179503,24738,80175,3991,
    71820,39612,75539], 
    
    'poblacion':[1184996,3155070,637026,822441,4796580,8918653,3406465,2748391,650555,1632934,
    5486372,3388768,2665018,7350682,15175862,4351037,1777227,1084979,4653458,3801962,5779829,
    1827937,1325578,2585518,3216000,2662480,2238603,3268554,1169936,7643194,1955577,1490668], 
    
    'fecha':['1857-02-05','1952-01-16','1974-10-08','1863-04-29','1824-09-14','2016-01-29',
    '1824-07-06','1824-05-07','1856-09-12','1824-05-22','1823-12-20','1849-10-27','1869-01-16',
    '1823-12-23','1823-12-20','1823-12-22','1869-04-17','1917-01-26','1824-05-07','1823-12-21',
    '1823-12-21','1823-12-23','1974-10-08','1823-12-22','1830-10-14','1824-01-10','1824-02-07',
    '1824-02-07','1856-12-09','1823-12-22','1823-12-23','1823-12-23'] 
    } 
    ) 
    

    Para sumar los valores de una columna en  un dataframe utilizaremos el comando:

    mi_data_frame[nombre_columna].sum()

    Así para sumar la columna población  de nuestro dataframe de ejemplo utilizaremos el comando:

    estados['poblacion'].sum()
    

    Python pandas: para sumar la columna población  de nuestro dataframe de ejemplo utilizaremos el comando sum()

    Para obtener el valor máximo de una columna en  un dataframe utilizaremos el comando:

    mi_data_frame[nombre_columna].max()
    

    Así para obtener el valor máximo de la columna población  de nuestro dataframe de ejemplo utilizaremos el comando:

    estados['poblacion'].max()
    

    Python pandas: >Para obtener el valor máximo de una columna en  un dataframe utilizaremos el comando max()

    Pero... ¿a que estados pertenecen esos datos? ¿Cómo podemos recuperar el Estado con la mayor población junto con su nombre?

    En python la misma tarea se puede hacer de diferentes formas... con diferentes funciones. Por ejemplo para la tarea arriba referida podemos usar los comandos:

    mi_dataframe.loc[mi_dataframe['columna_a_buscar'].idxmax()]
    
    # o también podemos usar:
    
    mi_dataframe[mi_dataframe['columna_a_buscar']==mi_dataframe['columna_a_buscar'].max()]
    

    Para nuesto caso el código a emplear es: 

    estados.loc[estados['poblacion'].idxmax()]
    

    Python pandas: recuperar el Estado con la mayor población junto con su nombre

    El mismo resultado lo podemos obtener con el comando:

    estados[estados['poblacion']==estados['poblacion'].max()]
    

    Python pandas:

    Podemos almacenar el resultado en una variable... Y ahí comenzaremos a detectar algunas diferencias. Para el primer código obtenemos una serie, una especie de list:

    resultado = estados.loc[estados['poblacion'].idxmax()]
    type(resultado)
    

    Python pandas: Podemos almacenar el resultado de idxmax() en una variable...

    La serie es una especie de list, así que podemos acceder a sus elementos por el índice / posición que ocupa dentro:

    resultado[0]
    # muestra la primera columna, el nombre del Estado
    resultado[1]
    # muestra la segunda columna, el nombre de la capital
    resultado[2]
    # muestra la tercera columna, la superficie
    resultado[3]
    # muestra la cuarta columna, la población
    

    Python pandas: La serie es una especie de list

    Mientras que para el segundo código obtenemos un dataframe:

    resultado2 = estados[estados['poblacion']==estados['poblacion'].max()]
    type(resultado2)
    

    Python pandas: max() nos devuelve un dataframe

    Al ser un dataframe  podemos acceder a sus elementos por el nombre de la columna:

    resultado2['nombre']
    # muestra la primera columna, el nombre del Estado
    resultado2['capital']
    # muestra la segunda columna, el nombre de la capital
    resultado2['superficie']
    # muestra la tercera columna, la superficie
    resultado2['poblacion']
    # muestra la cuarta columna, la población
    

    Python pandas: Al ser un dataframe  podemos acceder a sus elementos por el nombre de la columna

    Misma lógica usaremos para obtener el valor mínimo de una columna. Para ello en  un dataframe utilizaremos el comando:

    mi_data_frame[nombre_columna].min()

    Así para obtener el valor mínimo de la columna población  de nuestro dataframe de ejemplo utilizaremos el comando:

    estados['poblacion'].min()
    

    Python pandas: obtener el valor mínimo de la columna población  de nuestro dataframe

    Pero... ¿a que estados pertenecen esos datos? ¿Cómo podemos recuperar el Estado con la menor población junto con su nombre?

    Por ejemplo para la tarea arriba referida podemos usar los comandos:

    mi_dataframe.loc[mi_dataframe['columna_a_buscar'].idxmin()]
    
    # pero también podemo usar:
    
    mi_dataframe[mi_dataframe['columna_a_buscar']==mi_dataframe['columna_a_buscar'].min()]
    

    Para nuesto caso el código a emplear es: 

    estados.loc[estados['poblacion'].idxmin()]
    

    Python pandas: obtener el valor mínimo de la columna población  de nuestro dataframe

    El mismo resultado lo podemos obtener con el comando:

    estados[estados['poblacion']==estados['poblacion'].min()]
    

    Python pandas: min()

    Podemos almacenar el resultado en una variable... Y ahí comenzaremos a detectar algunas diferencias. Para el primer código obtenemos una serie, una especie de list:

    resultado = estados.loc[estados['poblacion'].idxmin()]
    type(resultado)
    

    Python pandas: el resultado se almacena en una serie

    La serie es una especie de list, así que podemos acceder a sus elementos por el índice / posición que ocupa dentro:

    resultado[0]
    # muestra la primera columna, el nombre del Estado
    resultado[1]
    # muestra la segunda columna, el nombre de la capital
    resultado[2]
    # muestra la tercera columna, la superficie
    resultado[3]
    # muestra la cuarta columna, la población
    

    Python pandas: La serie es una especie de list, así que podemos acceder a sus elementos por el índice

    Mientras que para el segundo código obtenemos un dataframe:

    resultado2 = estados[estados['poblacion']==estados['poblacion'].min()]
    type(resultado2)
    

    Python pandas: con min() obtenemos un dataframe

    Al ser un dataframe  podemos acceder a sus elementos por el nombre de la columna:

    resultado2['nombre']
    # muestra la primera columna, el nombre del Estado
    resultado2['capital']
    # muestra la segunda columna, el nombre de la capital
    resultado2['superficie']
    # muestra la tercera columna, la superficie
    resultado2['poblacion']
    # muestra la cuarta columna, la población
    

    Python pandas: Al ser un dataframe  podemos acceder a sus elementos por el nombre de la columna

    Para obtener el promedio de una columna en  un dataframe utilizaremos el comando:

    mi_data_frame[nombre_columna].mean()

    Así para obtener el promedio de la columna población  de nuestro dataframe de ejemplo utilizaremos el comando:

    estados['poblacion'].mean()

    Python pandas: mean() obtener el promedio de la columna

    Así para obtener el promedio de la columna superficie  de nuestro dataframe de ejemplo utilizaremos el comando:

    estados['superficie'].mean()

    Python pandas: mean() obtener el promedio de la columna

    Para obtener la desviación standard de una columna en  un dataframe utilizaremos el comando:

    mi_data_frame[nombre_columna].std()

    Así para obtener la desviación standard de la columna población  de nuestro dataframe de ejemplo utilizaremos el comando:

    estados['poblacion'].std()

    Python pandas: std() obtener la desviación standard

    Así para obtener la desviación standard de la columna superficie  de nuestro dataframe de ejemplo utilizaremos el comando:

    estados['superficie'].std()

    Python pandas: std() obtener la desviación standard

    Para obtener la varianza  de una columna en  un dataframe utilizaremos el comando:

    mi_data_frame[nombre_columna].var()

    Así para obtener la varianza de la columna población  de nuestro dataframe de ejemplo utilizaremos el comando:

    estados['poblacion'].var()

    Python pandas: var() obtener la varianza

    Así para obtener la varianza  de la columna superficie  de nuestro dataframe de ejemplo utilizaremos el comando:

    estados['superficie'].var()

    Python pandas: var() obtener la varianza 

    Podemos ordenar nuestro dataframe de manera ascendente o descendente en relación a cualquier columa. Para ello usaremos el comando:

    mi_data_frame.sort_values(by=['nombre_columna'], ascending=False/True)

    Así para ordenar nuestro dataframe de ejemplo  a partir de la columna población de manera ascendente utilizaremos el comando:

    estados.sort_values(by=['poblacion'], ascending=False)

    Python pandas: sort_values() ordenar valores de manera descendente

    Así para ordenar nuestro dataframe de ejemplo  a partir de la columna población de manera descendente utilizaremos el comando:

    estados.sort_values(by=['poblacion'], ascending=True)

    Python pandas: sort_values() ordenar valores de manera ascendente

    Para analizar un dataframe y detectar cuantos valores únicos hay en una columna y su frecuencia, cantidad de veces que ocurren, podemos utilizar el comando:

    mi_data_frame[nombre_columna].value_counts()

    Así para detectar cuantos valores únicos hay en la columna fecha y su frecuencia, cantidad de veces que ocurren,   en nuestro dataframe de ejemplo utilizaremos el comando:

    estados['fecha'].value_counts()

    Python pandas: value_counts() contar valores únicos

    Actualmente México es una federación de 31 Estados y la Ciudad de México. Descubrimos ahora que al inicio, el 20 de septiembre de 1823,  sólo había 2 Estados miembros de la federación... y con el paso de los días y años se fueron incorporando nuevos Estados.

    ¿Cómo fue esa incorporación? Podemos verlo con el comando:

    estados.sort_values(by=['fecha'], ascending=True)

    Y el resultado es:

    Python pandas: sort_values() ordenar valores

    Podemos obtener también la suma acumulada de una columna en  un dataframe, para ello utilizaremos el comando:

    mi_data_frame[nombre_columna].cumsum()

    Así para obtener la suma acumulada de la columna población  de nuestro dataframe de ejemplo utilizaremos el comando:

    estados['poblacion'].cumsum()

    Python pandas: cumsum() suma acumulada

    Merge, combinar, dataframes

    Podemos concatenar dos o más dataframes. Pero también podemos combinarlos / merge y compararlos para detectar que valores están presentes en uno u otro dataframe. Una vez combinados, podemos realizar el análisis de nuestro dataframe.

    Para ello ulilizaremos el comando:

    merge()

    Para este ejemplo vamos a crear dos dataframes de forma manual que almacene los nombres de los Estados de México y su población en dos diferentes años 2010 y 2020:

    estados_2010 = pd.DataFrame( 
    { 
    'nombre':['Aguascalientes','Baja California','Baja California Sur','Campeche','Chiapas',
    'Distrito Federal','Chihuahua','Coahuila','Colima','Durango','Guanajuato','Guerrero',
    'Hidalgo','Jalisco','México','Michoacán','Morelos','Nayarit','Nuevo León','Oaxaca','Puebla',
    'Querétaro','Quintana Roo','San Luis Potosí','Sinaloa','Sonora','Tabasco','Tamaulipas','Tlaxcala',
    'Veracruz','Yucatán','Zacatecas'], 
    
    'poblacion':[1184996,3155070,637026,822441,4796580,8918653,3406465,2748391,650555,1632934,5486372,
    3388768,2665018,7350682,15175862,4351037,1777227,1084979,4653458,3801962,5779829,1827937,1325578,
    2585518,3216000,2662480,2238603,3268554,1169936,7643194,1955577,1490668]
    } 
    ) 
    
    estados_2020 = pd.DataFrame( 
    { 
    'nombre':['Aguascalientes','Baja California','Baja California Sur','Campeche','Chiapas',
    'Chihuahua', 'Ciudad de México','Coahuila','Colima','Durango','Guanajuato','Guerrero',
    'Hidalgo','Jalisco','México','Michoacán','Morelos','Nayarit','Nuevo León','Oaxaca','Puebla',
    'Querétaro','Quintana Roo','San Luis Potosí','Sinaloa','Sonora','Tabasco','Tamaulipas','Tlaxcala',
    'Veracruz','Yucatán','Zacatecas'], 
    'poblacion':[1425607,3769020,798447,928363,5543828,3741869,9209944,3146771,731391,1832650,6166934,
    3540685,3082841,8348151,16992418,4748846,1971520,1235456,5784442,4132148,6583278,2368467,1857985,
    2822255,3026943,2944840,2402598,3527735,1342977,8062579,2320898,1622138]
    } 
    ) 
    

    Si los concatenaramos, tendríamos un dataframe con 64 filas... Pero nosotros queremos crear un dataframe con 32 filas, una para cada estado, y una columna con la población en el año 2010 y una columna con la población en el año 2020.

    Para ello usaremos el comando merge()

    estados_2010_vs_2020 = estados_2010.merge(estados_2020,on=['nombre'], how="left", indicator=True)
    

    El resultado de este comando es:

    Python pandas: Un merge de dos dataframes

    Con este código creamos un nuevo dataframe llamado estados_2010_vs_2020 que combinará los dos dataframes.

    Usaremos como punto de partida y referencia para nuesta combinación el dataframe  estados_2010 y sobre ese dataframe vaciaremos los datos almacenados en el dataframe  estados_2020

    Con el parámetro on definimos las columnas que utilizaremos como referencia para realizar la combinación, en este ejemplo combinaremos los dataframes a partir de la columna nombre, que almacena el nombre del estado. Pandas permite utilizar una o varias columnas  como referencia para realizar la combinación.

    Con el parámetro how definimos como se combinarán los dataframes. El parámetro how tiene varios posibles valores:

    left:  para este ejemplo utiliza como punto de partida y referencia para nuesta combinación el dataframe  estados_2010 y sobre ese dataframe vaciaremos los datos almacenados en el dataframe  estados_2020. Si hay datos  en el dataframe  estados_2020 que no existen en el  dataframe  estados_2010, no se mostrarán en el resultado final.

    right: para este ejemplo utiliza como punto de partida y referencia para nuesta combinación el dataframe  estados_2020 y sobre ese dataframe vaciaremos los datos almacenados en el dataframe  estados_2010. Si hay datos  en el dataframe  estados_2010 que no existen en el  dataframe  estados_2020, no se mostrarán en el resultado final.

    outter: para este ejemplo utiliza como punto de partida y referencia para nuesta combinación el dataframe  estados_2010 y sobre ese dataframe vaciaremos los datos almacenados en el dataframe  estados_2020. Si hay datos  en el dataframe  estados_2020 que no existen en el  dataframe  estados_2010, SÍ se mostrarán en el resultado final.

    inner: para este ejemplo utiliza como punto de partida y referencia para nuesta combinación el dataframe  estados_2010 y sobre ese dataframe vaciaremos los datos almacenados en el dataframe  estados_2020. Si hay datos  en el dataframe  estados_2020 que no existen en el  dataframe  estados_2010, NO se mostrarán en el resultado final.

    Con el parámetro indicator=True especificamos que pandas cree una columna que nos indique el resultado de la combinación, para detectar si hay datos que no existen en un dataframe

    Bien dicen que una imagen vale más que mil palabras, así que ilustremos mejor el resultado del parámetro how.

    Un ejemplo con left:

    estados_2010_vs_2020 = estados_2010.merge(estados_2020,on=['nombre'], how="left", indicator=True)
    

    El resultado de este comando es:

    Python pandas: Un merge con el valor left en el parámetro how

    Como podemos ver el registro con el estado Ciudad de México que existe en el dataframe estados_2020 no aparece en el resultado de la combinación (Nota en el año 2016 el Distrito Federal cambió de nombre, su nuevo nombre es Ciudad de México).

    Y la columna _merge nos indica que ese registro sólo existe en uno de los dataframes.

    Un ejemplo con right:

    estados_2010_vs_2020 = estados_2010.merge(estados_2020,on=['nombre'], how="right", indicator=True)
    

    El resultado de este comando es:

    Python pandas: Un merge con el valor right en el parámetro how

    Como podemos ver el registro con el estado Distrito Federal que existe en el dataframe estados_2010 no aparece en el resultado de la combinación (Nota en el año 2016 el Distrito Federal cambió de nombre, su nuevo nombre es Ciudad de México).

    Y la columna _merge nos indica que ese registro sólo existe en uno de los dataframes.

    Un ejemplo con outer:

    estados_2010_vs_2020 = estados_2010.merge(estados_2020,on=['nombre'], how="outer", indicator=True)
    

    El resultado de este comando es:

    Python pandas: Un merge con el valor outer en el parámetro how

    En este caso outer nos indica los dos registros que no existen en los dos dataframes... Y más aún los incluye en el resultado final.  Así tenemos un registro para Ciudad de México y otro para Distrito Federal (Nota en el año 2016 el Distrito Federal cambió de nombre, su nuevo nombre es Ciudad de México).

    Y la columna _merge nos indica en que dataframe está cada uno de ellos.

    Un ejemplo con inner:

    estados_2010_vs_2020 = estados_2010.merge(estados_2020,on=['nombre'], how="inner", indicator=True)
    

    El resultado de este comando es:

    Python pandas: Un merge con el valor inner en el parámetro how

    En este caso inner excluye  los dos registros que no existen en los dos dataframes...

    Extraer datos de acciones de la bolsa de valores

    Wes McKinney creó pandas para hacer análisis cuantitativo en el sector financiero. Consecuentemente podemos consultar los valores de las acciones en la bolsa de valores con ayuda de pandas y hacer el análisis correspondiente.

    También es posible consultar los datos abiertos del Banco Mudial (World Bank) la OCDE (OECD) o las estadísticas oficiales de la Unión Europea vía Eurostat.

     Para facilitar la consulta, es necesario instalar la librería pandas_datareader.

    En windows la librería pandas_datareader  se instala con el comando:

    pip install pandas_datareader

    En Ubuntu con python 3 la librería pandas_datareader  se instala con el comando:

    pip3 install pandas_datareader

    Para crear una gráfica con la información, usaremos la libería matplotlib.

    Una vez instaladas las librerías pandas_datareader y  matplotlib iniciamos python e importamos las librerías:

    import pandas as pd 
    from pandas_datareader import data 
    import datetime as dt 
    import matplotlib.pyplot as plt
    

    Python pandas: importamos pandas, pandas_datareader y matplotlib

    Enseguida definimos la acción a consultar y el periodo de tiempo. En este ejemplo se consultara el valor de la acción de Tesla del 25 de julio de 2022 al 29 de julio de 2022. Par ello se utiliza el comando:

    data1 = data.DataReader(name='TSLA', data_source='yahoo', start='2022-07-25', end='2022-07-29') 
    # hacemos la consulta del valor de la acciòn
    # el parámetro name define la acción a consultar por sus siglas, acorde al NYSE
    # TSLA son las acciones de Tesla
    # el parámetro source define el servidor que consultaremos
    # en este ejemplo utilizamos los servidores de yahoo para descargar el valor de las acciones
    # el parámetro start define la fecha inicial de la consulta
    # en este caso 25 de julio de 2022
    # el parámetro end define la fecha final de la consulta
    # en este caso 29 de julio de 2022
    

    Python pandas: Extraer datos de acciones de la bolsa de valores

    Algunas siglas de acciones de empresas famosas:

    El resultado del comando es  un data frame:

    Python pandas: Extraer datos de acciones de la bolsa de valores y almacenarlos en un data frame

    Y este es  el contenido del dataframe:

    Python pandas:

    El dataframe incluye los siguientes datos de la acción

    Con ayuda de una list podemos extraer el valor de varias acciones simultáneamente y elegir una de las columnas. En este ejemplo seleccionaremos varias acciones y solo extraeremos el precio al final de las operaciones del mercado

    data1 = data.DataReader(name=['AAPL', 'GOOGL', 'AMZN', 'MSFT'], data_source='yahoo', start='2022-07-25', end='2022-07-29')['Close']
    

    Python pandas: podemos extraer el valor de varias acciones simultáneamente

    Y el resultado es:

    Python pandas: podemos extraer el valor de varias acciones simultáneamente

    Con ayuda de matplotlib podemos crear una gráfica.  Para ello utilizaremos los comandos:

    data1.plot(title='Precio de la acción') 
    #creamos la gráfica 
    plt.show() 
    # mostramos la gráfica
    

    Python pandas: Con ayuda de matplotlib podemos crear una gráfica.

    Y el resultado se mostrará en la pantalla:

    Python pandas: Con ayuda de matplotlib podemos crear una gráfica.

    Este ejemplo es parte de un tutorial más completo que puede consultarse:

    Sitios de interés

    Sitio oficial de Python


    Comenta y opina este texto     Lee mi libro de visitas
    © 1997-2022 Alain García Gómez
    albegago@hotmail.com
    Twitter: Youtube @feesgo
    YouTube Youtube
    El vínculo a este documento es:

    Compartir en facebook Compartir en twitter Compartir en whatsapp Rss

    Puedes apoyar a este sitio invitándome a comer...

    Este sitio utiliza cookies propias y de terceros para mejorar sus servicios. Si continua navegando, entendemos que acepta su uso. Política de Privacidad