Structure de données Python3

Dans ce chapitre, nous introduisons principalement la structure de données Python sur la base des points de connaissances appris précédemment.

Liste

Les listes en Python sont variables. C'est la caractéristique la plus importante qui les distingue des chaînes et des tuples. En une phrase, les listes peuvent être modifiées, et les chaînes et les tuples ne le peuvent pas. .

Voici les méthodes pour les listes en Python :

L'exemple suivant montre la plupart des méthodes de la liste :

>>> a = [66.25, 333, 333, 1, 1234.5]
>>> print(a.count(333), a.count(66.25), a.count('x'))
2 1 0
>>> a.insert(2, -1)
>>> a.append(333)
>>> a
[66.25, 333, -1, 333, 1, 1234.5, 333]
>>> a.index(333)
1
>>> a.remove(333)
>>> a
[66.25, -1, 333, 1, 1234.5, 333]
>>> a.reverse()
>>> a
[333, 1234.5, 1, 333, -1, 66.25]
>>> a.sort()
>>> a
[-1, 1, 66.25, 333, 333, 1234.5]

Remarque : Les méthodes qui modifient la liste telles que l'insertion, la suppression ou le tri n'ont aucune valeur de retour.

Utiliser la liste comme pile

La méthode list facilite l'utilisation de la liste comme pile. La pile est une structure de données spécifique. Le premier élément saisi est le dernier. un à libérer (dernier entré, premier sorti). Utilisez la méthode append() pour ajouter un élément en haut de la pile. Un élément peut être libéré du haut de la pile à l'aide de la méthode pop() sans spécifier d'index. Par exemple :

>>> stack = [3, 4, 5]
>>> stack.append(6)
>>> stack.append(7)
>>> stack
[3, 4, 5, 6, 7]
>>> stack.pop()
7
>>> stack
[3, 4, 5, 6]
>>> stack.pop()
6
>>> stack.pop()
5
>>> stack
[3, 4]

Utiliser la liste comme file d'attente

Vous pouvez également utiliser la liste comme file d'attente, mais le premier élément ajouté à la file d'attente est le premier à être retiré ; mais si les listes ne sont pas efficaces à cet effet. Ajouter ou extraire des éléments de la fin de la liste est rapide, mais insérer ou extraire des éléments du début de la liste n'est pas rapide (car tous les autres éléments doivent être déplacés un par un).

>>> from collections import deque
>>> queue = deque(["Eric", "John", "Michael"])
>>> queue.append("Terry")           # Terry arrives
>>> queue.append("Graham")          # Graham arrives
>>> queue.popleft()                 # The first to arrive now leaves
'Eric'
>>> queue.popleft()                 # The second to arrive now leaves
'John'
>>> queue                           # Remaining queue in order of arrival
deque(['Michael', 'Terry', 'Graham'])

Compréhensions de listes

Les compréhensions de listes fournissent un moyen simple de créer des listes à partir de séquences. Généralement, les applications appliquent certaines opérations à chaque élément d'une séquence et utilisent le résultat comme élément pour générer une nouvelle liste ou créer une sous-séquence basée sur certains critères.

Chaque compréhension de liste commence par for suivi d'une expression, puis de zéro ou plusieurs clauses for ou if. Le résultat renvoyé est une liste générée à partir des contextes for et if suivants en fonction de l'expression. Si vous souhaitez que l'expression dérive un tuple, vous devez utiliser des parenthèses.

Ici, nous multiplions chaque valeur de la liste par trois pour obtenir une nouvelle liste :

>>> vec = [2, 4, 6]
>>> [3*x for x in vec]
[6, 12, 18]

Maintenant, nous jouons un petit tour :

>>> [[x, x**2] for x in vec]
[[2, 4], [4, 16], [6, 36]]

Ici, nous multiplions chaque valeur de la séquence Appeler une méthode un élément à la fois :

>>> freshfruit = ['  banana', '  loganberry ', 'passion fruit  ']
>>> [weapon.strip() for weapon in freshfruit]
['banana', 'loganberry', 'passion fruit']

On peut utiliser les clauses if comme filtres :

>>> [3*x for x in vec if x > 3]
[12, 18]
>>> [3*x for x in vec if x < 2]
[]

Voici quelques démonstrations de boucles et d'autres techniques :

>>> vec1 = [2, 4, 6]
>>> vec2 = [4, 3, -9]
>>> [x*y for x in vec1 for y in vec2]
[8, 6, -18, 16, 12, -36, 24, 18, -54]
>>> [x+y for x in vec1 for y in vec2]
[6, 5, -7, 8, 7, -5, 10, 9, -3]
>>> [vec1[i]*vec2[i] for i in range(len(vec1))]
[8, 12, -54]

Liste Les compréhensions peuvent utiliser des expressions complexes ou des fonctions imbriquées :

>>> [str(round(355/113, i)) for i in range(1, 6)]
['3.1', '3.14', '3.142', '3.1416', '3.14159']

Analyse de listes imbriquées

Les listes Python peuvent également être imbriquées.

L'exemple suivant montre une liste matricielle 3X4 :

>>> matrix = [
...     [1, 2, 3, 4],
...     [5, 6, 7, 8],
...     [9, 10, 11, 12],
... ]

L'exemple suivant convertit une liste matricielle 3X4 en une liste 4X3 :

>>> [[row[i] for row in matrix] for i in range(4)]
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

L'exemple suivant peut également être implémenté en utilisant la méthode suivante :

>>> transposed = []
>>> for i in range(4):
...     transposed.append([row[i] for row in matrix])
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

Une autre méthode d'implémentation :

>>> transposed = []
>>> for i in range(4):
...     # the following 3 lines implement the nested listcomp
...     transposed_row = []
...     for row in matrix:
...         transposed_row.append(row[i])
...     transposed.append(transposed_row)
...
>>> transposed
[[1, 5, 9], [2, 6, 10], [3, 7, 11], [4, 8, 12]]

instruction del

Utilisez l'instruction del pour supprimer un élément d'une liste par index plutôt que par valeur. Ceci est différent de l'utilisation de pop() pour renvoyer une valeur. Vous pouvez utiliser l'instruction del pour supprimer une coupe d'une liste ou pour effacer la liste entière (la méthode que nous avons introduite précédemment consistait à attribuer une liste vide à la coupe). Par exemple :

>>> a = [-1, 1, 66.25, 333, 333, 1234.5]
>>> del a[0]
>>> a
[1, 66.25, 333, 333, 1234.5]
>>> del a[2:4]
>>> a
[1, 66.25, 1234.5]
>>> del a[:]
>>> a
[]

Vous pouvez également utiliser del pour supprimer des variables d'entité :

>>> del a

Tuples et séquences

Un tuple est constitué de plusieurs valeurs séparées par des virgules, pour exemple :

>>> t = 12345, 54321, 'hello!'
>>> t[0]
12345
>>> t
(12345, 54321, 'hello!')
>>> # Tuples may be nested:
... u = t, (1, 2, 3, 4, 5)
>>> u
((12345, 54321, 'hello!'), (1, 2, 3, 4, 5))

Comme vous pouvez le voir, les tuples sont toujours affichés avec des parenthèses pour faciliter l'expression correcte des structures imbriquées. Il peut ou non être saisi avec ou sans parenthèses, mais les parenthèses sont généralement requises (si le tuple fait partie d'une expression plus grande).

Ensemble

Un ensemble est un ensemble non ordonné d'éléments non répétitifs. Les fonctionnalités de base incluent le test des relations et l'élimination des éléments en double.

Les collections peuvent être créées à l'aide d'accolades ({}). Remarque : Si vous souhaitez créer une collection vide, vous devez utiliser set() au lieu de {} ; ce dernier crée un dictionnaire vide, une structure de données que nous présenterons dans la section suivante.

Voici une démonstration simple :

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # show that duplicates have been removed
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # fast membership testing
True
>>> 'crabgrass' in basket
False

>>> # Demonstrate set operations on unique letters from two words
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # unique letters in a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # letters in a but not in b
{'r', 'd', 'b'}
>>> a | b                              # letters in either a or b
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # letters in both a and b
{'a', 'c'}
>>> a ^ b                              # letters in a or b but not both
{'r', 'd', 'b', 'm', 'z', 'l'}>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # show that duplicates have been removed
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # fast membership testing
True
>>> 'crabgrass' in basket
False

>>> # Demonstrate set operations on unique letters from two words
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # unique letters in a
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # letters in a but not in b
{'r', 'd', 'b'}
>>> a | b                              # letters in either a or b
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # letters in both a and b
{'a', 'c'}
>>> a ^ b                              # letters in a or b but not both
{'r', 'd', 'b', 'm', 'z', 'l'}

Les collections prennent également en charge les compréhensions :

>>> a = {x for x in 'abracadabra' if x not in 'abc'}
>>> a
{'r', 'd'}

Dictionnaire

Une autre introduction Python très utile Le type de données construit est un dictionnaire. Contrairement aux séquences

, qui sont indexées par des entiers continus, les dictionnaires sont indexés par des mots-clés, qui peuvent être de n'importe quel type immuable, généralement des chaînes ou des valeurs numériques.

La meilleure façon de comprendre un dictionnaire est de le considérer comme une collection non ordonnée de paires clé => valeur. Au sein d’un même dictionnaire, les mots-clés doivent être différents les uns des autres.

Une paire d'accolades crée un dictionnaire vide : {}.

Voici un exemple simple d'utilisation d'un dictionnaire :

>>> tel = {'jack': 4098, 'sape': 4139}
>>> tel['guido'] = 4127
>>> tel
{'sape': 4139, 'guido': 4127, 'jack': 4098}
>>> tel['jack']
4098
>>> del tel['sape']
>>> tel['irv'] = 4127
>>> tel
{'guido': 4127, 'irv': 4127, 'jack': 4098}
>>> list(tel.keys())
['irv', 'guido', 'jack']
>>> sorted(tel.keys())
['guido', 'irv', 'jack']
>>> 'guido' in tel
True
>>> 'jack' not in tel
False

Le constructeur dict() construit un dictionnaire directement à partir d'une liste de tuples de paires clé-valeur. Les compréhensions de liste spécifient des paires clé-valeur spécifiques s'il existe un modèle fixe :

>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}

De plus, les compréhensions de dictionnaire peuvent être utilisées pour créer des dictionnaires d'expressions de clés et de valeurs arbitraires :

>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}

if mot-clé Juste un simple chaîne, il est parfois plus pratique d'utiliser des paramètres de mots-clés pour spécifier des paires clé-valeur :

>>> dict(sape=4139, guido=4127, jack=4098)
{'sape': 4139, 'jack': 4098, 'guido': 4127}

Conseils de traversée

Lors du parcours dans un dictionnaire, les mots-clés et les valeurs correspondantes peuvent Utilisez la méthode items() pour les interpréter simultanément :

>>> knights = {'gallahad': 'the pure', 'robin': 'the brave'}
>>> for k, v in knights.items():
...     print(k, v)
...
gallahad the pure
robin the brave

Lors du parcours dans la séquence, la position de l'index et la valeur correspondante peuvent être obtenues simultanément à l'aide de la fonction enumerate() :

>>> for i, v in enumerate(['tic', 'tac', 'toe']):
...     print(i, v)
...
0 tic
1 tac
2 toe

Traverse two ou plus en même temps La séquence peut être combinée en utilisant zip() :

>>> questions = ['name', 'quest', 'favorite color']
>>> answers = ['lancelot', 'the holy grail', 'blue']
>>> for q, a in zip(questions, answers):
...     print('What is your {0}?  It is {1}.'.format(q, a))
...
What is your name?  It is lancelot.
What is your quest?  It is the holy grail.
What is your favorite color?  It is blue.

Pour parcourir une séquence en sens inverse, spécifiez d'abord la séquence, puis appelez la fonction reversesd() :

>>> for i in reversed(range(1, 10, 2)):
...     print(i)
...
9
7
5
3
1

Pour parcourir une séquence dans l'ordre, Utilisez la fonction sorted() pour renvoyer une séquence triée sans modifier la valeur d'origine :

>>> basket = ['apple', 'orange', 'apple', 'pear', 'orange', 'banana']
>>> for f in sorted(set(basket)):
...     print(f)
...
apple
banana
orange
pear

Voir la documentation

• Liste Python3

• Tuple Python3

• Dictionnaire Python3