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.