Qu'est-ce que la méthode split() en Python ?

Définition de la méthode split() en Python

La méthode split() est l'une des méthodes les plus utilisées en Python pour manipuler les chaînes de caractères. Elle permet de diviser une chaîne de caractères en une liste de sous-chaînes en se basant sur un séparateur (aussi appelé délimiteur). Par défaut, ce séparateur est l'espace blanc (espaces, tabulations, sauts de ligne).

En d'autres termes, split() prend une chaîne unique et la découpe en plusieurs morceaux, chacun devenant un élément d'une list. C'est une opération fondamentale que vous rencontrerez dans presque tous les projets Python, que ce soit pour le traitement de fichiers, l'analyse de données ou le développement web. Si vous souhaitez maîtriser ce type de manipulation et bien d'autres, notre formation complète sur Python vous guidera pas à pas.

La syntaxe de base est la suivante :

chaine.split(sep=None, maxsplit=-1)

Où :

• sep (optionnel) : le séparateur utilisé pour découper la chaîne. Par défaut None, ce qui signifie que Python utilise les espaces blancs.
• maxsplit (optionnel) : le nombre maximum de découpes à effectuer. Par défaut -1, ce qui signifie qu'il n'y a pas de limite.

Utilisation basique de split()

Commençons par le cas le plus simple : découper une phrase en mots. Lorsque vous appelez split() sans aucun argument, Python découpe la chaîne à chaque espace blanc.

phrase = "Bonjour le monde Python"
mots = phrase.split()
print(mots)
# Résultat : ['Bonjour', 'le', 'monde', 'Python']

Comme vous pouvez le constater, la méthode retourne une list contenant chaque mot de la phrase. C'est extrêmement pratique pour compter les mots d'un texte ou accéder à un mot précis par son index.

phrase = "Python est un langage puissant"
mots = phrase.split()

# Nombre de mots
print(len(mots))  # 5

# Accéder au premier mot
print(mots[0])  # Python

# Accéder au dernier mot
print(mots[-1])  # puissant

Vous remarquerez ici l'utilisation de la fonction len pour obtenir le nombre d'éléments dans la liste résultante.

Découper avec un séparateur personnalisé

L'un des grands atouts de split() est de pouvoir spécifier n'importe quel séparateur. Cela est particulièrement utile lorsque vous travaillez avec des données structurées comme des fichiers CSV, des logs ou des URL.

Séparer par une virgule

donnees_csv = "Alice,28,Paris,Développeuse"
champs = donnees_csv.split(",")
print(champs)
# Résultat : ['Alice', '28', 'Paris', 'Développeuse']

Séparer par un point-virgule

ligne = "nom;prenom;age;ville"
colonnes = ligne.split(";")
print(colonnes)
# Résultat : ['nom', 'prenom', 'age', 'ville']

Séparer par un saut de ligne

texte = "Première ligne\nDeuxième ligne\nTroisième ligne"
lignes = texte.split("\n")
print(lignes)
# Résultat : ['Première ligne', 'Deuxième ligne', 'Troisième ligne']

Séparer par une chaîne de plusieurs caractères

Le séparateur n'est pas limité à un seul caractère. Vous pouvez utiliser n'importe quelle chaîne :

texte = "Python-->Java-->JavaScript-->Rust"
langages = texte.split("-->")
print(langages)
# Résultat : ['Python', 'Java', 'JavaScript', 'Rust']

Le paramètre maxsplit

Le second paramètre de split() permet de limiter le nombre de découpes effectuées. C'est très utile lorsque vous ne souhaitez extraire que les premiers éléments d'une chaîne tout en conservant le reste intact.

phrase = "un deux trois quatre cinq"
resultat = phrase.split(" ", 2)
print(resultat)
# Résultat : ['un', 'deux', 'trois quatre cinq']

Ici, Python a effectué seulement 2 découpes, ce qui produit une liste de 3 éléments. Le troisième élément contient tout le reste de la chaîne, non découpé.

Un cas d'usage très courant est de séparer une clé et sa valeur :

config = "database_host=mon-serveur.believemy.com"
cle, valeur = config.split("=", 1)
print(cle)     # database_host
print(valeur)  # mon-serveur.believemy.com

En utilisant maxsplit=1, nous nous assurons que seul le premier signe = est pris en compte, ce qui est essentiel si la valeur elle-même contient des signes =.

Différence entre split() sans argument et split(" ")

Il existe une subtilité importante que beaucoup de développeurs ignorent : appeler split() sans argument n'est pas identique à appeler split(" "). Voici pourquoi :

Voyons cela en pratique :

texte = "  Bonjour   le    monde  "

# Sans argument
print(texte.split())
# Résultat : ['Bonjour', 'le', 'monde']

# Avec un espace comme argument
print(texte.split(" "))
# Résultat : ['', '', 'Bonjour', '', '', 'le', '', '', '', 'monde', '', '']

rsplit() : découper depuis la droite

Python propose également la méthode rsplit() qui fonctionne de manière identique à split(), mais effectue les découpes depuis la droite de la chaîne. Sans le paramètre maxsplit, le résultat est le même que split(). La différence n'apparaît que lorsque vous limitez le nombre de découpes.

chemin = "dossier/sous-dossier/fichier.txt"

# split depuis la gauche
print(chemin.split("/", 1))
# Résultat : ['dossier', 'sous-dossier/fichier.txt']

# rsplit depuis la droite
print(chemin.rsplit("/", 1))
# Résultat : ['dossier/sous-dossier', 'fichier.txt']

Comme vous pouvez le voir, rsplit() est idéal pour extraire le dernier élément d'un chemin ou d'une chaîne composée.

splitlines() : découper par lignes

Pour découper un texte en lignes, Python offre une méthode dédiée : splitlines(). Elle reconnaît automatiquement tous les types de fins de ligne (\n, \r\n, \r), ce qui la rend plus robuste que split("\n").

texte = "Ligne 1\nLigne 2\r\nLigne 3\rLigne 4"
lignes = texte.splitlines()
print(lignes)
# Résultat : ['Ligne 1', 'Ligne 2', 'Ligne 3', 'Ligne 4']

Cas d'usage pratiques

Analyser un fichier CSV simple

L'un des cas d'usage les plus fréquents de split() est le traitement de fichiers CSV (sans utiliser de bibliothèque externe) :

donnees_brutes = """nom,age,ville
Alice,28,Paris
Bob,35,Lyon
Charlie,42,Marseille"""

lignes = donnees_brutes.strip().splitlines()
en_tetes = lignes[0].split(",")

for ligne in lignes[1:]:
    valeurs = ligne.split(",")
    for en_tete, valeur in zip(en_tetes, valeurs):
        print(f"{en_tete}: {valeur}")
    print("---")

Cet exemple utilise zip pour associer chaque en-tête à sa valeur, et les f-string pour un affichage clair. C'est un excellent exercice pour comprendre l'interaction entre plusieurs fonctionnalités de Python.

Extraire des informations d'une URL

url = "https://believemy.com/fr/formations/formation-python"

# Extraire le protocole
protocole, reste = url.split("://", 1)
print(protocole)  # https

# Extraire le domaine et le chemin
domaine, chemin = reste.split("/", 1)
print(domaine)  # believemy.com
print(chemin)    # fr/formations/formation-python

# Décomposer le chemin
segments = chemin.split("/")
print(segments)  # ['fr', 'formations', 'formation-python']

Nettoyer et transformer des données

tags_bruts = "  python , machine learning ,  data science , web  "
tags = [tag.strip() for tag in tags_bruts.split(",")]
print(tags)
# Résultat : ['python', 'machine learning', 'data science', 'web']

Ici, nous combinons split(",") avec une compréhension de liste et strip() pour nettoyer chaque élément. C'est un pattern très courant en Python.

Compter les mots d'un texte

def compter_mots(texte):
    """Compte le nombre de mots dans un texte."""
    mots = texte.split()
    return len(mots)

article = "Python est un langage de programmation populaire et puissant"
print(compter_mots(article))  # 9

On utilise ici une fonction définie avec def accompagnée d'une docstring pour documenter son rôle.

Rejoindre après avoir découpé : la méthode join()

La méthode join() est le complément naturel de split(). Si split() transforme une chaîne en liste, join() fait l'inverse : elle transforme une liste en chaîne.

# Découper
phrase = "Python est fantastique"
mots = phrase.split()
print(mots)  # ['Python', 'est', 'fantastique']

# Rejoindre avec un tiret
resultat = "-".join(mots)
print(resultat)  # Python-est-fantastique

# Rejoindre avec un espace
resultat2 = " ".join(mots)
print(resultat2)  # Python est fantastique

Un cas d'usage classique est la création de slugs pour les URL :

titre = "  Qu'est-ce que la Méthode Split en Python ?  "
slug = "-".join(titre.strip().lower().split())
print(slug)  # qu'est-ce-que-la-méthode-split-en-python-?

Bonnes pratiques

Voici les recommandations essentielles pour utiliser split() efficacement dans vos projets Python :

• Privilégiez split() sans argument pour découper du texte naturel. Cela gère automatiquement les espaces multiples et les espaces en début/fin de chaîne.
• Utilisez maxsplit lorsque vous n'avez besoin que des premiers éléments. Cela améliore la performance et évite des découpes inutiles.
• Préférez splitlines() à split("\n") pour découper un texte en lignes, car cette méthode gère correctement tous les types de fins de ligne.
• Pensez à strip() après un split() avec séparateur explicite, car les espaces autour des éléments ne sont pas supprimés automatiquement.
• Utilisez le déballage (unpacking) pour extraire directement les valeurs dans des variables lorsque vous connaissez le nombre d'éléments attendus.
• Gérez les erreurs : vérifiez toujours que la liste résultante contient le nombre d'éléments attendu avant d'y accéder par index.

Erreurs courantes à éviter

Voici les pièges les plus fréquents liés à l'utilisation de split() :

Oublier que split() ne modifie pas la chaîne originale

Les chaînes en Python sont immuables. La méthode split() retourne une nouvelle liste, elle ne modifie pas la chaîne d'origine :

texte = "un deux trois"
texte.split()  # Retourne ['un', 'deux', 'trois'] mais n'est pas stocké
print(texte)   # "un deux trois" - inchangé

# Il faut stocker le résultat
mots = texte.split()
print(mots)  # ['un', 'deux', 'trois']

Confondre split() sans argument et split(" ")

Nous l'avons vu plus haut, mais c'est une erreur si fréquente qu'elle mérite d'être répétée. Utilisez split() sans argument pour le texte naturel.

Ne pas gérer les chaînes vides

donnees = "a,,b,,c"
resultat = donnees.split(",")
print(resultat)  # ['a', '', 'b', '', 'c']

# Filtrer les chaînes vides
resultat_filtre = [x for x in donnees.split(",") if x]
print(resultat_filtre)  # ['a', 'b', 'c']

Appeler split() sur un type non-string

# Ceci provoquera une erreur
nombre = 12345
# nombre.split()  # AttributeError: 'int' object has no attribute 'split'

# Convertissez d'abord en chaîne
chiffres = str(nombre)
resultat = list(chiffres)
print(resultat)  # ['1', '2', '3', '4', '5']

Performance et alternatives

La méthode split() est très performante pour la plupart des cas d'usage. Cependant, dans certaines situations spécifiques, des alternatives peuvent être plus adaptées :

• Module re (expressions régulières) : lorsque le séparateur est complexe ou variable.
• Module csv : pour les fichiers CSV complexes (avec des guillemets, des échappements, etc.).
• partition() : lorsque vous ne souhaitez séparer qu'en 3 parties (avant, séparateur, après).

import re

# Découper par plusieurs séparateurs à la fois
texte = "mot1,mot2;mot3:mot4"
resultat = re.split(r"[,;:]", texte)
print(resultat)  # ['mot1', 'mot2', 'mot3', 'mot4']

# Utiliser partition() pour une seule découpe
email = "utilisateur@believemy.com"
nom, sep, domaine = email.partition("@")
print(nom)      # utilisateur
print(domaine)  # believemy.com

Questions fréquentes

Les deux méthodes fonctionnent de manière identique lorsqu'elles sont appelées sans le paramètre maxsplit. La différence apparaît uniquement lorsque vous limitez le nombre de découpes : split() découpe depuis le début (la gauche) de la chaîne, tandis que rsplit() découpe depuis la fin (la droite). Par exemple, "a/b/c".split("/", 1) donne ['a', 'b/c'] alors que "a/b/c".rsplit("/", 1) donne ['a/b', 'c'].

Non, la méthode split() native ne prend en charge qu'un seul séparateur à la fois. Pour découper une chaîne avec plusieurs séparateurs simultanément, vous devez utiliser le module re (expressions régulières) avec la fonction re.split(). Par exemple : re.split(r"[,;:]", texte) découpera la chaîne à chaque virgule, point-virgule ou deux-points.

Le comportement dépend de la présence ou non d'un séparateur. "".split() (sans argument) retourne une liste vide []. En revanche, "".split(",") (avec un séparateur explicite) retourne [''], c'est-à-dire une liste contenant une chaîne vide. C'est un détail important à garder en tête lorsque vous traitez des données pouvant contenir des chaînes vides.

La méthode split() n'est qu'une des nombreuses méthodes puissantes offertes par Python pour manipuler les chaînes de caractères. Pour maîtriser l'ensemble de ces outils et développer des projets concrets, nous vous recommandons de suivre notre formation dédiée à Python. Vous y apprendrez non seulement la manipulation de texte, mais aussi les structures de données, la programmation orientée objet et bien plus encore, avec des exercices pratiques à chaque étape.