Como dividir listas em Python: Exemplos básicos e métodos avançados

As listas em Python são tipos de dados de matriz mutável dinâmica usados para armazenar itens ordenados. A divisão de listas é uma tarefa comum em Python, essencial para manipular e analisar dados com eficiência. 

Você pode aprender mais sobre análise de dados fazendo o curso Analista de dados com Python para aprimorar suas habilidades, que aborda os vários métodos de divisão de listas em Python, incluindo exemplos práticos e práticas recomendadas. 

O domínio dessas técnicas aprimorará suas habilidades de programação, tornando seus scripts mais eficientes e fáceis de manter. Vamos começar.

A resposta rápida: Como dividir uma lista em Python

• A maneira mais simples de dividir uma lista em Python é por meio do fatiamento com o operador :. Por exemplo, podemos dividir uma lista da seguinte forma: split_list = my_list[:5], que divide a lista no quinto índice. 

• O restante deste artigo explora outros métodos para dividir uma lista, incluindo compreensões de lista, itertools, numpy, entre outros. Cada método tem vantagens exclusivas e é adequado para diferentes casos de uso, como veremos.

O método mais comum: dividir uma lista usando o fatiamento

A divisão de uma lista no índice em Python é provavelmente a técnica de divisão de lista mais comum. O método de divisão garante que a lista em Python seja dividida em sublistas no índice especificado. Aqui está um guia passo a passo sobre como implementar o fatiamento em Python.

• Defina a lista: Suponha que você tenha uma lista [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] e queira dividi-la em um índice específico n.
• Identifique o índice de divisão: Especifique o índice n onde você deseja fatiar a lista.
• Crie a primeira fatia: No código abaixo, crie a first_slice para conter elementos desde o início da lista até o índice n, mas não o incluindo.
• Crie a segunda fatia: Defina second_slice para incluir todos os elementos do índice n até o final da lista.

# Define a list of integers from 1 to 10
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Index where the list will be split
n = 4

# Slice the list from the beginning to the nth index (not inclusive)
first_slice = my_list[:n]

# Slice the list from the nth index to the end
second_slice = my_list[n:]

# Print the first slice of the list
print("First slice:", first_slice)  # Output: [1, 2, 3, 4]

# Print the second slice of the list
print("Second slice:", second_slice)  # Output: [5, 6, 7, 8, 9, 10]

Exemplo de saída da lista dividida do Python por meio de fatiamento. Imagem do autor

Noções básicas sobre divisão de listas em Python

O fatiamento de listas em Python envolve a extração de uma sublista ou sublistas da lista principal. Quando quiser dividir uma lista em Python, você deve entender a sintaxe de divisão para compreender melhor a sublista adequada. A sintaxe de fatiamento inclui um início, uma parada e uma etapa.

# Example of slicing with start, stop, and step
slice[start:stop:step]

1. Início indica o início do índice do fatiamento.
2. Parada indica o fim do índice do fatiamento.
3. Etapa indica os intervalos entre os fatiamentos (1 por padrão).

# Define a list of integers from 1 to 10
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Slice the list from index 2 to 7 (index 2 inclusive, index 7 exclusive)
# This will include elements at index 2, 3, 4, 5, and 6
sublist = my_list[2:7]

# Print the sliced sublist
print(sublist) 

De acordo com o código acima, o fatiamento começa do índice 2 ao índice 6, pois a sublista não inclui o índice 7.

Exemplo de saída da sintaxe de fatiamento. Imagem do autor

Os benefícios da lista dividida do Python em termos de legibilidade e eficiência do código incluem:

• Simplificação do gerenciamento de dados: Ao dividir os dados em partes gerenciáveis, os cientistas de dados podem separar facilmente os dados de treinamento e de teste no aprendizado de máquina.
• Aumento da modularidade: Ao escrever funções com sublistas específicas, você aumenta a modularidade do seu código.
• Otimização do desempenho: O uso de partes menores da lista resulta em um processamento mais rápido em comparação com o uso de listas inteiras.
• Aumento da eficiência da memória: O método cria blocos sem copiar os dados subjacentes, o que o torna eficiente em termos de memória.

Técnicas diferentes para dividir listas em Python

Existem diferentes métodos para dividir uma lista em Python. Abaixo estão exemplos comuns que um profissional de dados pode encontrar durante sua prática.

Usando o fatiamento de listas

A divisão de lista por fatiamento do Python usa o operador : para dividir a lista no índice. Esse método utiliza a técnica de indexação para especificar o início e o fim do fatiamento.

As diferentes técnicas de fatiamento incluem as seguintes:

Fatiamento de índice positivo

Esse método usa os valores de índices positivos, começando da esquerda para a direita, para acessar os elementos da lista.

# Define a list of integers from 1 to 10
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Slice the list from index 2 to 7 (index 2 inclusive, index 7 exclusive)
# This will include elements at index 2, 3, 4, 5, and 6
sublist = my_list[2:7]

# Print the sliced sublist
print(sublist) 

Exemplo de saída da sintaxe de fatiamento usando índices positivos. Imagem do autor

Fatiamento de índice negativo

Esse método de lista dividida do Python usa os valores de índices negativos a partir do último elemento da lista, da direita para a esquerda.

# Define a list of integers from 1 to 10
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Slice the list to get the last 5 elements
sublist = my_list[-5:]

# Print the sliced sublist containing the last 5 elements
print(sublist)

# Slice the list to get all elements except the last 3
sublist = my_list[:-3]

# Print the sliced sublist containing all but the last 3 elements
print(sublist)

Exemplo de saída da sintaxe de fatiamento usando índices negativos. Imagem do autor

Usando o método de etapas

Essa abordagem usa condições específicas para dividir a lista ao acessar elementos diferentes.

# Define a list of integers from 1 to 10
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Slice the list to get every second element, starting from the beginning
sublist = my_list[::2]

# Print the sliced sublist containing every second element
print(sublist) 

# Slice the list to get every second element, starting from index 1
sublist = my_list[1::2]

# Print the sliced sublist containing every second element, starting from index 1
print(sublist) 

# Slice the list to get the elements in reverse order
sublist = my_list[::-1]

# Print the sliced sublist containing the elements in reverse order
print(sublist) 

Exemplo de saída da sintaxe de fatiamento usando o método de etapa.  Imagem do autor

Omissão de índices

Esse método divide a lista do Python, retornando apenas os elementos necessários em uma lista.

# Define a list of integers from 1 to 10
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Slice the list from the start to index 5 (index 5 not inclusive)
sublist = my_list[:5]

# Print the sliced sublist containing elements from the start to index 4
print(sublist) 

# Slice the list from index 5 to the end
sublist = my_list[5:]

# Print the sliced sublist containing elements from index 5 to the end
print(sublist) 

# Slice the list to get the entire list
sublist = my_list[:]

# Print the sliced sublist containing the entire list
print(sublist) 

Exemplo de saída da sintaxe de fatiamento omitindo os índices.  Imagem do autor

Uso de compreensões de lista

A compreensão de lista do Python permite que você divida a lista em partes com base nos valores da lista existente.

# Define a function to split a list into chunks of a specified size
def split_list(lst, chunk_size):
    # Use a list comprehension to create chunks
    # For each index 'i' in the range from 0 to the length of the list with step 'chunk_size'
    # Slice the list from index 'i' to 'i + chunk_size'
    return [lst[i:i + chunk_size] for i in range(0, len(lst), chunk_size)]

# Define a list of integers from 1 to 15
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

# Split the list into chunks of size 3 using the split_list function
chunks = split_list(my_list, 3)

# Print the resulting list of chunks
print(chunks)

O código acima usa a lista dividida do Python em n partes de tamanho três para retornar uma nova lista com listas de partes de 3 valores.

Exemplo de saída da lista dividida do Python usando a compreensão de divisão. Imagem do autor

Uso do Itertools

A lista dividida Python usando itertools usa o módulo do Python para transformar dados por meio de iteração.

# Import the islice function from the itertools module
from itertools import islice
# Define a function to yield chunks of a specified size from an iterable
def chunks(iterable, size):
    # Create an iterator from the input iterable
    iterator = iter(iterable)
    
    # Loop over the iterator, taking the first element in each iteration
    for first in iterator:
        # Yield a list consisting of the first element and the next 'size-1' elements from the iterator
        yield [first] + list(islice(iterator, size - 1))

# Define a list of integers from 1 to 15
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

# Convert the generator returned by the chunks function into a list of chunks
chunked_list = list(chunks(my_list, 3))

# Print the resulting list of chunks
print(chunked_list)

Exemplo de saída da lista dividida do Python usando itertools. Imagem do autor

Uso do numpy

A biblioteca numpy do Python é útil para dividir matrizes em sublistas. A função .array_split() permite divisões quando você especifica o número de divisões.

# Import the numpy library and alias it as np
import numpy as np

# Define a list of integers from 1 to 15
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

# Use numpy's array_split function to split the list into 3 chunks
chunks = np.array_split(my_list, 3)

# Convert each chunk back to a regular list and print the resulting list of chunks
print([list(chunk) for chunk in chunks])

Exemplo de saída da lista dividida do Python usando numpy. Imagem do autor

Divisão de listas em partes

A função Python a seguir também permite que você divida uma lista em partes. Esses blocos podem ser personalizados, dependendo do número que o usuário precisar.

# Define a function to split a list into chunks of a specified size
def split_into_chunks(lst, chunk_size):
    chunks = []  # Initialize an empty list to store chunks
    
    # Iterate over the list with a step of chunk_size
    for i in range(0, len(lst), chunk_size):
        # Slice the list from index 'i' to 'i + chunk_size' and append it to chunks
        chunks.append(lst[i:i + chunk_size])
    
    return chunks  # Return the list of chunks

# Define a list of integers from 1 to 16
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16]

# Split the list into chunks of size 4 using the split_into_chunks function
chunks = split_into_chunks(my_list, 4)

# Print the resulting list of chunks
print(chunks)

Exemplo de saída da lista dividida do Python em partes. Imagem do autor

Divisão de listas com base em condições

Quando quiser dividir uma lista em Python, você pode definir algumas regras/condições para a sublista. Esse método permite que você crie uma sublista que atenda a essas condições.

# Define a list of integers from 1 to 15
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

# List comprehension to filter elements divisible by 3
div_3 = [x for x in my_list if x % 3 == 0]

# List comprehension to filter elements not divisible by 3
not_div_3 = [x for x in my_list if x % 3 != 0]

# Print the list of elements divisible by 3
print(div_3)

# Print the list of elements not divisible by 3
print(not_div_3)

Exemplo de saída da lista dividida do Python com base em condições. Imagem do autor

Uso de loops for

Os loops for também podem ser usados para dividir listas em Python com base em condições e por meio de iteração.

# Define a function to split a list into sub-lists of size n
def split_by_n(lst, n):
    # Use a list comprehension to create sub-lists
    # For each index 'i' in the range from 0 to the length of the list with step 'n'
    # Slice the list from index 'i' to 'i + n'
    return [lst[i:i + n] for i in range(0, len(lst), n)]

# Define a list of integers from 1 to 15
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

# Split the list into sub-lists of size 5 using the split_by_n function
sub_lists = split_by_n(my_list, 5)

# Print the resulting list of sub-lists
print(sub_lists) 

Exemplo de saída da lista dividida do Python usando loops for. Imagem do autor

Uso da função zip()

Você também pode usar a função zip() em Python para dividir a lista por meio do pareamento.

# Define two lists: list1 containing integers from 1 to 10, and list2 containing letters from 'a' to 'j'
list1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
list2 = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j']

# Use the zip function to pair corresponding elements from list1 and list2 into tuples
paired = list(zip(list1, list2))

# Print the list of paired tuples
print(paired)

Exemplo de saída da lista dividida do Python usando a função zip(). Imagem do autor

Uso da função enumerate()

A função enumerate() divide as listas do Python usando condições de índice. Essa função usa a iteração para dividir uma lista em partes iguais.

# Define a list of integers from 1 to 15
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]

# Define the chunk size for splitting the list
chunk_size = 5

# Create a list of empty lists, one for each chunk
split_list = [[] for _ in range(chunk_size)]

# Iterate over the elements and their indices in my_list
for index, value in enumerate(my_list):
    # Calculate the index of the sublist where the current value should go using modulo operation
    sublist_index = index % chunk_size
    
    # Append the current value to the corresponding sublist in split_list
    split_list[sublist_index].append(value)

# Print the list of sublists after splitting my_list into chunks
print(split_list)

Exemplo de saída da lista dividida do Python usando a função enumerate(). Imagem do autor

Divisão de string em uma lista no Python

Uso do método split()

O método split() divide uma string em uma lista no Python, com um delimitador especificado. O método retorna as substrings de acordo com o número de delimitadores na string fornecida.

# Define a string
myString = "Goodmorning to you"

# Split the string into a list of words based on whitespace (default separator)
my_list = myString.split()

# Print the resulting list
print(my_list) 

Exemplo de saída de string dividida em lista no Python usando o método split(). Imagem do autor

Uso do método splitlines()

O método splitlines() divide a string em uma lista Python com base no caractere de nova linha.

# Define a string with newline characters
myString = "Goodmorning\nto\nyou"

# Split the string into a list of lines based on newline characters
my_list = myString.splitlines()

# Print the resulting list
print(my_list)

Exemplo de saída de string dividida em lista no Python usando o método splitlines(). Imagem do autor

Uso do método partition()

O método partition() divide as strings em listas no Python usando o separador fornecido. Esse método retorna três partes: a string antes do separador, o separador e tudo após o separador como uma lista.

# Define a string with a delimiter '/'
myString = "Goodmorning/to you"

# Use the partition() method to split the string into three parts based on the first occurrence of '/'
my_list = myString.partition('/')

# Print the resulting tuple
print(my_list)  # Output: ('Goodmorning', '/', 'to you')

Exemplo de saída de string dividida em lista do Python usando o método partition(). Imagem do autor

Uso de expressões regulares

No Python, as expressões regulares também podem ser usadas para dividir uma string em uma lista. O exemplo abaixo mostra como você pode fazer isso usando espaços em branco.

# Import the 're' module for regular expressions
import re

# Define a string
myString = "Goodmorning to you"

# Use re.split() to split the string based on whitespace ('\s' matches any whitespace character)
# Returns a list of substrings where the string has been split at each whitespace
my_list = re.split('\s', myString)

# Print the resulting list
print(my_list)

Exemplo de saída de string dividida em lista do Python usando expressões regulares. Imagem do autor

Tabela de comparação

Aqui está uma tabela para que você possa ver rapidamente quando diferentes técnicas podem ser úteis. Em termos práticos, a mesma técnica pode funcionar em muitos casos sem diferenças acentuadas no desempenho, portanto, as indicações de quando uma determinada técnica é mais útil podem ser um pouco exageradas. 

Armadilhas comuns e como evitá-las

Um profissional de dados pode encontrar alguns erros comuns ao lidar com listas divididas em Python. Abaixo estão algumas das armadilhas comuns e como evitá-las.

Erros off-by-one

O erro off-by-one ocorre durante o fatiamento básico quando você inclui menos ou mais índices do que o necessário na lista.

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

# Trying to get sublist from index 2 to 4, inclusive
sublist = my_list[2:5]  # Correct: my_list[2:5]
print(sublist)  # Output: [3, 4, 5]

# Incorrect usage:
sublist = my_list[2:4]  # Incorrect, excludes index 4
print(sublist)  # Output: [3, 4]

Para evitar esse erro, você deve entender a sequência de indexação em Python e saber o que incluir ou excluir ao indexar.

Erros com pacotes usados

Você também pode encontrar erros nos pacotes, especialmente quando o método de divisão requer módulos Python. Os exemplos incluem os pacotes numpy, re e itertools. Para evitar esse erro, certifique-se de que os pacotes sejam carregados corretamente e usados como versões compatíveis.

Tratamento de casos extremos

Casos extremos podem ocorrer na divisão de lista do Python quando você não levar em conta alguns cenários. Por exemplo, o trecho abaixo indica uma função que tenta dividir as listas em partes de 5 quando a lista contém apenas 4 itens.

import numpy as np

my_list = [1, 2, 3, 4]
chunks = np.array_split(my_list, 5)
print(chunks)

Para evitar esse erro, use instruções condicionais para lidar com o caso extremo, conforme mostrado abaixo.

import numpy as np

my_list = [1, 2, 3, 4]
if len(my_list) < 5:
    chunks = [my_list]
else:
    chunks = np.array_split(my_list, 5)
print(chunks)

Manuseio de caracteres especiais

Se você não conseguir lidar com caracteres especiais corretamente, também poderá ocorrer erros ao dividir listas de strings no Python. Esses caracteres especiais incluem espaços em branco, vírgulas ou alfanuméricos.

O exemplo abaixo mostra como você pode evitar esse erro especificando o caractere para dividir a lista de strings.

# Example list with special characters
my_list = ["apple, orange", "dog, mouse", "green, blue"]

# Splitting each string by the comma
split_list = [s.split(",") for s in my_list]
print(split_list)

Práticas recomendadas e diretrizes

Como a lista dividida em Python é uma operação comum na análise de dados, é importante que você siga algumas práticas para garantir a eficiência. Essas recomendações incluem:

• Manter a imutabilidade sempre que possível: Se a lista original não deve ser modificada, certifique-se de que suas operações de fatiamento não alterem a lista original. O fatiamento cria novas listas, portanto, isso geralmente não é um problema, mas você deve estar ciente disso ao trabalhar com estruturas de dados mais complexas.
• Otimizar para desempenho: Ao lidar com listas grandes, esteja atento às implicações de desempenho. Em geral, o fatiamento é eficiente, mas a cópia desnecessária de listas grandes pode levar a gargalos de desempenho.
• Lidar com casos extremos: Considere casos extremos, como uma lista vazia, divisão no início ou no final da lista e índices inválidos. Certifique-se de que seu código possa lidar com esses cenários de forma adequada.
• Incluir tratamento de erros e validação: O tratamento de erros é especialmente importante quando você deseja dividir uma lista em várias listas no Python, para que seu código não seja interrompido e crie surpresas. 

O curso de Programação em Python do DataCamp oferece uma explicação detalhada das práticas recomendadas para escrever código de forma eficiente, considerando conceitos comuns como tratamento de erros e desempenho. 

Técnicas avançadas de divisão de listas

A divisão de listas pode ser levada a um nível avançado com a utilização de vários métodos que oferecem mais controle e flexibilidade. 

Dividir a lista em várias listas

Você pode dividir a lista Python em várias listas especificando a divisão em índices específicos. Por exemplo, o código abaixo divide a lista no seguinte índice 2, 5, 7.

def split_at_indices(lst, indices):
    result = []
    prev_index = 0
    for index in indices:
        result.append(lst[prev_index:index])
        prev_index = index
    result.append(lst[prev_index:])
    return result

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
indices = [2, 5, 7]
split_lists = split_at_indices(my_list, indices)
print(split_lists)

Exemplo de saída da lista dividida do Python em várias listas. Imagem do autor

Dividir a lista em partes iguais

Você também pode usar uma biblioteca integrada, como a 'numpy', para dividir uma lista do Python em partes iguais com base no número de partes que você deseja.

import numpy as np

my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15]
num_parts = 3
split_lists = np.array_split(my_list, num_parts)
print([list(arr) for arr in split_lists])

Dividir uma lista pela metade

Você pode usar o fatiamento para dividir a lista do Python pela metade.

def split_in_half(lst):
    # Calculate the midpoint index of the list
    mid_index = len(lst) // 2
    # Return the two halves of the list
    return lst[:mid_index], lst[mid_index:]

# Example list
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Split the list into two halves
first_half, second_half = split_in_half(my_list)
print(first_half)
print(second_half)

No caso de uma lista com um número ímpar de elementos, você pode especificar o índice a ser incluído na primeira metade.

def split_in_half(lst):
    # Calculate the midpoint index of the list, including the middle element in the first half if the length is odd
    mid_index = (len(lst) + 1) // 2
    # Return the two halves of the list
    return lst[:mid_index], lst[mid_index:]

# Example list
my_list = [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Split the list into two halves, handling odd-length
first_half, second_half = split_in_half(my_list)
print(first_half) 
print(second_half) 

O Python Developer também oferece insights sobre como escrever códigos avançados que ajudarão você a entender as técnicas avançadas de divisão de listas.

Conclusão

Há diferentes métodos para dividir listas em Python. Cada método depende do tipo de lista e da preferência do usuário por eficiência. Como profissional de dados, é importante selecionar o método de lista dividida adequado à sua análise.

Para obter um entendimento completo da divisão de lista do Python, você pode aprender mais em nosso curso Fundamentos de Python. Você também pode fazer o curso Introdução ao Python para garantir que domine a operação de listas e outros tipos de dados em Python. A Folha de dicas de Python para iniciantes também é útil quando você quer dar uma olhada em como dividir uma lista em Python.