Université Abdelmalek Essadi Master SIM-MBD

Faculté des Sciences et Techniques –Tanger Semestre 1 2021-2022

Département Génie Informatique Module : POO en Python

Mémo sur les chaînes de caractères - Python

Une donnée de type chaîne de caractères (strings) peut se définir en première approximation comme
une suite quelconque de caractères. Dans un script python, on peut délimiter une telle suite de
caractères, soit par des apostrophes (simple quotes), soit par des guillemets (double quotes).
>>> phrase1 = 'Les produits'
>>> phrase2 = '"Oui", répondit-il,'
>>> phrase3 = "j'ai bien reçu"
>>> print(phrase2, phrase3, phrase1)
"Oui", répondit-il, j'ai bien reçu Les produits

Le caractère spécial « \ » (antislash) permet quelques subtilités complémentaires :

• Il permet d’écrire sur plusieurs lignes une commande qui serait trop longue.
• À l’intérieur d’une chaîne de caractères, l’ antislash permet d’insérer un certain nombre de codes
spéciaux (sauts à la ligne, apostrophes, guillemets, etc.):
>>> t= '"N\'est-ce pas ?" répondit-il.'
>>> print(t)
"N'est-ce pas ?" répondit-elle.

>>> s = "Ceci est une chaîne plutôt longue\n contenant plusieurs lignes \
... de texte.\n\
... Notez que les blancs en début\n de ligne sont significatifs.\n"
>>> print(s)
Ceci est une chaîne plutôt longue
contenant plusieurs lignes de texte.
Notez que les blancs en début
de ligne sont significatifs.

Triple quotes
Les chaînes entre triple apostrophes acceptent d'afficher des guillemets et des apostrophes ... mais
l'antislash doit être protégé.

>>> print ('''Mon cousin "omar" est né le 15\4\1980.''')

Mon cousin "omar" est né le 15980.
>>> print ("""Mon cousin "omar" est né le 15\4\1980.""")
Mon cousin "omar" est né le 15980.
>>> print ('''Mon cousin "omar" est né le 15\\4\\1980.''')
Mon cousin "omar" est né le 15\4\1980.
>>> print ("""Mon cousin "omar" est né le 15\\4\\1980.""")
Mon cousin "omar" est né le 15\4\1980.

Accès aux caractères individuels d’une chaîne

>>> ch="user1"
>>> print(ch[0],ch[3],ch[4])
ur1
>>> print (ch[-1], ch[-2], ch[-4], ch[-5])
1rsu
# la longueur d’une chaîne
>>> ch = ' salam '
>>> print(len(ch))
5

# Convertir une chaîne de caractères en nombre

>>> ch = '8647'
>>> print(ch + 45)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: can only concatenate str (not "int") to str
>>> print(int(ch) + 45)
8692
>>> print(float(ch) + 45)
8692.0

# Extraction de fragments de chaînes

Python propose pour cela une technique simple que l’on appelle slicing (“découpage en tranches”).
Elle consiste à indiquer entre crochets les indices correspondant au début et à la fin de la “tranche”
que l’on souhaite extraire. Dans la tranche [n,m], le n ième caractère est inclus, mais pas le m ième .

>>> ch='Extraction'
>>> print(ch[0:3])
Ext
>>> print(ch[3:7])
ract
>>> print(ch[:3]) # les 3 premiers caractères
Ext
>>> print(ch[3:]) # tout ce qui suit les 3 premiers caractères
raction

>>> ch = 'AidMoubarak'
>>> print(ch[:3], ch[3:11]) # la virgule génère un espace!
Aid Moubarak

Concaténation, répétition
Les chaînes peuvent être concaténées avec l’opérateur + et répétées avec l’opérateur * :

>>> n = 'Bon' + 'jour'

>>> m = 'Bla ! ' * 4
>>> print(n, m)
Bonjour Bla ! Bla ! Bla ! Bla !
>>>
Remarque : Les opérateurs + et * peuvent aussi être utilisés pour l’addition et la multiplication
lorsqu’ils s’appliquent à des arguments numériques. Le fait que les mêmes opérateurs puissent
fonctionner différemment en fonction du contexte dans lequel on les utilise est un mécanisme fort
intéressant que l’on appelle surcharge des opérateurs.

Parcours d’une séquence : l’instruction for ... in …

>>> nom ="Informatique"
>>> index=0
>>> while index < len(nom):
... print(nom[index]+'*',end=' ')
... index+=1
...
I* n* f* o* r* m* a* t* i* q* u* e* >>>

>>> for x in nom:

... print(x+'*',end=' ')
...
I* n* f* o* r* m* a* t* i* q* u* e* >>>

Appartenance d’un élément à une séquence

>>> x='y'
>>> if x in voyelles:
... print(x, "est un voyelle")
...
y est un voyelle

Les chaînes sont des séquences non modifiables

Vous ne pouvez pas modifier le contenu d’une chaîne existante !
>>> salut = 'bonjour à tous'
>>> salut[0] = 'B'
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: 'str' object does not support item assignment
>>> type(salut)
<class 'str'>

>>> salut = 'B' + salut[1:] # il s’agit bien d’une nouvelle chaîne

>>> print(salut)
Bonjour à tous

Les chaînes sont comparables

>>> "salut">"toto"
False
>>> "salut"<"toto"
True
>>> "1"<"2"
True
>>> "-1"<"-2"
True
>>> "a"=="A"
False

Conversion d’une chaîne string en chaîne bytes

Pour convertir une chaîne de caractères en une séquence d’octets, encodée suivant une norme
particulière, on utilise la méthode encode(), qui fonctionne de manière parfaitement symétrique à la
méthode decode() décrite précédemment. Convertissons par exemple la même chaîne de caractères,
à la fois en Utf-8 et en Latin-1 pour comparaison.

>>> chaine = "Bonne fête"

>>> octets_u = chaine.encode("Utf-8")
>>> octets_l = chaine.encode("Latin-1")
>>> octets_u
b'Bonne f\xc3\xaate'
>>> octets_l
b'Bonne f\xeate'
Dans les séquences d’octets ainsi obtenues, on voit clairement que les caractères accentués ê et ë
sont encodés à l’aide de deux octets dans le cas de la séquence Utf-8, et à l’aide d’un seul octet dans
le cas de la séquence Latin-1.

Conversions automatiques lors du traitement des fichiers

la fonction open() de Python dispose fort heureusement d’un paramétrage par défaut qui convient à
la plupart des situations modernes concrètes. Lorsque vous ouvrez un fichier en écriture, par
exemple, en choisissant "w" ou "a" comme deuxième argument pour open(), Python encode
automatiquement les chaînes à enregistrer en suivant la norme par défaut de votre système
d’exploitation

La technique est simple. Il suffit d’indiquer cet encodage à open() à l’aide d’un argument
supplémentaire : encoding =" norme_choisie " :

>>> chaine ="contrôle séquence\n" >>> chaine ="contrôle séquence\n"

>>> of =open("tt", "w", encoding ="Latin-1") >>> of =open("tt", "w", encoding ="Utf-8")
>>> of.write(chaine) >>> of.write(chaine)
18 18
>>> of.close() >>> of.close()
>>> of =open("tt", "rb") >>> of =open("tt", "rb")
>>> octets =of.read() >>> octets =of.read()
>>> of.close() >>> of.close()
>>> print(octets) >>> print(octets)
b'contr\xf4le s\xe9quence\n' b'contr\xc3\xb4le s\xc3\xa9quence\n'

→ Cas des scripts Python

Les scripts Python que vous écrivez sont eux-mêmes des textes, bien entendu. Suivant la
configuration de votre logiciel éditeur, ou de votre OS, ces textes pourront donc se retrouver
encodés suivant différentes normes. Afin que Python puisse les interpréter correctement, il vous est
conseillé d’y inclure toujours l’un des pseudo-commentaires suivants (obligatoirement à la 1 e ou à
la 2e ligne) :
# -*- coding:Latin-1 -*-
Ou bien :
# -*- coding:Utf-8 -*-

Accéder à d’autres caractères que ceux du clavier

Tous les caractères possèdent leur identifiant numérique universel. Python met à votre disposition
un certain nombre de fonctions prédéfinies permettant d’accéder à ces identifiants.

La fonction ord(ch) accepte n’importe quel caractère comme argument. En retour, elle fournit la
valeur de l’identifiant numérique correspondant à ce caractère.
La fonction chr(num) fait exactement le contraire, en vous présentant le caractère typographique
dont l’identifiant Unicode est égal à num. Pour que cela fonctionne, il faut cependant que deux
conditions soient réalisées :
• la valeur de num doit correspondre effectivement à un caractère existant (la répartition des
identifiants unicode n’est pas continue : certains codes ne correspondent donc à aucun caractère)
votre ordinateur doit disposer d’une description graphique du caractère, ou, en d’autres termes,
connaître le dessin de ce caractère, que l’on appelle un glyphe . Les systèmes d’exploitation récents
disposent cependant de bibliothèques de glyphes très étendues, ce qui devrait vous permettre d’en
afficher des milliers à l’écran.

>>> ord("é") >>> chr(233)

233 'é'
>>> ord("ô") >>> chr(244)
244 'ô'
>>> ord("ù") >>> chr(249)
249 'ù'

Exemple
>>> s = ""
>>> i = 945
>>> while i <= 969:
... s += chr(i)
... i = i + 1
...
>>> print("Alphabet grec (minuscule) : ", s)
Alphabet grec (minuscule) : αβγδεζηθικλμνξοπρςστυφχψω
Les chaînes sont des objets
Vous savez donc que l’on peut agir sur un objet à l’aide de méthodes (c’est-à-dire des fonctions
associées à cet objet). Sous Python, les chaînes de caractères sont des objets. On peut donc effectuer
de nombreux traitements sur les chaînes de caractères en utilisant des méthodes appropriées :
→ split() : convertit une chaîne en une liste de sous-chaînes. On peut choisir le caractère séparateur
en le fournissant comme argument, sinon c’est un espace par défaut.

>>> ch="chaîne de caractères" >>> ch ="Cet exemple, parmi d ' autres, peut encore servir"
>>> a=ch.split() >>> a=ch.split(",")
>>> print(a) >>> print(a)
['chaîne', 'de', 'caractères'] ['Cet exemple', " parmi d ' autres", ' peut encore servir']

→ join(liste) : rassemble une liste de chaînes en une seule (cette méthode effectue donc l’action
inverse de split() ). Attention : la chaîne à laquelle on applique cette méthode est celle qui servira de
séparateur (un ou plusieurs caractères sauf \) ; l’argument transmis est la liste des chaînes à
rassembler.

>>> a=['Cet exemple', " parmi d'autres", ' peut encore servir']
>>> ch=" ".join(a)
>>> print(ch)
Cet exemple parmi d'autres peut encore servir
>>> ch="-".join(a)
>>> print(ch)
Cet exemple- parmi d'autres- peut encore servir

→ find(sch) : cherche la position d’une sous-chaîne sch dans la chaîne :

>>> ch="Voici une exclamation codée en binaire"

>>> ch1="Voici une exclamation codée en binaire"
>>> ch2="exclamation"
>>> print(ch1.find(ch2))
10
>>> ch2="fst"
>>> print(ch1.find(ch2))
-1

→ count(sch) : compte le nombre de sous-chaînes sch dans la chaîne

>>> ch1="compte le nombre de sous-chaînes sch dans la chaîne"

>>> ch2="chaîne"
>>> print(ch1.count(ch2))
2

→ lower() : convertit une chaîne en minuscules

>>> ch="CONVERTIT une chaîne en minuscules"

>>> print(ch.lower())
convertit une chaîne en minuscules

→ upper() : convertit une chaîne en majuscules

>>> ch="convertit une chaîne en minuscules"
>>> print(ch.upper())
CONVERTIT UNE CHAÎNE EN MINUSCULES

→ title() : convertit en majuscule l’initiale de chaque mot (suivant l’usage des titres anglais) :

>>> ch="convertit une chaîne en minuscules"

>>> print(ch.title())
Convertit Une Chaîne En Minuscules

→ capitalize() : Convertit en majuscule seulement la première lettre de la chaîne :

>>> ch="convertit une chaîne en minuscules"

>>> print(ch.capitalize())
Convertit une chaîne en minuscules

→ swapcase() : convertit toutes les majuscules en minuscules, et vice-versa :

>>> ch="CONVERTIT une chaîne en minuscules"

>>> print(ch.swapcase())
convertit UNE CHAÎNE EN MINUSCULES

→ strip() : enlève les espaces éventuels au début et à la fin de la chaîne :

>>> ch=" FST de Tanger "

>>> print(ch.strip())
FST de Tanger

→ replace(c1, c2) : remplace tous les caractères c1 par des caractères c2 dans la chaîne :

>>> ch=" FST de Tanger "

>>> print(ch.replace(" ","-"))
-FST-de-Tanger-

→ index(car) : retrouve l’indice (index) de la première occurrence du caractère car dans la chaîne

>>> ch=" FST de Tanger "

>>> print(ch.index("T")) # cherche à partir du début de la chaîne et trouve le premier 'e'
3
print (ch.index("e",5)) # cherche seulement à partir de l'indice 5 et trouve le second 'e'
6

→ str(obj) : convertit (ou représente) l’objet obj en une chaîne de caractères. obj peut être une
donnée d’à peu près n’importe quel type

>> a, b = 17, ["Ali", 7.65]

>>> ch =str(a) +" est un entier et " +str(b) +" est une liste."
>>> print(ch)
17 est un entier et ['Ali', 7.65] est une liste.

Formatage des chaînes de caractères

Python vous offre une autre possibilité. Vous pouvez préparer une chaîne « patron » contenant
l’essentiel du texte invariable, avec des balises particulières aux endroits (les champs) où vous
souhaitez qu’apparaissent des contenus variables. Vous appliquerez ensuite à cette chaîne la
méthode format(), à laquelle vous fournirez comme arguments les divers objets à convertir en
caractères et à insérer en remplacement des balises (accolades).

>>> coul ="verte"

>>> temp =22
>>> ch ="La couleur est {} et la température vaut {} °C"
>>> print(ch.format(coul, temp))
La couleur est verte et la température vaut 22 °C

Les balises à utiliser sont constituées d’accolades, contenant ou non des indications de formatage :
a)→ Si les balises sont vides, la méthode format() devra recevoir autant d’arguments qu’il y aura de
balises dans la chaîne. Python appliquera alors la fonction str() à chacun de ces arguments, et les
insérera ensuite dans la chaîne à la place des balises, dans le même ordre. Les arguments peuvent
être n’importe quel objet ou expression Python :
>>> pi =3.1416
>>> r =4.7
>>> ch ="L’aire d’un disque de rayon {} est égale à {}."
>>> print(ch.format(r, pi * r**2))
L’aire d’un disque de rayon 4.7 est égale à 69.397944.

b)→ Les balises peuvent contenir des numéros d’ordre (comptés à partir de zéro) pour désigner
précisément lesquels des arguments transmis à format() devront les remplacer. Cette technique
est particulièrement précieuse si le même argument doit remplacer plusieurs balises

>>> ph="Les balise{0} peuv{1}t cont{1}ir des numéro{0}"

>>> print(ph.format("s", "en"))
Les balises peuvent contenir des numéros

c)→ Les balises peuvent aussi contenir des indications de formatage (en conjonction ou non avec
des numéros d’ordre). Par exemple, vous pouvez ainsi limiter la précision du résultat final, forcer
l’utilisation de la notation scientifique, fixer le nombre total de caractères, etc.

>>> pi =3.1416
>>> r =4.7
>>> ch ="L'aire d'un disque de rayon {} est égale à {:8.2f}."
>>> print(ch.format(r, pi * r**2))
L'aire d'un disque de rayon 4.7 est égale à 69.40.
>>> ch ="L'aire d'un disque de rayon {0} est égale à {1:6.2e}."
>>> print(ch.format(r, pi * r**2))
L'aire d'un disque de rayon 4.7 est égale à 6.94e+01.

Dans le premier essai, le résultat est formaté de manière à comporter un total de 8 caractères, dont 2
chiffres après le point décimal. Dans le second, le résultat est présenté en notation scientifique
( e+01 signifie x 10 01 ). Veuillez constater au passage que les arrondis éventuels sont effectués
correctement.

>>> n =789
>>> txt ="Le nombre {0:d} (décimal) vaut {0:x} en hexadécimal et {0:b} en binaire."
>>> print(txt.format(n))
Le nombre 789 (décimal) vaut 315 en hexadécimal et 1100010101 en binaire.

Formatage des chaînes « à l’ancienne »

>>> coul ="verte"

>>> temp = 22
>>> print ("La couleur est %s et la température vaut %s °C" % (coul, temp))
La couleur est verte et la température vaut 22 °C
La fonction sorted()

La fonction sorted() trie les éléments d'un itérable donné dans un ordre spécifique (ascendant ou
descendant) et renvoie l'itérable trié sous forme de liste.

La syntaxe de la fonction sorted() est la suivante :

sorted(iterable, key=None, reverse=False)

sorted() peut prendre au maximum trois paramètres :

1. itérable - Une séquence (chaîne, tuple, liste) ou une collection (ensemble, dictionnaire,
ensemble figé) ou tout autre itérateur.
2. inverse (facultatif) - Si le paramètre est vrai, la liste triée est inversée (ou triée par
ordre décroissant). La valeur par défaut est False si elle n'est pas fournie.
3. key (Facultatif) - Fonction qui sert de clé pour la comparaison de tri. La valeur par défaut
est None.
Exemple 1 : Trier une chaîne, une liste et un tuple
>>> py_list = ['e', 'a', 'u', 'o', 'i']
>>> print(sorted(py_list))
['a', 'e', 'i', 'o', 'u']
>>> py_string = 'Python'
>>> print(sorted(py_string))
['P', 'h', 'n', 'o', 't', 'y']
>>> py_tuple = ('e', 'a', 'u', 'o', 'i')
>>> print(sorted(py_tuple))
['a', 'e', 'i', 'o', 'u']

Remarque : Une liste possède également la méthode sort() qui fonctionne de la même manière que
sorted sauf que sort() ne renvoie aucune valeur et modifie la liste originale.

Exemple 2 : Trier par ordre décroissant

# set
>>> py_set = {'e', 'a', 'u', 'o', 'i'}
>>> print(sorted(py_set, reverse=True))
['u', 'o', 'i', 'e', 'a']
# dictionary
>>> py_dict = {'e': 1, 'a': 2, 'u': 3, 'o': 4, 'i': 5}
>>> print(sorted(py_dict, reverse=True))
['u', 'o', 'i', 'e', 'a']
# frozen set
>>> frozen_set = frozenset(('e', 'a', 'u', 'o', 'i'))
>>> print(sorted(frozen_set, reverse=True))
['u', 'o', 'i', 'e', 'a']
reverse = True : trie l'iterable dans l'ordre décroissant.

Paramètre key dans la fonction Python sorted()

Si vous voulez votre propre implémentation pour le tri, sorted() accepte également une fonction clé
comme paramètre optionnel. Sur la base de la valeur retournée par la fonction clé, vous pouvez trier
l'itérable donné.
Exemple : sorted(iterable, key=len) → trie en fonction de la longueur de l'élément ( du le plus bas
au plus haut).

Exemple 3 : Trier la liste en utilisant sorted() ayant une fonction clé

# prendre le deuxième élément pour le tri
>>> l = [(2, 2), (3, 4), (4, 1), (1, 3)]
>>> sorted_list = sorted(l, key=take_second)
>>> print('Sorted list:', sorted_list)
Sorted list: [(4, 1), (2, 2), (1, 3), (3, 4)]

Exemple 4 : Tri à l'aide de clés multiples

# Liste imbriquée d'informations sur les élèves dans une olympiade scientifique
# Lister les éléments : (Nom de l'élève, notes sur 100, âge)

Nous voulons trier la liste de manière à ce que l'étudiant ayant obtenu les meilleures notes se trouve
au début. Au cas où les étudiants auraient des notes égales, ils doivent être triés de manière à ce que
le plus jeune participant arrive en premier.

Nous pouvons réaliser ce type de tri avec des clés multiples en renvoyant un tuple au lieu d'un
nombre. On peut comparer deux n-uplets en comparant leurs éléments en commençant par le
premier. S'il y a égalité (les éléments sont égaux), le deuxième élément est comparé, et ainsi de
suite.

>>> participant_list = [
... ('Ali', 50, 18),
... ('Tarik', 75, 12),
... ('Daoud', 75, 20),
... ('Jamal', 90, 22),
... ('Mohamed', 45, 12)
... ]

>>> def sorter(item):

... error = 100 - item[1]
... age = item[2]
... return (error, age)

>>> sorted_list = sorted(participant_list, key=sorter)

>>> print(sorted_list)
[('Jamal', 90, 22), ('Tarik', 75, 12), ('Daoud', 75, 20), ('Ali', 50, 18), ('Mohamed', 45, 12)]
>>>

Remarque : la fonction lambda est utilisée à l'intérieur de la clé plutôt que de passer un nom de
fonction séparé :
>>> participant_list = [
... ('Ali', 50, 18),
... ('Tarik', 75, 12),
... ('Daoud', 75, 20),
... ('Jamal', 90, 22),
... ('Mohamed', 45, 12)
... ]

>>> sorted_list = sorted(participant_list, key=lambda item: (100-item[1], item[2]))

>>> print(sorted_list)
[('Jamal', 90, 22), ('Tarik', 75, 12), ('Daoud', 75, 20), ('Ali', 50, 18), ('Mohamed', 45, 12)]
>>>