--- title: Pandas author: Steve Kossouho --- # Manipuler des fichiers ---- ## Charger un fichier Si le principal intérêt de Pandas est de manipuler des données pour en extraire des informations, cela se fait difficilement sans outils intégrés pour charger des sources de données généralistes. Pandas est capable de lire et de convertir en `DataFrame`{.python} des données provenant de sources dans des formats tels que [CSV]{.naming}, [JSON]{.naming}, [XLSX]{.naming}, [SAS]{.naming} ou encore des requêtes [SQL]{.naming}. ---- ### Fichiers CSV La fonction de chargement de documents CSV de Pandas se nomme simplement `pandas.read_csv()`{.python}. Cette fonction est capable de renvoyer un `DataFrame`{.python} depuis un document, dont le chemin peut être : 1. Un chemin de fichier local, absolu ou relatif; 2. une URL utilisant le protocole HTTP, HTTPS, FTP ou S3. ```python {.numberLines} import pandas as pd data = pd.read_csv("https://sub.domain.tld/resource-path.csv") ``` La fonction propose de nombreux _arguments avec valeur par défaut_ pour personnaliser le chargement du document. Il est ainsi possible de personnaliser l'encodage, la détection d'en-tête, ou encore demander à interpréter spécifiquement le contenu de colonnes de type date ou de type numérique. [Documentation de `read_csv`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_csv.html) ---- ### Fichiers Excel Les documents [Open Document (ODS)]{.naming} et [Excel]{.naming} possèdent plusieurs différences notables avec les documents [CSV]{.naming} : 1. Ils contiennent potentiellement plusieurs feuilles de calcul; 2. ils possèdent des informations sur le type ([format]{.naming}) des cellules. Vous pouvez ainsi charger plusieurs `DataFrame`{.python} depuis un seul document de tableur, ou choisir une feuille de calcul à charger. Également, vous n'avez normalement pas à préciser d'arguments pour interpréter correctement des dates; l'information est présente dans le document. [Documentation de `read_excel`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_excel.html) ```python {.numberLines} import pandas as pd data: pd.DataFrame = pd.read_excel("https://sub.domain.tld/resource-path.csv", sheet_name="Sheet1") sheets: dict[str, pd.DataFrame] = pd.read_excel("https://sub.domain.tld/resource-path.csv", sheet_name=None) ``` ---- #### Bibliothèques tableur Selon le type de document à charger, par défaut, Pandas aura besoin d'une bibliothèque supplémentaire pour interpréter le contenu du document. | Type de document | Bibliothèque à installer | |------------------|-------------------------------| | `.odf` | `pip install odfpy`{.bash} | | `.xls` | `pip install xlrd`{.bash} | | `.xlsb` | `pip install pyxlsb`{.bash} | | `.xlsx` | `pip install openpyxl`{.bash} | ---- ### Requête SQL Bien que le SQL puisse être utilisé seul pour de l'analyse de données, charger le résultat d'une requête SQL dans un `DataFrame`{.python} peut être utile pour effectuer des calculs spécifiques avec Pandas, ou encore générer facilement des graphiques. Pandas propose deux fonctions pour charger du contenu SQL : 1. `def read_sql_table(table: str, connection, ...)`{.python} 2. `def read_sql_query(sql: str, connection, ...)`{.python} - [Documentation de `read_sql_table`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_sql_table.html) - [Documentation de `read_sql_query`](https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.read_sql_query.html) ---- Ces deux fonctions nécessitent un objet de connexion à une base, qui peut provenir de deux bibliothèques uniquement : | Base de données | Bibliothèque à utiliser | |----------------------|---------------------------| | SQLite3 | `sqlite3` ou `sqlalchemy` | | MySQL / MariaDB | `sqlalchemy` | | PostgreSQL | `sqlalchemy` | | Oracle | `sqlalchemy` | | Microsoft SQL Server | `sqlalchemy` | ---- #### SQLAlchemy [SQLAlchemy](https://www.sqlalchemy.org/) est une bibliothèque qu'on appelle communément un [ORM]{.naming}. C'est une abstraction objet qui permet de converser avec des moteurs de base de données SQL uniquement avec des classes et des méthodes Python. Pandas est capable d'utiliser des objets de connexion de la bibliothèque SQLAlchemy pour envoyer des commandes brutes SQL. ```python {.numberLines} import pandas as pd from sqlalchemy import create_engine # L'URL dépend du moteur à utiliser. engine = create_engine("sqlite:///home/user/path/file.db") with engine.connect() as connection: data = pd.read_sql_table("", connection) ``` ---- #### SQLite3 La bibliothèque SQLite3 fournie avec les distributions classiques de Python, est une bibliothèque [DBAPI 2.0]{.naming} uniquement compatible avec le moteur de bases de données embarquées SQLite 3. Pandas accepte les objets de connexion de la bibliothèque pour envoyer des commandes SQL. ```python {.numberLines} import pandas as pd import sqlite3 connection = sqlite3.connect("/home/user/path/file.db") data = pd.read_sql_query("SELECT * FROM table WHERE column = 1", connection) connection.close() ``` ---- ### SAS Les fichiers de [datasets]{.naming} produits par la solution commerciale propriétaire SAS sont lisibles par Pandas. Le type des colonnes récupérées correspond normalement à ce qui aura été défini dans le document. ```python {.numberLines} import pandas as pd data = pd.read_sas("/path/to/file.sas7bdat") ``` ---- ### Parquet Le format [Parquet]{.naming} est un format de fichier en colonnes optimisé pour une utilisation avec des systèmes de traitement de données à grande échelle comme Hadoop. Il est spécialement conçu pour fonctionner avec la bibliothèque Apache Arrow et fournit des performances exceptionnelles pour des ensembles de données de grande taille. Pour charger un DataFrame depuis un fichier Parquet, vous pouvez utiliser la fonction `pandas.read_parquet()`{.python}. Cette fonction renvoie un objet `DataFrame` à partir d'une source de fichier Parquet. La source peut être un chemin de fichier local, absolu ou relatif ou une URL utilisant le protocole HTTP, FTP ou S3. Assurez-vous d'abord d'installer le paquet nécessaire pour lire les fichiers Parquet : ```bash {.numberLines} pip install pyarrow # ou pip install fastparquet ``` ---- Voici un exemple de code pour charger un DataFrame à partir d'un fichier Parquet : ```python {.numberLines} import pandas as pd # Charger un DataFrame depuis un fichier Parquet df = pd.read_parquet('/path/to/fichier.parquet') ``` Notez que si votre fichier Parquet est compressé (par exemple avec Snappy, Gzip ou Brotli), Pandas sera en mesure de le décompresser automatiquement lors de la lecture. ---- ## Sauvegarder pour Excel Enregistrer un fichier Excel depuis les données d'un `DataFrame` est extrêmement simple; chaque `DataFrame`{.python} possède des méthodes de sérialisation telles que `.to_excel()`{.python} ```python {.numberLines} import pandas as pd # Créer un dataframe simple df = pd.DataFrame(data={"A": [1, 2], "B": ["Bonjour", "Hello"]}) # Enregistrer le fichier avec les données du DataFrame df.to_excel("nom du fichier.xlsx") ``` Le fichier possèdera un style de tableur de base, qui ne semble à l'heure actuelle actuelle pas très configurable. ---- ## Exemples de ressources fichier - [Fichiers au format Parquet](https://github.com/Teradata/kylo/tree/master/samples/sample-data/parquet) - [Fichiers au format CSV](https://www.datablist.com/learn/csv/download-sample-csv-files) - [Fichiers au format Excel 2007+](https://file-examples.com/index.php/sample-documents-download/sample-xls-download/)