Power Query — Guide complet

01 — Fondamentaux

C'est quoi Power Query ?

🔌

Power Query est l'outil de transformation de données intégré à Excel (depuis 2016, onglet Données → Obtenir et transformer). Il permet d'importer des données de n'importe quelle source, de les nettoyer et de les remodeler — sans écrire de macros. Chaque transformation est enregistrée sous forme d'étapes rejouables en langage M.

⚡

Le grand avantage : une fois la requête construite, un simple clic sur Actualiser retraite toutes les données. Parfait pour les rapports récurrents alimentés par des exports CSV, bases de données ou APIs.

Avant Power Query	Avec Power Query
Nettoyage manuel chaque mois	Actualisation en 1 clic
Macros VBA fragiles	Interface visuelle + M auditable
Copier/coller entre fichiers	Connexion directe aux sources
Formules RECHERCHEV imbriquées	Fusion de tables propre
CSV mal formatés = travail manuel	Nettoyage automatisé & répété

📍

Dans Excel : Données → Obtenir des données pour démarrer une nouvelle requête. Données → Requêtes et connexions pour voir et gérer les requêtes existantes.

02

Connecter des sources

📄

Fichier Excel

.xlsx, .xlsb, .xlsm

📋

CSV / Texte

Délimiteur auto-détecté

🗄️

SQL Server

Requête SQL native

🌐

Web / HTML

Tableau d'une page web

🔗

API / JSON

REST via Web.Contents

📁

Dossier

Combine N fichiers

☁️

SharePoint

Listes & fichiers

📊

Access / OData

Base de données locale

Bonnes pratiques — sources

// Nommer les requêtes clairement
// ✓ Ventes_2025_Brut, Clients_Ref
// ✗ Requête1, Table2

// Toujours utiliser un Tableau structuré (Ctrl+T)
// comme source interne — la plage s'ajuste automatiquement

// Pour les CSV : spécifier le délimiteur et l'encodage
// Données → Obtenir des données → Fichier → CSV

🔒

Pour les connexions SQL ou SharePoint, les informations d'identification sont mémorisées dans Excel. Menu Données → Requêtes et connexions → Paramètres de la source de données pour les gérer.

03

L'éditeur de requêtes

🖥️

L'éditeur Power Query s'ouvre dans une fenêtre séparée. Il comporte 4 zones clés : le volet de requêtes (liste à gauche), l'aperçu des données (centre), les étapes appliquées (droite) et la barre de formule M (en haut).

Action	Où
Renommer une requête	Clic droit → Renommer
Voir le code M complet	Accueil → Éditeur avancé
Modifier une étape	Clic sur l'étape → modifier la barre M
Supprimer une étape	Clic droit → Supprimer
Réorganiser les étapes	Glisser-déposer dans le volet étapes
Charger dans Excel	Accueil → Fermer et charger

⚙️

Fermer et charger dans… (pas juste "Fermer et charger") permet de choisir : charger dans une feuille, comme connexion seule (pour les requêtes intermédiaires), ou dans le modèle de données PowerPivot.

⚠️

Les requêtes intermédiaires (nettoyage, jointures) doivent être chargées en connexion seulement — elles ne créent pas de feuille, mais restent disponibles pour d'autres requêtes.

04

Étapes appliquées

Chaque transformation crée une étape dans le volet droite. Chaque étape est une ligne de code M. L'ensemble forme un pipeline reproductible.

1SourceCsv.Document(...)

↓

2En-têtes promusTable.PromoteHeaders

↓

3Types modifiésTable.TransformColumnTypes

↓

4Lignes filtréesTable.SelectRows

↓

5Colonne ajoutéeTable.AddColumn

↓

6RésultatTable chargée dans Excel

Éditeur avancé — exemple complet

let

Source = Csv.Document(

File.Contents("C:\data\ventes.csv"),

[Delimiter=";", Encoding=65001]),

Entetes = Table.PromoteHeaders(Source),

Types = Table.TransformColumnTypes(Entetes, {

{"Date", type date}, {"Montant", type number}}),

Filtre = Table.SelectRows(Types,

each [Montant] > 0)

in

Filtre

05 — Transformations

Nettoyage des données

Problème	Solution Power Query
Espaces en trop	Transformer → Découper (Trim)
Casse incohérente	Transformer → Mettre en majuscules/minuscules
Lignes vides	Accueil → Supprimer les lignes → Supprimer les lignes vides
Doublons	Accueil → Supprimer les lignes → Supprimer les doublons
Type incorrect	Clic sur l'icône de type dans l'en-tête → choisir le bon type
Valeurs nulles	Filtre sur la colonne → décocher "null"
Erreurs dans une colonne	Clic droit sur l'en-tête → Supprimer les erreurs
Colonne Date mal formatée	Clic droit → Modifier le type → Utiliser les paramètres régionaux

Nettoyage en M

// Trim + Nettoyer (caractères invisibles)

Table.TransformColumns(Source, {

{"Nom", each Text.Trim(Text.Clean(_))}})

// Remplacer des valeurs

Table.ReplaceValue(Source,

"N/A", null, Replacer.ReplaceValue, {"Statut"})

// Supprimer les lignes où Montant est null ou négatif

Table.SelectRows(Source,

each [Montant] <> null and [Montant] >= 0)

// Garder seulement certaines colonnes

Table.SelectColumns(Source,

{"Date", "Client", "Montant"})

06

Colonnes calculées

Ajouter une colonne — interface

// Onglet "Ajouter une colonne" dans l'éditeur
// → Colonne personnalisée → saisir une formule M
// → Colonne à partir d'exemples → taper un exemple, PQ devine

// Exemples de formules dans l'interface
[Prix] * [Quantité]            // multiplication
[Prénom] & " " & [Nom]         // concaténation
Date.Year([Date])              // extraire l'année
if [CA] > 10000 then "A" else "B"  // condition

Table.AddColumn en M

// Ajouter une colonne Marge

Table.AddColumn(Source, "Marge",

each [CA] - [Coût], type number)

// Ajouter une colonne conditionnelle

Table.AddColumn(Source, "Segment",

each if [CA] > 50000 then "Grand"

else if [CA] > 10000 then "Moyen"

else "Petit")

// Fractionner une colonne Nom Complet

Table.SplitColumn(Source, "NomComplet",

Splitter.SplitTextByDelimiter(" "),

{"Prénom", "Nom"})

07

Grouper & agréger

📊

Grouper par est l'équivalent Power Query d'un tableau croisé dynamique ou d'un GROUP BY SQL. Il regroupe les lignes selon une ou plusieurs colonnes et calcule des agrégats.

Interface : Accueil → Grouper par

// Grouper les ventes par Région et calculer le total
// Grouper par : Région
// Nouvelle colonne : Total CA → Opération : Somme → Colonne : CA

// Résultat :
// Région | Total CA
// Paris  | 125 000
// Lyon   | 78 500

Table.Group en M

// Grouper par Région + calculer plusieurs agrégats

Table.Group(Source, {"Région"}, {

{"Total CA", each List.Sum([CA]), type number},

{"Nb Ventes", each Table.RowCount(_), Int64.Type},

{"CA Max", each List.Max([CA]), type number},

{"CA Moyen", each List.Average([CA]), type number}})

// Grouper sur plusieurs colonnes

Table.Group(Source, {"Région", "Année"}, {

{"CA", each List.Sum([CA])}})

08

Pivoter / Dépivoter

🔄

Dépivoter transforme des colonnes en lignes (format large → long). C'est l'opération la plus fréquente pour normaliser des données Excel mal structurées avant analyse.

Avant / Après dépivoter

// Avant (format large) :
// Produit | Jan  | Fév  | Mar
// A       | 100  | 120  | 90
// B       | 200  | 180  | 220

// Après dépivoter les colonnes Jan/Fév/Mar :
// Produit | Mois | Valeur
// A       | Jan  | 100
// A       | Fév  | 120
// A       | Mar  | 90
// B       | Jan  | 200
// ...

// Interface : sélectionner Jan/Fév/Mar → clic droit
// → Dépivoter les colonnes

Pivoter / Dépivoter en M

// Dépivoter des colonnes spécifiques

Table.UnpivotOtherColumns(Source,

{"Produit"}, // colonnes à garder

"Mois", "Valeur") // noms des nouvelles colonnes

// Pivoter (long → large)

Table.Pivot(Source,

List.Distinct(Source[Mois]), // valeurs → colonnes

"Mois", // colonne source

"Valeur", // colonne des valeurs

List.Sum) // agrégat en cas de doublons

09 — Combiner des sources

Fusionner des requêtes (JOIN)

La fusion est l'équivalent d'un JOIN SQL — elle combine deux tables sur une colonne commune.

Gauche externe

🟢⚪

Toutes les lignes de gauche + correspondances de droite. Le plus courant.

Interne

🟢🟢

Seulement les lignes présentes dans les deux tables.

Gauche anti

🟢✖

Lignes de gauche sans correspondance à droite. Trouver les absents.

Complète externe

🟢🟢🟢

Toutes les lignes des deux tables, avec nulls si pas de correspondance.

📌

Accueil → Fusionner des requêtes. Sélectionner la colonne clé dans chaque table (Ctrl+clic pour plusieurs colonnes). Choisir le type de jointure. Une colonne imbriquée apparaît — cliquer sur l'icône ⇢ pour développer les colonnes souhaitées.

Table.NestedJoin

// Joindre Ventes + Clients sur ID_Client

Jointure = Table.NestedJoin(

Ventes, {"ID_Client"},

Clients, {"ID"},

"Clients_Info",

JoinKind.LeftOuter),

// Développer les colonnes souhaitées

Résultat = Table.ExpandTableColumn(

Jointure, "Clients_Info",

{"Nom", "Région"})

10

Ajouter des requêtes (UNION)

📎

Ajouter des requêtes empile des tables ayant la même structure — l'équivalent d'un UNION ALL SQL. Parfait pour combiner des exports mensuels ou des fichiers d'agences différentes.

Interface

// Accueil → Ajouter des requêtes
// → Deux tables (simple) ou Trois tables et plus

// Les colonnes sont alignées par nom — pas par position
// Si une colonne manque dans une table → valeurs null

Table.Combine

// Combiner 3 requêtes

Table.Combine({Ventes_2023, Ventes_2024, Ventes_2025})

// Ajouter une colonne source pour tracer l'origine

let

T1 = Table.AddColumn(Ventes_2023, "Année", each 2023),

T2 = Table.AddColumn(Ventes_2024, "Année", each 2024),

Résultat = Table.Combine({T1, T2})

in Résultat

11

Combiner tous les fichiers d'un dossier

📁

La source Dossier est l'une des plus puissantes : elle importe automatiquement tous les fichiers d'un dossier (même structure), les combine, et se met à jour quand on ajoute un nouveau fichier.

Procédure

// 1. Données → Obtenir → Fichier → Dossier
//    → sélectionner le dossier contenant les fichiers

// 2. Cliquer sur "Combiner" → "Combiner et transformer"
//    → Excel crée automatiquement une requête de combinaison

// 3. Power Query crée 3 requêtes en coulisses :
//    - Paramètre de chemin source
//    - Exemple de fichier (à modifier pour définir le traitement)
//    - Requête finale (applique le traitement à tous les fichiers)

// 4. Modifier la requête "Exemple de fichier" pour définir
//    les transformations → elles s'appliquent à TOUS les fichiers

Combiner un dossier de CSV

// Power Query génère automatiquement ce code :

let

Source = Folder.Files("C:\data\exports\"),

// Filtrer seulement les CSV

Filtre = Table.SelectRows(Source,

each Text.EndsWith([Name], ".csv")),

// Ajouter le nom de fichier comme colonne source

Ajout = Table.AddColumn(Filtre, "Fichier",

each [Name]),

Combiné = Table.Combine(

List.Transform(Ajout[Content],

each Csv.Document(_,[Delimiter=";"])))

in Combiné

12 — Langage M

Introduction au langage M

📝

Le langage M (Power Query Formula Language) est fonctionnel et immuable : chaque expression produit une nouvelle valeur. Une requête est une suite d'expressions nommées (les étapes) se référençant les unes les autres dans un bloc let ... in.

Structure fondamentale

let

// Chaque étape = une expression nommée

Étape1 = Source.CSV(...),

Étape2 = Transformation(Étape1),

Étape3 = AutreTransformation(Étape2)

in

Étape3 // valeur finale retournée

Type M	Exemple
`number`	`42`, `3.14`
`text`	`"Paris"`
`logical`	`true`, `false`
`date`	`#date(2025, 1, 15)`
`list`	`{1, 2, 3}`
`record`	`[Nom="Alice", Age=30]`
`table`	Résultat d'une transformation
`null`	Valeur manquante

💡

Dans les formules M, each _ est un raccourci pour each (x) => x — c'est une fonction anonyme qui reçoit la ligne courante.

13

Fonctions M essentielles

Catégorie	Fonction	Rôle
Table	`Table.SelectRows`	Filtrer des lignes
	`Table.SelectColumns`	Garder des colonnes
	`Table.AddColumn`	Ajouter une colonne
	`Table.RenameColumns`	Renommer des colonnes
Texte	`Text.Trim`	Supprimer espaces
	`Text.Upper / Lower`	Casse
	`Text.Contains`	Contient une sous-chaîne
Date	`Date.Year`	Extraire l'année
	`Date.Month`	Extraire le mois
	`Date.From`	Convertir en date
Liste	`List.Sum / Average`	Agréger
Liste	`List.Distinct`	Valeurs uniques

Exemples courants

// Filtrer sur du texte

Table.SelectRows(T, each Text.StartsWith([Ref], "FR"))

// Filtrer sur une date

Table.SelectRows(T, each [Date] >= #date(2025,1,1))

// Ajouter Année + Mois

let T2 = Table.AddColumn(T, "Année", each Date.Year([Date])),

T3 = Table.AddColumn(T2, "Mois", each Date.Month([Date]))

in T3

// Remplacer null par 0

Table.ReplaceValue(T, null, 0, Replacer.ReplaceValue, {"Montant"})

14

Fonctions personnalisées

🔧

On peut créer ses propres fonctions M réutilisables — utile pour appliquer le même traitement à plusieurs requêtes (normalisation, calculs métier, formatage).

Créer une fonction

// Nouvelle requête vide → Éditeur avancé

// Nom de la requête : fx_NettoyerTexte

let

fn = (texte as text) => let

Trimmed = Text.Trim(texte),

Cleaned = Text.Clean(Trimmed),

Upper = Text.Upper(Cleaned)

in Upper

in fn

Utiliser la fonction

// Dans une autre requête :

Table.TransformColumns(Source, {

{"Nom", fx_NettoyerTexte},

{"Ville", fx_NettoyerTexte}})

// Ou via Table.AddColumn

Table.AddColumn(Source, "Nom_propre",

each fx_NettoyerTexte([Nom]))

🏷️

Préfixer les fonctions personnalisées avec fx_ pour les distinguer des requêtes de données dans le volet de navigation.

15

Actualisation & bonnes pratiques

Actualisation	Comment
Une requête	Clic droit → Actualiser
Tout le classeur	Données → Actualiser tout
Au démarrage	Propriétés de la requête → Actualiser à l'ouverture
Toutes les N minutes	Propriétés → Actualiser toutes les X minutes
Via VBA	`ThisWorkbook.RefreshAll`

⚠️

Si les fichiers source changent d'emplacement, les requêtes cassent. Utiliser des paramètres de chemin (Gérer les paramètres) pour centraliser le chemin et faciliter le déplacement.

✅

Bonnes pratiques

Organisation des requêtes

// Structure recommandée :
// 📁 Paramètres
//   └─ Chemin_Source       ← chemin du dossier/fichier
//   └─ Année_Actuelle      ← année pour les filtres
// 📁 Sources brutes
//   └─ Ventes_Brut         ← données brutes, connexion seulement
//   └─ Clients_Brut        ← idem
// 📁 Transformations
//   └─ Ventes_Propre       ← nettoyées, connexion seulement
//   └─ Fusion_VentesClient ← jointure, connexion seulement
// 📁 Résultats
//   └─ Rapport_Final       ← chargé dans Excel (feuille visible)

16 — Référence

Cheat Sheet Power Query

📋 Table — Lignes

`Table.SelectRows`	Filtrer des lignes
`Table.Skip`	Sauter N premières lignes
`Table.FirstN`	Garder N premières lignes
`Table.Distinct`	Supprimer les doublons
`Table.Sort`	Trier
`Table.RowCount`	Compter les lignes

📋 Table — Colonnes

`Table.SelectColumns`	Garder des colonnes
`Table.RemoveColumns`	Supprimer des colonnes
`Table.AddColumn`	Ajouter une colonne
`Table.RenameColumns`	Renommer
`Table.TransformColumns`	Transformer les valeurs
`Table.TransformColumnTypes`	Changer les types

🔤 Texte

`Text.Trim`	Supprimer les espaces
`Text.Clean`	Supprimer caract. invisibles
`Text.Upper/Lower`	Casse
`Text.Contains`	Contient une sous-chaîne
`Text.StartsWith`	Commence par
`Text.Split`	Fractionner en liste

📅 Date & Combiner

`Date.Year/Month/Day`	Extraire composants
`Date.From`	Convertir en date
`Date.AddDays`	Ajouter des jours
`Table.NestedJoin`	Fusionner (JOIN)
`Table.Combine`	Empiler (UNION)
`Table.Group`	Grouper & agréger

PowerQuery