Pandas & NumPy Academy · Leçon

Pandas ou SQL : choisir le bon outil

Comparez groupby/merge dans Pandas à GROUP BY/JOIN dans SQL et déterminez quelle couche doit gérer chaque transformation.

Leçon 4 sur 413 étapes

Pandas ou SQL : choisir le bon outil est une leçon Pandas & NumPy Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Pandas & NumPy Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Pandas & NumPy Academy comprend 4 leçons au total.

Deux outils aux points forts complémentaires

Pandas et SQL sont tous deux des outils de manipulation des données, utilisés par les analystes de données professionnels. L’idée essentielle est qu’ils sont complémentaires et non concurrents : SQL excelle dans les opérations déclaratives ensemblistes sur de grandes tables stockées dans des bases de données relationnelles, tandis que Pandas excelle dans les transformations impératives, ligne par ligne, et les transformations algorithmiques complexes sur des données déjà chargées en mémoire. Les meilleures chaînes de traitement utilisent chaque outil pour ce qu’il fait le mieux.

Points forts de SQL : ce que SQL fait mieux

SQL est généralement supérieur lorsque : les données sont volumineuses (de gigaoctets à téraoctets) et doivent être filtrées avant leur chargement ; les jointures portent sur plusieurs grandes tables et les index de la base de données offrent des gains de vitesse considérables ; les agrégations sont simples (SUM, COUNT, GROUP BY) ; les ensembles de résultats sont petits par rapport aux données d’entrée ; ou lorsque des lectures et écritures simultanées sont nécessaires (la base de données gère les transactions et le verrouillage). La syntaxe déclarative de SQL permet également aux optimiseurs de requêtes de choisir automatiquement le meilleur plan physique.

-- SQL excels at:
-- 1. Filtering billions of rows using an index
SELECT * FROM orders WHERE customer_id = 12345;

-- 2. Joining large tables efficiently
SELECT o.order_id, c.name, SUM(o.amount)
FROM orders o
JOIN customers c ON o.customer_id = c.id
GROUP BY o.order_id, c.name;

-- 3. Window functions on ordered data
SELECT order_id, amount,
       SUM(amount) OVER (PARTITION BY customer_id ORDER BY order_date)
FROM orders;

Points forts de Pandas : ce que Pandas fait mieux

Pandas est généralement supérieur lorsque : vous avez besoin d’une logique Python personnalisée que SQL ne peut pas exprimer (prétraitement pour l’apprentissage automatique, analyse personnalisée de chaînes, algorithmes complexes) ; les chaînes de transformation des données comportent de nombreuses étapes ; vous avez besoin d’une visualisation immédiatement après l’analyse ; les données sont déjà en mémoire et de nouvelles allers-retours vers SQL ajouteraient de la latence ; ou vous effectuez une analyse exploratoire nécessitant des itérations interactives. Pandas gère également les opérations non tabulaires, comme les calculs matriciels et le lissage des séries temporelles.

import pandas as pd

# Pandas excels at:
# 1. Custom Python logic that SQL cannot express
df['clean_name'] = df['name'].str.strip().str.title().str.replace(r'[^a-zA-Z ]', '', regex=True)

# 2. Vectorised string parsing
df[['first', 'last']] = df['full_name'].str.split(' ', n=1, expand=True)

# 3. Rolling statistics and time series
df['7day_avg'] = df['daily_sales'].rolling(7).mean()

# 4. Direct visualisation
# df.groupby('category')['sales'].sum().plot(kind='bar')

Faire correspondre les opérations SQL à Pandas

La plupart des opérations SQL ont des équivalents directs dans Pandas. Connaître les deux syntaxes vous rend plus polyvalent et vous aide à passer de l’une à l’autre lorsque vous changez d’outil. WHERE devient un indexage booléen ou .query() ; GROUP BY + SUM devient .groupby().sum() ; JOIN devient pd.merge() ; ORDER BY devient .sort_values() ; et DISTINCT devient .drop_duplicates(). Le sens sémantique est identique ; seule la syntaxe diffère.

import pandas as pd

df = pd.DataFrame({'region': ['N','S','N','E'], 'amount': [100,200,150,300]})

# SQL: SELECT region, SUM(amount) FROM df WHERE amount>100 GROUP BY region ORDER BY region
# Pandas:
result = (
    df[df['amount'] > 100]
    .groupby('region')['amount']
    .sum()
    .reset_index()
    .sort_values('region')
)
print(result)

Quand la taille des données détermine le choix

Voici un cadre pratique de décision fondé sur la taille des données : moins de 100 MB — utilisez uniquement Pandas, le surcoût de SQL n’en vaut pas la peine ; de 100 MB à 10 GB — filtrez et agrégerez dans SQL, puis chargez un DataFrame récapitulatif dans Pandas ; de 10 GB à 1 TB — utilisez SQL ou Dask pour le traitement, et Pandas uniquement pour le récapitulatif final ; plus de 1 TB — utilisez un SQL distribué (BigQuery, Spark SQL, Redshift). N’essayez jamais de charger une table de 100 GB dans Pandas sur un ordinateur portable doté de 16 GB de mémoire : le programme plantera ou saturera le disque.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///large.db')

# Right approach: SQL handles the heavy lifting
summary_df = pd.read_sql_query(
    '''
    SELECT region, product_category,
           SUM(revenue) AS total_revenue,
           COUNT(DISTINCT customer_id) AS unique_customers
    FROM orders
    WHERE order_date >= '2024-01-01'
    GROUP BY region, product_category
    ''',
    con=engine
)
# summary_df is small — now do Pandas things on it
print(summary_df.sort_values('total_revenue', ascending=False))

Fonctions de fenêtre SQL et rolling de Pandas

Les fonctions de fenêtrage de SQL (OVER (PARTITION BY ... ORDER BY ...)) sont puissantes, mais elles ont des limites : elles calculent efficacement les rangs cumulés, les décalages vers l’arrière ou l’avant, ainsi que les agrégats glissants simples, mais les statistiques glissantes complexes (par exemple, la corrélation de Pearson glissante) ne peuvent pas être exprimées en SQL. rolling() et expanding() de Pandas couvrent un éventail bien plus large de calculs sur des fenêtres, y compris les fonctions personnalisées via .apply(). Pour les fonctions de fenêtrage standard sur de grands volumes de données, privilégiez SQL ; pour une logique de fenêtrage complexe, privilégiez Pandas.

import pandas as pd

df = pd.DataFrame({
    'date': pd.date_range('2024-01-01', periods=30),
    'sales': [100 + i*10 + (i%7)*20 for i in range(30)]
})

# Pandas rolling — easy with arbitrary window functions
df['7d_mean'] = df['sales'].rolling(7).mean()
df['7d_std']  = df['sales'].rolling(7).std()
df['7d_corr'] = df['sales'].rolling(7).corr(df['sales'].shift(1))
print(df.tail())

Jointures complexes : la flexibilité de Pandas

Les jointures SQL reposent sur l’égalité des clés (à quelques exceptions près). Pandas prend en charge, avec pd.merge_asof(), les jointures temporelles approximatives (en mettant en correspondance la clé la plus proche plutôt qu’une égalité exacte), ce qui est très utile pour aligner des séries temporelles (par exemple, associer des cours boursiers à des événements de transaction au cours précédant le plus proche). Pandas prend également en charge les jointures conditionnelles en utilisant merge, puis un filtrage, alors qu’en SQL, il faut une sous-requête ou une jointure LATERAL pour exprimer cette logique. Ces modèles de jointure avancés constituent l’un des domaines où Pandas s’impose clairement.

import pandas as pd

trades = pd.DataFrame({
    'time': pd.to_datetime(['2024-01-01 10:00', '2024-01-01 10:05', '2024-01-01 10:12']),
    'symbol': ['AAPL', 'AAPL', 'AAPL'],
    'shares': [100, 200, 50]
})
prices = pd.DataFrame({
    'time': pd.to_datetime(['2024-01-01 10:00', '2024-01-01 10:10']),
    'price': [185.0, 186.5]
})

# Fuzzy join: match each trade to the nearest preceding price
result = pd.merge_asof(trades.sort_values('time'),
                       prices.sort_values('time'),
                       on='time', direction='backward')
print(result)

Pandas pour le profilage des données, SQL pour la production

Un schéma courant consiste à utiliser Pandas pour l’EDA et le profilage des données sur un échantillon représentatif (par exemple, le premier million de lignes), à développer progressivement votre logique de transformation, puis à traduire les étapes essentielles en SQL pour une utilisation à l’échelle de la production. Pandas permet d’itérer rapidement avec un retour visuel immédiat ; SQL s’exécute de manière fiable à grande échelle avec une infrastructure minimale. Maintenez les deux versions synchronisées : lorsque vous ajoutez une nouvelle fonctionnalité dans Pandas, écrivez la procédure stockée ou la vue SQL équivalente pour la production.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///data.db')

# Development: sample in Pandas for fast iteration
df_sample = pd.read_sql_query(
    'SELECT * FROM orders ORDER BY RANDOM() LIMIT 10000',
    con=engine
)
# Explore and prototype:
df_sample['revenue_tier'] = pd.cut(
    df_sample['amount'],
    bins=[0, 100, 500, float('inf')],
    labels=['low', 'mid', 'high']
)
print(df_sample['revenue_tier'].value_counts())
# Production: translate cut logic to SQL CASE WHEN

pandasql : écrire des requêtes SQL sur des DataFrames

La bibliothèque pandasql vous permet d’écrire des requêtes SQL directement sur des DataFrames Pandas, en utilisant SQLite en arrière-plan. sqldf('SELECT * FROM df WHERE amount > 100', locals()) exécute la requête sur le DataFrame df. Cette approche est utile si vous raisonnez en SQL alors que vos données se trouvent déjà dans Pandas, ou pour enseigner les concepts SQL avec des données en mémoire. Toutefois, elle est plus lente que Pandas natif pour la plupart des opérations : utilisez-la pour sa familiarité, pas pour ses performances.

# pip install pandasql
import pandas as pd
# from pandasql import sqldf

df = pd.DataFrame({
    'product': ['A', 'B', 'A', 'C', 'B'],
    'sales': [100, 200, 150, 80, 220]
})

# With pandasql (commented out as it requires install):
# result = sqldf('SELECT product, SUM(sales) AS total FROM df GROUP BY product', locals())

# Equivalent native Pandas:
result = df.groupby('product')['sales'].sum().reset_index()
print(result)

Cadre de décision : aide-mémoire rapide

Utilisez ce guide de décision pour choisir entre SQL et Pandas :

Données dans une base de données ET volumineuses ? Filtrez et agrégez d’abord en SQL.
Besoin d’une logique Python personnalisée ? Utilisez Pandas après un préfiltrage SQL.
Analyse exploratoire sur un échantillon ? Pandas permet d’itérer plus rapidement.
Série temporelle avec des statistiques glissantes complexes ? Utilisez rolling/ewm de Pandas.
Simple GROUP BY sur des millions de lignes ? Utilisez SQL avec des index.
Plusieurs petits DataFrames déjà en mémoire ? pd.merge() convient.
Besoin de transactions ACID ? Utilisez une base de données SQL, pas Pandas.

Combiner les deux : la chaîne de traitement hybride

L’approche la plus pratique est une chaîne de traitement hybride qui exploite les points forts de chaque outil. SQL gère l’ingestion, le filtrage grossier et les agrégations standard sur de grandes tables brutes. Le résultat — un DataFrame gérable — est transmis à Pandas pour la création de variables, les métriques personnalisées, les statistiques glissantes et la visualisation. Les résultats peuvent ensuite être réécrits dans la base de données pour leur mise à disposition. Cette chaîne de traitement est lisible, évolutive et facile à maintenir par tout analyste maîtrisant SQL et Python.

import pandas as pd
import sqlalchemy as sa

engine = sa.create_engine('sqlite:///pipeline.db')

# Step 1: SQL coarse aggregation
df = pd.read_sql_query('''
    SELECT DATE(order_date) AS date, region, SUM(amount) AS daily_revenue
    FROM orders WHERE status = 'completed'
    GROUP BY DATE(order_date), region
    ORDER BY date
''', con=engine, parse_dates=['date'])

# Step 2: Pandas rolling and pivoting (hard in SQL)
df['7d_avg'] = df.groupby('region')['daily_revenue'].transform(
    lambda x: x.rolling(7, min_periods=1).mean()
)
pivot = df.pivot(index='date', columns='region', values='7d_avg')
print(pivot.tail())

Vérification rapide

Testez votre compréhension des concepts d’analyse des données présentés dans cette leçon.

Réponds-y dans la leçon interactive

Récapitulatif de la leçon

Dans cette leçon, vous avez appris que SQL excelle dans le filtrage à grande échelle, les jointures et les agrégations simples sur des données indexées, que Pandas excelle dans la logique Python personnalisée, les statistiques glissantes complexes et l’analyse exploratoire, et que la meilleure stratégie consiste à utiliser une chaîne de traitement hybride : SQL effectue la réduction grossière et Pandas réalise les transformations complexes sur le résultat gérable. Ensuite, nous commencerons les statistiques inférentielles avec SciPy : tests de normalité et statistiques descriptives.

Gratuit pour commencer

Apprends Python avec un tuteur IA — gratuit

Écris et exécute du vrai code dans ton navigateur, obtiens de l'aide instantanée d'un tuteur IA disponible 24h/24, et reprends là où tu t'es arrêté sur le web ou dans l'app.

Cours: 30
Leçons: 120

Commencer gratuitement Voir le cours complet

Questions Fréquemment Posées

La leçon « Pandas ou SQL : choisir le bon outil » est-elle gratuite ?

Oui — le texte complet de « Pandas ou SQL : choisir le bon outil » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Pandas & NumPy Academy, passe à CoddyKit PRO. Le cours Pandas & NumPy Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Pandas ou SQL : choisir le bon outil » ?

Comparez groupby/merge dans Pandas à GROUP BY/JOIN dans SQL et déterminez quelle couche doit gérer chaque transformation. Tu pratiques Pandas & NumPy Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Pandas & NumPy Academy ?

Aucune expérience préalable n'est requise. Pandas & NumPy Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Pandas ou SQL : choisir le bon outil » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Pandas & NumPy Academy ?

Oui. Chaque leçon Pandas & NumPy Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

Se connecter à une base de données avec SQLAlchemy
Exécuter des requêtes SQL depuis Pandas
Écrire des DataFrames dans des tables de base de données
Pandas ou SQL : choisir le bon outil

← Retour à Pandas & NumPy Academy