<jupyter_start><jupyter_text>Avant propos: _Concernant les données utilisés dans cette série de sessions dans les notebooks__Les données utilisés dans cette série de tutoriels sont récupérés du site [fivethirtyeight.com](https://data.fivethirtyeight.com/). Ces données sont issues et publiés en licence  Creative [Commons Attribution 4.0 International License](https://creativecommons.org/licenses/by/4.0/).__J'utiliserais certaines données pour créer des tutoriels et récupérer des données réalistes afin de nous permettre de raconter une histoires et réaliser des visualisations.__Les données sont publiés dans un github publique je les au récupéré dans un fork que vous pouvez récupéré ici [opentrainingcamp/data](https://github.com/opentrainingcamp/data)_  Pourquois Python et pandas?Une des taches du datascientiste commence par la récuparation des données pertinante, puis éventuellement les stocké. Dans ce parcours d'apprentissage complémentaire, vous vous familiariserez avec Pandas et découvrirez les tenants et les aboutissants de la façon dont vous pouvez l'utiliser pour récupérer et analyser des données avec Python et ensuite les archiver.Pandas change la donne pour la science des données et l'analyse, en particulier si vous êtes arrivé à Python parce que vous recherchiez quelque chose de plus puissant qu'Excel et VBA. Pandas utilise des structures de données rapides, flexibles et expressives conçues pour rendre le travail avec des données relationnelles ou étiquetées (NoSql) à la fois facile et intuitif.Nous utiliserons Pandas comme pivot depuis et vers les BD Nosql: mongodeb, cassandra et elasticserch SEANCE DS01: Vous disposez d'un vaste ensemble de données riche en informations intéressantes, mais vous ne savez pas par où commencer à l'explorer? Vous souhaitez générer des statistiques à partir de celui-ci, mais elles ne sont pas si faciles à extraire? Ce sont précisément les cas d'utilisation où Pandas et Python peuvent vous aider! Avec ces outils, vous serez en mesure de découper un vaste ensemble de données en parties gérables et de tirer un aperçu de ces informations. Dans cette premières séance "Pandas", vous apprendrez à:* Calculez des métriques sur vos données* Effectuer des requêtes et des agrégations de base* Découvrez et gérez les données incorrectes, les incohérences et les valeurs manquantes* Visualisez vos données avec des tracés* Vous découvrirez également les différences entre les principales structures de données utilisées par Pandas et Python. Pour suivre, vous pouvez obtenir tous les exemples de code de ce didacticiel sur le lien ci-dessous:[Dans github](https://github.com/lipug/datascience)  Un utilitaire pour lire des urls (c'est du Python!)<jupyter_code>import requests

download_url = "https://github.com/lipug/datascience/raw/main/packages/lire.py"
target_path = "lire.py"

response = requests.get(download_url)
response.raise_for_status()    # Verifier tout est ok
with open(target_path, "wb") as f:
    f.write(response.content)
print("C'est fait....")<jupyter_output>C'est fait....<jupyter_text>.... explications ...  Montrons un avant goût des capacités des Pandas DataFrame. _Voici le dictionnaire de données que nous utiliserons [Classement ELO historique de la NBA](https://github.com/opentrainingcamp/data/tree/master/nba-elo)_<jupyter_code>l = ['https://github.com/opentrainingcamp/data/raw/master/nba-elo/nbaallelo.csv']
import lire
lire.read_from_url(l[0])
import pandas as pd
nba = pd.read_csv("nbaallelo.csv")
type(nba)
# ou directement
nba_f_url = pd.read_csv('https://github.com/opentrainingcamp/data/raw/master/nba-elo/nbaallelo.csv')
type(nba_f_url)
# Avons nous lu la même chose?
nba == nba_f_url<jupyter_output><empty_output><jupyter_text>On a suivi la convention d'importation de Pandas en Python avec l'alias pd. Ensuite, vous utilisez `.read_csv()` pour lire l'ensemble de données et le stocker en tant qu'objet DataFrame dans la variable nba. Vous pouvez voir combien de données nba contient:<jupyter_code>print(len(nba),nba.shape)<jupyter_output>126314 (126314, 23)<jupyter_text>Vous utilisez la fonction intégrée Python `len()` pour déterminer le nombre de lignes. Vous utilisez également l'attribut `.shape du DataFrame` pour voir sa dimensionnalité. Le résultat est un tuple contenant le nombre de lignes et de colonnes.Vous savez maintenant qu'il y a 126 314 lignes et 23 colonnes dans votre ensemble de données. Mais comment être sûr que l'ensemble de données contient vraiment des statistiques de basket-ball? Vous pouvez jeter un œil aux cinq premières lignes avec `.head()`:<jupyter_code>nba.head()<jupyter_output><empty_output><jupyter_text>Bien qu'il soit pratique de voir toutes les colonnes, vous n'aurez probablement pas besoin de six décimales! Changez-le en deux:<jupyter_code>pd.set_option("display.precision", 2)
help(pd.set_option)<jupyter_output><empty_output><jupyter_text>Pour vérifier que vous avez correctement modifié les options, vous pouvez exécuter à nouveau .head () ou afficher les cinq dernières lignes avec .tail () à la place:<jupyter_code>nba.tail()<jupyter_output><empty_output><jupyter_text>Vous pouvez découvrir d'autres possibilités de .head () et .tail () avec un petit exercice. Pouvez-vous imprimer les trois dernières lignes de votre DataFrame? Développez le bloc de code ci-dessous pour voir la solution:<jupyter_code># completer
nba.head(1)<jupyter_output><empty_output><jupyter_text>Semblable à la bibliothèque standard Python, les fonctions de Pandas sont également fournies avec plusieurs paramètres facultatifs. Chaque fois que vous tombez sur un exemple qui semble pertinent mais qui est légèrement différent de votre cas d'utilisation, consultez la [documentation officielle](https://pandas.pydata.org/pandas-docs/stable/). Il y a de bonnes chances que vous trouviez une solution en modifiant certains paramètres facultatifs!  Apprendre à connaître vos donnéesVous avez importé un fichier CSV avec la bibliothèque Pandas Python et jeté un premier coup d'œil au contenu de votre ensemble de données. Jusqu'à présent, vous n'avez vu que la taille de votre ensemble de données et ses premières et dernières lignes. Vous devez apprendre à examiner vos données de manière plus systématique.  Affichage des types de donnéesLa première étape pour connaître vos données consiste à découvrir les différents types de données qu'elles contiennent. Bien que vous puissiez mettre n'importe quoi dans une liste, les colonnes d'un DataFrame contiennent des valeurs d'un type de données spécifique. Lorsque vous comparez les structures de données Pandas et Python, vous verrez que ce comportement rend les Pandas beaucoup plus rapides!Vous pouvez afficher toutes les colonnes et leurs types de données avec .info ():<jupyter_code>nba.info()<jupyter_output><class 'pandas.core.frame.DataFrame'>
RangeIndex: 126314 entries, 0 to 126313
Data columns (total 23 columns):
 #   Column         Non-Null Count   Dtype  
---  ------         --------------   -----  
 0   gameorder      126314 non-null  int64  
 1   game_id        126314 non-null  object 
 2   lg_id          126314 non-null  object 
 3   _iscopy        126314 non-null  int64  
 4   year_id        126314 non-null  int64  
 5   date_game      126314 non-null  object 
 6   seasongame     126314 non-null  int64  
 7   is_playoffs    126314 non-null  int64  
 8   team_id        126314 non-null  object 
 9   fran_id        126314 non-null  object 
 10  pts            126314 non-null  int64  
 11  elo_i          126314 non-null  float64
 12  elo_n          126314 non-null  float64
 13  win_equiv      126314 non-null  float64
 14  opp_id         126314 non-null  object 
 15  opp_fran       126314 non-null  object 
 16  opp_pts        126314 non-null  int64  
 17  opp_elo_i      126314 non-nul[...]<jupyter_text>Pour plus d'informations, consultez [le guide de démarrage officiel](https://pandas.pydata.org/pandas-docs/stable/getting_started/).  Affichage des statistiques de baseMaintenant que vous avez vu quels types de données se trouvent dans votre ensemble de données, il est temps d'avoir un aperçu des valeurs que contient chaque colonne. Vous pouvez le faire avec `.describe()`:<jupyter_code>nba.describe()<jupyter_output><empty_output><jupyter_text>.describe () analyse uniquement les colonnes numériques par défaut, mais vous pouvez fournir d'autres types de données si vous utilisez le paramètre include:<jupyter_code>import numpy as np
nba.describe(include=np.object_)<jupyter_output><empty_output><jupyter_text>Jetez un œil aux colonnes team_id et fran_id. Votre ensemble de données contient 104 ID d'équipe différents, mais seulement 53 ID de franchise différents. De plus, l'ID d'équipe le plus fréquent est BOS, mais l'ID de franchise le plus fréquent est Lakers. Comment est-ce possible? Vous devrez explorer un peu plus votre ensemble de données pour répondre à cette question.  Explorer votre ensemble de donnéesL'analyse exploratoire des données peut vous aider à répondre à des questions sur votre ensemble de données. Par exemple, vous pouvez examiner la fréquence à laquelle des valeurs spécifiques apparaissent dans une colonne:<jupyter_code>nba["team_id"]
nba["team_id"].value_counts()
nba["fran_id"].value_counts()<jupyter_output><empty_output><jupyter_text>Il semble qu'une équipe nommée "Lakers" ait joué 6024 matchs, mais seuls 5078 d'entre eux ont été joués par les Lakers de Los Angeles (LAL). Découvrez qui est l'autre équipe "Lakers":<jupyter_code>nba.loc[nba["fran_id"] == "Lakers", ["team_id", "notes"]] 
# select team_id, notes from nba where fran_id = 'Lakers'
nba.loc[nba["fran_id"] == "Lakers", "team_id"].value_counts()<jupyter_output><empty_output><jupyter_text>En effet, les Lakers de Minneapolis («MNL») ont disputé 946 matchs. Vous pouvez même savoir quand ils ont joué à ces jeux:<jupyter_code>nba.loc[nba["team_id"] == "MNL", "date_game"].min()
nba.loc[nba["team_id"] == "MNL", "date_game"].max()
nba.loc[nba["team_id"] == "MNL", "date_game"].agg(("min", "max"))
nba.loc[nba["team_id"] == "BOS", "date_game"].agg(("min", "max"))<jupyter_output><empty_output><jupyter_text>On dirait que les Lakers de Minneapolis ont joué entre les années 1949 et 1959. Cela explique pourquoi vous pourriez ne pas reconnaître cette équipe! Surtout si on est Français ;) Vous avez également découvert pourquoi l'équipe des Boston Celtics «BOS» a joué le plus de matchs de l'ensemble de données. Analysons également un peu leur histoire. Découvrez combien de points les Celtics de Boston ont marqués au cours de tous les matchs contenus dans cet ensemble de données. Développez le bloc de code ci-dessous pour la solution:<jupyter_code>nba.loc[nba["team_id"] == "BOS", "pts"].agg(("sum", "min", "max", "mean", "std"))<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.07375754760798885, 'fraction_numerical': 0.020808174640037157, 'mean_word_length': 4.987764182424916, 'pattern_counts': {'":': 1, '<': 55, '<?xml version=': 0, '>': 55, 'https://': 10, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 2, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '14', 'dir': 'jupyter-structured-clean-dedup', 'id': '506856', 'license': 'MIT', 'n_tokens_mistral': 3701, 'n_tokens_neox': 3563, 'n_words': 1278, 'path': 'Notebook/Data/DS01_Pandas_pour_datascience.ipynb', 'repo_name': 'opentrainingcamp/python', 'size': '10765'}