Parlons de Collections, un module intégré de Python

1. Description du module

collections est un module intégré de Python. Le module dit intégré signifie que le module est empaqueté dans Python et peut être utilisé directement sans installation.

• collections contient des conteneurs spéciaux, offrant une alternative aux conteneurs intégrés de Python, tels que : list, dict, set, tuple.
• namedtuple : Peut créer un tuple contenant un nom.
• deque : Un conteneur similaire à une liste, qui peut rapidement ajouter et supprimer des éléments en tête et en queue de la file d'attente.
• OrderedDict : Une sous-classe de dict qui peut mémoriser l'ordre dans lequel les éléments sont ajoutés.
• defaultdict : Une sous-classe de dict qui peut appeler des fonctions qui fournissent des valeurs par défaut.
• Counter : Une sous-classe de dict qui compte les objets hachables.

2. Code pratique

(1) Fonction testNamedTuple

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

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 nomméetuple pour définir facilement un type de données, qui a l'invariance du tuple et peut être référencé en fonction d'attributs, ce qui le rend très pratique à utiliser.

Dans cet exemple, nous utilisons une coordonnée tridimensionnelle x, y, z pour définir un objet tuple. Il y a trois éléments d'objet, puis la valeur correspondante peut être référencée via la valeur de coordonnée.

from collections import namedtuple
from collections import deque
from collections import defaultdict
from collections import OrderedDict
from collections import Counter
def testNamedTuple():
vector=namedtuple('vector',['x','y','z'])
flag=vector(3,4,5)
print(type(flag))
print(isinstance(flag,vector))
print(isinstance(flag,tuple)) #通过这里的判定我们就可以知晓它是元组类型
print(flag.x,flag.y,flag.z)

(2) fonction testDeque

deque est une implémentation généralisée de la pile et de la file d'attente, et deque est l'abréviation de "file d'attente double-end".

deque prend en charge l'insertion et la suppression d'éléments sécurisés pour les threads et économes en mémoire aux deux extrémités de deque avec des performances d'environ O(1). Bien que list prenne également en charge des opérations similaires, elle optimise principalement les opérations de longueur fixe, facilitant ainsi la pop. (0) et insert(0,v) (qui modifieront la position et la taille des données) ont une complexité temporelle de O(n).

Dans les structures de données, nous savons que les files d'attente et les piles 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 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é de l'insertion et de la suppression est très faible.

Deque est une structure de liste doublement chaînée pour une mise en œuvre efficace des opérations d'insertion et de suppression. Elle est très adaptée à la mise en œuvre de structures de données telles que des files d'attente et des piles.

def testDeque():
list1=[x*x for x in range(101)]
delist=deque(list1) #对列表进行了一次再处理，让list1列表变成了双向链表结构
delist.append(1000)#将x添加到deque的右侧
delist.appendleft(2000)#将x添加到deque的左侧
delist.pop(1000)#移除和返回deque中最右侧的元素，如果没有元素，将会报出IndexError；
delist.popleft()#移除和返回deque中最左侧的元素，如果没有元素，将会报出IndexError；
delist.count(1)#返回deque中元素等于1的个数
delist.remove(10000)#移除第一次出现的value，如果没有找到，报出ValueError；
delist.reverse()#反转deque中的元素，并返回None；
list2=[1,3,4,5]
delist.extend(list2)#将可迭代变量iterable中的元素添加至deque的右侧
delist.extendleft(list2)#将变量iterable中的元素添加至deque的左侧，往左侧添加序列的顺序与可迭代变量iterable中的元素相反
delist.maxlen()#只读的属性，deque的最大长度，如果无解，就返回None
delist.rotate(1)#从右侧反转n步，如果n为负数，则从左侧反转
delist.clear()#将deque中的元素全部删除，最后长度为0；

(3) fonction testDefaultdict

defaultdict est une sous-classe du type de données intégré dict. Ses fonctions de base sont les mêmes que dict, sauf qu'elle remplace une méthode __missing__(key) et ajoute une variable objet inscriptible default_factory.

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

def testDefaultdict():
dict1= defaultdict(lambda: 'default') #Key不存在时，返回一个默认值，就可以用default，defaultdict的其他行为跟dict是完全一样的
dict1["k1"]="v1"
print(dict1["k2"])
list2= [('yellow',11),('blue',2),('yellow',3),('blue',4),('red',5),('red',10)]
dict1 = defaultdict(list)#使用list作为default_factory，很容易将一个key-value的序列转换为一个关于list的词典
for k,v in list2:
dict1[k].append(v)
print(dict1)

(4) fonction testOrderedDict

OrderedDict est similaire à un dictionnaire normal, sauf qu'il se souvient de l'ordre dans lequel les éléments ont été insérés, et lors d'une itération sur un dictionnaire ordonné, les éléments renvoyés sont l'ordre dans lequel ils ont été ajoutés pour la première fois . De cette façon, dict est un dictionnaire ordonné.

Lors de l'utilisation de dict, les touches ne sont pas ordonnées. Lors d’une itération sur un 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.

def testOrderedDict():
dict1=dict([('aaa', 111), ('ddd',444),('bbb', 222), ('ccc', 333)])
print(dict1)
dict2 = OrderedDict([('ddd',444),('aaa', 111), ('bbb', 222), ('ccc', 333)])#OrderedDict的key会按照插入的顺序排列，不是key本身排序
print(dict2)
dict3 = {"banana": 33, "apple": 222, "pear": 1, "orange": 4444}
# dict sorted by key
dict4=OrderedDict(sorted(dict3.items(), key=lambda t: t[0]))
print("dict4",dict4)
# dict sorted by value
dict5=OrderedDict(sorted(dict3.items(), key=lambda t: t[1]))
print("dict5",dict5)
# dict sorted by length of key string
dict6 = OrderedDict(sorted(dict3.items(), key=lambda t: len(t[0])))
print("dict6",dict6)
print(dict6['apple'])

(5) fonction testCounter

def testCounter():
'''counter可以支持方便、快速的计数'''
str1="abcdefgabcedergeghdjlkabcdefe" #将可迭代的字符串初始化counter
str2=Counter(str1)
print(str2) #从输出的内容来看，Counter实际上也是dict的一个子类
for k,v in str2.items():
print(k,v)
dict3 = {"banana": 33, "apple": 222, "pear": 1, "orange": 4444,"apples":2}#将dict初始化counter
dict4=Counter(dict3)
print(dict4)
print(dict4["test"])#Counter对象类似于字典，如果某个项缺失，会返回0，而不是报出KeyError；
dict5=Counter(high=9,age=33,money=-1)#将args初始化counter
print(dict5)
#elements返回一个迭代器，每个元素重复的次数为它的数目，顺序是任意的顺序，如果一个元素的数目少于1，那么elements()就会忽略它；
list1=list(dict5.elements())
print(list1)
#most_common返回一个列表，包含counter中n个最大数目的元素
#，如果忽略n或者为None，most_common()将会返回counter中的所有元素，元素有着相同数目的将会以任意顺序排列；
str1 = "abcdefgabcedergeghdjlkabcdefe"
list1=Counter(str1).most_common(3)
print(list1)
if __name__ == '__main__':
# testNamedTuple()
# testCounter()
testDefaultdict()
# testDeque()
# testOrderedDict()

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!