Python - Operadores e fatiamento de sequências
Aprenda sobre operadores e fatiamento de sequências em Python

O que é uma sequência?

Sequências são coleções ordenadas embutidas: strings, listas, tuplas e buffers.

Contamos o índice de determinada sequência a partir do zero.

+---+---+---+---+---+---+
| p | y | t | h | o | n |
+---+---+---+---+---+---+
  0   1   2   3   4   5

Outra coisa que precisamos saber sobre o fatiamento de sequências é um pouco óbvio mas vale reforçar:

• ao fatiar uma string teremos como resultado uma nova string fatiada:

  "python"[:3] retornará "pyt"

• ao fatiar um lista teremos como resultado uma nova lista com os “pedaços”:

  ["p", "y", "t", "h", "o", "n"][:3] retornará ["p", "y", "t"].

Veja mais exemplos:

p = "python"
p[0] # 'p'
p[1] # 'y'
p[2] # 't'
p[3] # 'h'
p[4] # 'o'
p[5] # 'n'

p = "python"
p[-1] # 'n'
p[-2] # 'o'
p[-3] # 'h'
p[-4] # 't'
p[-5] # 'y'
p[-6] # 'p'

Curiosidade, p[-0] é igual a p[0], ambos resultam em 'p'.

O operador [a:b] possui o comprimento de a (inclusive) até b(exclusive):

p = "python"
p[0:0] # ''
p[0:1] # 'p'
p[1:2] # 'y'
p[2:3] # 't'
p[3:4] # 'h'
p[4:5] # 'o'
p[5:6] # 'n'
p[6:6] # ''

O operador [:b] possui o comprimento até b (exclusive)”:

p = "python"
p[:1] # 'p'
p[:2] # 'py'
p[:3] # 'pyt'
p[:4] # 'pyth'
p[:5] # 'pytho'
p[:6] # 'python'

…equivalente a:

p = "python"
p[0:0] # ''
p[0:1] # 'p'
p[0:2] # 'py'
p[0:3] # 'pyt'
p[0:4] # 'pyth'
p[0:5] # 'pytho'
p[0:6] # 'python'

O operador [a:] possui o comprimento a partir de a(inclusive):

p = "python"
p[:]  # 'python'
p[1:] # 'ython'
p[2:] # 'thon'
p[3:] # 'hon'
p[4:] # 'on'
p[5:] # 'n'
p[6:] # ''

O trecho abaixo é para ilustrar como vários caminhos chegam no mesmo lugar.

p = ["p", "y", "t", "h", "o", "n"]
(p == p[0:6]) # True
(p == p[:6])  # True
(p == p[:])   # True

…ou seja, se aplicarmos um “print” nas formas acima, o resultado será exatamente o mesmo, veja:

print p       // ['p', 'y', 't', 'h', 'o', 'n']
print p[0:6]  // ['p', 'y', 't', 'h', 'o', 'n']
print p[:6]   // ['p', 'y', 't', 'h', 'o', 'n']
print p[:]    // ['p', 'y', 't', 'h', 'o', 'n']

O operador [:] representa o total da lista (ou string).

E há ainda o operador [a:b:n] que representa de n em n itens.

Operações com sequências

Atribuição em fatias:

Funções nativas p/ sequências

Fonte:

• Slide 34 de “Python: apresentando a sintaxe” (Luciano Ramalho)