Présentation de la bibliothèque d'utilitaires Python
bisect gère les listes ordonnées
Le module bisect contient deux fonctions principales, bisect et insort. Les deux fonctions utilisent des algorithmes de recherche binaire pour trouver et insérer des éléments dans une séquence ordonnée.
# BEGIN BISECT_DEMO
import bisect
import sys
HAYSTACK = [1, 4, 5, 6, 8, 12, 15, 20, 21, 23, 23, 26, 29, 30]
NEEDLES = [0, 1, 2, 5, 8, 10, 22, 23, 29, 30, 31]
ROW_FMT = '{0:2d} @ {1:2d} {2}{0:<2d}'
def demo(bisect_fn):
for needle in reversed(NEEDLES):
position = bisect_fn(HAYSTACK, needle) # <1>
offset = position * ' |' # <2>
print(ROW_FMT.format(needle, position, offset)) # <3>
if __name__ == '__main__':
if sys.argv[-1] == 'left': # <4>
bisect_fn = bisect.bisect_left
else:
bisect_fn = bisect.bisect
print('DEMO:', bisect_fn.__name__) # <5>
print('haystack ->', ' '.join('%2d' % n for n in HAYSTACK))
demo(bisect_fn)
# END BISECT_DEMO
'''
DEMO: bisect
haystack -> 1 4 5 6 8 12 15 20 21 23 23 26 29 30
31 @ 14 | | | | | | | | | | | | | |31
30 @ 14 | | | | | | | | | | | | | |30
29 @ 13 | | | | | | | | | | | | |29
23 @ 11 | | | | | | | | | | |23
22 @ 9 | | | | | | | | |22
10 @ 5 | | | | |10
8 @ 5 | | | | |8
5 @ 3 | | |5
2 @ 1 |2
1 @ 1 |1
0 @ 0 0
'''import bisect
import random
SIZE = 7
random.seed(1729)
my_list = []
for i in range(SIZE):
new_item = random.randrange(SIZE*2)
bisect.insort(my_list, new_item)
print('%2d ->' % new_item, my_list)
'''
10 -> [10]
0 -> [0, 10]
6 -> [0, 6, 10]
8 -> [0, 6, 8, 10]
7 -> [0, 6, 7, 8, 10]
2 -> [0, 2, 6, 7, 8, 10]
10 -> [0, 2, 6, 7, 8, 10, 10]
'''Parmi elles, les fonctions bisect et insort (essentiellement bisect_left et insort_left) ont bisect_right et insort_right similaires. La différence entre elles est que s'il y a des éléments avec le même résultat de calcul dans la liste, le nouvel élément sera inséré à gauche ou à droite de ces éléments.
structure de stockage numérique efficace de la baie
Bien que la liste soit flexible et simple, il s'agit d'une structure de conteneur (ce n'est pas une valeur spécifique, mais un pointeur vers l'élément correspondant. Bien que cela la rende plus largement utilisée, elle nécessite un accès et un stockage plus importants) , Donc, si le contenu stocké n'est qu'une valeur, vous pouvez utiliser un tableau, qui n'est pas un objet flottant, mais une traduction automatique du nombre. Dans le même temps, le tableau prend en charge presque toutes les opérations de liste.
from array import array
from random import random
floats = array('d', (random() for i in range(10**7)))
print(floats[-1])
# 0.7030774022684948
fp = open("floats.bin", 'wb')
floats.tofile(fp)
fp.close()
floats = array('d')
fp = open("floats.bin", 'wb')
floats2.fromfile(fp, 10**7)
fp.close()
print(floats2[-1])
# 0.7030774022684948
print(floats == floats2)
# TrueÉtant donné que le tableau autorise uniquement le stockage de certains types de valeurs, le type de données à stocker doit être spécifié lors de sa création. Les noms de types spécifiques sont indiqués dans le tableau ci-dessous.
vue mémoire vue mémoire
memoryview permet aux utilisateurs de manipuler différentes tranches du même tableau sans copier le contenu.
import array
numbers = array.array('h', [-2, -1, 0, 1, 2])
memv = memoryview(numbers)
print(len(memv)) # 5
print(memv[0]) # -2
memv_oct = memv.cast('B')
print(memv_oct.tolist()) # [254, 255, 255, 255, 0, 0, 1, 0, 2, 0]
memv_oct[5] = 4
print(numbers)
# array('h', [-2, -1, 1024, 1, 2])Un autre alias memv de numéros de données a été créé, et la conversion du type de données a été réalisée plus tard via memv.cast. En même temps, si memv est modifié, les données originales seront également modifiées.
deque
La classe collections.deque est une structure de données thread-safe qui peut rapidement ajouter et supprimer des éléments des deux côtés. Et si vous souhaitez qu'un type de données stocke les "éléments récemment utilisés", deque est également un bon choix. En effet, lors de la création d'une file d'attente bidirectionnelle, vous pouvez spécifier la taille de la file d'attente. Si la file d'attente est pleine, vous pouvez également supprimer les éléments expirés dans le sens inverse, puis ajouter de nouveaux éléments à la fin.
from collections import deque
dq = deque(range(10), maxlen=10)
print(dq) # deque([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)
dq.rotate(3)
print(dq) # deque([7, 8, 9, 0, 1, 2, 3, 4, 5, 6], maxlen=10)
dq.rotate(-4)
print(dq) # deque([1, 2, 3, 4, 5, 6, 7, 8, 9, 0], maxlen=10)
dq.appendleft(-1)
print(dq) # deque([-1, 1, 2, 3, 4, 5, 6, 7, 8, 9], maxlen=10)
dq.extend([11, 22, 33])
print(dq) # deque([3, 4, 5, 6, 7, 8, 9, 11, 22, 33], maxlen=10)
dq.extendleft([10, 20, 30, 40])
print(dq) # deque([40, 30, 20, 10, 3, 4, 5, 6, 7, 8], maxlen=10)deque prend en charge presque toutes les opérations de liste, mais deque ne prend pas en charge les opérations pop (p).
queue
Il fournit des classes de synchronisation (thread-safe) Queue, LifoQueue et PriorityQueue. Différents threads peuvent utiliser ces classes de données pour échanger des informations. Les méthodes de construction de ces trois classes ont un paramètre optionnel maxsize, qui accepte un entier positif comme entrée pour limiter la taille de la file d'attente. Mais une fois pleines, ces classes ne jetteront pas d'anciens éléments pour faire de la place. A l'inverse, si la file d'attente est pleine, elle sera verrouillée, sachant qu'un autre thread a supprimé un élément pour faire de la place. Cette fonctionnalité rend ces classes très appropriées pour contrôler le nombre de threads actifs.
Le package multitraitement implémente sa propre file d'attente, similaire à queue.Queue et conçue pour la communication inter-processus. Il existe également un type spécial multiprocessing.JoinableQueue, qui peut rendre la gestion des tâches plus pratique.
Le package asyncio comprend Queue, LifoQueue, PriorityQueue et JoinableQueue. Ces classes offrent une commodité particulière pour la gestion des tâches dans la programmation asynchrone.