Cómo dividir listas en Python: Ejemplos básicos y métodos avanzados

Las listas de Python son tipos de datos de arreglo mutables dinámicos que se utilizan para almacenar elementos ordenados. Dividir listas es una tarea habitual en Python, esencial para manipular y analizar datos de forma eficiente. 

Puedes obtener más información sobre el análisis de datos siguiendo el programa de analista de datos con Python para perfeccionar tus habilidades, que profundiza en los distintos métodos para dividir listas en Python, incluyendo ejemplos prácticos y mejores prácticas. 

Dominar estas técnicas mejorará tus habilidades de programación, haciendo que tus scripts sean más eficientes y fáciles de mantener. Empecemos.

La respuesta rápida: Cómo dividir una lista en Python

• La forma más sencilla de dividir una lista en Python es mediante el operador de corte ( : ). Por ejemplo, podemos dividir una lista de esta manera: split_list = my_list[:5], lo que divide la lista en el quinto índice. 

• El resto de este artículo explora otros métodos para dividir una lista, incluyendo comprensiones de listas, itertools, numpy, y más. Cada método tiene ventajas únicas y es adecuado para diferentes casos de uso, como veremos.

El método más común: dividir una lista utilizando el corte

La división de listas en Python por índice es probablemente la técnica más común para dividir listas. El método slicing garantiza que la lista de Python se divida en sublistas en el índice especificado. Aquí tienes una guía paso a paso sobre cómo implementar el slicing en Python.

• Define la lista: Supongamos que tienes una lista [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] y quieres dividirla en un índice específico n.
• Identifica el índice de división: Especifica el índice n donde deseas dividir la lista.
• Crea la primera porción: En el código siguiente, crea un first_slice para contener los elementos desde el principio de la lista hasta el índice n, sin incluirlo.
• Crea la segunda porción: Define second_slice para incluir todos los elementos desde el índice n hasta el final de la 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]

Comprender la división de listas en Python

El corte de listas en Python consiste en extraer una sublista o sublistas de la lista principal. Cuando quieras dividir una lista en Python, debes comprender la sintaxis de corte para entender mejor la sublista adecuada. La sintaxis de corte es slice[start:stop:step].

1. Start indica el inicio del índice del corte.
2. Stop indica el final del índice del corte.
3. El paso indica los intervalos entre cortes (1 por defecto).

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

Según el código anterior, el corte comienza desde el índice 2 hasta el índice 6, ya que la sublista no incluye el índice 7.

Las ventajas de la función split de Python en cuanto a legibilidad y eficiencia del código incluyen:

• Simplificación de la gestión de datos: Al dividir los datos en fragmentos manejables, los científicos de datos pueden separar fácilmente los datos de entrenamiento y prueba en machine learning.
• Mayor modularidad: Escribir funciones con sublistas específicas mejora la modularidad de tu código.
• Optimización del rendimiento: El uso de fragmentos de listas más pequeños da como resultado un procesamiento más rápido en comparación con el uso de listas completas.
• Mejora de la eficiencia de la memoria: El método crea fragmentos sin copiar los datos subyacentes, lo que lo hace eficiente en cuanto a memoria.

Diferentes técnicas para dividir listas en Python

Existen diferentes métodos para dividir una lista en Python. A continuación se muestran ejemplos comunes con los que un profesional de datos puede encontrarse durante su práctica.

Uso del corte de listas

El corte de listas en Python utiliza el operador : para dividir la lista en el índice. Este método utiliza la técnica de indexación para especificar el inicio y el final del corte.

Las diferentes técnicas para cortar incluyen las siguientes:

División positiva del índice

Este método utiliza los valores positivos de los índices, comenzando de izquierda a derecha, para acceder a los elementos de la 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]

Segmentación de índice negativo

Este método de Python para dividir listas utiliza valores de índice negativos que comienzan por el último elemento de la lista, de derecha a izquierda.

# 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 el método por pasos

Este enfoque utiliza condiciones específicas para dividir la lista al acceder a 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]

Omisión de índices

Este método divide la lista de Python devolviendo solo los elementos necesarios en una 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]

Uso de comprensiones de listas

La comprensión de listas en Python permite dividir una lista en fragmentos basándose en los valores de la 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]]

El código anterior utiliza Python para dividir la lista en fragmentos de tres elementos con el método n y devolver una nueva lista con fragmentos de tres valores.

Uso de Itertools

La división de listas en Python mediante itertools utiliza el módulo Python para transformar datos mediante iteración.

# 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

La biblioteca numpy de Python es útil para dividir arreglos en sublistas. La función .array_split() permite dividir al especificar el número de divisiones.

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

Dividir listas en fragmentos

La siguiente función de Python también permite dividir una lista en fragmentos. Estos fragmentos pueden personalizarse en función del número que necesites.

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

Dividir listas según condiciones

Cuando quieras dividir una lista en Python, puedes establecer algunas reglas/condiciones para la sublista. Este método te permite crear una sublista que cumpla estas condiciones.

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

Uso de bucles «Bucle for»

Los bucles «Bucle for» también pueden utilizarse para dividir listas en Python en función de condiciones y mediante iteración.

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

Uso de la función zip()

También puedes utilizar la función zip() en Python para dividir la lista mediante emparejamientos.

# 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 la función enumerate()

La función enumerate() divide las listas de Python utilizando condiciones de índice. Esta función utiliza la iteración para dividir una lista en partes iguales.

# 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 una cadena en una lista

Usando el método split()

El método split() divide una cadena en una lista en Python, dado un delimitador especificado. El método devuelve las subcadenas según el número de delimitadores en la cadena 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 el método splitlines()

El método splitlines() divide una cadena en una lista de Python basándose en el carácter de nueva línea.

# 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 el método partition()

El método partition() divide las cadenas en listas en Python utilizando el separador dado. Este método devuelve tres partes: la cadena antes del separador, el separador y todo lo que hay después del separador como una 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')

Uso de expresiones regulares

En Python, también se pueden utilizar expresiones regulares para dividir una cadena en una lista. El siguiente ejemplo muestra cómo hacerlo utilizando espacios en blanco.

# 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']

Tabla comparativa

Aquí tienes una tabla para que puedas ver de un vistazo cuándo pueden resultar útiles las diferentes técnicas. En la práctica, la misma técnica puede funcionar en muchos casos sin diferencias notables en el rendimiento, por lo que las indicaciones sobre cuándo es más útil una técnica concreta pueden ser algo exageradas.