Tutoriel Python - sommaire

Python : découverte des tuples, dictionnaires et ensembles

Avant d'aborder ces trois types de séquences, je voudrais revenir rapidement sur les modules. Comment importer un module, utilisez les outils de ce module ?

Les modules : importation & découverte d'un module

Comment activer (importer) un module ?

Pour activer, par exemple, les modules math puis random on peut écrire : "from math import*" puis "from random import *"
Or si vous avez consulté d'autres sources documentaires, vous avez pu lire  les instructions "import math" ou "import random".
Les deux solutions sont correctes !

Dans le premier cas on peut ensuite appeler les fonctions du module importé sans les préfixer. On peut donc écrire tout simplement :
• sqrt(25)
• randint(100)

Dans le deuxième cas il faudra ensuite préfixer les fonctions du module importé. La syntaxe correcte sera alors plus lourde :
• math.sqrt(25)
• random.randint(100)

Et si vous oubliez de préfixer les fonctions vous aurez un message d'erreur. >>> import math >>> sqrt(25) Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'sqrt' is not defined >>> math.sqrt(25) 5.0

La console ne comprend pas la commande sqrt(25) mais comprend la commande math.sqrt(25).
N'en concluez pas que la première solution est la meilleure car plus courte. C'est vrai, si vous n'activez qu'un module. Mais si vous importez plusieurs modules, il faut mieux utiliser la deuxième solution.
En effet il est alors possible qu'il ait des ambiguïtés ... Deux modules employant le même mot pour désigner deux fonctions différentes ...
Un seul exemple : dans les deux module time & datetime il existe une fonction qui porte le même nom : time() ...

La deuxième solution a aussi un avantage, je peux utiliser un alias (de préférence un mot court) qui servira de préfixe.
Exemple : >>>import random as rd >>>rd.randint(100) >>>rd.choice(chaine)

Vous donnerez un alias à un module importé lorsque le nom de ce dernier est long tel "datetime" ou "statistic".

Découverte d'un module

Mais comment connaitre la liste des fonctions d'un module et le rôle de chacune ? >>> import math >>> help(math) Help on built-in module math: NAME math DESCRIPTION This module provides access to the mathematical functions defined by the C standard. FUNCTIONS acos(x, /) Return the arc cosine (measured in radians) of x. The result is between 0 and pi. acosh(x, /) Return the inverse hyperbolic cosine of x. asin(x, /) Return the arc sine (measured in radians) of x. The result is between -pi/2 and pi/2. asinh(x, /) Return the inverse hyperbolic sine of x. ...

Pour découvrir toutes les fonctions d'un module il suffit de l'importer puis de taper la commande help(nomModule).
Pour avancer d'une page dans la liste tapez sur "espace".
La commande dir(nomModule) se contente d'afficher la liste des fonctions.

Traitements sur les listes

Avant d'aborder d'autres structures itérables qui existent en Python (tuples, dictionnaires et ensembles), je voudrais vous montrer quelques traitements complémentaires que l'on peut effectuer sur une liste.

Tirage au sort dans une liste

Le code correspondant : # nom programme : choice_liste.py import random liste_simple =["aaa", "bbb", "ccc", "ddd", "eee", "fff", "ggg", "hhh", "kkk", "mmm", "nnn", "ooo", "ppp", "qqq", "rrr" ] reponse ="o" while reponse in "oO": element = random.choice(liste_simple) print ("élément tiré au sort : ", element) reponse = input("voulez vous continuez O/N ? : ")

Pour importer le module "random" j'ai employé la syntaxe "import nomModule". Donc je dois ensuite préfixer les fonctions.
Notez la syntaxe pour extraire de façon aléatoire un élement : random.choice(nomListe)

Convertir une liste en chaine

Il peut s'avérer utile de convertir une liste en chaine.
À saisir dans la console Python : >>> maliste = ["aaa", "bbb", "ccc", "dddd", "ffff", "eeee"] >>> type(maliste) <class 'list'> >>> machaine = " - ".join(maliste) >>> machaine 'aaa - bbb - ccc - dddd - ffff - eeee'

machaine = " - ".join(maliste) : la méthode join() a une syntaxe étrange ...
Elle convertit ici une liste en chaine. Les crochets et les guillemets internes sont supprimés, les virgules sont ici remplacées par des "-".
Si je veux des espaces ll suffit d'écrire : : machaine = " ".join(maliste)

Donc pour convertir une chaine en liste il faut utiliser la méthode split() et pour convertir une liste en chaine il faut utiliser la méthode de liste join()

Autres méthodes pour modifier une liste

Dans la suite de commandes ci-dessous j'utilise différentes méthodes de manipulation de listes. >>> maliste = ["aaa", "bbb", "ccc", "dddd", "ffff", "eeee"] >>> maliste.reverse() >>> maliste ['eeee', 'ffff', 'dddd', 'ccc', 'bbb', 'aaa'] >>> maliste.sort() >>> maliste ['aaa', 'bbb', 'ccc', 'dddd', 'eeee', 'ffff'] >>> maliste.append('ggg') >>> maliste.insert(2,'iii') >>> maliste ['aaa', 'bbb', 'iii', 'ccc', 'dddd', 'eeee', 'ffff', 'ggg'] >>> maliste.remove('aaa') >>> maliste ['bbb', 'iii', 'ccc', 'dddd', 'eeee', 'ffff', 'ggg'] >>>

Syntaxe :
• nomListe.reverse() : inversion des éléments
• nomListe.sort() : tri par ordre croissant
• nomListe.append(valeur) : ajout en fin de liste
• nomListe.insert(indice, valeur) : insertion à la position précisée
• nomListe.remove(valeur) : suppression de l'élément ayant la valeur précisée

Remarques concernant les tris

Attention, ne confondez pas la fonction générique sorted() avec la méthode de liste sort(). La fonction sorted() peut s'appliquer à n'importe quel type de séquence (liste, tuple, dictionnaire, chaine,etc.) et cette fonction native ne modifie pas la série d'origine à la différence de la méthode sort().

Les commmandes ci-dessous portent sur les tris de listes. >>> maliste = ["aaa", "bbb", "ccc", "dddd", "ffff", "FFFF","AAAA"] >>> maliste.sort() >>> maliste ['AAAA', 'FFFF', 'aaa', 'bbb', 'ccc', 'dddd', 'ffff'] >>> uneliste =[1,"aaa", "zzz","FFF", 5, 9] >>> uneliste.sort() Traceback (most recent call last): File "<stdin>", line 1, in <module> TypeError: '<' not supported between instances of 'str' and 'int' >>> liste3 =["1", "12","aaa", "AAA", "zzz"] >>> liste3.sort() >>> liste3 ['1', '12', 'AAA', 'aaa', 'zzz']

Ci-dessus j'ai appliqué à des listes la méthode de liste : sort(). Notez qu'à chaque fois la liste d'origine est modifiée.

Avec la méthode de liste sort() :
• les éléments de la liste sont triés par valeurs croissantes de leur code ASCII et les lettres majuscules ont un code ASCI plus faible que les minuscules. Exemple : code ascii de "A" = 65 ; code ascii de "a" = 97
• on ne peut pas trier une liste mélangeant des entiers et des chaines.
• En cas de tri croissant, les chaines numériques apparaissent au début d'une liste.

Le type tuple

Dans un chapitre précédent j'ai évoqué cette séquence. J'ai montré qu'une fonction pouvait retourner un tuple (plusieurs valeurs séparées par des virgules).
Commandes à saisir : >>> montuple = (5,4,3,2,1) >>> type(montuple) <class 'tuple'> >>> uneserie = 1,2,3,4 >>> type(uneserie) <class 'tuple'>

Différences entre un tuple et une liste ?

Deux différences :
• une liste est délimitée par des crochets alors qu'un tuple est encadré par des parenthèses (ou par aucun symbole) !
• le plus important, c'est de savoir qu'un tuple peut pas être modifié après avoir été créé !

Pourquoi les tuples (ou uplets)

On peut se demander à quoi ça peut bien servir ce type de données ? En fait un tuple ça peut être très utile dans certains cas précis.

Un tuple permet une affectation multiple

À droite du signe "=" c'est un tuple (j'aurais pu encadrer de parenthèses).
Donc en une seule instruction j'ai créé et initialisé plusieurs variables.

Une fonction retournant plusieurs valeurs

Il s'agit d'une piqure de rappel. Voir chapitre 4 - les fonctions.

Exemple :

Une fonction permet de retourner le périmètre et l'aire d'un rectangle à partir de la longueur et de la largeur.
Dans la fonction les variables sont lo (comme longueur), la (comme largeur), p (comme périmètre), a (comme aire), >>> def rectangle(lo,la): ... p =(lo*2) + (la*2) ... a = lo*la ... return p, a ... >>> perimetre,aire = rectangle(20,10) >>> perimetre 60 >>> aire 200

Dans la fonction "rectangle" le mot "return" est suivi d'un tuple à deux éléments : p,a.
Notez l'appel de la fonction avec à gauche du signe "=" un tuple à deux éléments. la variable "perimetre" reçoit le périmètre ; la variable "aire" récupère la surface,

Permuter des valeurs

Exemple : >>> r1 ="bonjour" >>> r2 ="au revoir" >>> r1,r2 = r2,r1 >>> r1 'au revoir' >>> r2 'bonjour'

Notez bien la syntaxe r1,r2 = r2,r1 ; de chaque côté du signe "=" on a un tuple.

Créer des constantes dans un programme

Dans un programme il peut y avoir des variables qui ne doivent pas être modifiées après avoir été initialisées. C'est ce qu'on appelle des constantes. Il suffit donc d'initialiser ces variables particulières à partir d'un tuple.
Exemple : >>> taux_tva = 20, 5.5 >>> taux_tva[0] 20 >>> taux_tva[1] 5.5 >>> prix_ht = 1000 >>> prix_ht * taux_tva[0] /100 200.0 >>> taux_tva[0] = 18.6 TypeError: 'tuple' object does not support item assignment

La variable "taux_tva" contient un tuple avec deux éléments ; Chaque élément a un indice.

Les taux de TVA sont exprimés pour 100 €, donc je dois diviser par 100 pour obtenir la TVA.
Notez que je n'arrive pas à modifier le contenu du premier élément du tuple.

Testez vos connaissances !

Écrivez la fonction qui a partir du rayon retourne la circonférence et l'aire d'un cercle.
Donc un argument à passer lors de l'appel de la fonction et deux valeurs retournées par cette fonction.

Lire un tuple

Je peux appliquer le "slicing" et la méthode index() à un tuple.

Parcourir un tuple

Un tuple est une structure itérable : >>> montuple = 5,4,3,2,1 >>> for i in montuple: ... print(i) ... 5 4 3 2 1 >>>

Un tuple n'est pas mutable

Un tuple ne peut être modifié. Donc pas de méthodes disponibles pour ajouter, retirer, modifier les items.

Type dictionnaire

Un dictionnaire n'est pas une séquence d'éléménts simples mais une suite de paires "clé:valeur". Un paire "clé:valeur" s'appelle aussi un item.
Les dictionnaires sont délimités par des accolades. Un dictionnaire c'est l'équivalent d'un tableau associatif dans d'autres langages (PHP, JS).

Vous pouvez utiliser un dictionnaire pour réaliser un carnet d'adresses, dans lequel on accède à chaque contact en saisissant son nom.

Exemple

A tapez dans l'interpréteur : >>> mon_inventaire ={"manteaux" : 2, "vestes" : 3, "chemises" : 6, "pantalons" : 5} >>> type(mon_inventaire) <class 'dict'> >>> mon_inventaire {'manteaux': 2, 'vestes': 3, 'chemises': 6, 'pantalons': 5} >>> mon_inventaire["pantalons"] 5 >>> machaine =" - ".join(mon_inventaire) >>> machaine 'manteaux - vestes - chemises - pantalons' >>> mon_inventaire["pulls"] = 10 >>> mon_inventaire {'manteaux': 2, 'vestes': 3, 'chemises': 6, 'pantalons': 5, 'pulls': 10} >>>del(mon_inventaire["vestes"]) .>>> mon_inventaire {'manteaux': 2, 'chemises': 6, 'pantalons': 5, 'pulls': 10}

Je crée un dictionnaire nommé "mon_inventaire" qui comprend 4 paires de clé-valeur.
Pour accéder à une valeur il faut préciser la clé. Syntaxe : nomDictionnaire [clé]. Ainsi j'apprends que j'ai 5 pantalons.
machaine =" - ".join(mon_inventaire) : création d'une chaine à partir du dictionnaire, avec la méthode join() ; seules les clés sont conservées dans la chaine de destination.
mon_inventaire["pulls"] = 10 : ajout d'un cinquième paire au dictionnaire
del(mon_inventaire["vestes"]) suppression d'une paire du dictionnaire

Un programme qui parcourt un dictionnaire

Attention un dictionnaire est une séquence non pas d'éléments simples mais d'items c'est à dire de paires "clé:valeur". #nom programme : parcours_dico.py #objet : parcours d'un dictionnaire carnet = {"Pierre" : "pierre.dubus@gmail.com", "Pauline" : "duboispauline@hotmail.fr", "jacques" : "fredo_jacky@free.fr"} for paire in carnet.items(): print(paire)

Il faut appliquer la méthode items() pour afficher les paires "clé:valeur".

Exécution de ce programme : Pierre pierre.dubus@gmail.com Pauline duboispauline@hotmail.fr jacques fredo_jacky@free.fr

Remarques :
Pour afficher uniquement les clés il suffirait d'écrire :
for cle in carnet.keys():
Pour afficher uniquement les valeurs il suffirait d'écrire :
for valeur in carnet.values()

Nous avons donc trois méthodes pour parcourir un dictionnaire : items(), keys(), values().

Annexe : compléments sur le type dict

Commandes à saisir dans l'interpréteur : >>> mondico={} >>> type(mondico) <class 'dict'> >>> len(mondico) 0 >>> mondico2 =dict() >>> type(mondico2) <class 'dict'> >>> len(mondico2) 0 >>> ajout = {1:"I",2:"II",3:"III",4:"IV",5:"V"} >>> mondico.update(ajout) >>> mondico {1: 'I', 2: 'II', 3: 'III', 4: 'IV', 5: 'V'} >>> del mondico[5] #supprimer un item dont on connait la clé >>> mondico {1: 'I', 2: 'II', 3: 'III', 4: 'IV'} >>> mondico.clear() >>> mondico {} >>>

Je vous montre dans cette batterie de commandes comment :
• créer un dictionnaire vide (avec une paire d'accolades ou avec la fonction dict)
• ajouter des items à un dictionnaire avec la méthode de classe update(nouveaux items)
• vider un dictionnaire avec la méthode clear()

Je vous montre aussi que l'on peut appliquer à un objet dict les fonctions len() & del().
Pour supprimer l'item ayant la clé "5" j'aurai pu aussi employer la méthode de classe pop() : mondico.pop(5)

Les ensembles

Décidément Python n'est pas avare en structures de données ; vous connaissiez les listes et les tuples et vous venez de voir les dictionnaires.
Et bien depuis la version 3 de Python, il existe un nouveau type de séquence : les ensembles (ou "set" en anglais).

Différence entre un dictionnaire et un ensemble

Il ne faut pas confondre les ensembles avec les dictionnaires.
Certes dans les deux cas les délimiteurs sont des accolades. Mais dans un ensemble il n'y a que des éléments simples alors que dans un dictionnaire il y a des paires de "clé:valeur".

Intérêt des ensembles

Puisqu'un ensemble est une séquence de valeurs comme une liste, quel est l'intérêt pratique de cette nouvelle structure ???
À la différence d'une liste, un ensemble ne peut pas contenir une même valeur plusieurs fois. En d'autres termes il ne peut y avoir de doublons

Création d'un ensemble

Il existe plusieurs façons de créer un ensemble.

Pour créer un ensemble vide, il faut écrire : nomEnsemble = set()

Créer un ensemble non vide

Si vous tentez de saisir des doublons dans un ensemble, l'interpréteur ne signale aucune erreur mais élimine les doublons de la séquence.

Création d'un ensemble (ou set) à partir d'une liste

Il faut donc impérativement utiliser la fonction native set().
Dans la liste d'origine il y avait un doublon ; doublon qui a disparu dans l'ensemble.

Création d'un ensemble à partir d'une chaine

La chaine "anguille" comprend deux "l".
Dans la chaine "lotte de mer" il y a aussi des doublons.
Dans les "sets" ensemble2 et ensemble3 les doublons ont disparu.

Notez que l'existence de doublons dans la source ne provoque jamais d'erreurs d'exécution lorsqu'on appelle la fonction set()

On peut construire rapidement un "set" composé de nombres avec la fonction range()

Il faut donc imbriquer la fonction range() dans la fonction set().

Opérations sur les ensembles

Maintenant que vous savez créé un ensemble de différentes manières, voyons les manipulations sur ce type de données.

Ajouter une valeur au "set"

On a pu ajouter la lettre "i' à l'ensemble. Par contre la tentative d'ajout de la lettre "l" a échoué puisque cette valeur existait déjà dans le "set".
Constatez qu'il n'y a toujours pas de "plantage" de la commande.

Vérifier l'existence d'une valeur dans le "set"

On peut donc appliquer les opérateurs "in" et "not in" à un ensemble.

Parcourir un ensemble

Un 'set' est une structure itérable donc elle peut être parcouru par une boucle FOR. >>> for lettre in ensemble3: ... lettre ... 'r' 'l' 'm' 'd' 'i' 'e' ' ' 'o' 't'

Autres manipulations possibles

Vider un set de ses éléments

"ensemble4" est vidé grâce à la méthode clear()

Supprimer un élément dans l'ensemble

Je supprime la lettre "i" de l'ensemble puis je demande la suppression d'un élément qui n'existe pas ; l'interpréteur ne lève pas d'exception avec la méthode discard() mais signale une erreur avec la méthode remove().

Union de deux ensembles

Le nouveau ensemble ("set_union") est bien l'union de "set1" et "set2" ; les valeurs communes aux deux ensembles d'origine ne sont présentes qu'une fois.

Intersection de deux ensembles

Le nouvel ensemble ("set_inter") ne comprend que les éléments qui étaient communs aux deux ensembles d'origine : 5,6,7,8,9.

Convertir un ensemble en chaine

Donc nous pouvons produire une chaine à partir d'un ensemble.

La méthode 'join()' peut donc s'appliquer à des listes, des tuples, des dictionnaires et des ensembles pour produire une chaine.

Exemple d'utilisation des ensembles

Deux plongeurs donnent la liste des poissons qu'ils ont pu observer dans un lac.
Vous devez en déduire la liste des poissons de ce biotope (sans doublons). >>> plongeur1 = {"gardon", "goujon", "brème", "carpe", "rotengle", "barbeau", "silure"} >>> plongeur2 = {"anguille", "alose", "gardon", "brochet", "perche", "barbeau", "poisson-chat"} >>> liste_poissons = plongeur1.union(plongeur2) >>> liste_poissons {'brème', 'gardon', 'poisson-chat', 'barbeau', 'silure', 'goujon', 'alose', 'carpe', 'brochet', 'anguille', 'perche', 'rotengle'} >>> len(plongeur1) 7 >>> len(plongeur2) 7 >>> len(liste_poissons) 12

Deux espèces ont été signalées par les deux plongeurs.

Ce qu'on ne peut pas faire sur un ensemble

Un ensemble n'est pas une séquence : un élément n'a pas d'indice. Donc on ne peut pas "slicer" un ensemble ni appliquer la méthode index().
Démonstration : >>> ensemble4 =set(range(1,10)) >>> ensemble4[2] TypeError: 'set' object is not subscriptable >>> ensemble4.index(7) AttributeError: 'set' object has no attribute 'index'

Nous avons des erreurs lorsque l'on tente de slicer ou faire une recherche (méthode index()) dans un set.

Programme basé sur un ensemble

Vous vous souvenez du programme qui consistait à tirer au sort cinq cartes. Je disais même que ce programme "trichait" puisqu'une même carte pouvait être tirée 2 fois.
En utilisant un ensemble à la place d'une liste, 'pour construire la main du joueur), nous n'aurons plus ce problème !

Le code corrigé

Notez les commentaires multi-lignes : encadrés par trois guillemets

Notez que la fonction len() fonctionne pour tous les types de structures (liste, tuple, dictionnaire, ensemble).
Par contre pour ajouter un élément à un ensemble, la méthode est add() (et non pas append()).

Notez les symboles dans l'argumentation de la fonction print() :
• end=" -" : pour éviter un saut de ligne
• \n : pour créer un saut de ligne

Trace de l'exécution

Et oui, il y a encore un petit problème. Si la même carte est tirée au sort deux fois, l'ensemble ne comprend alors que 4 cartes (puisque les doublons sont interdits).

Il faudrait imaginer que dans ce cas (N cartes < à 5) il y ait un nouveau tirage.
C'est possible à condition de créer une fonction "tirage_carte" et d'appeler cette fonction dans le programme principal jusqu'à ce que le nombre de cartes dans la main soit de 5. C'est ce qu'on appelle faire de la programmation structurée.
Et oui, élaborer un programme parfait c'est parfois un long chemin ...