La wiki de TempWin

Esta página es de solo lectura. Puedes ver la fuente pero no puedes cambiarla. Pregunta a tu administrador si crees que esto es incorrecto.
====== Pandas ======

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

  * [[https://pandas.pydata.org/|Web oficial]]

Pandas está construido sobre NumPy. Sus estructuras de datos básicas son **Series** y **DataFrame**
===== Instalación =====

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**:

<code>
pip3 install pandas
</code>

===== Uso =====

Para importar pandas:

<code python>
import pandas as pd
from pandas import Series, DataFrame
</code>

<WRAP center round tip 60%>
El alias ''pd'' suele ser el que usa la comunidad.
</WRAP>

==== Series ====

''Series'' en Python es un objeto similar a un array de una dimensión.

Para crear una serie de pandas a partir de una **lista**:

<code python>
import pandas as pd

helados = ["Chocolate", "Vainilla", "Fresa", "Limón"]

pd.Series(helados)

# Resultado

# 0    Chocolate
# 1     Vainilla
# 2        Fresa
# 3        Limón
# dtype: object
</code>

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

Para crear una serie de pandas a partir de un **diccionario**:

<code python>
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
</code>

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

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

</code>

  * ''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.

=== Atributos ===

Información sobre las series.

<code python>
import pandas as pd

about_me = ["Smart", "Handsome", "Charming", "Brilliant", "Humble"]

s = pd.Series(about_me)
</code>

  * ''*.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.

=== Métodos ===

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 aritmética 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.


<WRAP center round tip 60%>
''dtype: object'' es la forma que tiene Pandas de referirse a las cadenas de caracteres (strings)
</WRAP>

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

<code python>
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
</code>

=== Búsqueda ===

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

<code python>
import pandas as pd

numeros = [1, 4, 19, 23]

n = numeros.Series(numeros)

1 in n.values

# Resultado:

# True
</code>

<WRAP center round important 60%>
Si hacemos ''1 in n'' buscará en los índices, no en los valores
</WRAP>

=== Extracción ===

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

<code python>
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
</code>

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

<code python>
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
</code>
==== Filtrar datos ====

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

<code python>
print(df.loc[df['Edad'] >= 18])
</code>

Podemos encadenar condiciones:

<code python>
print(df.loc[(df['Edad'] >= 18) & (df['Sexo'] == "Mujer")])
</code>
===== DataFrame =====

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**.

{{:informatica:programacion:python:modulos:pandas:pandas-dataframe.png|}}

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.

<code python>
import pandas as pd
</code>

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

<code>
>>> 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]
</code>

<WRAP center round info 60%>
Si aparece ''NaN'' es la forma que tiene Pandas de indicar que falta el valor.
</WRAP>

Ejemplo de un DataFrame creado a partir de un diccionario:

<code python>
purchases = [{'Customer': 'Bob', 'Item': 'Oranges', 'Quantity': 2, 'Unit price': 2},
             {'Customer': 'Bob', 'Item': 'Apples', 'Quantity': 3, 'Unit price': 1},
             {'Customer': 'Bob', 'Item': 'Milk', 'Quantity': 1, 'Unit price': 4},
             {'Customer': 'Alice', 'Item': 'Oranges', 'Quantity': 2, 'Unit price': 2},
             {'Customer': 'Alice', 'Quantity': 2, 'Unit price': 3}]
df = DataFrame(purchases)

df

# Resultado:

#   Customer     Item  Quantity  Unit price
# 0      Bob  Oranges         2           2
# 1      Bob   Apples         3           1
# 2      Bob     Milk         1           4
# 3    Alice  Oranges         2           2
# 4    Alice      NaN         2           3
</code>

==== Métodos ====

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.

<WRAP center round important 60%>
La mayoría de las funciones de DataFrames devuelven un objeto **nuevo** de pandas. Si queremos realizar una operación y que se modifique el propio objeto, debemos pasarle el argumento ''inplace=True'')
</WRAP>


<code>
>>> 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
</code>

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'':

<code python>
df.describe(include = "O")
</code>
==== Extraer columnas ====

Podemos coger una columna por su nombre:

<code python>
sales.Country
</code>

Se creará una serie.

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

<code python>
sales["Client Name"]
</code>

Para extraer más de una columna:

<code python>
sales[ ["Client Name", "Salary"] ]
</code>

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

==== Añadir filas ====

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

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

Podemos añadir un DataFrame en otro:

<code python>
df2.append(df1, ignore_index=True)
</code>
==== Añadir columnas ====

<code python>
sales["City"] = "Madrid"
</code>

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()'':

<code python>
sales.insert(3, column = "City", value = "Madrid")
</code>

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:

<code python>
sales["Salary+Bonus"] = sales["Salary"] + sales["Bonus"]
</code>

==== Eliminar filas ====

Utilizamos el método ''drop()''

<code python>
# Eliminar la fila que ocupa la posición 10:
new_sales = sales.drop(10)
</code>

Si queremos que se modifique el DataFrame en lugar de hacer una copia de él:

<code python>
# Eliminar la fila que ocupa la posición 10:
sales.drop(10, inplace=True)
</code>
==== Eliminar columnas ====

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

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

<WRAP center round tip 60%>
También podemos indicar el nombre de la columna en lugar de la posición: ''sales.drop(%%"%%Nacionalidad%%"%%, axis=1)''
</WRAP>

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

<code python>
del sales["Region"]
</code>

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

<code python>
sales.pop("Region")
</code>

<WRAP center round important 60%>
La operación ''pop()'' es permanente, es decir, modifica el DataFrame sin necesidad del argumento ''inplace''
</WRAP>

==== Eliminar filas vacías ====

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

<code python>
sales.dropna()
</code>

Para eliminar solo las filas completamente vacías:

<code python>
sales.dropna(how = "all")
</code>

==== Eliminar columnas vacías ====

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

<code python>
sales.dropna(axis = 1)

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

Podemos indicar las columnas a revisar:

<code python>
sales.dropna(subset = ["Salary", "Country"])
</code>

==== Rellenar vacíos (NaN) ====

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

<code python>
# Rellenar NaN con 0:
sales.fillna(0)
</code>

Podemos ir columna a columna:

<code python>
sales["Salary"].fillna(0, inplace = True)
</code>

<WRAP center round info 60%>
''inplace'' indica si el objeto al que se aplica el método se modificará.
</WRAP>

==== Reemplazar ====

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

<code python>
sales.replace("Espana", "España")
</code>

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

<code python>
sales.replace({"Espana": "España", "madrid": "Madrid"})
</code>
==== Cambiar tipos de datos ====

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

<code python>
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
</code>

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

<code python>
sales["Unit Price"] = sales["Unit Price"].astype("int")
</code>

<WRAP center round important 60%>
Para poder utilizar este método, es necesario que todas las filas tengan valores, es decir, que no exista ningún ''NaN''
</WRAP>

Si queremos pasar una fecha al formato ISO:

<code python>
sales["Date"] = sales.to_datetime(sales["Date"])
</code>

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

<code python>
sales["Date"] = sales.to_datetime(sales["Date"], format="%d/%m/%Y")
</code>
==== Ordenación ====

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

<code python>
sales.sort_values(by="Salary")
</code>

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:

<code python>
sales.sort_values(["Client Name", "Salary"], ascending = [True, False])
</code>

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

==== Filtrar datos ====

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":

<code python>
filtro = sales["Region"] == "Europe"
sales[filtro]

filtro = sales["Salary"] > 10000
sales[filtro]
</code>

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

<code python>
filtro1 = sales["Region"] == "Europe" 
filtro2 = sales["Salary"] > 10000

sales[filtro1 & filtro2]
</code>

  * ''&'': 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'':

<code python>
filtro = sales["Region"].isin(["Europe", "Asia"])
sales[filtro]
</code>

Estamos buscando las filas cuya "Region" sea "Europe" o "Asia".

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

<code python>
filtro = sales["Salary"].between(20000, 50000)
sales[filtro]
</code>

<WRAP center round info 60%>
Los valores límites también están incluidos en el filtro, es decir, para el ejemplo anterior, también devolvería las filas cuyo salario fuese 20000 y 50000.
</WRAP>

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

<code python>
filtro = sales["Salary"].between(20000, 50000)
sales.where(filtro)
</code>

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:

<code pytyon>
sales.query("Country == 'Canada'")
</code>

Otro ejemplo:

<code python>
sales.query("Country in ['Canada', 'Japan']")
</code>

Si queremos combinar condiciones:

<code python>
sales.query("Country == 'Canada' and Salary > 10000")
</code>

<WRAP center round important 60%>
Para poder usar el método ''query()'' las columnas no deben contener espacios.
</WRAP>


=== Vacíos ===

Para filtrar por vacíos:

<code python>
filtro = sales["Region"].isnull()

# Devuelve todas las filas donde "Region" esté vacío (NaN)
sales[filtro]
</code>

Lo contrario se haría con ''notnull()'':

<code python>
filtro = sales["Region"].notnull()

# Devuelve todas las filas donde "Region" no esté vacío:
sales[filtro]
</code>

=== Duplicados ===

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

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

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

<code python>
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)
</code>

Para contarlos, utilizamos el método ''nunique'':

<code python>
sales["Region"].nunique(dropna = False)

# Resultado:
# 7
</code>

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

==== Extracción ====

=== Por posición del íncide ===

Utilizamos el método ''iloc()'':

<code python>
# 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]]
</code>

Podemos hacer la intersección con el segundo argumento:

<code python>
sales.iloc[14, 2]

# Devuelve el contenido del índice 14 en su tercera (posición 2) columna.
</code>

=== Por etiqueta del índice ===

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

<code python>
sales.set_index("Order ID", inplace = True)
</code>

Si queremos volver a dejar los índices por defecto:

<code python>
sales.reset_index(inplace = True)
</code>


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

<code python>
sales.set_index("Region", inplace = True)
sales.loc["Europe"]
</code>

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

<code python>
sales.loc["Europe", "Item Type"]

# Devuelve las filas cuya "Region" sea "Europe" y su valor de "Item Type"
</code>

=== Extracción al azar ===

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

<code python>
# Extrae una fila al azar:
sales.sample()
</code>

Podemos indicar el número de filas a extraer:

<code python>
# Extraer 10 muestras al azar:
sales.sample(n = 10)
</code>

Incluso podríamos extraer por fracciones del total:

<code python>
# Extraer una muestra del 25 % del total:
sales.sample(frac = .25)
</code>

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

<code python>
# Extraer 3 columnas al azar:
sales.sample(n = 3, axis = "columns")
</code>

=== Máximos ===

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

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

Otra forma:

<code python>
sales["Units Sold"].nlargest(3)
</code>

=== Mínimos ===

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

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

Otra forma:

<code python>
sales["Units Sold"].nsmallest(2)
</code>

==== Modificar valores ====

<code python>
sales.iloc[10, 2] = "Hola"
</code>

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":

<code python>
es_europa = sales["Region"] == "Europe"

sales.loc[es_europa, "Region"] = "Europa"
</code>
==== Trabajando con texto ====

Modificando cadenas con ''str.replace()'':

<code python>
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")
</code>

Eliminando espacios:

<code python>
# 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()
</code>

=== Filtrando por texto ===

<code python>
# 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]
</code>

==== Unión de DataFrames ====

  * ''concat()''
  * Inner join
  * ''merge()''

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

<WRAP center round info 60%>
''ignore_index'' por defecto es ''False'', así que cogerá los índices originales de cada DataFrame concatenado
</WRAP>

Para realizar inner joins:

<code python>
cliente1.merge(cliente2, how = "inner", on = "Customer ID")
</code>

Para los left joins:

<code python>
cliente1.merge(cliente2, how = "left", on = "Customer ID")
</code>

==== Agrupar ====

<code python>
dfg = df.groupby("Region")
</code>

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:

<code python>
dfg = df.groupby(["Region", "Country"])
</code>
===== Fechas =====

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:

<code python>
pd.read_csv("ventas.csv", index_col = "ID", parse_dates = ["fecha_pedido", "fecha_envio"])
</code>

==== Timestamp ====

<code pytyon>
pd.Timestamp("2020-12-31 00:01:59")

pd.Timestamp("2020/12/31 00:01:59")

pd.Timestamp(2020, 12, 31, 0, 1, 59)
</code>

==== date_range() ====

Genera fechas dentro de un rango:

<code python>
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')
</code>

  * ''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'':

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


==== Timedelta ====

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

<code python>
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')
</code>

Para crear un objeto de este tipo:

<code python>
pd.Timedelta(days = 3, hours = 12, minutes = 45)

# Resultado
# Timedelta('3 days 12:45:00')
</code>
===== Entrada de datos =====

==== CSV ====

Podemos cargar también desde una URL:

<code python>
url = "direccion/fichero.csv"
pd.read_csv(url)
</code>

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

<code python>
pd.read_csv("fichero.csv", header = None)
</code>

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

<code python>
pd.read_csv("fichero.csv", sep = ';')
</code>

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

<code python>
pd.read_csv("fichero.csv", sep = '\s+')
</code>
==== Excel ====

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

<code>
pip3 install xlrd
</code>

<WRAP center round important 60%>
Si vamos a leer un fichero que no sea ''.xls'' (''.xlsx'', por ejemplo), será mejor utilizar ''openpyxl'' ya que en últimas versiones de xlrd [[https://groups.google.com/g/python-excel/c/IRa8IWq_4zk/m/Af8-hrRnAgAJ?pli=1|van a dejar de dar soporte a formatos que no sean ''.xls'']].
</WRAP>


<code python>
pd.read_excel("fichero.xlsx")
</code>

Si queremos leerlo con ''openpyxl'':

<code python>
pd.read_excel("fichero.xlsx", engine="openpyxl")
</code>

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

<code python>
pd.read_excel("fichero.xlsx", sheet_name = "Hoja 2")
</code>

Si de una hoja solo queremos ciertas columnas:

<code python>
pd.read_excel("fichero.xlsx", sheet_name = "Hoja 2", usecols = "A,L,M:AA")
</code>

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.

=== Saltar filas ===

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

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

==== CSV ====

<code python>
pd.to_csv("salida.csv", index = False)
</code>

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

Podemos indicar qué columnas exportar:

<code python>
pd.to_csv("salida.csv", index = False, columns = ["Nombre", "Apellidos", "Edad"])
</code>

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

<code python>
pd.to_csv("salida.csv", index = False, encoding = "utf-8")
</code>

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

<code python>
pd.to_csv("salida.csv", sep=";")
</code>

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

<code python>
pd.to_csv("salida.csv", index=False, float_format="%0.4f")
</code>

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

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

<code>
pip3 install openpyxl
</code>

<code python>
# 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()
</code>

Podríamos elegir qué columnas grabar:

<code python>
ventas.to_excel(output, sheet_name = "Ventas", index = False, columns = ["Fecha", "Precio"])
</code>

===== Opciones =====

==== Número de resultados ====

Filas a mostrar:

<code python>
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
</code>

Columnas a mostrar:

<code python>
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
</code>

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

<code python>
# 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)
</code>

Para reiniciar las opciones a sus valores iniciales:

<code python>
pd.reset_option("max_rows")

pd.reset_option("max_columns")
</code>

<WRAP center round tip 60%>
Podemos saber más acerca de una opción mediante el método ''describe_option()''. Por ejemplo, ''pd.describe_option(%%"%%max_columns%%"%%)''
</WRAP>

==== Precisión numérica ====

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

Por defecto, Pandas muestra 6 decimales.

<code python>
pd.get_option("precision")

# Resultado:
# 6
</code>

Para establecer otra precisión:

<code python>
pd.set_option("precision", 2)
</code>
===== Ejemplos =====

==== Combinar ficheros Excel ====

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:

<code python>
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)
</code>


==== Filtrar registros Excel ====

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'':

<code python>
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)
</code>

==== Titanic ====

Partiendo de un CSV con información sobre pasajeros:

<code python>
import pandas as pd

fname = '~/data/titanic/train.csv'

data = pd.read_csv(fname)
</code>

Ver si hay campos vacíos:

<code python>
data.count()
</code>

Valores mínimos y máximos de edad:

<code python>
data['Age'].min(), data['Age'].max()
</code>

Distribución de valores de supervivientes:

<code python>
data['Survived'].value_counts()
</code>

En términos porcentuales:

<code python>
data['Survived'].value_counts() * 100 / len(data)
</code>

Distribución por sexo:

<code python>
data['Sex'].value_counts()
</code>

Distribución por tipo de pasajero:

<code python>
data['Pclass'].value_counts()
</code>

Representación gráfica (en notebook de Jupyter):

<code python>
%matplotlib inline

alpha_color = 0.5

# Distribución se supervivientes
data['Survived'].value_counts().plot(kind='bar')
</code>

Distribución gráfica por sexo:

<code python>
data['Sex'].value_counts().plot(kind='bar',
                                color=['b', 'r'],
                                alpha=alpha_color)
</code>

Distribución gráfica por clase de pasajeros:

<code python>
data['Pclass'].value_counts().sort_index().plot(kind='bar',
                                                alpha=alpha_color)
</code>

Comparando gráficamente supervivientes con edades:

<code python>
data.plot(kind='scatter', x='Survived', y='Age')
</code>

Comparando gráficamente supervivientes con tramos de edades:

<code python>
bins = [0, 10, 20, 30, 40, 50, 60, 70, 80]

data['AgeBin'] = pd.cut(data['Age'], bins)

data[data['Survived'] == 1]['AgeBin'].value_counts().sort_index().plot(kind='bar')
</code>

Gráficamente los que no sobrevivieron:

<code python>
data[data['Survived'] == 0]['AgeBin'].value_counts().sort_index().plot(kind='bar')
</code>

<code python>
data['AgeBin'].value_counts().sort_index().plot(kind='bar')
</code>

Pasajeros de primera clase que sobrevivieron:

<code python>
data[data['Pclass'] == 1]['Survived'].value_counts().plot(kind='bar')
</code>

Pasajeros de tercera clase que sobrevivieron:

<code python>
data[data['Pclass'] == 3]['Survived'].value_counts().plot(kind='bar')
</code>

Pasajeros de género masculino que sobrevivieron:

<code python>
data[data['Sex'] == 'male']['Survived'].value_counts().plot(kind='bar')
</code>

Pasajeros de género femenino que sobrevivieron:

<code python>
data[data['Sex'] == 'female']['Survived'].value_counts().plot(kind='bar')
</code>

Pasajeros de género masculino y primera clase que sobrevivieron:

<code python>
data[(data['Sex'] == 'male') & (data['Pclass'] == 1)]['Survived'].value_counts().plot(kind='bar')
</code>

Pasajeros de género masculino y tercera clase que sobrevivieron:

<code python>
data[(data['Sex'] == 'male') & (data['Pclass'] == 3)]['Survived'].value_counts().plot(kind='bar')
</code>

Pasajeros de género femenino y primera clase que sobrevivieron:

<code python>
data[(data['Sex'] == 'female') & (data['Pclass'] == 1)]['Survived'].value_counts().plot(kind='bar')
</code>

Pasajeros de género femenino y tercera clase que sobrevivieron:

<code python>
data[(data['Sex'] == 'female') & (data['Pclass'] == 3)]['Survived'].value_counts().plot(kind='bar')
</code>


===== Recursos =====

  * https://github.com/bonzanini/VideoCourse-DataAnalysisPython