2.3.6.4 Tipi sequenza mutabile

Gli oggetti lista supportano ulteriori operazioni che permettono modifiche locali dell'oggetto. Altri tipi di sequenze mutabili (quando aggiunte al linguaggio) potrebbero anche supportare queste operazioni. Le stringhe e le tuple sono tipi di sequenze immutabili: questi oggetti non possono essere modificati una volta creati. Le seguenti operazioni vengono definite su una sequenza di tipo mutabile (dove x è un oggetto arbitrario):

Operazione Risultato Note

s[i] = x elemento i di s viene sostituito da x
s[i:j] = t la fetta di s da i a j viene sostituita da t
del s[i:j] uguale a s[i:j] = []
s[i:j:k] = t gli elementi di s[i:j:k] vengono sostituiti da quelli di t (1)
del s[i:j:k] rimuove gli elementi di s[i:j:k] dalla lista
s.append(x) uguale a s[len(s):len(s)] = [x] (2)
s.extend(x) ugualea a s[len(s):len(s)] = x (3)
s.count(x) restituisce il numero di i per cui s[i] == x
s.index(x[, i[, j]]) restituisce il più piccolo k, tale che s[k] == x e i <= k < j (4)
s.insert(i, x) uguale a s[i:i] = [x] (5)
s.pop([i]) uguale a x = s[i]; del s[i]; restituisce x (6)
s.remove(x) uguale a del s[s.index(x)] (4)
s.reverse() inverte gli elementi di s localmente (7)
s.sort([cmp[, key[, reverse]]]) ordina gli elementi di s localmente (7), (8), (9), (10)

Note:

Operazione	Risultato	Note
`s[i] = x`	elemento `i` di `s` viene sostituito da `x`
`s[i:j] = t`	la fetta di `s` da `i` a `j` viene sostituita da `t`
`del s[i:j]`	uguale a `s[i:j] = []`
`s[i:j:k] = t`	gli elementi di `s[i:j:k]` vengono sostituiti da quelli di `t`	(1)
`del s[i:j:k]`	rimuove gli elementi di `s[i:j:k]` dalla lista
`s.append(x)`	uguale a `s[len(s):len(s)] = [x]`	(2)
`s.extend(x)`	ugualea a `s[len(s):len(s)] = x`	(3)
`s.count(x)`	restituisce il numero di `i` per cui `s[i] == x`
`s.index(x[, i[, j]])`	restituisce il più piccolo `k`, tale che `s[k] == x` e `i <= k < j`	(4)
`s.insert(i, x)`	uguale a `s[i:i] = [x]`	(5)
`s.pop([i])`	uguale a `x = s[i]; del s[i]; restituisce x`	(6)
`s.remove(x)`	uguale a `del s[s.index(x)]`	(4)
`s.reverse()`	inverte gli elementi di `s` localmente	(7)
`s.sort([cmp[, key[, reverse]]])`	ordina gli elementi di `s` localmente	(7), (8), (9), (10)

(1)

t deve avere la stessa lunghezza della fetta che sta rimpiazzando.

(2)

L'implementazione in C di Python ha accettato storicamente i parametri multipli ed implicitamente li ha uniti nelle tuple; questo non funziona più in Python 2,0. L'uso di questa specie di funzionalità viene deprecato da Python 1.4.

(3)

Solleva un'eccezione quando x non è un oggetto lista.

(4)

Solleva un'eccezione ValueError quando x non viene trovato in s. Quando un indice negativo viene passato come secondo o terzo parametro al metodo index(), vi viene aggiunta la lunghezza della lista, come per gli indici delle fette. Se l'indice è ancora negativo, viene troncato a zero, come per gli indici delle fette. Modificato nella versione 2.3: Precedentemente, index() non aveva argomenti per specificare le posizioni di start e stop.

(5)

Quando un indice negativo viene passato come primo parametro del metodo insert(), vi viene aggiunta la lunghezza della lista, come per gli indici delle fette. Modificato nella versione 2.3: Precedentemente, tutti gli indici negativi venivano troncati a zero.

(6)

Il metodo pop() viene supportato solamente dai tipi lista ed array. L'argomento facoltativo i è per definizione -1, così per definizione l'ultimo elemento viene rimosso e rstituito.

(7)

I metodi sort() e reverse() modificano la lista localmente, per economia di spazio, quando ordinano o invertono una grande lista. Per ricordarvi che operano come effetto secondario, non restituiscono liste ordinate o invertite.

(8)

Il metodo sort() accetta argomenti facoltativi per controllare i confronti.

cmp specifica una funzione di confronto personalizzata di due argomenti (lista elementi) che dovrebbe restituire un negativo, zero o un numero positivo, in funzione del primo argomento considerato più piccolo, uguale, o più grande del secondo argomento: "cmp=lambda x,y: cmp(x.lower(), y.lower())"

key specifica una funzione di un argomento che viene usato per estrarre una chiave di confronto da ogni elemento della lista: "cmp=str.lower"

reverse è un valore booleano. Se impostato a True, gli elementi della lista vengono elencati come se ogni confronto venisse invertito.

In generale, i processi di conversione key e reverse sono più veloci di quelli che specificano la funzione equivalente cmp. Questo perché cmp viene chiamato più volte per ogni elemento della lista, mentre key e reverse toccano ogni elemento della lista solo una volta.

Modificato nella versione 2.3: Il supporto per None come un equivalente per l'omissione, cmp è stato aggiunto.

Modificato nella versione 2.4: Il supporto per key e reverse è stato aggiunto.

(9)

A partire da Python 2.3, il metodo sort() viene garantito come stabile. sort() è stabile se garantisce di non cambiare l'ordine relativo degli elementi uguali che si confrontano -- questo aiuta per ordinare in più passaggi (per esempio, ordinare per dipartimento, quindi per grado di stipendio).

(10)

Mentre una lista può essere ordinata, l'effetto di tentare di mutarla, o anche esaminarla, non viene definito. L'implementazione in C di Python 2.3 e successivi fa apparire la lista vuota durante l'ordinamento, e solleva un'eccezione di tipo ValueError se può rilevare che la lista è stata modificata durante l'operazione.

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