10 choses surprenantes que vous pouvez faire avec le module de collections de Python

Introduction

La bibliothèque standard de Python est vaste, offrant une large gamme de modules pour effectuer efficacement les tâches courantes.

Parmi ceux-ci, le collections Le module est un exemple remarquable, qui fournit des types de données de conteneurs spécialisés qui peuvent servir d’alternatives aux conteneurs intégrés à usage général de Python comme dict, list, setet tuple. Alors que de nombreux développeurs connaissent certains de ses composants, le module héberge une variété de fonctionnalités qui sont étonnamment utiles et peuvent simplifier le code, améliorer la lisibilité et augmenter les performances.

Ce tutoriel explore dix applications pratiques – et peut-être surprenantes – du Python collections module.

1. Compter les objets hashable sans effort avec compteur

Une tâche courante dans presque tous les projets d’analyse des données consiste à compter les occurrences d’éléments dans une séquence. Le collections.Counter La classe est conçue spécifiquement pour cela. C’est une sous-classe de dictionnaire où les éléments sont stockés sous forme de clés et leurs dénombrements sont stockés comme des valeurs.

from collections import Counter

# Count the frequency of words in a list
words = ('galaxy', 'nebula', 'asteroid', 'comet', 'gravitas', 'galaxy', 'stardust', 'quasar', 'galaxy', 'comet')
word_counts = Counter(words)

# Find the two most common words
most_common = word_counts.most_common(2)

# Output results
print(f"Word counts: {word_counts}")
print(f"Most common words: {most_common}")

Sortir:

Word counts: Counter({'galaxy': 3, 'comet': 2, 'nebula': 1, 'asteroid': 1, 'gravitas': 1, 'stardust': 1, 'quasar': 1})
Most common words: (('galaxy', 3), ('comet', 2))

2. Création de classes légères avec namedtuple

Lorsque vous avez besoin d’une classe simple juste pour regrouper les données, sans méthodes, un namedtuple est une option utile et économe en mémoire. Il vous permet de créer des objets de type tuple qui ont des champs accessibles par la recherche d’attribut ainsi que d’être indexables et itérables. Cela rend votre code plus lisible que l’utilisation d’un tuple standard.

from collections import namedtuple

# Define a Book namedtuple
# Fields: title, author, year_published, isbn
Book = namedtuple('Book', ('title', 'author', 'year_published', 'isbn'))

# Create an instance of the Book
my_book = Book(
    title="The Hitchhiker"s Guide to the Galaxy',
    author="Douglas Adams",
    year_published=1979,
    isbn='978-0345391803'
)

print(f"Book Title: {my_book.title}")
print(f"Author: {my_book.author}")
print(f"Year Published: {my_book.year_published}")
print(f"ISBN: {my_book.isbn}")

print("n--- Accessing by index ---")
print(f"Title (by index): {my_book(0)}")
print(f"Author (by index): {my_book(1)}")
print(f"Year Published (by index): {my_book(2)}")
print(f"ISBN (by index): {my_book(3)}")

Sortir:

Accessing book data by field name
Title (by field name): The Hitchhiker's Guide to the Galaxy
Author (by field name): Douglas Adams
Year Published (by field name): 1979
ISBN (by field name): 978-0345391803

Accessing book data by index
Title (by index): The Hitchhiker's Guide to the Galaxy
Author (by index): Douglas Adams
Year Published (by index): 1979
ISBN (by index): 978-0345391803

Vous pouvez penser à un namedtuple Comme similaire à une structure C mutable, ou en tant que classe de données sans méthodes. Ils ont définitivement leurs utilisations.

3. Gérer les clés du dictionnaire manquantes defaultdict

Une frustration commune lorsque vous travaillez avec les dictionnaires est le KeyError Cela se produit lorsque vous essayez d’accéder à une clé qui n’existe pas. Le collections.defaultdict est la solution parfaite. C’est une sous-classe de dict Cela appelle une fonction d’usine pour fournir une valeur par défaut pour les clés manquantes. Ceci est particulièrement utile pour le regroupement des éléments.

from collections import defaultdict

# Group a list of tuples by the first element
scores_by_round = (('contestantA', 8), ('contestantB', 7), ('contestantC', 5),
                   ('contestantA', 7), ('contestantB', 7), ('contestantC', 6),
                   ('contestantA', 9), ('contestantB', 5), ('contestantC', 4))
grouped_scores = defaultdict(list)

for key, value in scores_by_round:
    grouped_scores(key).append(value)

print(f"Grouped scores: {grouped_scores}")

Sortir:

Grouped scores: defaultdict(, {'contestantA': (8, 7, 9), 'contestantB': (7, 7, 5), 'contestantC': (5, 6, 4)})

4. Implémentation de files d’attente et de piles rapides avec deque

Les listes Python peuvent être utilisées comme piles et files d’attente, même si elles ne sont pas optimisées pour ces opérations. L’ajout et la surface de la fin d’une liste sont rapides, mais faire de même depuis le début est lent car tous les autres éléments doivent être déplacés. Le collections.deque (la file d’attente à double extrémité) est conçue pour les ajoues rapides et les pops des deux extrémités.

Tout d’abord, voici un exemple de file d’attente en utilisant deque.

from collections import deque

# Create a queue
d = deque((1, 2, 3))
print(f"Original queue: {d}")

# Add to the right
d.append(4)
print("Adding item to queue: 4")
print(f"New queue: {d}")

# Remove from the left
print(f"Popping queue item (from left): {d.popleft()}")  

# Output final queue
print(f"Final queue: {d}")

& nbsp

Sortir:

Original queue: deque((1, 2, 3))
Adding item to queue: 4
New queue: deque((1, 2, 3, 4))
Popping queue item (from left): 1
Final queue: deque((2, 3, 4))

Et maintenant utilisons deque Pour créer une pile:

from collections import deque

# Create a stack
d = deque((1, 2, 3))
print(f"Original stack: {d}")

# Add to the right
d.append(5)
print("Adding item to stack: 5")
print(f"New stack: {d}")

# Remove from the right
print(f"Popping stack item (from right): {d.pop()}")

# Output final stack
print(f"Final stack: {d}")

Sortir:

Original stack: deque((1, 2, 3))
Adding item to stack: 5
New stack: deque((1, 2, 3, 5))
Popping stack item (from right): 5
Final stack: deque((1, 2, 3))

5. Se souvenir de l’ordre d’insertion avec OrderedDict

Avant Python 3.7, les dictionnaires standard n’ont pas préservé l’ordre dans lequel les éléments ont été insérés. Pour résoudre ceci, le collections.OrderedDict a été utilisé. Alors que les dicts standard maintiennent désormais l’ordre d’insertion, OrderedDict a toujours des fonctionnalités uniques, comme le move_to_end() Méthode, qui est utile pour les tâches comme la création d’un cache simple.

from collections import OrderedDict

# An OrderedDict remembers the order of insertion
od = OrderedDict()
od('a') = 1
od('b') = 2
od('c') = 3

print(f"Start order: {list(od.keys())}")

# Move 'a' to the end
od.move_to_end('a')
print(f"Final order: {list(od.keys())}")

Sortir:

Start order: ('a', 'b', 'c')
Final order: ('b', 'c', 'a')

6. Combinant plusieurs dictionnaires avec ChainMap

Le collections.ChainMap La classe fournit un moyen de relier plusieurs dictionnaires ensemble afin qu’ils puissent être traités comme une seule unité. C’est souvent beaucoup plus rapide que de créer un nouveau dictionnaire et d’exécuter plusieurs update() appels. Les recherches recherchent les mappages sous-jacents un par un jusqu’à ce qu’une clé soit trouvée.

Créons une chaîne ChainMap nommée Chain et interrogez-la pour les clés.

from collections import ChainMap

# Create dictionaries
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 3, 'c': 4}

# Create a ChainMap
chain = ChainMap(dict1, dict2)

# Print dictionaries
print(f"dict1: {dict1}")
print(f"dict2: {dict2}")

# Query ChainMap for keys and return values
print("nQuerying ChainMap for keys")
print(f"a: {chain('a')}")
print(f"c: {chain('c')}")
print(f"b: {chain('b')}")

Sortir:

dict1: {'a': 1, 'b': 2}
dict2: {'b': 3, 'c': 4}

Querying keys for values
a: 1
c: 4
b: 2

Notez que, dans le scénario ci-dessus, «B» se trouve en premier dans dict1le premier dictionnaire en chainet c’est donc la valeur associée à cette clé qui est renvoyée.

7. Garder une histoire limitée avec Deque maxlen

UN deque peut être créé avec une longueur maximale fixe en utilisant le maxlen argument. Si plus d’éléments sont ajoutés que la longueur maximale, les éléments de l’extrémité opposée sont automatiquement jetés. C’est parfait pour garder une histoire des N derniers éléments.

from collections import deque

# Keep a history of the last 3 items
history = deque(maxlen=3)
history.append("cd ~")
history.append("ls -l")
history.append("pwd")
print(f"Start history: {history}")

# Add a new item, push out the left-most item
history.append("mkdir data")
print(f"Final history: {history}")

Sortir:

Start history: deque(('cd ~', 'ls -l', 'pwd'), maxlen=3)
Final history: deque(('ls -l', 'pwd', 'mkdir data'), maxlen=3)

8. Créer facilement des dictionnaires imbriqués avec defaultdict

S’appuyer sur defaultdictvous pouvez créer facilement des dictionnaires imbriqués ou en forme d’arbres. En fournissant un lambda fonction qui en renvoie un autre defaultdictvous pouvez créer des dictionnaires de dictionnaires à la volée.

from collections import defaultdict
import json

# A function that returns a defaultdict
def tree():
    return defaultdict(tree)

# Create a nested dictionary
nested_dict = tree()
nested_dict('users')('user1')('name') = 'Felix'
nested_dict('users')('user1')('email') = 'user1@example.com'
nested_dict('users')('user1')('phone') = '515-KL5-5555'

# Output formatted JSON to console
print(json.dumps(nested_dict, indent=2))

Sortir:

{
  "users": {
    "user1": {
      "name": "Felix",
      "email": "user1@example.com",
      "phone": "515-KL5-5555"
    }
  }
}

9. effectuer des opérations arithmétiques sur Counters

Flash d’information: vous pouvez effectuer des opérations arithmétiques, comme l’addition, la soustraction, l’intersection et l’union, sur Counter objets. Il s’agit d’un outil puissant pour comparer et combiner le nombre de fréquences à partir de différentes sources.

from collections import Counter

c1 = Counter(a=4, b=2, c=0, d=-2)
c2 = Counter(a=1, b=2, c=3, d=4)

# Add counters -> adds counts for common keys
print(f"c1 + c2 = {c1 + c2}")

# Subtract counters -> keeps only positive counts
print(f"c1 - c2 = {c1 - c2}")

# Intersection -> takes minimum of counts
print(f"c1 & c2 = {c1 & c2}")

# Union -> takes maximum of counts
print(f"c1 | c2 = {c1 | c2}")

Sortir:

c1 + c2 = Counter({'a': 5, 'b': 4, 'c': 3, 'd': 2})
c1 - c2 = Counter({'a': 3})
c1 & c2 = Counter({'b': 2, 'a': 1})
c1 | c2 = Counter({'a': 4, 'd': 4, 'c': 3, 'b': 2})

10. Éléments tournants efficacement avec deque

Le deque L’objet a un rotate() Méthode qui vous permet de faire pivoter efficacement les éléments. Un argument positif fait pivoter des éléments à droite; un négatif, à gauche. C’est beaucoup plus rapide que de trancher et de réjouir des listes ou des tuples.

from collections import deque

d = deque((1, 2, 3, 4, 5))
print(f"Original deque: {d}")

# Rotate 2 steps to the right
d.rotate(2)
print(f"After rotating 2 to the right: {d}")

# Rotate 3 steps to the left
d.rotate(-3)
print(f"After rotating 3 to the left: {d}")

Sortir:

Original deque: deque((1, 2, 3, 4, 5))
After rotating 2 to the right: deque((4, 5, 1, 2, 3))
After rotating 3 to the left: deque((2, 3, 4, 5, 1))

Emballage

Le collections Le module de Python est une collection de tueurs de données de conteneurs spécialisées et hautes performances. De compter les articles avec Counter pour construire des files d’attente efficaces avec dequeces outils peuvent rendre votre code plus propre, plus efficace et plus pythonique. En vous familiarisant avec ces fonctionnalités surprenantes et puissantes, vous pouvez résoudre des problèmes de programmation courants d’une manière plus élégante et efficace.

Matthew Mayo (@ Mattmayo13) est titulaire d’une maîtrise en informatique et d’un diplôme d’études supérieures en exploration de données. En tant que rédacteur en chef de Kdnuggets & Statologieet rédacteur en chef à Maîtrise de l’apprentissage automatiqueMatthew vise à rendre les concepts de science des données complexes accessibles. Ses intérêts professionnels incluent le traitement du langage naturel, les modèles de langue, les algorithmes d’apprentissage automatique et l’exploration de l’IA émergente. Il est motivé par une mission pour démocratiser les connaissances dans la communauté des sciences des données. Matthew est codant depuis l’âge de 6 ans.