Tutoriel Python - sommaire

Approfondissements sur les structure itérables

Terminologie

Si vous avez lu tous les chapitres précédents (et pas simplement survolé), vous avez déjà appris beaucoup de choses. Mais vous avez peut-être le sentiment de tout mélanger. Il est possible que vous soyez effrayé par les connaissances à retenir.
Je m'en vais vous rassurer. D'abord il ne faut pas tout apprendre par coeur ; c'est impossible, tant le langage Python est riche. Il suffit que vous disposiez d'astuces pour retrouver rapidement l'information dont vous avez besoin.

Dans ce chapitre, je ne vais pas aborder de nouvelles notions mais simplement revenir mais en approfondissant, sur les structures itérables (chaines, listes, ensembles, dictionnaires, tuples).

Lisez très attentivement l'encadré ci-dessous. Il est en effet important de saisir parfaitement le sens de certains termes du jargon Python.

Découvrir les méthodes d'une classe

Entre les listes, les tuples, les dictionnaires, les ensembles vous êtes perdus. Quel type de séquence utiliser ???
Quelles méthodes puis-je employer à un ensemble. Sont-elles les mêmes que celles relatives à une liste ou un tuple ou encore un dictionnaire ???
Pour connaitre les méthodes d'une classe il suffit de taper dans la console de Python : dir(nomClasse) ou help(nomClasse)

Commande dir

Commandes à saisir dans l'interpréteur : >>> 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-dessous, j'ai supprimé, des captures d'écran, les méthodes spéciales ou "magiques" : celles qui sont précédées et suivies de deux "underscores"). Nous n'avons pas à nous préoccuper pour l'instant.
Notez le nombre impressionnant de méthodes que l'on peut appliquer à une chaine (instance de la classe 'str'). Par contre les méthodes de la classe "tuple" ne sont qu'au nombre de 2 (index() & count()) et c'est logique puisque les tuples ne sont pas mutables.
Notez que certaines méthodes sont aussi communes à plusieurs classes. Ainsi on retrouve la méthode clear() pour les listes, les ensembles et les dictionnaires. La méthode count() est présenté dans plusieurs classes. On trouve également la méthode index() pour les classes "list", "tuple", "str" mais pas pour les dictionnaires et les ensembles qui ne sont pas des séries indexables.
Par contre l'ajout d'un élément se fait avec add() pour un 'set' alors qu'il se fait avec append() pour une liste.

Commande help

Pour avoir des infos plus détaillées sur la syntaxe et le rôle de chaque méthode 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. ... >>>

Fonctions génériques et méthodes de classes

Je l'ai déjà signalé dans le chapitre 8, mais je pense qu'il pas inutile de faire une piqure de rappel : il ne faut pas confondre fonctions génériques (ou "builtin" ) avec méthodes de classe.
Par exemple, ne confondez pas : sort() et sorted() ; de même que reverse() et reversed().
sort() & reverse() sont de méthodes de la classe 'list' tandis que sorted() & reversed() sont des fonctions génériques qui peuvent donc s'appliquer à n'importe quelle séquence itérable (liste, tuple, dictionnaire, ensemble ou chaine).
Etudiez bien les commandes ci-dessous ! >>> monset ={5,3,1,9,11,7} >>> monset.reverse() AttributeError: 'set' object has no attribute 'reverse' >>> monset.sort() AttributeError: 'set' object has no attribute 'sort' >>> sorted(monset) [1, 3, 5, 7, 9, 11] >>> machaine ="xzyuaoipqsbdfqcd" >>> sorted(machaine) ['a', 'b', 'c', 'd', 'd', 'f', 'i', 'o', 'p', 'q', 'q', 's', 'u', 'x', 'y', 'z'] >>> sorted(machaine, reverse =True) ['z', 'y', 'x', 'u', 's', 'q', 'q', 'p', 'o', 'i', 'f', 'd', 'd', 'c', 'b', 'a'] >>> montuple =(5,4,3,2,1) >>> tuple_trie = sorted(montuple) >>> tuple_trie [1, 2, 3, 4, 5] >>> montuple (5, 4, 3, 2, 1) >>> max(maliste) 13 >>> max(machaine) 'z' >>> max(monset) 11

Analyse de ces commandes :
• monset.reverse() : la méthode reverse() ne peut s'appliquer à un ensemble
• monset.sort() : même remarque pour la méthode sort()
• sorted(monset) : par contre on peut appliquer la fonction générique sorted() à n'importe quelle séquence itérable (liste, tuple ensemble, string).
  La fonction sorted() retourne toujours une liste et ne modifie pas la série d'origine !
• sorted(machaine,reverse =True) : la fonction générique sorted() accepte en deuxième argument "reverse =True" afin d'effectuer un tri par ordre décroissant.
• max() e& min() sont aussi des fonctions génériques

Moralité : employez plutôt les fonctions génériques que certaines méthodes de classe.

Attention la syntaxe n'est pas la même selon que vous faites appel à une méthode de classe et une fonction générique :
• appel d'une méthode de classe : objet.méthode(argument éventuel) ; exemple : maListe.sort()
• appel d'une fonction générique : fonction(objet) ; exemple : sorted(maListe)

Cette différence de syntaxe découle de la POO (Programmation Orienté Objet ; pour les attributs et méthodes d'une classe il faut utiliser la notation pointée.

Retour sur les chaines (ou "strings")

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.

Quelques méthodes applicables aux chaines

Jusqu'à présent je n'ai présenté que quelques méthodes de la classe 'str' alors qu'elles sont très très nombreuses ...
Commençons : >>> chaine1 ="bonjour" >>> chaine2 ="123456" >>> chaine3 ="bonsoir chère madame" >>> chaine3.capitalize() 'Bonsoir chère madame' >>> chaine3.upper() 'BONSOIR CHÈRE MADAME' >>> chaine3.lower() 'bonsoir chère madame' >>> >>> chaine2 ="123456" >>> chaine2.upper() '123456'

Les méthodes lower(), upper(), capitalize() "modifient la casse".
Bien évidemment ces méthodes n'ont aucun impact sur des chaines composées de chiffres.

Davantage de méthodes

Petit à petit on découvre la richesse des méthodes applicables à une chaine. >>> monTel ="0601010101" >>> type(monTel) <class 'str'> >>> monTel.isnumeric() True >>> monTel.isdigit() True >>> monTel.count("1") 4 >>> for i in monTel: ... print(i) ... 0 6 0 ... 0 1 >>>

Commentaire :
• type(monTel) : retourne class 'str' car si la variable ne comprend que des chiffres, ils sont délimités par des guillemets.
• isnumeric(): retourne VRAI car la chaine ne comprend que des chiffres
• isdigit() : retourne VRAI si la chaine ne comprend que des chiffres. Donc ces deux méthodes sont identiques !
• monTel.count("1") : retourne le nombre d'occurences "1" dans la chaine
• une chaine est une structure itérable : peut être parcourue par un FOR

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 dans la classe de chaine. >>> 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'

Analyse :
• machaine.index('y') : recherche l’occurrence "y" dans la chaine. Mais message d'erreur car l'occurrence n'est pas trouvée ...
• machaine.find('y') : utilisez plutôt la méthode find() qui retourne -1 si recherche vaine
• 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 !

Je rappelle aussi que la fonction search() du module "re" permet de vérifier si une chaine correspond (ou pas) à un certain gabarit (défini en utilisant la syntaxe des expressions régulières).

Effacer 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'

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).

Extraire une sous-chaine d'une chaine

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" >>> chainecorrige = chainebizarre.replace(" ","").replace("*","").replace("-","") >>> chainecorrige '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).

Exemple : dans des chaines on trouve le mon d'une espèce animal, nom précédé OU suivi d'un code indiquant le groupe : "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-groupe. >>> 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.

Explications des commmandes :
• 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 - et c'est important en programmation - l'expression entre crochets peut contenir des variables.

Convertir les chaines en nombres

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.

Tapez les commandes suivantes dans la console Python : >>> 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) peut convertir une chaine en flottant (nombre décimal).
Donc pour convertir une chaine corrrespondant à un nombre décimal en un entier il faut imbriquer eval() dans int() !

Transformer une chaine en liste

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. >>> 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'>

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.

Rappels de méthodes applicables à un objet 'list'

Commentaire :
• 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 ensemble à 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

Quelques rappels et compléments concernant les ensembles. >>> 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] Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: 'set' object is not subscriptable >>>

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 syntaxe 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 qu'il est interdit de "slicer" un ensemble.
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

Analyse des commandes :
• 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() : le dictionnaire est vidé
• 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.

Annexe 1: méthodes de liste

Méthodes de liste

Dans cette annexe je présente de façon exhaustive toutes les méthodes d'un objet de type list.

Voici toutes les méthodes applicables à un objet de type list :
• list.append(x): ajoute un élément à la fin de la liste
• list.extend(iterable) : Étend la liste en y ajoutant tous les éléments de l'itérable
• list.copy() : copie la liste dans une nouvelle ; exemple : newliste = odlliste.copy()
• list.insert(i, x) : insère un élément x à la position i
• list.remove(x) : supprime de la liste le premier élément dont la valeur est égale à x
• list.pop(i) : supprime de la liste l'item situé à la position i
• list.clear() : supprime tous les éléments de la liste.
• list.index(x) : renvoie la position du premier élément de la liste dont la valeur égale x
• list.count(x) : renvoie le nombre d'éléments ayant la valeur x dans la liste
• list.sort() : ordonne les éléments dans la liste
• list.reverse() : inverse l'ordre des éléments dans la liste

Attention toutes ces méthodes modifient la liste d'origine. Les listes sont "muables".

Attention aux confusions

Pour supprimer un item d'une liste on peut aussi utiliser la fonction générique del().
Pour trier ou inverser, vous pouvez utiliser les fonctions natives sorted() & reversed() qui ne modifient pas la liste d'origine.
Vous pouvez aussi "slicer" une liste.

Exemple d'emploi de la fonction del() : >>> maliste = [-1, 1, 66.25, 333, 333, 1234.5] >>> del(a[0]) >>> maliste [1, 66.25, 333, 333, 1234.5] >>>

Le premier item a été supprimé.

Exemple d'emploi de sorted() et sort(). >>> maliste = [5,4,3,2,1] >>> sorted(maliste) [1, 2, 3, 4, 5] >>> maliste [5, 4, 3, 2, 1] >>> maliste.sort() >>> maliste [1, 2, 3, 4, 5] >>>

La fonction native sorted() ne modifie pas la liste d'origine, ce qui n'est pas le cas de la méthode de classe sort().
Je rappelle aussi que les syntaxes sont aussi différentes : fonctionNative(objet) d'une part et objet.méthode() d'autre part.

Annexe 2 : méthodes de chaine

Attention les chaines sont "immuables" : en appliquant une méthode à une chaine celle-ci n'est pas modifiée ; il faut affecter la modification à une nouvelle chaine.
Démonstration : >>> machaine ="abcde" >>> machaine2 = machaine.upper() >>> machaine 'abcde' >>> machaine2 'ABCDE' >>>

La chaine "machaine" n'a pas été modifiée par la méthode upper() mais une nouvelle chaine "machaine2" a été créée!

Pour rechercher une sous-chaine dans une chaine on peut utiliser index() mais aussi find() Cette dernière présente un gros avantage : si l'occurence n'est pas trouvée elle retourne -1 et non pas un message d'erreur. Elle est donc à priviligier en programmation.

Sachez que de nombreuses méthodes de chaine retournent un booléen. Citons :
• islower()
• istitle()
• isalnum()
• isalpha()
• isdigit() ou isdecimal() ou isnumeric()
• isspace()
• isupper()
• iscapitalize()

Ne confondez pas "title" et "capitalize" :
• title : première lettre de chaque mot de la chaine en majuscule.
• capitalize : première lettre de la chaine en majuscule.