Pular para o conteúdo principal

Python Slice: Métodos úteis para a codificação cotidiana

Descubra como o fatiamento pode extrair, reorganizar e analisar seus dados sem esforço. Aproveite os índices negativos, as fatias multidimensionais e os valores de etapa avançados para obter precisão total.
Actualizado 15 de jan. de 2025  · 8 min de leitura

Se você está cansado de se atrapalhar com índices de fatia confusos ou de se perguntar por que suas listas fatiadas não estão se comportando como esperado, você está no lugar certo. Neste guia, dividiremos o fatiamento do Python em partes digeríveis (trocadilho intencional). Abordaremos tudo, desde os conceitos básicos da sintaxe de fatiamento até técnicas avançadas com matrizes multidimensionais. Além disso, compartilharei exemplos com aplicativos reais que você pode usar imediatamente.

Se você está ansioso para construir uma base sólida em Python, confira também nosso curso Python Fundamentals, que foi criado para ajudá-lo a dominar habilidades essenciais, como fatiamento, estruturas de dados e muito mais.

Entendendo o fatiamento em Python

Vamos falar um pouco sobre o que significa fatiamento em Python e por que ele é útil.

O que é fatiamento em Python?

Slicing em Python é um método para extrair partes específicas de sequências como strings, listas, tuplas e intervalos. O fatiamento pode se referir ao uso da função integrada slice() ou à notação de colchetes ainda mais comum, que se parece com isto: [start:end:step]. A funcionalidade é uma parte essencial da linguagem Python, portanto,você pode executar o fatiamento com ou sem importar nenhum pacote adicional. O fatiamento, como ocorre em bibliotecas externas como NumPy ou pandas, apresenta algumas diferenças interessantes, que abordarei em detalhes a seguir.

Por que usar o fatiamento em Python?

O fatiamento em Python é uma das ferramentas mais eficientes e intuitivas para a manipulação de dados. Quer você esteja analisando conjuntos de dados, processando cadeias de caracteres ou manipulando matrizes, o fatiamento permite que você acesse e manipule subconjuntos de dados. 

Veja por que todo desenvolvedor deve dominá-la:

  1. Código limpo e conciso: O fatiamento elimina a necessidade de loops repetitivos ou condições complexas, resultando em um código mais curto, mais limpo e mais fácil de depurar.
  2. Processamento eficiente de dados: Ao contrário da indexação manual, o fatiamento é otimizado para desempenho. Os mecanismos internos do Python garantem que as operações de fatiamento sejam rápidas e eficientes em termos de memória.
  3. Versatilidade entre estruturas de dados: O fatiamento funciona perfeitamente em todo o ecossistema do Python, desde strings e listas até estruturas mais avançadas, como arrays NumPy e quadros de dados pandas.
  4. Aplicativos do mundo real: O fatiamento simplifica as tarefas diárias de codificação. Você precisa processar apenas um segmento de um conjunto de dados? Você pode extrair colunas específicas de uma tabela? Ou reverter uma cadeia de caracteres para um projeto de análise de texto? Você pode fatiar.

Métodos básicos de fatiamento em Python

Como eu disse, o fatiamento é um recurso essencial do Python, permitindo que os desenvolvedores extraiam partes de sequências como listas, strings e tuplas. O Python oferece duas maneiras principais de fatiar sequências sem importar nada: a sintaxe de fatiamento : e a função slice(). Entender os dois métodos é útil, pois é muito provável que você veja os dois métodos sendo usados.

Usando o : Sintaxe de fatiamento do Python

A sintaxe de corte sequence[start:stop:step] é a maneira mais comum de acessar partes de uma sequência. Cada parâmetro -start, stop e step- controla como o fatiamento é realizado:

  • start: Índice onde a fatia começa (inclusive). O padrão é 0 se for omitido.

  • stop: Índice em que a fatia termina (exclusivo). Se omitido, o padrão é o comprimento da sequência.

  • step: Determina o intervalo entre os elementos. Se omitido, o padrão é 1.

Vamos tentar um exemplo:

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

print(numbers[1:4])  
# Output: [20, 30, 40]  

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

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

Você também pode aplicar esse método de fatiamento a cadeias de caracteres:

text = "Python Slicing"  

print(text[7:])   
# Output: "Slicing"  

print(text[::-1]) 
# Output: "gnicilS nohtyP" (reverses the string)  

Você pode até mesmo extrair elementos alternativos de uma lista com o fatiamento:

data = [100, 200, 300, 400, 500]  

alternate = data[::2]  

print(alternate)  
# Output: [100, 300, 500]  

Em um cenário do mundo real, o fatiamento é particularmente útil quando você trabalha com grandes conjuntos de dados. Digamos que você esteja lidando com um arquivo de log com milhões de registros e precise extrair as últimas 1.000 entradas para análise:

logs = load_large_dataset()  
recent_logs = logs[-1000:]  

Essa abordagem evita o carregamento de todo o conjunto de dados na memória, garantindo que seu aplicativo seja executado com eficiência.

Usando a função slice() do Python

A função slice() do Python oferece uma definição alternativa de parâmetros de corte como objetos de corte reutilizáveis. Esses objetos encapsulam a lógica de fatiamento e podem ser aplicados em várias sequências.

Sintaxe e uso

A função slice() segue o formato:

slice(start, stop, step)  

Aqui está um exemplo:

# Create a slice object
slice_obj = slice(1, 4)

# Apply to a list
numbers = [10, 20, 30, 40, 50]
print(numbers[slice_obj])  # Output: [20, 30, 40]

# Apply to a string
text = "Python"
print(text[slice_obj])  # Output: "yth"  

Vantagens da função slice() do Python

Pessoalmente, gosto de usar a função slice() porque ela me permite reutilizar o mesmo objeto de fatia em diferentes sequências, evitando a lógica de fatia repetitiva. Isso também facilita a leitura e a manutenção do código.

Como você pode ver no exemplo a seguir, definimos um objeto de fatia uma vez e o reutilizamos em várias sequências. Isso elimina a necessidade de você especificar repetidamente os mesmos valores start, end e step. Isso também melhora a reutilização, pois a alteração dos limites da fatia em um único local atualiza automaticamente todos os usos dessa fatia

# Define a reusable slice
my_slice = slice(2, 5)

# Apply to multiple sequences
data_list = [100, 200, 300, 400, 500]
data_string = "SlicingExample"

print(data_list[my_slice])  # Output: [300, 400, 500]
print(data_string[my_slice])  # Output: "ici"  

Comparação de ambos os métodos

Ambos os métodos de fatiamento têm seu lugar no Python. A sintaxe é perfeita para operações concisas, enquanto o site slice() é inestimável para uma lógica de fatiamento reutilizável e dinâmica.

Recurso Sintaxe slice() Função
Facilidade de uso Simples para tarefas de corte rápido Melhor para lógica reutilizável
Legibilidade Ideal para fatias simples Adiciona clareza para cortes complexos
Versatilidade Limitado ao uso único no código Reutilizável em várias sequências

Python Slice em bibliotecas

O fatiamento não se limita às estruturas de dados incorporadas do Python - ele se estende a bibliotecas poderosas como NumPy e pandas, que são indispensáveis para a manipulação de dados. Embora os princípios básicos permaneçam consistentes, essas bibliotecas introduzem recursos adicionais de fatiamento adaptados às suas estruturas de dados.

Fatiamento em NumPy

As matrizes NumPy levam o fatiamento para o próximo nível, oferecendo ferramentas poderosas para a manipulação de conjuntos de dados grandes e multidimensionais. Uma diferença fundamental no fatiamento do NumPy são as visualizações em relação às cópias: o fatiamento de uma matriz NumPy normalmente retorna uma visualização (uma referência aos dados originais), não uma nova cópia. Esse comportamento garante a eficiência ao trabalhar com grandes conjuntos de dados, mas requer um manuseio cuidadoso para evitar alterações não intencionais.

Fatiamento de matrizes 1D

import numpy as np  

# Create a 1D array
array = np.array([10, 20, 30, 40, 50])

# Slice elements from index 1 to 3
print(array[1:4])  
# Output: [20 30 40]  

# Apply step
print(array[::2])  
# Output: [10 30 50]  

Cortar matrizes multidimensionais

Com matrizes multidimensionais, o fatiamento se aplica a cada eixo de forma independente.

# Create a 2D array
array_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Slice the first two rows and first two columns
print(array_2d[:2, :2])  
# Output:
# [[1 2]
#  [4 5]]  

# Slice the last column
print(array_2d[:, -1])  
# Output: [3 6 9]  

Benefícios do fatiamento do NumPy

  1. Eficiência de memória: As operações em fatias evitam a cópia de dados, acelerando os cálculos.
  2. Flexibilidade: O fatiamento multidimensional permite um controle preciso dos subconjuntos de dados.

Confira nosso curso Introdução à ciência de dados com Python para que você possa se aprofundar no NumPy.

Fatiamento em pandas

O pandas expande o fatiamento para trabalhar perfeitamente com DataFrames e Series, introduzindo maneiras mais intuitivas de acessar e manipular dados estruturados. Embora se baseie no fatiamento básico do Python, o fatiamento do pandas tem comportamentos exclusivos adaptados aos dados tabulares.

Cortar linhas e colunas em um DataFrame

import pandas as pd  

# Create a sample DataFrame
student_data = {'Name': ['Alice', 'Bob', 'Charlie'], 
                'Age': [25, 30, 35], 
                'Score': [85, 90, 95]}

students = pd.DataFrame(student_data

# Slice the first two rows
print(students[:2])  
# Output:
#      Name  Age  Score
# 0   Alice   25     85
# 1     Bob   30     90  

# Slice specific columns by name
print(students[['Name', 'Score']])  
# Output:
#       Name  Score
# 0    Alice     85
# 1      Bob     90
# 2  Charlie     95  

Usando .loc[] e .iloc[]

O pandas apresenta .loc[] (baseado em rótulo) e .iloc[] (baseado em índice) para um controle mais preciso.

# Slice using .iloc (index-based)
print(df.iloc[1:, 1:])  
# Output:
#    Age  Score
# 1   30     90
# 2   35     95  
# Slice using .loc (label-based)
print(df.loc[:1, ['Name', 'Age']])  
# Output:
#    Name  Age
# 0  Alice   25
# 1    Bob   30  

Principais diferenças no fatiamento de pandas

  • Faixa inclusiva: Diferentemente do fatiamento do Python, o .loc[] inclui o índice de parada para linhas e colunas.

  • Indexação mistaO pandas permite o fatiamento com rótulos e posições, oferecendo maior flexibilidade.

Para conhecer técnicas avançadas, explore nosso curso Manipulando DataFrames com pandas.

Fatiamento de Python com diferentes tipos de dados

Agora, vamos examinar exemplos de fatias do Python com diferentes tipos de dados para você ver como as fatias funcionam em diferentes estruturas de dados, como strings, listas, tuplas ou tipos de dados mais complexos.

Cortar cordas

As cadeias de caracteres em Python são sequências de caracteres, o que significa que você pode dividi-las como se fossem listas ou tuplas. Isso torna o fatiamento útil para extrair substrings, inverter texto ou formatar dados. Aqui estou usando :.

Basic string slicing# Extract a substring
text = "Python Slicing"
print(text[7:14])  # Output: Slicing  

# Reverse a string
print(text[::-1])  # Output: gnicilS nohtyP  

A função slice() permite que você crie objetos de fatia reutilizáveis para operações de fatia consistentes.

# Create a slice object
slicer = slice(7, 14)

# Apply the slice object
print(text[slicer])  # Output: Slicing  

Casos práticos de uso

  • Análise de dados: Extraia campos específicos de textos estruturados, como linhas CSV ou arquivos de registro.
  • Manipulação de texto: Formatar cadeias de caracteres removendo prefixos, sufixos ou caracteres indesejados.

Fatiamento de listas e tuplas

Listas e tuplas são estruturas de dados fundamentais do Python, e dividi-las pode simplificar seu trabalho.

Corte básico de listas

# Extract elements from a list
numbers = [10, 20, 30, 40, 50]

print(numbers[1:4])  
# Output: [20, 30, 40]  

# Skip elements using steps
print(numbers[::2])  
# Output: [10, 30, 50]  

Fatiamento de tuplas

As tuplas são imutáveis, mas o fatiamento ainda funciona para extrair partes delas.

# Slice a tuple
colors = ("red", "green", "blue", "yellow")

print(colors[:2])  
# Output: ('red', 'green')  

Filtragem e reordenação

O fatiamento é uma maneira útil de filtrar ou reordenar elementos.

# Filter odd-indexed elements
data = [5, 10, 15, 20, 25]

filtered = data[1::2]  
# Output: [10, 20]  

Fatiamento na análise de dados

Na análise de dados, o fatiamento desempenha um papel na extração e reorganização de subconjuntos de dados para análise posterior. Os casos de uso na análise de dados incluem a seleção de subconjuntos, em que você extrai linhas ou colunas relevantes para uma análise focada, e a transformação de dados, em que você pode reorganizar conjuntos de dados para melhor visualização ou geração de relatórios.

Fatiamento com NumPy

import numpy as np  

# Create a 2D array
data = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Extract the first two rows
print(data[:2, :])  
# Output:
# [[1 2 3]
#  [4 5 6]]  

Haveria muito mais a dizer sobre como trabalhar com o Numpy, mas você pode explorar o fatiamento do NumPy em profundidade com nosso curso Data Structures and Algorithms in Python.

Cortando com pandas

Uma opção é o pandas, que oferece recursos de fatiamento que permitem que você acesse e manipule linhas e colunas. Aqui está uma demonstração rápida de como cortar linhas e colunas em um DataFrame:

import pandas as pd  

# Create a DataFrame
df = pd.DataFrame({
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'Score': [85, 90, 95]
})

# Slice rows and columns
print(df.loc[:1, ['Name', 'Score']])  
# Output:
#      Name  Score
# 0   Alice     85
# 1     Bob     90  

Técnicas avançadas de fatiamento em Python

Depois de entender técnicas mais avançadas, você poderá manipular estruturas de dados com precisão e eficiência impressionantes. As técnicas a seguir ajudarão você a escrever um código Python mais limpo e mais rápido.

Modificação de listas com fatiamento

Um dos poderes menos conhecidos do fatiamento é sua capacidade de modificar listas diretamente. Você pode substituir, inserir ou excluir vários elementos em uma única linha de código.

Substitua os elementos:

numbers = [1, 2, 3, 4, 5]
numbers[1:4] = [20, 30, 40]

print(numbers)
# Output: [1, 20, 30, 40, 5]

Inserir elementos:

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

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

Excluir elementos:

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

print(numbers)
# Output: [1, 5]

Eficiência de memória

Entender se o Python cria uma cópia ou uma visualização é essencial para o gerenciamento de memória ao dividir estruturas de dados, especialmente com grandes conjuntos de dados. Você sabe que, com aslistas e cadeias de caracteres incorporadas do , o Slicing sempre cria uma cópia da sequência original, mas com as matrizes do NumPy, o slicing cria uma visualização, o que significa que tanto a matriz original quanto a fatia apontam para os mesmos dados na memória .

No código a seguir, nossa operação de fatiamento cria uma visualização da matriz NumPy original em vez de uma cópia. Isso significa que tanto o arr quanto o sliced fazem referência aos mesmos dados subjacentes na memória. Como resultado, a modificação de sliced afeta diretamente arr.

import numpy as np

arr = np.array([1, 2, 3, 4, 5])
sliced = arr[1:4]
sliced[0] = 99

print(arr)
# Output: [1, 99, 3, 4, 5]

Sempre tenha cuidado ao modificar fatias em bibliotecas externas para evitar efeitos colaterais não intencionais.

Considerando casos especiais

O fatiamento é eficiente, mas não é infalível. Aqui estão as armadilhas comuns:

Fatiamento fora do limite

numbers = [1, 2, 3]

print(numbers[5:10])
# Output: []

O corte fora dos limites não gera um erro - ele simplesmente retorna uma lista vazia.

Fatias vazias

numbers = [1, 2, 3]

print(numbers[1:1])
# Output: []

Quando os índices de início e parada são os mesmos, o resultado é uma fatia vazia.

Comportamento confuso das etapas

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

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

A etapa -2 divide a lista em ordem inversa, pulando cada segundo elemento.

Indexação negativa

A indexação negativa permite que você corte sequências a partir do final em vez do início.

Acesso aos últimos elementos

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

print(numbers[-1])  # Last element
# Output: 5

Reversão de uma lista

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

print(numbers[::-1])  # Reverse the list
# Output: [5, 4, 3, 2, 1]

A indexação negativa é particularmente útil quando você trabalha com comprimentos de sequência desconhecidos ou quando processa dados de trás para frente.

Fatiamento multidimensional

O fatiamento não se limita a estruturas unidimensionais. Em bibliotecas como a NumPy, você pode fatiar matrizes multidimensionais com precisão.

import numpy as np

matrix = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])

# Extract a sub-matrix
sub_matrix = matrix[:2, 1:]

print(sub_matrix)
# Output:
# [[2, 3],
#  [5, 6]]

Dicas para cortes multidimensionais:

  1. Use vírgulas para separar os cortes de cada dimensão.

  2. Evite misturar índices negativos e fatiamento padrão : de forma que você crie ambiguidade.

Dica de depuração: Sempre imprima fatias intermediárias ao depurar fatias multidimensionais para garantir que você esteja direcionando o subconjunto correto.

Erros comuns de fatiamento de Python

O fatiamento do Python é poderoso, mas não é imune a erros. Algumas armadilhas comuns podem atrapalhar até mesmo desenvolvedores experientes. Compreender esses problemas e suas soluções é essencial para que você tenha um código limpo e preciso.

Cometer erros de um para um

Um erro "off-by-one" ocorre quando os índices de início ou parada em suas operações de fatiamento incluem ou excluem elementos não intencionais. Esse é um dos problemas mais comuns no fatiamento e pode levar a resultados imprecisos ou a erros no seu código.

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

# Intending to extract [2, 3, 4]
slice_result = numbers[1:3]

print(slice_result)
# Output: [2, 3]

Aqui, o índice de parada exclui o elemento no índice 3, causando uma omissão não intencional. Como você pode evitar esse erro:

  • Entenda a regra do índice de parada: O índice de parada no fatiamento é exclusive, o que significa que não está incluído no resultado. Sempre adicione 1 ao índice de parada se você quiser incluir esse elemento.
  • Use comprimentos explícitos: Se a fatia incluir um intervalo específico de índices, confirme se o cálculo do início ao fim corresponde à sua intenção.

Aqui está um exemplo corrigido:

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

print(slice_result)
# Output: [2, 3, 4]

Valores de etapas mal compreendidos

Os valores de etapa determinam quantos elementos você deve ignorar entre os índices ao dividir. Se você não entender como funcionam os valores das etapas, poderá obter resultados inesperados, especialmente com etapas negativas.

Ignorar poucos ou muitos elementos

numbers = [1, 2, 3, 4, 5]
# Expecting every second element

step_result = numbers[::3]

print(step_result)
# Output: [1, 4]

Aqui, uma etapa de 3 pula muitos elementos, resultando em menos valores do que o esperado. O código a seguir é um exemplo de confusão de etapas negativas.

numbers = [1, 2, 3, 4, 5]
step_result = numbers[::-2]

print(step_result)
# Output: [5, 3, 1]

As etapas negativas invertem a lista e pulam elementos, mas se você não entender o comportamento delas, pode ser difícil prever o resultado. Aqui está o que eu considero quando penso em como usar os valores das etapas corretamente:

  • Planeje seus intervalos: Verifique se o valor da etapa está alinhado com o intervalo que você precisa. Para cada segundo elemento, use um step de 2.

  • Teste as etapas negativas isoladamente: Faça experiências com pequenos exemplos para confirmar que você entende como as fatias invertidas se comportam.

  • Combine valores de etapas com índices de início/parada: Use os índices de início e parada para limitar o intervalo da fatia ao aplicar valores de etapa.

Aqui está um exemplo corrigido de melhor uso das etapas:

Every second element:
numbers = [1, 2, 3, 4, 5]

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

Reverse with a step:
numbers = [1, 2, 3, 4, 5]

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

Não seguir as práticas recomendadas

Aqui estão algumas boas ideias para que você não cometa erros:

  1. Visualize suas fatias: Use comentários ou instruções de impressão para verificar a lógica de corte.

  2. Pratique com exemplos: Comece com listas pequenas e simples para testar sua compreensão dos parâmetros de início, parada e etapa.

  3. Use funções incorporadas para maior clareza: Em caso de dúvida, crie fatias com a função slice() para obter uma lógica de fatias mais explícita.

Conclusão

Ao longo deste guia, exploramos conceitos como:

  • Os conceitos básicos de sintaxe e parâmetros de fatiamento, incluindo start, stop, e step.

  • Técnicas interessantes, como a modificação de listas com fatiamento, levando em consideração as práticas de eficiência de memória e a manipulação de dados multidimensionais.

  • Erros que as pessoas cometem, como erros de um para um e mal-entendidos dos valores das etapas, e como evitá-los.

A melhor maneira de solidificar seu entendimento é por meio da prática. Faça experiências com conjuntos de dados do mundo real, teste casos extremos e desafie você mesmo indo além do básico.

O DataCamp está aqui para ajudar. Experimente nosso curso sobre Manipulação de dados com Python e outros cursos como Desenvolvimento de pacotes Python para ter uma experiência de aprendizado interativa. Quer você seja um iniciante ou esteja procurando aperfeiçoar suas técnicas, esses recursos podem ajudá-lo a dominar o fatiamento e outras habilidades.


Oluseye Jeremiah's photo
Author
Oluseye Jeremiah
LinkedIn

Escritor técnico especializado em IA, ML e ciência de dados, tornando ideias complexas claras e acessíveis.

Temas

Aprenda Python com o DataCamp

curso

Introduction to Python

4 hr
6M
Master the basics of data analysis with Python in just four hours. This online course will introduce the Python interface and explore popular packages.
Ver DetalhesRight Arrow
Iniciar curso
Ver maisRight Arrow
Relacionado

tutorial

Tutorial de indexação de lista Python()

Neste tutorial, você aprenderá exclusivamente sobre a função index().
Sejal Jaiswal's photo

Sejal Jaiswal

6 min

tutorial

Pandas Tutorial: DataFrames em Python

Explore a análise de dados com Python. Os DataFrames do Pandas facilitam a manipulação de seus dados, desde a seleção ou substituição de colunas e índices até a remodelagem dos dados.
Karlijn Willems's photo

Karlijn Willems

20 min

tutorial

21 ferramentas essenciais do Python

Aprenda sobre as ferramentas Python essenciais para o desenvolvimento de software, raspagem e desenvolvimento da Web, análise e visualização de dados e aprendizado de máquina.
Abid Ali Awan's photo

Abid Ali Awan

6 min

tutorial

Como aparar uma cadeia de caracteres em Python: Três métodos diferentes

Aprenda os fundamentos do corte de caracteres à esquerda e à direita de uma string em Python.
Adel Nehme's photo

Adel Nehme

5 min

tutorial

Tutorial de strings em Python

Neste tutorial, você aprenderá tudo sobre as cadeias de caracteres do Python: fatiamento e encadeamento, manipulação e formatação com a classe Formatter, cadeias de caracteres f, modelos e muito mais!
Sejal Jaiswal's photo

Sejal Jaiswal

16 min

tutorial

Tutorial de funções Python

Um tutorial sobre funções em Python que aborda como escrever funções, como chamá-las e muito mais!
Karlijn Willems's photo

Karlijn Willems

14 min

Ver maisVer mais