3.3.6 Metodi aggiuntivi per emulare tipi sequenza

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.

__getslice__( self, i, j)
Deprecato dalla versione 2.0 di Python. Supporta oggetti fetta come parametri per il metodo __getitem__().
Chiamato per implementare la valutazione di 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__().

__setslice__( self, i, j, sequence)
Chiamato per implementare l'assegnamento di 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__().

__delslice__( self, i, j)
Chiamato per implementare la rimozione di 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.