MySQL Insert en Python

L'insertion de données dans une table MySQL depuis Python nécessite trois éléments : une connexion active, une instruction SQL paramétrée et un appel à commit(). Ce chapitre couvre les insertions d'une seule ligne, les insertions en masse avec executemany(), la récupération de l'ID auto-généré de la nouvelle ligne, la gestion des doublons avec ON DUPLICATE KEY UPDATE, ainsi que les pièges courants pour les débutants.

Prérequis

Avant d'exécuter l'un des exemples ici, assurez-vous d'avoir :

• Python 3.x et un serveur MySQL en cours d'exécution
• mysql-connector-python installé :

pip install mysql-connector-python

• Une base de données et une table customers déjà créées — consultez MySQL Create Database et MySQL Create Table si vous devez les configurer au préalable.

Les exemples supposent la définition de table suivante :

CREATE TABLE IF NOT EXISTS customers (
  id      INT AUTO_INCREMENT PRIMARY KEY,
  name    VARCHAR(255) NOT NULL,
  address VARCHAR(255)
);

Connexion à MySQL

Chaque opération commence par un objet de connexion. Passez votre hôte, vos identifiants et le nom de la base de données à mysql.connector.connect(), puis créez un curseur :

import mysql.connector

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

mycursor = mydb.cursor()

L'objet cursor envoie du SQL au serveur. Réutilisez la même connexion pour plusieurs instructions plutôt que de vous reconnecter à chaque fois.

Insertion d'une seule ligne

Utilisez l'instruction SQL INSERT INTO avec des espaces réservés %s et passez les valeurs réelles sous forme de tuple. Ne construisez jamais la chaîne de requête avec le formatage % ou les f-strings de Python — cela expose votre code aux 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 = "INSERT INTO customers (name, address) VALUES (%s, %s)"
  val = ("John", "Highway 21")

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

  print(mycursor.rowcount, "record inserted.")

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

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

Points clés :

• %s est la syntaxe de l'espace réservé pour mysql-connector-python, quel que soit le type de données de la colonne (les chaînes, entiers et dates utilisent tous %s).
• mydb.commit() est obligatoire — sans cela, l'insertion n'est jamais écrite sur le disque. MySQL encapsule les instructions DML dans des transactions implicites ; vous devez valider pour les finaliser.
• mydb.rollback() dans le bloc except annule toute modification partielle si l'instruction échoue.

Récupération de l'ID auto-incrémenté

Après une insertion réussie, mycursor.lastrowid contient la clé primaire AUTO_INCREMENT que MySQL a attribuée à la nouvelle ligne :

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 = "INSERT INTO customers (name, address) VALUES (%s, %s)"
  val = ("Alice", "Maple Street 7")

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

  print("Inserted row ID:", mycursor.lastrowid)

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

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

Exemple de sortie :

Inserted row ID: 1

La valeur est 0 si la table n'a pas de colonne AUTO_INCREMENT. Utilisez lastrowid pour référencer immédiatement le nouvel enregistrement dans des tables associées (par exemple, pour insérer une ligne correspondante dans une table orders).

Insertion de plusieurs lignes

executemany() envoie une liste de tuples de valeurs en un seul aller-retour vers le serveur, ce qui est bien plus efficace qu'appeler execute() dans une boucle :

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 = "INSERT INTO customers (name, address) VALUES (%s, %s)"
  vals = [
    ("Peter",   "Lowstreet 4"),
    ("Amy",     "Apple St 652"),
    ("Hannah",  "Mountain 21"),
    ("Michael", "Valley 345"),
    ("Sandy",   "Ocean Blvd 2"),
    ("Betty",   "Green Grass 1"),
    ("Richard", "Sky St 331"),
    ("Susan",   "One Way 98"),
    ("Vicky",   "Yellow Garden 2"),
    ("Ben",     "Park Lane 38"),
    ("William", "Central St 954"),
    ("Chuck",   "Main Road 989"),
    ("Viola",   "Sideway 1633"),
  ]

  mycursor.executemany(sql, vals)
  mydb.commit()

  print(mycursor.rowcount, "records inserted.")

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

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

Exemple de sortie :

13 records inserted.

mycursor.rowcount après executemany() renvoie le nombre total de lignes affectées pour tous les tuples.

Quand préférer executemany() à une boucle

Pour les très grands jeux de données (dizaines de milliers de lignes), envisagez de les regrouper par lots de 500 à 1000 lignes afin qu'un seul échec ne compromette pas l'intégralité de l'opération.

Insertion sans échec en cas de doublons

Si votre table possède une contrainte UNIQUE et que vous tentez d'insérer une ligne qui existe déjà, MySQL génère une erreur de clé dupliquée. Deux stratégies courantes permettent d'éviter cela :

INSERT IGNORE

INSERT IGNORE ignore silencieusement les lignes qui violent une contrainte unique :

sql = "INSERT IGNORE INTO customers (name, address) VALUES (%s, %s)"
mycursor.execute(sql, ("John", "Highway 21"))
mydb.commit()
print(mycursor.rowcount, "row(s) affected")  # 0 if row already existed

ON DUPLICATE KEY UPDATE

ON DUPLICATE KEY UPDATE effectue une mise à jour lorsque la clé unique existe déjà, transformant l'instruction en « upsert » (insertion ou mise à jour) :

sql = """
  INSERT INTO customers (name, address)
  VALUES (%s, %s)
  ON DUPLICATE KEY UPDATE address = VALUES(address)
"""
mycursor.execute(sql, ("John", "New Address 5"))
mydb.commit()
# rowcount is 1 for insert, 2 for update, 0 if row existed but was unchanged
print(mycursor.rowcount, "row(s) affected")

Utilisez ON DUPLICATE KEY UPDATE lorsque vous souhaitez stocker la valeur la plus récente, que la ligne soit nouvelle ou existante.

Insertion de données depuis un dictionnaire

Lorsque vos données proviennent d'une liste de dictionnaires (par exemple, d'une charge utile JSON analysée), vous pouvez construire le SQL et les valeurs dynamiquement :

import mysql.connector
from mysql.connector import Error

customers = [
  {"name": "Eva",   "address": "Elm Street 3"},
  {"name": "Oscar", "address": "Birch Lane 9"},
]

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

  sql = "INSERT INTO customers (name, address) VALUES (%(name)s, %(address)s)"
  mycursor.executemany(sql, customers)
  mydb.commit()

  print(mycursor.rowcount, "records inserted.")

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

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

Les espaces réservés nommés (%(name)s) rendent l'intention plus claire lorsque des dictionnaires sont impliqués et réduisent le risque de désalignement des valeurs positionnelles.

Erreurs courantes à éviter

Oublier commit() — L'insertion semble fonctionner (aucune erreur) mais aucune donnée n'est enregistrée. Appelez toujours mydb.commit() après les instructions DML.

Construire du SQL avec du formatage de chaîne — L'utilisation de f-strings ou du formatage % pour intégrer des entrées utilisateur est la source la plus fréquente d'injection SQL. Passez toujours les valeurs comme second argument à execute().

Laisser des connexions ouvertes — Utilisez un bloc finally (ou un gestionnaire de contexte) pour vous assurer que cursor.close() et mydb.close() sont toujours appelés.

Utiliser INSERT alors que la table n'a pas encore été créée — Vous obtiendrez une erreur Table 'mydatabase.customers' doesn't exist. Exécutez d'abord CREATE TABLE ou vérifiez avec SHOW TABLES. Consultez MySQL Create Table.

Prochaines étapes

Une fois vos lignes insérées, vous souhaiterez généralement les relire. Consultez MySQL Select pour les requêtes SELECT, MySQL Where pour le filtrage, et MySQL Update pour modifier des lignes existantes.