Apprendre Python et s'initier à la programmation

Une fois un ensemble créé, il est possible d'en obtenir des informations ou de le modifier en utilisant des fonctions dédiées aux ensembles. On a déjà vu les fonctions len et in, dans la section précédente, qui permettent respectivement de connaitre la taille de l'ensemble et de tester l'appartenance d'un élément à un ensemble.

Une fois un ensemble créé, on peut le modifier, c'est-à-dire lui ajouter ou retirer des valeurs. On utilise pour cela les fonctions add et remove, qu'il faut appliquer sur la variable contenant l'ensemble. L'exemple suivant crée un ensemble, lui retire deux valeurs et en ajoute une :

S = {1, 2, 3, 4}
S.remove(1)
S.remove(2)
S.add(5)

print(S)

Comme on peut le constater sur le résultat de l'exécution de ces instructions, l'ensemble qui contenait cinq éléments au départ ne contient plus que les trois éléments kitxmlcodeinlinelatexdvp3finkitxmlcodeinlinelatexdvp, kitxmlcodeinlinelatexdvp4finkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvp5finkitxmlcodeinlinelatexdvp :

{3, 4, 5}

Si on tente de supprimer un élément qui ne fait pas partie de l'ensemble, la fonction remove provoquera une erreur lors de l'exécution. Il existe également une fonction discard qui, elle, ne produira pas d'erreur. Enfin, il existe également une fonction pop qui permet d'obtenir l'un des éléments de l'ensemble, le retirant de ce dernier.

Comme on le verra en détail plus loin, Python est un langage de programmation très riche qui permet notamment de définir des opérations spécifiques à chaque nouveau type de données.

En l'occurrence, il est possible d'effectuer des opérations ensemblistes sur les données de type set. La figure 1 illustre le résultat de ces différentes opérations, étant donné deux ensembles kitxmlcodeinlinelatexdvpAfinkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvpBfinkitxmlcodeinlinelatexdvp :

• la différence entre kitxmlcodeinlinelatexdvpAfinkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvpBfinkitxmlcodeinlinelatexdvp, notée kitxmlcodeinlinelatexdvpA \setminus Bfinkitxmlcodeinlinelatexdvp, contient tous les éléments de kitxmlcodeinlinelatexdvpAfinkitxmlcodeinlinelatexdvp sauf ceux appartenant également à kitxmlcodeinlinelatexdvpBfinkitxmlcodeinlinelatexdvp ;
• l'union des ensembles kitxmlcodeinlinelatexdvpAfinkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvpBfinkitxmlcodeinlinelatexdvp, notée kitxmlcodeinlinelatexdvpA \cup Bfinkitxmlcodeinlinelatexdvp, contient tous les éléments se trouvant soit dans kitxmlcodeinlinelatexdvpAfinkitxmlcodeinlinelatexdvp, soit dans kitxmlcodeinlinelatexdvpBfinkitxmlcodeinlinelatexdvp (ou dans les deux) ;
• l'intersection des ensembles kitxmlcodeinlinelatexdvpAfinkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvpBfinkitxmlcodeinlinelatexdvp, notée kitxmlcodeinlinelatexdvpA \cap Bfinkitxmlcodeinlinelatexdvp, contient tous les éléments se trouvant à la fois dans kitxmlcodeinlinelatexdvpAfinkitxmlcodeinlinelatexdvp et dans kitxmlcodeinlinelatexdvpBfinkitxmlcodeinlinelatexdvp.

Comme on le verra plus loin dans ce livre, le langage Python permet de redéfinir des opérateurs pour tout nouveau type de données. En l'occurrence, les opérations ensemblistes de différence, d'union et d'intersection sont respectivement calculées par les opérateurs -, | et &. Voici un exemple utilisant ces trois opérateurs :

A = {1, 2, 3, 4}
B = {3, 4, 5}

print(A - B)
print(A & B)
print(A | B)

Voici le diagramme de Venn reprenant les deux ensembles kitxmlcodeinlinelatexdvpAfinkitxmlcodeinlinelatexdvp et kitxmlcodeinlinelatexdvpBfinkitxmlcodeinlinelatexdvp, ainsi que leurs différents éléments :

Le résultat de l'exécution de ces instructions correspond bien aux résultats attendus des opérations ensemblistes, et est conforme à ce que l'on peut observer sur le diagramme de Venn :

{1, 2}
{3, 4}
{1, 2, 3, 4, 5}

Tout comme c'est le cas avec les opérateurs arithmétiques, on peut également construire des affectations composées à partir des opérateurs ensemblistes. Cela nous offre donc une autre possibilité pour modifier un ensemble. Étant donné un ensemble A, les deux séquences d'instructions suivantes sont (presque) équivalentes :

# Appel de fonction
A.add(6)
A.remove(4)

# Opération ensembliste
A |= {6}
A -= {4}

Pourquoi ces opérations ne sont-elles pas complètement équivalentes ? Pour vraiment le comprendre, il faudra attendre le prochain chapitre sur les objets, mais on peut néanmoins déjà comprendre l'intuition grâce à la figure 2 qui montre la situation en mémoire.

Sur la gauche, on peut voir la situation en mémoire avant et après exécution de l'instruction A.add(6). L'ensemble contenu dans la variable A a été modifié et contient un élément supplémentaire.

Sur la droite, on peut voir la situation en mémoire avant et après exécution de l'instruction A |= {6}. La valeur de la variable A a été modifiée et contient un nouvel ensemble, résultat de l'union de l'ensemble A original avec l'ensemble {6}. L'ensemble qui était originellement référencé par la variable A reste en mémoire, mais n'est plus accessible.

Terminons cette section en nous penchant sur l'aspect modifiable des éléments d'un ensemble, mais également de l'ensemble en tant que tel.

La première contrainte importante concernant les éléments d'un ensemble est qu'ils doivent être non modifiables. Voyons cela avec l'exemple suivant qui tente de créer un ensemble contenant des listes :

A = {[0], [1, 2, 3]}

Les listes étant modifiables, on ne peut en utiliser comme éléments d'un ensemble et une erreur d'exécution est produite par l'interpréteur :

Traceback (most recent call last):
  File "program.py", line 1, in <module>
    A = {[0], [1, 2, 3]}
TypeError: unhashable type: 'list'

Et qu'en est-il des ensembles ? Comme on l'a vu précédemment, un ensemble est modifiable puisqu'on peut lui ajouter ou retirer des éléments une fois créé, notamment avec add et remove.

Il est possible de définir un ensemble non modifiable, c'est-à-dire que l'on ne pourra pas le modifier une fois créé. Pour cela, on utilise simplement le type frozenset au lieu du type set. Tout ce que l'on a vu précédemment pour les ensembles, à l'exception des opérations de modification, est également applicable aux frozenset.

L'exemple suivant crée un ensemble non modifiable et tente de lui ajouter un élément :

A = frozenset([1, 2, 3])
A.add(6)

Puisque la variable A contient un ensemble non modifiable, une erreur se produit lors de l'exécution :

Traceback (most recent call last):
  File "program.py", line 2, in <module>
    A.add(6)
AttributeError: 'frozenset' object has no attribute 'add'

Néanmoins, notez que l'instruction A |= {6} s'exécute sans produire d'erreur. Après son exécution, la variable A contiendra un nouvel ensemble, à savoir frozenset({1, 2, 3, 6}). On n'a donc pas modifié l'ensemble originellement présent dans A, mais on lui a affecté un nouvel ensemble non modifiable.

Le dictionnaire est un type modifiable, c'est-à-dire que l'on va pouvoir modifier les valeurs des paires clé-valeur qu'il contient, mais également lui ajouter ou retirer de telles paires. Modifier la valeur d'une paire se fait comme avec les listes, c'est-à-dire avec les crochets en précisant la clé de la paire que l'on veut modifier. Ainsi, pour changer le prix des citrons, on écrit l'instruction suivante :

price['lemon'] = 0.90

Si la clé que l'on avait spécifiée dans l'instruction précédente n'existait pas dans le dictionnaire, une nouvelle paire clé-valeur aurait été ajoutée. C'est donc ainsi que l'on ajoute un élément à un dictionnaire :

price['apple'] = 1.00
print(price)

Cette instruction a donc ajouté une nouvelle paire dont la clé est 'apple' et la valeur est kitxmlcodeinlinelatexdvp1.00finkitxmlcodeinlinelatexdvp, comme on peut le constater sur le résultat de l'exécution :

{'pear': 1.0, 'lemon': 0.9, 'apple': 1.0}

Pour supprimer un élément du dictionnaire, comme on l'a précédemment vu, il suffit d'utiliser la fonction del. Par exemple, pour supprimer la paire correspondant aux poires, on écrit :

del(price['pear'])

Il existe plusieurs manières de parcourir un dictionnaire. Comme on a vu en début de section, on peut utiliser la boucle for qui va parcourir ses différentes clés. On accède ensuite aux valeurs associées aux clés avec les crochets :

for fruit in price:
    print(fruit, price[fruit], sep=' : ')

L'exécution de cette boucle affiche le résultat suivant :

apple : 1.0
lemon : 0.9

Rappelez-vous bien que l'ordre n'est pas déterminé et peut donc être différent entre deux exécutions, puisqu'un dictionnaire est un ensemble.

On peut récupérer toutes les clés d'un dictionnaire grâce à la fonction keys et tous ses éléments grâce à la fonction items, toutes deux à appliquer sur le dictionnaire duquel on veut extraire les informations. Ces deux fonctions renvoient respectivement des données de type dict_keys et dict_items. Ce sont des séquences que l'on peut transformer en listes avec la fonction list. L'exemple suivant et son résultat illustrent cela :

print(price.keys())
print(price.items())

print(list(price.keys()))
print(list(price.items()))

dict_keys(['apple', 'lemon'])
dict_items([('apple', 1.0), ('lemon', 0.9)])

['apple', 'lemon']
[('apple', 1.0), ('lemon', 0.9)]

Enfin, on peut également directement parcourir les paires d'un dictionnaire en utilisant la fonction items :

for key, value in price.items():
    print(key, value, sep=' : ')

Un dictionnaire ressemble à un tuple nommé pour certains points, mais il s'agit bel et bien de deux types de données différents. Voici les différences entre ces deux types :

• un tuple nommé est une séquence et ses éléments sont donc ordonnés, ce qui n'est pas le cas d'un dictionnaire qui est un ensemble de paires ;
• un tuple nommé est non modifiable alors que le dictionnaire l'est ;
• les attributs d'un tuple nommé doivent être des chaines de caractères alors que les clés d'un dictionnaire peuvent être n'importe quelle donnée non modifiable.

On peut aisément aller plus loin et augmenter la dimension d'une liste. Par exemple, une liste à trois dimensions est simplement une liste de listes de listes. Pour accéder aux valeurs de la liste tridimensionnelle, il faudra dès lors spécifier trois indices. Par exemple, pour la liste suivante :

data = [[[1], [2, 3]], [[4, 5, 6]]]

On accède à la valeur kitxmlcodeinlinelatexdvp1finkitxmlcodeinlinelatexdvp avec data[0][0][0] et à la valeur kitxmlcodeinlinelatexdvp6finkitxmlcodeinlinelatexdvp avec data[1][0][2]. De manière générale, on évite toutefois de monter en dimensions, car cela rend les listes plus complexes, notamment pour accéder à leurs éléments et les manipuler. Autant les listes à deux dimensions sont encore assez répandues, celles à trois dimensions sont déjà plus rares et ne parlons même pas des dimensions supérieures.

Ce que l'on vient de voir avec les listes peut s'appliquer aux autres structures de données que l'on a vues jusqu'à présent, en respectant certaines contraintes.

Tout d'abord, tout ce que l'on peut imbriquer dans une liste, on peut également le faire avec des tuples. On a déjà vu que l'on pouvait imbriquer des listes dans une liste, et on peut également y imbriquer des tuples. On pourrait, par exemple, stocker une liste de coordonnées dans le plan comme suit :

coords = [(0,0), (7,-2), (4,5), (-3,-9)]

On peut également imbriquer des ensembles dans une liste. Par exemple, on pourrait vouloir stocker une liste de lunches, par ordre de préférence :

lunches = [
    {'apple', 'banana', 'grape'},
    {'yogurt', 'cereals'},
    {'bread', 'cheese', 'ham'},
    {'sausage'}
]

Remarquez que la liste a été déclarée sur plusieurs lignes, afin de la rendre plus lisible. Une telle notation est autorisée et même recommandée lorsque vous déclarez des structures complexes.

Enfin, il n'y a aucun problème à stocker des dictionnaires dans une liste. L'exemple suivant montre comment on pourrait stocker ses contacts par ordre alphabétique des prénoms :

contacts = [
    {'firstname': 'Alexis', 'lastname': 'King'},
    {'firstname': 'Brice', 'lastname': 'Monster'},
    {'firstname': 'Sébastien', 'lastname': 'Adams'}
]

Concernant les ensembles, on a vu que l'on ne pouvait y stocker que des valeurs non modifiables. On ne va donc pas pouvoir y imbriquer des listes, des ensembles (on peut néanmoins imbriquer des ensembles non modifiables, obtenus avec frozenset, dans des ensembles) ou des dictionnaires. On peut, par exemple, imbriquer des tuples dans un ensemble. Voici, par exemple, un ensemble reprenant, pour différents athlètes, les résultats réalisés en mètres pour trois lancers de javelot consécutifs :

results = {
    (90.73, 89.23, 90.12),
    (87.23, 90.11, 88.12),
    (90.88, 88.61, 89.91)
}

La même restriction s'applique aux clés d'un dictionnaire qui doivent donc être des valeurs non modifiables. On peut, par exemple, utiliser un tuple comme clé d'un dictionnaire. L'exemple suivant associe une personne à une série de coordonnées dans le plan :

config = {
    (0, 0): 'Arnaud',
    (2, 1): 'Louis',
    (-1, 3): 'Marie',
    (3, -1): 'Dan'
}

Si on désire pouvoir placer plusieurs personnes à une même coordonnée, et se rappelant que les clés d'un dictionnaire doivent être uniques, on va devoir imbriquer une liste dans le dictionnaire :

config = {
    (0, 0): ['Arnaud', 'Pierre'],
    (2, 1): ['Louis'],
    (-1, 3): ['Marie', 'Éric', 'Tom'],
    (3, -1): ['Dan']
}

Comme on le verra à la section suivante, on va aussi pouvoir imbriquer des dictionnaires ensemble afin de construire des structures complexes permettant de représenter de véritables bases de données.

Terminons cette section en s'intéressant à la copie de structures de données, qui peut parfois se révéler délicate sachant qu'une variable ne contient pas toute la structure de données, mais uniquement une référence vers l'emplacement en mémoire où elle est stockée. En effet, comme on l'a vu à la section 5.1, lorsqu'on affecte à une variable une autre variable qui contient une référence vers une liste, on crée un alias. Les deux variables contiennent une référence vers la même zone mémoire, contenant la liste, et permettent donc d'agir sur la même liste. Revoyons cela avec l'exemple suivant :

L = [1, 2, 3]
A = L

A[0] = 42
print(L)

Alors que l'on pourrait croire, de prime abord, que la variable A contient une copie de la liste référencée par la variable L, ce n'est effectivement pas le cas. Les variables A et L sont des alias vers la même liste, qui n'existe donc qu'une seule fois en mémoire. On peut le constater avec le résultat de l'exécution :

[42, 2, 3]

Pour faire une réelle copie, il faut passer par la fonction prédéfinie list qui va, elle, créer une nouvelle liste en mémoire, avec le même contenu que celle passée en paramètre. Pour faire une véritable copie, l'exemple précédent doit donc se réécrire comme suit :

L = [1, 2, 3]
A = list(L)

A[0] = 42
print(L)

Cette fois-ci, le code affiche bien ce que l'on attend :

[1, 2, 3]

Ce comportement est exactement le même pour toutes les autres structures de données que l'on a vues jusqu'à présent. Il ne pose évidemment aucun souci pour les structures de données non modifiables comme les chaines de caractères, les tuples ou les intervalles.

Pour les autres structures, il faudra à chaque fois passer par la fonction prédéfinie correspondant à la structure de données pour en faire une copie, à savoir list, set et dict.

I-C-1-c-i. Module copy▲

La méthode de copie que l'on vient de voir permet en réalité de faire une copie en surface. Pour comprendre cette notion, attardons-nous un moment sur l'exemple suivant :

 

Sélectionnez

1.
2.
3.
4.
5.

L = [[1, 2], [3, 4, 5]]
A = list(L)

A[1][0] = 42
print(L)

Bien que l'on ait fait une copie de la liste référencée par la variable L dans la variable A, après avoir modifié cette copie à partir de la variable A, on observe le résultat suivant après exécution :

 

Sélectionnez

[[1, 2], [42, 4, 5]]

Pour comprendre ce qui s'est passé, il faut examiner la situation en mémoire, après exécution des deux premières instructions, illustrée à la figure 4. On y voit donc que la liste directement référencée par la variable L a bel et bien été copiée, cette copie étant référencée par la variable A. La subtilité, c'est que les listes qui sont référencées par ces deux listes sont, elles, uniques et c'est dans ces listes que se trouvent les valeurs de la liste à deux dimensions.

Si on le souhaite, il est également possible de faire une copie en profondeur, c'est-à-dire que tous les niveaux de la structure de données seront copiés, même les imbriquées.

Pour cela, on va faire appel au module copy qui propose deux fonctions :

• copy permet de faire une copie en surface ;
• deepcopy permet de faire une copie en profondeur.

L'exemple précédent avec une copie en profondeur se réécrit simplement comme suit, sans oublier d'importer le module copy évidemment :

 

Sélectionnez

1.
2.
3.
4.
5.
6.
7.

import copy

L = [[1, 2], [3, 4, 5]]
A = copy.deepcopy(L)

A[1][0] = 42
print(L)

Le résultat de l'exécution montre que l'on a bel et bien une copie intégrale de la liste L :

 

Sélectionnez

[[1, 2], [3, 4, 5]]

La copie en profondeur copie donc intégralement toutes les structures imbriquées. Cela a deux conséquences immédiates : la copie prendra plus de temps et la consommation mémoire globale du programme sera plus grande. Lorsqu'on fait une copie, il est dès lors important de se poser la question de savoir ce que l'on veut en faire. Si c'est uniquement pour la consulter, un simple alias suffira, et si c'est pour la modifier, selon la profondeur des modifications envisagées, le choix se portera vers une copie en surface ou en profondeur.

Les documents JSON sont utilisés pour construire des bases de données orientées document. Dans de telles bases de données, les éléments stockés peuvent être des documents JSON. Un tel type de base de données supporte essentiellement quatre opérations que l'on résume avec l'acronyme CRUD (Create, Read, Update, and Delete) :

• création et ajout d'un nouveau document ;
• lecture et récupération d'un document par une recherche ;
• mise à jour d'un document existant par modification, ajout ou suppression de paires ;
• suppression d'un document existant.

Ces quatre opérations sont nécessaires pour avoir un système complet. Si on considère l'implémentation d'une base de données orientée documents à l'aide de Python, en utilisant les dictionnaires pour stocker les documents JSON, il est assez simple d'implémenter ces quatre opérations à l'aide de celles utilisables sur les dictionnaires.

Un document JSON peut toujours être transformé en un dictionnaire Python ; cette opération s'appelle la désérialisation. L'opération inverse, appelée sérialisation, tente de convertir un dictionnaire Python en un document JSON. Cette seconde opération n'est pas toujours possible, les dictionnaires Python étant plus riches que ce qui est permis en JSON. On relève notamment les différences majeures suivantes :

• les étiquettes des paires d'un document JSON doivent être des chaines de caractères alors qu'elles peuvent être n'importe quelle donnée non modifiable dans un dictionnaire Python ;
• les types de données autorisés pour les valeurs des paires d'un document JSON sont limités aux chaines de caractères, booléens, nombres entiers et flottants, listes et documents JSON imbriqués alors qu'il y a beaucoup plus de types autorisés dans un dictionnaire Python.

Les deux opérations de sérialisation et de désérialisation peuvent être faites à partir de fonctions disponibles dans le module json. La fonction dumps correspond à la sérialisation et la fonction loads désérialise un document JSON.

Le premier exemple construit un dictionnaire Python et le sérialise en un document JSON qui est ensuite affiché. Le résultat renvoyé par la fonction dumps est de type chaine de caractères :

import json

bb = {'seasons': 5, 'genre': ['crime drama', 'thriller']}
skins = {'seasons': 7, 'genre': ['teen drama', 'comedy drama']}
tvshows = {'Breaking Bad': bb, 'Skins': skins}

document = json.dumps(tvshows, indent=4)
print(type(document))
print(document)

Le paramètre nommé indent de la fonction dumps permet d'obtenir un joli formatage du document JSON, comme on le voit sur le résultat de l'exécution :

<class 'str'>
{
    "Breaking Bad": {
        "genre": [
            "crime drama",
            "thriller"
        ],
        "seasons": 5
    },
    "Skins": {
        "genre": [
            "teen drama",
            "comedy drama"
        ],
        "seasons": 7
    }
}

Voyons maintenant l'opération inverse, à savoir la création d'un dictionnaire Python à partir d'une chaine de caractères contenant un document JSON. On utilise donc pour cela la fonction loads comme le montre l'exemple suivant :

import json

document = '{"Belgium":{"capital":"Brussels","languages":["french","dutch","german"]},"China":{"capital":"Beijing","languages":["mandarin chinese"]}}'

countries = json.loads(document)
print(type(countries))
print(countries['China'])

La variable countries, qui stocke le résultat renvoyé par la fonction loads, contient bien un dictionnaire comme on peut le constater sur le résultat de l'exécution :

<class 'dict'>
{'languages': ['mandarin chinese'], 'capital': 'Beijing'}

Les deux fonctions dumps et loads provoquent une erreur lors de l'exécution lorsqu'un problème de format de données est présent. La sérialisation échouera si le dictionnaire Python passé en paramètre comporte des éléments interdits par le format JSON. La désérialisation échouera si la chaîne de caractères passée en paramètre ne représente pas un document JSON valide.