Simple Python String (Backward) Slicing

Question

Sì, lo so che ci sono un sacco di domande simili lassù. Ma non riesco a trovare quello che stavo cercando.

La mia confusione riguarda l'affettamento all'indietro.

my_jumble = ['jumbly', 'wumbly', 'number', 5] 
print(my_jumble[:1:-1]) 

Ora ho scoperto che il risultato sarà

[5, 'number'] 

Così ho pensato che forse mi metterà alla prova fuori modificando le estremità in quel affettare stringa.

print(my_jumble[:2:-1]) 

ero davvero sicuro che Python mi avrebbe dato qualcosa di simile

[5, 'number', 'wumbly'] 

Invece mi ha dato questo che mi ha fatto completamente perso ...

[5] 

qualcuno può spiegare che cosa è sta succedendo qui? Sono nuovo di Python e trovo questo molto confuso .. Grazie per qualsiasi aiuto.

Answer 1

Credo che uno dei modi più semplici per capire cosa sta succedendo nel codice è di comprendere che a ritroso affettare inverte il modo in cui si indice vostra lista (visivamente, è come invertire la vostra lista) prima dello ottenendo fette ma gli indici degli elementi nell'elenco stesso non cambiare.

Così, quando si dispone di una lista come questa:

['jumbly', 'wumbly', 'number', 5] 
    0  1   2  3 #<-- index 

rendendo all'indietro lettura (aggiungendo -1 come terzo indicizzatore), si rendono sembra come questo (perché è ormai indicizzazione dal ultima alla prima, invece che dal primo all'ultimo):

[5, 'number', 'wumbly', 'jumbly'] 
3  2   1  0  #<-- index 

e poi quando si fetta dal "principio" a uno (:1), si ottiene tutto dal "principio" (ora il "Inizio" è 3) e fermarsi quando vedendo 1:

[5, 'number', 'wumbly', 'jumbly'] 
3  2   1  0  #<-- index 
^ ^  x 
grab! grab!  nope! 

Così avete ottenuto il vostro ritorno:

[5, 'number'] 

Lo stesso principio vale quando si fetta all'indietro con [:2:-1]:

[5, 'number', 'wumbly', 'jumbly'] 
3  2   1  0  #<-- index 
^  x 
grab! nope! 

Così hai ottenuto il tuo risultato:

[5] 

Ora, usando questo principio, sapete cosa mettere come secondo indicizzatore se volete restituire quello che volete: zero! ->[:0:-1]:

[5, 'number', 'wumbly', 'jumbly'] 
3  2   1  0  #<-- index 
^ ^  ^  x 
grab! grab!  grab! nope! 

Poi, si otterrà il risultato che si desidera:

[5, 'number', 'wumbly'] 

Answer 2

@HarryLens Per fare ciò che realmente vuoi, dovrai farlo in questo modo.

print(my_jumble[-1:0:-1]) 

Anche questo farebbe:

print(my_jumble[:0:-1]) 

Penso che si ritiene che quando si stride è da un -1, l'elenco è invertita. Vedete il primo numero rappresenta la posizione di partenza e il secondo numero la posizione finale (della fetta che volete) nella lista corrente, non la lista invertita. Fare riferimento this.

Answer 3

La sintassi si sta utilizzando è list[start:stop:step]

Se non lo fai in ingresso un valore per start, nemmeno pari a zero, quindi python decide un avvio adatto. Sarà 0 per un passaggio positivo e l'ultimo elemento per un passaggio negativo.

Quindi, nel primo esempio, si sta effettivamente dicendo di scegliere tutti gli articoli a partire da 0, fino a 1, ma nell'ordine inverso. Così stampato [5,'number']

Nel tuo secondo esempio, quello che stai dicendo è scegliere tutti gli articoli a partire dal primo, fino al terzo, nell'ordine inverso. Quindi, procedendo nell'ordine inverso, si inizia da 5, il terzo elemento nell'elenco è 'number', ma poiché hai detto solo fino alla terza, si ferma proprio lì.

Poiché è stato assegnato un valore positivo per stop, sarà nella direzione da sinistra a destra, quindi il terzo elemento nell'ordine corretto nel caso.

Si noti inoltre che in python list[start: stop] equivale a [start: stop), il primo elemento è considerato, è esclusivo del limite destro.

Answer 4

array[start:end:step] significa iniziare con indice start allora ad ogni ciclo ciclo aggiungere ad essa step e rompere il ciclo se l'indice diventa maggiore o uguale a end.Se start è omesso, è uguale a 0. Se si omette end, è impostato su len(array). Se start o end è negativo, è impostato su len(array) + start o len(array) + end. Se step è negativo, viene aggiunto all'indice corrente su ciascun ciclo di ciclo, ma la condizione per continuare il ciclo è current_index > end, non current_index < end quando step è positivo.

Così ['jumbly', 'wumbly', 'number', 5][:1:-1] significa iniziare a prendere gli elementi dall'indice len(array) all'indice 1 (ad esclusione di) - così ci viene data gli elementi ['number', 5]:

>>> ['jumbly', 'wumbly', 'number', 5][:1:-1] 
>>> [5, 'number'] 

['jumbly', 'wumbly', 'number', 5][:2:-1] significa per iniziare a prendere gli elementi dall'indice len(array) all'indice 2 (valore di 'number' viene memorizzato nella lista di indice 2) (non incluso) - quindi abbiamo [5]:

Oppure per spiegare meglio con una stringa i cui caratteri sono gli indici:

>>> '0123'[:1:-1] 
>>> '32' 

>>> '0123'[:2:-1] 
>>> '3'