Introduction aux collections de modules intégrés Python

Introduction aux collections de modules intégrés de Python

Collections est un module de collection intégré à Python qui fournit de nombreuses fonctions utiles Classe Collection.

1.namedtuple

Python fournit de nombreux types de base très utiles, tels que le tuple de type immuable, que nous pouvons facilement utiliser pour représenter un vecteur binaire.

Apprentissage recommandé : Tutoriel vidéo Python

>>> v = (2,3)

Nous avons constaté que bien que (2,3) représente deux coordonnées d'un vecteur, s'il n'y a pas d'explication supplémentaire, et il Il est difficile de voir directement que ce tuple est utilisé pour représenter une coordonnée.

Définir une classe pour cela est un gros problème à l'heure actuelle, nommé tuple est pratique.

>>> from collections import namedtuple
>>> Vector = namedtuple('Vector', ['x', 'y'])
>>> v = Vector(2,3)
>>> v.x
2
>>> v.y
3

namedtuple est une fonction qui crée un objet tuple personnalisé et spécifie le nombre d'éléments du tuple, et peut utiliser des attributs au lieu d'index pour référencer un élément du tuple.

De cette façon, nous pouvons utiliser Nametuple pour définir facilement un type de données. Il a l'invariance d'un tuple et peut être référencé en fonction d'attributs.

Nous pouvons vérifier le type de l'objet Vector créé.

>>> type(v)
<class &#39;__main__.Vector&#39;>
>>> isinstance(v, Vector)
True
>>> isinstance(v, tuple)
True

De même, si vous souhaitez utiliser des coordonnées et un rayon pour représenter un cercle, vous pouvez également utiliser la définition du tuple nommé :

>>> Circle = namedtuple('Circle', ['x', 'y', 'r'])
# namedtuple('名称', [‘属性列表’])

2, deque

dans les données Dans la structure, nous savons que la file d'attente et la pile sont deux types de données très importants, l'un est premier entré, premier sorti et l'autre est dernier entré, premier sorti. En python, lorsque vous utilisez une liste pour stocker des données, l'accès aux éléments par index est très rapide, mais l'insertion et la suppression d'éléments sont très lentes, car la liste est un stockage linéaire, et lorsque la quantité de données est importante, l'efficacité d'insertion et de suppression est très faible.

Deque est une structure de liste doublement chaînée pour une implémentation efficace des opérations d'insertion et de suppression. Elle est très adaptée à l'implémentation de structures de données telles que des files d'attente et des piles. En plus d'implémenter append() et pop() de list,

>>> from collections import deque
>>> deq = deque([1, 2, 3])
>>> deq.append(4)
>>> deq
deque([1, 2, 3, 4])
>>> deq.appendleft(5)
>>> deq
deque([5, 1, 2, 3, 4])
>>> deq.pop()
4
>>> deq.popleft()
5
>>> deq
deque([1, 2, 3])

deque prend également en charge appendleft() et popleft(), afin que vous puissiez ajouter ou supprimer des éléments dans l'en-tête de manière très efficace.

3. defaultdict

Lors de l'utilisation du type de dictionnaire dict, si la clé référencée n'existe pas, KeyError sera levée. Si vous souhaitez qu'une valeur par défaut soit renvoyée lorsque la clé n'existe pas, vous pouvez utiliser defaultdict.

>>> from collections import defaultdict
>>> dd = defaultdict(lambda: 'defaultvalue')
>>> dd['key1'] = 'a'
>>> dd['key1']
'a'
>>> dd['key2'] # key2未定义，返回默认值
'defaultvalue'

Notez que la valeur par défaut est renvoyée en appelant la fonction et que la fonction est transmise lors de la création de l'objet defaultdict.

À l'exception du renvoi de la valeur par défaut lorsque la clé n'existe pas, les autres comportements de defaultdict sont exactement les mêmes que ceux de dict.

4. OrderedDict

Lors de l'utilisation de dict, les touches ne sont pas ordonnées. Lors d'une itération sur dict, nous ne pouvons pas déterminer l'ordre des clés.

Mais si vous souhaitez conserver l'ordre des clés, vous pouvez utiliser OrderedDict.

>>> from collections import OrderedDict
>>> d = dict([('a', 1), ('b', 2), ('c', 3)])
>>> d # dict的Key是无序的
{'a': 1, 'c': 3, 'b': 2}
>>> od = OrderedDict([('a', 1), ('b', 2), ('c', 3)])
>>> od # OrderedDict的Key是有序的
OrderedDict([('a', 1), ('b', 2), ('c', 3)])

Notez que les clés de OrderedDict seront disposées dans l'ordre d'insertion, pas la clé elle-même

>>> od = OrderedDict()
>>> od['z'] = 1
>>> od['y'] = 2
>>> od['x'] = 3
>>> list(od.keys()) # 按照插入的Key的顺序返回
['z', 'y', 'x']

OrderedDict peut implémenter un dict FIFO (premier entré, premier sorti). La capacité dépasse la limite, supprimez d'abord la clé ajoutée la plus ancienne.

from collections import OrderedDict
class LastUpdatedOrderedDict(OrderedDict):
    def __init__(self, capacity):
        super(LastUpdatedOrderedDict, self).__init__()
        self._capacity = capacity
    def __setitem__(self, key, value):
        containsKey = 1 if key in self else 0
        if len(self) - containsKey >= self._capacity:
            last = self.popitem(last=False)
            print('remove:', last)
        if containsKey:
            del self[key]
            print('set:', (key, value))
        else:
            print('add:', (key, value))
        OrderedDict.__setitem__(self, key, value)

5. ChainMap

ChainMap peut enchaîner un ensemble de dicts pour former un dict logique. ChainMap lui-même est également un dict, mais lors de la recherche, il recherchera les dicts internes dans l'ordre.

Quel est le meilleur moment pour utiliser ChainMap ? Par exemple : les applications doivent souvent transmettre des paramètres. Les paramètres peuvent être transmis via la ligne de commande, via des variables d'environnement et peuvent également avoir des paramètres par défaut. Nous pouvons utiliser ChainMap pour implémenter la recherche de priorité des paramètres, c'est-à-dire vérifier d'abord les paramètres de ligne de commande, s'ils ne sont pas transmis, puis vérifier les variables d'environnement, sinon utiliser les paramètres par défaut.

Le code suivant montre comment trouver les deux paramètres user et color.

from collections import ChainMap
import os, argparse
# 构造缺省参数:
defaults = {
    'color': 'red',
    'user': 'guest'
}
# 构造命令行参数:
parser = argparse.ArgumentParser()
parser.add_argument('-u', '--user')
parser.add_argument('-c', '--color')
namespace = parser.parse_args()
command_line_args = { k: v for k, v in vars(namespace).items() if v }
# 组合成ChainMap:
combined = ChainMap(command_line_args, os.environ, defaults)
# 打印参数:
print('color=%s' % combined['color'])
print('user=%s' % combined['user'])

Lorsqu'il n'y a pas de paramètres, imprimez les paramètres par défaut :

$ python3 use_chainmap.py 
color=red
user=guest

Lorsque les paramètres de ligne de commande sont transmis, les paramètres de ligne de commande sont utilisés en premier :

$ python3 use_chainmap.py -u bob
color=red
user=bob

En même temps, la ligne de commande est passée dans Paramètres et variables d'environnement, les paramètres de ligne de commande ont une priorité plus élevée :

$ user=admin color=green python3 use_chainmap.py -u bob
color=green
user=bob

Compteur

Le compteur est un simple compteur. , par exemple, compter le nombre d'occurrences de caractères. Count:

from collections import Counter
>>> s = 'abbcccdddd'
>>> Counter(s)
Counter({'d': 4, 'c': 3, 'b': 2, 'a': 1})

Counter est en fait une sous-classe de dict.

7. Résumé

Le module de collections fournit des classes de collection utiles, qui peuvent être sélectionnées selon les besoins.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!