W3docs
fr
Se connecter

Python MySQL DELETE – Supprimer des lignes d'une table

Apprenez à supprimer des lignes d'une base MySQL en Python avec mysql-connector-python, requêtes paramétrées, suppressions en lot et gestion des erreurs.

Supprimer des enregistrements d'une base de données MySQL est une tâche courante dans toute application Python orientée données — que vous purgiez des sessions expirées, supprimiez un compte utilisateur ou archiviez d'anciennes commandes. Ce chapitre vous montre comment utiliser l'instruction SQL DELETE via la bibliothèque mysql-connector-python, en couvrant les suppressions de ligne unique, les suppressions en lot, les requêtes paramétrées sécurisées, les transactions et la gestion des erreurs.

Prérequis

Vous avez besoin des éléments suivants avant d'exécuter les exemples :

  • Python 3.8 ou une version ultérieure installé
  • mysql-connector-python installé (pip install mysql-connector-python)
  • Un serveur MySQL en cours d'exécution (local ou distant)
  • Une base de données et une table avec lesquelles travailler (voir MySQL Get Started et MySQL Create Table)

Les exemples ci-dessous supposent que vous disposez déjà d'une base de données appelée mydatabase contenant une table customers créée et remplie dans le chapitre MySQL Insert.

L'instruction DELETE

L'instruction SQL DELETE supprime une ou plusieurs lignes d'une table :

DELETE FROM table_name WHERE condition;

Incluez toujours une clause WHERE. Sans elle, chaque ligne de la table est supprimée. MySQL ne vous avertit pas — la table entière est effacée instantanément.

Se connecter à MySQL

Avant d'exécuter une instruction, vous devez ouvrir une connexion et créer un objet curseur. Le curseur est l'objet qui envoie le SQL au serveur et récupère les résultats.

import mysql.connector
from mysql.connector import Error

mydb = mysql.connector.connect(
    host="localhost",
    user="yourusername",
    password="yourpassword",
    database="mydatabase"
)

mycursor = mydb.cursor()

Supprimer une seule ligne

La manière la plus sûre de cibler une ligne spécifique est d'utiliser une requête paramétrée. Passez la valeur sous forme de tuple Python — le connecteur remplace l'espace réservé %s après avoir échappé la valeur, ce qui empêche les injections SQL.

import mysql.connector
from mysql.connector import Error

try:
    mydb = mysql.connector.connect(
        host="localhost",
        user="yourusername",
        password="yourpassword",
        database="mydatabase"
    )
    mycursor = mydb.cursor()

    sql = "DELETE FROM customers WHERE name = %s"
    val = ("John",)                   # note the trailing comma — this is a tuple

    mycursor.execute(sql, val)
    mydb.commit()                     # write the change to disk

    print(mycursor.rowcount, "record(s) deleted")

except Error as e:
    print(f"Error: {e}")
    mydb.rollback()                   # undo any partial changes on failure

finally:
    if mydb.is_connected():
        mycursor.close()
        mydb.close()

cursor.rowcount vous indique combien de lignes l'instruction a réellement supprimées. Une valeur de 0 signifie que la condition WHERE ne correspondait à rien — la requête s'est exécutée sans erreur, mais rien n'a été supprimé.

Pourquoi commit() est obligatoire

mysql-connector-python ouvre les connexions en mode autocommit désactivé par défaut. Tant que vous n'appelez pas mydb.commit(), la suppression n'existe qu'à l'intérieur de votre transaction courante et est invisible pour les autres connexions. Si votre script plante avant de valider, la suppression est automatiquement annulée. Appelez mydb.rollback() explicitement dans le bloc except pour rendre l'intention claire.

Supprimer plusieurs lignes avec une seule instruction

Si vous souhaitez supprimer toutes les lignes correspondant à un motif, conservez la clause WHERE mais élargissez la condition. Un seul appel à execute() est nécessaire.

import mysql.connector
from mysql.connector import Error

try:
    mydb = mysql.connector.connect(
        host="localhost",
        user="yourusername",
        password="yourpassword",
        database="mydatabase"
    )
    mycursor = mydb.cursor()

    # Delete every customer whose address contains "Highway"
    sql = "DELETE FROM customers WHERE address LIKE %s"
    val = ("%Highway%",)

    mycursor.execute(sql, val)
    mydb.commit()

    print(mycursor.rowcount, "record(s) deleted")

except Error as e:
    print(f"Error: {e}")
    mydb.rollback()

finally:
    if mydb.is_connected():
        mycursor.close()
        mydb.close()

Supprimer des lignes par plusieurs ID (executemany)

Lorsque vous disposez d'une liste de clés primaires à supprimer, utilisez executemany() pour exécuter la même instruction paramétrée une fois par élément en un seul aller-retour :

import mysql.connector
from mysql.connector import Error

ids_to_delete = [(5,), (12,), (17,), (34,)]   # list of 1-tuples

try:
    mydb = mysql.connector.connect(
        host="localhost",
        user="yourusername",
        password="yourpassword",
        database="mydatabase"
    )
    mycursor = mydb.cursor()

    sql = "DELETE FROM customers WHERE id = %s"
    mycursor.executemany(sql, ids_to_delete)
    mydb.commit()

    print(mycursor.rowcount, "record(s) deleted")

except Error as e:
    print(f"Error: {e}")
    mydb.rollback()

finally:
    if mydb.is_connected():
        mycursor.close()
        mydb.close()

executemany() englobe toutes les suppressions individuelles dans une seule transaction, de sorte que soit toutes réussissent, soit aucune ne le fait.

Utiliser un gestionnaire de contexte (modèle recommandé)

Ouvrir la connexion dans une instruction with garantit qu'elle est toujours fermée, même si une exception se produit en cours de route. C'est le modèle le plus propre pour le code en production :

import mysql.connector
from mysql.connector import Error

db_config = {
    "host": "localhost",
    "user": "yourusername",
    "password": "yourpassword",
    "database": "mydatabase",
}

try:
    with mysql.connector.connect(**db_config) as mydb:
        with mydb.cursor() as mycursor:
            sql = "DELETE FROM customers WHERE name = %s"
            mycursor.execute(sql, ("Alice",))
            mydb.commit()
            print(mycursor.rowcount, "record(s) deleted")

except Error as e:
    print(f"Error: {e}")

Le bloc with ferme à la fois le curseur et la connexion lorsque le bloc se termine, qu'une exception ait été levée ou non.

Compter les lignes avant de supprimer (simulation à vide)

Avant d'exécuter un DELETE destructeur, il est recommandé d'exécuter d'abord un SELECT COUNT(*) avec la même clause WHERE. Cela agit comme une simulation à vide qui vous indique combien de lignes seront affectées :

import mysql.connector
from mysql.connector import Error

try:
    mydb = mysql.connector.connect(
        host="localhost",
        user="yourusername",
        password="yourpassword",
        database="mydatabase"
    )
    mycursor = mydb.cursor()

    condition = "%Highway%"

    # Dry run: count matching rows first
    mycursor.execute("SELECT COUNT(*) FROM customers WHERE address LIKE %s", (condition,))
    count = mycursor.fetchone()[0]
    print(f"{count} row(s) would be deleted")

    if count > 0:
        mycursor.execute("DELETE FROM customers WHERE address LIKE %s", (condition,))
        mydb.commit()
        print(f"{mycursor.rowcount} row(s) deleted")

except Error as e:
    print(f"Error: {e}")
    mydb.rollback()

finally:
    if mydb.is_connected():
        mycursor.close()
        mydb.close()

Erreurs courantes

Oublier la clause WHERE

# DANGER: deletes every row in the table
mycursor.execute("DELETE FROM customers")
mydb.commit()

Vérifiez toujours que votre clause WHERE est présente et correcte avant d'appeler commit().

Passer une chaîne au lieu d'un tuple

# Wrong — passes the string "John" character by character
mycursor.execute("DELETE FROM customers WHERE name = %s", "John")

# Correct — wrap the value in a tuple
mycursor.execute("DELETE FROM customers WHERE name = %s", ("John",))

Ne pas appeler commit()

mycursor.execute("DELETE FROM customers WHERE name = %s", ("John",))
# Missing mydb.commit() — the deletion will be silently rolled back
# when the connection closes

Bonnes pratiques

  • Utilisez des requêtes paramétrées (espaces réservés %s) en permanence. Ne construisez jamais des chaînes SQL avec des f-strings ou la concaténation + à partir de données fournies par l'utilisateur — cela ouvre une vulnérabilité aux injections SQL.
  • Validez ou annulez toujours explicitement. Compter sur la fermeture de la connexion pour annuler une transaction est source de confusion ; rendez le résultat explicite dans votre code.
  • Vérifiez rowcount après la suppression pour confirmer que le nombre attendu de lignes a été supprimé.
  • Utilisez des transactions pour les suppressions en plusieurs étapes. Si vous devez supprimer des lignes de plusieurs tables liées (par exemple, une commande et ses articles), enveloppez les opérations dans une seule transaction afin de ne jamais vous retrouver avec des données orphelines.
  • Ajoutez des index appropriés sur les colonnes utilisées dans les clauses WHERE. Une suppression qui parcourt toute la table est lente sur les grands ensembles de données.

Chapitres associés

  • MySQL Get Started — installez le connecteur et créez votre première connexion
  • MySQL Create Table — créez les tables depuis lesquelles vous allez supprimer
  • MySQL Insert — ajoutez des lignes avant de vous entraîner à les supprimer
  • MySQL Update — modifiez des lignes au lieu de les supprimer
  • MySQL Where — maîtrisez la clause WHERE utilisée dans toutes les instructions DELETE
  • MySQL Drop Table — supprimez toute la structure d'une table, pas seulement ses lignes
Was this page helpful?