Tutoriel d'utilisation des collections de bibliothèques standard Python

Introduction

Python nous fournit 4 structures de données de base : liste, tuple, dict, défini, mais lorsqu'il s'agit de grandes quantités de données, ces quatre structures de données sont évidemment trop simples. Par exemple, l'efficacité d'insertion d'une liste en tant que liste chaînée unidirectionnelle sera relativement faible dans certaines situations. Un dicté ordonné. Nous devons donc actuellement utiliser le package collections fourni par la bibliothèque standard Python. Il fournit plusieurs classes de collection utiles. La maîtrise de ces classes de collection nous permettra non seulement de rendre le code que nous écrivons plus pythonique, mais également d'améliorer son efficacité. nos programmes fonctionnent.

Utilisation de defaultdict

defaultdict (default_factory) ajoute default_factory au-dessus du dict ordinaire (dictionnaire), de sorte que la clé (clé) correspondante soit automatiquement générée lorsque il n'existe pas Type de valeur (valeur), le paramètre default_factory peut être spécifié sous forme de liste, Set, int et autres types légaux.

exemple1

>>> from collections import defaultdict
>>> s = [('red', 1), ('blue', 2), ('red', 3), ('blue', 4), ('red', 1), ('blue', 4)]

Nous avons maintenant un ensemble de listes (listes) comme celle ci-dessus Bien que nous ayons 6 ensembles de données, après une observation attentive, nous. n'ont en réalité que deux ensembles de données. Il existe plusieurs couleurs, mais chaque couleur correspond à plusieurs valeurs. Nous voulons maintenant convertir cette liste en un dict (dictionnaire). La clé (clé) de ce dict correspond à une couleur, et la valeur (valeur) du dict est définie dans une liste pour stocker plusieurs valeurs correspondantes. à la couleur. Nous pouvons utiliser defaultdict(list) pour résoudre ce problème.

# 
d可以看作一个dict(字典)，dict的value是一个list(列表)
>>> d = defaultdict(list)
>>> for k, v in s:
...     d[k].append(v)
...
>>> d
defaultdict(<class &#39;list&#39;>, {&#39;blue&#39;: [2, 4, 4], &#39;red&#39;: [1, 3, 1]})

exemple2

Il y a quelques imperfections dans l'exemple ci-dessus, telles que {'bleu' : [2, 4, 4], 'rouge' : [1, 3, 1]} Dans ce defaultdict, la couleur bleue contient deux 4 et la couleur rouge contient deux 1. Cependant, nous ne voulons pas contenir d'éléments en double. Pour le moment, nous pouvons envisager d'utiliser defaultdict(set) pour résoudre ce problème. La différence entre set (collection) et list (list) est que les mêmes éléments ne sont pas autorisés à exister dans set.

>>> d = defaultdict(set)
>>> for k, v in s:
...     d[k].add(v)
...
>>> d
defaultdict(<class &#39;set&#39;>, {&#39;blue&#39;: {2, 4}, &#39;red&#39;: {1, 3}})

exemple3

>>> s = 
'hello world'

En utilisant le formulaire defaultdict(int) nous comptons le nombre d'occurrences de chaque caractère dans une chaîne.

>>> d = defaultdict(int)
>>> for k in s:
...     d[k] += 1
...
>>> d
defaultdict(<class &#39;int&#39;>, {&#39;o&#39;: 2, &#39;h&#39;: 1, &#39;w&#39;: 1, &#39;l&#39;: 3, &#39; &#39;: 1, &#39;d&#39;: 1, &#39;e&#39;: 1, &#39;r&#39;: 1})

Utilisation de OrderedDict

Nous savons que le dict par défaut (dictionnaire) n'est pas ordonné, mais dans certains cas, nous devons conserver l'ordre du dict , pour le moment, vous pouvez utiliser OrderedDict, qui est une sous-classe de dict, mais conserve le type ordonné de dict sur la base de dict. Voyons comment l'utiliser.

exemple1

>>> from collections import OrderedDict
# 
无序的dict
>>> d = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}

Il s'agit d'un dict (dictionnaire) non ordonné. Nous pouvons maintenant utiliser OrderedDict pour ordonner ce dict.

# 
将d按照key来排序
>>> OrderedDict(sorted(d.items(), key=lambda t: t[0]))
OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])
# 
将d按照value来排序
>>> OrderedDict(sorted(d.items(), key=lambda t: t[1]))
OrderedDict([('pear', 1), ('orange', 2), ('banana', 3), ('apple', 4)])
# 
将d按照key的长度来排序
>>> OrderedDict(sorted(d.items(), key=lambda t: len(t[0])))
OrderedDict([('pear', 1), ('apple', 4), ('orange', 2), ('banana', 3)])

exemple2

L'utilisation de la méthode popitem(last=True) nous permet de supprimer les clés du dict dans LIFO (premier entré, dernier out) order -value, c'est-à-dire supprimer la dernière paire clé-valeur insérée. Si last=False, supprimez la valeur-clé dans le dict selon FIFO (premier entré, premier sorti).

>>> d = {'banana': 3, 'apple': 4, 'pear': 1, 'orange': 2}
# 
将d按照key来排序
>>> d = OrderedDict(sorted(d.items(), key=lambda t: t[0]))
>>> d
OrderedDict([('apple', 4), ('banana', 3), ('orange', 2), ('pear', 1)])
# 
使用popitem()方法来移除最后一个key-value对
>>> d.popitem()
('pear', 1)
# 
使用popitem(last=False)来移除第一个key-value对
>>> d.popitem(last=False)
('apple', 4)

exemple3

Utilisez move_to_end(key, last=True) pour modifier l'ordre clé-valeur de l'objet OrderedDict ordonné. Grâce à cette méthode, nous pouvons insérer n'importe quelle valeur-clé dans l'objet OrderedDict ordonné au début ou à la fin du dictionnaire.

>>> d = OrderedDict.fromkeys('abcde')
>>> d
OrderedDict([('a', None), ('b', None), ('c', None), ('d', None), ('e', None)])
# 
将key为b的key-value对移动到dict的最后
>>> d.move_to_end('b')
>>> d
OrderedDict([('a', None), ('c', None), ('d', None), ('e', None), ('b', None)])
>>> ''.join(d.keys())
'acdeb'
# 
将key为b的key-value对移动到dict的最前面
>>> d.move_to_end('b', last=False)
>>> ''.join(d.keys())
'bacde'

Utilisation de deque

L'avantage du stockage de données par liste est que la recherche d'éléments par index sera rapide, mais l'insertion et la suppression d'éléments sont très lent Oui, car il s’agit d’une structure de données de liste à chaînage unique. Deque est une liste bidirectionnelle pour une implémentation efficace des opérations d'insertion et de suppression. Elle convient aux files d'attente et aux piles et est thread-safe.

List fournit uniquement les méthodes append et pop pour insérer/supprimer des éléments à la fin de la liste, mais deque ajoute appendleft/popleft pour nous permettre d'insérer/supprimer efficacement des éléments au début de l'élément. De plus, la complexité de l'algorithme d'utilisation de deque pour ajouter (ajouter) ou afficher (pop) des éléments aux deux extrémités de la file d'attente est d'environ O (1), mais pour l'opération de l'objet liste visant à modifier la longueur de la liste et la position des données, par exemple exemple La complexité des opérations pop(0) et insert(0, v) est aussi élevée que O(n). Puisque le fonctionnement de deque est fondamentalement le même que celui de list, il ne sera pas répété ici.

Utilisation de ChainMap

ChainMap est utilisé pour combiner plusieurs dicts (dictionnaires) dans une liste (juste une métaphore), qui peut être comprise comme la fusion de plusieurs dictionnaires Mais c’est différent de la mise à jour et plus efficace.

>>> from collections import ChainMap
>>> a = {'a': 'A', 'c': 'C'}
>>> b = {'b': 'B', 'c': 'D'}
>>> m = ChainMap(a, b)
# 
构造一个ChainMap对象
>>> m
ChainMap({'a': 'A', 'c': 'C'}, {'b': 'B', 'c': 'D'})
>>> m['a']
'A'
>>> m['b']
'B'
# 
将m变成一个list
>>> m.maps
[{'a': 'A', 'c': 'C'}, {'b': 'B', 'c': 'D'}]

# 
更新a中的值也会对ChainMap对象造成影响
>>> a['c'] = 'E'
>>> m['c']
'E'
# 
从m复制一个ChainMap对象，更新这个复制的对象并不会对m造成影响
>>> m2 = m.new_child()
>>> m2['c'] = 'f'
>>> m['c']
'E'
>>> a['c']
'E'
>>> m2.parents
ChainMap({'a': 'A', 'c': 'C'}, {'b': 'B', 'c': 'D'})

Utilisation de Counter

exemple1

Counter est également une sous-classe de dict . Il s'agit d'un conteneur non ordonné et peut être considéré comme un compteur, utilisé pour compter le nombre d'éléments liés.

>>> from collections import Counter
>>> cnt = Counter()
# 
统计列表中元素出现的个数
>>> for word in ['red', 'blue', 'red', 'green', 'blue', 'blue']:
...  cnt[word] += 1
...
>>> cnt
Counter({'blue': 3, 'red': 2, 'green': 1})
# 
统计字符串中元素出现的个数
>>> cnt = Counter()
>>> for ch in 'hello':
...     cnt[ch] = cnt[ch] + 1
...
>>> cnt
Counter({'l': 2, 'o': 1, 'h': 1, 'e': 1})

exemple2

Utilisez la méthode elements() pour renvoyer un itérateur (itérateur) en fonction du nombre d'occurrences des éléments. Les éléments sont renvoyés dans. n'importe quel ordre. Si les éléments Si le nombre est inférieur à 1, il sera ignoré.

>>> c = Counter(a=4, b=2, c=0, d=-2)
>>> c
Counter({'a': 4, 'b': 2, 'c': 0, 'd': -2})
>>> c.elements()
<itertools.chain object at 0x7fb0a069ccf8>
>>> next(c)
&#39;a&#39;
# 
排序
>>> sorted(c.elements())
[&#39;a&#39;, &#39;a&#39;, &#39;a&#39;, &#39;a&#39;, &#39;b&#39;, &#39;b&#39;]

Utilisez most_common(n) pour renvoyer une liste contenant les n premiers éléments qui apparaissent dans l'objet Counter.

>>> c = Counter('abracadabra')
>>> c
Counter({'a': 5, 'b': 2, 'r': 2, 'd': 1, 'c': 1})
>>> c.most_common(3)
[('a', 5), ('b', 2), ('r', 2)]

Utilisation du tuple nommé

Utilisez le tuple nommé(typename, field_names) pour nommer les éléments du tuple afin de rendre le programme plus lisible.

>>> from collections import namedtuple
>>> Point = namedtuple('PointExtension', ['x', 'y'])
>>> p = Point(1, 2)
>>> p.__class__.__name__
'PointExtension'
>>> p.x
1
>>> p.y
2

Ce qui précède est le contenu du didacticiel d'utilisation des collections de la bibliothèque standard Python. Pour plus de contenu connexe, veuillez faire attention au site Web PHP chinois (www.php.cn) !