Lecture et écriture de données avec Pandas

Pandas fournit un ensemble riche de fonctions pour lire et écrire divers formats de données. En plus des formats CSV et Excel couramment utilisés, il prend également en charge les bases de données SQL, les tableaux HTML, Parquet et d'autres formats. Cette section présente ces fonctions d'E/S complémentaires pour vous aider à gérer de manière flexible l'importation et l'exportation de données dans différents scénarios.

Aperçu des fonctions d'E/S principales

La fonctionnalité d'E/S de Pandas est très puissante et prend en charge la lecture et l'écriture de plusieurs formats de données. Voici les fonctions de lecture et d'écriture couramment utilisées :

Fonctions de lecture	Fonctions d'écriture	Formats pris en charge	Scénarios typiques
`pd.read_csv()`	`to_csv()`	CSV、TSV	Fichiers journaux, données tabulaires
`pd.read_excel()`	`to_excel()`	Excel（.xlsx, .xls）	Rapports commerciaux, données financières
`pd.read_sql()`	`to_sql()`	Bases de données SQL	Interaction avec les bases de données d'entreprise
`pd.read_html()`	-	Tableaux HTML	Extraction de données web
`pd.read_parquet()`	`to_parquet()`	Apache Parquet	Analyse et stockage de big data
`pd.read_feather()`	`to_feather()`	Format Feather	Lecture/écriture rapide, données en mémoire
`pd.read_json()`	`to_json()`	JSON	Données d'API, services web
`pd.read_pickle()`	`to_pickle()`	Python pickle	Sérialiser des objets Python

Les différents formats ont différents scénarios d'application. CSV est un format universel mais les fichiers sont volumineux ; Parquet est un stockage en colonnes, adapté à l'analyse de big data ; Excel convient à la consultation manuelle mais pas à de gros volumes de données.

Fichiers CSV et texte

CSV (valeurs séparées par des virgules) est le format d'échange de données le plus universel, et Pandas fournit le support le plus complet pour celui-ci.

Paramètres de lecture courants

Exemple

import pandas as pd

# Lecture de base
df = pd.read_csv("data.csv")

# Spécifier le délimiteur (CSV par défaut : virgule, TSV : tabulation)
df_tsv = pd.read_csv("data.tsv", sep="\t")

# Spécifier l'encodage (couramment utilisé pour les fichiers chinois)
df_utf8 = pd.read_csv("data.csv", encoding="utf-8")
df_gbk = pd.read_csv("data.csv", encoding="gbk")

# Ignorer des lignes (ignorer les lignes après l'en-tête ou les lignes de commentaire)
df = pd.read_csv("data.csv", skiprows=3) # Ignorer les 3 premières lignes
df = pd.read_csv("data.csv", skiprows=[2, 4]) # Ignorer les lignes 2 et 4

# Utiliser la ligne d'en-tête (première ligne par défaut)
df = pd.read_csv("data.csv", header=0) # Utiliser la ligne 0 comme en-tête
df = pd.read_csv("data.csv", header=None) # Ne pas utiliser d'en-tête, générer automatiquement 0,1,2...

# Spécifier les noms de colonnes
df = pd.read_csv("data.csv", names=["ID", "Nom", "Âge", "Ville"])

# Spécifier la colonne d'index
df = pd.read_csv("data.csv", index_col=0) # Utiliser la colonne 0 comme index
df = pd.read_csv("data.csv", index_col=["Name"]) # Plusieurs colonnes comme index composé

Traitement des valeurs manquantes

Exemple

import pandas as pd
import numpy as np

# Spécifier quelles valeurs sont traitées comme valeurs manquantes
df = pd.read_csv(
"data.csv",
na_values=["NA", "null", "NULL", "N/A", "", " "] # Ces valeurs seront toutes reconnues comme NaN
)

# Différentes colonnes peuvent utiliser différents marqueurs de valeurs manquantes
df = pd.read_csv(
"data.csv",
na_values={
"Age": ["Unknown", "0"], # Valeur manquante pour la colonne "Age"
"City": ["Unknown"] # Valeur manquante pour la colonne "City"
}
)

# Conserver certaines valeurs comme valeurs normales (non reconnues comme valeurs manquantes)
df = pd.read_csv("data.csv", keep_default_na=False)

Écriture de fichiers CSV

Exemple

import pandas as pd

# Préparer les données de test
df = pd.DataFrame({
"Nom": ["Zhang San", "Li Si", "Wang Wu"],
"Âge": [25, 30, 28],
"Ville": ["Beijing", "Shanghai", "Guangzhou"]
})

# Écrire un CSV (avec index par défaut)
df.to_csv("output.csv")

# Ne pas écrire l'index
df.to_csv("output.csv", index=False)

# Spécifier le délimiteur
df.to_csv("output.csv", sep="\t")

# Ne pas écrire l'en-tête
df.to_csv("output.csv", header=False)

# Spécifier l'encodage
df.to_csv("output.csv", encoding="utf-8-sig") # Avec BOM, adapté pour l'ouverture dans Excel

Fichiers JSON

JSON (JavaScript Object Notation) est le format de données le plus courant dans les applications Web. Pandas fournit des fonctions de lecture et d'écriture flexibles.

Structure JSON et méthodes de lecture

Les structures de données JSON se présentent sous de nombreuses formes. Lors de la lecture, vous devez choisir les paramètres appropriés en fonction de la structure réelle :

Exemple

import pandas as pd
import json

# Préparer des données JSON de test
data_records = '''
[
{"name": "Zhang San", "age": 25, "city": "Beijing"},
{"name": "Li Si", "age": 30, "city": "Shanghai"},
{"name": "Wang Wu", "age": 28, "city": "Guangzhou"}
]
'''

# Méthode 1 : tableau JSON (un objet par ligne) -> DataFrame
df = pd.read_json(data_records, orient="records")
print("orient='records':")
print(df)
print()

# Méthode 2 : objet JSON (paires clé-valeur) -> Series
data_dict = '{"name": "Zhang San", "age": 25, "city": "Beijing"}'
s = pd.read_json(data_dict, typ="series")
print("Lire comme Series :")
print(s)

Format JSON Lines

JSON Lines (.jsonl) est un format où chaque ligne est un objet JSON complet, couramment utilisé dans les scénarios de journalisation et de mégadonnées :

Exemple

import pandas as pd

# Données au format JSON Lines
jsonl_data = '''{"name": "Zhang San", "age": 25}
{"name": "Li Si", "age": 30}
{"name": "Wang Wu", "age": 28}
{"name": "Zhao Liu", "age": 35}
'''

# Écrire un fichier JSON Lines
with open("data.jsonl", "w", encoding="utf-8") as f:
f.write(jsonl_data)

# Lire JSON Lines (chaque ligne est un objet JSON)
df = pd.read_json("data.jsonl", lines=True)
print(df)

Écriture de JSON

Exemple

import pandas as pd

df = pd.DataFrame({
"Nom": ["Zhang San", "Li Si", "Wang Wu"],
"Âge": [25, 30, 28],
"Ville": ["Beijing", "Shanghai", "Guangzhou"]
})

# Écrire du JSON avec différentes valeurs de orient
df.to_json("output_records.json", orient="records", force_ascii=False, indent=2)
df.to_json("output_index.json", orient="index", force_ascii=False, indent=2)
df.to_json("output_columns.json", orient="columns", force_ascii=False, indent=2)

# Format JSON Lines
df.to_json("output.jsonl", orient="records", lines=True, force_ascii=False)

Sérialisation Pickle

Pickle est le format de sérialisation d'objets natif de Python, qui peut sauvegarder n'importe quel objet Python, y compris les DataFrames et les structures imbriquées complexes.

Exemple

import pandas as pd
import pickle

# Créer un DataFrame avec une structure complexe
df = pd.DataFrame({
"A": range(10),
"B": range(10, 20),
"C": ["foo", "bar"] * 5
})

# Écrire un fichier Pickle
df.to_pickle("data.pkl")

# Lire un fichier Pickle
df_loaded = pd.read_pickle("data.pkl")
print(df_loaded)

# Écriture compressée (compression gzip, fichier plus petit)
df.to_pickle("data.pkl.gz", compression="gzip")
df_loaded = pd.read_pickle("data.pkl.gz", compression="gzip")

Le format Pickle ne peut être lu que par Python et ne convient pas pour l'échange de données entre langages. De plus, le chargement de fichiers Pickle à partir de sources non fiables présente un risque de sécurité ; ne chargez pas de fichiers .pkl d'origine inconnue.

Performances et sélection des scénarios

Les différents formats de données ont des caractéristiques de performance différentes. Choisir le format approprié peut grandement améliorer l'efficacité :

Format	Vitesse de lecture	Vitesse d'écriture	Taille du fichier	Scénario applicable
CSV	Lent	Moyenne	grand	Format d'échange universel, lisible par l'humain
Parquet	Très rapide	Rapide	Très minime	Analyse de big data, requête en colonnes
Feather	Extrêmement rapide	Extrêmement rapide	grand	Transfert rapide de données en mémoire
Pickle	Rapide	Rapide	Moyenne	Persistance d'objets Python
JSON	Lent	Moyenne	Très volumineux	API Web, multi-langage

Problèmes courants et précautions

1. Mémoire insuffisante lors de la lecture de fichiers volumineux

Pour les fichiers CSV ou JSON très volumineux, vous pouvez utiliser lechunksizeparamètre pour lire par morceaux, évitant de tout charger en mémoire d'un coup.

2. Problèmes d'encodage chinois

Lors du traitement de fichiers chinois, veillez à spécifier l'encodage correct. Les encodages courants incluent utf-8, gbk, gb2312, utf-8-sig (BOM), etc.

3. Fichier corrompu après l'écriture

Avant d'écrire des données importantes, il est recommandé de d'abord lire et vérifier. Lors de l'écriture de fichiers volumineux, l'utilisation d'un format compressé peut réduire les E/S disque et diminuer le risque de corruption des données.

4. Limitations du format Excel

Excel 2003 (.xls) prend en charge au maximum 65,536 lignes par feuille, tandis qu'Excel 2007 (.xlsx) prend en charge jusqu'à 1,048,576 lignes. Si la limite est dépassée, veuillez envisager d'autres formats.

Autres extensions