Archivo de la categoría: Python

Calendario de días laborales con Pandas

Banca, Machine Learning, Python, Seguros

Es habitual escuchar que un científico de datos es un estadístico que trabaja con Python. En parte, tiene razón. Sin embargo, quien ha trabajado dentro del mundo académico sabe que para un estadístico las vacas son esféricas y los meses tienen 365,25/12 días. En cambio, en el mundo real, ni hay dos vacas iguales ni un mes igual a otro.
Sirva esta entrada para poner en valor todo aquel trabajo adicional y tiempo dedicado por aquellos que trabajan con datos y huyen de simplificaciones estadísticas, ya se denominen científicos de datos o cómo quieran llamarse.

Series temporales con Pandas

Pandas, como se ha visto aquí, es la librería por excelencia para el manejo de datos ya que permite trabajar fácilmente con tablas numéricas y series temporales.
Una utilidad disponible en Pandas en relación a las series temporales es crear directamente rangos de fechas con la función pd.date_range(), la cual utiliza los siguientes parámetros (no todos obligatorios):

  • start: Inicio del rango. Límite izquierdo para generar fechas.
  • end: Fin del rango. Límite derecho para generar fechas.
  • period: Número de periodos a generar
  • freq: Frecuencia de las proyecciones. Entre otros:
    • D: Diaria (por defecto)
    • Y: Anual
    • M: Mensual
  • closed: Si queremos excluir el inicio (closed=’right’) o el final (closed=’left’)
  • name: Nombre del DatetimeIndex resultante (por defecto ninguno)

Ejemplo básico de una serie temporal

import pandas as pd
s = pd.date_range(start='2019-01-01', periods=12, freq='M')
df = pd.DataFrame(s, columns=['Fecha'])
print(df)

        Fecha
0  2019-01-31
1  2019-02-28
2  2019-03-31
3  2019-04-30
4  2019-05-31
5  2019-06-30
6  2019-07-31
7  2019-08-31
8  2019-09-30
9  2019-10-31
10 2019-11-30
11 2019-12-31

Crear una serie temporal con los últimos días laborales de cada mes

En determinados ámbitos, principalmente financiero y actuarial, resulta especialmente útil manejar rangos de fechas en donde los días de la serie correspondan al primer o último día laboral del mes (por ejemplo, cuando proyectamos pagos de cupones o rentas).
Para ello, la función pd.date_range() dispone de diferentes valores para el parámetro frecuencia. En el siguiente ejemplo, ‘BM’ corresponde con BusinessMonthEnd (último día laboral del mes):

import pandas as pd
s = pd.date_range('2019-01-01', periods=12, freq='BM')
df = pd.DataFrame(s, columns=['Fecha'])
print(df)

        Fecha
0  2019-01-31
1  2019-02-28
2  2019-03-29
3  2019-04-30
4  2019-05-31
5  2019-06-28
6  2019-07-31
7  2019-08-30
8  2019-09-30
9  2019-10-31
10 2019-11-29
11 2019-12-31

Aunque si queremos mayor exactitud, debemos tener en cuenta los días festivos (por ejemplo, si calculamos costes que dependan de los días exactamente transcurridos entre cupón y cupón, un 1 día entre 20 representa un 5% de error). Conocer los días festivos dentro de un periodo de tiempo es especialmente útil cuando estimamos usos y comportamientos humanos (transporte público, asistencias médicas, cargas en servidores informáticos…). En el sector asegurador, dichos patrones pueden afectar directamente en las reservas contables, por ejemplo, a la hora de calcular los costes incurridos pero no declarados (IBNR). De hecho, en algunas compañías aseguradoras es habitual que se incrementen ligeramente los ratios de siniestralidad los años bisiestos simplemente por disponer de un día natural más que el resto.

En el siguiente ejemplo introducimos una lista con un par de días festivos simplemente para ver el funcionamiento: el 31 de mayo (Día de Castilla-La Mancha) y 28 de febrero (Día de Andalucía). Posteriormente calculamos los días transcurridos entre pagos si estos se produjeran el último día de mes:

import pandas as pd
fiestas = ['2019-02-28','2019-05-31']
es_holidays = pd.tseries.offsets.CustomBusinessMonthEnd(holidays=fiestas)
s = pd.date_range('2019-01-01', periods=12, freq=es_holidays)
df = pd.DataFrame(s, columns=['Fecha'])
df['n_dias'] = df['Fecha'].diff().dt.days.fillna(0)
print(df)

        Fecha  n_dias
0  2019-01-31     0.0
1  2019-02-27    27.0
2  2019-03-29    30.0
3  2019-04-30    32.0
4  2019-05-30    30.0
5  2019-06-28    29.0
6  2019-07-31    33.0
7  2019-08-30    30.0
8  2019-09-30    31.0
9  2019-10-31    31.0
10 2019-11-29    29.0
11 2019-12-31    32.0

(Como puede observarse, el 28-2 y 31-5 no aparecen en el calendario de pagos)

Reglas de cálculo para los días festivos

Por último, existe la opción de escribir reglas para calcular los días festivos (ya que normalmente estos son trasladados al siguiente día laboral). En ciertos países, como Estados Unidos, existen leyes al respecto (como la Uniform Monday Holiday Act of 1968), cuyas reglas están incluidas en Pandas y pueden consultarse haciendo un print(USFederalHolidayCalendar.rules).

Sin embargo, en muchos otros países no existen reglas para determinar los festivos del año (como ocurre en España), sino que cada año las fiestas laborales son fijadas por normativa. No obstante, vamos a aventurarnos a crear las reglas del calendario laboral español con la premisa de que los festivos que caigan en domingo se pasan al lunes siguiente (instrucción observance=sunday_to_monday). Posteriormente, mostramos los días laborales de diciembre para comprobar su funcionamiento.

from pandas.tseries.holiday import *
from pandas.tseries.offsets import CustomBusinessDay

class EsBusinessCalendar(AbstractHolidayCalendar):
   rules = [
     Holiday('Año Nuevo', month=1, day=1, observance=sunday_to_monday),
     Holiday('Epifanía del Señor', month=1, day=6, observance=sunday_to_monday),
     Holiday('Viernes Santo', month=1, day=1, offset=[Easter(), Day(-2)]),
     Holiday('Día del Trabajador', month=5, day=1, observance=sunday_to_monday),
     Holiday('Asunción de la Virgen', month=8, day=15, observance=sunday_to_monday),
     Holiday('Día de la Hispanidad', month=10, day=12, observance=sunday_to_monday),
     Holiday('Todos los Santos', month=11, day=1, observance=sunday_to_monday),
     Holiday('Día Constitución', month=12, day=6, observance=sunday_to_monday),
     Holiday('Inmaculada Concepción', month=12, day=8, observance=sunday_to_monday),	    
     Holiday('Navidad', month=12, day=25, observance=sunday_to_monday)
   ]

es_BD = CustomBusinessDay(calendar=EsBusinessCalendar())
s = pd.date_range('2019-12-01', end='2019-12-31', freq=es_BD)
df = pd.DataFrame(s, columns=['Fecha'])
print(df)

        Fecha
0  2019-12-02
1  2019-12-03
2  2019-12-04
3  2019-12-05
4  2019-12-10
5  2019-12-11
6  2019-12-12
7  2019-12-13
8  2019-12-16
9  2019-12-17
10 2019-12-18
11 2019-12-19
12 2019-12-20
13 2019-12-23
14 2019-12-24
15 2019-12-26
16 2019-12-27
17 2019-12-30
18 2019-12-31

(Se aprecia como el domingo 8 de diciembre es reemplazado por el lunes 9)

Así, una vez creado nuestro calendario de fiestas nacionales, podemos utilizarlo para conocer las fiestas de próximos años, por ejemplo para el año 2020:

calendar = EsBusinessCalendar()
print(calendar.holidays(start='2020-01-01', end='2020-12-31'))

DatetimeIndex(['2020-01-01', '2020-01-06', '2020-04-10', '2020-05-01',
               '2020-08-15', '2020-10-12', '2020-11-02', '2020-12-07',
               '2020-12-08', '2020-12-25'],
              dtype='datetime64[ns]', freq=None)

Las fiestas regionales o locales pueden ser incluidas de la misma manera, aunque hay que tener en cuenta que en ciertas comunidades es costumbre trasladar ciertas fiestas al 19 de marzo o el jueves del Corpus en vez de al siguiente lunes (en ese caso habría que crear una nueva función basada en la función de Pandas sunday_to_monday).

Nuestro calendario puede ser utilizado también en otras librerías como Prophet. Prophet es una librería avanzada de machine learning creada por Facebook, enfocada a modelos de regresión no lineales de datos a lo largo del tiempo, la cual requiere un listado de días festivos que debe ser proporcionado por el usuario.

Lectura de archivos csv con Python y Pandas

Formación, Monográficos, Python, ,

A continuación os planteo un acercamiento básico a la lectura de archivos csv con Python y algunos trucos para facilitar la vida cuando realizamos importaciones basados en la experiencia como son leer los primeros registros del csv o realizar una lectura de observaciones aleatoria por si el archivo es muy voluminoso. Para realizar las importaciones vamos a emplear Pandas y la función read_csv con sus infititas opciones:

 pd.read_csv(filepath_or_buffer, sep=', ', delimiter=None, header='infer', names=None, index_col=None, usecols=None, squeeze=False, prefix=None, mangle_dupe_cols=True, dtype=None, engine=None, converters=None, true_values=None, false_values=None, skipinitialspace=False, skiprows=None, nrows=None, na_values=None, keep_default_na=True, na_filter=True, verbose=False, skip_blank_lines=True, parse_dates=False, infer_datetime_format=False, keep_date_col=False, date_parser=None, dayfirst=False, iterator=False, chunksize=None, compression='infer', thousands=None, decimal=b'.', lineterminator=None, quotechar='"', quoting=0, escapechar=None, comment=None, encoding=None, dialect=None, tupleize_cols=None, error_bad_lines=True, warn_bad_lines=True, skipfooter=0, doublequote=True, delim_whitespace=False, low_memory=True, memory_map=False, float_precision=None)

Para trabajar la entrada vamos a necesitar dos archivos de texto:

Como costumbre poner la ubicación del archivo y después la lectura:

path = 'C:/temp/'

import pandas as pd
df = pd.read_csv (path + 'index.csv')
df.head()

En este caso la vida es maravillosa y ha salido todo a la primera pero sabemos que eso no pasa siempre, ejecutáis:

df = pd.read_csv (path + 'bank-additional-full.csv')
df.head()

El separador es distinto:

df = pd.read_csv (path + 'bank-additional-full.csv', sep = ';')
df.head()

La vida sigue sin ser muy complicada porque el archivo de ejemplo tiene pocos registros, pero imaginad que leéis unas docenas de GB por ello previamente es mejor ejecutar:

df = pd.read_csv (path + 'bank-additional-full.csv', nrows= 200)
df.shape

con nrows = 200 leemos las primeras 200 líneas y podemos comprobar si lo estamos leyendo correctamente y podemos ahorrarnos disgustos, tiempo y trabajo. E incluso estaría bien no leer las docenas de GB porque no tenemos suficiente memoria o porque no necesitamos leer entero el archivo podemos leer por trozos:

meses = ['may', 'jul']
df = pd.DataFrame()
for trozo in pd.read_csv(path + 'bank-additional-full.csv', sep=';',
                             chunksize=1000):
    df = pd.concat([df,trozo[trozo['month'].isin(meses)]])

df.month.value_counts()

Con chunksize estamos leyendo el archivo csv en trozos (chunks) de 1000 en 1000 y nos quedamos sólo con aquellos que cumplan un determinado requisito, en este caso que el campo month sea may o jul. E incluso podéis leer el csv extrayendo una muestra aleatoria mientras leéis el fichero por partes y no sobre pasar la memoria:

df2 = pd.DataFrame()
for trozo in pd.read_csv(path + 'bank-additional-full.csv', sep=';',
                             chunksize=1000):
    df2 = pd.concat([df2,trozo.sample(frac=0.25)])
df2.shape

Este último truco puede servir para leer csv extremadamente grandes y realizar los primeros análisis aproximativos a nuestro problema porque como dice un buen amigo “si en 200.000 registros no encuentras una señal no hace falta que cargues millones”.

Data Management básico con Pandas

Formación, Python

Entrada dedicada al manejo de datos más básico con Python y Pandas, es análoga a otra ya realizada con dplyr para R. Sirve para tener en un vistazo las tareas más habituales que realizamos en el día a día con Pandas. Para aquel que se esté introduciendo al uso de Python puede ser de utilidad tener todo junto y más claro, a mi personalmente me sirve para no olvidar cosas que ya no uso. En una sola entrada recogemos las dudas más básicas cuando nos estamos iniciando con Python. Las tareas más comunes son:

  • Seleccionar columnas
  • Eliminar columnas
  • Seleccionar registros
  • Crear nuevas variables
  • Sumarizar datos
  • Ordenar datos

Para variar vamos a emplear el conjunto de datos iris y que nos descargamos directamente de una url para ello las primeras sentencias que hemos de ejecutar son las siguientes:

import pandas as pd
import io
import requests
url='https://raw.githubusercontent.com/uiuc-cse/data-fa14/gh-pages/data/iris.csv'
s=requests.get(url).content
df=pd.read_csv(io.StringIO(s.decode('utf-8')))

Este código es un buen ejemplo de como obtener un csv directamente de una url porque en ocasiones pueden surgir problemas.

Seleccionar columnas:
Directamente

df2 = df[['sepal_length','sepal_width']]
df2.head()

Mediante una lista, parece más claro.

seleccionadas = ['sepal_length','sepal_width']
df2 = df[seleccionadas]
df2.head()

Eliminar columnas:

df3 = df.drop(columns=['sepal_length','sepal_width'])
df3.head()

Seleccionar registros:

Con condiciones simples, los operadores se pueden consultar pero no son “extraños”. También se presenta la función value_counts() que es una sumarización muy habitual.

df['species'].value_counts()
df4 = df[df['species']=="setosa"]
df4['species'].value_counts()

Algo que tiene especial relevancia (desde mi punto de vista) son los paréntesis en condiciones complejas o múltiples cuando usamos Pandas.

df5 = df.loc[(df.sepal_length<5) & (df.species=="setosa")]
df6 = df[(df['sepal_length']<5) & (df['species'] != "setosa")]

Particularmente la función isin para hacer condiciones del tipo in en listas la encuentro de mucha utilidad.

lista = ['setosa', 'virginica']
df7 = df[df['species'].isin(lista)]
df7['species'].value_counts()

Crear nuevas variables:

df['sepal_length_tipi'] = df['sepal_length']/df['sepal_length'].mean()
df['sepal_length_tipi'].describe()

En este sentido destacaría el uso de la función de numpy where, el famoso np.where que trabaja igual que el ifelse de R.

import numpy as np

df['sepal_length_altas'] = np.where(df['sepal_length'] > np.mean(df['sepal_length']),
                                    "Por encima de la media", "Por debajo de la media")
df['sepal_length_altas'].value_counts()

Sumarizar datos:

df[['sepal_length','species']].groupby('species').mean()
df[['sepal_length','species']].groupby('species').count()

Sumarizar por múltiples columnas tienes que listar variables.

df.groupby(['species','sepal_length_altas']).min()

Ordenar data frames con python pandas:

df8 = df.sort_values('sepal_length',ascending=[True])

Si queremos ordenar por múltiples campos del data frame con distintos órdenes:

df9 = df.sort_values(['sepal_length','sepal_width'],ascending=[True,False])

Pero en pocas líneas quedan recogidas las principales tareas con registros y columnas que se pueden hacer en un data frame con Pandas. La siguiente entrada irá encaminada a la unión de data frames con Python y Pandas.

Las mujeres son más inteligentes pero no están en puestos directivos

Opinión, Python,

A raíz de una noticia sobre la reestructuración del consejo directivo de un gran banco en España donde sólo una mujer ha sido elegida entre los 12 puestos de dirección general me ha surgido la oportunidad para explicar que es una distribución de probabilidad, que es una distribución normal y que es la media y la desviación típica.

Aquí tenéis en python un código que simula el IC de los hombres y el IC de las mujeres, no me he complicado mucho la vida ni he buscado datos al respecto pero leyendo un poco creo que deben de parecerse mucho a esto:

import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

hombres = np.random.normal(loc=60, scale=32, size=10000)
mujeres = np.random.normal(loc=70, scale=25, size=10000)

p1=sns.kdeplot(hombres, shade=True, color="r")
p1=sns.kdeplot(mujeres, shade=True, color="b")
sns.plt.show()

Bonito gráfico de densidades con varias variables hecho con seaborn y kdeplot de sintaxis sencilla que pone de manifiesto con unos datos simulados (con cierto talento) que en media la mujer es un 15% más inteligente que el hombre, pero la dispersión de la inteligencia del hombre es mayor, o como le he dicho a la persona que le he explicado que es la distribución normal, hay hombres muy tontos y hombres muy listos, muchos más que mujeres muy tontas y mujeres muy listas; así es la biología.

Pero ya os digo yo que la relación de hombres/mujeres inteligentes no es 1/12, así que esa importante entidad bancaria no está tomando decisiones correctas. Ellos verán lo que hacen pero no ha sido una medida inteligente, probablemente porque la ha tomado un hombre.

Crear archivo csv desde SAS con Python

Consultoría, Python, Trucos

Con la librería sas7bdat de Python podemos leer archivos SAS y crear directamente un data frame, es la mejor librería para hacerlo, si la tabla SAS que deseáis leer está comprimida (compress=yes) con pandas no podréis hacerlo. Pero tengo que agradecer a mi compañero Juan que me haya descubierto la función convert_file para pasar directamente el archivo SAS a csv, es más eficiente y parece que consume menos recursos del equipo. La sintaxis es muy sencilla:

import pandas as pd
from sas7bdat import SAS7BDAT

start_time = time.time()
path_file_sas = '/ubicacion/archivo/sas/tabla_SAS.sas7bdat'
path_file_csv = 'ubicacion/archivo/csv/archivo_CSV.csv'
f = SAS7BDAT(path_file_sas)

f.convert_file(path_file_csv, delimiter=',', step_size=10000)

end_time = time.time()
(end_time - start_time) / 60

La función convert_file realiza el proceso paso a paso, trozo a trozo, chunk to chunk. Si la tarea la realizas con un equipo esto te permite poder seguir usándolo. Me ha parecido un truco útil para poder importar tablas SAS a Python creando primero un csv, podéis agradecer a Juan.

 

Truco Python. Seleccionar o eliminar variables de un data frame en base a un prefijo, sufijo o si contienen un caracter

Formación, Machine Learning, Python, Trucos

A la hora de seleccionar las características de un data frame es posible que nos encontremos con la necesidad de seleccionar o eliminar características del data frame y que el nombre de esas características tenga un determinado patrón. Esta labor la podemos realizar mediante selección de elementos en listas, en esta entrada del blog vamos a tener 3 tipos de selecciones:

1. Seleccionar o eliminar aquellas variables que empiezan por un determinado prefijo
2. Seleccionar o eliminar aquellas variables que contienen una cadena de caracteres
3. Seleccionar o eliminar aquellas variables que finalizan con un sufijo

Para ilustrar este trabajo generamos un data frame con datos aleatorios y 10 columnas:

import numpy as np
import pandas as pd
df = pd.DataFrame(np.random.randint(0,100,size=(100, 10)),
columns=['A1','A2','A3','B1','B2','B3','C1','C2','C3','DA'])

El primero de los filtros a realizar es identificar que variables de nuestro data frame contienen el string ‘A’:

col = list(df.columns)
#Filtro 1: Columnas que tienen una A
filtro1 = [col for col in df if col.find('A')>=0]
#Eliminar
df1_drop = df.drop(columns=filtro1)
#Seleccionar
df1_keep = df[filtro1]

Siempre vamos a hacer el mismo proceso, las características de nuestro data frame irán en una lista, después recorremos la lista y seleccionamos aquellos donde el método .find(‘A’) sea mayor o igual a 0, con esto hemos creado una sublista con aquellas características que tienen el string ‘A’ mediante .drop(columns=) eliminamos del data frame los elementos contenidos en una lista Seguir leyendo Truco Python. Seleccionar o eliminar variables de un data frame en base a un prefijo, sufijo o si contienen un caracter →

Truco Python. Agrupar variable en función de la frecuencia

Formación, Python, Trucos

Me ha surgido la necesidad de crear una nueva variable en un data frame a partir de la frecuencia de otra, es decir, quedarme con los valores más frecuentes y aplicar una categoría resto para aquellos valores que no estén en los más frecuentes. Para realizar esto se me ha ocurrido la siguiente función en Python:

def agrupa_frecuencia (var_origen, var_destino, df, grupos, valor_otros):
df_grp= df[var_origen].value_counts()
list_grp = list(df_grp.iloc[0:grupos,].index)
df[var_destino] = df[var_origen].map(lambda x: x if x in list_grp else valor_otros, na_action='ignore')

Es una función con más parámetros que líneas, pero necesitamos una variable de origen, una variable de destino que será la que calcularemos, el data frame sobre el que realizamos la tarea, el número de grupos más otro que será el “resto” y dar un valor a ese “resto”. La función lo que hace es una tabla de frecuencias ordenada descendentemente con .value_counts() y creamos una lista con el número de grupos que deseamos. Por último mediante lambdas si la variable origen está en la lista generada anteriormente le asignamos el mismo valor, en caso contrario asignamos el valor “resto”. Es una programación sencilla, seguramente haya una función específica en sckitlearn para agrupar variables en base a la frecuencia, pero no la he encontrado y he tardado más en buscarla que en hacerla.

Como es habitual os pongo un ejemplo de uso para que podáis ver como funciona:

personas = 1000
grupo = pd.DataFrame(np.random.poisson(15,personas))
grupo['clave']=0
valor = pd.DataFrame(np.random.uniform(100,10000,personas))
valor['clave']=0
df = pd.merge(grupo,valor,on='clave')
del df['clave']
df.columns = ['grupo', 'valor']
df['grupo'].value_counts()

Vemos que grupo crea muchos valores y vamos a agrupar la variable del data frame de forma que los 10 más frecuentes toman su valor y los demás serán un resto:

agrupa_frecuencia('grupo', 'grupo_nuevo', df, 10, 99)
df['grupo_nuevo'].value_counts()

Parece que funciona, si mejoráis, actualizáis o encontráis pegas…

Truco Python. Restar meses con formato YYYYMM

Formación, Python, Trucos

La operación con fechas en meses con el formato YYYYMM es tarea habitual cuando trabajamos con tablas particionadas. De hecho hay una entrada en el blog sobre esto muy popular. Me ha surgido este tema con Python y os pongo la función que he creado:

def dif_mes(d1, d2):
    return (d1//100 - d2//100) * 12 + d1%100 - d2%100 

dif_mes (201812,201709)

Muy sencilla, por si os surge la necesidad.

Beatifulsoup. Web scraping con Python o como las redes sociales pueden estar cambiando la forma de escribir

Formación, Monográficos, Python,

Boxplot_BeatifulShop

Desde hace tiempo mis frases son más cortas. Creo que es un problema de las redes sociales, sobre todo twitter, que está cambiando mi comportamiento. Para analizar si esto está pasando se me ha ocurrido analizar la longitud de las frases de este blog desde sus inicios y de paso aprovechar para hacer web scraping con la librería Beatifulshop de Python. La idea es recorrer el blog y calcular la longitud de las frases y representar gráficamente como ha ido evolucionando esa longitud.

Podía haber trabajado directamente con la base de datos de wordpress pero he preferido leer las páginas de la web. Hay un problema, si véis el nombre de las páginas no tiene un orden cronológico, son el nombre de la propia entrada [https://analisisydecision.es/los-bancos-lo-llaman-transformacion-digital-yo-lo-llamo-me-da-miedo-facebook/] pero es cierto que se almacena una vista por mes de las entradas publicadas [https://analisisydecision.es/2017/02/] vamos a emplear esas vistas que no recogen la entrada entera pero si las primeras frases, con estas limitaciones vamos a medir la longitud de las frases.

Luego la analizamos paso a paso pero la función de Python que voy a emplear es:

import pandas as pd
from bs4 import BeautifulSoup
import requests
import re
import time
import string

def extrae (anio, mes):
url = "https://analisisydecision.es/" + anio + "/" + mes + "/"
print (url)
# Realizamos la petición a la web
pagina = requests.get(url)
soup = BeautifulSoup(pagina.content, 'html.parser')
m = str(soup.find_all('p'))
m = BeautifulSoup(m)
m = str(m.get_text())
frases = pd.DataFrame(m.split("."),columns=['frase'])
frases['largo'] =  frases['frase'].str.len()
frases['mes'] = anio + mes
frases['frase'] = frases['frase'].apply(lambda x:''.join([i for i in x if i not in string.punctuation]))
frases = frases.loc[frases.largo>10]
time.sleep(60)
return frases

Os comento paso a paso, a la función le vamos a pasar el mes y el año y esa será la url que lee https://analisisydecision.es/2017/02/ esa es la web sobre la que vamos a hacer el scraping. Vía request obtenemos la web y BeatifulSoup sólo para quedarnos con el contenido en HTML de la web cargada Seguir leyendo Beatifulsoup. Web scraping con Python o como las redes sociales pueden estar cambiando la forma de escribir →