Analizar datos de Cricket con Python: una guía práctica

Share on facebook
Share on twitter
Share on linkedin
Share on telegram
Share on whatsapp

Contenidos

Este artículo fue publicado como parte del Blogatón de ciencia de datos

Introducción

Python es un lenguaje versátil. Se utiliza para fines generales de programación y desarrollo, y también para tareas complejas como aprendizaje automático, ciencia de datos y análisis de datos. No solo es fácil de aprender, sino que también tiene algunas bibliotecas maravillosas, lo que lo convierte en el lenguaje de programación de primera elección para mucha gente.

En este artículo, veremos uno de esos casos de uso de Python. Usaremos Python para analizar el desempeño del jugador de cricket indio MS Dhoni en su carrera de One Day International (ODI).

93595dhoni_photo-4874470

Conjunto de datos

Si está familiarizado con el concepto de web scraping, puede extraer los datos de este Enlace ESPN Cricinfo. Si no conoce el raspado web, ¡no se preocupe! Puede descargar los datos directamente desde aquí. Los datos están disponibles como un archivo de Excel para descargar.

Una vez que tenga el conjunto de datos con usted, deberá cargarlo en Python. Puede usar el fragmento de código a continuación para cargar el conjunto de datos en Python:

# importing essential libraries and packages
import pandas as pd
import numpy as np
import datetime
import matplotlib.pyplot as plt
import seaborn as sns
# reading the dataset
df = pd.read_excel('MS_Dhoni_ODI_record.xlsx')

Una vez que se ha leído el conjunto de datos, debemos mirar el principio y el final del conjunto de datos para asegurarnos de que se importa correctamente. El encabezado del conjunto de datos debería verse así:

9977161-8981997

Si los datos se cargan correctamente, podemos pasar al siguiente paso, limpieza y preparación de datos.

Limpieza y preparación de datos

Estos datos se han extraído de una página web, por lo que no están muy limpios. Comenzaremos eliminando los primeros 2 caracteres de la cadena de oposición porque eso no es necesario.

# removing the first 2 characters in the opposition string
df['opposition'] = df['opposition'].apply(lambda x: x[2:])

A continuación, crearemos una columna para el año en el que se jugó el partido. Asegúrese de que la columna de fecha esté presente en el formato DateTime en su DataFrame. De lo contrario, utilice pd.to_datetime () para convertirlo al formato DateTime.

# creating a feature for match year
df['year'] = df['date'].dt.year.astype(int)

También crearemos una columna que indique si Dhoni no estuvo en esa entrada o no.

# creating a feature for being not out
df['score'] = df['score'].apply(str)
df['not_out'] = np.where(df['score'].str.endswith('*'), 1, 0)

Ahora eliminaremos la columna del número ODI porque no es necesaria.

# dropping the odi_number feature because it adds no value to the analysis
df.drop(columns="odi_number", inplace=True)

También eliminaremos todas las coincidencias de nuestros registros en las que Dhoni no bateó y almacenaremos esta información en un nuevo DataFrame.

# dropping those innings where Dhoni did not bat and storing in a new DataFrame
df_new = df.loc[((df['score'] != 'DNB') & (df['score'] != 'TDNB')), 'runs_scored':]

Finalmente, arreglaremos los tipos de datos de todas las columnas presentes en nuestro nuevo DataFrame.

# fixing the data types of numerical columns
df_new['runs_scored'] = df_new['runs_scored'].astype(int)
df_new['balls_faced'] = df_new['balls_faced'].astype(int)
df_new['strike_rate'] = df_new['strike_rate'].astype(float)
df_new['fours'] = df_new['fours'].astype(int)
df_new['sixes'] = df_new['sixes'].astype(int)

Estadísticas de carrera

Echaremos un vistazo al estadísticas descriptivas de la carrera ODI de MS Dhoni. Puede usar el siguiente código para esto:

first_match_date = df['date'].dt.date.min().strftime('%B %d, %Y') # first match
print('First match:', first_match_date)
last_match_date = df['date'].dt.date.max().strftime('%B %d, %Y') # last match
print('nLast match:', last_match_date)
number_of_matches = df.shape[0] # number of mathces played in career
print('nNumber of matches played:', number_of_matches)
number_of_inns = df_new.shape[0] # number of innings
print('nNumber of innings played:', number_of_inns)
not_outs = df_new['not_out'].sum() # number of not outs in career
print('nNot outs:', not_outs)
runs_scored = df_new['runs_scored'].sum() # runs scored in career
print('nRuns scored in career:', runs_scored)
balls_faced = df_new['balls_faced'].sum() # balls faced in career
print('nBalls faced in career:', balls_faced)
career_sr = (runs_scored / balls_faced)*100 # career strike rate
print('nCareer strike rate: {:.2f}'.format(career_sr))
career_avg = (runs_scored / (number_of_inns - not_outs)) # career average
print('nCareer average: {:.2f}'.format(career_avg))
highest_score_date = df_new.loc[df_new.runs_scored == df_new.runs_scored.max(), 'date'].values[0]
highest_score = df.loc[df.date == highest_score_date, 'score'].values[0] # highest score
print('nHighest score in career:', highest_score)
hundreds = df_new.loc[df_new['runs_scored'] >= 100].shape[0] # number of 100s
print('nNumber of 100s:', hundreds)
fifties = df_new.loc[(df_new['runs_scored']>=50)&(df_new['runs_scored']<100)].shape[0] #number of 50s
print('nNumber of 50s:', fifties)
fours = df_new['fours'].sum() # number of fours in career
print('nNumber of 4s:', fours)
sixes = df_new['sixes'].sum() # number of sixes in career
print('nNumber of 6s:', sixes)

La salida debería verse así:

3238762-6518323

Esto nos da una buena idea de la carrera general de MS Dhoni. Comenzó a jugar en 2004, y jugó por última vez un ODI en 2019. En una carrera de más de 15 años, ha anotado 10cientos y la asombrosa cantidad de 73 cincuenta. Ha anotado más de 10,000 carreras en su carrera con un promedio de 50.6 y una tasa de strike de 87.6. Su puntuación más alta es 183 *.

Ahora haremos un análisis más exhaustivo de su actuación contra diferentes equipos. También veremos su desempeño año tras año. Tomaremos la ayuda de visualizaciones para esto.

Análisis

En primer lugar, veremos cuántos partidos que ha jugado contra diferentes oposiciones. Puede utilizar el siguiente código para este propósito:

# number of matches played against different oppositions
df['opposition'].value_counts().plot(kind='bar', title="Number of matches against different oppositions", figsize=(8, 5));

La salida debería verse así:

4745663-5469482

Podemos ver que ha jugado la mayoría de sus partidos contra Sri Lanka, Australia, Inglaterra, West Indies, Sudáfrica y Pakistán.

Veamos cuántos carreras que ha marcado contra diferentes oposiciones. Puede utilizar el siguiente fragmento de código para generar el resultado:

runs_scored_by_opposition = pd.DataFrame(df_new.groupby('opposition')['runs_scored'].sum())
runs_scored_by_opposition.plot(kind='bar', title="Runs scored against different oppositions", figsize=(8, 5))
plt.xlabel(None);

La salida se verá así:

3054064-3236023

Podemos ver que Dhoni ha anotado la mayor cantidad de carreras contra Sri Lanka, seguido de Australia, Inglaterra y Pakistán. También ha jugado muchos partidos contra estos equipos, así que tiene sentido.

Para tener una imagen más clara, echemos un vistazo a su promedio de bateo contra cada equipo. El siguiente fragmento de código nos ayudará a obtener el resultado deseado:

innings_by_opposition = pd.DataFrame(df_new.groupby('opposition')['date'].count())
not_outs_by_opposition = pd.DataFrame(df_new.groupby('opposition')['not_out'].sum())
temp = runs_scored_by_opposition.merge(innings_by_opposition, left_index=True, right_index=True)
average_by_opposition = temp.merge(not_outs_by_opposition, left_index=True, right_index=True)
average_by_opposition.rename(columns = {'date': 'innings'}, inplace=True)
average_by_opposition['eff_num_of_inns'] = average_by_opposition['innings'] - average_by_opposition['not_out']
average_by_opposition['average'] = average_by_opposition['runs_scored'] / average_by_opposition['eff_num_of_inns']
average_by_opposition.replace(np.inf, np.nan, inplace=True)
major_nations = ['Australia', 'England', 'New Zealand', 'Pakistan', 'South Africa', 'Sri Lanka', 'West Indies']

Para generar el gráfico, use el fragmento de código a continuación:

plt.figure(figsize = (8, 5))
plt.plot(average_by_opposition.loc[major_nations, 'average'].values, marker="o")
plt.plot([career_avg]*len(major_nations), '--')
plt.title('Average against major teams')
plt.xticks(range(0, 7), major_nations)
plt.ylim(20, 70)
plt.legend(['Avg against opposition', 'Career average']);

La salida se verá así:

2691265-8822385

Como podemos ver, Dhoni se ha desempeñado notablemente contra equipos duros como Australia, Inglaterra y Sri Lanka. Su promedio contra estos equipos está cerca del promedio de su carrera o ligeramente más alto. El único equipo contra el que no ha tenido un buen desempeño es Sudáfrica.

Veamos ahora sus estadísticas interanuales. Empezaremos mirando cuántos partidos ha jugado cada año después de su debut. El código para eso será:

df['year'].value_counts().sort_index().plot(kind='bar', title="Matches played by year", figsize=(8, 5))
plt.xticks(rotation=0);

La trama se verá así:

6946666-6733820

Podemos ver que en 2012, 2014 y 2016, Dhoni jugó muy pocos partidos de ODI para India. En general, después de 2005-2009, el número medio de partidos que jugó se redujo ligeramente.

También deberíamos mirar cuántos carreras que ha marcado todos los años. El código para eso será:

df_new.groupby('year')['runs_scored'].sum().plot(kind='line', marker="o", title="Runs scored by year", figsize=(8, 5))
years = df['year'].unique().tolist()
plt.xticks(years)
plt.xlabel(None);

La salida debería verse así:

4937967-6641218

Se puede ver claramente que Dhoni anotó la mayor cantidad de carreras en el año 2009, seguido de 2007 y 2008. El número de carreras comenzó a reducirse después de 2010 (porque el número de partidos jugados también comenzó a reducirse).

Finalmente, veamos su Progresión promedio de bateo de carrera por entradas. Estos son datos de series de tiempo y se han representado en un diagrama de líneas. El código para eso será:

df_new.reset_index(drop=True, inplace=True)
career_average = pd.DataFrame()
career_average['runs_scored_in_career'] = df_new['runs_scored'].cumsum()
career_average['innings'] = df_new.index.tolist()
career_average['innings'] = career_average['innings'].apply(lambda x: x+1)
career_average['not_outs_in_career'] = df_new['not_out'].cumsum()
career_average['eff_num_of_inns'] = career_average['innings'] - career_average['not_outs_in_career']
career_average['average'] = career_average['runs_scored_in_career'] / career_average['eff_num_of_inns']

El fragmento de código para la trama será:

plt.figure(figsize = (8, 5))
plt.plot(career_average['average'])
plt.plot([career_avg]*career_average.shape[0], '--')
plt.title('Career average progression by innings')
plt.xlabel('Number of innings')
plt.legend(['Avg progression', 'Career average']);

El gráfico de salida se verá así:

6257868-2808702

Podemos ver que después de un comienzo lento y una caída en el rendimiento en la entrada número 50, el rendimiento de Dhoni se recuperó sustancialmente. Hacia el final de su carrera, constantemente promedió por encima de 50.

EndNote

En este artículo, analizamos el rendimiento de bateo del jugador de cricket indio MS Dhoni. Observamos las estadísticas generales de su carrera, su desempeño contra diferentes oponentes y su desempeño año tras año.

Este artículo ha sido escrito por Vishesh Arora. Puedes conectarte conmigo en LinkedIn.

Los medios que se muestran en este artículo no son propiedad de DataPeaker y se utilizan a discreción del autor.

Suscribite a nuestro Newsletter

No te enviaremos correo SPAM. Lo odiamos tanto como tú.

error: Alert: Content is protected !!