img
Apprenez la programmation où que vous soyez avec Rachid Saad
📞 Appelez maintenant !

Python les Bases
Chapitre 8 : Chaînes de caractères

Ce chapitre vous apprendra à manipuler efficacement les chaînes de caractères, élément fondamental de tout programme Python. Vous découvrirez les méthodes de formatage, les techniques de recherche et remplacement, ainsi que les expressions régulières. Ces compétences vous permettront de traiter et transformer du texte avec précision dans vos applications.

Introduction aux chaînes de caractères

Les chaînes de caractères (strings) sont un type de données fondamental en Python qui permettent de représenter et manipuler du texte. Elles sont immutables et offrent une riche panoplie de méthodes pour les traiter.

Qu'est-ce qu'une chaîne de caractères ?

Une chaîne de caractères est une séquence ordonnée de caractères. En Python, les chaînes sont des objets qui appartiennent à la classe str et sont immutables (non modifiables après création).

definition_chaine.py
# Une chaîne de caractères est une séquence de caractères
chaine = "Bonjour le monde"

# Type de la variable
print(type(chaine))  # 

# Les chaînes sont des séquences, on peut itérer dessus
for caractere in "Python":
    print(caractere)

# Output:
# P
# y
# t
# h
# o
# n

Création et déclaration de chaînes

Il existe plusieurs façons de créer des chaînes de caractères en Python. La plus simple est d'utiliser des guillemets simples ou doubles.

creation_chaine.py
# Création avec des guillemets simples
chaine1 = 'Hello'

# Création avec des guillemets doubles
chaine2 = "World"

# Chaîne vide
chaine_vide = ""
print("Chaîne vide:", chaine_vide, "Longueur:", len(chaine_vide))

# Conversion d'autres types en chaîne
nombre = 42
chaine_nombre = str(nombre)
print("Nombre en chaîne:", chaine_nombre, "Type:", type(chaine_nombre))

# Utilisation du constructeur str()
chaine_constructeur = str(3.14)
print("Avec constructeur:", chaine_constructeur)

Types de guillemets (simples, doubles, triples)

Python supporte différents types de guillemets pour définir des chaînes de caractères, chacun avec ses particularités.

types_guillemets.py
# Guillemets simples - pratique pour les chaînes contenant des doubles quotes
chaine_simple = 'Il a dit "Bonjour"'
print(chaine_simple)

# Guillemets doubles - pratique pour les chaînes contenant des apostrophes
chaine_double = "C'est l'heure du Python"
print(chaine_double)

# Guillemets triples (simples ou doubles) - pour les chaînes multilignes
chaine_multiligne = """Ceci est une chaîne
qui s'étend sur
plusieurs lignes"""
print(chaine_multiligne)

# Guillemets triples pour les docstrings (documentation de fonctions)
def ma_fonction():
    """Ceci est une docstring.
    Elle décrit ce que fait la fonction.
    """
    return 42

# Utilisation d'échappement pour inclure des guillemets
chaine_echappee = "Il a dit \"C'est générique\""
print(chaine_echappee)

# Alternative sans échappement
chaine_alternative = 'Il a dit "C' + "'" + 'est générique"'
print(chaine_alternative)

Propriétés fondamentales des chaînes

Les chaînes de caractères en Python possèdent plusieurs propriétés essentielles qui déterminent leur comportement et leur utilisation. Comprendre ces propriétés est crucial pour manipuler efficacement le texte en Python.

Immutabilité des chaînes

Les chaînes de caractères en Python sont immutables, ce qui signifie qu'elles ne peuvent pas être modifiées après leur création. Toute opération qui semble modifier une chaîne crée en réalité une nouvelle chaîne.

immutabilite_chaine.py
# Démonstration de l'immutabilité des chaînes
chaine = "Python"

# Tentative de modification directe (provoque une erreur)
# chaine[0] = "J"  # TypeError: 'str' object does not support item assignment

# Pour "modifier" une chaîne, on doit créer une nouvelle chaîne
nouvelle_chaine = "J" + chaine[1:]
print("Originale:", chaine)          # Python
print("Modifiée:", nouvelle_chaine)   # Jython

# Vérification que l'identité mémoire a changé
print("Même objet?", chaine is nouvelle_chaine)  # False

# Les méthodes de chaînes retournent de nouvelles chaînes
chaine_maj = chaine.upper()
print("Originale:", chaine)          # Python
print("En majuscules:", chaine_maj)  # PYTHON

# Conséquence sur la performance
# La concaténation répétée dans une boucle est inefficace
resultat = ""
for i in range(1000):
    resultat += str(i)  # Crée une nouvelle chaîne à chaque itération

# Alternative plus efficace avec une liste
parties = []
for i in range(1000):
    parties.append(str(i))
resultat = "".join(parties)  # Une seule création de chaîne

Indexation et accès aux caractères

Les chaînes de caractères sont des séquences ordonnées, ce qui permet d'accéder à leurs caractères individuels par leur position (index). L'indexation commence à 0 pour le premier caractère.

indexation_chaine.py
# Indexation positive (de gauche à droite)
chaine = "Python"

print("Premier caractère:", chaine[0])   # P
print("Deuxième caractère:", chaine[1])  # y
print("Troisième caractère:", chaine[2]) # t
print("Dernier caractère:", chaine[5])   # n

# Indexation négative (de droite à gauche)
print("Dernier caractère:", chaine[-1])  # n
print("Avant-dernier:", chaine[-2])     # o
print("Premier caractère:", chaine[-6]) # P

# Tentative d'accès hors limites
try:
    print(chaine[10])  # IndexError: string index out of range
except IndexError as e:
    print("Erreur:", e)

# Parcours d'une chaîne caractère par caractère
print("Parcours avec for:")
for caractere in chaine:
    print(caractere, end=" ")  # P y t h o n

print("\nParcours avec index:")
for i in range(len(chaine)):
    print(f"chaine[{i}] = {chaine[i]}")

# Vérification d'appartenance
print("'P' dans chaine:", 'P' in chaine)    # True
print("'z' dans chaine:", 'z' in chaine)    # False
print("'thon' dans chaine:", 'thon' in chaine) # True

Longueur d'une chaîne avec len()

La fonction intégrée len() permet de déterminer le nombre de caractères contenus dans une chaîne. C'est une opération très courante et rapide en Python.

longueur_chaine.py
# Utilisation de len() avec différentes chaînes
chaine_vide = ""
chaine_simple = "Hello"
chaine_espaces = "   "
chaine_speciale = "Café"  # Caractères accentués
chaine_emoji = "Python ?"  # Avec emoji

print(f"'{chaine_vide}' a une longueur de {len(chaine_vide)}")        # 0
print(f"'{chaine_simple}' a une longueur de {len(chaine_simple)}")    # 5
print(f"'{chaine_espaces}' a une longueur de {len(chaine_espaces)}")  # 3
print(f"'{chaine_speciale}' a une longueur de {len(chaine_speciale)}") # 4
print(f"'{chaine_emoji}' a une longueur de {len(chaine_emoji)}")      # 8 (7 caractères + 1 emoji)

# Applications pratiques de len()
mot_de_passe = "secret123"

# Validation de longueur
if len(mot_de_passe) < 8:
    print("Le mot de passe est trop court")
else:
    print("Longueur de mot de passe acceptable")

# Parcours sécurisé avec connaissance de la longueur
texte = "Bonjour"
for i in range(len(texte)):
    print(f"Caractère à l'index {i}: {texte[i]}")

# Comparaison de longueurs
chaine1 = "court"
chaine2 = "beaucoup plus long"

if len(chaine1) > len(chaine2):
    print(f"'{chaine1}' est plus long que '{chaine2}'")
else:
    print(f"'{chaine2}' est plus long que '{chaine1}'")

# Attention: len() compte les caractères, pas les mots
phrase = "Python est génial"
print(f"'{phrase}' a {len(phrase)} caractères et {len(phrase.split())} mots")

Manipulation de base

Les opérations de base sur les chaînes de caractères incluent la concaténation (assemblage), la répétition et la comparaison. Ces opérations fondamentales sont essentielles pour manipuler efficacement le texte en Python.

Concaténation de chaînes

La concaténation est l'opération qui consiste à assembler plusieurs chaînes de caractères en une seule. En Python, on peut utiliser l'opérateur + ou la méthode join().

concatenation.py
# Concaténation avec l'opérateur +
					prenom = "Jean"
					nom = "Dupont"
					nom_complet = prenom + " " + nom
					print(nom_complet)  # Jean Dupont
					
					# Concaténation avec des littéraux
					message = "Bonjour " + prenom + ", comment allez-vous?"
					print(message)  # Bonjour Jean, comment allez-vous?
					
					# Concaténation avec des variables de différents types
					age = 25
					info = prenom + " a " + str(age) + " ans"
					print(info)  # Jean a 25 ans
					
					# Concaténation avec la méthode join() (plus efficace pour plusieurs chaînes)
					mots = ["Python", "est", "un", "langage", "puissant"]
					phrase = " ".join(mots)
					print(phrase)  # Python est un langage puissant
					
					# Join avec un séparateur différent
					chemin = "/".join(["dossier", "sous-dossier", "fichier.txt"])
					print(chemin)  # dossier/sous-dossier/fichier.txt
					
					# Attention: l'opérateur + crée une nouvelle chaîne à chaque utilisation
					# Ce qui peut être inefficace pour de nombreuses concaténations
					resultat = ""
					for i in range(10):
					    resultat += str(i)  # Peu efficace pour de grandes boucles
					print(resultat)  # 0123456789
					
					# Méthode plus efficace avec une liste et join()
					parties = []
					for i in range(10):
					    partes.append(str(i))
					resultat = "".join(parties)  # Beaucoup plus efficace
					print(resultat)  # 0123456789

Répétition de chaînes

L'opérateur * permet de répéter une chaîne de caractères un certain nombre de fois. C'est utile pour créer des séparateurs, des motifs ou des chaînes de remplissage.

repetition.py
# Répétition simple avec l'opérateur *
					separateur = "-" * 20
					print(separateur)  # --------------------
					
					# Création de motifs
					motif = "*-" * 10
					print(motif)  # *-*-*-*-*-*-*-*-*-*-
					
					# Répétition de séquences plus complexes
					applaudissements = "?" * 5
					print(applaudissements)  # ?????
					
					# Utilisation pratique pour l'alignement de texte
					titre = "RAPPORT"
					largeur = 30
					espaces_avant = " " * ((largeur - len(titre)) // 2)
					ligne = espaces_avant + titre
					print(ligne)
					
					# Création d'une bordure
					bordure = "#" * largeur
					print(bordure)
					print(ligne)
					print(bordure)
					
					# Répétition avec 0 ou nombre négatif
					vide = "abc" * 0
					print("Chaîne vide:", vide, "Longueur:", len(vide))  # Chaîne vide:  Longueur: 0
					
					# La répétition avec un nombre négatif retourne une chaîne vide
					vide_neg = "abc" * -5
					print("Répétition négative:", vide_neg, "Longueur:", len(vide_neg))  # Longueur: 0
					
					# Combinaison de concaténation et répétition
					indentation = "  " * 3 + "→ "
					texte = "élément de liste"
					print(indentation + texte)  #       → élément de liste

Comparaison de chaînes

Python permet de comparer des chaînes de caractères à l'aide des opérateurs de comparaison standards. Les comparaisons sont effectuées caractère par caractère selon l'ordre lexicographique (ordre du dictionnaire).

comparaison.py
# Comparaisons de base
					chaine1 = "apple"
					chaine2 = "banana"
					
					print("apple == banana:", chaine1 == chaine2)  # False
					print("apple != banana:", chaine1 != chaine2)  # True
					print("apple < banana:", chaine1 < chaine2)    # True (a vient avant b)
					print("apple > banana:", chaine1 > chaine2)    # False
					
					# Comparaison avec la même chaîne
					print("apple == apple:", chaine1 == "apple")  # True
					
					# Comparaison sensible à la casse
					minusc = "python"
					majusc = "PYTHON"
					
					print("python == PYTHON:", minusc == majusc)          # False
					print("python.lower() == PYTHON.lower():", minusc.lower() == majusc.lower())  # True
					
					# Comparaison de chaînes avec préfixes communs
					print("abc < abcd:", "abc" < "abcd")    # True (abc est plus court)
					print("abc < abd:", "abc" < "abd")      # True (c vient avant d)
					
					# Ordre lexicographique (comme dans un dictionnaire)
					mots = ["zèbre", "abeille", "chat", "banane"]
					mots_tries = sorted(mots)
					print("Mots triés:", mots_tries)  # ['abeille', 'banane', 'chat', 'zèbre']
					
					# Comparaison avec des nombres (conversion implicite impossible)
					try:
					    resultat = "10" > 5  # TypeError: '>' not supported between instances of 'str' and 'int'
					except TypeError as e:
					    print("Erreur:", e)
					
					# Comparaison correcte avec conversion explicite
					nombre_str = "10"
					nombre_int = 5
					print("10 > 5 (en nombre):", int(nombre_str) > nombre_int)  # True
					
					# Comparaisons avec opérateurs multiples
					chaine = "python"
					print("'p' <= chaine <= 'z':", 'p' <= chaine <= 'z')  # True
					print("'a' <= chaine <= 'm':", 'a' <= chaine <= 'm')  # False

Indexation et découpage (slicing)

L'indexation et le découpage sont des techniques fondamentales pour accéder et extraire des portions spécifiques d'une chaîne de caractères en Python.

Indexation positive et négative

Python permet d'accéder aux caractères d'une chaîne via deux systèmes d'indexation :

indexation_chaines.py
texte = "Python"

# Indexation positive (commence à 0)
# P y t h o n
# 0 1 2 3 4 5
premier = texte[0]  # 'P'
deuxieme = texte[1]  # 'y'
dernier = texte[5]  # 'n'

# Indexation négative (commence à -1 depuis la fin)
# P  y  t  h  o  n
# -6 -5 -4 -3 -2 -1
dernier_neg = texte[-1]  # 'n'
avant_dernier = texte[-2]  # 'o'
premier_neg = texte[-6]  # 'P'

Syntaxe du slicing

Le slicing permet d'extraire une sous-chaîne en utilisant la syntaxe [début:fin:pas] :

syntaxe_slicing.py
phrase = "Programmation Python"

# Syntaxe : [début:fin] (fin non incluse)
sous_chaine = phrase[0:11]  # "Programmation"
langage = phrase[13:19]  # "Python"

# Omission du début (par défaut 0)
debut = phrase[:11]  # "Programmation"

# Omission de la fin (par défaut jusqu'au bout)
fin = phrase[13:]  # "Python"

# Copie complète
copie = phrase[:]  # "Programmation Python"

# Avec des index négatifs
sans_dernier = phrase[:-1]  # "Programmation Pytho"
trois_derniers = phrase[-3:]  # "hon"

Pas (step) dans le slicing

Le paramètre 'pas' permet de contrôler l'intervalle entre les caractères extraits :

pas_slicing.py
alphabet = "ABCDEFGHIJKLMNOP"

# Pas de 2 (prendre un caractère sur deux)
un_sur_deux = alphabet[:10:2]  # "ACEGI"

# Pas de 3
un_sur_trois = alphabet[::3]  # "ADGJMP"

# Pas négatif (pour inverser)
inverse = alphabet[::-1]  # "PONMLKJIHGFEDCBA"

# Inverser une portion
portion_inverse = alphabet[3:8:-1]  # "" (vide car logique incorrecte)
portion_inverse_correcte = alphabet[8:3:-1]  # "IHGFE"

# Pas de 2 en arrière
arriere_deux = alphabet[::-2]  # "PNLJHFDB"

Exemples pratiques de découpage

Voici des exemples concrets d'utilisation du slicing dans des situations réelles :

exemples_pratiques_slicing.py
# Extraction d'informations d'une chaîne formatée
date = "2024-03-15"
annee = date[:4]  # "2024"
mois = date[5:7]  # "03"
jour = date[8:]  # "15"

# Nettoyage de données
email = "  utilisateur@domaine.com  "
nom_utilisateur = email.strip()[:email.find("@")]  # Extraction avant @
domaine = email.strip()[email.find("@")+1:]  # Extraction après @

# Manipulation de texte
phrase = "Bonjour tout le monde"
premiere_moitie = phrase[:len(phrase)//2]  # "Bonjour to"
deuxieme_moitie = phrase[len(phrase)//2:]  # "ut le monde"

# Vérifications avec slicing
url = "https://www.example.com/page"
est_https = url[:5] == "https"  # True
extension = url[-4:]  # "page" (pas d'extension ici)

# Création de patterns
mot = "DEVELOPPEMENT"
lettres_paires = mot[1::2]  # "EELPEENT"
lettres_impaires = mot[::2]  # "DVLOPEMN"

# Palindrome check
mot_test = "radar"
est_palindrome = mot_test == mot_test[::-1]  # True

Méthodes de transformation

Python offre plusieurs méthodes pour transformer les chaînes de caractères, permettant de modifier leur casse, supprimer les espaces superflus ou remplacer des parties de la chaîne.

Modification de la casse (upper, lower, title, capitalize)

Les méthodes de modification de casse permettent de changer la capitalisation des caractères dans une chaîne. Ces méthodes retournent toujours une nouvelle chaîne sans modifier l'originale.

modification_casse.py
# Méthodes de modification de casse
					chaine = "python est un langage de programmation"
					
					# upper() - Convertit toute la chaîne en majuscules
					majuscules = chaine.upper()
					print("upper():", majuscules)  # PYTHON EST UN LANGAGE DE PROGRAMMATION
					
					# lower() - Convertit toute la chaîne en minuscules
					texte_mixte = "PyThOn EsT GéNial"
					minuscules = texte_mixte.lower()
					print("lower():", minuscules)  # python est génial
					
					# title() - Convertit la première lettre de chaque mot en majuscule
					titre = chaine.title()
					print("title():", titre)  # Python Est Un Langage De Programmation
					
					# capitalize() - Convertit seulement la première lettre de la chaîne en majuscule
					capitalise = chaine.capitalize()
					print("capitalize():", capitalise)  # Python est un langage de programmation
					
					# swapcase() - Inverse la casse de tous les caractères
					inverse = "PyThOn".swapcase()
					print("swapcase():", inverse)  # pYtHoN
					
					# Cas particuliers avec des caractères Unicode
					texte_unicode = "café au lait"
					print("Unicode upper:", texte_unicode.upper())  # CAFÉ AU LAIT
					
					# Les méthodes de casse ne modifient pas la chaîne originale
					print("Original après upper:", chaine)  # python est un langage de programmation
					
					# Application pratique: normalisation pour la comparaison
					utilisateur_saisie = "Admin"
					utilisateur_db = "admin"
					
					if utilisateur_saisie.lower() == utilisateur_db.lower():
					    print("Utilisateur valide (comparaison insensible à la casse)")
					else:
					    print("Utilisateur invalide")
					
					# Application: formatage de noms propres
					nom_mal_formate = "jean-pierre dupont"
					nom_formate = nom_mal_formate.title()
					print("Nom formaté:", nom_formate)  # Jean-Pierre Dupont

Suppression d'espaces (strip, lstrip, rstrip)

Les méthodes de suppression d'espaces permettent de nettoyer les chaînes en enlevant les espaces superflus au début, à la fin ou des deux côtés. Elles sont particulièrement utiles pour le traitement des entrées utilisateur.

suppression_espaces.py
# Méthodes de suppression d'espaces
					chaine_avec_espaces = "   Hello World!   "
					
					# strip() - Supprime les espaces des deux côtés
					nettoyee = chaine_avec_espaces.strip()
					print(f"'{chaine_avec_espaces}' -> strip() -> '{nettoyee}'")  # 'Hello World!'
					
					# lstrip() - Supprime les espaces seulement à gauche (début)
					gauche = chaine_avec_espaces.lstrip()
					print(f"'{chaine_avec_espaces}' -> lstrip() -> '{gauche}'")  # 'Hello World!   '
					
					# rstrip() - Supprime les espaces seulement à droite (fin)
					droite = chaine_avec_espaces.rstrip()
					print(f"'{chaine_avec_espaces}' -> rstrip() -> '{droite}'")  # '   Hello World!'
					
					# Suppression de caractères spécifiques
					chaine_speciale = "***Hello!***"
					sans_etoiles = chaine_speciale.strip("*")
					print(f"'{chaine_speciale}' -> strip('*') -> '{sans_etoiles}'")  # 'Hello!'
					
					chaine_mixte = "  **  Hello  **  "
					nettoyee_mixte = chaine_mixte.strip()  # Enlève seulement les espaces
					print(f"'{chaine_mixte}' -> strip() -> '{nettoyee_mixte}'")  # '**  Hello  **'
					
					nettoyee_complete = chaine_mixte.strip().strip("*").strip()  # Enlève espaces puis * puis espaces
					print(f"'{chaine_mixte}' -> multiples strips -> '{nettoyee_complete}'")  # 'Hello'
					
					# Application pratique: nettoyage d'entrées utilisateur
					email_saisi = "  USER@EXAMPLE.COM  "
					email_normalise = email_saisi.strip().lower()
					print(f"Email normalisé: '{email_normalise}'")  # 'user@example.com'
					
					# Traitement de données CSV
					ligne_csv = "  Alice, 25, Ingenieur  \n"
					champs = [champ.strip() for champ in ligne_csv.strip().split(",")]
					print("Champs nettoyés:", champs)  # ['Alice', '25', 'Ingenieur']
					
					# Les méthodes de suppression ne modifient pas la chaîne originale
					print("Original après strip:", f"'{chaine_avec_espaces}'")  # '   Hello World!   '
					
					# Attention: strip() enlève aussi les tabulations et retours à la ligne
					chaine_avec_whitespace = "\t\n  Hello  \t\n"
					nettoyee_whitespace = chaine_avec_whitespace.strip()
					print(f"Whitespace: '{chaine_avec_whitespace}' -> '{nettoyee_whitespace}'")  # 'Hello'

Remplacement de caractères (replace)

La méthode replace() permet de remplacer toutes les occurrences d'une sous-chaîne par une autre dans une chaîne. Elle est très utile pour la modification et le nettoyage de texte.

remplacement.py
# Méthode replace()
					chaine = "J'aime le Java et le JavaScript"
					
					# Remplacer une sous-chaîne par une autre
					remplacee = chaine.replace("Java", "Python")
					print(f"'{chaine}' -> replace('Java', 'Python') -> '{remplacee}'")
					# J'aime le Python et le PythonScript
					
					# Remplacer avec un nombre limité d'occurrences
					remplacee_limitee = chaine.replace("Java", "Python", 1)
					print(f"'{chaine}' -> replace('Java', 'Python', 1) -> '{remplacee_limitee}'")
					# J'aime le Python et le JavaScript
					
					# Remplacer des caractères individuels
					texte = "café"
					sans_accents = texte.replace("é", "e")
					print(f"'{texte}' -> replace('é', 'e') -> '{sans_accents}'")  # 'cafe'
					
					# Supprimer des caractères (remplacer par une chaîne vide)
					numero_telephone = "+33 (0)1 23 45 67 89"
					numero_nettoye = numero_telephone.replace(" ", "").replace("(", "").replace(")", "").replace("-", "")
					print(f"Téléphone nettoyé: '{numero_nettoye}'")  # '+330123456789'
					
					# Application: correction d'erreurs courantes
					texte_avec_erreurs = "J'ai recu votre message. C'etait genial!"
					texte_corrige = texte_avec_erreurs.replace("recu", "reçu").replace("etait", "était").replace("genial", "génial")
					print(f"Texte corrigé: '{texte_corrige}'")
					# J'ai reçu votre message. C'était génial!
					
					# Application: formatage de texte
					texte_markdown = "# Titre **important**"
					texte_html = texte_markdown.replace("# ", "<h1>").replace("**", "<strong>")
					print(f"HTML: '{texte_html}'")  # '<h1>Titre <strong>important<strong>'
					
					# La méthode replace() est sensible à la casse
					texte = "Python python PYTHON"
					remplace = texte.replace("python", "Java")
					print(f"'{texte}' -> replace('python', 'Java') -> '{remplace}'")  # 'Python Java PYTHON'
					
					# Pour un remplacement insensible à la casse, on peut utiliser une approche différente
					import re
					texte = "Python python PYTHON"
					remplace_insensible = re.sub("python", "Java", texte, flags=re.IGNORECASE)
					print(f"Remplacement insensible: '{remplace_insensible}'")  # 'Java Java Java'
					
					# replace() ne modifie pas la chaîne originale
					print("Original après replace:", chaine)  # J'aime le Java et le JavaScript

Méthodes de recherche et vérification

Python offre de nombreuses méthodes pour rechercher des éléments dans les chaînes et vérifier leurs propriétés, facilitant l'analyse et la validation de données textuelles.

Recherche de sous-chaînes (find, index, in)

Python propose plusieurs méthodes pour localiser des sous-chaînes dans une chaîne :

recherche_sous_chaines.py
texte = "Python est un langage de programmation puissant"

# Méthode find() - retourne l'index ou -1 si non trouvé
position = texte.find("langage")  # 15
non_trouve = texte.find("Java")  # -1

# find() avec positions de début et fin
position_limitee = texte.find("de", 10, 30)  # 23

# Méthode index() - similaire à find() mais lève une exception
index_trouve = texte.index("Python")  # 0
# texte.index("Java")  # ValueError: substring not found

# Opérateur 'in' - retourne True/False
contient = "programmation" in texte  # True
ne_contient_pas = "Java" in texte  # False

# Recherche depuis la fin avec rfind() et rindex()
texte_double = "Python langage Python"
derniere_position = texte_double.rfind("Python")  # 15
premiere_position = texte_double.find("Python")  # 0

Vérification du contenu (startswith, endswith)

Ces méthodes permettent de vérifier si une chaîne commence ou se termine par une sous-chaîne spécifique :

verification_contenu.py
fichier = "document.pdf"
url = "https://www.python.org"
nom = "Mr. Dupont"

# Vérification du début avec startswith()
est_https = url.startswith("https")  # True
est_monsieur = nom.startswith("Mr.")  # True
est_madame = nom.startswith("Mme")  # False

# Vérification de la fin avec endswith()
est_pdf = fichier.endswith(".pdf")  # True
est_org = url.endswith(".org")  # True
est_com = url.endswith(".com")  # False

# Vérification avec plusieurs possibilités (tuple)
extensions_images = (".jpg", ".png", ".gif", ".bmp")
photo = "vacation.jpg"
est_image = photo.endswith(extensions_images)  # True

protocoles = ("http://", "https://", "ftp://")
site = "ftp://files.example.com"
est_protocole_valide = site.startswith(protocoles)  # True

# Avec positions de début et fin
chemin = "/home/user/documents/file.txt"
commence_par_home = chemin.startswith("home", 1)  # True (à partir de l'index 1)

Tests sur le type de caractères (isdigit, isalpha, isalnum)

Ces méthodes permettent de tester la nature des caractères composant une chaîne :

tests_type_caracteres.py
# Tests de base
nombre = "12345"
lettres = "Python"
mixte = "Python3"
espaces = "   "
vide = ""

# isdigit() - vérifie si tous les caractères sont des chiffres
print(nombre.isdigit())  # True
print(lettres.isdigit())  # False
print(mixte.isdigit())  # False

# isalpha() - vérifie si tous les caractères sont des lettres
print(lettres.isalpha())  # True
print(nombre.isalpha())  # False
print(mixte.isalpha())  # False

# isalnum() - vérifie si tous les caractères sont alphanumérique
print(mixte.isalnum())  # True
print(lettres.isalnum())  # True
print(nombre.isalnum())  # True

# Autres tests utiles
phrase = "Hello World"
minuscules = "hello"
majuscules = "HELLO"
titre = "Hello World"

# isspace() - vérifie si tous les caractères sont des espaces
print(espaces.isspace())  # True
print(phrase.isspace())  # False

# islower() - vérifie si tous les caractères sont en minuscules
print(minuscules.islower())  # True
print(majuscules.islower())  # False

# isupper() - vérifie si tous les caractères sont en majuscules
print(majuscules.isupper())  # True
print(minuscules.isupper())  # False

# istitle() - vérifie si la chaîne est en format titre
print(titre.istitle())  # True
print(minuscules.istitle())  # False

# Exemples pratiques de validation
code_postal = "75001"
nom_utilisateur = "user123"
mot_de_passe = "MonMotDePasse"

est_code_postal_valide = code_postal.isdigit() and len(code_postal) == 5
est_nom_utilisateur_valide = nom_utilisateur.isalnum()
contient_lettres = any(c.isalpha() for c in mot_de_passe)
contient_majuscule = any(c.isupper() for c in mot_de_passe)

Division et assemblage de chaînes

Python offre plusieurs méthodes puissantes pour diviser des chaînes en éléments plus petits ou pour assembler plusieurs éléments en une seule chaîne. Ces opérations sont essentielles pour le traitement de texte et la manipulation de données.

Division avec split()

La méthode split() permet de diviser une chaîne en une liste d'éléments selon un séparateur :

division_split.py
# Division avec séparateur par défaut (espaces)
phrase = "Bonjour le monde Python"
mots = phrase.split()
print(mots)  # ['Bonjour', 'le', 'monde', 'Python']

# Division avec un séparateur spécifique
fruits = "pomme,banane,orange,kiwi"
liste_fruits = fruits.split(",")
print(liste_fruits)  # ['pomme', 'banane', 'orange', 'kiwi']

# Limiter le nombre de divisions
texte = "un-deux-trois-quatre"
result = texte.split("-", 2)  # Divise seulement 2 fois
print(result)  # ['un', 'deux', 'trois-quatre']

# Division par lignes
texte_multiligne = "Ligne 1\nLigne 2\nLigne 3"
lignes = texte_multiligne.split("\n")
print(lignes)  # ['Ligne 1', 'Ligne 2', 'Ligne 3']

Assemblage avec join()

La méthode join() est l'inverse de split() : elle assemble une liste de chaînes en une seule chaîne :

assemblage_join.py
# Assemblage avec un séparateur
mots = ["Python", "est", "fantastique"]
phrase = " ".join(mots)
print(phrase)  # "Python est fantastique"

# Assemblage avec virgules
fruits = ["pomme", "banane", "orange"]
liste_csv = ",".join(fruits)
print(liste_csv)  # "pomme,banane,orange"

# Assemblage sans séparateur
lettres = ["P", "y", "t", "h", "o", "n"]
mot = "".join(lettres)
print(mot)  # "Python"

# Assemblage avec saut de ligne
lignes = ["Première ligne", "Deuxième ligne", "Troisième ligne"]
texte_final = "\n".join(lignes)
print(texte_final)
# Première ligne
# Deuxième ligne
# Troisième ligne

Partition avec partition() et rpartition()

Les méthodes partition() et rpartition() divisent une chaîne en exactement 3 parties :

partition_chaines.py
# partition() - divise depuis le début
email = "utilisateur@exemple.com"
avant, sep, apres = email.partition("@")
print(f"Avant: '{avant}'")  # Avant: 'utilisateur'
print(f"Séparateur: '{sep}'")  # Séparateur: '@'
print(f"Après: '{apres}'")  # Après: 'exemple.com'

# rpartition() - divise depuis la fin
chemin = "/home/user/documents/fichier.txt"
repertoire, sep, nom_fichier = chemin.rpartition("/")
print(f"Répertoire: '{repertoire}'")  # Répertoire: '/home/user/documents'
print(f"Nom fichier: '{nom_fichier}'")  # Nom fichier: 'fichier.txt'

# Cas où le séparateur n'existe pas
texte = "pas de séparateur"
avant, sep, apres = texte.partition("|")
print(f"Avant: '{avant}'")  # Avant: 'pas de séparateur'
print(f"Séparateur: '{sep}'")  # Séparateur: ''
print(f"Après: '{apres}'")  # Après: ''

# Exemple pratique : analyse d'URL
url = "https://www.exemple.com/page?param=valeur"
base, sep, params = url.partition("?")
print(f"URL de base: {base}")  # URL de base: https://www.exemple.com/page
print(f"Paramètres: {params}")  # Paramètres: param=valeur

Formatage de chaînes

Python propose plusieurs méthodes pour formater des chaînes de caractères, permettant d'insérer des variables et de contrôler leur présentation. Chaque méthode a ses avantages selon le contexte d'utilisation.

Formatage avec l'opérateur %

L'opérateur % est la méthode de formatage la plus ancienne, inspirée du langage C :

formatage_operateur.py
# Formatage de base avec %
nom = "Alice"
age = 25
message = "Je m'appelle %s et j'ai %d ans" % (nom, age)
print(message)  # Je m'appelle Alice et j'ai 25 ans

# Spécificateurs de format courants
entier = 42
flottant = 3.14159
texte = "Python"

print("Entier: %d" % entier)  # Entier: 42
print("Flottant: %f" % flottant)  # Flottant: 3.141590
print("Texte: %s" % texte)  # Texte: Python
print("Hexadécimal: %x" % entier)  # Hexadécimal: 2a

# Contrôle de la précision
pi = 3.14159265359
print("Pi avec 2 décimales: %.2f" % pi)  # Pi avec 2 décimales: 3.14
print("Pi avec 4 décimales: %.4f" % pi)  # Pi avec 4 décimales: 3.1416

# Formatage avec dictionnaire
personne = {"nom": "Bob", "age": 30, "ville": "Paris"}
info = "%(nom)s, %(age)d ans, habite à %(ville)s" % personne
print(info)  # Bob, 30 ans, habite à Paris

Méthode format()

La méthode format() offre plus de flexibilité et de lisibilité que l'opérateur % :

methode_format.py
# Formatage de base avec format()
nom = "Claire"
age = 28
message = "Je m'appelle {} et j'ai {} ans".format(nom, age)
print(message)  # Je m'appelle Claire et j'ai 28 ans

# Formatage avec index
template = "Le {1} coûte {0} euros"
prix_message = template.format(15.50, "livre")
print(prix_message)  # Le livre coûte 15.5 euros

# Formatage avec noms
produit = "Produit: {nom}, Prix: {prix} €, Stock: {stock}"
info_produit = produit.format(nom="Ordinateur", prix=899.99, stock=5)
print(info_produit)  # Produit: Ordinateur, Prix: 899.99 €, Stock: 5

# Formatage avec objets et attributs
class Point:
    def __init__(self, x, y):
        self.x = x
        self.y = y

p = Point(3, 4)
coord = "Point: ({0.x}, {0.y})".format(p)
print(coord)  # Point: (3, 4)

# Formatage avec dictionnaire
donnees = {"nom": "Python", "version": 3.9}
info = "Langage: {nom}, Version: {version}".format(**donnees)
print(info)  # Langage: Python, Version: 3.9

f-strings (formatted string literals)

Les f-strings, introduites en Python 3.6, offrent la syntaxe la plus moderne et lisible :

f_strings.py
# F-strings de base
nom = "David"
age = 35
message = f"Je m'appelle {nom} et j'ai {age} ans"
print(message)  # Je m'appelle David et j'ai 35 ans

# Expressions dans les f-strings
x = 10
y = 5
resultat = f"La somme de {x} et {y} est {x + y}"
print(resultat)  # La somme de 10 et 5 est 15

# Appel de méthodes dans les f-strings
texte = "python"
formatted = f"Texte en majuscules: {texte.upper()}"
print(formatted)  # Texte en majuscules: PYTHON

# Formatage de nombres
prix = 1234.5678
devise = f"Prix: {prix:.2f} €"
print(devise)  # Prix: 1234.57 €

# Formatage avec objets
class Personne:
    def __init__(self, nom, profession):
        self.nom = nom
        self.profession = profession

p = Personne("Marie", "Développeuse")
presentation = f"{p.nom} est {p.profession.lower()}"
print(presentation)  # Marie est développeuse

# F-strings multilignes
nom_complet = "Jean Dupont"
email = "jean.dupont@email.com"
carte_visite = f"""
Nom: {nom_complet}
Email: {email}
Statut: {'Actif' if True else 'Inactif'}
"""
print(carte_visite)

Formatage avancé (alignement, précision)

Python offre de nombreuses options pour contrôler précisément l'affichage des données :

formatage_avance.py
# Alignement et largeur de champ
nom = "Python"
print(f"Gauche:    '{nom:<15}'")  # Gauche:    'Python         '
print(f"Centré:    '{nom:^15}'")  # Centré:    '    Python     '
print(f"Droite:    '{nom:>15}'")  # Droite:    '         Python'

# Remplissage avec caractères personnalisés
titre = "MENU"
print(f"{titre:=^20}")  # ========MENU========
print(f"{titre:-^20}")  # --------MENU--------
print(f"{titre:*^20}")  # ********MENU********

# Formatage des nombres
nombre = 1234567.89
print(f"Séparateurs de milliers: {nombre:,}")  # 1,234,567.89
print(f"Notation scientifique: {nombre:.2e}")  # 1.23e+06
print(f"Pourcentage: {0.75:.1%}")  # 75.0%

# Zéros de tête pour les nombres
numero = 42
print(f"Numéro: {numero:05d}")  # Numéro: 00042
print(f"Hexadécimal: 0x{numero:04x}")  # Hexadécimal: 0x002a

# Formatage des dates et heures
from datetime import datetime
maintenant = datetime.now()
print(f"Date: {maintenant:%d/%m/%Y}")
print(f"Heure: {maintenant:%H:%M:%S}")
print(f"Complet: {maintenant:%A %d %B %Y à %H:%M}")

# Tableau formaté
produits = [
    ("Pomme", 1.50, 120),
    ("Banane", 0.80, 85),
    ("Orange", 2.20, 200)
]

print(f"{'Produit':<10} {'Prix':>8} {'Stock':>8}")
print("-" * 30)
for nom, prix, stock in produits:
    print(f"{nom:<10} {prix:>8.2f} {stock:>8d}")

Caractères spéciaux et échappement

Python permet d'utiliser des caractères spéciaux dans les chaînes grâce aux séquences d'échappement. Il existe également des méthodes pour traiter les chaînes brutes et gérer l'Unicode.

Séquences d'échappement (\n, \t, \, etc.)

Les séquences d'échappement permettent d'insérer des caractères spéciaux dans les chaînes :

sequences_echappement.py
# Séquences d'échappement courantes
print("Ligne 1\nLigne 2")  # \n = saut de ligne
# Ligne 1
# Ligne 2

print("Nom:\tPrénom")  # \t = tabulation
# Nom:    Prénom

print("Il a dit: \"Bonjour!\"")  # \" = guillemet double
# Il a dit: "Bonjour!"

print('Elle a dit: \'Salut!\'')  # \' = guillemet simple
# Elle a dit: 'Salut!'

print("Chemin: C:\\Users\\Documents")  # \\ = antislash littéral
# Chemin: C:\Users\Documents

# Autres séquences utiles
print("Retour\rchariot")  # \r = retour chariot
print("Avant\bArrière")  # \b = retour arrière
print("Signal\a")  # \a = signal sonore (bell)
print("Saut\fde page")  # \f = saut de page
print("Tab\vverticale")  # \v = tabulation verticale

# Caractères par code ASCII/Unicode
print("\101\102\103")  # Codes octaux: ABC
print("\x41\x42\x43")  # Codes hexadécimaux: ABC

# Création d'un menu formaté
menu = """
====== MENU PRINCIPAL ======
1.\tNouveau fichier
2.\tOuvrir fichier
3.\tEnregistrer
4.\tQuitter
============================
Votre choix: """
print(menu)

Chaînes brutes (raw strings)

Les chaînes brutes (raw strings) traitent les antislashs comme des caractères littéraux :

chaines_brutes.py
# Comparaison chaîne normale vs raw string
normale = "C:\nouveau\texte\fichier.txt"
brute = r"C:\nouveau\texte\fichier.txt"

print("Normale:", normale)  # Interprète \n et \t comme séquences
print("Brute:", brute)    # Garde les antislashs littéralement

# Utilisation pour les chemins Windows
chemin_windows = r"D:\Mes Documents\Projets\Python\script.py"
print(chemin_windows)

# Expressions régulières (très utile avec raw strings)
import re

# Sans raw string (difficile à lire)
pattern1 = "\\d+\\.\\d+"  # Pour matcher des nombres décimaux

# Avec raw string (plus lisible)
pattern2 = r"\d+\.\d+"  # Même résultat, plus clair

texte = "Le prix est 19.99 euros"
resultat = re.search(pattern2, texte)
print(f"Prix trouvé: {resultat.group()}")  # Prix trouvé: 19.99

# Raw strings pour documentation/templates
template_sql = r"""
SELECT * FROM users 
WHERE name LIKE '%{name}%' 
AND age > {min_age}
ORDER BY created_at DESC;
"""

requete = template_sql.format(name="Jean", min_age=18)
print(requete)

Caractères Unicode

Python 3 gère nativement l'Unicode, permettant d'utiliser des caractères de toutes les langues :

caracteres_unicode.py
# Caractères Unicode directs
print("Français: Bonjour! ??")
print("Español: ¡Hola! ??")
print("中文: 你好! ??")
print("العربية: مرحبا! ??")
print("Русский: Привет! ??")

# Caractères Unicode par code
print("\u0048\u0065\u006c\u006c\u006f")  # Hello
print("\u03B1\u03B2\u03B3")  # αβγ (grec)
print("\u2764\uFE0F")  # ❤️ (cœur rouge)

# Symboles mathématiques et scientifiques
formule = "E = mc² (où c ≈ 3×10⁸ m/s)"
print(formule)

mathematiques = "∀x ∈ ℝ: √x² = |x| ∧ π ≈ 3.14159"
print(mathematiques)

# Émojis et symboles modernes
statut = "✅ Terminé | ⚠️ Attention | ❌ Erreur | ? En cours"
print(statut)

# Fonctions utiles pour Unicode
caractere = "é"
print(f"Caractère: {caractere}")
print(f"Code Unicode: {ord(caractere)}")  # Code Unicode: 233
print(f"Nom Unicode: {caractere.encode('unicode_escape').decode()}")

# Conversion inverse
code = 233
print(f"Code {code} = '{chr(code)}'")  # Code 233 = 'é'

# Normalisation Unicode (important pour les comparaisons)
import unicodedata

texte1 = "café"  # é comme un seul caractère
texte2 = "cafe\u0301"  # e + accent aigu combiné

print(f"Texte 1: {texte1} (longueur: {len(texte1)})")
print(f"Texte 2: {texte2} (longueur: {len(texte2)})")
print(f"Égaux? {texte1 == texte2}")  # False!

# Normalisation pour comparaison correcte
norm1 = unicodedata.normalize('NFC', texte1)
norm2 = unicodedata.normalize('NFC', texte2)
print(f"Après normalisation: {norm1 == norm2}")  # True!

Exercices pratiques et applications

Cette section présente des exercices pratiques et des applications concrètes pour maîtriser la manipulation des chaînes de caractères en Python.

Validation de données textuelles

La validation de données textuelles est essentielle dans de nombreuses applications. Voici des exemples de validation courante :

validation_donnees.py
# Validation d'une adresse email
def valider_email(email):
    if "@" not in email:
        return False
    parties = email.split("@")
    if len(parties) != 2:
        return False
    nom, domaine = parties
    return len(nom) > 0 and "." in domaine

# Validation d'un numéro de téléphone français
def valider_telephone_fr(numero):
    # Supprimer les espaces et tirets
    numero = numero.replace(" ", "").replace("-", "")
    # Vérifier que c'est uniquement des chiffres
    if not numero.isdigit():
        return False
    # Vérifier la longueur
    if len(numero) == 10 and numero.startswith("0"):
        return True
    return False

# Validation d'un mot de passe fort
def valider_mot_de_passe(mdp):
    if len(mdp) < 8:
        return False, "Trop court (minimum 8 caractères)"
    if not any(c.isupper() for c in mdp):
        return False, "Doit contenir une majuscule"
    if not any(c.islower() for c in mdp):
        return False, "Doit contenir une minuscule"
    if not any(c.isdigit() for c in mdp):
        return False, "Doit contenir un chiffre"
    return True, "Mot de passe valide"

Nettoyage et traitement de texte

Le nettoyage de texte est crucial pour le traitement de données textuelles :

nettoyage_texte.py
# Nettoyer un texte : supprimer les caractères indésirables
def nettoyer_texte(texte):
    # Supprimer les espaces en début/fin
    texte = texte.strip()
    # Remplacer les espaces multiples par un seul
    while "  " in texte:
        texte = texte.replace("  ", " ")
    # Supprimer les caractères de ponctuation
    ponctuation = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
    for p in ponctuation:
        texte = texte.replace(p, "")
    return texte

# Compter les mots dans un texte
def compter_mots(texte):
    texte_nettoye = nettoyer_texte(texte.lower())
    mots = texte_nettoye.split()
    compteur = {}
    for mot in mots:
        compteur[mot] = compteur.get(mot, 0) + 1
    return compteur

# Extraire les mots-clés (mots de plus de 4 lettres)
def extraire_mots_cles(texte):
    texte_nettoye = nettoyer_texte(texte.lower())
    mots = texte_nettoye.split()
    mots_cles = [mot for mot in mots if len(mot) > 4]
    return list(set(mots_cles))  # Supprimer les doublons

# Censurer des mots interdits
def censurer_texte(texte, mots_interdits):
    for mot in mots_interdits:
        etoiles = "*" * len(mot)
        texte = texte.replace(mot, etoiles)
    return texte

Manipulation de noms et adresses

Traitement et formatage de données personnelles comme les noms et adresses :

manipulation_noms.py
# Formater un nom proprement
def formater_nom(nom_complet):
    # Nettoyer et diviser le nom
    parties = nom_complet.strip().split()
    # Mettre en forme : première lettre majuscule, reste minuscule
    nom_formate = " ".join([partie.capitalize() for partie in parties])
    return nom_formate

# Extraire le prénom et le nom de famille
def extraire_prenom_nom(nom_complet):
    parties = formater_nom(nom_complet).split()
    if len(parties) >= 2:
        prenom = parties[0]
        nom = " ".join(parties[1:])
        return prenom, nom
    return parties[0], ""

# Créer des initiales
def generer_initiales(nom_complet):
    parties = formater_nom(nom_complet).split()
    initiales = "".join([partie[0].upper() for partie in parties])
    return initiales

# Formater une adresse
def formater_adresse(numero, rue, ville, code_postal):
    # Formater chaque partie
    rue_formatee = rue.title()
    ville_formatee = ville.upper()
    code_postal = code_postal.strip()
    
    # Assembler l'adresse
    adresse = f"{numero} {rue_formatee}\n{code_postal} {ville_formatee}"
    return adresse

# Extraire le code postal d'une adresse
def extraire_code_postal(adresse):
    mots = adresse.split()
    for mot in mots:
        if mot.isdigit() and len(mot) == 5:
            return mot
    return None

Projets concrets

Voici des projets complets utilisant les chaînes de caractères :

projets_concrets.py
# Projet 1: Générateur de mots de passe
import random
import string

def generer_mot_de_passe(longueur=12, inclure_majuscules=True, 
                             inclure_chiffres=True, inclure_symboles=True):
    caracteres = string.ascii_lowercase
    if inclure_majuscules:
        caracteres += string.ascii_uppercase
    if inclure_chiffres:
        caracteres += string.digits
    if inclure_symboles:
        caracteres += "!@#$%^&*"
    
    mot_de_passe = "".join(random.choice(caracteres) for _ in range(longueur))
    return mot_de_passe

# Projet 2: Analyseur de texte simple
def analyser_texte(texte):
    # Statistiques de base
    nb_caracteres = len(texte)
    nb_caracteres_sans_espaces = len(texte.replace(" ", ""))
    nb_mots = len(texte.split())
    nb_phrases = texte.count(".") + texte.count("!") + texte.count("?")
    nb_paragraphes = texte.count("\n\n") + 1
    
    # Retourner un dictionnaire avec les statistiques
    return {
        "caracteres": nb_caracteres,
        "caracteres_sans_espaces": nb_caracteres_sans_espaces,
        "mots": nb_mots,
        "phrases": nb_phrases,
        "paragraphes": nb_paragraphes,
        "mots_par_phrase": nb_mots / nb_phrases if nb_phrases > 0 else 0
    }

# Projet 3: Convertisseur de casse
def convertir_casse(texte, type_casse):
    conversions = {
        "snake_case": lambda t: t.lower().replace(" ", "_"),
        "camelCase": lambda t: t.split()[0].lower() + "".join(mot.capitalize() for mot in t.split()[1:]),
        "PascalCase": lambda t: "".join(mot.capitalize() for mot in t.split()),
        "kebab-case": lambda t: t.lower().replace(" ", "-"),
        "SCREAMING_SNAKE_CASE": lambda t: t.upper().replace(" ", "_")
    }
    
    if type_casse in conversions:
        return conversions[type_casse](texte)
    return texte
Contact

📚 Cours à distance

Apprends à coder en Python, Java, C/C++
avec des cours à distance via Google Meet.

Appelez-maintenant
By Rachid Saad

Rejoignez notre communauté d'apprentissage à distance

Explorez nos cours à distance. Commencez votre apprentissage dès aujourd'hui!

Revenir aux chapitres : Python les Bases | Allez au cours gratuits