Python Language
Indicizzazione e affettatura

Sintassi

• obj [start: fermata: passo]
• slice (stop)
• slice (start, stop [, step])

Parametri

Osservazioni

Slicing di base

Per ogni iterabile (per esempio una stringa, una lista, ecc.), Python consente di suddividere e restituire una sottostringa o una sottolista dei suoi dati.

Formato per affettare:

iterable_name[start:stop:step]

dove,

• start è il primo indice della sezione. Il valore predefinito è 0 (l'indice del primo elemento)
• stop uno dopo l'ultimo indice della fetta. Il valore predefinito è len (iterabile)
• step è la dimensione del passo (meglio spiegato dagli esempi di seguito)

Esempi:

a = "abcdef"
a            # "abcdef" 
             # Same as a[:] or a[::] since it uses the defaults for all three indices
a[-1]        # "f"
a[:]         # "abcdef" 
a[::]        # "abcdef" 
a[3:]        # "def" (from index 3, to end(defaults to size of iterable)) 
a[:4]        # "abcd" (from beginning(default 0) to position 4 (excluded)) 
a[2:4]       # "cd" (from position 2, to position 4 (excluded)) 

Inoltre, uno dei precedenti può essere utilizzato con le dimensioni del passo definite:

a[::2]       # "ace" (every 2nd element)
a[1:4:2]     # "bd" (from index 1, to index 4 (excluded), every 2nd element)

Gli indici possono essere negativi, nel qual caso vengono calcolati dalla fine della sequenza

a[:-1]     # "abcde" (from index 0 (default), to the second last element (last element - 1))
a[:-2]     # "abcd" (from index 0 (default), to the third last element (last element -2))
a[-1:]     # "f" (from the last element to the end (default len()) 

Anche le dimensioni degli step possono essere negative, nel qual caso la slice itererà attraverso la lista in ordine inverso:

a[3:1:-1]   # "dc" (from index 2 to None (default), in reverse order)

Questo costrutto è utile per invertire un iterabile

a[::-1]     # "fedcba" (from last element (default len()-1), to first, in reverse order(-1))

Nota che per i passaggi negativi l' end_index predefinito è None (vedi http://stackoverflow.com/a/12521981 )

a[5:None:-1] # "fedcba" (this is equivalent to a[::-1])
a[5:0:-1]    # "fedcb" (from the last element (index 5) to second element (index 1)

Fare una copia superficiale di un array

Un modo rapido per fare una copia di un array (al contrario di assegnare una variabile con un altro riferimento alla matrice originale) è:

arr[:]

Esaminiamo la sintassi. [:] significa che start , end e slice sono tutti omessi. Hanno come valore predefinito 0 , len(arr) e 1 , rispettivamente, il che significa che il subarray che stiamo richiedendo avrà tutti gli elementi di arr dall'inizio fino alla fine.

In pratica, questo assomiglia a qualcosa:

arr = ['a', 'b', 'c']
copy = arr[:]
arr.append('d')
print(arr)    # ['a', 'b', 'c', 'd']
print(copy)   # ['a', 'b', 'c']

Come puoi vedere, arr.append('d') aggiunto d a arr , ma la copy rimasta invariata!

Si noti che questo fa una copia superficiale , ed è identico a arr.copy() .

Inversione di un oggetto

È possibile utilizzare le sezioni per invertire molto facilmente una str , list o tuple (o sostanzialmente qualsiasi oggetto di raccolta che implementa l'slicing con il parametro step). Ecco un esempio di inversione di una stringa, sebbene ciò si applichi anche agli altri tipi sopra elencati:

s = 'reverse me!'
s[::-1]    # '!em esrever'

Diamo un'occhiata veloce alla sintassi. [::-1] significa che la sezione dovrebbe essere dall'inizio fino alla fine della stringa (poiché l' start e la end sono omessi) e un passo di -1 significa che dovrebbe spostarsi attraverso la stringa al contrario.

Indicizzazione delle classi personalizzate: __getitem__, __setitem__ e __delitem__

class MultiIndexingList:
    def __init__(self, value):
        self.value = value
        
    def __repr__(self):
        return repr(self.value)
    
    def __getitem__(self, item):
        if isinstance(item, (int, slice)):
            return self.__class__(self.value[item])
        return [self.value[i] for i in item]
    
    def __setitem__(self, item, value):
        if isinstance(item, int):
            self.value[item] = value
        elif isinstance(item, slice):
            raise ValueError('Cannot interpret slice with multiindexing')
        else:
            for i in item:
                if isinstance(i, slice):
                    raise ValueError('Cannot interpret slice with multiindexing')
                self.value[i] = value
    
    def __delitem__(self, item):
        if isinstance(item, int):
            del self.value[item]
        elif isinstance(item, slice):
            del self.value[item]
        else:
            if any(isinstance(elem, slice) for elem in item):
                raise ValueError('Cannot interpret slice with multiindexing')
            item = sorted(item, reverse=True)
            for elem in item:
                del self.value[elem]

Ciò consente l'affettatura e l'indicizzazione per l'accesso agli elementi:

a = MultiIndexingList([1,2,3,4,5,6,7,8])
a
# Out: [1, 2, 3, 4, 5, 6, 7, 8]
a[1,5,2,6,1]
# Out: [2, 6, 3, 7, 2]
a[4, 1, 5:, 2, ::2]
# Out: [5, 2, [6, 7, 8], 3, [1, 3, 5, 7]]
#       4|1-|----50:---|2-|-----::2-----   <-- indicated which element came from which index

Mentre l'impostazione e l'eliminazione di elementi consente solo l'indicizzazione di numeri interi separati da virgole (nessuna suddivisione):

a[4] = 1000
a
# Out: [1, 2, 3, 4, 1000, 6, 7, 8]
a[2,6,1] = 100
a
# Out: [1, 100, 100, 4, 1000, 6, 100, 8]
del a[5]
a
# Out: [1, 100, 100, 4, 1000, 100, 8]
del a[4,2,5]
a
# Out: [1, 100, 4, 8]

Assegnazione delle fette

Un'altra caratteristica accurata che utilizza le slice è l'assegnazione delle slice. Python consente di assegnare nuove sezioni per sostituire le vecchie sezioni di un elenco in una singola operazione.

Ciò significa che se hai una lista, puoi sostituire più membri in un singolo incarico:

lst = [1, 2, 3]
lst[1:3] = [4, 5]
print(lst) # Out: [1, 4, 5]

Il compito non deve corrispondere anche alle dimensioni, quindi se si volesse sostituire una vecchia sezione con una nuova sezione di dimensioni diverse, è possibile:

lst = [1, 2, 3, 4, 5]
lst[1:4] = [6]
print(lst) # Out: [1, 6, 5]

È anche possibile utilizzare la sintassi di slicing nota per eseguire operazioni come la sostituzione dell'intero elenco:

lst = [1, 2, 3]
lst[:] = [4, 5, 6]
print(lst) # Out: [4, 5, 6]

O solo gli ultimi due membri:

lst = [1, 2, 3]
lst[-2:] = [4, 5, 6]
print(lst) # Out: [1, 4, 5, 6]

Affetta oggetti

Le slice() sono oggetti in sé e possono essere archiviate in variabili con la funzione slice() integrata. Le variabili di sezione possono essere utilizzate per rendere il codice più leggibile e per promuovere il riutilizzo.

>>> programmer_1 = [ 1956, 'Guido', 'van Rossum', 'Python', 'Netherlands']
>>> programmer_2 = [ 1815, 'Ada', 'Lovelace', 'Analytical Engine', 'England']
>>> name_columns = slice(1, 3)
>>> programmer_1[name_columns]
['Guido', 'van Rossum']
>>> programmer_2[name_columns]
['Ada', 'Lovelace']

Indicizzazione di base

Gli elenchi Python sono basati su 0, ovvero il primo elemento nell'elenco può essere consultato dall'indice 0

arr = ['a', 'b', 'c', 'd']
print(arr[0])
>> 'a'

È possibile accedere al secondo elemento nell'elenco per indice 1 , terzo elemento per indice 2 e così via:

print(arr[1])
>> 'b'
print(arr[2])
>> 'c'

È inoltre possibile utilizzare indici negativi per accedere agli elementi dalla fine dell'elenco. per esempio. index -1 ti darà l'ultimo elemento della lista e index -2 ti darà il penultimo elemento della lista:

print(arr[-1])
>> 'd'
print(arr[-2])
>> 'c'

Se si tenta di accedere a un indice che non è presente nell'elenco, verrà sollevato un IndexError :

print arr[6]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
IndexError: list index out of range