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

Las listas de Python son datos de tipo matriz dinámica mutable que se utilizan para almacenar elementos ordenados. Dividir listas es una tarea habitual en Python, esencial para manipular y analizar datos con eficiencia. 

Puedes aprender más sobre el análisis de datos realizando el curso Analista de datos con Python para perfeccionar tus habilidades. Este curso se sumerge en los distintos métodos para dividir listas en Python e incluye ejemplos prácticos y prácticas recomendadas. 

Dominar estas técnicas mejorará tus habilidades de programación y hará que tus scripts sean más eficientes y mantenibles. ¡Empecemos!

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

• La forma más sencilla de dividir una lista en Python es aplicándole slicing con el operador :. Por ejemplo, podemos dividir una lista de esta forma: split_list = my_list[:5], que divide la lista en el quinto índice. 

• El resto de este artículo explora otros métodos para dividir una lista, como 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 slicing

La división de listas de Python en un índice es probablemente la técnica de división de listas más común. El método slicing garantiza que la lista 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 concreto, n.
• Identifica el índice de división: Especifica el índice n, donde quieres aplicar el slicing a la lista.
• Crea el primer slicing: En el código siguiente, crea first_slice para que contenga elementos desde el principio de la lista hasta el índice n, pero sin incluirlo.
• Crea el segundo slicing: Define second_slice para que incluya 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)  # Output: [1, 2, 3, 4]

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

Ejemplo de salida de una lista dividida en Python mediante slicing. Imagen del autor

Comprender la división de listas en Python

El slicing de listas en Python consiste en extraer sublistas de la lista principal. Cuando quieras dividir una lista en Python, debes entender la sintaxis de slicing para comprender mejor la sublista adecuada. La sintaxis de slicing incluye un inicio, un fin y un paso.

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

1. Start indica el inicio del índice del slicing.
2. Stop indica el fin del índice del slicing.
3. Step indica los intervalos o pasos del slicing (1 de forma predeterminada).

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

Según el código anterior, el slicing empieza en el índice 2 y va hasta el índice 6, ya que la sublista no incluye el índice 7.

Ejemplo de salida de la sintaxis de slicing. Imagen del autor

Entre las ventajas de la lista dividida de Python en cuanto a legibilidad y eficiencia del código se incluyen las siguientes:

• 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 los de prueba en el machine learning.
• Aumento de la modularidad: Escribir funciones con sublistas específicas mejora la modularidad de tu código.
• Optimización del rendimiento: Si utilizas fragmentos de lista de menor tamaño, el procesamiento es más rápido que si utilizas listas enteras.
• Aumento de la eficiencia de la memoria: El método crea fragmentos sin copiar los datos subyacentes, por lo que hace un uso eficiente de la memoria.

Diferentes técnicas para dividir listas en Python

Existen distintos métodos para dividir una lista en Python. A continuación se presentan ejemplos comunes con los que pueden encontrarse los profesionales de los datos.

Utilizar el slicing de listas

El slicing 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 slicing.

Las diferentes técnicas de slicing son las siguientes:

Slicing de índice positivo

Este método utiliza los valores de los índices positivos, 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) 

Ejemplo de salida de la sintaxis de slicing utilizando índices positivos. Imagen del autor

Slicing de índice negativo

Este método de Python para dividir listas utiliza los valores de los índices negativos empezando 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)

Ejemplo de salida de la sintaxis de slicing utilizando índices negativos. Imagen del autor

Utilizar el método de paso

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

Ejemplo de salida de la sintaxis de slicing mediante el método de paso.  Imagen del autor

Omitir índices

Este método aplica slicing a la lista Python devolviendo solo los elementos necesarios de 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) 

Ejemplo de salida de la sintaxis de slicing omitiendo los índices.  Imagen del autor

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

El código anterior utiliza la lista dividida de Python en n fragmentos de tamaño tres para devolver una nueva lista con fragmentos de 3 valores.

Ejemplo de salida de una lista dividida en Python utilizando la comprensión. Imagen del autor

Utilizar itertools

La lista dividida de Python mediante itertools utiliza el módulo de 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)

Ejemplo de salida de una lista dividida en Python utilizando itertools. Imagen del autor

Utilizar numpy

La biblioteca numpy de Python es útil para dividir matrices en sublistas. La función .array_split() permite divisiones cuando se especifica 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])

Ejemplo de salida de una lista dividida en Python utilizando numpy. Imagen del autor

Dividir listas en fragmentos

La siguiente función de Python también permite dividir una lista en fragmentos. Estos fragmentos podrían personalizarse en función del número que necesite el usuario.

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

Ejemplo de salida de la lista dividida en fragmentos en Python. Imagen del autor

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)

Ejemplo de salida de una lista dividida en Python basada en condiciones. Imagen del autor

Utilizar bucles for

Los bucles for también se pueden utilizar 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) 

Ejemplo de salida de una lista dividida en Python utilizando bucles for. Imagen del autor

Utilizar la función zip()

También puedes utilizar la función zip() de Python para dividir la 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)

Ejemplo de salida de una lista dividida en Python utilizando la función zip(). Imagen del autor

Utilizar 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 fragmentos 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)

Ejemplo de salida de una lista dividida en Python utilizando la función enumerate(). Imagen del autor

Cadena de Python dividida en lista

Utilizar 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 de 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) 

Ejemplo de salida de cadena dividida en lista en Python utilizando el método split(). Imagen del autor

Utilizar el método splitlines()

El método splitlines() divide la cadena en una lista en Python en función del 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)

Ejemplo de salida de cadena dividida en lista en Python utilizando el método splitlines(). Imagen del autor

Utilizar el método partition()

El método partition() divide 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 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')

Ejemplo de salida de cadena dividida en lista en Python utilizando el método partition(). Imagen del autor

Utilizar expresiones regulares

En Python, las expresiones regulares también se pueden utilizar para dividir una cadena en una lista. El ejemplo siguiente 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)

Ejemplo de salida de cadena dividida en lista en Python utilizando expresiones regulares. Imagen del autor

Tabla comparativa

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

Errores comunes y cómo evitarlos

Los profesionales de los datos pueden encontrarse con algunos errores comunes al manejar listas divididas en Python. A continuación te indicamos algunos de los errores más comunes y cómo evitarlos.

Errores por uno

El error por uno se produce durante el slicing básico cuando incluyes menos o más índices de los necesarios en la 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 este error, debes comprender la secuencia de indexación en Python y saber qué incluir o excluir al indexar.

Errores con los paquetes utilizados

También puedes encontrar errores con los paquetes, especialmente cuando el método de división requiere módulos de Python. Algunos ejemplos son los paquetes numpy, re y itertools. Para evitar este error, asegúrate de que los paquetes se carguen correctamente y se utilicen como versiones compatibles.

Tratamiento de casos extremos

Pueden darse casos extremos en la división de listas en Python cuando no tienes en cuenta algunas situaciones. Por ejemplo, el fragmento siguiente indica una función que intenta dividir listas en fragmentos de 5 cuando la lista solo contiene 4 elementos.

import numpy as np

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

Para evitar este error, utiliza sentencias condicionales para tratar el caso extremo, como se muestra a continuación.

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)

Tratamiento de caracteres especiales

No tratar correctamente los caracteres especiales también puede provocar errores al dividir listas de cadenas en Python. Entre estos caracteres especiales se incluyen espacios en blanco, comas o caracteres alfanuméricos.

El ejemplo siguiente muestra cómo evitar este error especificando el carácter para dividir la lista de cadenas.

# 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ácticas recomendadas y directrices

Dado que dividir listas en Python es una operación habitual en el análisis de datos, es importante seguir algunas prácticas para garantizar la eficiencia. Entre estas recomendaciones se incluyen las siguientes:

• Mantén la inmutabilidad siempre que sea posible: Si la lista original no debe modificarse, asegúrate de que tus operaciones de slicing no modifiquen la lista original. El slicing crea nuevas listas, por lo que esto no suele ser un problema, pero tenlo en cuenta cuando trabajes con estructuras de datos más complejas.
• Optimiza el rendimiento: Cuando trabajes con listas grandes, ten en cuenta las implicaciones para el rendimiento. El slicing suele ser eficiente, pero la copia innecesaria de listas grandes puede provocar cuellos de botella en el rendimiento.
• Trata casos extremos: Estudia casos extremos como una lista vacía, la división al principio o al final de la lista y los índices no válidos. Asegúrate de que tu código pueda tratar estas situaciones con elegancia.
• Incluye tratamiento de errores y validación: El tratamiento de errores es especialmente importante cuando quieres dividir una lista en varias listas en Python, para que tu código no se rompa y cree sorpresas. 

El curso Programación en Python de DataCamp ofrece una explicación detallada de las prácticas recomendadas para escribir código de forma eficiente, teniendo en cuenta conceptos comunes como el tratamiento de errores y el rendimiento. 

Técnicas avanzadas de división de listas

La división de listas puede llevarse a un nivel avanzado utilizando diferentes métodos que ofrecen más control y flexibilidad. 

Dividir la lista en varias listas

Puedes dividir la lista Python en varias listas especificando la división en índices concretos. Por ejemplo, el código siguiente divide la lista en el siguiente í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)

Ejemplo de salida de lista dividida de Python en varias listas. Imagen del autor

Dividir la lista en partes iguales

También puedes utilizar una biblioteca integrada como "numpy" para dividir una lista Python en partes iguales en función del número de partes que desees.

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 una lista por la mitad

Se puede utilizar el slicing para dividir la lista Python por la mitad.

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)

En el caso de una lista con un número impar de elementos, puedes especificar el índice que deseas incluir en la primera mitad.

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) 

Desarrollado en Python también ofrece información sobre cómo escribir código avanzado que te ayudará a comprender las técnicas avanzadas de división de listas.

Conclusión

Existen distintos métodos para dividir listas en Python. Cada método depende del tipo de lista y de la preferencia del usuario en lo relativo a eficiencia. Como profesional de los datos, es importante seleccionar el método de división de listas adecuado para tu análisis.

Para conocer a fondo la división de listas de Python, puedes obtener más información en nuestro curso Fundamentos de Python. También puedes hacer el curso Introducción a Python para asegurarte de que dominas las operaciones con listas y otros tipos de datos en Python. La Hoja de trucos de Python para principiantes también resulta útil cuando quieres echar un vistazo a cómo dividir una lista en Python.