Hoy uno rápido, pero creo que bastante útil. El otro día tuve la necesidad de buscar las estadísticas de Euroliga para uno de los mil proyectos que empiezo (la mayoría se quedan a la mitad). Y me pareció que podría ser interesante dar a conocer el método.

Ya dije en uno de los primeros post que iba a enseñar la manera dificil de extraer datos de la Euroliga, pero ahora que lo veo, esta forma es mas fácil que la api.

Para asegurarnos de cuál enlace tiene la tabla, botón derecho y le damos a inspeccionar.

Código en R

Una vez que tenemos el enlace copiado, cargamos las librerías, que esta vez son pocas.

library(tidyverse)
library(httr)

El código completo en R es este:

url<- “https://feeds.incrowdsports.com/provider/euroleague-feeds/v3/competitions/E/statistics/players/traditional?seasonMode=Single&limit=1000&sortDirection=descending&seasonCode=E2025&statisticMode=perGame&statisticSortMode=perGame”

raw_players <- GET(url) %>% content()

players <- pluck(raw_players, “players”) %>%
  tibble(value = .) %>%
  unnest_wider(value) %>% 
  unnest_wider(player) %>% 
  unnest_wider(team, names_sep = “_”)

Y nos devuelve esto

Read more

Este tutorial va a explicar como hacerlo en 🐍 y y en R 💻.

🐍 Código en Python

No me voy a entretener mucho explicando cada línea. Vamos a lo práctico, que es lo que interesa.

Cargamos las librerías

Las típicas para scraping, limpieza y manipulación de datos:

import pandas as pd
import polars as pl, requests
import janitor.polars
from bs4 import BeautifulSoup

Creamos un elemento con la URL

Vamos a trabajar con la web de pretemporada del Rincón. Aquí está el enlace:

url = "https://www.rincondelmanager.com/smgr/pretemporada.php"

Extraemos los nombres de los jugadores y su bandera

Las filas no siempre coinciden, así que añadimos una condición para evitar errores cuando el div con la bandera está vacío. Si no hay bandera, devuelve NULL

headers = {"User-Agent": "Mozilla/5.0"}
res = requests.get(url, headers = headers)
soup = BeautifulSoup(res.text, "html.parser")

jugador = soup.select(".jugador a[href]")

dfbanderas = pl.DataFrame({
     "jugador": [a.get_text(strip=True) for a in jugador],
     "bandera": [
    " ".join(j.find("div").get("class"))
    if (j.find("div") is not None and j.find("div").get("class"))
    else None
    for j in jugador
]

})
dfbanderas

Extraemos la tabla principal

Usamos read_html desde pandas y luego convertimos a polars, limpiando los nombres para que no haya líos con espacios, tildes, etc.

url = "https://www.rincondelmanager.com/smgr/pretemporada.php"
df = pl.from_pandas(
    pd.read_html(
        url, thousands=".", decimal=",", storage_options={"User-Agent": "Mozilla/5.0"}
    )[0]
).clean_names(remove_special=True, strip_underscores=True)
df

Juntamos las dos tablas

Hacemos un join por el nombre del jugador y seleccionamos solo las columnas clave, ya ordenadas:

tabla = (df.join(dfbanderas, on="jugador", how="left")
        .select(["jug", "jugador", "bandera", "eq", "pos", "broker", "jug_1", "pts", "val", "val_est", "rent"]))
tabla

Y ya estaría. Una tabla limpia, con nombres, banderas y todas las estadísticas ordenadas. Sin tocar nada a mano y lista para usar en lo que necesites.

💾 Guardamos el archivo en CSV

Para terminar, guardamos la tabla final en un .csv, que siempre viene bien tenerlo listo para reutilizar:

tabla.write_csv("tabla_pretemporada.csv")

🧪 Código en R

Ahora sí, vamos con R. Aquí no hay complicación ni magia negra, pero sí algunas cosas que conviene explicar para que todo funcione bien.

Cargamos las librerías

Necesitamos las de siempre para scraping y manipulación básica:

library(tidyverse)
library(rvest)
library(janitor)
library(xml2)

Read more

El tutorial de hoy muestra cómo cree esta tabla en Python y en R. De la página de Proballers.com

Mi lenguaje principal es R y es con el que hago los ánalisis porque lo tengo mas automatizado y porque hasta ahora la calidad de las visualizaciones estaban, a mi parecer, a años luz (de mejores) de las de Python. Pero con la implementación de la librerías gt() y gtExtras() (great_tables gt_extras en Python) ahora ya el lenguaje que elijas es igual, reconozco que Python es mucho más popular y es el que conoce y piden en todos lados, y aunque todavía no está igual al 100%, por ejemplo no está intregrado poner superindices, que es la diferencía fundamental con la tabla hecha con R, si que el 98% es prácticamente igual.

Comenzaremos en Python y luego paseremos a R

Código en Python 🐍

Empezamos cargando las librerías

import polars as pl, pandas as pd, requests #extraer, transformar, cargar, descargar Json
from bs4 import BeautifulSoup # parsear HTML
from urllib.parse import urljoin # rutas absolutas
from great_tables import GT, md, loc, style # tabla GT / formatos
import gt_extras as gte # extras GT (resaltados)
import polars.selectors as cs # seleccionar numéricas
from selenium import webdriver # exportar PNG (GT)
from PIL import Image, ImageOps  # margen PNG (post)

Aprovecho para recordar que uso Jupiter NoteBooks, por lo que cada bloque de código es un chunk en el archivo original mi escritorio se ve así:

Comentar que escribo el código Python como si estuviera escribiendolo en R, por lo que a lo mejor es diferente a lo que se ve en otros lados.

Cargamos la url, y mediante pandas y polars extraemos la primera tabla por eso el [0], limpiamos y corregimos los nombres de las columnas, las seleccionamos, cambiamos el nombre de eff por el de val. Como la tabla son totales, dividimos todo por los partidos jugados y redondeamos, solo a minutos (sin segundos) la columna min, y las demás con 1 decimal

url = "https://www.proballers.com/basketball/player/65439/dzanan-musa/totals"
df = (
    pl.from_pandas(pd.read_html(url, storage_options={"User-Agent": "Mozilla/5.0"})[0])
    .clean_names(remove_special=True, strip_underscores=True)
    .select(
        "season",
        "team",
        "league",
        "gp",
        "min",
        "pts",
        "reb",
        "ast",
        "stl",
        "to",
        "blk",
        pl.col("eff").alias("val"),
    )
).with_columns(
    ((cs.numeric().exclude("gp", "min")) / pl.col("gp")).round(1),  # todas las numéricas ≠ gp,min
    ((pl.col("min") / pl.col("gp")).round().cast(pl.Int8)),          # min: 0 decimales
)
df 

El resultado de este bloque se ve en la foto de arriba

Ahora necesitamos una serie de datos en forma de tablas para enriquecer los datos y poder conseguir una visualización que den ganas de verla.

Tenemos que extraer a parte, los logos, los nombres de los equipos y hacer una tabla con el fin de unirla a la de los datos. Esto ya lo expliqué en otros tutoriales: botón derecho y buscamos los elementos.

Un detalle al final verás que hay una linea (.unique) que es para quitar de la tabla los nombres que se repiten, debido a los años que juega en cada equipo. Si los dejaramos, nos duplicaría al unir la tabla tantas veces como se repitiera el nombre.

# Dataframe con los nombres de equipo y sus logos

headers = {"User-Agent": "Mozilla/5.0"}
res = requests.get(url, headers = headers)
soup = BeautifulSoup(res.text, "html.parser")

links = soup.select(".show .second__left img[src]") #logos
links2 = soup.select(".show .second__left a[title]") # nombres de equipo

#Tabla con ambas cosas

dfLogos = pl.DataFrame({
     "team": [a.get_text(strip=True) for a in links2],
    "url_logo":   [img["src"] for img in links]
}).unique(subset=["team"], keep="first", maintain_order=True)

Disclaimer:
Estas tareas tan minuciosas y tediosas —como hacer tablas de equivalencias entre los nombres de liga en Proballers y sus nombres reales, o buscar los colores oficiales de los equipos— me llevarían unos cuantos minutos si tuviera que hacerlas a mano.

Pero se resuelven con algo tan simple como pedirle a ChatGPT que busque esas equivalencias por mí… y que me monte una tabla con lo que necesito.

Hacemos una con las de las ligas (GPT)

ligas = pl.DataFrame(
    {
        "league": ["ABA-1", "CRO-1 Up", "CRO-1", "USA-1", "USA-2", "TUR-1", "SPA-1"],
        "liga":   ["ABA League", "Premijer Liga (Fase por el título)", "Premijer Liga (Croacia)",
                   "NBA", "G League", "BSL (Türkiye)", "ACB"],
    },
    ) # categoriza 'league'
ligas

A partir de aquí, me harías muy feliz si me ayudas a sacar este proyecto adelante mejorando tu suscripción.

Gracias por adelantado.

Read more

¿Qué tal todo?

Mientras pueda, tenga tiempo y sepa cómo hacerlo, compartiré con los suscriptores premium el código R y el código Python, como si una piedra de Rosseta se tratara, la verdad es que ambos lenguajes son muy similares; creo que R es posterior y por eso muchas funciones y maneras de escribir código son mas cortas y eficientes y posee una mayor y mejor capacidad gráfica. Al final todo se puede hacer con todo, pero mientras en uno, son dos palabras, en otro pueden ser 10 lineas.

No se si se percibe, pero a mi me gusta resumir mucho al escribir código y prefiero la eficiencia, quizás porque al ser autodidacta no he aprendido bajo la disciplina de ningún profesor, ni de ningún curso. Es algo que recomiendo.

Yo aprendí a base de imponerme proyectos. Cuando encontraba lo que quería hacer preguntaba y pregunto a todo el mundo, buscaba y busco turoriales por todas partes. Una cosa que quiero agradecer es la facilidad y la buena disposición de verdaderos cracks como Owen Philips , Abdoul Madjid o Dan Oehm y muchos otros que han tenido tanta paciencia conmigo. Lo cierto es que breaba y breo a mucha gente 😂, porque: ya sé que no... pero y si sí.

Codigo R

Cómo siempre las librerias. Tengo que confesar que me he cambiado de portatil y hasta que vuelva a cargar todo tal y como lo tenía en el antiguo pues… Bueno, ponemos las lbrerias, las fuentes y mi tema ( también podeis simplemente poner theme_minimal() en el plot)

library(tidyverse)
library(rvest)
library(janitor)
library(shadowtext)
library(ggtext)
library(extrafont)
library(sysfonts)
library(showtext)

font_add(family = "oswald", regular = "Oswald-VariableFont_wght.ttf")
font_add(family = "oswaldbold", regular = "Oswald-Bold.ttf")
font_add(family = "Font Awesome 6 Brands", regular = "fa-brands-400.ttf")

showtext_auto()
showtext_opts(dpi = 320)

#mi tema
theme_ivo <- function () {
  theme_minimal(base_size=9, base_family="oswald") %+replace%
    theme(
      panel.grid.minor = element_blank(),
      plot.background = element_rect(fill = 'white', color = "white")
    )
}

Si quereis saber cómo se llama y donde teneis alguna fuente en vuestro sistema teclead

font_files() %>% tibble() %>% filter(str_detect(family,"Oswald"))

Luego el nombre que hay poner es el que está debajo de la columna family, como vereís en el primer rectangulo, yo he cambiado el nombre para diferenciar el face bold del Regular

Scraping Data

Vamos a usar los datos de la web RealGM

Si quereis los datos de un solo año tecleais esto

df <-"https://basketball.realgm.com/international/league/1/Euroleague/team-stats/2025/Averages/Team_Totals" %>%
  read_html() %>%
  html_element("table") %>%
  html_table() %>%
  clean_names() %>%
  select(team, fgm, fga, fg_percent, x3pm, x3pa, x3p_percent) %>%
  mutate(x2pa = fga- x3pa) %>% #no hay columna de intentos de 2
  summarise(x2pa_media = mean(x2pa),
            x3pa_media = mean(x3pa))

Cómo dije mas arriba me gusta ahorrar y a la vez que descargo los datos los limpio los selecciono y creo las columnas.

Ahora vamos a sacar los datos de los últimos 20 años

Si te gusta lo que lees, pásate a pago y te llevas el resto del análisis + el código R y Python (formato “piedra de Rosetta”,🙈). Con tu apoyo puedo seguir picando piedra y compartir lo que aprendo. 🏀

Read more

Bueno, pensando en la nada. 😅; hablando con algunos suscriptores premium me surgió la idea de crear algo útil también en Python, además de R. No porque sea más fácil (¡no lo es!), sino porque es un lenguaje más popular y quizá más accesible para mucha gente.

👉 En este post voy a mostrar la forma más sencilla de conseguir datos de la Euroliga usando la librería euroleague_api. Más adelante, también en exclusiva para suscriptores premium, compartiré el camino difícil: cómo extraer los datos directamente de la página oficial de Euroleague.

De momento voy a dar por hecho que tenéis unas nociones básicas de Python y Jupyter Notebooks (yo suelo trabajar en VSCode).

También aviso: para el data wrangling voy a usar Polars en lugar de Pandas. ¿La razón? Viniendo del Tidyverse de R, Pandas me parece un dolor de muelas y una castaña.

A mí me gusta escribir el código en Notebooks porque me permite controlar mejor cada resultado.

Instalación de librerías

Si aún no tienes las librerías, abre tu terminal y escribe:

pip install -U pyjanitor polars euroleague-api 

El parámetro -U actualiza a la última versión en caso de que ya las tengas instaladas.

Primeros imports en Python

import polars as pl
import janitor.polars
from euroleague_api.play_by_play_data import PlayByPlay

Con esto ya tenemos lo necesario para empezar a trabajar.

En este ejemplo vamos a extraer el play-by-play completo de la última temporada en Euroliga.
Aquí tienes el enlace a toda la documentación de la API por si prefieres sacar cualquier otro dataset disponible.

(Tip: para EuroCup solo hay que cambiar la “E” por la “U”. El año siempre corresponde al primero de la temporada: por ejemplo, la 24-25 se escribe como 2024).

competition_code = "E"  #  Rrecuerda EuroLeague ("E"), EuroCup suele ser "U"

# 1) Instanciar
pbp = PlayByPlay(competition_code)

# 2) Descargar toda la temporada (devuelve pandas.DataFrame)
pbp_df = pbp.get_game_play_by_play_data_single_season(season=2024)

Así es como lo veo yo, y así se vería si trabajas con VSCode y Jupyter Notebooks, tal como comenté antes

La API te devuelve un DataFrame de Pandas, bastante malo (de los peores que he descargado, solo comparable al de la primera FEB). Para poder trabajar con Polars hay que convertirlo a un DataFrame de Polars, y para eso necesitamos tener instalado ipywidgets. Así que, por si acaso, aquí te dejo el pip

#Escribimos en el terminal
pip install -U ipywidgets

Ok, ya tenemos el widget instalado, ahora lo convertimos a un dataframe de Polars.

df = pl.from_pandas(pbp_df)

Ya tenemos el play-by-play, pero no es muy usable tal y como viene. Así que vamos a transformarlo en algo con lo que realmente podamos trabajar y calcular datos. Lo primero que me llama la atención es la columna PLAYINFO: describe el tipo de jugada, los intentos realizados/convertidos y los puntos acumulados por el jugador. Nosotros vamos a usar únicamente la jugada y los puntos. En lugar de complicarnos con un regex que extraiga, separe y construya nuevas columnas, lo haremos de una forma más sencilla.

Hasta aquí la parte abierta de este tutorial. Hemos preparado el terreno, instalado librerías y visto cómo luce el play-by-play en bruto.

A partir de aquí viene lo interesante: cómo transformar esos datos en un formato realmente útil para analizarlos. Te enseño paso a paso cómo limpiar la columna PLAYINFO, generar variables nuevas y empezar a construir métricas desde cero.

👉 Todo eso lo encontrarás en la parte premium del post. Si quieres seguir y acceder al código completo con explicaciones detalladas, suscríbete a la versión de pago y apoya este proyecto.

Read more