Fatiamento em Python (slicing): strings, listas e tuplas

Iniciante20 min6 exercícios80 XP

Este tutorial foi traduzido do original em inglês.Read in English Leer en español Читать на русском อ่านภาษาไทย Avisar sobre um erro de tradução

Antes de começar

Strings em Python: criar, acessar, fatiar e manipular texto Listas em Python: criar, acessar, modificar e percorrer

0/6 exercícios

Imagine uma pizza cortada em 8 fatias, numeradas de 0 a 7. Nem sempre você quer a pizza inteira. Às vezes você quer as fatias de 2 a 5. Às vezes quer uma fatia sim, outra não. Às vezes quer as três últimas fatias.

O fatiamento (slicing) do Python permite pegar um pedaço de qualquer sequência (uma lista, uma string ou uma tupla) usando a mesma notação simples. É um dos recursos mais elegantes do Python e, depois que você aprende, passa a usá-lo em todo lugar.

Neste tutorial, você vai aprender a notação start:stop:step (início, fim e passo), como funcionam os índices negativos, como inverter qualquer sequência e os padrões de fatiamento mais comuns, que os desenvolvedores Python usam todos os dias.

Como funciona o fatiamento básico?

A sintaxe básica de uma fatia é sequence[start:stop]. Ela devolve os itens a partir do índice start até o índice stop, mas sem incluí-lo. Pense nisso como um intervalo semiaberto.

Fatiamento básico com start:stop

fruits = ['apple', 'banana', 'cherry', 'date', 'elderberry']

# Get items at index 1, 2 (stops before 3)

print(fruits[1:3]) # ['banana', 'cherry']

# Get the first three items

print(fruits[0:3]) # ['apple', 'banana', 'cherry']

# Get items from index 2 to the end

print(fruits[2:5]) # ['cherry', 'date', 'elderberry']

Saída

['banana', 'cherry']
['apple', 'banana', 'cherry']
['cherry', 'date', 'elderberry']

A regra de "parar antes" pode parecer estranha no começo. Mas ela tem uma vantagem: fruits[0:3] devolve exatamente 3 itens. Em uma fatia simples [start:stop] em que 0 <= start <= stop <= len(fruits), o número de itens é stop - start.

Omitindo start e stop

numbers = [10, 20, 30, 40, 50, 60]

# First three items (omit start)

print(numbers[:3]) # [10, 20, 30]

# Everything from index 3 onward (omit stop)

print(numbers[3:]) # [40, 50, 60]

# Copy the entire list (omit both)

copy = numbers[:]

print(copy) # [10, 20, 30, 40, 50, 60]

Saída

[10, 20, 30]
[40, 50, 60]
[10, 20, 30, 40, 50, 60]

O que faz o parâmetro step?

A sintaxe completa de uma fatia é sequence[start:stop:step]. O step (passo) controla o tamanho do salto entre os itens que você pega. Um passo 2 pega um item sim, outro não. Um passo 3 pega um item a cada três.

Usando o parâmetro step

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Every other item

print(numbers[::2]) # [0, 2, 4, 6, 8]

# Every other item starting from index 1

print(numbers[1::2]) # [1, 3, 5, 7, 9]

# Every third item

print(numbers[::3]) # [0, 3, 6, 9]

# From index 1 to 7, every 2nd item

print(numbers[1:7:2]) # [1, 3, 5]

Saída

[0, 2, 4, 6, 8]
[1, 3, 5, 7, 9]
[0, 3, 6, 9]
[1, 3, 5]

Se você deixar de fora o start e o stop, um passo positivo cobre a sequência inteira, do começo ao fim. Um passo negativo inverte esses padrões e começa pelo final, como você vai ver abaixo. Você só precisa informá-los se quiser restringir o intervalo.

Como funcionam os índices negativos no fatiamento?

Índices negativos contam a partir do fim da sequência. -1 é o último item, -2 é o penúltimo, e assim por diante. Você pode usar números negativos em qualquer parte da fatia: start, stop ou step.

Fatiamento com índices negativos

letters = ['a', 'b', 'c', 'd', 'e', 'f']

# Last three items

print(letters[-3:]) # ['d', 'e', 'f']

# Everything except the last two

print(letters[:-2]) # ['a', 'b', 'c', 'd']

# From second-to-last to last

print(letters[-2:]) # ['e', 'f']

Saída

['d', 'e', 'f']
['a', 'b', 'c', 'd']
['e', 'f']

Índices negativos são extremamente úteis quando você quer itens contados a partir do fim. Por exemplo, my_list[-3:] sempre devolve os três últimos itens, seja qual for o tamanho da lista.

Fatiamento negativo com strings

word = 'Python'

# Remove first and last character

print(word[1:-1]) # ytho

# Last 4 characters

print(word[-4:]) # thon

# First 2 characters

print(word[:2]) # Py

Saída

ytho
thon
Py

Como inverter uma sequência com [::-1]

Um passo negativo diz ao Python para andar para trás. O padrão mais comum é [::-1], que inverte a sequência inteira. Sem início, sem fim, passo -1: vai do fim até o começo.

Invertendo com [::-1]

# Reverse a list

numbers = [1, 2, 3, 4, 5]

print(numbers[::-1]) # [5, 4, 3, 2, 1]

# Reverse a string

word = 'hello'

print(word[::-1]) # olleh

# Reverse a tuple

coords = (10, 20, 30, 40)

print(coords[::-1]) # (40, 30, 20, 10)

Saída

[5, 4, 3, 2, 1]
olleh
(40, 30, 20, 10)

Você pode combinar um passo negativo com início e fim para inverter só uma parte. Com um passo negativo, o start deve ser maior que o stop, já que você está andando para trás.

Passo negativo com início e fim

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Reverse items from index 7 down to index 2 (not including 2)

print(numbers[7:2:-1]) # [7, 6, 5, 4, 3]

# Every other item, reversed

print(numbers[::-2]) # [9, 7, 5, 3, 1]

Saída

[7, 6, 5, 4, 3]
[9, 7, 5, 3, 1]

Fatiando strings, listas e tuplas

A mesma sintaxe [start:stop:step] funciona em todos os tipos de sequência. A única diferença é o que você recebe de volta: fatiar uma lista devolve uma lista, fatiar uma string devolve uma string e fatiar uma tupla devolve uma tupla.

O fatiamento preserva o tipo

# Slicing a string -> string

name = 'Alexander'

print(name[0:4]) # Alex

print(type(name[0:4])) # <class 'str'>

# Slicing a list -> list

scores = [90, 85, 77, 92, 88]

print(scores[1:4]) # [85, 77, 92]

# Slicing a tuple -> tuple

point = (10, 20, 30, 40, 50)

print(point[::2]) # (10, 30, 50)

Saída

Alex
<class 'str'>
[85, 77, 92]
(10, 30, 50)

Padrões de fatiamento que todo desenvolvedor Python deve conhecer

Estes são os padrões de fatiamento que você mais vai ver e usar. Pense nisto como sua referência rápida.

Seis padrões essenciais de fatiamento

data = ['a', 'b', 'c', 'd', 'e', 'f', 'g']

# First N items

print(data[:3]) # ['a', 'b', 'c']

# Last N items

print(data[-3:]) # ['e', 'f', 'g']

# Remove first item

print(data[1:]) # ['b', 'c', 'd', 'e', 'f', 'g']

# Remove last item

print(data[:-1]) # ['a', 'b', 'c', 'd', 'e', 'f']

# Middle items (remove first and last)

print(data[1:-1]) # ['b', 'c', 'd', 'e', 'f']

# Reverse the whole thing

print(data[::-1]) # ['g', 'f', 'e', 'd', 'c', 'b', 'a']

Saída

['a', 'b', 'c']
['e', 'f', 'g']
['b', 'c', 'd', 'e', 'f', 'g']
['a', 'b', 'c', 'd', 'e', 'f']
['b', 'c', 'd', 'e', 'f']
['g', 'f', 'e', 'd', 'c', 'b', 'a']

Você também pode usar o fatiamento do lado esquerdo de uma atribuição para substituir um trecho de uma lista. Isso se chama atribuição por fatia (slice assignment).

Atribuição por fatia (só em listas)

colors = ['red', 'green', 'blue', 'yellow', 'purple']

# Replace items at index 1 and 2

colors[1:3] = ['lime', 'sky']

print(colors) # ['red', 'lime', 'sky', 'yellow', 'purple']

# You can even replace with a different number of items

colors[1:3] = ['orange']

print(colors) # ['red', 'orange', 'yellow', 'purple']

Saída

['red', 'lime', 'sky', 'yellow', 'purple']
['red', 'orange', 'yellow', 'purple']

Exercícios práticos

Pegue os itens do meio

Escreva o código

Dada a lista animals, use fatiamento para exibir só os três itens do meio: ['cat', 'dog', 'elephant'].

animals = ['ant', 'bear', 'cat', 'dog', 'elephant', 'fox', 'giraffe']

# Print the middle three items using slicing

Preveja a saída da fatia

Preveja a saída

O que este código exibe? Pense bem nos índices negativos.

word = 'programming'
print(word[-4:])

Escreva uma instrução print() que produza exatamente a mesma saída.

# Predict the output and write the matching print statement

print("?")

Extraia os itens de índice par

Escreva o código

Dada a lista letters, use fatiamento com passo para exibir só os itens nos índices pares (0, 2, 4, 6). O resultado deve ser ['a', 'c', 'e', 'g'].

letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']

# Print items at even indices using slicing

Inverta uma palavra

Escreva o código

Use fatiamento para inverter a string word e exiba o resultado. A saída deve ser nohtyp.

word = 'python'

# Reverse the word using slicing and print it

Corrija o bug no fatiamento

Corrija o erro

Este código tenta pegar os três últimos itens de uma lista, mas está usando a fatia errada. Corrija o bug para que ele exiba ['date', 'elderberry', 'fig'].

fruits = ['apple', 'banana', 'cherry', 'date', 'elderberry', 'fig']

# Bug: this doesn't get the last three items

last_three = fruits[3:0]

print(last_three)

Verificador de palíndromos

Escreva o código

Escreva uma função chamada is_palindrome(text) que retorne True se o texto for lido igual de frente para trás e de trás para frente, e False caso contrário. Use fatiamento para inverter a string. Converta o texto para minúsculas antes, para que a verificação não diferencie maiúsculas de minúsculas.

Teste com estas chamadas:

print(is_palindrome('racecar'))
print(is_palindrome('Python'))
print(is_palindrome('Madam'))

Como funciona o fatiamento básico?

O que faz o parâmetro step?

Como funcionam os índices negativos no fatiamento?

Como inverter uma sequência com [::-1]

Fatiando strings, listas e tuplas

Padrões de fatiamento que todo desenvolvedor Python deve conhecer

Exercícios práticos

Tutoriais relacionados