collections — tipi di raccolte e contenitori

Questo modulo fornisce tipi di dati contenitore specializzati che integrano le strutture native list, tuple, dict e set: una coda a doppia estremità (deque), una factory di tuple con campi nominati (namedtuple()) e un dizionario che preserva l’ordine (OrderedDict).

Classi

class collections.deque(iterable: Iterable, maxlen: int, flags: int = 0)

Le deque (code a doppia estremità) sono un contenitore simile a una lista che supporta aggiunte e rimozioni in O(1) da entrambe le estremità della deque. Le nuove deque vengono create usando i seguenti argomenti:

• iterable è un iterabile usato per popolare la deque al momento della creazione. Può essere una tupla o una lista vuota per creare una deque inizialmente vuota.

• maxlen deve essere specificato e la deque sarà limitata a questa lunghezza massima. Una volta che la deque è piena, qualsiasi nuovo elemento aggiunto scarterà gli elementi dall’estremità opposta.

• Il parametro opzionale flags può essere 1 per verificare l’overflow durante l’aggiunta di elementi.

Gli oggetti deque supportano bool, len(), l’iterazione e l’accesso in lettura e scrittura tramite indice. Dispongono inoltre dei seguenti metodi:

append(x: Any) → None

Aggiunge x al lato destro della deque. Solleva IndexError se il controllo dell’overflow è abilitato e non c’è più spazio nella coda.

appendleft(x: Any) → None

Aggiunge x al lato sinistro della deque. Solleva IndexError se il controllo dell’overflow è abilitato e non c’è più spazio nella coda.

pop() → Any

Rimuove e restituisce un elemento dal lato destro della deque. Solleva IndexError se non è presente alcun elemento.

popleft() → Any

Rimuove e restituisce un elemento dal lato sinistro della deque. Solleva IndexError se non è presente alcun elemento.

extend(iterable: Iterable) → None

Estende la deque aggiungendo tutti gli elementi di iterable al lato destro della deque. Solleva IndexError se il controllo dell’overflow è abilitato e non c’è più spazio nella deque.

collections.namedtuple(name: str, fields: str | Sequence[str]) → type

Questa è una funzione factory per creare un nuovo tipo namedtuple con un nome specifico e un insieme di campi. Una namedtuple è una sottoclasse di tuple che consente di accedere ai suoi campi non solo tramite indice numerico, ma anche con una sintassi di accesso ad attributi che utilizza nomi simbolici dei campi. Fields è una sequenza di stringhe che specifica i nomi dei campi. Per compatibilità con CPython può anche essere una stringa con nomi di campo separati da spazi (ma questo è meno efficiente). Esempio d’uso:

from collections import namedtuple

MyTuple = namedtuple("MyTuple", ("id", "name"))
t1 = MyTuple(1, "foo")
t2 = MyTuple(2, "bar")
print(t1.name)
assert t2.name == t2[1]

Le istanze forniscono inoltre il seguente metodo:

collections._asdict() → OrderedDict

Restituisce i nomi dei campi e i loro valori come un OrderedDict.

class collections.OrderedDict(*args: Any, **kwargs: Any)

Sottoclasse del tipo dict che ricorda e preserva l’ordine in cui le chiavi sono state aggiunte. Accetta le stesse forme di costruttore di dict (un iterabile di coppie (key, value), un’altra mappatura o argomenti keyword). Quando un ordered dict viene iterato, le chiavi/elementi vengono restituiti nell’ordine in cui sono stati aggiunti:

from collections import OrderedDict

# To make benefit of ordered keys, OrderedDict should be initialized
# from sequence of (key, value) pairs.
d = OrderedDict([("z", 1), ("a", 2)])
# More items can be added as usual
d["w"] = 5
d["b"] = 3
for k, v in d.items():
    print(k, v)

Output:

z 1
a 2
w 5
b 3

popitem() → Tuple

Rimuove e restituisce una coppia (chiave, valore) dal dizionario. Le coppie vengono restituite in ordine LIFO.

Differenze rispetto a CPython

OrderedDict.popitem() non supporta l’argomento last=False e rimuoverà e restituirà sempre l’ultimo elemento, se presente.

Una soluzione alternativa consiste nell’usare pop(<first_key>) per rimuovere il primo elemento:

first_key = next(iter(d))
d.pop(first_key)