I seguenti metodi facoltativi possono venire definiti per favorire l'emulazione di oggetti sequenza. Metodi per sequenze immutabili dovrebbero al massimo definire __getslice__(); sequenze mutabili possono definire tutti e tre i metodi.
self, i, j) |
self[i:j]
. L'oggetto restituito dovrebbe
essere dello stesso tipo di self. Si noti che l'assenza di
i o j nell'espressione di affettamento viene sostituita
rispettivamente da zero o sys.maxint
. Se vengono usati indici
negativi nell'affettamento, viene aggiunta all'indice la lunghezza
della sequenza. Se l'istanza non implementa il metodo
__len__(), viene sollevata un'eccezione
AttributeError.
Non viene data alcuna garanzia che gli indici modificati in questo
modo non siano ancora negativi. Indici che sono maggiori della
lunghezza della sequenza non vengono modificati.
Se non viene trovato __getslice__(), viene creato un oggetto
fetta e passato invece a __getitem__().
self, i, j, sequence) |
self[i:j]
. Stesse osservazioni fatte su
i e j per __getslice__().
Questo metodo è deprecato. Se non viene trovato
__setslice__(), o per affettamenti estesi nella forma
self[i:j:k]
, viene creato un oggetto
fetta e passato a __setitem__() invece di richiamare
__setslice__().
self, i, j) |
self[i:j]
. Stesse osservazioni su i e
j per __getslice__(). Questo metodo è deprecato. Se
non viene trovato __delslice__() o per affettamenti estesi
nella forma self[i:j:k]
, viene creato
un oggetto fetta e passato a __delitem__() invece di
richiamare __delslice__().
Da notare che questi metodi vengono invocati solo quando viene usata un'affettamento singolo con un solo carattere due punti ed il metodo di affettamento è disponibile. Per operazioni di affettamento viene richiamato __getitem__(), __setitem__() o __delitem__() con un oggetto fetta come argomento.
Il seguente esempio dimostra come creare un programma o un modulo compatibile con versioni precedenti di Python (assumendo che i metodi __getitem__(), __setitem__() e __delitem__() supportino oggetti fetta come argomenti):
class MyClass: ... def __getitem__(self, index): ... def __setitem__(self, index, value): ... def __delitem__(self, index): ... if sys.version_info < (2, 0): # They won't be defined if version is at least 2.0 final def __getslice__(self, i, j): return self[max(0, i):max(0, j):] def __setslice__(self, i, j, seq): self[max(0, i):max(0, j):] = seq def __delslice__(self, i, j): del self[max(0, i):max(0, j):] ...
Si notino le chiamate a max() che sono necessarie a causa
della gestione degli indici negativi prima della chiamata ai metodi
__*slice__(). Quando vengono usati indici negativi, i metodi
__*item__() li ricevono come vengono forniti ma i metodi
__*slice__() ottengono una forma ``contraffatta'' degli indici.
Per ogni indice negativo, la lunghezza della sequenza viene aggiunta
all'indice prima di richiamare il metodo (anche se può risultare
ancora un indice negativo); questa è la gestione abituale degli
indici negativi fatta dalle sequenze built-in ed è il comportamento
che ci si aspetta anche dai metodi __*item__(). Comunque,
dato che dovrebbero già fare tutto questo, gli indici negativi non
possono essere passati loro; devono essere costretti alla legatura
della sequenza prima di venire passati ai metodi __*item__().
La chiamata a max(0, i)
restituisce un valore appropriato.
Vedete Circa questo documento... per informazioni su modifiche e suggerimenti.