Spaces:
Sleeping
Sleeping
| import pandas as pd | |
| def check_columns(df, required_columns): | |
| """ | |
| Vérifie si les colonnes requises sont présentes dans le DataFrame. | |
| Parameters: | |
| - df (pd.DataFrame): Le DataFrame à vérifier. | |
| - required_columns (list): Liste des noms de colonnes requis. | |
| Returns: | |
| - bool: True si toutes les colonnes sont présentes, sinon False. | |
| """ | |
| return all(column in df.columns for column in required_columns) | |
| class StatsManager: | |
| def __init__(self, events): | |
| self.events = events | |
| def calculate_stat(self, required_columns, func): | |
| """ | |
| Vérifie si les colonnes nécessaires sont présentes, puis applique la fonction de calcul si elles sont présentes. | |
| Parameters: | |
| - required_columns (list): Liste des colonnes requises. | |
| - func (callable): Fonction à appliquer si les colonnes sont présentes. | |
| Returns: | |
| - tuple: Les résultats de la fonction si les colonnes sont présentes, sinon (None, None). | |
| """ | |
| if check_columns(self.events, required_columns): | |
| return func(self.events) | |
| else: | |
| return None, None | |
| def get_possession(self): | |
| return self.calculate_stat(['possession_team'], self._calculate_possession) | |
| def _calculate_possession(self, events): | |
| possession_counts = events['possession_team'].value_counts() | |
| if len(possession_counts) < 2: | |
| return None, None | |
| total_possession = possession_counts.iloc[0] + possession_counts.iloc[1] | |
| home_possession = round((possession_counts.iloc[0] / total_possession) * 100, 1) | |
| away_possession = round((possession_counts.iloc[1] / total_possession) * 100, 1) | |
| return home_possession, away_possession | |
| def get_total_xg(self): | |
| return self.calculate_stat(['shot_statsbomb_xg', 'team'], self._calculate_total_xg) | |
| def _calculate_total_xg(self, events): | |
| data = events[['shot_statsbomb_xg', 'team']].dropna(subset=['shot_statsbomb_xg']) | |
| if data.empty: | |
| return None, None | |
| data = data.groupby('team')['shot_statsbomb_xg'].sum() | |
| if len(data) < 2: | |
| return None, None | |
| return round(data.iloc[0], 2), round(data.iloc[1], 2) | |
| def get_total_shots(self): | |
| return self.calculate_stat(['shot_statsbomb_xg', 'team'], self._calculate_total_shots) | |
| def _calculate_total_shots(self, events): | |
| data = events[['shot_statsbomb_xg', 'team']].dropna(subset=['shot_statsbomb_xg']) | |
| if data.empty: | |
| return None, None | |
| shot_counts = data.groupby('team').count()['shot_statsbomb_xg'] | |
| if len(shot_counts) < 2: | |
| return None, None | |
| return shot_counts.iloc[0], shot_counts.iloc[1] | |
| def get_total_shots_off_target(self): | |
| return self.calculate_stat(['shot_outcome', 'team'], self._calculate_total_shots_off_target) | |
| def _calculate_total_shots_off_target(self, events): | |
| off_target_outcomes = ['Off T', 'Blocked', 'Missed'] | |
| data = events[events['shot_outcome'].isin(off_target_outcomes)] | |
| if data.empty: | |
| return None, None | |
| off_target_counts = data.groupby('team').size() | |
| if len(off_target_counts) < 2: | |
| return None, None | |
| return off_target_counts.iloc[0], off_target_counts.iloc[1] | |
| def get_total_shots_on_target(self): | |
| return self.calculate_stat(['shot_outcome', 'team'], self._calculate_total_shots_on_target) | |
| def _calculate_total_shots_on_target(self, events): | |
| on_target_outcomes = ['Goal', 'Saved', 'Saved To Post', 'Shot Saved Off Target'] | |
| data = events[events['shot_outcome'].isin(on_target_outcomes)] | |
| if data.empty: | |
| return None, None | |
| on_target_counts = data.groupby('team').size() | |
| if len(on_target_counts) < 2: | |
| return None, None | |
| return on_target_counts.iloc[0], on_target_counts.iloc[1] | |
| def get_total_passes(self): | |
| return self.calculate_stat(['pass_end_location', 'team'], self._calculate_total_passes) | |
| def _calculate_total_passes(self, events): | |
| pass_counts = events.filter(regex='^pass_end_location|^team$').groupby('team').count()['pass_end_location'] | |
| if len(pass_counts) < 2: | |
| return None, None | |
| return pass_counts.iloc[0], pass_counts.iloc[1] | |
| def get_successful_passes(self): | |
| return self.calculate_stat(['pass_outcome', 'team'], self._calculate_successful_passes) | |
| def _calculate_successful_passes(self, events): | |
| home_passes, away_passes = self.get_total_passes() | |
| unsuccessful_passes = events.filter(regex='^pass_outcome|^team$').groupby('team').count().reset_index()['pass_outcome'] | |
| if len(unsuccessful_passes) < 2: | |
| return None, None | |
| home_unsuccessful_passes = unsuccessful_passes.iloc[0] | |
| away_unsuccessful_passes = unsuccessful_passes.iloc[1] | |
| return home_passes - home_unsuccessful_passes, away_passes - away_unsuccessful_passes | |
| def get_total_corners(self): | |
| return self.calculate_stat(['pass_type', 'team'], self._calculate_total_corners) | |
| def _calculate_total_corners(self, events): | |
| corner_counts = events.filter(regex='^pass_type|^team$').query('pass_type == "Corner"').groupby('team').count()['pass_type'] | |
| if len(corner_counts) < 2: | |
| return None, None | |
| return corner_counts.iloc[0], corner_counts.iloc[1] | |
| def get_total_fouls(self): | |
| return self.calculate_stat(['type', 'team'], self._calculate_total_fouls) | |
| def _calculate_total_fouls(self, events): | |
| fouls = events[events['type'] == 'Foul Committed'] | |
| foul_counts = fouls.groupby('team').size() | |
| if len(foul_counts) < 2: | |
| return None, None | |
| return foul_counts.iloc[0], foul_counts.iloc[1] | |
| def get_total_yellow_cards(self): | |
| return self.calculate_stat(['bad_behaviour_card', 'team'], self._calculate_total_yellow_cards) | |
| def _calculate_total_yellow_cards(self, events): | |
| yellow_card_counts = events.filter(regex='^bad_behaviour_card|^team$').query('bad_behaviour_card == "Yellow Card"').groupby('team').count()['bad_behaviour_card'] | |
| if len(yellow_card_counts) < 2: | |
| return None, None | |
| return yellow_card_counts.iloc[0], yellow_card_counts.iloc[1] | |
| def get_total_red_cards(self): | |
| return self.calculate_stat(['bad_behaviour_card', 'team'], self._calculate_total_red_cards) | |
| def _calculate_total_red_cards(self, events): | |
| red_card_counts = events.filter(regex='^bad_behaviour_card|^team$').query('bad_behaviour_card == "Red Card"').groupby('team').count()['bad_behaviour_card'] | |
| if len(red_card_counts) < 2: | |
| return None, None | |
| return red_card_counts.iloc[0], red_card_counts.iloc[1] | |