Choix et importation des données

Choisir le format de données approprié

Avant d'importer des données en Python, vous devez choisir le format de données approprié. Le choix du format dépend de plusieurs facteurs :

• La nature des données : S'agit-il de données tabulaires (comme dans une feuille de calcul), de données hiérarchiques (comme dans un fichier XML ou JSON), de données textuelles, de données binaires, etc. ?
• La taille des données : Certains formats sont plus adaptés aux petits fichiers, d'autres aux grands fichiers.
• La complexité des données : Certains formats permettent de représenter des structures de données complexes (avec des relations entre les données), d'autres sont plus adaptés aux données simples.
• La source des données : D'où proviennent les données ? D'un fichier local, d'une base de données, d'une API web, etc. ?
• Les outils disponibles : Quelles bibliothèques Python avez-vous à disposition pour lire et écrire ce format de données ?
• Les exigences de performance : Certains formats sont plus rapides à lire et à écrire que d'autres.
• La lisibilité : Certains formats sont lisibles par un humain (comme CSV, JSON, XML), d'autres non (comme les fichiers binaires).
• Interopérabilité Le format est-il lisible par d'autres applications/langages?

Voici quelques formats de données courants et leurs utilisations typiques :

• CSV (Comma Separated Values) : Format texte simple pour les données tabulaires. Chaque ligne représente un enregistrement, et les valeurs sont séparées par des virgules (ou un autre délimiteur). Adapté aux données simples, mais peut devenir difficile à gérer pour les données complexes ou hiérarchiques.
• JSON (JavaScript Object Notation) : Format texte léger pour l'échange de données. Il est basé sur une structure de paires clé-valeur (similaire aux dictionnaires Python) et de listes. Très utilisé pour les API web. Facile à lire et à écrire pour les humains et les machines.
• Excel : Format de fichier propriétaire de Microsoft Excel. Adapté aux données tabulaires, avec des fonctionnalités de mise en forme, de calcul, etc.
• XML (Extensible Markup Language) : Format texte pour représenter des données structurées de manière hiérarchique. Plus verbeux que JSON, mais plus flexible.
• Bases de données SQL : Pour les données structurées et relationnelles, stockées dans des bases de données comme MySQL, PostgreSQL, SQLite, etc.
• Fichiers binaires (spécifiques) : Pour les données non textuelles (images, sons, vidéos, etc.) ou pour les données structurées de manière spécifique à une application.
• Pickle : Format binaire spécifique à Python pour sérialiser et désérialiser des objets Python. (Attention aux problèmes de sécurité et de compatibilité).
• Parquet, Feather, HDF5 : Formats binaires optimisés pour le stockage et la lecture rapide de grandes quantités de données tabulaires (souvent utilisés en data science).

Importer des données CSV : csv et Pandas

Pour lire des fichiers CSV, vous pouvez utiliser le module `csv` de la bibliothèque standard, ou la bibliothèque `Pandas` (plus puissante et plus pratique pour l'analyse de données).

Avec le module `csv` :

import csv

with open('mon_fichier.csv', 'r', encoding='utf-8', newline='') as fichier:
    lecteur_csv = csv.reader(fichier, delimiter=',', quotechar='"')  # Crée un lecteur CSV
    # delimiter: caractère de séparation (par défaut, la virgule)
    # quotechar: caractère de citation (par défaut, le guillemet double)
    for ligne in lecteur_csv:
        print(ligne)  # Chaque ligne est une liste de chaînes de caractères

Explication :

• `csv.reader(fichier, delimiter=',', quotechar='"')` crée un objet lecteur CSV qui permet d'itérer sur les lignes du fichier CSV.
• `delimiter` spécifie le caractère de séparation des colonnes (par défaut, la virgule).
• `quotechar` spécifie le caractère utilisé pour entourer les champs qui contiennent des caractères spéciaux (comme le délimiteur ou le caractère de citation lui-même).
• Chaque ligne est retournée sous forme de *liste* de chaînes de caractères.

Avec Pandas (recommandé pour l'analyse de données) :

import pandas as pd

df = pd.read_csv('mon_fichier.csv')  # Lit le fichier CSV et retourne un DataFrame
print(df.head()) #Affiche les premières lignes

`pd.read_csv()` a de nombreuses options pour contrôler la lecture du fichier (séparateur, en-tête, types de données, gestion des valeurs manquantes, etc.).

Importer des données JSON : le module json

Pour lire des fichiers JSON, vous pouvez utiliser le module `json` de la bibliothèque standard.

Fonctions clés :

• `json.load(fichier)` : Lit un fichier JSON et retourne un objet Python (généralement un dictionnaire ou une liste).
• `json.loads(chaine)` : Lit une chaîne de caractères JSON et retourne un objet Python.

Exemple :

import json

# Lire un fichier JSON
with open('mon_fichier.json', 'r', encoding='utf-8') as f:
    donnees = json.load(f)

# donnees est maintenant un objet Python (dictionnaire ou liste)
print(donnees)

# Lire une chaîne JSON
chaine_json = '{"nom": "Alice", "age": 30}'
donnees = json.loads(chaine_json)
print(donnees)  # Affiche : {'nom': 'Alice', 'age': 30}

Si le fichier JSON n'est pas valide, une exception `json.JSONDecodeError` sera levée.

Importer des données Excel : Pandas

Pour lire des fichiers Excel, la méthode la plus simple est d'utiliser Pandas :

import pandas as pd

# Lire un fichier Excel (premier onglet)
df = pd.read_excel('mon_fichier.xlsx')

# Lire un onglet spécifique
# df = pd.read_excel('mon_fichier.xlsx', sheet_name='Feuil2')

print(df.head())

`pd.read_excel()` a de nombreuses options pour contrôler la lecture du fichier (nom de l'onglet, ligne d'en-tête, colonnes à lire, etc.).

Note : Pour lire des fichiers Excel, Pandas peut avoir besoin de bibliothèques supplémentaires (comme `openpyxl` pour les fichiers `.xlsx`, ou `xlrd` pour les anciens fichiers `.xls`). Installez-les avec `pip` si nécessaire.

Importer des données depuis une base de données SQL

Pour lire des données à partir d'une base de données SQL, vous pouvez utiliser une bibliothèque Python spécifique à votre base de données (par exemple, `psycopg2` pour PostgreSQL, `mysql-connector-python` pour MySQL, `sqlite3` pour SQLite).

Vous pouvez aussi utiliser un ORM (Object-Relational Mapper) comme SQLAlchemy, ou l'ORM intégré de Django (si vous utilisez Django).

En général, l'approche consiste à :

1. Etablir une connexion à la base de données.
2. Exécuter une requête SQL.
3. Récupérer les résultats (généralement sous forme de liste de tuples, ou de liste de dictionnaires).
4. Fermer la connexion.

Exemple (avec `sqlite3`, qui est inclus dans la bibliothèque standard) :

import sqlite3

# Connexion à la base de données (crée la base si elle n'existe pas)
connexion = sqlite3.connect('ma_base.db')

# Créer un curseur
curseur = connexion.cursor()

# Exécuter une requête
curseur.execute("SELECT * FROM ma_table")

# Récupérer les résultats
resultats = curseur.fetchall()  # Retourne une liste de tuples

# Afficher les résultats
for ligne in resultats:
    print(ligne)

# Fermer la connexion
connexion.close()

Pour des opérations plus complexes, et pour une meilleure abstraction, il est recommandé d'utiliser un ORM.

Importer des données avec Pandas : la méthode générale

Pandas est l'outil recommandé pour l'importation et la manipulation de données structurées. Il fournit des fonctions de haut niveau pour la lecture de nombreux formats :

df = pd.read_csv('data.csv') # Fichier CSV
df = pd.read_excel('data.xlsx') # Fichier Excel
df = pd.read_json('data.json') # Fichier JSON
df = pd.read_html('data.html') # Tables HTML
#etc.

Ces fonctions retournent directement un objet `DataFrame`, qui est la structure de données centrale de Pandas, et qui permet ensuite de manipuler facilement les données.

Pandas offre énormément d'options pour configurer l'importation (encodage, séparateurs, noms de colonnes, etc.). Référez-vous à la documentation pour les détails.

Bonnes pratiques

Pour résumer, voici quelques bonnes pratiques :

• Choisissez le bon format en fonction de la nature, taille et complexité de vos données, de leur source, et des outils disponibles.
• Utilisez Pandas pour la manipulation de données tabulaires. Il fournit un haut niveau d'abstraction et beaucoup de flexibilité.
• Gérez toujours les erreurs potentielles lors de l'importation (fichier non trouvé, format invalide, etc.) avec des blocs `try...except`.
• Spécifiez l'encodage des fichiers texte (`encoding='utf-8'` en général).
• Fermez les fichiers et les connexions aux bases de données après utilisation (utilisez `with` autant que possible).