Premiers pas
Installation et import
pandas s'importe conventionnellement comme pd, avec numpy comme np puisque pandas utilise des tableaux numpy sous le capot. Les deux structures de données cœur sont Series (tableau 1D étiqueté) et DataFrame (table 2D étiquetée). Presque toute manipulation de données tabulaires en Python commence ici.
# Install pandas (pick one)
pip install pandas
conda install pandas
# Standard import convention
import pandas as pd
import numpy as np # pandas relies heavily on numpy
# Check version
print(pd.__version__)
# Pandas is built on numpy: a Series is a 1D labeled array,
# a DataFrame is a 2D labeled table (dict of Series).Series et DataFrame
Une Series a une seule colonne de valeurs plus un index (étiquettes). Un DataFrame est une collection de Series partageant un index commun — pensez tableur ou table SQL. On peut bâtir des DataFrames depuis des dicts (clés=colonnes), des listes de listes, des tableaux numpy ou des fichiers.
import pandas as pd
# Series: 1D labeled array
s = pd.Series([10, 20, 30, 40], index=["a", "b", "c", "d"])
# a 10
# b 20
# ...
# DataFrame: 2D table (dict of columns)
df = pd.DataFrame({
"name": ["Alice", "Bob", "Charlie"],
"age": [25, 30, 35],
"city": ["NYC", "LA", "SF"],
})
# From list of lists with column names
df2 = pd.DataFrame([[1, 2], [3, 4]], columns=["a", "b"])Créer un DataFrame d'exemple
Pour des expériences rapides, bâtissez un petit DataFrame depuis un dict. Pour des tests plus grands, utilisez les générateurs aléatoires de numpy avec une graine pour la reproductibilité. date_range crée un DatetimeIndex — le socle du travail en séries temporelles. Régler tôt un index significatif (dates, IDs) rend les sélections et jointures ultérieures bien plus propres.
import pandas as pd
import numpy as np
# Quick test DataFrame with random data
df = pd.DataFrame({
"id": range(1, 6),
"name": ["Alice", "Bob", "Charlie", "David", "Eve"],
"age": [25, 30, 35, 28, 40],
"score": [85.5, 92.0, 78.3, 88.9, 95.2],
"pass": [True, True, False, True, True],
})
# Larger random DataFrame
rng = np.random.default_rng(42)
big = pd.DataFrame(rng.normal(size=(100, 4)), columns=list("ABCD"))
# Dates as index
dates = pd.date_range("2024-01-01", periods=5)
ts = pd.DataFrame({"value": [1, 2, 3, 4, 5]}, index=dates)Lire des données depuis des fichiers
read_csv est le cheval de bataille — spécifiez toujours sep, encoding, parse_dates et index_col quand c'est pertinent pour éviter le nettoyage après chargement. Parquet est bien plus rapide et petit que CSV pour les grands jeux de données et préserve les dtypes. Pour SQL, les engines SQLAlchemy gèrent le pooling de connexions. read_clipboard est étonnamment pratique pour une analyse rapide par copier-coller.
import pandas as pd
# CSV — the most common
df = pd.read_csv("data.csv")
df = pd.read_csv("data.csv", sep=";", encoding="utf-8",
parse_dates=["date"], index_col="id")
# Excel (needs openpyxl)
df = pd.read_excel("data.xlsx", sheet_name="Sheet1")
# JSON
df = pd.read_json("data.json")
# Parquet (fast columnar format, great for large data)
df = pd.read_parquet("data.parquet")
# SQL (needs SQLAlchemy)
from sqlalchemy import create_engine
engine = create_engine("sqlite:///my.db")
df = pd.read_sql("SELECT * FROM users", engine)
# Clipboard (paste a table from a spreadsheet)
df = pd.read_clipboard()Sauvegarder des données
Passez toujours index=False en exportant vers CSV/Excel sauf si votre index porte des données significatives — sinon vous aurez une colonne fantôme « Unnamed: 0 » au rechargement. Parquet préserve les dtypes entre sauvegarde/chargement (CSV non). Utilisez if_exists='append' pour ajouter des lignes à une table SQL existante, 'replace' pour écraser.
import pandas as pd
# CSV (no index by default is usually what you want)
df.to_csv("output.csv", index=False)
df.to_csv("output.csv", index=False, encoding="utf-8-sig") # Excel-friendly
# Excel (needs openpyxl)
df.to_excel("output.xlsx", sheet_name="Sheet1", index=False)
# Parquet (preserves dtypes, fast, compressed)
df.to_parquet("output.parquet")
# JSON
df.to_json("output.json", orient="records", indent=2)
# SQL
df.to_sql("users", engine, if_exists="replace", index=False)
# Multiple sheets to one Excel file
with pd.ExcelWriter("multi.xlsx") as writer:
df1.to_excel(writer, sheet_name="sheet1", index=False)
df2.to_excel(writer, sheet_name="sheet2", index=False)Inspection des données
Voir les données : head, tail, sample
head/tail montrent les bords ; sample montre des lignes aléatoires, plus représentatif pour contrôler distributions et formats. Utilisez set_option pour désactiver la troncature quand vous inspectez des DataFrames larges — les défauts masquent colonnes et lignes. Regardez toujours des données d'échantillon avant toute analyse pour attraper tôt les problèmes d'encodage, valeurs sentinelles et incompatibilités de types.
import pandas as pd
# First/last rows
df.head() # first 5 (default)
df.head(10) # first 10
df.tail() # last 5
df.tail(3) # last 3
# Random sample (great for sanity checks)
df.sample(5) # 5 random rows
df.sample(frac=0.1, random_state=42) # 10% of rows
df.sample(n=5, replace=True) # sample with replacement (bootstrap)
# See the raw values (not truncated)
pd.set_option("display.max_rows", 200)
pd.set_option("display.max_columns", None)
pd.set_option("display.width", 1000)Structure et dtypes
info() est l'appel d'inspection le plus utile — il montre les dtypes, les comptages non nuls par colonne et la mémoire. Surveillez le dtype object (souvent des chaînes stockées inefficacement) ; convertir en 'category' ou 'string' économise la mémoire. memory_usage(deep=True) révèle le vrai coût des colonnes object, souvent bien plus grand que rapporté.
# Shape and basic structure
df.shape # (rows, cols)
df.size # rows * cols
df.ndim # 2 for DataFrame, 1 for Series
len(df) # number of rows
# Column names and dtypes
df.columns # column labels
df.index # row labels
df.dtypes # dtype of each column
df.info() # concise summary: dtypes, non-null counts, memory
# Memory usage (helpful for big data)
df.memory_usage(deep=True)
df.info(memory_usage="deep")Statistiques descriptives
describe() donne un résumé statistique rapide — surveillez un count incohérent (valeurs manquantes) et des min/max suspects. value_counts() est essentiel pour les colonnes catégorielles (fréquence et équilibre des classes). corr() passe par défaut à Pearson ; method='spearman' pour la corrélation de rang. Utilisez toujours numeric_only=True sur des frames à types mixtes pour éviter les erreurs.
# Numeric summary (count, mean, std, min, quartiles, max)
df.describe()
df.describe(include="all") # include non-numeric too
df.describe(percentiles=[.1, .5, .9])
# Per-column stats
df["age"].mean()
df["age"].median()
df["age"].std()
df["age"].var()
df["age"].min(), df["age"].max()
df["age"].quantile(0.95)
# Non-numeric summaries
df["city"].value_counts()
df["city"].unique()
df["city"].nunique()
# Correlation and covariance
df.corr(numeric_only=True)
df.cov(numeric_only=True)Valeurs uniques et comptages
value_counts est l'une des méthodes pandas les plus utilisées — accouplez-la à normalize=True pour des proportions et dropna=False pour vérifier les manquants. crosstab construit une table de fréquences de deux catégorielles, utile pour les tests du khi-deux et les matrices de confusion. Binner les colonnes continues avant value_counts révèle la forme de la distribution.
# Unique values
df["city"].unique() # array of unique values
df["city"].nunique() # count of unique
df["city"].nunique(dropna=False) # include NaN
# Value counts (frequency table)
df["city"].value_counts()
df["city"].value_counts(normalize=True) # proportions
df["city"].value_counts(ascending=True)
df["city"].value_counts(dropna=False) # count NaN too
# Cross tabulation (frequency table of two columns)
pd.crosstab(df["city"], df["pass"])
# Binning then counting
df["age_group"] = pd.cut(df["age"], bins=[0, 18, 30, 50, 100],
labels=["child", "young", "adult", "senior"])
df["age_group"].value_counts()Vérifier les valeurs manquantes
Vérifiez toujours les manquants avant l'analyse — isnull().sum() par colonne est le premier regard standard. Attention aux colonnes à forte fraction manquante ; elles peuvent exiger une suppression ou une stratégie différente. Les lignes manquantes sur colonnes critiques se filtrent avec df[df.isnull().any(axis=1)]. La bibliothèque missingno visualise les patterns de manquants pour repérer des problèmes structurels.
# Count missing per column
df.isnull().sum()
df.isna().sum() # alias
# Fraction missing
df.isnull().mean().mul(100).round(2) # % missing per column
# Total missing
df.isnull().sum().sum()
# Rows with any missing
df[df.isnull().any(axis=1)]
# Non-null counts
df.notnull().sum()
# Visualize missingness pattern
# (requires missingno: import missingno as msno; msno.matrix(df))Bases de Series
Créer des Series
Une Series est un tableau 1D avec étiquettes (l'index). L'index permet de chercher des valeurs par étiquette, pas seulement par position. Spécifier des dtypes plus petits (int8, float32) économise la mémoire sur les grands jeux — int8 tient -128..127, largement pour des booléens-en-entiers ou des petits codes. Les clés de dict deviennent naturellement l'index.
import pandas as pd
import numpy as np
# From a list
s = pd.Series([1, 2, 3, 4])
# From a list with custom index
s = pd.Series([10, 20, 30], index=["a", "b", "c"])
# From a dict (keys become index)
s = pd.Series({"a": 1, "b": 2, "c": 3})
# From a numpy array
s = pd.Series(np.random.randn(5))
# Scalar broadcast to an index
s = pd.Series(5, index=["a", "b", "c"]) # [5, 5, 5]
# Specify dtype
s = pd.Series([1, 2, 3], dtype="float64")
s = pd.Series([1, 2, 3], dtype="int8") # save memoryIndexation et sélection
Le slicing par étiquettes (s['a':'c']) est INCLUSIF aux deux bouts — un piège courant vs le slicing positionnel de Python, exclusif. Utilisez .loc pour les étiquettes et .iloc pour les positions pour éviter l'ambiguïté, surtout avec des index entiers. Le s[...] par défaut est surchargé (étiquette ou position selon le dtype), donc .loc/.iloc explicites sont plus sûrs en production.
s = pd.Series([10, 20, 30, 40], index=["a", "b", "c", "d"])
# By label (index)
s["a"] # 10
s[["a", "c"]] # multiple labels -> Series
s["a":"c"] # slice INCLUSIVE of both ends (label-based)
# By position
s.iloc[0] # first by position
s.iloc[-1] # last
s.iloc[1:3] # EXCLUSIVE of end (positional, like Python)
# By label with .loc (explicit)
s.loc["a"]
s.loc["a":"c"] # inclusive
# Boolean indexing
s[s > 20]
s[(s > 10) & (s < 40)]Opérations vectorisées
Les opérations sur Series sont vectorisées (pas de boucles Python) et s'alignent sur l'index — en additionnant deux Series, pandas matche les étiquettes et remplit NaN où elles ne se recouvrent pas. Cet alignement d'index est la fonctionnalité phare de pandas mais peut surprendre ; utilisez .values pour opérer sur des tableaux numpy bruts si vous voulez du pur positionnel. Les opérations vectorisées sont 100 à 1000x plus rapides que les boucles iterrows.
s = pd.Series([1, 2, 3, 4])
# Element-wise arithmetic (aligns on index)
s + 10 # [11, 12, 13, 14]
s * 2
s ** 2
1 / s # [1.0, 0.5, 0.333, 0.25]
# Between two Series (aligns on index, NaN for mismatches)
s1 = pd.Series({"a": 1, "b": 2, "c": 3})
s2 = pd.Series({"b": 20, "c": 30, "d": 40})
s1 + s2 # a=NaN, b=22, c=33, d=NaN
# Comparison and boolean
s > 2 # [False, False, True, True]
s.between(2, 3) # inclusive
# Math methods
s.sum(), s.mean(), s.std(), s.cumsum()Méthodes Series utiles
sort_values et rank sont des outils quotidiens. drop_duplicates garde la première occurrence par défaut ; keep='last' pour la dernière. clip est pratique pour borner les aberrantes avant tracé. La plupart des méthodes sautent NaN par défaut ; skipna=False pour propager. Beaucoup retournent une nouvelle Series (pandas est surtout immuable), donc enchaînez : s.dropna().sort_values().head(10).
s = pd.Series([3, 1, 4, 1, 5, 9, 2, 6, np.nan])
# Sorting
s.sort_values() # ascending
s.sort_values(ascending=False)
s.sort_index()
# Ranking
s.rank(method="average") # 'min','max','first','dense'
# Unique, counts
s.unique()
s.nunique()
s.value_counts()
s.duplicated() # boolean: True if seen before
s.drop_duplicates()
# Statistical
s.sum(), s.prod(), s.cumsum(), s.cummax()
s.abs()
s.round(2)
s.clip(lower=0, upper=10) # cap values to a range
s.quantile([0.25, 0.5, 0.75])Gérer NaN dans Series
fillna offre de nombreuses stratégies : constante, statistique (moyenne/médiane), remplissage avant/arrière (idéal pour les séries temporelles), ou interpolation. ffill/bfill propagent la dernière valeur connue — parfait pour des données de capteurs ou de bourse qui ne doivent pas sauter. À la lecture, utilisez na_values pour convertir les sentinelles ('?', -999) en NaN afin de les traiter uniformément. interpolate supporte les méthodes linéaire, temporelle et par index.
s = pd.Series([1.0, 2.0, np.nan, 4.0, np.nan])
# Detect
s.isna() # boolean mask
s.notna()
s.isna().sum() # count of NaN
# Drop
s.dropna() # remove NaN
# Fill
s.fillna(0) # constant
s.fillna(s.mean()) # with mean
s.fillna(method="ffill") # forward fill (old API)
s.ffill() # forward fill (new)
s.bfill() # backward fill
s.interpolate() # linear interpolation
# Replace sentinel values with NaN on read
# pd.read_csv("x.csv", na_values=["?", "N/A", ""])Sélection et filtrage
Sélectionner des colonnes
La notation crochets df['col'] marche toujours ; la notation point df.col est pratique mais échoue pour les noms avec espaces ou en collision avec des méthodes (comme 'count'). filter(like=) et select_dtypes sont des façons propres de saisir des groupes de colonnes sans lister chaque nom — inestimable sur des DataFrames larges à centaines de colonnes.
# Single column (returns Series)
df["age"]
df.age # only if name is a valid Python identifier
# Multiple columns (returns DataFrame)
df[["name", "age", "city"]]
# Columns by pattern
df.filter(like="age") # columns containing "age"
df.filter(regex="^\d{4}$") # columns matching regex
df.filter(items=["name", "age"]) # specific columns
# Select by dtype
df.select_dtypes(include="number")
df.select_dtypes(include=["int64", "float64"])
df.select_dtypes(exclude="object")
df.select_dtypes(include="datetime")loc vs iloc
Le piège n°1 de pandas : .loc utilise les étiquettes (slices inclusives), .iloc les positions (exclusives). Pour l'affectation, utilisez TOUJOURS .loc/iloc — l'indexation chaînée comme df[df.a<5]['b']=0 lève SettingWithCopyWarning et peut échouer en silence. .loc supporte les masques booléens (filtrage par étiquettes), la façon propre de filtrer et affecter.
# .loc: label-based (inclusive slices)
df.loc[5] # row with index label 5
df.loc[5, "name"] # row 5, column 'name'
df.loc[5:10, ["name", "age"]] # rows 5-10 (inclusive), 2 cols
df.loc[df["age"] > 30] # boolean mask
# .iloc: position-based (exclusive slices)
df.iloc[0] # first row
df.iloc[-1] # last row
df.iloc[0:5] # first 5 rows (exclusive)
df.iloc[0:5, 0:2] # first 5 rows, first 2 cols
df.iloc[:, 0] # all rows, first column
# Setting values (use .loc for assignment!)
df.loc[df["age"] < 0, "age"] = 0 # cap negatives to 0
# AVOID chained indexing: df[df["a"]<5]["b"] = 0 # SettingWithCopyWarningFiltrage booléen
En combinant des conditions, utilisez & | ~ avec parenthèses autour de chaque condition — le and/or de Python ne marche pas sur les tableaux booléens. isin est la façon propre de filtrer sur plusieurs valeurs (plus rapide que des == chaînés). Le filtrage de chaînes passe par l'accesseur .str. Négation avec ~ (NOT bit à bit). Tout cela retourne un nouveau DataFrame filtré ; affectez à une variable pour le conserver.
# Single condition
df[df["age"] > 30]
df[df["city"] == "NYC"]
# Multiple conditions (use & | ~, NOT and/or/not; parenthesize!)
df[(df["age"] > 25) & (df["city"] == "NYC")]
df[(df["city"] == "NYC") | (df["city"] == "LA")]
df[~df["pass"]] # NOT pass
# isin for membership
df[df["city"].isin(["NYC", "LA", "SF"])]
# String methods in filters
df[df["name"].str.startswith("A")]
df[df["name"].str.contains("li", case=False)]
# Between
df[df["age"].between(25, 35, inclusive="both")]
# Null checks
df[df["score"].isnull()]
df[df["score"].notnull()]Méthode query()
query() se lit comme du SQL et évite la parenthésade du filtrage booléen. Utilisez @ pour référencer des variables locales Python. Sur de grands DataFrames, query peut être plus rapide car il évalue l'expression avec numexpr, évitant la création de tableaux booléens intermédiaires. Particulièrement agréable dans des chaînes groupby et pipelines.
# query() — string-based filtering, often more readable
df.query("age > 30")
df.query("age > 25 and city == 'NYC'")
df.query("age > 25 and city in ['NYC', 'LA']")
df.query("age > 25 or score > 90")
# Refer to Python variables with @
cities = ["NYC", "LA"]
df.query("city in @cities")
# Compare columns
df.query("score > age")
# Negation
df.query("not pass")
# query is faster than boolean indexing on large frames
# because it uses numexpr to avoid intermediate arraysÉchantillonnage et poids
sample(frac=0.8) suivi de drop(train.index) est une découpe train/test propre qui préserve l'index d'origine. Pour l'échantillonnage stratifié (préservation des proportions de classes), train_test_split de sklearn est plus fiable que du code pandas manuel. L'échantillonnage pondéré sert à l'importance sampling ou à simuler des données biaisées.
# Random sample
df.sample(n=5) # 5 rows
df.sample(frac=0.1) # 10% of rows
df.sample(n=5, random_state=42) # reproducible
# Sample with weights
df.sample(n=5, weights="score") # higher score -> more likely
# Sample with replacement (bootstrap)
df.sample(n=len(df), replace=True)
# Train/test split
train = df.sample(frac=0.8, random_state=42)
test = df.drop(train.index)
# Stratified sample (preserve class proportions)
from sklearn.model_selection import train_test_split
train, test = train_test_split(df, test_size=0.2,
stratify=df["city"], random_state=42)Nettoyage des données
Gérer les données manquantes
dropna(how='all') ne jette que les lignes entièrement vides ; thresh garde les lignes avec au moins N valeurs non nulles. Le remplissage par colonne via un dict est plus propre que plusieurs fillna. Pour les séries temporelles, ffill/bfill et interpolate préservent la continuité. Considérez toujours si la manquance elle-même est informative — ajouter une colonne indicatrice 'is_missing' avant imputation peut préserver ce signal pour le ML.
# Drop rows with any missing
df.dropna() # any NaN in any column
df.dropna(how="all") # only if ALL columns NaN
df.dropna(subset=["age", "city"]) # only check these columns
df.dropna(thresh=3) # keep rows with >=3 non-NaN
# Fill missing
df.fillna(0)
df.fillna({"age": df["age"].mean(),
"city": "Unknown"})
df["age"] = df["age"].fillna(df["age"].median())
# Forward/backward fill (for time series)
df.ffill()
df.bfill()
# Interpolate
df.interpolate(method="linear")
df.interpolate(method="time") # for DatetimeIndex
# Flag rows that were imputed
df["age_was_missing"] = df["age"].isnull()Retirer les doublons
duplicated() marque les lignes répétant une ligne antérieure ; keep='last' pour marquer la première occurrence à la place. keep=False marque chaque ligne dupliquée (y compris la première), utile pour inspecter toutes les lignes en conflit. drop_duplicates retourne un nouveau DataFrame ; inplace=True ou réaffectation pour modifier. subset permet de dédupliquer sur des colonnes clés comme email ou ID.
# Find duplicates
df.duplicated() # True for rows that are duplicates of earlier
df.duplicated().sum() # count
df[df.duplicated()] # view duplicates
# Drop duplicates
df.drop_duplicates() # full-row duplicates
df.drop_duplicates(subset=["email"]) # dup on email only
df.drop_duplicates(subset=["name", "dob"], keep="last") # keep last occurrence
df.drop_duplicates(keep=False) # drop ALL duplicates (keep none)
# Find rows where a column is duplicated
df[df.duplicated(subset=["email"], keep=False)]
# .keep=False marks ALL duplicates (including first)Renommer et réordonner
rename avec un dict de colonnes est la façon la plus sûre de renommer — il ne renomme que les colonnes listées et laisse les autres intactes. Réordonner les colonnes n'est qu'une sélection dans l'ordre voulu. set_index suivi de reset_index(drop=True) est la façon propre de remplacer un index brouillon. Passez str.strip sur les noms de colonnes tôt — des espaces finaux invisibles causent d'interminables maux de tête KeyError.
# Rename columns
df.rename(columns={"old_name": "new_name"})
df.rename(columns=str.upper) # uppercase all
df.rename(columns=str.strip) # strip whitespace
# Replace all column names
df.columns = ["id", "name", "age"]
# Add prefix/suffix
df.add_prefix("col_")
df.add_suffix("_v2")
# Reorder columns
df[["name", "age", "city"]] # select in new order
# Reorder rows by index
df.sort_index()
# Reset / set index
df.reset_index(drop=True) # drop old index
df.set_index("id") # use 'id' as index
# Swap rows and columns
df.transpose() # or df.TConversion de types
astype échoue sur des valeurs non parsables ; pd.to_numeric avec errors='coerce' transforme les mauvaises valeurs en NaN — bien plus sûr pour des données sales. Le dtype 'category' économise énormément de mémoire pour les chaînes à faible cardinalité. Le downcasting (int64->int8) peut réduire la mémoire de 8x pour les colonnes à petite plage. Parsez toujours les dates avec une chaîne de format explicite, pour la vitesse et la justesse.
# Convert a column's dtype
df["age"] = df["age"].astype(int)
df["price"] = df["price"].astype(float)
df["pass"] = df["pass"].astype(bool)
df["city"] = df["city"].astype("category") # save memory
# Convert with pd.to_numeric (handles bad values)
df["price"] = pd.to_numeric(df["price"], errors="coerce") # bad -> NaN
df["price"] = pd.to_numeric(df["price"], errors="ignore") # leave as-is
# Parse dates
df["date"] = pd.to_datetime(df["date"], format="%Y-%m-%d")
# Convert multiple columns at once
df = df.astype({"age": "int8", "score": "float32", "city": "category"})
# Downcast to save memory
df["age"] = pd.to_numeric(df["age"], downcast="integer")Remplacer des valeurs
replace est le cheval de bataille pour convertir les valeurs sentinelles (-999, '?') en NaN avant analyse. map applique un dict de lookup élément par élément (les valeurs non matchées deviennent NaN). where garde les valeurs où la condition est True et remplace le reste ; mask est l'inverse. Tout cela retourne de nouveaux objets — réaffectez pour appliquer.
# Replace specific values
df["city"].replace({"NYC": "New York", "LA": "Los Angeles"})
df.replace(-999, np.nan) # whole frame
df.replace(["?", "N/A", ""], np.nan) # multiple sentinels
# Replace by condition (mask)
df.loc[df["age"] < 0, "age"] = np.nan
# Clip outliers
df["age"] = df["age"].clip(0, 120)
# Map values with a dict (like a lookup)
df["grade"] = df["score"].map({90: "A", 80: "B", 70: "C"})
# Where: keep where condition True, else replace
df["age"].where(df["age"] >= 0, 0) # set negatives to 0
# Mask: opposite of where
df["age"].mask(df["age"] < 0, 0)Transformation des données
apply et applymap
apply exécute une fonction Python par élément/ligne — flexible mais lent (100x plus lent que les opérations vectorisées). Préférez toujours les opérations vectorisées (df['col'] + 1, .str.upper()) quand possible. Réservez apply à la logique non vectorisable (parsing de chaînes custom, transformations conditionnelles référençant plusieurs colonnes). Pour un travail par ligne, axis=1 et accédez aux colonnes via row['col'].
# Apply a function to each element of a column (Series)
df["age"] = df["age"].apply(lambda x: x + 1)
df["name"] = df["name"].apply(str.upper)
# Apply with multiple args
df["score"] = df["score"].apply(lambda x, n: round(x, n), n=2)
# Apply a function to each ROW (axis=1) — use columns
df["full"] = df.apply(lambda row: f"{row['name']} ({row['age']})", axis=1)
# Apply to every element of a DataFrame (newer: .map)
df = df.map(lambda x: str(x).strip() if isinstance(x, str) else x)
# Vectorized alternative (MUCH faster than apply)
df["age"] = df["age"] + 1 # vectorized, prefer this
df["name"] = df["name"].str.upper()Ajouter et modifier des colonnes
np.where est le if-else vectorisé — bien plus rapide que apply avec lambda. np.select gère plusieurs conditions comme un case/when. assign est un moyen compatible avec les chaînes d'ajouter des colonnes (idéal dans les pipelines). insert place une colonne à une position précise. Supprimez avec drop(columns=[...]) — bien plus clair que del df['col'].
# Add a new column
df["full_name"] = df["first"] + " " + df["last"]
df["is_adult"] = df["age"] >= 18
# Conditional column with np.where
df["category"] = np.where(df["age"] >= 18, "adult", "minor")
# Multiple conditions with np.select
conditions = [df["age"] < 18, df["age"] < 65, df["age"] >= 65]
choices = ["minor", "adult", "senior"]
df["group"] = np.select(conditions, choices, default="unknown")
# insert at a specific position
df.insert(2, "score_pct", df["score"] / 100) # at col index 2
# Assign multiple columns at once (returns new df)
df = df.assign(
age_months=df["age"] * 12,
score_squared=df["score"] ** 2,
)
# Drop columns
df.drop(columns=["temp", "junk"])Binning et discrétisation
cut divise la plage en bins de largeur égale (peut produire des bins vides) ; qcut en bins de fréquence égale (compte ~identique par bin) — généralement plus utile pour des données asymétriques. right=False rend les bins inclusifs à gauche [0,18) au lieu d'inclusifs à droite (0,18]. Les colonnes binées deviennent catégorielles, parfaites pour l'agrégation groupby.
# Equal-width bins
df["age_bin"] = pd.cut(df["age"], bins=4)
# Custom bins with labels
df["age_group"] = pd.cut(
df["age"],
bins=[0, 18, 30, 50, 100],
labels=["child", "young", "adult", "senior"],
right=False, # left-inclusive: [0, 18)
)
# Equal-frequency bins (quantiles)
df["income_quartile"] = pd.qcut(df["income"], q=4, labels=["Q1","Q2","Q3","Q4"])
# Get bin edges
df["age_bin"].value_counts(sort=False)
pd.cut(df["age"], bins=4).cat.categories # see the bin rangesOpérations de chaînes (accesseur .str)
L'accesseur .str vectorise les méthodes de chaînes Python — ne bouclez jamais avec apply(str.upper). split avec expand=True transforme une colonne en plusieurs (idéal pour scinder des noms). extract avec groupes nommés tire des données structurées du texte. Toutes les méthodes .str retournent NaN pour les entrées NaN et acceptent na= pour contrôler ce comportement.
# All vectorized string methods via .str
df["name"] = df["name"].str.upper()
df["name"] = df["name"].str.lower()
df["name"] = df["name"].str.strip() # remove leading/trailing
df["name"] = df["name"].str.replace(" ", "_")
df["name"] = df["name"].str.title() # Title Case
# Split
df["name"].str.split(" ") # list per row
df[["first", "last"]] = df["name"].str.split(" ", expand=True)
# Contains / startswith / match (returns boolean)
df["name"].str.contains("li", case=False, na=False)
df["name"].str.startswith("A")
df["name"].str.match(r"^A\w+$") # regex match
# Extract with regex groups
df["name"].str.extract(r"(?P<first>\w+)\s+(?P<last>\w+)")
# Length
df["name"].str.len()Dates et heures (accesseur .dt)
Convertissez toujours les colonnes de dates avec pd.to_datetime d'abord, puis utilisez .dt pour accéder aux composantes. L'accesseur .dt débloque year/month/day/weekday/hour et les opérations de fuseau. Pandas compare directement les dates aux chaînes ('2024-01-01'). Le travail avec fuseaux utilise tz_localize (ajouter tz) et tz_convert (changer tz) — ne mélangez pas datetimes naïfs et conscients.
df["date"] = pd.to_datetime(df["date"])
# Extract parts
df["year"] = df["date"].dt.year
df["month"] = df["date"].dt.month
df["day"] = df["date"].dt.day
df["weekday"] = df["date"].dt.day_name() # 'Monday'
df["hour"] = df["date"].dt.hour
df["is_weekend"] = df["date"].dt.dayofweek >= 5
# Date arithmetic
df["age_days"] = (pd.Timestamp("today") - df["date"]).dt.days
# Format back to string
df["date_str"] = df["date"].dt.strftime("%Y-%m-%d")
# Timezone handling
df["date_utc"] = df["date"].dt.tz_localize("UTC")
df["date_local"] = df["date_utc"].dt.tz_convert("US/Eastern")
# Filter by date
df[df["date"] > "2024-01-01"]
df[df["date"].between("2024-01-01", "2024-12-31")]GroupBy et agrégation
GroupBy de base
groupby suit split-apply-combine : scinder les lignes par clé de groupe, appliquer une fonction par groupe, combiner les résultats. groupby('city')['age'].mean() retourne une Series indexée par ville ; agg avec une liste retourne un DataFrame. size() compte toutes les lignes par groupe (clés NaN incluses) ; value_counts() exclut NaN et trie par fréquence. Plusieurs clés créent un index hiérarchique.
# Split-Apply-Combine: group rows, compute per group
df.groupby("city")["age"].mean() # one column, one agg
df.groupby("city")["age"].agg(["mean", "median", "std"])
# Multiple columns
df.groupby("city")[["age", "score"]].mean()
# Group by multiple columns (hierarchical)
df.groupby(["city", "pass"])["age"].mean()
# Quick counts per group
df.groupby("city").size() # includes NaN groups
df["city"].value_counts() # excludes NaN, sorted
# Iterate over groups
for name, group in df.groupby("city"):
print(name, len(group))Agrégations multiples
Les agrégations nommées (pandas 0.25+) sont la façon la plus propre — les colonnes de sortie portent les noms que vous spécifiez au lieu d'un MultiIndex. La syntaxe est nouvelle_col=('colonne_source', 'fonction'). Les fonctions custom via lambda marchent mais sont plus lentes que les intégrées (mean, sum, etc. optimisées en C). Faites toujours reset_index() si vous voulez la clé de groupe comme colonne ordinaire.
# Different aggregations per column
df.groupby("city").agg({
"age": ["mean", "median", "std"],
"score": ["min", "max", "count"],
})
# Named aggregations (cleaner output, no MultiIndex)
result = df.groupby("city").agg(
avg_age=("age", "mean"),
median_age=("age", "median"),
n_people=("age", "count"),
max_score=("score", "max"),
)
# Custom aggregation function
df.groupby("city").agg(
age_range=("age", lambda x: x.max() - x.min()),
)
# Reset index to get a flat DataFrame
result = result.reset_index()transform et filter
transform est magique — il retourne une Series de même longueur que l'entrée, broadcastant le résultat de chaque groupe à ses membres. Parfait pour ajouter des statistiques au niveau groupe (moyenne par catégorie) à côté des lignes d'origine, ou remplir les manquants par moyennes de groupe. filter garde ou jette des groupes entiers selon une condition booléenne par groupe (ex. jeter les villes trop peu échantillonnées).
# transform: broadcast group result back to original shape
df["age_mean_city"] = df.groupby("city")["age"].transform("mean")
df["age_dev"] = df["age"] - df.groupby("city")["age"].transform("mean")
# Fill missing with group mean
df["score"] = df.groupby("city")["score"].transform(
lambda s: s.fillna(s.mean()))
# filter: keep/drop entire groups based on a condition
# keep groups with more than 2 rows
big_groups = df.groupby("city").filter(lambda g: len(g) > 2)
# keep groups where average score > 80
df.groupby("city").filter(lambda g: g["score"].mean() > 80)apply sur les groupes
apply sur groupby est le plus flexible (n'importe quelle fonction par groupe) mais le plus lent — préférez les agrégations intégrées (mean, sum) ou transform quand possible. Retourner une Series depuis votre fonction crée un DataFrame dont l'index de la Series devient les colonnes. idxmax retourne l'index du max — servez-vous-en pour chercher d'autres colonnes de la même ligne.
# Apply any function per group (most flexible)
def top_scorer(g):
return g.nlargest(1, "score")
df.groupby("city").apply(top_scorer)
df.groupby("city").apply(lambda g: g.nlargest(2, "score"))
# Normalize within group
df.groupby("city").apply(
lambda g: (g["score"] - g["score"].mean()) / g["score"].std()
)
# Multiple results per group
def summarize(g):
return pd.Series({
"count": len(g),
"avg_score": g["score"].mean(),
"top_name": g.loc[g["score"].idxmax(), "name"],
})
df.groupby("city").apply(summarize)
# include_groups=False (newer pandas) to exclude group cols from gTables pivot et crosstab
pivot_table est groupby + unstack combinés — parfait pour transformer des données longues en matrice (ex. score moyen par ville × réussite). margins=True ajoute des totaux ligne/colonne. crosstab est un pivot spécialisé pour compter des combinaisons (tables de fréquences) ; normalize='index' donne des proportions par ligne. Melt est l'inverse, convertissant le large en long.
# pivot_table: groupby + reshape in one step
pd.pivot_table(df, values="score", index="city", columns="pass",
aggfunc="mean")
pd.pivot_table(df, values="score", index="city", columns="pass",
aggfunc=["mean", "count"], margins=True)
# Multiple values
pd.pivot_table(df, values=["age", "score"], index="city",
aggfunc={"age": "mean", "score": "max"})
# crosstab: frequency table of two (or more) categoricals
pd.crosstab(df["city"], df["pass"])
pd.crosstab(df["city"], df["pass"], normalize="index") # row %
pd.crosstab(df["city"], df["pass"], values=df["score"],
aggfunc="mean") # like a pivot
# Melt a pivot back to long
wide = pd.pivot_table(df, values="score", index="city", columns="pass")
long = wide.reset_index().melt(id_vars="city", var_name="pass",
value_name="score")Fusion et jointure
merge (jointures façon SQL)
merge est le JOIN SQL de pandas — how contrôle inner/left/right/outer/cross. Spécifiez toujours on explicitement ; si la clé a des noms différents, utilisez left_on/right_on. Utilisez suffixes pour désambiguïser les colonnes qui se recouvrent (le défaut _x/_y est opaque). validate='m:1' (ou '1:1','1:m','m:m') lève une erreur si la cardinalité de la jointure est mauvaise — une excellente garde contre la duplication accidentelle de lignes.
# Like SQL JOIN
pd.merge(df1, df2, on="id") # inner join (default)
pd.merge(df1, df2, on="id", how="left") # left join
pd.merge(df1, df2, on="id", how="right")
pd.merge(df1, df2, on="id", how="outer") # full outer
pd.merge(df1, df2, on="id", how="cross") # cartesian product
# Different column names in each frame
pd.merge(df1, df2, left_on="user_id", right_on="id")
# Join on index
pd.merge(df1, df2, left_index=True, right_index=True)
# Suffixes for overlapping non-key columns
pd.merge(df1, df2, on="id", suffixes=("_left", "_right"))
# Validate to catch unexpected duplicates
pd.merge(df1, df2, on="id", validate="m:1") # many-to-one expectedconcat (empilement)
concat empile des DataFrames verticalement (axis=0, défaut) ou horizontalement (axis=1). ignore_index=True jette les index d'origine et crée un propre 0..n-1 — généralement ce qu'on veut en empilant. join='inner' ne garde que les colonnes partagées (utile quand les frames ont divergé). verify_integrity=True erre sur les index dupliqués — un filet de sécurité pour les appends désordonnés.
# Stack vertically (rows) — same columns
pd.concat([df1, df2])
pd.concat([df1, df2], ignore_index=True) # reindex 0..n-1
# Stack horizontally (columns)
pd.concat([df1, df2], axis=1)
# Concat with keys (hierarchical index)
pd.concat([df1, df2], keys=["q1", "q2"])
# Append (deprecated; use concat)
# df1.append(df2) # deprecated, use pd.concat
# Verify columns match when stacking
pd.concat([df1, df2], verify_integrity=True) # error on dup index
# Join options for mismatched columns
pd.concat([df1, df2], join="inner") # keep only shared columns
pd.concat([df1, df2], join="outer") # keep all, NaN for missingjoin (par index)
join est du sucre syntaxique sur merge pour le cas courant de jointure par index — un peu plus concis quand les deux frames ont déjà des index significatifs. Pour joindre par colonnes, merge est plus clair. join peut joindre plusieurs DataFrames d'un coup (passez une liste), pratique pour appliquer plusieurs tables de référence à une frame principale.
# join is merge optimized for joining on the index
df1.join(df2) # join on index
df1.join(df2, how="left") # left, right, inner, outer
df1.join([df2, df3]) # join multiple at once
# join on a column (set index first)
df1.set_index("id").join(df2.set_index("id"), how="inner")
# Suffix for overlapping columns
df1.join(df2, lsuffix="_left", rsuffix="_right")
# When to use join vs merge:
# - join: keys are the index (faster, cleaner)
# - merge: keys are regular columns (more flexible)combine et update
combine_first est la façon idiomatique de remplir les manquants depuis un autre DataFrame — comme un coalesce en SQL. update modifie df1 en place, n'écrasant que là où df2 a des valeurs non NaN. Parfaits pour patcher un jeu de données maître avec des données partielles plus récentes. concat + drop_duplicates est une union/déduplication rapide, mais pour de vraies opérations ensemblistes, considérez merge avec indicator=True.
# combine_first: fill NaN in df1 with values from df2
df1.combine_first(df2)
# Where df1 is NaN, take df2's value; otherwise keep df1.
# update: overwrite df1 in place with non-NaN from df2
df1.update(df2)
# combine with a custom function
import numpy as np
df1.combine(df2, lambda s1, s2: np.minimum(s1, s2))
# Concat then drop duplicates (union with dedup)
pd.concat([df1, df2]).drop_duplicates()Vérifier les résultats de fusion
indicator=True est inestimable pour déboguer les jointures — il dit de quel côté viennent les lignes. Un saut soudain du nombre de lignes après un merge signifie généralement des clés dupliquées dans une frame ; vérifiez avec value_counts() sur la clé avant de joindre. Pour un simple « filtrer df1 sur les clés présentes dans df2 », utilisez isin (semi-join) — pas besoin de vrai merge.
# indicator=True adds a '_merge' column showing the source
merged = pd.merge(df1, df2, on="id", how="outer", indicator=True)
# _merge values: 'left_only', 'right_only', 'both'
# Find rows in df1 but not df2 (anti-join)
only_left = merged[merged["_merge"] == "left_only"]
# Find rows in both (intersection)
both = merged[merged["_merge"] == "both"]
# Detect unexpected row explosion (duplicate keys)
print(len(df1), len(df2), len(merged))
# if len(merged) >> max(len(df1), len(df2)) you have duplicate keys
# isin for a simple semi-join (filter df1 to keys in df2)
df1[df1["id"].isin(df2["id"])] # semi-join
df1[~df1["id"].isin(df2["id"])] # anti-joinRefaçonner les données
melt (large vers long)
melt convertit les données au format large (une ligne par entité, plusieurs colonnes de mesures) en format long (une ligne par mesure), le format tidy préféré par la plupart des bibliothèques ML/stats. id_vars sont les colonnes identifiantes conservées telles quelles ; tout le reste devient des paires var/valeur. Le format long se groupby, filtre et trace plus facilement.
# melt: unpivot columns into rows
df_wide = pd.DataFrame({
"id": [1, 2],
"q1": [10, 20],
"q2": [15, 25],
"q3": [20, 30],
})
long = df_wide.melt(id_vars="id", var_name="quarter", value_name="score")
# id quarter score
# 0 1 q1 10
# 1 2 q1 20
# ...
# Melt only specific columns
df_wide.melt(id_vars="id", value_vars=["q1", "q2"])
# Keep the wide columns too (with identifier)
df_wide.melt(id_vars="id", value_vars=["q1","q2","q3"],
var_name="quarter", value_name="score",
ignore_index=True)pivot (long vers large)
pivot refaçonne du long en large sans agrégation — il échoue s'il y a des paires (index, colonnes) dupliquées, auquel cas utilisez pivot_table avec une aggfunc. Les noms de colonnes deviennent les colonnes du pivot, ce qui peut troubler — reset_index() et columns.name=None nettoient le résultat. pivot est l'inverse de melt.
# pivot: long to wide (without aggregation)
df_long = pd.DataFrame({
"id": [1, 1, 1, 2, 2, 2],
"quarter": ["q1", "q2", "q3", "q1", "q2", "q3"],
"score": [10, 15, 20, 30, 35, 40],
})
wide = df_long.pivot(index="id", columns="quarter", values="score")
# quarter q1 q2 q3
# id
# 1 10 15 20
# 2 30 35 40
# pivot fails on duplicate index/value combos — use pivot_table then
df_long.pivot_table(index="id", columns="quarter",
values="score", aggfunc="sum")
# Restore a regular column from the index
wide = wide.reset_index()
wide.columns.name = Nonestack et unstack
stack/unstack déplacent des niveaux entre lignes et colonnes sur les objets MultiIndex — puissants pour refaçonner les résultats groupés. Un groupby multi-clés produit une Series avec MultiIndex ; unstack transforme un niveau en colonnes pour une vue matricielle. stack est l'inverse. Ce sont les briques des tables pivot sous le capot.
# MultiIndex column example
df = pd.DataFrame({
("A", "x"): [1, 2],
("A", "y"): [3, 4],
("B", "x"): [5, 6],
})
# stack: turn column level into inner row index
stacked = df.stack()
# Now a Series with MultiIndex (row, col_level_2)
# unstack: inverse — turn row level into column level
stacked.unstack()
# Common use: reshape grouped result
g = df.groupby(["city", "year"])["score"].mean()
# city year
# NYC 2023 80
# NYC 2024 85
# LA 2023 70
g.unstack("year") # years become columns
# 2023 2024
# city
# NYC 80 85
# LA 70 NaNExploser les listes
explode transforme une colonne de listes en une ligne par élément de liste, dupliquant les autres colonnes — essentiel pour les données imbriquées (tableaux JSON, enregistrements multi-tags). C'est la façon propre de normaliser les colonnes à valeurs de liste avant analyse. Pour l'inverse (combiner des lignes en une liste), utilisez groupby + apply(list).
# explode: turn list-like values into separate rows
df = pd.DataFrame({
"id": [1, 2],
"tags": [["python", "ml"], ["sql", "db", "etl"]],
})
# id tags
# 0 1 [python, ml]
# 1 2 [sql, db, etl]
exploded = df.explode("tags")
# id tags
# 0 1 python
# 0 1 ml
# 1 2 sql
# 1 2 db
# 1 2 etl
# Useful after str.split
df["tags"] = df["tags_str"].str.split(",")
exploded = df.explode("tags")
# Aggregate back: groupby + list
exploded.groupby("id")["tags"].apply(list)Opérations MultiIndex
MultiIndex (index hiérarchique) permet de représenter des données de haute dimension en 2D. xs (cross-section) sélectionne à un niveau précis sans devoir spécifier tous les niveaux externes. swaplevel et sort_index(level=) réordonnent les niveaux pour différentes vues. La plupart du temps, reset_index() aplatit un MultiIndex en colonnes ordinaires, plus faciles à manipuler.
# Create a MultiIndex DataFrame
idx = pd.MultiIndex.from_tuples([("NYC", 2023), ("NYC", 2024),
("LA", 2023)], names=["city", "year"])
df = pd.DataFrame({"score": [80, 85, 70]}, index=idx)
# Select by outer level
df.loc["NYC"] # all NYC rows
df.xs("NYC", level="city") # same, more explicit
# Select by inner level
df.xs(2023, level="year")
# Swap levels
df.swaplevel()
# Sort by level
df.sort_index(level="year")
# Reset one level back to a column
df.reset_index(level="year")
# Flatten columns after a groupby
g = df.groupby(["city", "year"]).mean().reset_index()Tri et classement
Trier les valeurs
sort_values avec une liste de colonnes et une liste ascending correspondante trie lexicographiquement — clé primaire d'abord, puis départage. na_position contrôle où vont les NaN (défaut 'last'). Le tri est stable, donc les clés égales préservent l'ordre d'origine. Le tri modifie l'ordre de l'index ; reset_index(drop=True) donne ensuite un index séquentiel propre.
# Sort by one column
df.sort_values("age")
df.sort_values("age", ascending=False)
# Sort by multiple columns (stable sort)
df.sort_values(["city", "age"], ascending=[True, False])
# city ascending, age descending within each city
# Put NaNs first or last
df.sort_values("score", na_position="first")
# In-place (modifies df)
df.sort_values("age", inplace=True)
# Sort by index
df.sort_index()
df.sort_index(axis=1) # sort columns by name
df.sort_index(ascending=False)
# Reset index after sorting
df.sort_values("age").reset_index(drop=True)Classement (rank)
rank est essentiel pour les percentiles, les top-N dans les groupes et les statistiques non paramétriques. method='dense' donne 1,2,2,3 (sans trous) — parfait pour les médailles ou notes ; 'first' départage par ordre d'apparition. rank(pct=True) retourne des percentiles. groupby + rank calcule des classements par groupe (ex. meilleur vendeur par région).
# Default rank: average for ties (1, 2.5, 2.5, 4)
df["rank"] = df["score"].rank()
# Methods for handling ties
df["score"].rank(method="average") # default
df["score"].rank(method="min") # ties get the min rank
df["score"].rank(method="max") # ties get the max rank
df["score"].rank(method="first") # ties broken by order of appearance
df["score"].rank(method="dense") # 1, 2, 2, 3 (no gaps)
# Ascending / descending
df["score"].rank(ascending=False) # highest = rank 1
# Rank as percentile
df["pct"] = df["score"].rank(pct=True)
# Rank within groups
df["city_rank"] = df.groupby("city")["score"].rank(ascending=False)nlargest et nsmallest
nlargest/nsmallest sont optimisées — elles utilisent un tas en interne, donc plus rapides que trier toute la frame quand vous n'avez besoin que de quelques lignes (ex. top 10 d'un million). Pour « top N par groupe », groupby + apply(nlargest) est l'idiome, quoique plus lent qu'un tri complet + groupby head sur certaines données. keep contrôle le départage ('first', 'last', 'all').
# Top N rows — faster than sort_values + head on large data
df.nlargest(5, "score") # top 5 by score
df.nlargest(5, "score", keep="first") # tie-breaking
df.nsmallest(3, "age") # youngest 3
# Top N per group
df.groupby("city").apply(lambda g: g.nlargest(2, "score"))
# Bottom N with multiple columns
df.nsmallest(5, ["age", "score"])
# Equivalent sort_values (slower for big data)
df.sort_values("score", ascending=False).head(5)Trier index et colonnes
sort_index(axis=1) alphabétise les colonnes — pratique après des merges ajoutant des colonnes dans un ordre arbitraire. Pour mettre les colonnes clés d'abord (comme 'id', 'name'), utilisez la concaténation de listes : colonnes de tête puis le reste. La sélection explicite df[[...]] est la façon la plus claire de réordonner, et sert aussi à sous-ensembler les colonnes.
# Sort the row index
df.sort_index()
df.sort_index(ascending=False)
# Sort columns alphabetically
df.sort_index(axis=1)
df.sort_index(axis=1, ascending=False)
# Reorder columns explicitly
df[["name", "age", "city", "score"]]
# Reorder to a pattern
cols = sorted(df.columns)
df = df[cols]
# Move specific columns to the front
front = ["id", "name"]
df = df[front + [c for c in df.columns if c not in front]]Tri avec clés
sort_values(key=) applique une fonction à la colonne avant tri — tris insensibles à la casse ou par longueur. Les colonnes Ordered Categorical trient selon l'ordre de catégories défini, pas alphabétiquement — parfait pour les jours de la semaine, tailles (S<M<L) ou ordres métier personnalisés. Le tri naturel (file1, file2, file10) exige une clé custom qui sépare les chiffres.
# Sort by a function of the values (key, like sorted())
df.sort_values("name", key=lambda s: s.str.lower())
# case-insensitive sort
# Sort by string length
df.sort_values("name", key=lambda s: s.str.len())
# Sort by a custom order (categorical)
df["city"] = pd.Categorical(df["city"],
categories=["NYC", "LA", "SF"], ordered=True)
df.sort_values("city") # follows the defined category order
# Natural sort (numbers in strings)
import re
def natural_key(s):
return [int(t) if t.isdigit() else t for t in re.split(r"(\d+)", s)]
df.sort_values("version", key=lambda s: s.map(natural_key))Opérations datetime
Parser les dates
Passez toujours une chaîne de format explicite quand vous la connaissez — 10x plus rapide que l'inférence et sans ambiguïté (01/02/2024 peut être 2 janvier ou 1er février). errors='coerce' transforme les valeurs non parsables en NaT (Not a Time, le NaN des datetime). pd.to_datetime sur un DataFrame avec colonnes year/month/day construit les dates à partir des parties.
# Parse strings to datetime
df["date"] = pd.to_datetime(df["date"])
df["date"] = pd.to_datetime(df["date"], format="%Y-%m-%d") # faster + safer
# Handle mixed formats
df["date"] = pd.to_datetime(df["date"], format="mixed")
# Coerce bad values to NaT (datetime NaN)
df["date"] = pd.to_datetime(df["date"], errors="coerce")
# Parse on read
df = pd.read_csv("data.csv", parse_dates=["date", "created_at"])
# Parse multiple columns into one
df["datetime"] = pd.to_datetime(df[["year", "month", "day"]])
# Timestamp (scalar)
pd.Timestamp("2024-06-15 14:30:00")
pd.Timestamp.now()
pd.Timestamp("2024-06-15").tz_localize("UTC")date_range et Periods
date_range génère des séquences DatetimeIndex avec des chaînes freq flexibles : 'D' (jour), 'H' (heure), 'MS' (début de mois), 'W-MON' (lundis hebdomadaires), 'Q' (trimestre). bdate_range saute les week-ends. Period représente un intervalle (un mois entier, un trimestre entier) plutôt qu'un instant — utile pour les périodes de reporting. Les alias freq sont puissants : '2D' = tous les 2 jours.
# Generate a sequence of dates
pd.date_range("2024-01-01", "2024-01-10") # daily
pd.date_range("2024-01-01", periods=10) # 10 days
pd.date_range("2024-01-01", periods=10, freq="H") # hourly
pd.date_range("2024-01-01", "2024-12-31", freq="MS") # month start
pd.date_range("2024-01-01", "2024-12-31", freq="W-MON") # weekly Mondays
# Business days only
pd.bdate_range("2024-01-01", periods=10)
# Period (represents an interval, like a month)
p = pd.Period("2024-06", freq="M")
p.to_timestamp() # convert to the month's start
p.start_time, p.end_time
# Period range
pd.period_range("2024-01", "2024-12", freq="M")Resampling et conversion de fréquence
resample est le groupby des séries temporelles — downsample avec une agrégation (sommes et moyennes W/M/Q), upsample avec un remplissage (ffill, interpolate). resample exige un DatetimeIndex. Les arguments 'label' et 'closed' contrôlent si la borne du bin appartient à la période de gauche ou droite — important pour les agrégations hebdo/mensuelles afin d'éviter les décalages d'une unité.
ts = pd.Series(range(100), index=pd.date_range("2024-01-01", periods=100, freq="D"))
# Downsample (more frequent -> less frequent): use agg
ts.resample("W").sum() # weekly sum
ts.resample("M").mean() # monthly mean
ts.resample("QE").max() # quarterly max
# Upsample (less -> more frequent): need fill
ts.resample("H").asfreq() # hourly, NaN for gaps
ts.resample("H").ffill() # forward fill
ts.resample("H").interpolate() # linear interp
# Custom aggregation
ts.resample("W").agg(["mean", "std", "count"])
# Resample with multiple columns
df.resample("M").agg({"sales": "sum", "visits": "mean"})
# Use 'label' and 'closed' to control bin edges
ts.resample("M", label="right", closed="right").sum()Décalage et lags
shift, diff et pct_change fondent le feature engineering des séries temporelles. shift(1) crée un lag (la valeur d'hier alignée sur la ligne d'aujourd'hui) — parfait pour les caractéristiques autorégressives. shift(-1) jette un œil au futur (pour bâtir des cibles de pas suivant). diff et pct_change mesurent les changements. Triez toujours par temps avant de les utiliser, et surveillez les NaN aux bornes.
# Shift values forward/backward (for time-series features)
ts.shift(1) # move values down by 1 (yesterday's value)
ts.shift(-1) # move up by 1 (tomorrow's value)
# Difference (today - yesterday)
ts.diff() # first difference
ts.diff(7) # week-over-week difference
# Percentage change
ts.pct_change()
ts.pct_change(periods=7) # 7-day pct change
# Lag features for ML
df["lag_1"] = df["sales"].shift(1)
df["lag_7"] = df["sales"].shift(7)
df["roll_7"] = df["sales"].rolling(7).mean()
df["target_next"] = df["sales"].shift(-1) # next-day target
# Shift by a time frequency
ts.shift(1, freq="D") # shift the INDEX by 1 dayFenêtres roulantes et expansives
rolling calcule une statistique sur une fenêtre glissante — moyennes mobiles, volatilité, etc. min_periods permet de calculer sur fenêtres partielles (sinon les N-1 premières sont NaN). ewm donne des moyennes pondérées exponentiellement (points récents plus pondérés — courant en finance). expanding croît depuis le début (stats cumulatives). Les fenêtres temporelles ('7D') gèrent correctement l'échantillonnage irrégulier, contrairement aux fenêtres par comptage de lignes.
s = pd.Series([1, 2, 3, 4, 5, 6, 7, 8, 9, 10], dtype=float)
# Rolling window (fixed-size sliding window)
s.rolling(3).mean() # 3-period moving average
s.rolling(7).std()
s.rolling(3, min_periods=1).mean() # allow partial windows
# Custom aggregation
s.rolling(3).apply(lambda x: x.max() - x.min())
# Exponentially weighted (decaying weights)
s.ewm(span=7).mean() # EWMA — recent data weighted more
s.ewm(alpha=0.3).mean()
# Expanding window (grows from start)
s.expanding().mean() # cumulative mean
s.expanding().max() # running max
# Window with time-based offset (needs DatetimeIndex)
ts.rolling("7D").mean() # 7-day window, not 7 rowsDonnées catégorielles
Créer des catégorielles
Le dtype category stocke les chaînes en codes entiers plus une table de lookup — énorme économie mémoire pour les colonnes à faible cardinalité (une colonne ville à 5 valeurs uniques sur un million de lignes). Les catégorielles ordonnées supportent les comparaisons (taille > 'M') et trient selon l'ordre de catégories, pas alphabétiquement. Utilisez category pour les colonnes à ensemble de valeurs connu et petit.
# Convert to category dtype
df["city"] = df["city"].astype("category")
# Create with explicit categories
s = pd.Categorical(["a", "b", "a", "c"],
categories=["a", "b", "c", "d"])
# Ordered categorical (for sorting & comparisons)
size = pd.Categorical(["M", "L", "S", "XL"],
categories=["S", "M", "L", "XL"],
ordered=True)
size > "M" # works because it's ordered
# Memory savings
df["city"].memory_usage(deep=True) # object
df["city"].astype("category").memory_usage(deep=True) # much lessL'accesseur .cat
L'accesseur .cat manipule les métadonnées catégorielles. remove_unused_categories rogne la liste de catégories aux valeurs réelles — important après filtrage, quand beaucoup de catégories deviennent vides. rename_categories change les étiquettes sans toucher aux codes sous-jacents. reorder_categories change l'ordre de tri. Tout cela retourne de nouvelles Series ; réaffectez pour appliquer.
s = pd.Series(["a", "b", "a", "c"], dtype="category")
# Inspect categories
s.cat.categories # Index(['a', 'b', 'c'])
s.cat.codes # integer codes
s.value_counts()
# Add / remove categories
s = s.cat.add_categories(["d"])
s = s.cat.remove_categories(["d"]) # values in 'd' become NaN
s = s.cat.remove_unused_categories()
# Rename categories
s = s.cat.rename_categories({"a": "alpha", "b": "beta"})
# Reorder categories
s = s.cat.reorder_categories(["c", "b", "a"])
# Set / unset ordering
s = s.cat.as_ordered()
s = s.cat.as_unordered()Opérations catégorielles
Les opérations catégorielles sont généralement plus rapides que les opérations object (chaînes) pour groupby et value_counts. En fusionnant deux colonnes catégorielles, alignez d'abord leurs ensembles de catégories avec set_categories — des catégories désaccordées causent des merges lents et des NaN silencieux. Reconvertissez en string/object avec astype(str) quand l'overhead catégoriel ne vaut pas (ex. colonnes de texte libre).
# Operations preserve categorical dtype where possible
s = pd.Series(["low", "high", "med", "low"], dtype="category")
s.value_counts()
# Comparison on ordered categoricals
size = pd.Series(["M", "L", "S"], dtype="category")
size = size.cat.as_ordered().cat.reorder_categories(["S","M","L","XL"])
size > "M" # boolean Series
# Groupby works as expected
df.groupby("city")["score"].mean()
# Converting back
df["city"] = df["city"].astype(str) # to string
df["city"] = df["city"].astype("object") # to object
# Beware: merges between categoricals can be slow if categories differ
# Align categories before merging:
cats = sorted(set(df1["city"].cat.categories) |
set(df2["city"].cat.categories))
df1["city"] = df1["city"].cat.set_categories(cats)
df2["city"] = df2["city"].cat.set_categories(cats)Optimisation mémoire
L'optimisation mémoire compte au chargement de grands jeux : convertissez les chaînes à faible cardinalité en category (économie de 10 à 100x), downcastez les numériques (int64->int8 pour des entiers à petite plage, float64->float32). Le dtype 'string' (pandas 1.0+) est plus économe que object et gère mieux NaN. Règle empirique : si nunique/len < 0.5, category vaut le coup.
# Check current memory
df.info(memory_usage="deep")
# Convert object columns to category when cardinality is low
for col in df.select_dtypes(include="object"):
if df[col].nunique() / len(df) < 0.5: # <50% unique
df[col] = df[col].astype("category")
# Downcast numeric columns
df["age"] = pd.to_numeric(df["age"], downcast="integer")
df["score"] = pd.to_numeric(df["score"], downcast="float")
# Use string dtype (pandas 1.0+) instead of object
df["name"] = df["name"].astype("string")
# Compare memory before/after
before = df.memory_usage(deep=True).sum()
# ... optimize ...
after = df.memory_usage(deep=True).sum()
print(f"Reduced from {before/1e6:.1f}MB to {after/1e6:.1f}MB")Variables indicatrices (one-hot)
get_dummies encode en one-hot les colonnes catégorielles en colonnes indicatrices 0/1 — essentiel avant des modèles linéaires incapables de gérer les catégorielles. drop_first évite le piège des variables indicatrices (multicolinéarité) en régression linéaire. Pour les pipelines ML, préférez OneHotEncoder de sklearn (gère les catégories inconnues au test via handle_unknown='ignore') à get_dummies.
# One-hot encode categoricals
pd.get_dummies(df["city"])
pd.get_dummies(df, columns=["city", "pass"]) # encode multiple
# Drop first to avoid multicollinearity (for linear models)
pd.get_dummies(df["city"], drop_first=True)
# With a prefix
pd.get_dummies(df["city"], prefix="city")
# From categorical with all categories
pd.get_dummies(df["city"].astype("category"))
# Alternatively, sklearn's OneHotEncoder (for ML pipelines)
from sklearn.preprocessing import OneHotEncoder
ohe = OneHotEncoder(sparse_output=False, handle_unknown="ignore")
X_ohe = ohe.fit_transform(df[["city"]])Performance et optimisation
Vectorisation (éviter iterrows)
iterrows est le péché de performance n°1 de pandas — 100 à 1000x plus lent que les opérations vectorisées. Préférez toujours les opérations vectorisées sur colonnes (df['a'] + df['b']), .str pour les chaînes, et np.where pour le if-else. Si vous devez vraiment boucler, itertuples est bien plus rapide que iterrows (namedtuples vs Series). Pour une logique complexe, considérez numba ou cython, ou extrayez en numpy avec .to_numpy().
# BAD: iterrows is extremely slow
for idx, row in df.iterrows():
df.loc[idx, "x"] = row["a"] + row["b"]
# GOOD: vectorized operations
df["x"] = df["a"] + df["b"]
# GOOD: .str accessor for strings
df["name"] = df["name"].str.upper()
# GOOD: np.where for conditionals
df["cat"] = np.where(df["a"] > 0, "pos", "neg")
# If you must iterate (rare), use itertuples (faster than iterrows)
for row in df.itertuples():
process(row.a, row.b)
# Or .to_numpy() / .values for raw array loops
for row in df[["a", "b"]].to_numpy():
...
# Benchmark
%timeit df["a"] + df["b"]
%timeit df.apply(lambda r: r["a"] + r["b"], axis=1)eval et query
eval et query parsent des expressions en chaînes et les évaluent avec numexpr, qui peut être 2 à 4x plus rapide que l'arithmétique Python sur de grands DataFrames car il évite de créer des tableaux intermédiaires et évalue au niveau C. Le bénéfice s'amenuise sur les petites données (overhead de parsing). Utile pour des expressions complexes sur grandes frames — mais benchmarkez toujours, ce n'est pas toujours plus rapide.
# eval: evaluate string expressions (uses numexpr, faster on big data)
df.eval("total = a + b + c", inplace=True)
df.eval("ratio = a / (b + c)")
df.eval("c = a > b")
# Multiple operations in one eval (efficient)
df.eval("""
total = a + b
ratio = a / b
flag = a > 10
""", inplace=True)
# query: boolean filter via string (same engine)
df.query("a > 0 and b < 10")
# Local variables with @
threshold = 5
df.query("a > @threshold")
# eval is faster than Python arithmetic on large frames
# because it avoids intermediate arraysDtypes efficaces
Choisir le bon dtype est le gain mémoire le plus facile : downcastez les entiers (int64->int8 économise 8x), category pour les chaînes à faible cardinalité (10 à 100x), 'string' au lieu d'object. Int64 nullable (I majuscule) gère les colonnes entières avec NaN — l'int64 ordinaire ne peut pas avoir de NaN, donc de telles colonnes passent en float64 par défaut. Le dtype Sparse aide pour les données majoritairement nulles.
# Downcast numerics
df["age"] = pd.to_numeric(df["age"], downcast="unsigned") # 0-255
df["score"] = pd.to_numeric(df["score"], downcast="float")
# Use category for low-cardinality strings
df["city"] = df["city"].astype("category")
# Use 'string' dtype instead of object
df["name"] = df["name"].astype("string")
# Use Nullable integers (Int64 with capital I) for ints with NaN
df["count"] = df["count"].astype("Int64") # supports NaN
# Sparse for mostly-zero data
s = pd.Series([0, 0, 0, 1, 0, 0]).astype("Sparse[int]")
# Compare memory
df["city"].astype("object").memory_usage(deep=True)
df["city"].astype("category").memory_usage(deep=True)Traitement par chunks
read_csv(chunksize=...) retourne un itérateur — chaque chunk est un DataFrame de tant de lignes, permettant de traiter des fichiers plus grands que la mémoire. Agrégez par chunk, puis combinez les résultats partiels. Pour SQL, chunksize utilise des curseurs côté serveur. C'est le moyen le plus simple de gérer des données à l'échelle du gigaoctet sans Spark ; pour le vrai big data, considérez Dask ou Polars.
# Process a large CSV in chunks (low memory)
chunk_iter = pd.read_csv("huge.csv", chunksize=100_000)
results = []
for chunk in chunk_iter:
# process each chunk (filter, aggregate, etc.)
result = chunk.groupby("city")["sales"].sum()
results.append(result)
# Combine chunk results
total = pd.concat(results).groupby(level=0).sum()
# Or use the iterator directly
for i, chunk in enumerate(pd.read_csv("huge.csv", chunksize=50000)):
chunk.to_parquet(f"part_{i:04d}.parquet")
# For SQL, use server-side cursors
chunks = pd.read_sql("SELECT * FROM big_table", engine,
chunksize=100000)Profiling et benchmarking
Benchmark toujours avant d'optimiser — %timeit compare rapidement les approches. ydata-profiling (anciennement pandas-profiling) génère un rapport HTML complet (stats, corrélations, manquants) — inestimable pour l'EDA. Surveillez SettingWithCopyWarning : il signale que votre affectation risque de ne pas persister, source courante de bugs silencieux. Réglez mode.chained_assignment='raise' pour les attraper en erreurs pendant le développement.
# Time an operation
%timeit df["a"] + df["b"]
# Line profiling (install line_profiler)
# %load_ext line_profiler
# %lprun -f my_function my_function(df)
# Memory profiling (install memory_profiler)
# %load_ext memory_profiler
# %memit df.groupby("city").sum()
# pandas profiling report (install ydata-profiling)
# from ydata_profiling import ProfileReport
# ProfileReport(df).to_file("report.html")
# Quick stats
df.info(memory_usage="deep")
df.describe(include="all")
# Find slow ops
import pandas as pd
pd.set_option("mode.chained_assignment", "warn") # catch copy bugsBases de données et SQL
Lire depuis SQL
Les engines SQLAlchemy gèrent le pooling de connexions et les différences de dialectes — utilisez-les plutôt que des connexions DBAPI brutes. Utilisez toujours des requêtes paramétrées (params=) pour les valeurs fournies par l'utilisateur afin de prévenir l'injection SQL. chunksize streame les grandes tables par lots. Pour des requêtes complexes, écrivez-les en SQL (la base est optimisée pour) et laissez pandas gérer le résultat.
from sqlalchemy import create_engine
import pandas as pd
# Create an engine (connection pool)
engine = create_engine("sqlite:///my.db")
engine = create_engine("postgresql://user:pass@host:5432/db")
engine = create_engine("mysql+pymysql://user:pass@host/db")
# Read a whole table
df = pd.read_sql("users", engine)
# Read a query
df = pd.read_sql("SELECT * FROM users WHERE age > 18", engine)
# Parameterized queries (safe from SQL injection)
df = pd.read_sql(
"SELECT * FROM users WHERE city = %s",
engine,
params=("NYC",),
)
# Chunked reads for large tables
for chunk in pd.read_sql("SELECT * FROM big", engine, chunksize=100000):
process(chunk)Écrire vers SQL
if_exists='replace' jette et recrée la table ; 'append' ajoute des lignes ; 'fail' (défaut) lève une erreur si la table existe. method='multi' batche les lignes en une seule instruction INSERT — bien plus rapide que le défaut d'une ligne par instruction. Pour de très grosses écritures, chunksize=10000 équilibre mémoire et aller-retours. Passez toujours index=False sauf si l'index est de vraies données.
# Write a DataFrame to a SQL table
df.to_sql("users", engine, if_exists="replace", index=False)
df.to_sql("users", engine, if_exists="append", index=False) # add rows
# Specify schema and dtype
from sqlalchemy.types import VARCHAR, INTEGER
df.to_sql("users", engine, if_exists="replace",
dtype={"name": VARCHAR(100), "age": INTEGER()})
# Write in chunks (for large DataFrames)
df.to_sql("users", engine, if_exists="append",
chunksize=10000, method="multi")
# method='multi' uses a single INSERT with multiple rows (faster)
# For PostgreSQL, method='multi' with chunksize ~10000 is optimal
# Don't write the index unless it's meaningful data
# index=False avoids a spurious 'index' columnOpérations façon SQL dans pandas
La plupart des opérations SQL se mappent à pandas : SELECT est la sélection de colonnes, WHERE le filtrage booléen, GROUP BY le groupby, JOIN le merge, UNION le concat+drop_duplicates, CASE WHEN le np.where. Connaître ces mappings permet de choisir le bon outil : SQL pour les jointures/agrégations complexes côté serveur (laisser la base optimiser), pandas pour l'analyse itérative et le tracé.
# SELECT cols
df[["name", "age"]]
# WHERE
df[df["age"] > 18]
# GROUP BY + aggregations
df.groupby("city")["age"].mean()
# ORDER BY
df.sort_values("age", ascending=False)
# LIMIT
df.head(10)
# DISTINCT
df["city"].unique()
df.drop_duplicates(subset=["city"])
# JOIN
pd.merge(df1, df2, on="id", how="inner")
# UNION
pd.concat([df1, df2]).drop_duplicates()
# CASE WHEN
np.where(df["age"] >= 18, "adult", "minor")
# HAVING
g = df.groupby("city").filter(lambda g: g["age"].mean() > 30)Exécution SQL avec text()
SQLAlchemy 2.0 exige text() pour les chaînes SQL brutes — une mesure de sécurité séparant le SQL de confiance des paramètres non fiables. engine.begin() ouvre une transaction qui commite automatiquement au succès et annule en cas d'exception — utilisez-le toujours pour les écritures. Liez les paramètres avec :nom et un dict params pour prévenir l'injection.
from sqlalchemy import text
# Use text() for explicit SQL (recommended over raw strings)
query = text("SELECT city, COUNT(*) as n FROM users GROUP BY city")
df = pd.read_sql(query, engine)
# Bind parameters safely
query = text("SELECT * FROM users WHERE age > :min_age AND city = :city")
df = pd.read_sql(query, engine,
params={"min_age": 18, "city": "NYC"})
# Execute DDL or DML (non-SELECT)
with engine.begin() as conn: # transaction
conn.execute(text("CREATE INDEX idx_city ON users(city)"))
conn.execute(text("DELETE FROM users WHERE id = :id"),
{"id": 999})Parquet vs CSV vs SQL
Parquet est le meilleur défaut de stockage — columnar, compressé et préservant les dtypes (le CSV perd les dtypes et force une réinférence à chaque chargement). Feather est le plus rapide pour les caches éphémères (format Apache Arrow, sans overhead de sérialisation). Pickle est pratique mais casse entre versions de Python/pandas. Utilisez SQL quand les données sont partagées et nécessitent une interrogation côté serveur.
# CSV: human-readable, slow, loses dtypes, large
df.to_csv("data.csv", index=False)
df = pd.read_csv("data.csv") # re-infers dtypes (slow, error-prone)
# Parquet: binary, fast, preserves dtypes, compressed (best for storage)
df.to_parquet("data.parquet")
df = pd.read_parquet("data.parquet") # dtypes preserved exactly
# Feather: fastest for short-lived storage (Apache Arrow)
df.to_feather("data.feather") # requires a RangeIndex
df = pd.read_feather("data.feather")
# Pickle: Python-specific, fast, but version-fragile
df.to_pickle("data.pkl")
df = pd.read_pickle("data.pkl")
# SQL: shared, queryable, but slower for bulk reads
df.to_sql("table", engine)
df = pd.read_sql("SELECT * FROM table", engine)
# Rule of thumb:
# - CSV for human exchange
# - Parquet for storage/archival (best default)
# - Feather for fast cache between Python processes
# - SQL for shared, queryable dataAnalyse de séries temporelles
Définir un DatetimeIndex
Le travail en séries temporelles avec pandas commence par un DatetimeIndex — mettez la colonne de dates en index et triez-la. Ensuite vous pouvez slicer avec des chaînes (df.loc['2024-06'] pour tout juin) et utiliser resample/rolling/shift. L'indexation par chaîne partielle est incroyablement pratique. Triez toujours l'index après l'avoir défini ; beaucoup de méthodes temporelles exigent des index triés.
# Ensure the date column is datetime, then set as index
df["date"] = pd.to_datetime(df["date"])
df = df.set_index("date").sort_index()
# Now you can slice by date strings
df.loc["2024"] # all of 2024
df.loc["2024-06"] # June 2024
df.loc["2024-06-01":"2024-06-15"] # date range (inclusive)
# Partial string indexing on Series
s = df["value"]
s["2024-06-15"]
# Filter with date strings
df[df.index >= "2024-01-01"]
# A DatetimeIndex unlocks resample, rolling, shift, etc.Resampling en pratique
resample est le groupby des séries temporelles — 'MS' (début de mois), 'ME' (fin de mois), 'QE' (fin de trimestre), 'W' (hebdomadaire). Combinez avec groupby pour un resampling par catégorie (ex. ventes hebdo par ville). asfreq ajoute des lignes pour les périodes de temps manquantes (remplies de NaN), utile pour exposer les trous des données irrégulières. L'agrégation last() prend la valeur finale de chaque période.
# Daily -> monthly revenue
daily.resample("MS").sum()
# Common frequencies:
# D=day, B=business day, W=weekly, MS=month start, ME=month end,
# QS=quarter start, YE=year end, H=hour, T/min=minute, S=second
# Multiple aggregations
daily.resample("ME").agg({"sales": "sum", "users": "mean"})
# Resample per group
df.groupby("city").resample("W")["sales"].sum()
# Handle missing periods (fill gaps in the timeline)
daily.asfreq("D") # add NaN rows for missing days
daily.asfreq("D").ffill() # fill them
# Quarter-end reporting
daily.resample("QE").last() # last value of each quarterFuseaux horaires
tz_localize assigne un fuseau à des timestamps naïfs (sans changer les valeurs) ; tz_convert convertit vers un autre fuseau (en changeant les valeurs affichées). Les deux se confondent facilement. Localisez d'abord, puis convertissez. Les transitions d'heure d'été créent des heures ambiguës/manquantes — gérez-les avec ambiguous='infer' (pour données triées) ou 'NaT'.
# Localize naive timestamps (assign a timezone)
s = pd.Series(pd.date_range("2024-01-01", periods=3, freq="H"))
s_localized = s.dt.tz_localize("UTC")
s_localized = s.dt.tz_localize("America/New_York")
# Convert between timezones
s_utc = s.dt.tz_localize("UTC")
s_est = s_utc.dt.tz_convert("US/Eastern")
s_hk = s_utc.dt.tz_convert("Asia/Hong_Kong")
# On a DatetimeIndex
idx = pd.date_range("2024-01-01", periods=3, freq="H", tz="UTC")
idx = idx.tz_convert("Asia/Shanghai")
# Remove timezone info
s_naive = s_utc.dt.tz_localize(None)
# Ambiguous times (DST fall-back): use 'infer' or 'NaT'
s.dt.tz_localize("US/Eastern", ambiguous="infer")Fonctions de fenêtre
Les fenêtres roulantes temporelles ('7D') gèrent correctement les données irrégulièrement échantillonnées, contrairement aux fenêtres par comptage (rolling(7)). ewm (pondération exponentielle) pondère davantage les observations récentes — courant en finance pour lisser. groupby + rolling calcule des fenêtres par groupe (ex. moyenne mobile 7 jours par action). reset_index nettoie le MultiIndex produit par groupby+rolling.
# Rolling window with time offset
ts.rolling("7D").mean() # 7-day window (handles irregular sampling)
# Rolling with custom function
ts.rolling("30D").apply(lambda x: np.quantile(x, 0.95))
# Expanding window (cumulative)
ts.expanding(min_periods=10).mean()
# Exponentially weighted
ts.ewm(span=20).mean() # like a 20-period EWMA
ts.ewm(halflife=10).mean()
# Window per group
df.groupby("city")["sales"].rolling("7D").mean().reset_index(level=0, drop=True)
# Compare rolling vs ewm for smoothing
# ewm weights recent points more — better for fast-changing seriesSaisonnalité et décomposition
seasonal_decompose découpe une série temporelle en composantes tendance, saisonnière et résiduelle — utile pour comprendre la structure et désaisonnaliser. period est la longueur du cycle (12 pour des données mensuelles avec saisonnalité annuelle). Le groupby sur index.month ou index.dayofweek révèle les patterns saisonniers. autocorrelation_plot montre la corrélation d'une série avec ses propres lags.
# Seasonal decomposition (needs statsmodels)
from statsmodels.tsa.seasonal import seasonal_decompose
# Additive model: y = trend + seasonal + residual
result = seasonal_decompose(ts, model="additive", period=12)
result.plot()
result.trend, result.seasonal, result.resid
# Multiplicative model: y = trend * seasonal * residual
result = seasonal_decompose(ts, model="multiplicative", period=12)
# Seasonal plots
ts.groupby(ts.index.month).mean() # average by month
ts.groupby(ts.index.dayofweek).mean() # by weekday
# Lag plot (autocorrelation check)
pd.plotting.lag_plot(ts, lag=1)
pd.plotting.autocorrelation_plot(ts)Visualisation
Tracés de base
Le tracé pandas est bâti sur matplotlib — l'accesseur .plot donne des graphiques rapides pour l'EDA. plot() passe par défaut en lignes (bon pour les séries temporelles), plot.bar() pour les comptages catégoriels, plot.hist() pour les distributions, plot.scatter() pour les relations. Pour des graphiques de qualité publication, passez à seaborn ou plotly, mais pour une inspection rapide en analyse, les tracés pandas sont imbattables.
import matplotlib.pyplot as plt
# Line plot (default for time series)
df["score"].plot()
df.plot(x="date", y="score")
# Bar chart
df["city"].value_counts().plot.bar()
df["city"].value_counts().plot.barh() # horizontal
# Histogram
df["age"].plot.hist(bins=20)
df[["age", "score"]].plot.hist(alpha=0.5, bins=20)
# Scatter
df.plot.scatter(x="age", y="score", c="pass", colormap="viridis")
# Box plot (per group)
df.boxplot(column="score", by="city")
# Area, density, pie
df["city"].value_counts().plot.pie(autopct="%1.1f%%")
df["score"].plot.kde() # kernel density estimate
plt.tight_layout(); plt.show()Tracer avec Seaborn
Seaborn excelle aux visualisations statistiques : violons, pair plots (matrice de nuages), heatmaps, droites de régression avec intervalles de confiance. Il gère élégamment le « grouper par couleur » (hue), verbeux en matplotlib. pairplot est le moyen le plus rapide de balayer toutes les relations par paires d'un jeu. Passez toujours le DataFrame et utilisez les noms de colonnes — l'API seaborn est conçue pour les données tidy.
import seaborn as sns
import matplotlib.pyplot as plt
# Statistical plots that pandas can't easily do
sns.histplot(df["score", kde=True])
sns.boxplot(data=df, x="city", y="score")
sns.violinplot(data=df, x="city", y="score")
# Relationships
sns.scatterplot(data=df, x="age", y="score", hue="city")
sns.pairplot(df[["age", "score", "pass"]], hue="pass")
# Correlation heatmap
sns.heatmap(df.corr(numeric_only=True), annot=True, cmap="coolwarm")
# Regression plot
sns.regplot(data=df, x="age", y="score")
# Facet grid (small multiples)
g = sns.FacetGrid(df, col="city", hue="pass")
g.map(sns.histplot, "score")
plt.tight_layout(); plt.show()Tracés interactifs avec Plotly
Plotly Express produit des graphiques interactifs (info-bulles au survol, zoom, pan) — parfait pour les tableaux de bord et partager des insights avec des parties prenantes non techniques. L'API rappelle seaborn (passez un DataFrame, mappez les colonnes aux esthétiques). write_html sauvegarde un fichier HTML interactif autonome. Pour la performance pure avec des millions de points, considérez datashader ; pour la finition, Plotly est excellent.
import plotly.express as px
# Interactive scatter (hover, zoom, pan)
fig = px.scatter(df, x="age", y="score", color="city",
hover_data=["name"], title="Score vs Age")
fig.show()
# Line chart
fig = px.line(df, x="date", y="score", color="city")
# Bar
fig = px.bar(df, x="city", y="score", color="pass", barmode="group")
# Histogram
fig = px.histogram(df, x="score", color="city", marginal="box")
# Faceted
fig = px.scatter(df, x="age", y="score", facet_col="city")
# 3D
fig = px.scatter_3d(df, x="age", y="score", z="hours", color="city")
# Save as HTML (interactive, no JS needed to view)
fig.write_html("plot.html")Subplots et mises en page
plt.subplots crée une grille d'axes ; passez chacun à ax= en traçant. sharex/sharey aligne les axes entre subplots (utile pour comparer des échelles). secondary_y trace une deuxième série sur un autre axe y (ex. prix et volume). tight_layout prévient le chevauchement des étiquettes. Pour des mises en page complexes, gridspec offre un contrôle plus fin des tailles.
import matplotlib.pyplot as plt
# pandas plot on specific axes
fig, axes = plt.subplots(2, 2, figsize=(12, 8))
df["age"].plot.hist(ax=axes[0, 0], title="Age")
df["score"].plot.hist(ax=axes[0, 1], title="Score")
df["city"].value_counts().plot.bar(ax=axes[1, 0], title="City")
df.plot.scatter(x="age", y="score", ax=axes[1, 1], title="Age vs Score")
plt.tight_layout(); plt.show()
# Shared x-axis
fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True, figsize=(10, 6))
df["score"].plot(ax=ax1)
df["age"].plot(ax=ax2)
# Secondary y-axis
ax = df["score"].plot()
df["age"].plot(ax=ax, secondary_y=True)
ax.set_ylabel("Score"); ax.right_ax.set_ylabel("Age")Styliser des DataFrames
Les objets Styler personnalisent le rendu des DataFrames en Jupyter et HTML — dégradés, barres-dans-cellules et formatage conditionnel rendent les tables lisibles d'un coup d'œil. format contrôle l'affichage des nombres (décimales, pourcentages). Le style se calcule à l'affichage (ne change pas les données) et s'exporte en HTML pour les rapports. applymap applique une fonction par cellule ; apply marche par ligne/colonne.
# Style a DataFrame for HTML/Jupyter display
styled = df.style.highlight_max(color="lightgreen")
styled = df.style.highlight_min(color="lightcoral")
styled = df.style.background_gradient(cmap="Blues", subset=["score"])
# Bar charts inside cells
df.style.bar(subset=["score"], color="#5fba7d")
# Format numbers
df.style.format({"score": "{:.2f}", "age": "{:.0f}"})
df.style.format({"score": "{:.2%}"}) # as percentage
# Conditional formatting
def color_neg_red(val):
color = "red" if val < 0 else "black"
return f"color: {color}"
df.style.applymap(color_neg_red, subset=["change"])
# Combine styles
(df.style
.format({"score": "{:.2f}"})
.background_gradient(cmap="RdYlGn", subset=["score"])
.set_caption("Student Scores"))
# Export to HTML
styled.to_html("table.html")Export et formatage
Formater l'affichage
Les options d'affichage contrôlent l'impression de pandas dans la console/Jupyter — augmentez max_rows/max_columns pour voir plus, réglez float_format pour des décimales cohérentes. option_context est un gestionnaire de contexte qui change temporairement les réglages (les restaure ensuite), parfait pour une inspection ponctuelle sans changer globalement votre environnement. Mettez les réglages usuels dans un script de démarrage.
# Global display options
pd.set_option("display.max_rows", 100)
pd.set_option("display.max_columns", 50)
pd.set_option("display.width", 1000)
pd.set_option("display.max_colwidth", 100)
pd.set_option("display.float_format", "{:.2f}".format)
# Reset to defaults
pd.reset_option("display.max_rows")
# Float formatting only for one operation
with pd.option_context("display.float_format", "{:.2f}".format):
print(df)
# Temporarily show more rows
with pd.option_context("display.max_rows", None):
print(df.head(100))Exporter vers plusieurs formats
to_markdown produit des tables prêtes pour GitHub pour les README et docs. to_html s'intègre aux pages web ; to_latex pour les articles académiques. to_dict(orient='records') convertit en liste de dicts (façon JSON) pour les API. Chaque format a des options — explorez la doc. Pour Excel, engine='openpyxl' supporte le formatage de formules, formats conditionnels et graphiques.
# CSV
df.to_csv("out.csv", index=False)
df.to_csv("out.tsv", sep="\t", index=False)
# Excel with formatting (needs openpyxl)
with pd.ExcelWriter("out.xlsx", engine="openpyxl") as w:
df.to_excel(w, sheet_name="data", index=False)
summary.to_excel(w, sheet_name="summary")
# Markdown (great for docs/reports)
print(df.to_markdown(index=False))
df.to_markdown("table.md", index=False)
# HTML
df.to_html("table.html", index=False, classes="table")
# LaTeX
print(df.to_latex(index=False, caption="Results"))
# JSON
df.to_json("out.json", orient="records", indent=2, date_format="iso")
# Dict / records
df.to_dict(orient="records") # list of dicts
df.to_dict(orient="list") # dict of listsPresse-papiers et chaînes
to_clipboard(excel=True) copie une table séparée par tabulations qui se colle directement dans Excel/Google Sheets — incroyablement pratique pour déplacer des données entre Python et tableurs. read_clipboard est l'inverse : copiez une table depuis une page web ou un tableur, puis lisez-la dans un DataFrame sans fichier. to_string donne une représentation texte simple pour les logs.
# Copy a DataFrame to the clipboard (paste into Excel/Sheets)
df.to_clipboard(index=False, excel=True)
# Read from clipboard (paste a table from a spreadsheet/webpage)
df = pd.read_clipboard()
# Convert to string with formatting
print(df.to_string(index=False))
print(df.to_string(max_rows=10))
# Pretty-print in Jupyter
from IPython.display import display
display(df.head(10))
# Render a Series as a string
print(s.to_string())
# Quick peek at value (useful in debugging)
df.head().to_dict("records")Formatage Excel
openpyxl permet de styliser la sortie Excel par programmation — en-têtes gras, largeurs de colonnes, figeage de volets, formatage conditionnel, formules. Accédez au workbook via writer.book et aux feuilles via writer.sheets après écriture. L'auto-dimensionnement des colonnes exige un calcul manuel de largeur (Excel ne le fait pas automatiquement à l'écriture). Les volets figés gardent les en-têtes visibles au défilement.
from openpyxl.styles import Font, PatternFill
from openpyxl.utils import get_column_letter
# Write with conditional formatting
with pd.ExcelWriter("report.xlsx", engine="openpyxl") as writer:
df.to_excel(writer, sheet_name="Data", index=False)
# Access the workbook to style
wb = writer.book
ws = writer.sheets["Data"]
# Bold header
for cell in ws[1]:
cell.font = Font(bold=True, color="FFFFFF")
cell.fill = PatternFill("solid", fgColor="4472C4")
# Auto-size columns
for col in ws.columns:
max_len = max(len(str(c.value)) for c in col if c.value is not None)
ws.column_dimensions[get_column_letter(col[0].column)].width = max_len + 2
# Freeze header row
ws.freeze_panes = "A2"Notebooks reproductibles
Standardiser les en-têtes de notebook (imports, options, graine, vérification de version) rend les analyses reproductibles et économise du débogage. pd.show_versions() rapporte les versions pandas/numpy/python — collez-le dans les rapports de bug. Un helper check_df qui imprime shape, dtypes, head et manquants standardise le premier regard sur tout nouveau jeu de données. Supprimez seulement des catégories d'avertissement précises, jamais tout.
# At the top of every analysis notebook
import pandas as pd
import numpy as np
pd.set_option("display.max_columns", None)
pd.set_option("display.float_format", "{:.4f}".format)
# Set a seed for reproducibility
np.random.seed(42)
# Show versions for reproducibility
pd.show_versions()
# Common imports grouped
import matplotlib.pyplot as plt
import seaborn as sns
sns.set_theme(style="whitegrid")
# Suppress chained-assignment warnings cleanly
import warnings
warnings.filterwarnings("ignore", category=FutureWarning)
# Validate data on load
def check_df(df, name="df"):
print(f"=== {name} ===")
print(f"Shape: {df.shape}")
print(df.dtypes)
print(df.head())
print(df.isnull().sum())
check_df(df)Pièges courants
SettingWithCopyWarning
SettingWithCopyWarning signifie que pandas vous prévient que votre affectation pourrait ne pas persister — l'indexation chaînée (df[mask]['col']=x) peut modifier une copie temporaire. Le correctif est toujours .loc[row_mask, col_name] = value pour l'affectation conditionnelle. Quand vous sous-ensemblez puis modifiez, utilisez .copy() pour être explicite. En développement, réglez l'avertissement à 'raise' pour attraper ces bugs en erreurs.
# BAD: chained indexing — may not modify df
df[df["age"] > 30]["city"] = "NYC" # SettingWithCopyWarning
# GOOD: single .loc assignment
df.loc[df["age"] > 30, "city"] = "NYC"
# When subsetting, be explicit about copy vs view
subset = df[df["age"] > 30].copy() # explicit copy
subset["city"] = "NYC" # safe — modifies subset only
# Detect the warning
pd.set_option("mode.chained_assignment", "warn") # default
pd.set_option("mode.chained_assignment", "raise") # error (dev mode)
pd.set_option("mode.chained_assignment", None) # suppress
# Rule: if you're going to modify, use .loc or .copy() firstSurprises d'alignement d'index
L'alignement d'index est le superpouvoir de pandas et son plus grand piège. Quand vous affectez une Series à une colonne, pandas matche par index, pas par position — donc si votre Series a un index différent, vous obtenez des NaN ou de mauvaises valeurs. Utilisez .values pour affecter par position, ou reset_index pour aligner les index d'abord. Ce bug est silencieux (aucun avertissement) et figure parmi les erreurs pandas les plus fréquentes.
# Adding Series aligns on index — NaN where they don't match
s1 = pd.Series([1, 2, 3], index=["a", "b", "c"])
s2 = pd.Series([10, 20, 30], index=["b", "c", "d"])
s1 + s2
# a NaN
# b 12.0
# c 33.0
# d NaN
# When assigning a Series to a column, alignment happens by index
df["new"] = some_series # rows matched by INDEX, not position!
# To force positional alignment, use .values
df["new"] = some_series.values # assign by position
# After sorting/resetting, indexes may not match
df1 = df.sort_values("age")
df1["rank"] = range(len(df1)) # WRONG if index isn't 0..n-1
df1["rank"] = np.arange(len(df1)) # also WRONG — aligns on index
df1["rank"] = pd.Series(range(len(df1)), index=df1.index) # correct
# Or simply:
df1 = df1.reset_index(drop=True)
df1["rank"] = range(len(df1))inplace vs réaffectation
La communauté pandas s'éloigne d'inplace=True vers la réaffectation fonctionnelle — elle permet l'enchaînement de méthodes (pipelines lisibles) et est plus prévisible. inplace économise rarement la mémoire (pandas copie souvent quand même). Le style chaîné (df.methode().methode().methode()) se lit de haut en bas et est l'idiome moderne. N'utilisez inplace qu'après avoir mesuré un réel bénéfice mémoire.
# Two equivalent styles:
df = df.sort_values("age") # reassign (returns new df)
df.sort_values("age", inplace=True) # modify in place
# Most pandas methods return a new object (functional style).
# inplace=True modifies the object — but:
# 1. It's being deprecated in some methods
# 2. It can prevent method chaining
# 3. It sometimes still makes a copy under the hood
# Prefer functional style for chaining:
(df
.sort_values("age")
.reset_index(drop=True)
.rename(columns={"old": "new"}))
# inplace is fine for memory savings on huge DataFrames,
# but rarely matters otherwise.Arguments par défaut mutables
Faire croître un DataFrame ligne par ligne (df.append ou pd.concat dans une boucle) est O(n²) — chaque append copie toute la frame. Collectez toujours les lignes dans une liste, puis construisez le DataFrame une fois. S'applique aussi aux arguments par défaut mutables de Python (listes, dicts) — ils sont partagés entre appels, un bug Python classique. Utilisez None comme sentinelle et initialisez dans la fonction.
# BAD: default mutable args are shared across calls
def add_row(df, new_data=[]): # NEVER use mutable defaults
new_data.append(1)
return df
# GOOD: use None
def add_row(df, new_data=None):
if new_data is None:
new_data = []
...
# Building a DataFrame row by row (SLOW — anti-pattern)
df = pd.DataFrame()
for item in items:
df = pd.append(df, item) # deprecation + O(n^2)
# GOOD: build a list of records, then construct once
records = []
for item in items:
records.append({"name": item.name, "value": item.value})
df = pd.DataFrame(records)
# Or use from_records
df = pd.DataFrame.from_records(items, columns=["name", "value"])Propagation des NaN
NaN ne s'égalise jamais lui-même (NaN == NaN est False) — utilisez isna() pour détecter les manquants, jamais ==. Par défaut, les agrégations sautent NaN (sum, mean), mais skipna=False le propage. Les colonnes entières avec du NaN sont promues en float64 (les ints numpy ne peuvent pas tenir NaN) ; utilisez le dtype nullable 'Int64' (I majuscule) pour garder des entiers avec NaN.
# NaN propagates through most operations
np.nan + 1 # nan
np.nan > 0 # False
pd.Series([1, 2, np.nan]).sum() # 3.0 (skips NaN by default)
pd.Series([1, 2, np.nan]).mean() # 1.5
# Some operations DON'T skip NaN
pd.Series([1, 2, np.nan]).sum(skipna=False) # nan
# Comparisons with NaN are always False
pd.Series([1, np.nan]) == pd.Series([1, np.nan])
# [True, False] — NaN != NaN!
# Check for NaN correctly
s.isna() # True for NaN
s.isnull() # alias
s == np.nan # WRONG — always False!
s.fillna(0) == 0 # check after filling
# Integer columns with NaN become float
s = pd.Series([1, 2, None]) # becomes float64: [1.0, 2.0, NaN]
# Use nullable Int64 to keep integer with NaN
s = pd.Series([1, 2, None], dtype="Int64")Motifs du monde réel
Gabarit d'EDA
Une fonction d'EDA standardisée garantit que vous vérifiez toujours shape, dtypes, manquants, distributions et doublons avant la modélisation. Attraper tôt un mauvais dtype (nombres en chaînes), une manquance cachée (valeurs sentinelles comme -999) ou des doublons inattendus économise des heures de débogage en aval. Lancez cela sur chaque nouveau jeu de données en première étape.
import pandas as pd
import numpy as np
def eda(df, name="df"):
print(f"=== {name} ===")
print(f"Shape: {df.shape}")
print("\n--- dtypes ---")
print(df.dtypes)
print("\n--- head ---")
print(df.head())
print("\n--- missing ---")
print(df.isnull().sum())
print("\n--- numeric summary ---")
print(df.describe())
print("\n--- categorical summary ---")
print(df.describe(include="object"))
print("\n--- duplicates ---")
print(f"{df.duplicated().sum()} duplicate rows")
# Usage
eda(df)
# Per-column deep dive
for col in df.columns:
print(f"\n### {col}")
print(f"dtype: {df[col].dtype}")
print(f"unique: {df[col].nunique()}")
if df[col].dtype == "object":
print(df[col].value_counts().head(10))
else:
print(df[col].describe())Bâtir un pipeline de nettoyage
L'enchaînement de méthodes (le pipeline .pipe / .assign / .dropna) rend le nettoyage reproductible et testable — chaque étape est une fonction pure, facile à inspecter à tout moment. Renommez les colonnes en snake_case tôt pour éviter les maux de guillemets. Les assertions à la fin attrapent les échecs silencieux (ex. toutes les dates échouant au parsing). Enveloppez le pipeline dans une fonction pour le réutiliser sur de nouveaux lots de données.
def clean(df):
"""A reusable cleaning pipeline."""
return (df
# Standardize column names
.rename(columns=lambda c: c.strip().lower().replace(" ", "_"))
# Drop empty columns
.dropna(axis=1, how="all")
# Parse dates
.assign(date=lambda d: pd.to_datetime(d["date"], errors="coerce"))
# Numeric coercion
.assign(amount=lambda d: pd.to_numeric(d["amount"], errors="coerce"))
# Fill missing
.fillna({"category": "unknown"})
# Dedupe
.drop_duplicates()
# Reset index
.reset_index(drop=True)
)
df_clean = clean(df_raw)
# Verify
assert df_clean["date"].notnull().all(), "Some dates failed to parse"
assert len(df_clean) <= len(df_raw), "Cleaning should not add rows"Analyse par table pivot
pivot_table est le couteau suisse de l'analyste — combinez-le à margins=True pour les totaux et à une heatmap pour un insight immédiat. L'inverse (melt) ramène au format long tidy pour un traitement supplémentaire. Le motif « top N par groupe » (tri puis groupby head) est extrêmement courant dans le reporting d'affaires.
# Multi-dimensional analysis in one shot
pivot = pd.pivot_table(
df,
values="revenue",
index=["region", "product"],
columns=["quarter"],
aggfunc="sum",
fill_value=0,
margins=True, # add row/column totals
margins_name="Total",
)
# Heatmap of the pivot
import seaborn as sns
sns.heatmap(pivot, annot=True, fmt=".0f", cmap="YlGnBu")
# Convert back to long
long = pivot.reset_index().melt(
id_vars=["region", "product"],
var_name="quarter",
value_name="revenue",
)
# Top product per region
top = (df
.groupby(["region", "product"])["revenue"].sum()
.reset_index()
.sort_values("revenue", ascending=False)
.groupby("region").head(1))Feature engineering pour le ML
Le feature engineering est là où la connaissance métier rencontre pandas : agrégations par entité (dépense vie entière du client), ratios (dépense par mois), caractéristiques temporelles (ancienneté), catégorielles binées. Fusionnez les caractéristiques agrégées sur la frame principale par ID d'entité. get_dummies encode en one-hot pour les modèles linéaires. Enveloppez dans une fonction pour appliquer les mêmes transformations à l'entraînement et à l'inférence.
def add_features(df):
"""Add features for a churn model."""
out = df.copy()
# Time-based features
out["tenure_years"] = out["tenure_months"] / 12
out["is_new_customer"] = (out["tenure_months"] < 12).astype(int)
# Aggregations per customer (need transaction history)
# txns is a separate transactions DataFrame
agg = txns.groupby("customer_id").agg(
total_spend=("amount", "sum"),
txn_count=("amount", "count"),
avg_txn=("amount", "mean"),
last_txn_date=("date", "max"),
).reset_index()
out = out.merge(agg, on="customer_id", how="left")
# Ratio features
out["spend_per_month"] = out["total_spend"] / out["tenure_months"]
# Binning
out["age_group"] = pd.cut(out["age"], bins=[0,25,40,60,100],
labels=["young","adult","mid","senior"])
# Encode categoricals
out = pd.get_dummies(out, columns=["age_group", "plan"], drop_first=True)
return out
df_ml = add_features(df)Lire des CSV désordonnés
Les CSV réels sont désordonnés : mauvais encodages (essayez latin-1 ou cp1252 quand utf-8 échoue), virgules décimales européennes (decimal=','), lignes de métadonnées avant l'en-tête (skiprows), valeurs nulles sentinelles (na_values). usecols ne charge que les colonnes nécessaires, économisant la mémoire sur les fichiers larges. Inspectez toujours les premières lignes d'un CSV inconnu avec un éditeur de texte avant de le lire aveuglément.
# Common CSV issues and fixes
# Bad encoding
df = pd.read_csv("data.csv", encoding="latin-1") # or utf-8-sig, cp1252
# Wrong separator
df = pd.read_csv("data.tsv", sep="\t")
df = pd.read_csv("data.csv", sep=";", decimal=",") # European format
# Skip metadata rows at the top
df = pd.read_csv("data.csv", skiprows=3)
# Multiple header rows
df = pd.read_csv("data.csv", header=[0, 1])
# Custom NA values
df = pd.read_csv("data.csv", na_values=["?", "N/A", "NULL", -999])
# Parse dates with multiple formats
df = pd.read_csv("data.csv", parse_dates=["date"], dayfirst=True)
# Only load specific columns (saves memory)
df = pd.read_csv("data.csv", usecols=["id", "date", "amount"])
# Handle quoted fields with commas/newlines
df = pd.read_csv("data.csv", quotechar='"', escapechar="\\")Opérations de fenêtres en profondeur
Rolling avec fonctions personnalisées
Les agrégations rolling intégrées (mean, std, median, quantile) sont optimisées en C et rapides. Les fonctions apply personnalisées sont flexibles mais plus lentes (callback Python par fenêtre). Pour des moyennes pondérées ou régressions, apply avec des opérations numpy à l'intérieur. raw=True (défaut) passe des tableaux numpy (plus rapide) ; raw=False passe des Series si vous avez besoin de l'index.
s = pd.Series(range(20), dtype=float)
# Built-in aggregations (fast, C-optimized)
s.rolling(5).mean()
s.rolling(5).std()
s.rolling(5).median()
s.rolling(5).quantile(0.75)
s.rolling(5).sum()
# Custom function (slower, but flexible)
s.rolling(5).apply(lambda x: x.max() - x.min())
# Weighted rolling average
weights = np.array([0.1, 0.2, 0.3, 0.25, 0.15])
s.rolling(5).apply(lambda x: np.dot(x, weights))
# Rolling regression (slope over window)
def slope(x):
return np.polyfit(range(len(x)), x, 1)[0]
s.rolling(10).apply(slope)
# raw=False passes Series (with index) to the function
s.rolling(5).apply(lambda x: x.iloc[-1] / x.iloc[0], raw=False)Fenêtres temporelles
Les fenêtres temporelles ('7D') gèrent correctement les données irrégulièrement échantillonnées — elles incluent tous les points dans la plage de temps, pas un nombre fixe de lignes. Essentiel pour les séries temporelles réelles avec trous. center=True centre la fenêtre sur le point courant (utile pour lisser). closed='left' exclut le point courant (éviter les fuites quand on calcule des caractéristiques depuis le « futur »).
# Row-count vs time-based windows
ts = pd.Series(range(100), index=pd.date_range("2024-01-01", periods=100, freq="D"))
# Row-count: exactly 7 rows (may span more than 7 days if data is irregular)
ts.rolling(7).mean()
# Time-based: all rows within the last 7 days (handles gaps)
ts.rolling("7D").mean()
# Time-based is essential for irregular time series
irregular = pd.Series([1, 2, 3],
index=pd.to_datetime(["2024-01-01", "2024-01-05", "2024-01-15"]))
irregular.rolling("7D").sum() # 1, 3, 3 (third is just itself, no neighbors in 7d)
# Center the window
ts.rolling("7D", center=True).mean() # window centered on current point
# Closed controls which endpoints are included
ts.rolling("7D", closed="left").mean() # exclude current pointExpanding et EWMA
expanding calcule des statistiques sur toutes les données depuis le début jusqu'au point courant — utile pour les benchmarks cumulatifs et les extrêmes courants. ewm (pondération exponentielle) pondère davantage les observations récentes — le standard du lissage financier (EWMA). span est intuitif (proche d'une moyenne mobile sur N périodes) ; alpha est le facteur de lissage brut. L'EWMA réagit plus vite qu'une moyenne mobile simple aux changements récents.
s = pd.Series([1, 2, 3, 4, 5, 6, 7, 8], dtype=float)
# Expanding: window grows from the start
s.expanding(min_periods=2).mean() # cumulative mean
s.expanding().max() # running maximum
s.expanding().std()
# Exponentially weighted moving average
s.ewm(span=5).mean() # span=N similar to N-period moving avg
s.ewm(alpha=0.3).mean() # alpha = smoothing factor (0-1)
s.ewm(halflife=3).mean() # halflife: weight halves every N periods
# EWMA volatility (finance)
returns.ewm(span=20).std() # 20-period EWMA volatility
# Relationship: span = (2/alpha) - 1
# Higher alpha/span = more responsive to recent dataOpérations cumulatives
cumsum, cummax, cummin, cumprod sont des méthodes cumulatives directes — plus rapides que expanding pour les cas courants. Combinées à groupby, elles calculent des totaux courants par groupe (ex. solde courant par client). L'astuce du cumsum sur une condition booléenne crée des identifiants de session/segment — utile pour découper des séries temporelles en épisodes entre événements.
s = pd.Series([1, 2, 3, 4, 5])
# Direct cumulative methods (faster than expanding)
s.cumsum() # [1, 3, 6, 10, 15]
s.cummax() # [1, 2, 3, 4, 5]
s.cummin() # [1, 1, 1, 1, 1]
s.cumprod() # [1, 2, 6, 24, 120]
# Cumulative within groups
df["running_total"] = df.groupby("customer")["amount"].cumsum()
df["rank_in_group"] = df.groupby("customer")["amount"].rank(ascending=False)
df["pct_of_total"] = df["amount"] / df.groupby("customer")["amount"].transform("sum")
# Cumulative count of condition
df["days_since_event"] = (df["event"] == 1).cumsum()
df["event_number"] = df.groupby(
(df["event"] == 1).cumsum()
).cumcount()Rolling apply à sorties multiples
Pour plusieurs statistiques roulantes, calculer chacune séparément (window.mean(), window.std()) est plus clair et souvent plus rapide qu'un seul apply retournant une Series. Les quantiles roulants permettent de bâtir des bandes de confiance (q10/q90) autour d'une tendance. Créer un DataFrame de stats roulantes est le motif typique avant tracé ou alimentation d'un modèle ML.
# Apply a function returning multiple values per window
def rolling_stats(x):
return pd.Series({
"mean": x.mean(),
"std": x.std(),
"min": x.min(),
"max": x.max(),
})
stats = s.rolling(10).apply(rolling_stats, raw=False)
# This creates a DataFrame with one row per window, columns = the Series index
# Alternative: compute each separately (often clearer)
window = s.rolling(10)
result = pd.DataFrame({
"mean": window.mean(),
"std": window.std(),
"min": window.min(),
"max": window.max(),
})
# Rolling quantiles
q = pd.DataFrame({
"q10": s.rolling(20).quantile(0.1),
"q50": s.rolling(20).quantile(0.5),
"q90": s.rolling(20).quantile(0.9),
})Snippets Pandas associés
Copy-paste ready code for common tasks.
DataFrame Creation
Build DataFrames from dicts, lists, and files.
Indexing and Selecting
Select rows and columns with loc, iloc, and masks.
GroupBy Operations
Split, aggregate, and transform with groupby.
Merge and Join
Combine frames with merge and concat.
Pivot Tables
Reshape data with pivot, melt, and pivot_table.
Time Series
Resample, shift, and roll windows over time data.
Missing Data
Detect, fill, and drop NaN values.
I/O Operations
Read and write CSV, Excel, Parquet, and SQL.
Was this helpful?