Nouveau : Datasets open source gratuits disponibles !Decouvrir →
sharing-data.fr sharing-data.fr
🗄️
Intermediaire 30 min • SQL

SQL pour le Data Science

Pourquoi SQL pour le Data Science ?

SQL, ou Structured Query Language, est un langage de programmation utilisé pour gérer et analyser des données structurées dans les bases de données relationnelles. En tant que Data Scientist, vous aurez besoin d'effectuer une multitude d'opérations sur vos données, allant du simple filtrage jusqu'à l'extraction de modèles complexes.

Par exemple, si vous travaillez pour un e-commerce, SQL peut vous aider à analyser des ventes par produit, générer des rapports sur le comportement des utilisateurs ou même prévoir les tendances futures en fonction des données historiques.

Prerequis

Avant de plonger dans l'utilisation de SQL pour le Data Science, voici quelques connaissances et outils qui vous seront utiles :

  • Connaissances requises :

    • Compréhension de base de la théorie des ensembles et des relations.
    • Connaissance des opérations fondamentales sur les tables (SELECT, INSERT, UPDATE, DELETE).
    • Familiarité avec les notions clés du Data Science comme l'analyse exploratoire de données (EDA), l'apprentissage supervisé, etc.

  • Outils à installer :

    • PostgreSQL ou MySQL : Pour créer et gérer vos bases de données.
    • DBeaver : Un client universel pour accéder et interagir avec les bases de données SQL.
    • Jupyter Notebook : Pour écrire et exécuter du code SQL interactif.

Concepts fondamentaux

Tables et Relations

Une base de données SQL est composée de tables. Chaque table est une collection de lignes et de colonnes, où chaque ligne représente un enregistrement et chaque colonne une propriété de cet enregistrement. Les relations entre les tables sont définies par des clés étrangères.

Schema mental :

+-----------------+        +---------------+
|     Clients     |        |   Transactions  |
+-----------------+        +---------------+
| id (PK)         |<-------| id (PK)       |
| nom             |        | client_id     |
| adresse         |        | montant       |
| email           |        | date          |
+-----------------+        +---------------+

Code SQL :

CREATE TABLE Clients (
    id INT PRIMARY KEY,
    nom VARCHAR(100),
    adresse VARCHAR(255),
    email VARCHAR(100)
);

CREATE TABLE Transactions (
    id INT PRIMARY KEY,
    client_id INT,
    montant DECIMAL(10, 2),
    date DATE,
    FOREIGN KEY (client_id) REFERENCES Clients(id)
);

SELECT pour la récupération de données

La commande SELECT est utilisée pour récupérer des données à partir d'une ou plusieurs tables.

Schema mental :

+-----------------+
|     Clients     |
+-----------------+
| id (PK)         |
| nom             |
| adresse         |
| email           |
+-----------------+

Code SQL :

SELECT id, nom FROM Clients WHERE email = 'example@example.com';

JOIN pour les relations entre tables

La commande JOIN permet de combiner des lignes de plusieurs tables en fonction d'une condition.

Schema mental :

+-----------------+
|     Clients     |
+-----------------+
| id (PK)         |
| nom             |
| adresse         |
| email           |
+-----------------+
+---------------+
|   Transactions  |
+---------------+
| id (PK)       |
| client_id     |
| montant       |
| date          |
+---------------+

Code SQL :

SELECT C.id, C.nom, T.montant 
FROM Clients AS C 
JOIN Transactions AS T ON C.id = T.client_id;

GROUP BY pour les agrégations

La commande GROUP BY est utilisée pour regrouper des enregistrements en fonction d'une ou plusieurs colonnes.

Schema mental :

+-----------------+
|     Clients     |
+-----------------+
| id (PK)         |
| nom             |
| adresse         |
| email           |
+-----------------+

Code SQL :

SELECT client_id, COUNT(*) AS nombre_transactions 
FROM Transactions 
GROUP BY client_id;

INSERT pour l'ajout de données

La commande INSERT est utilisée pour ajouter de nouvelles lignes dans une table.

Schema mental :

+-----------------+
|     Clients     |
+-----------------+
| id (PK)         |
| nom             |
| adresse         |
| email           |
+-----------------+

Code SQL :

INSERT INTO Clients (id, nom, adresse, email)
VALUES (1, 'John Doe', '123 rue des champs', 'john.doe@example.com');

UPDATE pour la modification de données

La commande UPDATE est utilisée pour modifier les enregistrements existants dans une table.

Schema mental :

+-----------------+
|     Clients     |
+-----------------+
| id (PK)         |
| nom             |
| adresse         |
| email           |
+-----------------+

Code SQL :

UPDATE Clients 
SET email = 'new.email@example.com' 
WHERE id = 1;

DELETE pour la suppression de données

La commande DELETE est utilisée pour supprimer des enregistrements existants dans une table.

Schema mental :

+-----------------+
|     Clients     |
+-----------------+
| id (PK)         |
| nom             |
| adresse         |
| email           |
+-----------------+

Code SQL :

DELETE FROM Clients 
WHERE id = 1;

Mise en pratique : projet fil rouge

Mini-projet complet et réaliste : Gestionnaire de tâches

Étape 1 : Création des tables

Schema mental :

+-----------------+
|     Taches      |
+-----------------+
| id (PK)         |
| titre           |
| description     |
| date_limite     |
| etat            |
+-----------------+
+---------------+
|   Priorites     |
+---------------+
| id (PK)       |
| nom             |
+---------------+

Code SQL :

CREATE TABLE Taches (
    id INT PRIMARY KEY,
    titre VARCHAR(100),
    description TEXT,
    date_limite DATE,
    etat ENUM('En attente', 'En cours', 'Terminée')
);

CREATE TABLE Priorites (
    id INT PRIMARY KEY,
    nom VARCHAR(50)
);

Étape 2 : Ajout des relations

Schema mental :

+-----------------+
|     Taches      |
+-----------------+
| id (PK)         |
| titre           |
| description     |
| date_limite     |
| etat            |
| priorite_id     | <--- Relation avec Priorites
+-----------------+
+---------------+
|   Priorites     |
+---------------+
| id (PK)       |
| nom             |
+---------------+

Code SQL :

ALTER TABLE Taches ADD COLUMN priorite_id INT;
ALTER TABLE Taches ADD FOREIGN KEY (priorite_id) REFERENCES Priorites(id);

Étape 3 : Insertion de données

Schema mental :

+-----------------+
|     Taches      |
+-----------------+
| id (PK)         |
| titre           |
| description     |
| date_limite     |
| etat            |
| priorite_id     | <--- Relation avec Priorites
+-----------------+
+---------------+
|   Priorites     |
+---------------+
| id (PK)       |
| nom             |
+---------------+

Code SQL :

INSERT INTO Priorites (id, nom)
VALUES (1, 'Basse'), (2, 'Moyenne'), (3, 'Haute');

INSERT INTO Taches (id, titre, description, date_limite, etat, priorite_id)
VALUES 
(1, 'Faire les courses', 'Acheter du lait, des œufs, du pain...', '2023-04-15', 'En attente', 1),
(2, 'Rédiger le rapport', 'Compléter le rapport mensuel sur les ventes...', '2023-04-30', 'En cours', 2);

Étape 4 : Récupération de données

Schema mental :

+-----------------+
|     Taches      |
+-----------------+
| id (PK)         |
| titre           |
| description     |
| date_limite     |
| etat            |
| priorite_id     | <--- Relation avec Priorites
+-----------------+
+---------------+
|   Priorites     |
+---------------+
| id (PK)       |
| nom             |
+---------------+

Code SQL :

SELECT T.id, T.titre, T.description, T.date_limite, T.etat, P.nom AS priorite 
FROM Taches AS T 
JOIN Priorites AS P ON T.priorite_id = P.id;

Étape 5 : Mise à jour et suppression de données

Schema mental :

+-----------------+
|     Taches      |
+-----------------+
| id (PK)         |
| titre           |
| description     |
| date_limite     |
| etat            |
| priorite_id     | <--- Relation avec Priorites
+-----------------+
+---------------+
|   Priorites     |
+---------------+
| id (PK)       |
| nom             |
+---------------+

Code SQL :

UPDATE Taches 
SET etat = 'En cours' 
WHERE id = 1;

DELETE FROM Taches 
WHERE id = 2;

Étape 6 : Export des données

Schema mental :

+-----------------+
|     Taches      |
+-----------------+
| id (PK)         |
| titre           |
| description     |
| date_limite     |
| etat            |
| priorite_id     | <--- Relation avec Priorites
+-----------------+
+---------------+
|   Priorites     |
+---------------+
| id (PK)       |
| nom             |
+---------------+

Code SQL :

SELECT * INTO Taches_backup FROM Taches;

Erreurs fréquentes et debugging

Erreur 1 : Syntaxe incorrecte de la commande SELECT

Mauvais code :

SELECT id, nom FORM Clients WHERE email = 'example@example.com';

Correct code :

SELECT id, nom FROM Clients WHERE email = 'example@example.com';

Erreur 2 : Mauvaise relation dans le JOIN

Mauvais code :

SELECT C.id, C.nom, T.montant 
FROM Clients AS C 
JOIN Transactions AS T ON C.id != T.client_id;

Correct code :

SELECT C.id, C.nom, T.montant 
FROM Clients AS C 
JOIN Transactions AS T ON C.id = T.client_id;

Erreur 3 : Tentative d'ajout de données dans une table sans clé primaire définie

Mauvais code :

CREATE TABLE Taches (
    titre VARCHAR(100),
    description TEXT,
    date_limite DATE,
    etat ENUM('En attente', 'En cours', 'Terminée')
);

INSERT INTO Taches (titre, description, date_limite, etat)
VALUES ('Faire les courses', 'Acheter du lait, des œufs, du pain...', '2023-04-15', 'En attente');

Correct code :

CREATE TABLE Taches (
    id INT PRIMARY KEY,
    titre VARCHAR(100),
    description TEXT,
    date_limite DATE,
    etat ENUM('En attente', 'En cours', 'Terminée')
);

INSERT INTO Taches (id, titre, description, date_limite, etat)
VALUES (1, 'Faire les courses', 'Acheter du lait, des œufs, du pain...', '2023-04-15', 'En attente');

Pour aller plus loin

1. Analyse de performances avec EXPLAIN

L'analyseur d'exécution SQL (EXPLAIN) peut vous aider à comprendre comment les requêtes sont exécutées et à identifier les problèmes de performance.

Code SQL :

EXPLAIN SELECT * FROM Clients WHERE email = 'example@example.com';

2. Utilisation des sous-queries

Les sous-queries permettent d'effectuer des opérations complexes en imbriquant des requêtes dans d'autres requêtes.

Schema mental :

+-----------------+
|     Taches      |
+-----------------+
| id (PK)         |
| titre           |
| description     |
| date_limite     |
| etat            |
| priorite_id     | <--- Relation avec Priorites
+-----------------+
+---------------+
|   Priorites     |
+---------------+
| id (PK)       |
| nom             |
+---------------+

Code SQL :

SELECT T.id, T.titre 
FROM Taches AS T 
WHERE T.priorite_id IN (
    SELECT P.id FROM Priorites AS P WHERE P.nom = 'Haute'
);

3. Utilisation des fenêtres (Window Functions)

Les fonctions de fenêtre vous permettent d'effectuer des calculs sur un ensemble de lignes qui partagent une caractéristique commune.

Schema mental :

+-----------------+
|     Taches      |
+-----------------+
| id (PK)         |
| titre           |
| description     |
| date_limite     |
| etat            |
| priorite_id     | <--- Relation avec Priorites
+-----------------+
+---------------+
|   Priorites     |
+---------------+
| id (PK)       |
| nom             |
+---------------+

Code SQL :

SELECT T.id, T.titre, T.date_limite, 
       RANK() OVER (ORDER BY T.date_limite DESC) AS rang
FROM Taches AS T;

Défi pratique : Créer une API simple pour accéder aux données de la gestionnaire de tâches

Créez une API simple en utilisant Flask pour permettre à des utilisateurs d'interagir avec les données de la gestionnaire de tâches via des requêtes HTTP.

Besoin d'aide sur SQL ?

Besoin d'aide sur un projet technique ? Decrivez-le pour des conseils personnalises.

Recevoir des conseils

Questions frequentes

Quelle est la différence entre SQL et NoSQL?
SQL est un langage structuré pour gérer des bases de données relationnelles, tandis que NoSQL est utilisé pour les bases de données non relationnelles qui offrent plus de flexibilité et d'échelle.
Comment optimiser une requête SQL?
Pour optimiser une requête SQL, il faut utiliser des indices sur les colonnes utilisées dans les WHERE, JOIN et ORDER BY. Évitez aussi les sous-requêtes non nécessaires et assurez-vous que votre base de données est bien normalisée.
Quelle est la fonction GROUP BY en SQL?
La fonction GROUP BY en SQL est utilisée pour regrouper des lignes en groupes identiques selon une ou plusieurs colonnes. Elle est souvent utilisée avec les fonctions d'agrégation comme COUNT, SUM, AVG, MAX et MIN.

Pages liees

CheatsheetCheatsheet SQLErreursErreurs frequentes SQLTutorielsTous les tutoriels

Chaque semaine, le meilleur de la tech francaise

Tendances, salaires, outils et opportunites — directement dans votre boite mail.

Gratuit. Desabonnement en un clic. Pas de spam.