5.11 collections -- Tipi di dato contenitore ad alte prestazioni

Nuovo nella versione 2.4.

Questo modulo implementa tipi di dato contenitore ad alte prestazioni. Al momento l'unico tipo di dato è una deque. Future integrazioni potranno comprendere B-tree ed heap di Fibonacci.

deque( [iterable])
Restituisce un nuovo oggetto deque inizializzato da sinistra a destra (mediante append()) con i dati presi da iterable. Se iterable non viene specificato, il nuovo deque è vuoto.

I deque sono una generalizzazione delle pile e delle code (si pronuncia ``deck'' ed è l'abbreviazione di ``double-ended queue''). I deque supportano il thread-safe ed i metodi append e pop sono efficienti nell'uso della della memoria da entrambe le estremità del deque con approssimativamente le stesse prestazioni O(1) in entrambe le direzioni.

Sebbene gli oggetti list supportino operazioni simili, i deque sono ottimizzati per operazioni veloci a lunghezza fissa e comportano un costo di O(n) spostamenti in memoria per le operazioni "pop(0)" e "insert(0, v)" che modificano sia la dimensione che la posizione della rappresentazione sottostante dei dati. Nuovo nella versione 2.4.

Gli oggetti deque supportano i seguenti metodi:

append( x)
aggiunge x all'estremità destra del deque.

appendleft( x)
Aggiunge x all'estremità sinistra del deque.

clear( )
Rimuove tutti gli elementi dal deque riducendolo a lunghezza 0.

extend( iterable)
Estende l'estremità destra del deque aggiungendo gli elementi presi dall'argomento iterabile iterable.

extendleft( iterable)
Estende l'estremità sinistra del deque aggiungendo gli elementi presi dall'argomento iterabile iterable. Notate che la serie di inserimenti a sinistra del deque corrisponde ad invertire l'ordine degli elementi dell'argomento iterable.

pop( )
Rimuove e restituisce un elemento dall'estremità destra del deque. Se non sono presenti elementi viene sollevata un'eccezione IndexError.

popleft( )
Rimuove e restituisce un elemento dall'estremità sinistra del deque. Se non sono presenti elementi viene sollevata un'eccezione IndexError.

rotate( n)
Ruota il deque di n posizioni verso destra. Se n è negativo, ruota a sinistra. Ruotare di una posizione a destra equivale a: "d.appendleft(d.pop())".

In aggiunta ai metodi citati, i deque supportano l'iterazione, il pickling, "len(d)", "reversed(d)", "copy.copy(d)", "copy.deepcopy(d)", il controllo di appartenenza con l'operatore in ed i riferimenti del tipo "d[-1]".

Esempio:

>>> from collections import deque
>>> d = deque('ghi')                 # crea un nuovo deque con tre elementi
>>> for elem in d:                   # itera gli elementi del deque
...     print elem.upper()
G
H
I

>>> d.append('j')                    #  aggiunge un nuovo elemento
                                     #+ all'estremità destra
>>> d.appendleft('f')                #  aggiunge un nuovo elemento
                                     #+ all'estremità sinistra
>>> d                                #  mostra il contenuto del deque
deque(['f', 'g', 'h', 'i', 'j'])

>>> d.pop()                          #  restituisce e rimuove
                                     #+ l'elemento più a destra
'j'
>>> d.popleft()                      #  restituisce e rimuove
                                     #+ l'elemento più a sinistra
'f'
>>> list(d)                          #  elenca il contenuto del deque
['g', 'h', 'i']
>>> d[0]                             #  punta all'elemento più a sinistra
'g'
>>> d[-1]                            #  punta all'elemento più a destra
'i'

>>> list(reversed(d))                #  elenca il contenuto del deque
                                     #+ in ordine inverso
['i', 'h', 'g']
>>> 'h' in d                         #  cerca nel deque
True
>>> d.extend('jkl')                  #  aggiunge più elementi in una volta
>>> d
deque(['g', 'h', 'i', 'j', 'k', 'l'])
>>> d.rotate(1)                      #  rotazione a destra
>>> d
deque(['l', 'g', 'h', 'i', 'j', 'k'])
>>> d.rotate(-1)                     #  rotazione a sinistra
>>> d
deque(['g', 'h', 'i', 'j', 'k', 'l'])

>>> deque(reversed(d))               #  crea un nuovo deque rovesciato
deque(['l', 'k', 'j', 'i', 'h', 'g'])
>>> d.clear()                        #  svuota il deque
>>> d.pop()                          #  non si può eseguire pop su un
                                     #+ deque vuoto
Traceback (most recent call last):
  File "<pyshell#6>", line 1, in -toplevel-
    d.pop()
IndexError: pop from an empty deque

>>> d.extendleft('abc')              #  extendleft() inverte l'ordine
                                     #+ di input
>>> d
deque(['c', 'b', 'a'])



Subsections
Vedete Circa questo documento... per informazioni su modifiche e suggerimenti.