Lembrete do "fatiamento" ou slicing em Python

fatiamento.txt

O array que vamos usar tem as primeira 5 letras do alfabeto:
array = ['a', 'b', 'c', 'd', 'e']

Se quisermos nos referir a elas, precisamos saber quais so as posições que elas ocupam no array.

Então, ao referenciarmos o array:
array = ['a', 'b', 'c', 'd', 'e']

Seria o mesmo que "usar" o array como referência, pois as posições das letras começam a contar do 0:
array = [0, 1, 2, 3, 4]

Se quisermos pegar pedaços desse array, como da letra 'a' até a letra 'd', abaixo tem um breve lembrete para consulta rápida porque a sintaxe pode gerar confusão.


Fatiamento (Slicing)

Se quisermos as primeiras quatro letras começando do 'a':
['a', 'b', 'c', 'd']

Temos:
array[0:4]

Então, se usamos array[início:fim], pegamos tudo o que está no array do ínicio até fim-1.

Se quisermos tudo o que está no array a partir da primeira letra:
['a', 'b', 'c', 'd', 'e']

Temos:
array[0:]

Então array[início:] pega tudo o que está no array do início em diante.

Se quisermos todo o array começando do 'a' menos o último elemento:
['a', 'b', 'c', 'd']

Temos:
array[:4]

Então, na sintaxe array[:fim] pegamos tudo o que está no array até fim-1.

Se quisermos pegar o array inteiro:
['a', 'b', 'c', 'd', 'e']

Temos:
array[:]

Então, a sintaxe array[:] faz uma cópia de todo o array, ela pega o array inteiro. Basta não definirmos o começo e o fim no fatiamento.


Fatiamento com passo/etapa (step)

Se quisermos um pedaço do início até o fim, dando dois passos até o próximo item:
['a', 'c']

Temos:
array[0:4:2]

Se olharmos para o array original e a sua tradução em posições:
array = [0, 1, 2, 3, 4]
array = ['a', 'b', 'c', 'd', 'e']

andar 2 passos começa do 'a' ou 0, então andamos 'a', andamos 'b' e pegamos o 'c'.
Depois começamos do 'c', andamos 'c', andamos 'd' e paramos de andar, pois 'e' ou 4 é a última posição.

Um modo de visualizar isso é traduzindo o array para números e fim, como:
array = ['a', 'b', 'c', 'd', 'e']
array = [0, 1, 2, 3, fim]

Vamos pegar o início, que é o 0 e o 2, no caso, temos um 0 e um 2 que correspodem ao 'a' e 'c' e paramos antes do fim.

Se for do início ao fim, com 3 passos:
['a', 'd']

Temos:
array[0:4:3]

Tradução do array:
[0, 1, 2, 3, fim]

Começamos no 'a', andamos 'a', andamos 'b', andamos 'c', pegamos 'd'. Chegamos no fim, então paramos.

E do início ao fim, com um passo:
['a', 'b', 'c', 'd']

Temos:
array[0:4:1]

Tradução do array:
[0, 1, 2, 3, fim]

Começamos no 'a', andamos 'a', pegamos 'b', começamos no 'b', andamos 'b', pegamos 'c', começamos no 'c', andamos 'c', pegamos 'd', começamos no 'd', andamos 'd' e não dá para pegar o fim, então paramos.

Então, a sintaxe array[início:fim:passo] pega o que está no array do início, conta os passos do início, pega onde ele termina e faz isso até antes do fim ou fim-1.


Fatiamento com números negativos

Se quisermos pegar a última letra do array:
['e']

Temos:
array[-1]

Então, a sintaxe array[-1] pega o último elemento do array.

Se quisermos as últimas duas letras, 'd' e 'e' do final do array:
['d', 'e']

Temos:
array[-2:]

Então, com array[-2:] pegamos os últimos dois itens do array.

Se quisermos excluir as últimas duas letras do array:
['a', 'b', 'c']

Temos:
array[:-2]

Então, array[:-2] pega tudo no array, exceto os últimos dois itens.


Fatiamento com passo e números negativos

Se quisremos inverter a ordem do array:
['e', 'd', 'c', 'b', 'a']

Temos:
array[::-1]

Então, a sintaxe array[::-1] pega todos os itens do array do último para o primeiro e inverte a ordem.


Para pegarmos dois itens do começo do array invertidos:
['b', 'a']

Temos:
array[1::-1]

Então a sintaxe array[1::-1] pega os primeiros dois ítens do array e inverte a ordem.

Se quisermos pegar os últimos dois itens na ordem inversa:
['e', 'd']

Temos:
array[:-3:-1]

A sintaxe array[:-3:-1] pega os últimos dois itens do array e inverte a ordem.

Se quisermos tudo, exceto últimos dois itens na ordem inversa:
['c', 'b', 'a']

Temos:
array[-3::-1]

A sintaxe array[-3::-1] pega tudo do array, inverte a ordem e exclui os últimos dois itens.

Fonte de inspiração: https://stackoverflow.com/questions/509211/understanding-slice-notation