Pandas es una herramienta de código abierto para la manipulación y análisis de datos.

• Web oficial

En Ubuntu se puede instalar mediante el paquete python3-pandas y en Arch Linux con python-pandas

También se puede instalar a través de pip:

pip3 install pandas

Para importar pandas:

import pandas as pd

Para crear una serie de panda a partir de una lista:

import panda as pd
 
helados = ["Chocolate", "Vainilla", "Fresa", "Limón"]
 
pd.Series(helados)
 
# Resultado
# 0    Chocolate
# 1     Vainilla
# 2        Fresa
# 3        Limón
# dtype: object

En la parte izquierda está el índice. No tiene por qué ser índice numérico.

Para crear una serie de panda a partir de un diccionario:

import pandas as pd
 
webster = {
           "Plátano": "Fruta deliciosa",
           "Púrpura": "Un color"
           }
 
pd.Series(webster)
 
# Resultado
# Plátano    Fruta deliciosa
# Púrpura           Un color
# dtype: object

Para crear una serie a partir de datos externos, por ejemplo, de un fichero CSV:

import pandas as pd
a = pd.read_csv("ruta/fichero.csv", usecols = ["Titulo1"], squeeze = True)

• usecols: permite indicar qué columna leer del CSV.
• squeeze: si los datos procesados contienen solo una columna, devolverá una Serie en lugar de un objeto DataFrame.

Información sobre las series.

import pandas as pd
 
about_me = ["Smart", "Handsome", "Charming", "Brilliant", "Humble"]
 
s = pd.Series(about_me)

• *.values: array de todos los valores de la serie.
• *.index: indica dónde empieza la serie, donde termina y cómo van incrementándose los índices de la serie.
• *.dtype: devuelve el tipo de dato que contiene la serie.
• *.is_unique: indica si todos los elementos son únicos (no se repiten)
• *.ndim: número de dimensiones (las series solo tienen 1 dimensión)
• *.shape: devuelve una tupla con el número de filas y columnas.
• *.size': cuenta el número de elementos.
• *.name: nombre de la serie.

Cálculos o modificaciones sobre la serie.

• *.sum(): suma los elementos de una serie
• *.prod(): multiplicación de todos los elementos de la serie.
• *.mean(): devuelve la media de los elementos de la serie.
• *.head(): devuelve, por defecto, los primeros 5 elementos de la serie. Entre paréntesis se puede indicar el número de elementos a devolver.
• *.tail(): devuelve, por defecto, los últimos 5 elementos de la serie. Entre paréntesis se puede indicar el número de elementos a devolver.
• *.short_values(): ordena los elementos (pero no sus índices)
• *.short_index(): ordena los índices.
• *.count(): número de elementos (excluye los elementos vacíos o inexistentes).
• *.min(): devuelve el valor más pequeño.
• *.max(): devuelve el valor más grande.
• *.median(): devuelve la mediana (el valor que está en el medio después de ordenar los elementos)
• *.mode(): devuelve el valor que más se repite.
• *.describe(): realiza varias operaciones a la vez.
• *.value_counts(): devuelve el número de veces que aparece un elemento. Parecida a la función PIVOT de Excel.
• *.apply(funcion): realiza una operación sobre los elementos.

Si queremos modificar una estructura de Pandas tras aplicarle un método, tenemos que usar el argumento inplace:

numeros = [1.3, 2.8, 10.5, 0.3]
 
numeros.sort_values(inplace = True)
 
numeros
 
# Resultado:
# >>> numeros
# 3     0.3
# 0     1.3
# 1     2.8
# 2    10.5
# dtype: float64

Podemos usar la palabra reservada in para buscar un elemento en una serie

import pandas as pd
 
numeros = [1, 4, 19, 23]
 
n = numeros.Series(numeros)
 
1 in n.values
 
# Resultado:
# True

Se utilizan los corchetes para indicar las posiciones de los índices que queremos extraer.

import pandas as pd
 
numeros = [1, 4, 19, 23]
 
n = numeros.Series(numeros)
 
n[2]
 
# Resultado:
# 19
 
n[[0, 1, 2]]
 
# Resultado:
# >>> n[[0, 1, 2]]
# 0     1
# 1     4
# 2    19
# dtype: int64

Se puede utilizar también las etiquetas de índice para hacer las extracciones:

import pandas as pd
 
paises_ciudades = pd.read_csv("paises_ciudades.csv", index_col = "País", squeeze = True)
 
paises_ciudades
# Resultado
País
España     Madrid
Francia     París
España     Burgos
Name: Ciudad, dtype: object
 
paises_ciudades["España"]
 
# Resultado: 
# País
# España    Madrid
# España    Burgos
# Name: Ciudad, dtype: object

Si queremos quedarnos con las filas cuya columna Edad tenga un valor de 18 o más:

print(df.loc[df['Edad'] >= 18])

Podemos encadenar condiciones:

print(df.loc[(df['Edad'] >= 18) & (df['Sexo'] == "Mujer")])

Las series son estructuras de una dimensión (una columna de datos). Un DataFrame es una estructura bidimensional, consiste en filas y columnas, como una tabla.

El tema de las dimensiones viene por el número de referencias que tenemos que dar a la hora de extraer algún valor. Por ejemplo, en las series, nos basta con el índice para indicar que queremos trabajar con el dato que hay en la posición 100. Con los DataFrames esto no es suficiente ya que además de indicar la fila, tenemos que hacer referencia a la columna para indicar unívocamente el dato de interés.

import pandas as pd

Ejemplo de DataFrame a partir de la carga de un fichero CSV:

>>> sales
                           Region               Country   Item Type Sales Channel Order Priority  Order Date   Order ID   Ship Date  Units Sold  Unit Price  Unit Cost  Total Revenue  Total Cost  Total Profit
0    Middle East and North Africa                 Libya   Cosmetics       Offline              M  10/18/2014  686800706  10/31/2014        8446      437.20     263.33     3692591.20  2224085.18    1468506.02
1                   North America                Canada  Vegetables        Online              M   11/7/2011  185941302   12/8/2011        3018      154.06      90.93      464953.08   274426.74     190526.34
2    Middle East and North Africa                 Libya   Baby Food       Offline              C  10/31/2016  246222341   12/9/2016        1517      255.28     159.42      387259.76   241840.14     145419.62
3                            Asia                 Japan      Cereal       Offline              C   4/10/2010  161442649   5/12/2010        3322      205.70     117.11      683335.40   389039.42     294295.98
4              Sub-Saharan Africa                  Chad      Fruits       Offline              H   8/16/2011  645713555   8/31/2011        9845        9.33       6.92       91853.85    68127.40      23726.45
..                            ...                   ...         ...           ...            ...         ...        ...         ...         ...         ...        ...            ...         ...           ...
995  Middle East and North Africa            Azerbaijan      Snacks       Offline              C   4/18/2010  534085166   4/25/2010        6524      152.58      97.44      995431.92   635698.56     359733.36
996                        Europe               Georgia   Baby Food       Offline              H    8/1/2011  590768182    9/7/2011         288      255.28     159.42       73520.64    45912.96      27607.68
997  Middle East and North Africa  United Arab Emirates  Vegetables        Online              C   5/12/2011  524363124   6/28/2011        9556      154.06      90.93     1472197.36   868927.08     603270.28
998                        Europe               Finland   Household       Offline              L   1/25/2016  289606320   2/14/2016        9801      668.27     502.54     6549714.27  4925394.54    1624319.73
999                        Europe              Portugal      Cereal       Offline              C   4/10/2014  811546599    5/8/2014        3528      205.70     117.11      725709.60   413164.08     312545.52

[1000 rows x 14 columns]

Muchos son los mismos que en las series.

• *.head(): devuelve las 5 primeras líneas del DataFrame.
• *.tail(): devuelve las 5 últimas líneas del DataFrame.
• .*min(): devuelve el valor mínimo de cada columna.
• .*max(): devuelve el valor máximo de cada columna.
• *.dtypes(): devuelve el tipo de dato de cada columna
• *.columns(): devuelve las columnas del DataFrame.
• *.columns.values: devuelve un array de Numpy con el nombre de las columnas del DataFrame.
• *.columns.values.tolist(): devuelve una lista con los nombres de las columnas del DataFrame.
• *.value_counts(): devuelve cuántas veces aparece cierto elemento (como agrupar).
• *.info(): devuelve información sobre el DataFrame
• *.describe(): realiza varias operaciones a la vez.
• *.nunique(): devuelve los valores únicos de una columna.

>>> sales.info()
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1000 entries, 0 to 999
Data columns (total 14 columns):
 #   Column          Non-Null Count  Dtype
---  ------          --------------  -----
 0   Region          1000 non-null   object
 1   Country         1000 non-null   object
 2   Item Type       1000 non-null   object
 3   Sales Channel   1000 non-null   object
 4   Order Priority  1000 non-null   object
 5   Order Date      1000 non-null   object
 6   Order ID        1000 non-null   int64
 7   Ship Date       1000 non-null   object
 8   Units Sold      1000 non-null   int64
 9   Unit Price      1000 non-null   float64
 10  Unit Cost       1000 non-null   float64
 11  Total Revenue   1000 non-null   float64
 12  Total Cost      1000 non-null   float64
 13  Total Profit    1000 non-null   float64
dtypes: float64(5), int64(2), object(7)
memory usage: 109.5+ KB

Si queremos mostrar un resumen de operaciones habituales, pero solo con los valores que no son numéricos, pasamos las opción include con el valor O:

df.describe(include = "O")

Podemos coger una columna por su nombre:

sales.Country

Se creará una serie.

Si la columna tiene un espacio, entonces es mejor hacer referencia por la etiqueta:

sales["Client Name"]

Para extraer más de una columna:

sales[ ["Client Name", "Salary"] ]

Como extraemos más de una columna, el objeto resultante será un DataFrame y no una serie.

Si queremos añadir una fila al final del DataFrame:

df.append({"Nombre": "Pepito", "Año": 2000, "Edad": 20}, ignore_index=True)

Podemos añadir un DataFrame en otro:

df2.append(df1, ignore_index=True)

sales["City"] = "Madrid"

Se creará una nueva columna llamada “City” con el valor “Madrid” en todas sus filas.

Si queremos indicar la posición de la nueva columna, utilizaremos el método insert():

sales.insert(3, column = "City", value = "Madrid")

Con el anterior código decimos que la nueva columna “City” ocupará la posición 3 (será entonces la columna 4) y todos sus valores serán “Madrid”.

También se pueden crear columnas calculadas:

sales["Salary+Bonus"] = sales["Salary"] + sales["Bonus"]

Utilizamos el método drop()

# Eliminar la fila que ocupa la posición 10:
sales.drop(10)

Utilizamos también el método drop(), pero con el argumento axis a 1 para indicar que queremos eliminar columnas:

# Eliminar la columna que ocupa la posición 10:
sales.drop(10, axis = 1)

También podemos borrarla utilizando la función del:

del sales["Region"]

También podemos eliminarla con método pop():

sales.pop("Region")

Utilizamos el método dropna() para eliminar las filas que contienen algún valor NaN.

sales.dropna()

Para eliminar solo las filas completamente vacías:

sales.dropna(how = "all")

Utilizamos también el método dropna() pero cambiando el eje:

sales.dropna(axis = 1)
 
# También se podría indicar así:
# sales.dropna(axis = "columns")

Podemos indicar las columnas a revisar:

sales.dropna(subset = ["Salary", "Country"])

Para aquellas “celdas” donde no hay datos (y Pandas indica con NaN), podemos indicar qué valor:

# Rellenar NaN con 0:
sales.fillna(0)

Podemos ir columna a columna:

sales["Salary"].fillna(0, inplace = True)

Para sustituir un valor por otro, utilizamos el método replace():

sales.replace("Espana", "España")

A este método se ls puede pasar un diccionario para realice diferentes sustituciones a la vez:

sales.replace({"Espana": "España", "madrid": "Madrid"})

Para ver el tipo de dato de cada columna, utilizamos dtype():

sales.dtypes
 
# Resultado
#>>> sales.dtypes
#Region             object
#Country            object
#Item Type          object
#Sales Channel      object
#Order Priority     object
#Order Date         object
#Order ID            int64
#Ship Date          object
#Units Sold          int64
#Unit Price        float64
#Unit Cost         float64
#Total Revenue     float64
#Total Cost        float64
#Total Profit      float64
#dtype: object

Para modificar el tipo de dato que contiene cada columna se puede usar el método astype():

sales["Unit Price"] = sales["Unit Price"].astype("int")

Si queremos pasar una fecha al formato ISO:

sales["Date"] = sales.to_datetime(sales["Date"])

Si el formato original de fecha no es estándar o Pandas no lo coge correctamente, podemos indicárselo con la opción format:

sales["Date"] = sales.to_datetime(sales["Date"], format="%d/%m/%Y")

Como un DataFrame es una estructura de dos dimensiones, debemos indicar la columna por la que queremos ordenar:

sales.sort_values("Salary")

Estaríamos ordenando todo el DataFrame en base a los valores de la columa “Salary”.

Si queremos ordenar en base a más de 1 columna:

sales.sort_values(["Client Name", "Salary"], ascending = [True, False])

Estamos ordenando “Client Name” en orden alfabético y “Salary” descendentemente.

Podemos filtrar por varios métodos:

• Posición
• where()
• query()

Si queremos quedarnos con las filas que tengan “Europe” como valor de la columna “Region”:

filtro = sales["Region"] == "Europe"
sales[filtro]
 
filtro = sales["Salary"] > 10000
sales[filtro]

Se pueden usar más de una condición para filtrar datos:

filtro1 = sales["Region"] == "Europe" 
filtro2 = sales["Salary"] > 10000
 
sales[filtro1 & filtro2]

• &: AND. Deben cumplirse todas las condiciones para obtener una verdad.
• |: OR. Si una de las condiciones es cierta, el total será verdad.

Si vamos a combinar varias condiciones con | es recomendable utilizar el método isin:

filtro = sales["Region"].isin(["Europe", "Asia"])
sales[filtro]

Estamos buscando las filas cuya “Region” sea “Europe” o “Asia”.

Si queremos buscar por un rango de valores, utilizamos el método between:

filtro = sales["Salary"].between(20000, 50000)
sales[filtro]

También podemos filtrar utilizando el método where():

filtro = sales["Salary"].between(20000, 50000)
sales.where(filtro)

La diferencia es que devuelve el DataFrame entero, pero solo están cubiertas las filas que cumplen la condición, el resto contienen NaN

Por último, el método query() se supone que es más eficiente para los filtrados:

sales.query("Country == 'Canada'")

Otro ejemplo:

sales.query("Country in ['Canada', 'Japan']")

Si queremos combinar condiciones:

sales.query("Country == 'Canada' and Salary > 10000")

Para filtrar por vacíos:

filtro = sales["Region"].isnull()
 
# Devuelve todas las filas donde "Region" esté vacío (NaN)
sales[filtro]

Lo contrario se haría con notnull():

filtro = sales["Region"].notnull()
 
# Devuelve todas las filas donde "Region" no esté vacío:
sales[filtro]

El método drop_duplicates() se usa para eliminar duplicados:

# Quedarnos con los valores únicos:
sales.drop_duplicates(subset = ["Item Type"], keep = "first")

Para contar los valores únicos, utilizamos el método unique():

sales["Region"].unique()
 
# Ejemplo de salida:
#array(['Middle East and North Africa', 'North America', 'Asia',
#       'Sub-Saharan Africa', 'Europe',
#       'Central America and the Caribbean', 'Australia and Oceania'],
#      dtype=object)

Para contarlos, utilizamos el método nunique:

sales["Region"].nunique(dropna = False)
 
# Resultado:
# 7

• dropna indica si queremos descartar los valores vacíos (NaN)

Utilizamos el método iloc():

# Obtener las filas desde el índice 0 al 9
sales.iloc[0:10]
 
# Obtener las filas del índice 0 y del 2
sales.iloc[[0,2]]

Podemos hacer la intersección con el segundo argumento:

sales.iloc[14, 2]
 
# Devuelve el contenido del índice 14 en su tercera (posición 2) columna.

Si queremos establecer los valores de cierta columna como índice del DataFrame:

sales.set_index("Order ID", inplace = True)

Si queremos volver a dejar los índices por defecto:

sales.reset_index(inplace = True)

Ahora podemos extraer datos en base a la etiqueta del índice:

sales.set_index("Region", inplace = True)
sales.loc["Europe"]

Podemos hacer la intersección indicando un segundo argumento al método loc():

sales.loc["Europe", "Item Type"]
 
# Devuelve las filas cuya "Region" sea "Europe" y su valor de "Item Type"

Para extraer filas al azar, se puede utilizar el método sample():

# Extrae una fila al azar:
sales.sample()

Podemos indicar el número de filas a extraer:

# Extraer 10 muestras al azar:
sales.sample(n = 10)

Incluso podríamos extraer por fracciones del total:

# Extraer una muestra del 25 % del total:
sales.sample(frac = .25)

Si quisiéramos extraer al azar columnas en lugar de filas, añadimos el argument axis con el valor 1 o columns:

# Extraer 3 columnas al azar:
sales.sample(n = 3, axis = "columns")

Para extraer los N valores más grandes, utilizamos el método nlargest():

# Las 3 filas con los valores de la columna "Units Sold" más grandes:
sales.nlargest(3, columns = "Units Sold")

Otra forma:

sales["Units Sold"].nlargest(3)

Para extraer los N valores más pequeños, utilizamos el método nsmallest():

# Las 2 filas con los valores de la columna "Units Sold" más pequeños:
sales.nsmallest(2, columns = "Units Sold")

Otra forma:

sales["Units Sold"].nsmallest(2)

sales.iloc[10, 2] = "Hola"

Cambiamos el valor que ya en la fila 10, columna 2 por el texto “Hola”.

Podemos cambiar una serie de valores. Por ejemplo, donde “Region” sea “Europa”, quiero que ahora valga “Europa”:

es_europa = sales["Region"] == "Europe"
 
sales.loc[es_europa, "Region"] = "Europa"

Modificando cadenas con str.replace():

sales["Region"] = sales["Region"].str.replace("Europe", "Europa")
 
# Elimina el símbolo '€' y cambia el tipo de dato de la columna 'Salary' a decimal.
sales["Salary"] = sales["Salary"].str.replace("€", "").astype("float")

Eliminando espacios:

# Elimina espacios a la derecha
sales["Region"] = sales["Region"].str.rstrip()
 
# Elimina espacios a la izquierda
sales["Region"] = sales["Region"].str.lstrip()
 
# Elimina espacios a los dos lados:
sales["Region"] = sales["Region"].str.strip()

# Devuelve todos los valores de "Region" que contengan 'rope'
filtro = sales["Region"].str.lower().str.contains("eur")
sales[filtro]
 
# Devuelve todos los valores de "Region" que empiecen por 'eur'
filtro = sales["Region"].str.lower().str.startswith("eur")
sales[filtro]

• concat()
• Inner join
• merge()

# Unión de dos DataFrame que comparten estructura:
clientes = pd.concat(objs = [cliente1, cliente2], ignore_index = True)

Para realizar inner joins:

cliente1.merge(cliente2, how = "inner", on = "Customer ID")

Para los left joins:

cliente1.merge(cliente2, how = "left", on = "Customer ID")

dfg = df.groupby("Region")

Esto creará un objeto DataFrameGroupBy y podremos usar en él los métodos típicos:

• sum()
• mean()
• median()
• min()
• max()

Se puede agrupar por más de un campo poniéndolos entre corchetes:

dfg = df.groupby(["Region", "Country"])

Cuando cargamos un fichero a un DataFrame y contiene alguna fecha, lo indicamos con el argumento parse_dates para poder así luego operar con objetos de tipo fecha en lugar de strings:

pd.read_csv("ventas.csv", index_col = "ID", parse_dates = ["fecha_pedido", "fecha_envio"])

pd.Timestamp("2020-12-31 00:01:59")
 
pd.Timestamp("2020/12/31 00:01:59")
 
pd.Timestamp(2020, 12, 31, 0, 1, 59)

Genera fechas dentro de un rango:

pd.date_range(start = "2020-12-01", end = "2020-12-31", freq = "D")
 
# Resultado
#DatetimeIndex(['2020-12-01', '2020-12-02', '2020-12-03', '2020-12-04',
#               '2020-12-05', '2020-12-06', '2020-12-07', '2020-12-08',
#               '2020-12-09', '2020-12-10', '2020-12-11', '2020-12-12',
#               '2020-12-13', '2020-12-14', '2020-12-15', '2020-12-16',
#               '2020-12-17', '2020-12-18', '2020-12-19', '2020-12-20',
#               '2020-12-21', '2020-12-22', '2020-12-23', '2020-12-24',
#               '2020-12-25', '2020-12-26', '2020-12-27', '2020-12-28',
#               '2020-12-29', '2020-12-30', '2020-12-31'],
#              dtype='datetime64[ns]', freq='D')

• freq: cómo se generan las fechas. D un día; 2D, dos días; W para domingos. Incrementa horas con H; M para meses; B para días laborales.

Podemos especificar la cantidad de fechas con la opción periods:

# Generar 10 fechas desde el 2020-12-01
pd.date_range(start = "2020-12-01", periods = 10, freq = "D"

Medida de tiempo, es un momento en el tiempo, como una fecha.

time_a = pd.Timestamp("2020-12-10 04:35:06")
 
time_b = pd.Timestamp("2020-12-01 12:22:58")
 
time_a - time_b
 
# Resultado:
# Timedelta('8 days 16:12:08')

Para crear un objeto de este tipo:

pd.Timedelta(days = 3, hours = 12, minutes = 45)
 
# Resultado
# Timedelta('3 days 12:45:00')

Podemos cargar también desde una URL:

url = "direccion/fichero.csv"
pd.read_csv(url)

Si no queremos coger la cabecera del fichero (normalmente contendrá el nombre de los campos/columnas):

pd.read_csv("fichero.csv", header = None)

Si los datos están separados por otro caracter que no sea la coma, lo indicamos como parámetro:

pd.read_csv("fichero.csv", sep = ';')

Si estuviesen separados por espacios, pero no sabemos cuántos, utilizamos una expresión regular:

pd.read_csv("fichero.csv", sep = '\s+')

Para la lectura de ficheros de Excel es necesario el módulo xlrd:

pip3 install xlrd

pd.read_excel("fichero.xlsx")

Si queremos leerlo con openpyxl:

pd.read_excel("fichero.xlsx", engine="openpyxl")

Si tuviésemos más de una hoja, podríamos cargar solo la que quisiéramos:

pd.read_excel("fichero.xlsx", sheet_name = "Hoja 2")

Si de una hoja solo queremos ciertas columnas:

pd.read_excel("fichero.xlsx", sheet_name = "Hoja 2", usecols = "A,L,M:AA")

En el ejemplo anterior solo leería las columnas A, L y de la M hasta la AA, ambas incluidas.

Si quisiéramos cargar varias hojas a la vez, el resultado sería un diccionario donde cada clave apuntaría a un dataframe, uno por hoja.

Si a la hora de leer un fichero Excel queremos descartar ciertas filas:

# Cargamos un fichero Excel como un DataFrame de Pandas, 
# saltándonos las 3 primeras filas
pd.read_excel("fichero.xlsx", skiprows=[0,1,2]

pd.to_csv("salida.csv", index = False)

• index indica si el índice aparecerá en el fichero resultante.

Podemos indicar qué columnas exportar:

pd.to_csv("salida.csv", index = False, columns = ["Nombre", "Apellidos", "Edad"])

Si queremos forzar la codificación, utilizamos el parámetro encoding:

pd.to_csv("salida.csv", index = False, encoding = "utf-8")

Si queremos cambiar el separador de campos (por defecto es una coma):

pd.to_csv("salida.csv", sep=";")

Si vamos a guardar datos con decimales, podemos indicar la precisión (número de decimales) con la que queremos que se guarden:

pd.to_csv("salida.csv", index=False, float_format="%0.4f")

Con el código anterior, indicamos que los números decimales tengan 4 decimales.

Para la escritura de ficheros de Excel es necesario el módulo openpyxl:

pip3 install openpyxl

# Creamos un contenedor para poder guardar finalmente un fichero Excel
output = pd.ExcelWriter("salida.xlsx")
 
# Escribimos el DataFrame en el contenedor Excel
ventas.to_excel(output, sheet_name = "Ventas", index = False)
 
# Escribimos el fichero
output.save()

Podríamos elegir qué columnas grabar:

ventas.to_excel(output, sheet_name = "Ventas", index = False, columns = ["Fecha", "Precio"])

Filas a mostrar:

import pandas as pd
 
# Número de filas que mostrará Pandas de un DataFrame:
pd.options.display.max_rows
 
# Establecer el número de filas a mostrar:
pd.options.display.max_rows = 10

Columnas a mostrar:

import pandas as pd
 
# Número de columnas que mostrará Pandas de un DataFrame:
pd.options.display.max_columns
 
# Establecer el número de columnas a mostrar:
pd.options.display.max_columns= 3

También podemos modificar las opciones utilizando métodos en lugar de atributos:

# Obtener el valor de las opciones
pd.get_option("max_rows")
 
pd.get_option("max_columns")
 
# Modificar las opciones
pd.set_option("max_rows", 10)
pd.set_option("max_columns", 3)

Para reiniciar las opciones a sus valores iniciales:

pd.reset_option("max_rows")
 
pd.reset_option("max_columns")

Por precisión nos referimos al número de decimales después del separador de decimales.

Por defecto, Pandas muestra 6 decimales.

pd.get_option("precision")
 
# Resultado:
# 6

Para establecer otra precisión:

pd.set_option("precision", 2)

El siguiente fragmento de código coge todos los ficheros .xlsx que hay en el directorio de trabajo y los une en un único documento llamado final.xlsx que será la unión de todos ellos:

import pandas as pd
import glob
 
all_data = pd.DataFrame()
 
for f in glob.glob("*.xlsx"):
    df = pd.read_excel(f)
    all_data = all_data.append(df, ignore_index=True)
 
# Volcamos el DataFrame resultante en un documento Excel
all_data.to_excel("final.xlsx", index=False)

El siguiente código abre el documento demo.xlsx, filtra los registros por los valores de dos columnas y vuelca el resultado en el fichero demo_mod.xlsx:

import os
import pandas as pd
 
df = pd.read_excel("demo.xlsx")
 
# Filtrado por columna
output = df.loc[(df['Age'] >= 50) & (df['Country'] == "United States")]
 
output.to_excel("demo_mod.xlsx", index=False)