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

As listas Python são tipos de dados dinâmicos e mutáveis usados para armazenar itens ordenados. Dividir listas é uma tarefa comum em Python, essencial para manipular e analisar dados de forma eficiente. 

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

Dominar essas técnicas vai melhorar 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 é usando o operador de corte ( : ). Por exemplo, podemos dividir uma lista assim: split_list = my_list[:5], que divide a lista no quinto índice. 

• O resto deste artigo fala sobre outras maneiras de dividir uma lista, como compreensões de lista, itertools, numpy e muito mais. Cada método tem vantagens únicas e é adequado para diferentes casos de uso, como veremos.

O jeito mais comum: dividir uma lista usando o corte

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

• Defina a lista: Digamos que você tem uma lista [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] e quer dividi-la em um índice específico n.
• Identifique o Índice de Divisão: Diz o índice n onde você quer dividir a lista.
• Criar a primeira fatia: No código abaixo, crie um first_slice o para conter elementos desde o início da lista até, mas não incluindo, o índice n.
• Criar 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)

# Print the second slice of the list
print("Second slice:", second_slice)

# Expected output:
# First slice: [1, 2, 3, 4]
# Second slice: [5, 6, 7, 8, 9, 10]

Entendendo a divisão de listas em Python

Cortar listas em Python é quando você pega uma ou mais sublistas da lista principal. Quando você quiser dividir uma lista no Python, precisa entender a sintaxe de divisão para entender melhor a sublista correta. A sintaxe de divisão é slice[start:stop:step].

1. Início indica o início do índice do corte.
2. Stop indica o fim do índice do corte
3. O passo mostra os intervalos entre os cortes (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) 

# Expected output: [3, 4, 5, 6, 7]

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

Os benefícios da divisão de listas em Python na legibilidade e eficiência do código incluem:

• Simplificando o gerenciamento de dados: Ao dividir os dados em partes fáceis de lidar, os cientistas de dados podem separar facilmente os dados de treinamento e teste no machine learning.
• Aumentando a modularidade: Escrever funções com sublistas específicas melhora a modularidade do seu código.
• Otimizando o desempenho: Usar pedaços menores da lista faz com que o processamento seja mais rápido do que usar listas inteiras.
• Aumentando a eficiência da memória: O método cria blocos sem copiar os dados subjacentes, tornando-o eficiente em termos de memória.

Diferentes técnicas para dividir listas em Python

Tem vários jeitos de dividir uma lista no Python. Abaixo estão alguns exemplos comuns que um profissional de dados pode encontrar durante sua prática.

Usando o corte de lista

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

As diferentes técnicas para cortar incluem o seguinte:

Corte de índice positivo

Esse método usa os valores positivos dos índices, 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) 

# Expected output: [3, 4, 5, 6, 7]

Corte de índice negativo

Esse método de divisão de lista do Python usa os valores negativos dos índices, começando pelo ú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)

# Expected output:
# [6, 7, 8, 9, 10]
# [1, 2, 3, 4, 5, 6, 7]

Usando o método passo a passo

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

# 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) 

# Expected output:
# [1, 3, 5, 7, 9]
# [2, 4, 6, 8, 10]
# [10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

Omitindo índices

Esse método divide a lista Python, devolvendo só 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) 

# Expected output:
# [1, 2, 3, 4, 5]
# [6, 7, 8, 9, 10]
# [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

Usando compreensões de lista

A compreensão de listas em Python permite dividir uma 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)

# Expected output:
# [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15]]

n O código acima usa o Python para dividir a lista em trechos de três valores e criar uma nova lista com trechos de três valores.

Usando Itertools

A divisão de listas em Python usando itertools usa o módulo 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)

# Expected output:
# [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12], [13, 14, 15]]

Usando numpy

A biblioteca numpy em Python é útil para dividir matrizes em sublistas. A função .array_split() permite divisões ao especificar 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])

# Expected output:
# [[np.int32(1), np.int32(2), np.int32(3), np.int32(4), np.int32(5)], [np.int32(6), np.int32(7), np.int32(8), np.int32(9), np.int32(10)], [np.int32(11), np.int32(12), np.int32(13), np.int32(14), np.int32(15)]]

Dividindo listas em partes

A função Python a seguir também permite dividir 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)

# Expected output:
# [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]

Dividindo listas com base em condições

Quando você quiser dividir uma lista no Python, 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)

# Expected output:
# [3, 6, 9, 12, 15]
# [1, 2, 4, 5, 7, 8, 10, 11, 13, 14]

Usando 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) 

# Expected output:
# [[1, 2, 3, 4, 5], [6, 7, 8, 9, 10], [11, 12, 13, 14, 15]]

Usando a função zip()

Você também pode usar a função zip() no Python para dividir a lista por pares.

# 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)

# Expected output:
# [(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e'), (6, 'f'), (7, 'g'), (8, 'h'), (9, 'i'), (10, 'j')]

Usando a função enumerate()

A função enumerate() divide as listas Python usando condições de índice. Essa função usa 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)

# Expected output:
# [[1, 6, 11], [2, 7, 12], [3, 8, 13], [4, 9, 14], [5, 10, 15]]

Python divide string em lista

Usando o método split()

O método split() divide uma string em uma lista no Python, usando um delimitador específico. O método devolve as subcadeias de caracteres de acordo com o número de delimitadores na cadeia de caracteres dada.

# 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) 

# Expected output: ['Goodmorning', 'to', 'you']

Usando o método splitlines()

O método splitlines() divide uma 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)

# Expected output: ['Goodmorning', 'to', 'you']

Usando o método partition()

O método partition() divide strings em listas no Python usando o separador que você der. Esse método devolve três partes: a string antes do separador, o separador e tudo depois do 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)

# Expected output: ('Goodmorning', '/', 'to you')

Usando expressões regulares

Em Python, expressões regulares também podem ser usadas para dividir uma string em uma lista. O exemplo abaixo mostra como 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)

# Expected output: ['Goodmorning', 'to', 'you']

Tabela comparativa

Aqui está uma tabela para você ver rapidamente quando as diferentes técnicas podem ser úteis. Na prática, a mesma técnica pode funcionar em muitos casos sem grandes diferenças de desempenho, então as indicações sobre quando uma técnica específica é mais útil podem ser um pouco exageradas.