Approfondissements sur les structure itérables en Python

Dans ce chapitre, je vais approfondir les structures déjà évoquées précédemment (chaines, listes, ensembles, dictionnaires, tuples). Je vais aussi présenter les "arrays" en Python dans la fin du chapitre.

Les différentes structures de données

Les structures itérables

une liste au sens strict (objet "list")
un objet de type "range" (séquence d'entiers)
une tuple (liste qui ne peut être modifiée)
une chaine (suite de caractères alphanumériques)
un set (ou ensemble) : liste que ne peut comporter de doublons
un dictionnaire (liste de paires clé-valeur)

Ces structures sont dites "itérables" car elles peuvent être parcourues avec une boucle.

La liste (objet "list") est bien sûr la structure la plus utilisée mais les autres structures ont des particularités qui peuvent être intéressantes en programmation.
Ainsi on crée un tuple pour stocker des constantes.
On construit une série d'entiers (liste, tuple, set) à partir d'un objet "range".
On utilise un ensemble (ou 'set') si on veut une liste avec valeurs uniques.

Itérable, sliceable & mutable

Le sens de ces différents adjectifs doit être connu.

Un itérable est une structure de données qui peut être parcourue par une boucle FOR.
Les types itérables sont : str, list, tuple, dict, set & range

On appelle séquence un itérable "sliceable" (on peut extraire une tranche) avec la syntaxe nomSéquence[]
Les ensembles et les dictionnaires ne sont pas des séquences.

Il existe aussi les structures immuables et celles qui sont mutables.
Un tuple, une chaine & objet 'range' sont immuables : on ne peut pas modifier leur contenu.
Les autres structures (liste, dictionnaire, ensemble) sont mutables : on peut modifier leur contenu.

Dans la pratique on ne manipule pas directement un objet de type range ; on le transforme en liste ou tuple ou set :
maliste = list(range(...))
montuple = tuple(range(...))
monset = set(range(...))

Parcourir une structure itérable avec for ... enumerate

Comme vous savez dans une structure itérable on peut associer à chaque élément un indice.
Dans une structure for ... in basique cet indice ne peut apparaitre.
Par contre il apparait dans la structure for ... enumerate(séquence)

>>> liste = list(range(1,10,2))
>>> liste
[1, 3, 5, 7, 9]
>>> for ele in liste:
...     print(ele)
...
1
3
5
7
9
>>> for index, valeur in enumerate(liste):
...     print(index, valeur)
...
0 1
1 3
2 5
3 7
4 9

J'espère que vous notez bien l'apport de for ... in enumerate() par rapport à for ... in

Je peux appliquer for ... enumerate à une chaine ou à un tuple ou un ensemble.

>>> chaine ="Bonjour"
>>> for index,car in enumerate(chaine):
...     print(index,car)
...
0 B
1 o
2 n
3 j
4 o
5 u
6 r
>>> tuple = tuple(range(5))
>>> tuple
(0, 1, 2, 3, 4)
>>> for index,ele in enumerate(tuple) :
...     print(index,ele)
...
0 0
1 1
2 2
3 3
4 4
>>> ensemble = set(range(1,8))
>>> ensemble
{1, 2, 3, 4, 5, 6, 7}
>>> for index,ele in enumerate(ensemble):
...     print(index,ele)
...
0 1
1 2
2 3
3 4
4 5
5 6
6 7

Découvrir les méthodes d'une classe

Quelles méthodes puis-je employer pour chaque type de structure ?
Pour connaitre les méthodes d'une classe il suffit de taper dans la console de Python : dir(nomClasse) ou help(nomClasse)

Commandes dir(nomClasse)

>>> dir(range)
...  'count', 'index', 'start', 'step', 'stop'

>>> dir(list)
... 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort'

>>> dir(set)
... 'add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 
'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 
'union', 'update'

>>> dir(tuple)
... 'count', 'index'

>>> dir(dict)
… 'clear', 'copy', 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem', 'setdefault', 'update', 'values'
>>>

>>> dir(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', 'removeprefix', 
 'removesuffix', 'replace',
 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith',
 'strip', 'swapcase', 'title',
 'translate', 'upper', 'zfill'
>>>

Ci-dessus, j'affiche les méthodes pour chaque type de structure à l'exclusion des méthodes magiques (celles qui sont précédées et suivies de deux "underscores"). Nous n'avons pas à nous préoccuper de celles-ci pour l'instant.
Notez le nombre impressionnant de méthodes que l'on peut appliquer à une instance de la classe 'str'. Par contre les méthodes de la classe "tuple" ne sont qu'au nombre de 2 ... et 5 pour un objet "range".
Notez que certaines méthodes sont communes à plusieurs classes. Ainsi on retrouve la méthode clear() pour les listes, les ensembles et les dictionnaires. La méthode count() est présente aussi dans plusieurs classes.
On trouve également la méthode index() pour les classes "list", "tuple", "str" mais pas pour les dictionnaires et les ensembles q ui ne sont pas des structures indexables.

Commande help(nomClasse)

Pour avoir des infos plus détaillées sur la syntaxe et le rôle de chaque méthode de classe il est préférable d'utiliser la commande help.

>>>help(tuple)
...
 count(self, value, /)
	Return number of occurrences of value.
 index(self, value, start=0, stop=9223372036854775807, /)
     Return first index of value.
...
>>>

Retour sur les chaines (instances de la classe 'str')

L'image est grivoise mais le discours qui suit est des plus sérieux.

Je rappelle que dans un chapitre précédent, nous avons vu qu'il était facile de produire une chaine à partir d'une liste OU d'un tuple OU d'un dictionnaire OU d'un ensemble) via la méthode join(). Il est en effet, souvent plus simple de manipuler une chaine qu'une énumération d'éléments.
La liste des méthodes applicable à une chaine est impressionnante.

Rechercher une sous-chaine dans une chaine

Pour réchercher un caractère (ou plusieurs) dans une chaine, vous pensez à index() mais il existe aussi find(), rindex() et rfind(), startswith(), endswidth() ainsi que les opérateurs "in" et "not in".

Attention la méthode find() n'existe que pour la classe "str". >>> machaine ="avec cesar" >>> machaine.index('a') 0 >>> machaine.index('y') ValueError: substring not found >>> machaine.find('y') -1 >>> machaine.rindex('a') 8 >>> machaine.rfind('a') 8 >>> machaine.rindex('y') ValueError: substring not found >>> machaine.rfind('y') -1 >>> "y" in machaine False >>> "y" not in machaine True >>> "a" in machaine True >>> chaine1 ='bonjour' >>> chaine1.startswith('bon') True >>> chaine1.endswith('soir') False >>> >>> machaine_cryptee = machaine.replace('a','1').replace('e','2') >>> machaine_cryptee '1v2 c2s1r'

machaine.index('y') : message d'erreur car l'occurrence n'est pas trouvée
machaine.find('y') : retourne -1 car l'occurence n'est pas trouvée
les méthodes index() & find() recherchent en partant de la gauche, alors que les méthodes rindex() & rfind() recherchent en partant de la fin de la chaine (de la droite).
Dans l'exemple on apprend qu'il y a au moins deux lettres "a" dans la chaine : un "a" en position zéro et un autre en position 8.
pour une recherche d'une sous-chaine, vous pouvez aussi utiliser l'opérateur "in" ou "not in". Ces opérateurs retournent un booléen.
pour rechercher une occurrence en début de chaine il faut utiliser la méthode startswith() ; en fin de chaine : endswith(). Ces deux méthodes retournent True ou False
pour rechercher et remplacer il faut utiliser la méthodes replace(). On peut chainer plusieurs fois la méthode !

Supprimer les espaces dans une chaine

Exemple : >>> machaine = " bon jour " >>> machaine.strip() 'bon jour' >>> machaine.lstrip() 'bon jour ' >>> machaine.rstrip() ' bon jour' >>> machaine.strip().replace(" ","") 'bonjour' >>> machaine # commande 5 ' bon jour ' >>> machaine2 = machaine.strip().replace(" ","") #commande 6 >>> machaine2 'bonjour' >>> machaine = machaine.strip().replace(" ","") #commande 7 >>> machaine 'bonjour' >>>

lstrip() efface les espaces en début de chaine, rstrip() efface les espaces en fin de chaine ;
strip() équivaut à lstrip().rstrip().
Pour effacer les espaces en milieu de chaine il faut utiliser de la façon suivante : replace(" " ."") (remplacer espace par rien).

Ces commandes ne modifient pas la chaine d'origine

Les apparences sont trompeuses ; l'objet machaine n'a pas été modifié ! Cet objet "str" contient toujours des espaces au début comme l'indique la commande 5

Un objet string est immuable ! Vous ne pouvez pas modifier le contenu d'une chaine.
Vous devez donc créer une nouvelle chaine bénéficiant des modifications (commande 6) ; la nouvelle chaine peut avoir le même nom que la chaine d'origine (commande 7).

Obtenir une chaine débarassée de symboles et espaces

Les méthodes strip(), lstrip() & lstrip() sans arguments effacent les espaces. Mais vous pouvez argumenter ces méthodes.

Exemple : on souhaite débarasser une chaine des espaces,étoiles et tirets. >>> machaine =" * Bonjour * - " >>> machaine = machaine.lstrip(" *-").rstrip(" * -") >>> machaine 'Bonjour' >>>

Pour effacer des caractères parasites en milieu de de chaine l'astuce consiste à utiliser replace() avec en deuxième argument une chaine vide.
Exemple ci-dessous. >>> chainebizarre ="B*- on*-jour" >>> chainecorrigee = chainebizarre.replace(" ","").replace("*","").replace("-","") >>> chainecorrigee 'Bonjour'

Le "slicing" ou tranchage

Le 'slicing" a déjà été évoqué. Une simple expression entre crochets dit beaucoup de choses. Aussi la compréhension de cette expression n'est pas toujours facile. Sachez que l'indice peut être une valeur négative afin d'extraire à partir de la fin (ou droite de la chaine).

Donc le cadre du "slicing", l'indice peut avoir une valeur négative ; ce qui veut dire : extraire à partir de la fin (ou de la droite).

Premier exemple

Dans des chaines on trouve le mon d'une espèce animal, nom précédé OU suivi d'un code indiquant le taxon : "bi" comme bivalve ; "ga" comme gastéropode.
On veut afficher seulement le nom de l'espèce ; il faut donc pratiquer le "slicing" pour se débarasser du code. >>> espece ="bi-moule commune" # si code en début de chaine >>> print(espece[3:]) moule commune >>> espece2 ="bulot-ga" #si code en fin de chaine >>> print(espece2[:-3]) bulot

On affiche uniquementn le nom de l'espèce.

chaine[3:] : extraire à partir du caractère de rang 3 jusqu'à la fin
chaine[:-3]: extraire à partirt du rang 3 en partant de la fin et jusqu'au début de chaine

Autre exemple de "tranchage"

Rappelez vous, dans le chapitre 6 j'ai évoqué le code de César : un système de cryptage simple reposant sur un décalage de n lettres. >>> alphabet ="abcdefghijklmnopqrstuvwxyz" >>> n=2 >>> alphabet_2n =alphabet[n:] + alphabet[:n] >>> alphabet_2n 'cdefghijklmnopqrstuvwxyzab'

Grâce au "slicing" j'obtiens la table de conversion ("a" devient "c" , "b" devient "d" ... "z" devient "b") dans l'hypothèse d'un décalage de 2 (valeur de n).
Notez que l'expression entre crochets peut être une variable.

Convertir une chaine en nombre

Voilà une problèmatique que vous allez rencontrer souvent en programmation Python.
En effet la fonction input() retourne toujours une donnée de type 'str' même si vous n'avez saisi que des chiffres.

Tests dans la console : >>> chaine ="1245" >>> int(chaine) 1245 >>> chaine2 ="1245.55" >>> int(chaine2) ValueError: invalid literal for int() with base 10: '1245.55' >>> nombre =eval(chaine2) >>> type(nombre) <class 'float'> >>> nombre 1245.55

La fonction int(chaine) convertit une chaine en entier si celle-ci ne contient qu'une suite de chiffres mais "plante" si le format de la chaine est celle d'un flottant.
La fonction eval(chaine) convertit une chaine numérique en flottant. La fonction float(chaine) fait la même chose !

Produire une chaine à partir d'une liste

>>> chaine ="un deux trois quatre cinq"
>>> liste =list(chaine)
>>> liste
['u', 'n', ' ', 'd', 'e', 'u', 'x', ' ', 't', 'r', 'o', 'i', 's', ' ', 'q', 'u', 'a', 't', 'r', 'e', ' ',
 'c', 'i', 'n', 'q']
>>> liste = chaine.split()
>>> liste
['un', 'deux', 'trois', 'quatre', 'cinq']
>>> type(liste)
<class 'list'>

Employer la fonction générique 'list' n'est pas la bonne solution : chaque caractère de la chaine devient un item de la liste.
Par contre la méthode split() produit une liste où chaque mot de la chaine d'origine devient un item de la liste.

Retour sur les listes

Je vais maintenant revenir sur les listes au sens strict : objet "list".
Une liste est mutable ; on peut modifier son contenu initial.

Rappels sur les principales méthodes applicables à un objet 'list'

>>> maliste =[2,3,2,5,7,9]
>>> type(maliste)
<class 'list'>
>>> maliste.append(11)
>>> maliste
[2, 3, 2, 5, 7, 9, 11]
>>> maliste.reverse()
>>> maliste
[11, 9, 7, 5, 2, 3, 2]
>>> maliste.sort()
>>> maliste
[2, 2, 3, 5, 7, 9, 11]
>>> maliste.count(2)
2
>>> for i in maliste:
...     print(i)
...
2
3
2
5
7
9
11
>>> maliste.remove(11)
>>> maliste.pop(0)
>>> maliste
[2, 3, 5, 7, 9]
>>> maliste.clear()
>>> maliste
[]

maliste.append(11) : ajout du nombre 11 à la liste
maliste.reverse() : met la liste à l'envers
maliste.sort() : tri par ordre croissant d'une liste
maliste.count(2) : compte le nombre de 2 dans la liste
une liste est une structure itérable : peut être parcourue avec un FOR
maliste.remove(11) : suppression de l'item de valeur "11" dans la liste
maliste.pop(0) : suppression de l'élément d'indice zéro.
maliste.clear() : vidage de la liste

Il s'agit ici d'une "piqure de rappel". Toutes ces méthodes ont déjà été évoquées dans des chapitres précédents.
Je signale qu'il existe aussi les méthodes extend() pour ajout N éléments en fin de liste et insert(position, valeur) pour insérer un élément au milieu d'une liste.

Produire un tuple ou set à partir d'une liste

Il s'agit aussi de rappels. >>> maliste =[5,2,3,2,4,7,9,7] >>> montuple = tuple(maliste) >>> montuple (5, 2, 3, 2, 4, 7, 9, 7) >>> type(montuple) <class 'tuple'> >>> monset =set(maliste) >>> monset {2, 3, 4, 5, 7, 9} >>> type(monset) <class 'set'>

Pour créer un objet 'tuple' à partir d'une liste il faut utiliser la fonction tuple()
Pour produire un ensemble à partir d'une liste il faut utiliser la fonction set()
Notez que la fonction set() est "intelligente" : produit bien un ensemble (pas de doublons même s'ils existe dans la série d'origine).

Retour sur les ensembles ou "set"

Un ensemble est une liste qui interdit les doublons. >>> monset ={5,3,2,1,4,7,6} >>> type(monset) <class 'set'> >>> sorted(monset) [1, 2, 3, 4, 5, 6, 7] >>> reversed(monset) TypeError: 'set' object is not reversible >>> for i in monset: ... print(i) ... 1 2 3 4 5 6 7 >>> monset.add(9) >>> monset.add(9) >>> monset {1, 2, 3, 4, 5, 6, 7, 9} >>> monset.discard(6) >>> monset {1, 2, 3, 4, 5, 7, 9} >>> monset[1:3] ... TypeError: 'set' object is not subscriptable >>> monset.index(2) ... AttributeError: 'set' object has no attribute 'index' >>>

Un ensemble est une structure triable mais pas réversible.
Un ensemble est itérable : peut être parcourue par un FOR.
Si vous tentez d'ajouter dans une séquence un élément qui existe déjà, il y a échec mais sans message d'erreur. Attention la méthode n'est pas "append" mais "add".
La méthode remove() peut s'appliquer à un ensemble mais il faut lui préférer la méthode discard() : pas de message éventuel d'erreur
Pour terminer je vous montre aussi qu'un ensemble n'est ni tranchable ni indexable.
Je rappelle que concernant les ensembles il existe auss les opérations union & intersection qui ont déjà été abordées dans le chapitre 8. Je vous renvoie à ce chapitre : Tuto Python - chapitre 8

Retour sur les dictionnaires

Un dictionnaire (tableau associatif dans d'autres langages) est une structure qui comprend non pas des éléments mais des paires "clé : valeur" appelées items. >>> repertoire = {"marius":"0601010101", "émile":"0602020202","bernard": "0603030303","damien":"0604040404"} >>> type(repertoire) <class 'dict'> >>> repertoire.get("damien") '0604040404' >>> repertoire.get("louise") >>> repertoire["françois"] ="0605050505" >>> rperteoire.pop("marius") '0601010101' >>> repertoire["émile"] = "0701010101" >>> repertoire.popitem() ('françois', '0605050505') >>> repertoire.clear() >>> repertoire {} >>> ajout = {'alain': '0601010101', 'bernard':'0602020202'} >>> type(ajout) <class 'dict'> >>> repertoire.update(ajout) >>> repertoire {'alain': '0601010101', 'bernard': '0602020202'} >>> repertoire_copie = repertoire >>> repertoire_copie {'alain': '0601010101', 'bernard': '0602020202'} >>> for item in repertoire.items(): ... print(item) ... ('marius', '0601010101') ('émile', '0602020202') ('bernard', '0603030303') ('damien', '0604040404') >>> for cle in repertoire.keys(): ... print(cle) ... marius émile bernard damien

repertoire.get("damien") : récupération de la valeur correspondant à la clé ="damien"
repertoire.get("louise") : cette clé n'existe pas ; mais pas de message d'erreur.
repertoire["françois"] ="0605050505" : cette clé n'existe pas donc il s'agit d'un ajout
repertoire["émile"] = "0701010101" : cette clé existe donc il s'agit d'une mise à jour, émile change de numéro de portable.
reperteoire.pop("marius") : suppression de l'item ayant pour clé "marius"
repertoire.popitem() : suppression du dernier item
repertoire.clear() : vider le dictionnaire
repertoire.update(ajout) : ajout au dictionnaire "repertoire" (qui était vide) du contenu du dictionnaire nommé "ajout"
repertoire_copie = repertoire : pour créer un clone du dictionnaire "repertoire" il suffit de réaliser une affectation.

Un dictionnaire est une structure itérable mais la syntaxe de l'itération est un peu plus complexe que pour les autres types d'itérables.
Selon que vous voulez afficher les items (clé-valeur) OU seulement les clés OU seulement les valeurs il faut écrire : nomDict.items() / nomDict.keys() / nomDict.values avec "nomDict" : nom de la variable contenant le dictionnaire.

Traduction

Tutoriel Python - sommaire

Débuter en Python

Python - approfondissements

Tutoriel Python - recherche

L'auteur : Patrick Darcheville