STRUCTURES DE DONNÉES EN PYTHON

STRUCTURES DE DONNÉES EN PYTHON

INDEX

TU RETO EN ESTA UNIDAD........................................................................ 3

1. STRUCTURES DE DONNÉES..................................................................... 5
1.1. SÉQUENCES..................................................................................................6
1.1.1. LISTES....................................................................................................6
[Link]. Méthodes de consultation et de modification des listes ..................................... 13
1.1.2. TUPLAS................................................................................................19
1.1.3. DE RETOUR AVEC LES CHAÎNES..........................................................22
1.2. ENSEMBLES (ENSEMBLE DE DONNÉES).............................................................................22
1.3. DICTIONNAIRES.............................................................................................26
1.4. DÉFINITIONS PAR COMPRÉHENSION ..........................................................29
1.5. GÉNÉRATEURS
QUE FAIS-TU APRENDRE ? .......................................................................... 37
BIBLIOGRAPHIE ......................................................................................... 39

1
 STRUCTURES DE DONNÉES EN PYTHON

TU RETO DANS CETTE UNITÉ

Tu es arrivé jusqu'ici... félicitations ! Tu commences à disposer de connaissances

tos pour créer vos propres programmes, mais il vous manque encore quelque chose d'essentiel et
de suma importancia : les structures de données.

Saurais-tu dire en quelques mots ce que sont ce type de structures ? Non

ne t'inquiète pas si tu ne sais pas le décrire avec précision en ce moment. À la fin de cette
unité, tu comprendras parfaitement son utilisation et les différents types qui existent,
ainsi que les propriétés de chacune.

Allons-y...

3
 STRUCTURES DE DONNÉES EN PYTHON

1. STRUCTURES DE DONNÉES
Python incorpore plusieurs types de données composées de manière native. Nous pouvons
ver un type composé comme une structure de données qui nous permet d'almanecer
nar une collection d'éléments ou de valeurs. Si vous avez travaillé avec d'autres langages,
un exemple simple serait un tableau vectoriel d'éléments. Python nous offre
plus d'alternatives, avec des caractéristiques différentes selon la façon dont on amis
cenan les valeurs à l'intérieur de la structure et quelles opérations nous pouvons effectuer.

Bien que nous puissions également englober les chaînes (stryunicode) et les ensembles
tos(setyfrozenset)o les constructeurs dans cette catégorisation, dans cette
Unité, nous allons voir les trois structures de données principales de Python :

Tuples.

Listes.
Dictionnaires (ou tables de hachage).

En résumé, et pour commencer l'unité, les manières d'y accéder sont-

Les structures de contrôle (quel que soit leur type) sont :

Au moyen d'indices : séquence[0], séquence[1], séquence[2]...

séquence[n].

Médianteslicingo portions : séquence [début:fin:pas].

Par les itérateurs et les structures de contrôle (boucle for).

5
STRUCTURES DE DONNÉES EN PYTHON

Les structures de données en Python pourraient être divisées en deux groupes, lasse-
cuencielles (formées par des séquences de données ordonnées) et les ensembles de
données, qui ne sont pas ordonnées. À son tour, nous pouvons également les diviser par struc-
tours de données mutables et immuables, comme nous l'avons vu dans l'unité d'initiation.
Nous allons approfondir un peu plus tous ces termes.

1.1.SÉQUENCES

Nous commencerons par les structures de type séquentiel. Ce sont des types de données com-
placés par une série d'éléments, préservant l'ordre ou la position dans laquelle
ils sont ajoutés à la structure. Pour cette raison, on dit qu'ils sont des types ordonnés.

Comme cela prête parfois à confusion, nous allons le souligner. Ici, l'ordre n'est pas
cela signifie qu'en ajoutant des éléments, ceux-ci se réorganisent (par ex. numériquement
te o alfabétiquement). Cela fait simplement référence au fait qu'ils conservent l'ordre dans lequel
son ajoutés, c'est-à-dire leur ordre positionnel.

Tous les sous-types de séquences en Python partagent plusieurs opérations.

nes, comme l'accès indexé par position, le tranchage (pour ce que préfère-
ras, ne l'appelle jamais comme ça) ou « slicing », la concaténation ou l'appartenance. Va-
Nous allons tout voir plus en profondeur.

[Link]

Nous commençons avec cette structure de données séquentielle et mutable (nous pouvons
accéder à ses composants et les modifier par le biais de ses propres méthodes).
En Python, les listes sont probablement le type composé le plus utilisé.
en raison de sa polyvalence et de sa simplicité. Une liste est une séquence ordonnée d'éléments.
Mentos. Contrairement aux vecteurs ou tableaux d'autres langages, dans une liste il y a
ils peuvent mélanger des éléments de types différents sans problème. Bien que ce soit habituel
est-ce que tous les éléments ont le même type.

La façon courante de définir une liste est d'inclure les éléments séparés par
des virgules entre une paire de crochets.

6
 STRUCTURES DE DONNÉES EN PYTHON

Exemples de listes

Si tu as remarqué, la dernière liste d'exemple a des listes imbriquées comme éléments.

Combien d'éléments dirais-tu que la liste de niveau supérieur a-t-elle ? Serais-tu capable de
les identifier ? Nous pouvons utiliser ce que nous avons appris sur les boucles pour vérifier
barlo...

pour elemento dans listas_anidadas :

imprimer(elemento)

Ici il y a

['listas', 'anidadas']

[1, 2]

Pour accéder aux éléments d'une liste par leur index ou position, nous mettons le
indice entre crochets aussi.

7
STRUCTURES DE DONNÉES EN PYTHON

Le premier élément d'une liste (et de tout se-

la séquence) a l'indice zéro. Donc, si une liste a
nélementos, pour accéder au dernier nous devrons
utiliser l'indice(n - 1).

Si nous voulons obtenir la longueur d'une liste (le nombre d'éléments qui con-
nous devons simplement utiliser la fonction len().

Longueur de la liste

len(lista_nums)

# Resultado: 6

Longueur de la liste imbriquée :

Chaque "sous-liste" interne est considérée comme un seul élément

len(listes_imbriquées)

# Resultado: 3

Sélectionner un élément

lista_nums[0] # La première valeur est obtenue avec l'index zéro

lista_nums[5] # L'élément pour l'indice 5

# Résultat : 4

lista_nums[len(lista_nums)‐1] # Le dernier élément est dans LEN‐

1

# Resultado: 4

# En sélectionnant dans une liste imbriquée

listas_anidadas[1] # L'élément retourné peut être une autre liste

# Resultado: ['listas', 'anidadas']

8
 STRUCTURES DE DONNÉES EN PYTHON

Si nous utilisons des indices négatifs, nous commençons à compter depuis la fin

lista_nums[-1] # Renvoie le dernier élément de la liste

# Resultado: 4

lista_nums[-len(lista_nums)] # Retourne le premier élément de la liste

sta

# Résultat : 1

Pour que vous compreniez mieux comment fonctionnent les indices pour accéder à un
élément, imagine que nous avons la liste[ 'A', 'B', 'C', 'D', 'E', 'F' ].
La figure suivante montre à quelle position référence un indice positif ou un
indice négatif.

Au lieu de voir les indices "pointant" vers chaque élément, pensons que les ind...
ces marquent les positions entre les éléments de la séquence. Dans ce cas, l'indice
6 référence une position en dehors des limites de la liste et produirait une erreur.

Maintenant, il est plus facile de voir comment nous pouvons sélectionner une " tranche " d'éléments conti-
guos d'une liste. Nous indiquons l'indice ou la position de départ à partir de laquelle commencer
montre la sélection et la position finale jusqu'où nous voulons arriver, en les écrivant.
dans les crochets séparés par deux points (:). Dans les tranches, l'élément
le correspondant à la limite initiale est toujours inclus, mais l'élément à la limite
la finale est exclue.

9
STRUCTURES DE DONNÉES EN PYTHON

letras = ['A','B','C','D','E','F']

Nous sélectionnons une 'tranche' avec les deux premiers éléments

lettres[0:2]

# Resultado: ['A', 'B']

lettres[2:5]

# Resultado: ['C', 'D', 'E']

Si nous ne spécifions pas le deuxième indice, nous sélectionnons jusqu'à la fin

lettres[2:]

# Resultado: ['C', 'D', 'E', 'F']

# et si nous ne spécifions pas le premier indice, nous sélectionnons depuis le pr

incipio

lettres[:4]

# Resultado: ['A', 'B', 'C', 'D']

Nous pouvons également utiliser la notation des indices négatifs.

Nous sélectionnons depuis l'avant-dernière position (incluse) jusqu'à le

final

lettres[-2:]

# Resultado: ['E', 'F']

Nous sélectionnons depuis le début jusqu'à l'avant-dernière position

(exclue)

letras[:-2]

# Resultado: ['A', 'B', 'C', 'D']

Comme le premier index est toujours inclus

# et le second est toujours exclu,

nous pouvons reconstruire la liste ainsi

letras[:2] + letras[2:]

# Resultado: ['A', 'B', 'C', 'D', 'E', 'F']

10
 STRUCTURES DE DONNÉS EN PYTHON

Comme nous l'avons mentionné en début de section, les listes sont mutables, c'est
dire, nous pouvons modifier le contenu des éléments d'une liste de si-
formes suivantes…

imprimer(lista_lenguajes)

["C", "python", "fortran", "cobol"]

# nous modifions un élément individuel

lista_lenguajes[0] = "java"

imprimer(lista_lenguajes)

["java", "python", "fortran", "cobol"]

nous pouvons également remplacer les valeurs d'une "tranche"

lista_lenguajes[2:] = ["kotlin", "brainfuck"]

imprimer(lista_lenguajes)

['java', 'python', 'kotlin', 'brainfuck']

# ou supprimer certaines valeurs, en remplaçant par une liste vide

lista_lenguajes[1:3] = []

print(lista_lenguajes)

['java', 'brainfuck']

# ou la vider complètement

lista_lenguajes[:] = []

imprimer(lista_lenguajes)

[]

Une autre façon de modifier sa valeur est par le biais de la concaténation (ou de la réplication) de
listes. C'est-à-dire que nous pouvons "ajouter" deux listes ou répliquer leur contenu.

11
STRUCTURES DE DONNÉES EN PYTHON

lista_1 = ['a', 'b', 'c']

lista_2 = [100, 200, 300]

# concaténation

liste_1 + liste_2

['a', 'b', 'c', 100, 200, 300]

répliquer la liste trois fois

3 * liste_1

['a', 'b', 'c', 'a', 'b', 'c', 'a', 'b', 'c']

Nous pouvons également extraire les éléments d'une liste et les attribuer à différents
variables de forme simple avec une seule instruction.

x, y, z = lista_2

imprimer(x)

imprimer(y)

imprimer(z)

Résultat

100

200

300

12
 STRUCTURES DE DONNÉES EN PYTHON

[Link].Méthodes de consultation et de modification des listes

Lorsque nous aurons besoin de réaliser des consultations ou de modifier les valeurs de celles-ci, dans
En Python, nous disposons de l'aide de certaines méthodes que nous pourrons utiliser dans
notre bénéfice. Voyons-les...

Ajouter un élément à la fin de la liste : append() .

Extraire le dernier élément de la liste :pop().

Insérer un élément devant une position concrète : insert().

Rechercher la position précise d'un élément de la liste : index().

Compter le nombre de fois qu'un élément apparaît : count().

Supprimer le premier élément de la liste : remove().

Trier les valeurs de la liste : sort().

Inverser l'ordre de la liste : reverse().

Nettoyer les éléments d'une liste (vider) : clear().

Ensuite, nous avons un ordre qui nous permet d'éliminer une valeur concrète à l'intérieur
d'une liste :

Supprimer un élément en indiquant la position : del.

Ceci est différent de la méthode .pop(), qui renvoie une valeur. L'instruction du
il peut également être utilisé pour supprimer des sections d'une liste ou vider la liste complète.

a = [‐1, 1, 66.25, 333, 333, 1234.5]

supprimer a[0]

# Resultado: [1, 66.25, 333, 333, 1234.5]

supprimer a[2:4]

# Resultado: [1, 66.25, 1234.5]

del a[:]

# Resultado: []

13
STRUCTURES DE DONNÉES EN PYTHON

supprimerpeut également être utilisé pour supprimer des variables de

une liste.
del a.

Ce n'était pas une blague quand nous te parlions des bienfaits des listes et leur
polyvalence, tu ne crois pas ? Voyons un exemple de chaque méthode de la liste que
tu viens de lire pour que tu restes encore plus avec son fonctionnement.

lista_1 = ['a', 'b', 'c']

# ajouter un élément à la fin de la liste

lista_1.append('d')

imprimer(lista_1)

# Resultado: ['a', 'b', 'c', 'd']

# extraire le dernier élément de la liste

ultimo_valor = lista_1.pop()

print(ultimo_valor)

imprimer(lista_1)

Résultat : d

#['a', 'b', 'c']

insérer un élément devant une position précise

# insérer 'e' à la position zéro (au début)

lista_1.insert(0, 'e')

# insérer 'c' à la position 2

lista_1.insérer(2, 'c')

imprimer(lista_1)

# Resultado: ['e', 'a', 'c', 'b', 'c']

14
 STRUCTURES DE DONNÉES EN PYTHON

chercher à quelle position se trouve un élément

# (s'il n'existe pas, cela provoquera une erreur)

lista_1.index('b')

# Resultado: 3

compter le nombre de fois qu'un élément apparaît

lista_1.count('c')

# Resultado: 2

supprimer le premier élément de la liste

qui correspond à la valeur donnée

lista_1.remove('c')

print(lista_1)

# Resultado: ['e', 'a', 'b', 'c']

# trier les valeurs de la liste

# (selon le type : alphabétiquement, numériquement...)

lista_1.trier()

imprimer(lista_1)

# Resultado: ['a', 'b', 'c', 'e']

inverser l'ordre de la liste

lista_1.reverse()

imprimer(lista_1)

# Resultado: ['e', 'c', 'b', 'a']

# supprimer un élément en indiquant la position

del liste_1[2]

print(lista_1)

# Resultado: ['e', 'c', 'a']

# nettoyer tous les éléments de la liste

lista_1.clear()

imprimer(lista_1)

# Resultado: []

15
STRUCTURES DE DONNÉES EN PYTHON

Avant de continuer, profitons-en pour expliquer un détail supplémentaire sur les

variables, leur contenu et ce qui se passe lors des affectations en Python.

Imagine le cas habituel suivant. Vous avez une variable (appelons-la liste1) et la
vous initialisez avec des valeurs quelconques. Plus tard, peut-être après avoir fait plusieurs
calculs et opérations avec la première variable, vous devez créer une autre nouvelle variable
ble (disons liste2) et l'initialiser avec la même liste que la première a dans ce
moment. Donc, vous assignez la première variable à la dernière.

Nous créons et initialisons la première variable

liste1 = [1, 2, 3]

Nous faisons nos opérations ...

Et maintenant, nous devons créer une nouvelle variable

# e initialiser avec la même liste que liste1

lista2 = lista1

print(lista2)

# Resultado: [1, 2, 3]

# Évidemment, ils doivent maintenant avoir la même valeur

lista1 == lista2

Vrai

Évidemment, après l'attribution, les deux variables ont la même valeur. Mais c'est
que, en réalité, n'ont pas seulement la même valeur, mais qui visent la même
contenu.

Les deux sont des noms ou des références à la même donnée, à la même liste, et non deux.
copies distinctes avec les mêmes valeurs (quelqu'un se souvient des pointeurs en C++ ?).

Une variable en Python n'est rien d'autre qu'un nom ou une référence à une valeur.
ou structure de données qui est stockée d'une certaine manière en mémoire. Dans
Python, l'opération d'assignation d'une variable à une autre ne copie pas le contenu,
si non, cela définit un nouveau nom ou une référence au même contenu qui va-
variable originale.

16
 STRUCTURES DE DONNÉES EN PYTHON

Nous pouvons voir que deux variables représentent le même-

mon objet avec l'opérateurest.

Et qu'est-ce que cela implique ? Pense-y... Si nous modifions un élément dans la seconde va-
variable, que se passe-t-il avec la première ? Comme les deux variables ne sont rien de plus que

nombres ou références pour la même liste en mémoire, la première variable mos-

apportera également la nouvelle valeur.

Vérifions que les deux variables

# représentent le même objet

lista2 est liste1 # Vrai

# Resultado: True

# Nous modifions la liste2

lista2[1] = 99

# Et nous voyons que liste1 nous renvoie

# le même contenu modifié

print(lista1)

# Resultado: [1, 99, 3]

Néanmoins, si au lieu de modifier la valeur des éléments de la liste, vous assignez...

nous nommons une liste distincte, nous allons définir un nouvel objet ou une nouvelle structure de
données. La variable utilisée passera à nommer cet nouvel objet indépendant; les
Deux variables ne seront plus des références au même contenu.

Si nous affectons une nouvelle liste à la deuxième variable

lista2 = [7, 8, 9]

17
STRUCTURES DE DONNÉES EN PYTHON

Dejan de référencer le même contenu

lista2 est liste1 # Faux

Même si nous utilisons la première variable

dans l'expression pour définir de la seconde

lista2 = 2 * lista1 # Répétition de la première liste

Les structures de données auxquelles ils font référence sont différentes

lista2 est lista1 # Faux

Lorsqu'il s'agit de travailler avec des structures de données mutables (comme les listes), il faut
Tu dois tenir tout cela en compte pour éviter de modifier accidentellement le contenu.
donner à une variable en manipulant une seconde.

Si vous avez besoin d'une copie identique mais indépendante d'une liste, vous pouvez utiliser le
métodocopy().

lista1 = [1, 2, 3]

# Avec .copy() vous créez une nouvelle liste, copie exacte de l'originale,

mais indépendamment de cela

lista2 = [Link]()

Les valeurs dans les listes sont identiques

lista2 == lista1 # Vrai

¡Mais ce ne sont pas le même objet !!

lista2 est lista1 # Faux

Comme tu le vois, tu disposes d'un large éventail de méthodes pour te faciliter la vie
plus simple l'heure de travailler avec des listes. Passons à la structure suivante-
ra de données, qui te plaira aussi, mais d'une autre manière.

18
 STRUCTURES DE DONNÉES EN PYTHON

[Link]

Les tuples sont un type de données similaire aux listes. Comme elles, les tuples sont
formées par une séquence d'éléments ordonnés. Les différences princi-
pales son deux :

D'un point de vue syntaxique, ils sont définis en utilisant des parenthèses.
lieu de crochets (c'est pourquoi il est facile de se tromper en les déclarant).

D'un point de vue sémantique, les tuples sont immuables.

Que voulons-nous dire par immuables ? Eh bien, une fois que vous en avez créé un...
pla définissant ses éléments, vous ne pouvez plus modifier les valeurs qu'il contient.

Voyons un exemple de tuple pour que vous compreniez mieux cette structure
de données.

#!/usr/bin/python

#‐*‐codage: utf‐8‐*‐

# nous construisons les tuples en mettant leurs éléments

# séparés par des virgules entre deux parenthèses

palos_baraja = ("bastos", "oros", "espadas", "copas")

valores_baraja = ('A', 2, 3, 4, 5, 6, 7, 8, 9, 10, 'sota',

cheval

as_de_copas = (valores_baraja[0], palos_baraja[3])

caballo_de_bastos = (valores_baraja[11], palos_baraja[0])

nous pouvons utiliser des tuples comme éléments imbriqués dans un autre tuple

mano = (as_de_copas, caballo_de_bastos)

imprimer(mano)

# Resultado: (('A', 'copas'), ('caballo', 'bastos'))

print(mano[0])

# Resultado: ('A', 'copas')

19
STRUCTURES DE DONNÉES EN PYTHON

print(mano[1])

# Resultado: ('caballo', 'bastos')

# nous pouvons également utiliser des listes comme éléments,

# n'importe quel objet en réalité !

jugador = ("jugador_1", [as_de_copas, caballo_de_bastos])

imprimer(joueur)

# Resultado: ('jugador_1', [('A', 'copas'), ('caballo', 'bastos')])

Si vous essayez de modifier la tuple, vous obtiendrez une erreur.

tentez avec l'exemple que vous avez juste au-dessus, agré-
je condamne cette phrase.

mano[0] = ('caballo', "bastos").

En réalité, Python nous permet de définir un tuple sans utiliser les parenthèses au
la créer. C'est-à-dire, en mettant simplement les éléments séparés par des virgules.

De toute façon, nous te recommandons d'utiliser toujours les parenthèses. Pour commencer,
parce qu'ainsi tu mets en évidence qu'il s'agit d'un tuple et tu comprends plus facilement ton code. Et dés-
puisque lorsque vous utilisez des tuples imbriqués ou des expressions plus complexes pour
définir les éléments, tu devras inclure les parenthèses obligatoirement.

Alors, pourquoi faire des distinctions ? Simplifions !

De plus, il existe deux cas spéciaux de création de tuples : le tuple vide et le tuple
d'un seul élément. Les tuples vides se créent avec une paire de parenthèses
vide, sans aucun élément à l'intérieur.

20
 STRUCTURES DE DONNÉES EN PYTHON

Pour créer un tuple avec un seul élément, nous l'entourons de parenthèses, pe-
il est nécessaire d'ajouter une virgule juste derrière l'élément et avant la fermeture de
parenthèses. Ça semble étrange, mais les parenthèses servent aussi à "encapsuler"
lar" une expression ([Link].(3 * 4)), Python a besoin d'un indice pour distinguer si
nous voulons construire un tuple avec une seule valeur ou non.

# Nous créons le tuple vide avec une paire de parenthèses vides, sans
aucun

élément

()

print(tupla_vacia)

()

Nous créons un tuple avec un seul élément

tupla_un_elemento = (1,)

print(tupla_un_elemento)

# Résultat : (1,)

En résumé, il existe trois types généraux de tuples :

tupla = ( ) # Instance vide.

tupla = (1,2,3) # tuple homogène.

tupla = ("hola", 20, [1, 2, 3]) # tupla heterogénea (varios tipos de datos).

Comme tu le vois, sauf pour la particularité de l'immutabilité des tuples, la forme

travailler avec cette structure de données est similaire aux listes.

21
STRUCTURES DE DONNÉES EN PYTHON

[Link] AVEC LES CORDES

Si tu te souviens, quand nous avons présenté les chaînes de caractères dans une unité
auparavant, nous avons vu que nous pouvions extraire un élément en utilisant un indice entre crochets
achetez, et que nous pouvions également sélectionner une " tranche ", ou concaténer des chaînes, ou
répliquer une chaîne plusieurs fois...

Tu sais où je vais, n'est-ce pas ? En effet, les chaînes de caractères sont

un autre type de séquence en Python (comme nous vous l'avons déjà averti alors). Quelques
séquences ayant la particularité de ne se composer que de caractères de
texte, et que, au moment de les représenter, une notation plus compacte est utilisée et
sensible pour les humains, écrivant simplement le texte entre guillemets.
De plus, elles sont immuables (comme les tuples) et comportent une série de fun-
CTIONS ou méthodes spéciales uniquement pour une utilisation avec des chaînes.

[Link] (ENSEMBLE DE DONNÉES)

Tu as déjà appris qu'en Python, nous avons les types liste, tuple et chaîne de caractères.
et ce sont des types séquentiels, c'est-à-dire qu'ils sont des collections ordonnées d'éléments.

Eh bien, laissons maintenant les séquences. En Python, nous avons aussi des types com-
postes de données qui ne sont pas triés. C'est-à-dire que leurs éléments ne con-
servir l'ordre dans lequel ils sont placés.

Le type composé non ordonné le plus basique est l'ensemble (ou jeu de données)
Un ensemble est une collection non ordonnée d'éléments, et où
De plus, il ne peut y avoir d'éléments répétés. Un ensemble est modifiable.
Nous pouvons supprimer ou ajouter de nouveaux éléments, tant qu'ils ne sont pas déjà inclus.
dos dans l'ensemble.

L'utilité de ce type vient justement lorsque nous devons contrôler des éléments.
éléments dupliqués ou savoir si un élément a déjà été inclus (appartient) à un con-
ensemble, peu importe la position.

22
 STRUCTURES DE DONNÉES EN PYTHON

Pour créer un ensemble, nous écrivons les éléments entre une paire d'accolades et séparons
joyeux par des virgules. Si nous voulons créer un ensemble vide, nous utiliserons la fonction
set(), et non une paire de accolades vides ({}) comme vous pourriez le penser. Un peu plus ade-
l'ante te montrera qu'une paire de clés vides crée un dictionnaire vide.

Nous allons voir un petit exemple de campeur, qui va sûrement te laisser les choses.
beaucoup plus claires avec les ensembles de données :

#!/usr/bin/python

#‐*‐codage: utf‐8‐*‐

Nous allons contrôler quels objets

Nous ajoutons dans notre sac à dos pour une randonnée.

Nous créons un ensemble vide

(just to try, for this example we wouldn't need it)

set()

'inicializamos' le dataset : nous incluons plusieurs objets

en_mochila = {"bocadillo", "agua", "linterna", "agua", "cuerda"}

si nous imprimons la valeur du dataset, nous verrons que l'"eau"

ne apparaît pas dupliquée - nous savons déjà que nous apportons de l'eau

dans le sac à dos

# Resultado: {'cuerda', 'linterna', 'bocadillo', 'agua'}

Nous notons que nous mettons un couteau

en_mochila.ajouter("couteau")

imprimer(en_mochila)

# Resultado: {'agua', 'cuchillo', 'bocadillo', 'cuerda', 'linterna'

}

pour vérifier si un élément est dans l'ensemble

# nous utilisons 'in'

bocadillo

23
STRUCTURES DE DONNÉES EN PYTHON

"cerillas" pas dans en_mochila # True

nous pouvons également retirer un élément de l'ensemble

en_mochila.jeter("cuerda")

imprimer(en_mochila)

# Resultado: {'agua', 'cuchillo', 'bocadillo', 'linterna'}

Dans l'utilisation des jeux de données, nous disposons également des opérations habituelles
entre ensembles : union, différence, intersection, etc...

a = {1, 2, 3, 5, 8}

b = {1, 2, 4, 8, 16}

union de a et b

[Link](b)

# Resultado: {1, 2, 3, 4, 5, 8, 16}

# Nous pouvons aussi le faire ainsi : éléments qui sont dans a ou dans b

a|b

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

intersection de a et b

[Link](b)

{1, 2, 8}

# nous pouvons aussi le faire ainsi : éléments qui sont dans a et dans b

a&b

{1, 2, 8}

différence entre a et b

[Link]érence(b)

{3, 5}

24
 STRUCTURES DE DONNÉES EN PYTHON

# nous pouvons aussi le faire ainsi : éléments qui sont dans a mais pas
sont dans

a‐b

{3, 5}

d'autre part la différence symétrique ou exclusive entre a et b

[Link]érence_symétrique(b)

{3, 4, 5, 16}

# nous pouvons aussi le faire ainsi : des éléments qui sont exclusivement

bien en a ou bien en b (mais pas les deux)

a^b

{3, 4, 5, 16}

s = {1, 2}

# s est un sous-ensemble de a ?

s.est_un_sous_ensemble(a)

Vrai

ou dit autrement : tous les éléments de s sont dans a

s <= a

Vrai

¿A est un sur ensemble de S ?

a.est_un_sur_ensemble(s)

# Resultado: True

# ou bien... : a inclut tous les éléments qui sont dans s

a >= s

Vrai

25
STRUCTURES DE DONNÉES EN PYTHON

Comme vous pouvez le constater, le nombre d'actions que nous pouvons réaliser auxdag-
tasetes brutaux, ce qui les positionne comme une façon géniale d'effectuer des tâches
mathématiques avec des ensembles de données.

[Link]

Un autre type de donnée utile inclus nativement dans Python est le dictionnaire. Les
Les dictionnaires se trouvent parfois dans d'autres langages comme "mémoires associatives".
tivas" ou "arrangements associatifs". Contrairement aux séquences, qui sont indexées
par l'intermédiaire d'une plage numérique, les dictionnaires sont indexés avec des clés, qui peuvent-
il voit n'importe quel type immuable ; les chaînes et les nombres peuvent toujours être
clés. Les tuples peuvent être utilisés comme clés s'ils ne contiennent que des chaînes,
nombres ou tuples ; si un tuple contient tout objet mutable directement ou indirectement
rectement, il ne peut pas être utilisé comme clé. Vous ne pouvez pas utiliser des listes comme clés.

puisque les listes peuvent être modifiées en utilisant l'assignation par index, assignation
par section, ou des méthodes comme append() et extend(). En résumé, une clé
doit être formé d'un élément immuable, ne peut pas changer une
a été ajouté avec sa valeur au dictionnaire.

Le meilleur est de penser à un dictionnaire comme à un ensemble non ordonné de paires.

valeur, avec l'exigence que les clés soient uniques (dans
un dictionnaire en particulier). Placer une liste de paires clé:valeur séparées
clé:valeurs initiales au dictionnaire; cette
c'est aussi la façon dont les dictionnaires sont présentés dans la sortie. Pour ac-
céder à une valeur, nous utilisons des crochets comme nous le ferions dans une liste ou une
tupla, sauf qu'en ce cas nous indiquons la clé et non un indice de position.

Une paire de clés vides crée un dictionnaire

vide{}.

26
 STRUCTURES DE DONNÉES EN PYTHON

Les opérations principales sur un dictionnaire sont :

Sauvegarder une valeur avec une clé.

Extraire cette valeur donnée la clé.

Il est également possible de supprimer une paire clé:valeur. Si vous utilisez une clé qui existe déjà.
est en cours d'utilisation pour stocker une valeur, la valeur qui était associée à cette clé a été
perdre. Extraire une valeur en utilisant une clé inexistante nous donnera un joli
message d'erreur, comme il se doit.

Voyons cela plus facilement avec quelques exemples simples :

extension = {'juan': 4098, 'pedro': 4139}

extension['guido'] = 4127

imprimer(extension)

# Resultado: {'pedro': 4139, 'juan': 4098, 'guido': 4127}

extension['juan']

# Resultado: 4098

supprimer l'extension['pedro']

extension['ivan'] = 4127

imprimer(extension)

# Resultado: {'juan': 4098, 'ivan': 4127, 'guido': 4127}

imprimer([Link]és())

# Resultado: dict_keys(['juan', 'guido', 'ivan'])

print('guido' in extension)

Vrai

27
STRUCTURES DE DONNÉES EN PYTHON

La méthode keys() d'un dictionnaire renvoie une liste de toutes les clés dans
utilisation de ce dictionnaire, mais dans un ordre arbitraire (si tu veux qu'il soit ordonné, sim-
implémentez utilisez la méthode sort() sur la liste des clés). Pour vérifier si une
la clé est dans le dictionnaire, utilise le mot cléin.

Nous avons différentes façons d'itérer sur un dictionnaire. Nous pouvons itérer sur les
clés du dictionnaire de manière directe. Nous pouvons également itérer sur les paires-
jas (clé, valeur).

Nous pouvons itérer directement sur les clés d'un dictionnaire

libreta_telefonos = {'Carlos': 5556033, 'Javier': 5556051,

'Daniel': 5556056}

pour nombre dans libreta_telefonos :

print(nombre, "=", libreta_telefonos[nombre]) # Résultat :

5556033

5556051

5556056

Nous pouvons itérer sur les paires clé, valeur

pour nombre, téléphone dans livre_de_télé[Link]() :

print(nombre, "=", telefono) # Résultat :

5556033

5556051

5556056

# Et si ce que nous voulons, c'est itérer uniquement sur les valeurs,

nous pouvons le faire comme ça

pour telefono dans libreta_telefonos.valeurs() :

print(telefono) # Résultat :

# 5556033

# 5556051

# 5556056

28
 STRUCTURES DE DONNÉES EN PYTHON

Le constructeur dict() crée un dictionnaire directement à partir de listes de paires.

clé-valorguardados comme des tuples. Lorsque les paires suivent un motif, elles
pouvez-vous spécifier de manière compacte la liste des paires clé: valeur par compren-
sion.

dict([('pedro', 4139), ('guido', 4127), ('juan', 4098)])

# Salida: {'pedro': 4139, 'juan': 4098, 'guido': 4127}

dict([(x, x**2) for x in (2, 4, 6)])

# Salida: {2: 4, 4: 16, 6: 36}

Vous pouvez continuer à explorer par vous-même d'autres utilisations des dictionnaires, comme
dépôt d'information, par exemple… Te rappellent-ils la sémantique de la langue-
je JSON?

1.4.DÉFINITIONS PAR COMPRÉHENSION

Maintenant que nous avons vu les principaux types composés de données qu'offre
Python de forma nativa, nous allons vous présenter un type d'expressions très utiles
et puissants pour créer et travailler avec ces structures de données.

Les définitions par compréhension sont une manière très concise et simple de générer.
rar des collections de données de manière automatique. Elles sont principalement utilisées avec des listes,
mais ils sont applicables à tous les types de composés en faisant les ajustements nécessaires.

In English, list comprehensions usually appear, and in Spanish, some

Les auteurs appellent ces expressions listes par compréhension ou également
compréhension des listes. Tous font référence au même concept.

Les définitions par compréhension sont des expressions qui permettent de construire une
nouvelle collection la définissant à partir d'une autre collection de départ, une expre-
sion génératrice des nouveaux éléments à inclure et un prédicat ou une condition.

29
STRUCTURES DE DONNÉES EN PYTHON

Écrit comme ça, peut-être que ça te semble complexe, mais tu verras que c'est très simple. Le
Il vaut mieux commencer par un cas d'exemple. Imaginez que nous voulons sauvegarder
Dans une liste, la table de multiplication de 7. Une façon de le faire avec ce que tu as.
appris jusqu'à présent serait par le biais d'une boucle.

Nous préparons une liste vide pour y mettre les résultats.

tabla_del_7 = []

# Nous itérons les nombres de 0 à 9

pour x dans la plage(0, 10):

nous ajoutons à la liste la valeur suivante

table de multiplication de 7

tabla_del_7.append(7 * x)

imprimer(tableau_du_7)

# Resultado: [0, 7, 14, 21, 28, 35, 42, 49, 56, 63]

Nous avons dû créer une variable avec une liste vide au début, et ensuite
utiliser une boucle for pour itérer sur les valeurs de 0 à 9 et les modifier à chaque
je passe la liste, pour ajouter chaque valeur de la table de multiplication.

Ce n'est pas que ce soit un code très compliqué ni long. Mais Python nous permet
faire cela de manière plus simple et plus brève.

tabla_del_7 = [ 7 * x for x in range(0, 10) ]

imprimer(tableau_du_7)

Et nous obtenons le même résultat... n'est-ce pas génial ? Continuons un peu.

plus...

30
 STRUCTURES DE DONNÉES EN PYTHON

Le domaine des valeurs d'entrée peut être n'importe quel objet ou expression itérable.

lista_frutas = ["pera", "manzana", "ciruela", "cereza"]

[[Link]() for fruta in lista_frutas if [Link]("c")]

# Resultado: ['CIRUELA', 'CEREZA']

Nous pouvons également combiner deux ou plusieurs clauses avec leurs domaines de en-
trada pour construire la collection.

[ x * y pour x dans (1, 2, 3) pour y dans (4, 5, 6) ]

# Resultado: [4, 5, 6, 8, 10, 12, 12, 15, 18]

Cette expression est évaluée pour toutes les combinaisons de valeurs de x et y. Si cela
tu penses, c'est comme si tu avais deux boucles for imbriquées. Nous allons inclure dans chaque
élément généré les valeurs dexey, ainsi ça sera plus clair.

[ (x, y, x * y) pour x dans (1, 2, 3) pour y dans (4, 5, 6) ]

resultado

[(1, 4, 4),

(1, 5, 5)

(1, 6, 6)

(2, 4, 8)

(2, 5, 10)

(2, 6, 12)

(3, 4, 12)

(3, 5, 15)

(3, 6, 18)]

31
STRUCTURES DE DONNÉES EN PYTHON

Dans ce cas, nous avons fait en sorte que l'expression génératrice renvoie un tuple avec
les valeurs dex, yy dex * y. Toute expression peut être utilisée, tout le
complexe qu'il soit nécessaire, tant qu'il renvoie un élément valide.

Si au lieu de générer une liste, nous voulons construire un ensemble, seulement

nous devons remplacer les crochets par des accolades.

{ x pour x dans range(10) si x % 2 != 0 }

{1, 3, 5, 7, 9}

Si nous voulons une tuple, il ne suffira pas d'utiliser des parenthèses. Nous devrons
que utiliser le constructortuple()

tuple( x pour x dans range(5) )

# Resultado: (0, 1, 2, 3, 4)

Et pour construire un dictionnaire en utilisant le mécanisme de compréhension, ade-

plus d'utiliser des accolades au lieu des crochets, l'expression génératrice de-
devra avoir le format clé:valeur

ici la clé est le facteur multiplicateur,

et la valeur est le résultat de la multiplication

dict_tabla_7 = { num : 7 * num for num in range(0, 10) }

imprimer(dict_tabla_7[3])

# Resultado: 21

32
 STRUCTURES DE DONNÉES EN PYTHON

Comme défi, nous te proposons d'essayer tous les exemp-

plos que tu vois dans chaque unité et les tester dans ton interprète
pret de Python pour voir le résultat. Certains déjà les
vous avez sur le campus pour pouvoir les télécharger dans le
section « Exemples de l'unité ». D'autres vous devrez
copiez-les et essayez-les vous-même. Voir le code des autres
c'est une bonne manière d'apprendre et de comprendre
expliquant le fonctionnement d'une langue.

1.5.GÉNÉRATEURS

Un couple de paragraphes plus haut, nous venons de voir que si nous voulons créer un
pladefinie par compréhension ne suffit pas à remplacer les crochets par des parenthèses
thèse, nous devons utiliser le constructeur tuple().

Eh bien, que obtenons-nous alors si nous utilisons seulement les parenthèses ? En

dans ce cas, au lieu de renvoyer immédiatement une séquence complète avec
tous les valeurs, Python nous renvoie un type spécial d'objet que l'on appelle
namosgénérateur.

Disons qu'un générateur est un objet qui s'occupe de faire les calculs
pour générer les valeurs résultantes une à une selon nos besoins et les
allons demander, en itérant sur la collection d'entrée, au lieu de construire
la séquence entière d'un coup.

L'utilité de ce mécanisme est qu'il permet d'économiser de l'espace mémoire (ne pas
nous devons stocker tous les résultats) et il s'avère plus efficace dans les ca-
sos dans lesquels nous n'avons pas besoin de la séquence résultat complète en une seule fois, par
exemple, si nous voulons itérer les valeurs dans une boucle.

# nous construisons un générateur pour la table de multiplication de 7

gen_tabla_7 = ( 7 * x pour x dans range(0, 10) )

# si nous essayons d'imprimer le contenu de 'gen_tabla_7'...

imprimer(gen_tabla_7)

33
STRUCTURES DE DONNÉES EN PYTHON

# nous ne verrons pas une séquence, mais un message

# indiquant que c'est un objet de type 'générateur'

<générateur objet <genexpr> à 0x7f9d9438dca8>

nous allons l'utiliser dans une boucle

pour v dans gen_tabla_7 :

imprimer(v)

Le générateur renvoie une nouvelle valeur

chaque fois qu'on le demande

jusqu'à ce qu'il épuise tous les valeurs de son domaine d'entrée

# La sortie serait la suivante :

14

21

28

35

42

49

56

63

34
 STRUCTURES DE DONNÉES EN PYTHON

Si nous avons un générateur et que nous voulons extraire ses valeurs dans une liste, nous pouvons
utiliser le constructeur list.

si nous avons un générateur

(3 * x pour x dans range(0, 10))

# Et nous voulons transférer tous ses éléments dans une liste, nous utilisons 'list'

list(gen_tabla_3)

imprimer(lista_tabla_3)

# Resultado: [0, 3, 6, 9, 12, 15, 18, 21, 24, 27]

Remarquez que si vous essayez de réutiliser le générateur après avoir itéré

tous ses éléments (dans une boucle ou en les extrayant dans une liste), tu n'obtiendras rien
Oui, sauf éventuellement une erreur. Le générateur est vide, il est épuisé.
do y a plus de valeurs à retourner. Nous l'avons "brûlé".

autre_liste_table_3 = liste(gen_table_3)

# vous obtenez une liste vide []

print(otra_lista_tabla_3)

# Resultado: []

Profite de tout ce que les générateurs te offrent pour élargir tes compétences comme
programmeur Python.

35
 STRUCTURES DE DONNÉES EN PYTHON

QU'AS-TU APPRIS?

Nous avons vu tout au long de l'unité qu'il existe 3 structures de données impor-
tantes, sans compter les ensembles (datasets) et les chaînes (strings) :

Tuples.

Listes.

Dictionnaires.

Chacune de ces structures a ses propres caractéristiques. Par exemple,

dernières listes immuables, les listes peuvent être modifiées avec leurs propres mé-
Tous les dictionnaires disposent d'une structure clé:valeur qui nous offre
il y a beaucoup de possibilités.

Ce qui est commun à toutes elles, c'est que nous pouvons sélectionner des éléments indépendamment.

dents de chacune d'elles pour travailler. C'est sa flexibilité au moment de traiter les
données qui contiennent ce qui confère de la polyvalence à ces structures.

Pratiquez avec les exercices que nous vous proposons et les exemples de l'unité pour
comprendre parfaitement son fonctionnement.

37
 STRUCTURES DE DONNÉES EN PYTHON

BIBLIOGRAPHIE

Initiation au Big Data avec Python. MasterD.

39