Traitement de texte

Le texte est partout

Le texte est la forme la plus courante de données que traite un programme.

Domaine	Exemples de données textuelles
Web	Pages HTML, URLs, commentaires, messages
Science	Séquences d’ADN (ACGT), articles scientifiques, formules chimiques
Systèmes	Fichiers journaux, configurations, fichiers CSV
Jeux vidéo	Niveaux encodés, dialogues, sauvegardes
Linguistique	Corpus, traductions, correction orthographique

Un biologiste qui analyse une séquence d’ADN, un éditeur de jeu qui charge un niveau depuis un fichier, un data scientist qui nettoie un jeu de données — tous manipulent du texte.

Analogie fil conducteur

On va utiliser l’ADN comme exemple récurrent dans ce chapitre. Une séquence d’ADN comme ATGCGCATGC est juste une chaîne de caractères dont l’alphabet se limite à A, T, G, C. Ce qu’on apprend sur le texte général s’applique directement à ces séquences.

---

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

Une chaîne de caractères (string) est une séquence de caractères. Le mot-clé ici est séquence — comme une liste.

sequence = "ATGCGC"
message = 'Bonjour'

A T G C G C

B o n j o u r

Points communs avec les listes

Les chaînes partagent beaucoup de traits avec les listes.

Opération	Liste	Chaîne
Longueur	len([1, 2, 3]) → 3	len("ATG") → 3
Accès par indice	liste[0]	"ATG"[0] → 'A'
Tranchage	liste[1:3]	"ATGCGC"[1:3] → 'TG'
Appartenance	3 in [1, 2, 3]	"A" in "ATG" → True
Itération	for item in liste	for char in "ATG"
Concaténation	[1, 2] + [3, 4]	"AT" + "GC" → 'ATGC'
Répétition	[0] * 3 → [0, 0, 0]	"A" * 3 → 'AAA'

adn = "ATGCGCATGC"

print("Longueur :", len(adn))
print("Premier :", adn[0])
print("Dernier :", adn[-1])
print("Du 2e au 4e :", adn[1:4])
print("Inversée :", adn[::-1])

Résultat de l’exécution

Longueur : 10
Premier : A
Dernier : C
Du 2e au 4e : TGC
Inversée : CGTACGCGTA

La différence cruciale : l’immutabilité

Contrairement aux listes, les chaînes sont non modifiables (immutable).

liste = [1, 2, 3]
liste[0] = 99        # OK
print(liste)

texte = "ATG"
texte[0] = "G"       # TypeError !

Les chaînes sont immutables

Tu ne peux jamais modifier un caractère d’une chaîne par son indice. Toutes les “modifications” produisent en réalité une nouvelle chaîne.

C’est pour ça que toutes les méthodes de chaînes retournent une nouvelle chaîne plutôt que de modifier l’original.

---

Méthodes de transformation

Les méthodes de chaînes s’appellent avec la notation pointée et retournent une nouvelle chaîne.

Casse

texte = "atg cgc atg"

print(texte.upper())
print(texte.lower())
print(texte.capitalize())
print(texte.title())

Résultat de l’exécution

ATG CGC ATG
atg cgc atg
Atg cgc atg
Atg Cgc Atg

Espaces

donnees = "   ATGCGC   "

print("[" + donnees.strip() + "]")
print("[" + donnees.lstrip() + "]")
print("[" + donnees.rstrip() + "]")

Résultat de l’exécution

[ATGCGC]
[ATGCGC   ]
[   ATGCGC]

strip() et la saisie

.strip() est indispensable après input(). Si l’utilisateur tape un espace avant ou après, ça évite les comparaisons qui échouent silencieusement.

reponse = input("Continuer (o/n) ? ").strip().lower()
if reponse == "o":
    # ...

Remplacement

adn = "ATGCGCATGC"

# Remplacer toutes les occurrences
print(adn.replace("A", "a"))

# Limiter le nombre de remplacements
print(adn.replace("A", "a", 1))

Résultat de l’exécution

aTGCGCaTGC
aTGCGCATGC

Découpage et recollage

Ces deux méthodes sont inverses l’une de l’autre.

phrase = "chat chien oiseau poisson"

# split : chaîne → liste
mots = phrase.split(" ")
print(mots)

# join : liste → chaîne
rejoint = "-".join(mots)
print(rejoint)

Résultat de l’exécution

['chat', 'chien', 'oiseau', 'poisson']
chat-chien-oiseau-poisson

Sans argument, .split() découpe sur tous les espaces blancs (espaces, tabulations, retours à la ligne).

ligne_csv = "Alice,20,88.5,A"
champs = ligne_csv.split(",")
print(champs)

Résultat de l’exécution

['Alice', '20', '88.5', 'A']

La syntaxe de join

"-".join(liste) se lit à l’envers : on applique le séparateur sur la liste. C’est un peu contre-intuitif au début, mais on s’y habitue. Le séparateur peut être vide : "".join(liste) colle tous les éléments.

---

Méthodes de vérification

Ces méthodes retournent un booléen (True ou False).

Prédicats de contenu

print("12345".isdigit())
print("ATGCGC".isalpha())
print("ABC123".isalnum())
print("ABC 123".isalnum())    # Espace n'est pas alphanumérique

Résultat de l’exécution

True
True
True
False

Méthode	Teste si la chaîne contient
.isdigit()	Uniquement des chiffres (0-9)
.isalpha()	Uniquement des lettres
.isalnum()	Uniquement des lettres ou chiffres
.isspace()	Uniquement des espaces blancs
.isupper()	Uniquement des majuscules
.islower()	Uniquement des minuscules

Chaîne vide

Toutes ces méthodes retournent False pour une chaîne vide. "".isdigit() donne False.

Préfixes et suffixes

fichier = "donnees.csv"

print(fichier.startswith("donnees"))
print(fichier.endswith(".csv"))
print(fichier.endswith((".csv", ".txt", ".json")))

Résultat de l’exécution

True
True
True

Recherche

adn = "ATGCGCATGC"

print(adn.find("GC"))      # Position de la première occurrence
print(adn.find("TTT"))     # -1 si non trouvé
print(adn.count("GC"))     # Nombre d'occurrences

Résultat de l’exécution

3
-1
3

find() vs index()

.find() retourne -1 si la sous-chaîne n’existe pas. .index() lève une erreur. Utilise .find() si tu n’es pas sûr de la présence, .index() si l’absence serait un bug.

---

Indexage et itération

Parcours caractère par caractère

adn = "ATGCGC"

for base in adn:
    print(base)

Résultat de l’exécution

A
T
G
C
G
C

Parcours avec indice

adn = "ATGCGC"

for i, base in enumerate(adn):
    print("Position " + str(i) + " : " + base)

Résultat de l’exécution

Position 0 : A
Position 1 : T
Position 2 : G
Position 3 : C
Position 4 : G
Position 5 : C

Exemple : compter les bases

adn = "ATGCGCATGCAAATTTGGG"

a = adn.count("A")
t = adn.count("T")
g = adn.count("G")
c = adn.count("C")

print("A :", a)
print("T :", t)
print("G :", g)
print("C :", c)

# Teneur en GC (importante en biologie moléculaire)
teneur_gc = (g + c) / len(adn) * 100
print("Teneur en GC : " + format(teneur_gc, ".1f") + " %")

Résultat de l’exécution

A : 5
T : 4
G : 6
C : 4
Teneur en GC : 52.6 %

La fonction format()

format(teneur_gc, ".1f") formate un nombre selon un spec : ici, un flottant avec une décimale. On concatène ensuite avec + et le reste du message. Autres specs utiles :

• format(42, "05d") → "00042" (entier sur 5 chiffres avec zéros)
• format(0.125, ".2%") → "12.50%" (pourcentage)
• format(1234567, ",") → "1,234,567" (séparateur de milliers)

Concaténation par accumulation

Puisque les chaînes sont immutables, “construire” une chaîne se fait par concaténation ou via une liste.

# Construire la complémentaire d'un brin d'ADN
# A ↔ T, G ↔ C
adn = "ATGCGC"
complement = []

for base in adn:
    if base == "A":
        complement.append("T")
    elif base == "T":
        complement.append("A")
    elif base == "G":
        complement.append("C")
    elif base == "C":
        complement.append("G")

resultat = "".join(complement)
print("Original :", adn)
print("Complément :", resultat)

Résultat de l’exécution

Original : ATGCGC
Complément : TACGCG

Liste puis join

Accumuler dans une liste puis faire "".join(liste) est plus rapide que resultat = resultat + caractere dans une boucle, surtout pour de longues chaînes. Chaque + crée une nouvelle chaîne complète en mémoire.

---

---

NumPy pour l’analyse de séquences

Quand on analyse de grandes séquences (un gène complet fait des milliers de bases), les boucles Python deviennent lentes. NumPy permet des analyses vectorisées très rapides.

Convertir une chaîne en tableau

import numpy as np

adn = "ATGCGCATGC"
tableau = np.array(list(adn))
print(tableau)
print("Forme :", tableau.shape)
print("Type :", tableau.dtype)

Résultat de l’exécution

['A' 'T' 'G' 'C' 'G' 'C' 'A' 'T' 'G' 'C']
Forme : (10,)
Type : <U1

list("ATGC") découpe la chaîne en caractères. np.array(...) la transforme en tableau NumPy.

Comparaison vectorisée

On peut comparer tous les caractères à une valeur en une seule opération.

import numpy as np

adn = np.array(list("ATGCGCATGCAAATTTGGG"))

# Comparaison vectorisée : retourne un tableau de booléens
est_a = adn == "A"
print(est_a)

# Compter les True avec sum()
print("Nombre de A :", np.sum(est_a))

Résultat de l’exécution

[ True False False False False False  True False False False  True  True
  True False False False False False False]
Nombre de A : 5

Un tableau booléen peut être sommé directement : chaque True vaut 1, chaque False vaut 0.

Compter toutes les bases

import numpy as np

adn = np.array(list("ATGCGCATGCAAATTTGGG"))

for base in ["A", "T", "G", "C"]:
    compte = np.sum(adn == base)
    print(base + " : " + str(compte))

Résultat de l’exécution

A : 5
T : 4
G : 6
C : 4

Le résultat est identique à la version avec .count(), mais la structure s’étend naturellement à des analyses plus complexes.

Comparer deux séquences

import numpy as np

sequence_1 = np.array(list("ATGCGCATGC"))
sequence_2 = np.array(list("ATGCGCACGC"))

# Quelles positions diffèrent ?
differences = sequence_1 != sequence_2
print(differences)

# Nombre de différences
print("Différences :", np.sum(differences))

# Similarité en pourcentage
similarite = np.mean(sequence_1 == sequence_2) * 100
print("Similarité : " + format(similarite, ".1f") + " %")

Résultat de l’exécution

[False False False False False False False  True False False]
Différences : 1
Similarité : 90.0 %

Trouver les positions d’une base

import numpy as np

adn = np.array(list("ATGCGCATGCAAATTTGGG"))

positions_a = np.where(adn == "A")[0]
print("Positions de A :", positions_a)

Résultat de l’exécution

Positions de A : [ 0  6 10 11 12]

np.where(condition) retourne les indices où la condition est vraie. C’est l’équivalent vectorisé d’un for avec if.

---

Résumé

Opération	Outil	Exemple
Découper	.split()	"a,b,c".split(",") → ["a","b","c"]
Rejoindre	.join()	"-".join(["a","b"]) → "a-b"
Remplacer	.replace()	"ATG".replace("A","a") → "aTG"
Compter	.count()	"ATGA".count("A") → 2
Vérifier	.isdigit(), etc.	"123".isdigit() → True

Les chaînes restent immutables

Toutes les méthodes de chaînes retournent une nouvelle chaîne. L’originale n’est jamais modifiée. Souviens-toi d’assigner le résultat :

texte.upper()          # ⚠️ ignoré → résultat perdu
texte = texte.upper()  # ✅ correct