Header Ads Widget

Ticker

6/recent/ticker-posts

Cómo agregar un elemento a una lista en Python: anexar, asignación de sectores y más

 Últimamente, he estado pensando en nuevos temas de Python sobre los que escribir, así que recurrí a Google. Cuando busqué "Python cómo", apareció primero "Python cómo agregar a una lista". Dado que este debe ser un término de búsqueda popular, decidí que valía la pena un artículo. En otras palabras, hoy aprenderemos cómo agregar un elemento a una lista en Python.

Para ahorrar algo de tiempo, puede empezar a añadir elementos a una lista en este momento con el append()método: my_list.append(item)Si usted tiene necesidades más complejas, considere el uso extend()insert()o la asignación rebanada incluso. Consulte el resto del artículo para obtener más detalles.

Descripción del problema

Para las personas que provienen de otros lenguajes de programación, tareas como crear y agregar a una lista pueden ser abrumadoras. Después de todo, casi todos los idiomas admiten listas de una forma u otra (por ejemplo, matrices, listas, etc.), pero no todos los idiomas tienen la misma sintaxis. Por ejemplo, aquí hay un ejemplo de una matriz en Java:

1
2
int[] myArray = new int[10];
myArray[0] = 5; // [5, 0, 0, 0, 0, 0, 0, 0, 0, 0]

Aquí, hemos creado una matriz de tamaño fijo de 10 elementos y hemos establecido el primer elemento en 5. En otras palabras, realmente no agregamos elementos a las matrices en Java. En cambio, modificamos los elementos existentes.

Mientras tanto, en un lenguaje como Rust, las matrices se declaran un poco diferente:

1
2
let mut my_array: [i32; 10] = [0; 10];
my_array[0] = 5; // [5, 0, 0, 0, 0, 0, 0, 0, 0, 0]

En Rust, tenemos que declarar explícitamente la matriz como mutable con mutDe esa manera, podemos modificar la matriz como en Java. Además, la sintaxis es bastante diferente. Por ejemplo, establecemos el tipo en i32, el tamaño en 10 y todos los elementos en 0.

Por supuesto, hay lenguajes con listas integradas muy similares a las que puede encontrar en Python. Por ejemplo, las matrices (dinámicas) de Ruby se pueden crear y modificar de la siguiente manera:

1
2
my_array = []
my_array << 5  # [5]

A diferencia de la solución anterior, no tuvimos que configurar nuestra matriz con un tamaño determinado. En cambio, podemos comenzar con una matriz vacía. Luego, pusimos un 5 en la matriz y lo cancelamos.

Curiosamente, en Python, la sintaxis para crear una lista es bastante similar:

1
my_list = []

Pero, ¿cómo agregamos algo a esta lista? Ese es el tema de este artículo.

Soluciones

En esta sección, veremos varias formas de agregar un elemento a una lista en Python. Dado que esta tarea es bastante sencilla, no hay muchas opciones. De hecho, eso es algo por diseño en Python (es decir, "Debería haber una, y preferiblemente solo una, forma obvia de hacerlo"). Dicho esto, he incluido algunas soluciones tontas para mantener este artículo interesante.

Agregar un elemento a una lista de forma estática

Para ser honesto, esto es una especie de no respuesta. Dicho esto, si desea completar una lista, puede declarar los elementos estáticamente:

1
my_list = [2, 5, 6]

En lugar de agregar los elementos uno por uno, hemos decidido inicializar la lista exactamente como queremos que aparezca. En este caso, hemos creado una lista con tres elementos: 2, 5 y 6. En la siguiente sección, veremos nuestra primera forma de modificar una lista existente.

Agregar un elemento a una lista por asignación de sector

En Python, existe esta pieza de sintaxis muy peculiar que recién aprendí sobre la llamada asignación de segmentos. Mientras que la división se puede usar para devolver una sección de una lista, la asignación de división se puede usar para reemplazar una sección de una lista. En otras palabras, es posible escribir una expresión que agregue un valor al final de una lista:

1
2
my_list = []
my_list[len(my_list):] = [5]

Aquí, tenemos una expresión que reemplaza el final de la lista, que es una lista vacía, con una lista que contiene un solo valor. En esencia, hemos agregado un elemento al final de la lista.

Curiosamente, esta sintaxis se puede utilizar para reemplazar cualquier parte de una lista con cualquier otra lista. Por ejemplo, podríamos agregar un elemento al principio de la lista:

1
2
my_list = [1, 2, 3, 4]
my_list[:0] = [0] # [0, 1, 2, 3, 4]

Asimismo, podemos reemplazar cualquier sublista con cualquier otra lista de cualquier tamaño:

1
2
my_list = [1, 2, 3, 4]
my_list[:2] = [6, 7, 8, 9] # [6, 7, 8, 9, 3, 4]

Dato curioso: no estamos restringidos a listas con esta sintaxis. Podemos asignar cualquier iterable al segmento:

1
2
3
4
my_list = []
my_list[:] = "Hello" # ['H', 'e', 'l', 'l', 'o']
my_list[:] = (1, 2, 3) # [1, 2, 3]
my_list[:] = (i for i in range(5)) # [0, 1, 2, 3, 4]

Cuando agregué por primera vez esta solución a la lista, pensé que era un poco tonto, pero ahora veo mucho valor potencial en ella. Avíseme si alguna vez ha utilizado esta sintaxis y en qué contexto. Me encantaría ver algunos ejemplos en la naturaleza.

Agregar un elemento a una lista con Adjuntar

En una nota más tradicional, las personas que desean agregar un elemento al final de una lista en Python pueden confiar en agregar:

1
2
my_list = []
my_list.append(5)

Cada llamada para agregar agregará un elemento adicional al final de la lista. En la mayoría de los casos, este tipo de llamada se realiza en bucle. Por ejemplo, podríamos querer completar una lista de la siguiente manera:

1
2
3
my_list = []
for i in range(10):
    my_list.append(i)

Por supuesto, si va a hacer algo como esto y no está usando una lista existente, le recomiendo usar una lista de comprensión :

1
my_list = [i for i in range(10)]

En cualquier caso, append()suele ser el método de referencia para agregar un elemento al final de una lista. Por supuesto, si desea agregar más de un elemento a la vez, esta no es la solución para usted.

Agregar un elemento a una lista con Extender

Si está buscando combinar dos listas, este extend()es el método para usted:

1
2
my_list = []
my_list.extend([5])

En este ejemplo, agregamos una lista de un solo elemento al final de una lista vacía. Naturalmente, podemos agregar una lista de cualquier tamaño:

1
2
my_list = [3, 2]
my_list.extend([5, 17, 8])  # [3, 2, 5, 17, 8]

Otra gran característica de extend()es que no estamos restringidos a listas; podemos usar cualquier iterable. Eso incluye tuplas, cadenas y expresiones generadoras:

1
2
3
4
5
6
my_list = []
my_list.extend("Hello") # ['H', 'e', 'l', 'l', 'o']
my_list.clear()
my_list.extend((1, 2, 3)) # [1, 2, 3]
my_list.clear()
my_list.extend(i for i in range(5)) # [0, 1, 2, 3, 4]

Por supuesto, al igual que append()extend()no devuelve nada. En cambio, modifica la lista existente. También como append()extend()solo agrega el iterable al final de la otra lista. No hay forma de especificar a dónde va la entrada iterable. Si desea más control, sugiero asignación de división o nuestro siguiente método, insert().

Agregar un elemento a una lista con insertar

Si append()extend()no están haciendo por ti, lo recomiendo insert()Le permite agregar un elemento a una lista en cualquier índice:

1
2
my_list = []
my_list.insert(0, 5)

En este caso, insertamos un 5 en el índice 0. Naturalmente, podemos elegir cualquier índice válido:

1
2
my_list = [2, 5, 7]
my_list.insert(1, 6) # [2, 6, 5, 7]

Y al igual que con la sintaxis de lista normal, podemos usar índices negativos:

1
2
my_list = [2, 5, 7]
my_list.insert(-1, 9)  # [2, 5, 9, 7]

¡¿Cuan genial es eso?! Desafortunadamente, sin embargo, no podemos insertar una lista completa. Dado que las listas de Python no restringen el tipo, podemos agregar cualquier elemento que queramos. Como resultado, insertar una lista insertará literalmente esa lista:

1
2
my_list = [4, 5, 6]
my_list.insert(1, [9, 10])  # [4, [9, 10], 5, 6]

¡Afortunadamente, la asignación de cortes puede ayudarnos aquí!

Actuación

Con todas las soluciones listas para usar, echemos un vistazo a cómo se comparan en términos de rendimiento. Dado que cada solución no hace exactamente lo mismo, intentaré ser justo en la forma en que construyo mis ejemplos. Por ejemplo, todos los ejemplos siguientes agregarán un valor al final de cada una de las listas de muestra (ignorando las soluciones de asignación estática):

01
02
03
04
05
06
07
08
09
10
11
12
13
14
15
dieciséis
17
18
19
20
21
22
23
24
setup = """
empty_list = []
small_list = [1, 2, 3, 4]
large_list = [i for i in range(100000)]
"""
 
static_list_empty = "empty_list = []"
static_list_small = "small_list = [1, 2, 3, 4, 5]"
 
slice_assignment_empty = "empty_list[len(empty_list):] = [5]"
slice_assignment_small = "small_list[len(small_list):] = [5]"
slice_assignment_large = "large_list[len(large_list):] = [5]"
 
append_empty = "empty_list.append(5)"
append_small = "small_list.append(5)"
append_large = "large_list.append(5)"
 
extend_empty = "empty_list.extend([5])"
extend_small = "small_list.extend([5])"
extend_large = "large_list.extend([5])"
 
insert_empty = "empty_list.insert(len(empty_list), 5)"
insert_small = "small_list.insert(len(small_list), 5)"
insert_large = "large_list.insert(len(large_list), 5)"

Ahora, echemos un vistazo a todos los ejemplos de listas vacías:

01
02
03
04
05
06
07
08
09
10
11
>>> import timeit
>>> min(timeit.repeat(setup=setup, stmt=static_list_empty))
0.06050460000005842
>>> min(timeit.repeat(setup=setup, stmt=slice_assignment_empty))
0.4962195999996766
>>> min(timeit.repeat(setup=setup, stmt=append_empty))
0.17979939999986527
>>> min(timeit.repeat(setup=setup, stmt=extend_empty))
0.27297509999971226
>>> min(timeit.repeat(setup=setup, stmt=insert_empty))
0.49701270000059594

Como era de esperar, la solución más sencilla funciona mejor. Veamos cómo se desarrolla eso a medida que aumentamos nuestra lista:

01
02
03
04
05
06
07
08
09
10
>>> min(timeit.repeat(setup=setup, stmt=static_list_small))
0.1380927000000156
>>> min(timeit.repeat(setup=setup, stmt=slice_assignment_small))
0.5136848000001919
>>> min(timeit.repeat(setup=setup, stmt=append_small))
0.1721136000005572
>>> min(timeit.repeat(setup=setup, stmt=extend_small))
0.28814950000014505
>>> min(timeit.repeat(setup=setup, stmt=insert_small))
0.5033762000002753

Nuevamente, append()hace el trabajo más rápido. Ahora, echemos un vistazo a una lista enorme:

1
2
3
4
5
6
7
8
>>> min(timeit.repeat(setup=setup, stmt=slice_assignment_large))
0.5083946000004289
>>> min(timeit.repeat(setup=setup, stmt=append_large))
0.18050170000060461
>>> min(timeit.repeat(setup=setup, stmt=extend_large))
0.28858020000006945
>>> min(timeit.repeat(setup=setup, stmt=insert_large))
0.5108225000003586

Sorprendentemente, todas estas soluciones parecen escalar realmente bien. Dicho esto, se append()lleva la palma. Después de todo, se amortiza O (1) . En otras palabras, agregar a una lista es una operación de tiempo constante siempre que no nos quedemos sin espacio.

Dicho esto, tome estas métricas de rendimiento con un grano de sal. Después de todo, no todas las soluciones serán perfectas para sus necesidades.

Desafío

Ahora que sabemos cómo agregar un elemento a una lista, intentemos escribir un algoritmo de clasificación simple. Después de todo, esa es la tarea perfecta para alguien que quiera familiarizarse con los diversos métodos de manipulación de listas.

Personalmente, no me importa qué algoritmo de clasificación implemente (por ejemplo, burbuja, inserción, combinación, etc.) o qué tipo de datos elija ordenar (por ejemplo, números, cadenas, etc.). De hecho, ni siquiera me importa si ordena los datos en su lugar o crea una lista completamente separada. Lo único que me importa es que uses uno o más de los métodos descritos en este artículo para hacerlo.

Cuando crea que tiene una buena solución, no dude en compartirla en los comentarios. Como siempre, compartiré un ejemplo en los comentarios.

Un pequeño resumen

Con todo eso fuera del camino, echemos un vistazo a todas nuestras soluciones nuevamente:

01
02
03
04
05
06
07
08
09
10
11
12
13
14
# Statically defined list
my_list = [2, 5, 6]
 
# Appending using slice assignment
my_list[len(my_list):] = [5]  # [2, 5, 6, 5]
 
# Appending using append()
my_list.append(9)  # [2, 5, 6, 5, 9]
 
# Appending using extend()
my_list.extend([-4])  # [2, 5, 6, 5, 9, -4]
 
# Appending using insert()
my_list.insert(len(my_list), 3)  # [2, 5, 6, 5, 9, -4, 3]

De lejos, este ha sido uno de mis artículos favoritos para escribir en un tiempo. No hay nada como aprender algo nuevo mientras escribes una respuesta corta a la pregunta "¿Cómo agrego un elemento a una lista?"

Publicar un comentario

0 Comentarios