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:

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

Operadores Descrição
s[-i] acesso a um item pelo final
s+z concatenação
s*n n cópias de s concatenadas
i in s teste de inclusão
i not in s teste de inclusão negativo

Atribuição em fatias:

Operadores Descrição
s[2:5] = [4,3,2,1] válida apenas em sequências mutáveis

Funções nativas p/ sequências

Operadores Descrição
len(s) número de elementos
min(s) valores mínimo contido em s
max(s) valores máximo contido em s
sorted(s) devolve uma lista com itens de s em ordem ascendente
reversed(s) retorna um iterador para percorrer os elementos do último ao primeiro

Fonte:

Comentários

comments powered by Disqus