Les méthodes des chaines de caractères en Python

Objectifs

Connaître les Méthodes associées aux chaînes de caractères

Présentation

Sous Python, les chaînes de caractères sont des objets. On peut donc effectuer de nombreux traitements dessus en utilisant des méthodes appropriées. En voici quelques-unes, choisies parmi les plus utiles.
Mais vous pouvez obtenir la liste complète de toutes les méthodes associées à un objet à l’aide de la fonction intégrée dir(str) ou help(str) :

[‘__add__‘, ‘__class__‘, ‘__contains__‘, ‘__delattr__‘, ‘__dir__‘, ‘__doc__‘, ‘__eq__‘, ‘__format__‘, ‘__ge__‘, ‘__getattribute__‘, ‘__getitem__‘, ‘__getnewargs__‘, ‘__gt__‘, ‘__hash__‘, ‘__init__‘, ‘__init_subclass__‘, ‘__iter__‘, ‘__le__‘, ‘__len__‘, ‘__lt__‘, ‘__mod__‘, ‘__mul__‘, ‘__ne__‘, ‘__new__‘, ‘__reduce__‘, ‘__reduce_ex__‘, ‘__repr__‘, ‘__rmod__‘, ‘__rmul__‘, ‘__setattr__‘, ‘__sizeof__‘, ‘__str__‘, ‘__subclasshook__‘]

Il existe de nombreuses méthodes (sortes de fonctions préfixées par l’objet ici la chaîne) sur le traitement des chaînes.Les méthodes suivantes sont applicables sur des objets Python de type str : capitalize(), casefold(), center(), count(), encode(), endswith(), expandtabs(), find(), format(), format_map(), index(), isalnum(), isalpha(), isascii(), isdecimal(), isdigit(), isidentifier(), islower(), isnumeric(), isprintable(), isspace(), istitle(), isupper(), join(), ljust(), lower(), lstrip(), maketrans(), partition(), replace(), rfind(), rindex(), rjust(), rpartition(), rsplit(), rstrip(), split(), splitlines(), startswith(), strip(), swapcase(), title(), translate(), upper(), zfill().

Quelques méthodes

Les méthodes .lower() et .upper()

Les méthodes .lower() et .upper() renvoient un texte en minuscule et en majuscule respectivement. On remarque que l’utilisation de ces fonctions n’altère pas la chaîne de caractères de départ mais renvoie une chaîne de caractères transformée.
Pour mettre en majuscule la première lettre seulement, vous pouvez faire :

>>> x [0]. upper () + x [1:]
'Girafe '
ou encore plus simple avec la méthode adéquate :
>>> x. capitalize ()
'Girafe '

La méthode .split()

La méthode .split() découpe une chaîne de caractères en plusieurs éléments appelés champs, en utilisant comme séparateur n’importe quelle combinaison « d’espace(s) blanc(s) ».

>>> animaux = " girafe tigre singe souris "
>>> animaux . split ()
['girafe ', 'tigre ', 'singe ', 'souris ']
>>> for animal in animaux . split ():
... print ( animal )
...
girafe
tigre
singe
souris

Il est possible de modifier le séparateur de champs, par exemple :

>>> animaux = " girafe : tigre : singe :: souris "
>>> animaux . split (":")
['girafe ', 'tigre ', 'singe ', '', 'souris ']

Attention, dans cet exemple, le séparateur est un seul caractères : (et non pas une combinaison de un ou plusieurs ":)" menant ainsi à une chaîne vide entre singe et souris.
Il est également intéressant d’indiquer à .split() le nombre de fois qu’on souhaite découper la chaîne de caractères avec l’argument maxsplit() :

>>> animaux = " girafe tigre singe souris "
>>> animaux . split ( maxsplit =1)
['girafe ', 'tigre singe souris ']
>>> animaux . split ( maxsplit =2)
['girafe ', 'tigre ', 'singe souris ']

La méthode .find()

La méthode .find(), quant à elle, recherche une chaîne de caractères passée en argument :

>>> animal = " girafe "
>>> animal . find ("i")
1
>>> animal . find (" afe ")
3
>>> animal . find ("z")
-1
>>> animal . find (" tig ")
-1

Si l’élément recherché est trouvé, alors l’indice du début de l’élément dans la chaîne de caractères est renvoyé. Si l’élément n’est pas trouvé, alors la valeur -1 est renvoyée.
Si l’élément recherché est trouvé plusieurs fois, seul l’indice de la première occurrence est renvoyé :

>>> animaux = " girafe tigre "
>>> animaux . find ("i")

La méthode .replace()

On trouve aussi la méthode .replace() qui substitue une chaîne de caractères par une autre :

>>> animaux = " girafe tigre "
>>> animaux . replace (" tigre ", " singe ")
'girafe singe '
>>> animaux . replace ("i", "o")
'gorafe togre '

La méthode .count()

La méthode .count() compte le nombre d’occurrences d’une chaîne de caractères passée en argument :

>>> animaux = " girafe tigre "
>>> animaux . count ("i")
 2
>>> animaux . count ("z")
0
>>> animaux . count (" tigre ")

La méthode .startswith()

La méthode .startswith() vérifie si une chaîne de caractères commence par une autre chaîne de caractères :

>>> chaine = " Bonjour monsieur le capitaine !"
>>> chaine . startswith (" Bonjour ")
True
>>> chaine . startswith (" Au revoir ")
False

Cette méthode est particulièrement utile lorsqu’on lit un fichier et que l’on veut récupérer certaines lignes commençant par un mot-clé. Par exemple dans un fichier PDB, les lignes contenant les coordonnées des atomes commencent par le mot-clé ATOM.

La méthode .strip()

La méthode .strip() permet de « nettoyer les bords » d’une chaîne de caractères :

>>> chaine = " Comment enlever les espaces au dé but et à la fin ? "
>>> chaine . strip ()
'Comment enlever les espaces au dé but et à la fin ?'

La méthode .strip() enlève les espaces situés sur les bords de la chaîne de caractère mais pas ceux situés entre des caractères visibles. En réalité, cette méthode enlève n’importe quel combinaison « d’espace(s) blanc(s) » sur les bords, par exemple :

>>> chaine = " \ tfonctionne avec les tabulations et les retours à la ligne \n"
>>> chaine . strip ()
'fonctionne avec les tabulations et les retours à la ligne '

La méthode .strip() est très pratique quand on lit un fichier et qu’on veut se débarrasser des retours à la ligne.

La méthode .join()

La méthode .join() assemble les éléments d’une liste pour former une chaîne unique, chaque élément étant séparé par un point virgule. Le séparateur n’est pas forcément un point-virgule, il n’est même pas forcément un caractère unique. Il peut être n’importe quelle chaîne.
La conversion d’une liste de chaînes de caractères en une chaîne de caractères est un peu particulière puisqu’elle fait appelle à la méthode .join().

>>> seq = ["A", "T", "G", "A", "T"]
>>> seq
['A', 'T', 'G', 'A', 'T ']
>>> " -". join ( seq )
'A-T-G-A-T'
>>> " ". join ( seq )
'A T G A T'
>>> "". join (seq )
'ATGAT '

Attention, la méthode .join() ne s’applique qu’à une liste de chaînes de caractères.

>>> maliste = ["A", 5, "G"]
>>> " ". join ( maliste )
Traceback ( most recent call last ):
File "<stdin >", line 1, in <module >
TypeError : sequence item 1: expected string , int found

Application

Énoncé

On considère la chaîne de caractères val :val = "3.4 17.2 atom "
On souhaite extraire les valeurs 3.4 et 17.2 pour ensuite les additionner.

Solution

Dans un premier temps, on découpe la chaîne de caractères avec l’instruction .split() :

>>> val2 = val . split ()
>>> val2
[ '3.4 ' , '17.2 ' , 'atom ']

On obtient alors une liste de chaînes de caractères. On transforme ensuite les deux premiers éléments de cette liste en floats (avec la fonction float()) pour pouvoir les additionner :

>>> float ( val2 [0]) + float ( val2 [1])
20.599999999999998

Python

Les méthodes des chaines de caractères en Python