structure de données python3

Ce chapitre est principalement associée à la connaissance que nous avons appris plus tôt pour introduire des structures de données Python.

liste

liste Python est variable, ce qui est la caractéristique la plus importante distingue des chaînes et tuples, à savoir une phrase: La liste peut être modifiée, tandis que les chaînes et les tuples ne peuvent pas.

Voici une liste de Python:

L'exemple suivant illustre plus de la liste des méthodes:

>>> 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: Comme pour insérer, supprimer ou modifier la méthode trier la liste, etc. aucune valeur de retour.

Utilisez la liste comme une pile

Le procédé de fabrication d'une liste de listes peut facilement être utilisé comme une pile, la pile comme une structure de données spécifique, le premier à entrer dans le dernier élément à être libéré (LIFO). Utilisez la méthode append () peut ajouter un élément au sommet de la pile. Sans un indice explicite de la pop () peut récupérer un élément à partir du haut de la pile. 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]

Utilisez la liste comme une file d'attente

La liste peut également être utilisé comme une file d'attente, la file d'attente est le premier à rejoindre les éléments, le premier sorti, mais prenez cette liste que le but est pas efficace. Ajouter à la fin des éléments de la liste ou pop-up de vitesse, cependant, pour insérer ou éjecter de la vitesse de la tête est pas rapide (parce que tous les autres éléments doivent se déplacer l'un par un) dans la liste.

>>> 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'])

Liste compréhensions

Liste compréhensions fournissent un moyen concis pour créer des listes de la séquence. Certaines applications sont généralement appliquées à chaque élément d'une séquence d'opérations, avec le résultat que l'on obtient que les éléments pour générer une nouvelle liste, ou de créer des séquences déterminées en fonction des conditions de détermination.

Chaque compréhension de la liste sont après pour une expression, puis zéro ou plus pour ou si les clauses. Le résultat est une liste générée à partir du contexte ultérieur et si, conformément à l'expression. Si vous voulez la formule d'un tuple, vous devez utiliser des parenthèses.

Ici, nous allons énumérer chaque numéro par trois, pour obtenir une nouvelle liste:

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

Maintenant, nous jouons petits trucs:

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

Ici, on invoque une méthode individuellement pour chaque élément d'une séquence:

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

Nous pouvons utiliser la clause if comme un filtre:

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

Voici quelques démos sur le cyclisme et d'autres compétences:

>>> 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 des compréhensions peuvent utiliser des expressions complexes ou fonctions imbriquées:

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

liste imbriquée compréhension

les listes Python peuvent aussi être imbriquées.

L'exemple suivant montre la liste de matrice de 3X4:

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

L'exemple suivant répertorie 3X4 matrice 4X3 liste de conversion:

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

Les exemples suivants peuvent également utiliser les méthodes suivantes:

>>> 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:

>>> 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]]

del déclaration

Vous pouvez utiliser l'instruction del par index au lieu de la valeur à supprimer un élément d'une liste. Ceci est l'utilisation de la pop () retourne une valeur différente. Vous pouvez utiliser l'instruction del pour supprimer une coupe de la liste, ou effacer la liste entière (notre ancienne méthode de présentation est attribué une coupe à la liste vide). 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 supprimer la variable d'instance avec del:

>>> del a

Tuples et séquences

numéro de Tuple de valeurs séparées par des virgules consiste, par 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 le voyez, sur la sortie tuples sont alway entre parenthèses, afin d'exprimer correctement la structure imbriquée. Il peut y avoir pas de crochets ou lors de l'entrée, mais les supports sont généralement requis (si le tuple fait partie d'une expression plus large).

ensemble

Une collection est une collection non ordonnée d'éléments uniques. Caractéristiques de base comprennent des tests et d'éliminer les doublons.

Vous pouvez créer un ensemble d'accolades ({}). Remarque: Si vous voulez créer un ensemble vide, vous devez utiliser le set () au lieu de {}, ce qui crée un dictionnaire vide, la section suivante, nous allons introduire cette structure de données.

Ce qui suit est une démonstration simple:

>>> basket = {'apple', 'orange', 'apple', 'pear', 'orange', 'banana'}
>>> print(basket)                      # 删除重复的
{'orange', 'banana', 'pear', 'apple'}
>>> 'orange' in basket                 # 检测成员
True
>>> 'crabgrass' in basket
False

>>> # 以下演示了两个集合的操作
...
>>> a = set('abracadabra')
>>> b = set('alacazam')
>>> a                                  # a 中唯一的字母
{'a', 'r', 'b', 'c', 'd'}
>>> a - b                              # 在 a 中的字母，但不在 b 中
{'r', 'd', 'b'}
>>> a | b                              # 在 a 或 b 中的字母
{'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
>>> a & b                              # 在 a 和 b 中都有的字母
{'a', 'c'}
>>> a ^ b                              # 在 a 或 b 中的字母，但不同时在 a 和 b 中
{'r', 'd', 'b', 'm', 'z', 'l'}

Collecte supporte également le calcul de la formule:

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

dictionnaire

Un autre type de données utiles intégré dans Python est le dictionnaire.

Une séquence continue d'index entier, et cette différence est, dictionnaire indexé mot-clé des mots-clés peuvent être tout type immuable, habituellement avec une chaîne ou numérique.

La meilleure façon de le comprendre comme un dictionnaire sont des paires clé => valeur désordonnées. Dans le même dictionnaire, les clés doivent être différents les uns des autres.

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

Ceci est un exemple simple de l'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

Constructor dict () pour construire le dictionnaire directement à partir de la liste des clés-tuple. Si vous avez un motif fixe, compréhensions spécifier particulier une paires clé-valeur:

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

En outre, le dictionnaire peut être utilisé pour créer une expression pour tirer un dictionnaire de clés et de valeurs:

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

Si le mot clé est simplement une chaîne de paires clé-valeur en utilisant des arguments de mots clés parfois plus commode de spécifier:

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

techniques de Traversal

Lorsque vous traversez dans les dictionnaires, la valeur de clé correspondant et peut utiliser les éléments () Méthode d'interprétation simultanée sur:

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

En traversant dans la séquence, l'indice de position et la valeur correspondante peuvent être utilisés enumerate () fonction de réception aussi:

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

En traversant deux ou plusieurs séquences, vous pouvez utiliser le zip () en combinaison:

>>> 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 traverser une séquence inverse, spécifiez d'abord la séquence, puis appelez reversesd () fonction:

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

Traversant une séquence selon l'ordre, l'utilisation de la fonction triée () retourne une séquence triée, ne modifie pas la valeur d'origine:

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

Consultez la documentation

• liste python3
• python3 tuple
• dictionnaire python3