Listas en Python

Guía completa de referencia

[1, 2, 3].append(4)
>>> [1, 2, 3, 4]

Preparado por Romario

Universidad Continental — Arequipa

Agosto 2026
Listas en Python Ing. de Sistemas

Contents

1 Introducción 2

2 Creación de listas 2

3 Indexación y slicing 2

4 Métodos que modifican la lista (in-place) 3

5 Métodos que NO modifican la lista 3

6 El parámetro key en sort() 3

7 List comprehensions 3

8 Funciones built-in con listas 4

9 Operadores sobre listas 4

10 Copias: superficial vs profunda 4

11 Módulos relacionados 5
11.1itertools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
11.2bisect — listas ordenadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
11.3heapq — colas de prioridad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
[Link] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

12 Métodos ”dunder” detrás de las listas 6

13 Tabla resumen de complejidad 6

14 Cuándo NO usar listas 6

15 Cheat sheet final 6

1
 Listas en Python Ing. de Sistemas

1 Introducción
Las listas (list) son la estructura de datos más versátil en Python: son mutables, orde-
nadas y permiten elementos de tipos heterogéneos. Esta guía cubre desde lo básico
hasta las herramientas menos conocidas del ecosistema estándar.

1 mi_lista = [1, "dos", 3.0, [4, 5], True]

2 print(type(mi_lista)) # <class 'list'>

Nota: A diferencia de las tuplas, las listas se pueden modificar después de creadas
(mutabilidad). Esto tiene implicaciones de rendimiento y de manejo de memoria que
se explican más adelante.

2 Creación de listas

1 vacia = []
2 vacia2 = list()
3 numeros = [1, 2, 3, 4, 5]
4 desde_rango = list(range(10))
5 desde_string = list("hola") # ['h','o','l','a']
6 repetida = [0] ∗ 5 # [0,0,0,0,0]
7 anidada = [[1,2], [3,4], [5,6]]
8 por_comprension = [x∗∗2 for x in range(5)]

Cuidado con [[0]*3]*3 para crear matrices: las tres sublistas son la misma refer-
encia en memoria. Usa [[0]*3 for _ in range(3)] en su lugar.

3 Indexación y slicing

1 lista = [10, 20, 30, 40, 50]

2

3 lista[0] # 10 (primer elemento)

4 lista[−1] # 50 (ultimo elemento)
5 lista[1:3] # [20, 30]
6 lista[:3] # [10, 20, 30]
7 lista[2:] # [30, 40, 50]
8 lista[::2] # [10, 30, 50] (paso 2)
9 lista[::−1] # [50, 40, 30, 20, 10] (invertida)
10 lista[1:4:2] # [20, 40]

2
Listas en Python Ing. de Sistemas

4 Métodos que modifican la lista (in-place)

Método Descripción
append(x) Agrega x al final
extend(iterable) Agrega todos los elementos de un iterable
insert(i, x) Inserta x en la posición i
remove(x) Elimina la primera coincidencia de x
pop([i]) Elimina y devuelve el elemento en i (o el último)
clear() Vacía la lista
sort(key=,reverse=) Ordena in-place
reverse() Invierte el orden in-place

1 lista = [3, 1, 4, 1, 5]
2 [Link](9) # [3,1,4,1,5,9]
3 [Link]() # [1,1,3,4,5,9]
4 [Link](reverse=True) # [9,5,4,3,1,1]
5 [Link]() # invierte el orden actual

5 Métodos que NO modifican la lista

1 lista = [3, 1, 4, 1, 5]
2
3 [Link](4) # 2 (posicion de la primera coincidencia)
4 [Link](1) # 2 (cuantas veces aparece 1)
5 [Link]() # copia superficial (shallow copy)
6 sorted(lista) # nueva lista ordenada, no muta la original
7 list(reversed(lista)) # iterador invertido

6 El parámetro key en sort()

1 personas = [("Ana", 25), ("Luis", 20), ("Eva", 30)]

2
3 [Link](key=lambda p: p[1]) # ordena por edad
4 [Link](key=lambda p: p[0]) # ordena por nombre
5
6 palabras = ["banana", "kiwi", "sandia"]
7 [Link](key=len) # ordena por longitud

También puedes usar [Link] para ordenar por múltiples criterios de

forma más eficiente que un lambda.

1 from operator import itemgetter

2 [Link](key=itemgetter(1, 0)) # por edad y luego nombre

7 List comprehensions

3
 Listas en Python Ing. de Sistemas

1 cuadrados = [x∗∗2 for x in range(10)]

2 pares = [x for x in range(20) if x % 2 == 0]
3 mixto = [x if x > 0 else 0 for x in [−2, 5, −8, 3]]
4 matriz_plana = [x for fila in matriz for x in fila]
5 combinaciones = [(x, y) for x in range(3) for y in range(3) if x != y]

8 Funciones built-in con listas

1 len(lista)
2 sum(lista)
3 max(lista)
4 min(lista)
5 any(lista)
6 all(lista)
7 enumerate(lista) # (indice, valor)
8 zip(lista1, lista2) # combina en tuplas
9 map(func, lista)
10 filter(func, lista)

1 for i, valor in enumerate(["a", "b", "c"]):

2 print(i, valor)
3

4 nombres = ["Ana", "Luis"]

5 edades = [25, 20]
6 for nombre, edad in zip(nombres, edades):
7 print(nombre, edad)

9 Operadores sobre listas

1 [1, 2] + [3, 4] # [1, 2, 3, 4] concatenacion

2 [1, 2] ∗ 3 # [1, 2, 1, 2, 1, 2] repeticion
3 3 in [1, 2, 3] # True pertenencia
4 [1, 2] == [1, 2] # True comparacion por contenido
5 del lista[0] # elimina por indice
6 del lista[1:3] # elimina un slice
7 lista[1:3] = [9, 9] # reemplaza un slice

10 Copias: superficial vs profunda

Este es uno de los errores más comunes en Python. Una copia superficial (shallow)
no copia los objetos anidados; una copia profunda (deep) sí.

1 import copy
2
3 original = [[1, 2], [3, 4]]
4
5 superficial = [Link]() # o list(original) o original[:]
6 profunda = [Link](original)
7

4
 Listas en Python Ing. de Sistemas

8 superficial[0][0] = 99
9 print(original) # [[99, 2], [3, 4]] <− se modifico!
10
11 profunda[1][0] = 77
12 print(original) # [[99, 2], [3, 4]] <− no se modifico

11 Módulos relacionados
11.1 itertools

1 from itertools import (

2 chain, combinations, permutations, product,
3 groupby, accumulate, islice, cycle, repeat,
4 dropwhile, takewhile, compress, pairwise
5 )
6
7 list(permutations([1,2,3], 2))
8 # [(1,2),(1,3),(2,1),(2,3),(3,1),(3,2)]
9
10 list(combinations([1,2,3], 2))
11 # [(1,2),(1,3),(2,3)]
12
13 list(chain([1,2], [3,4]))
14 # [1,2,3,4]
15
16 list(accumulate([1,2,3,4]))
17 # [1,3,6,10] (suma acumulada)

11.2 bisect — listas ordenadas

1 import bisect
2
3 lista = [1, 3, 4, 7, 9]
4 [Link](lista, 5) # inserta manteniendo el orden
5 pos = bisect.bisect_left(lista, 4) # busqueda binaria

11.3 heapq — colas de prioridad

1 import heapq
2
3 lista = [5, 1, 8, 3]
4 [Link](lista) # convierte en heap in−place
5 [Link](lista, 2)
6 menor = [Link](lista) # extrae el minimo

11.4 [Link]

1 from collections import deque

2
3 cola = deque([1, 2, 3])
4 [Link](0) # O(1) al inicio (una lista normal es O(n))

5
Listas en Python Ing. de Sistemas

5 [Link]() # O(1)

Usa deque cuando necesites insertar o eliminar frecuentemente por el inicio de la

secuencia. Las listas normales son ineficientes para eso.

12 Métodos ”dunder” detrás de las listas

1 lista.__len__() # lo que usa len(lista)

2 lista.__contains__(3) # lo que usa "3 in lista"
3 lista.__getitem__(0) # lo que usa lista[0]
4 lista.__add__([4,5]) # lo que usa lista + [4,5]
5 lista.__iter__() # lo que usa "for x in lista"

13 Tabla resumen de complejidad

Operación Complejidad
append(x) O(1) amortizado
pop() (al final) O(1)
pop(0) (al inicio) O(n)
insert(0, x) O(n)
x in lista O(n)
lista[i] O(1)
len(lista) O(1)
sort() O(n log n)

14 Cuándo NO usar listas

• Si necesitas insertar/eliminar frecuentemente por el inicio → [Link]
• Si necesitas cómputo numérico intensivo → [Link]
• Si necesitas una cola de prioridad → heapq
• Si necesitas elementos únicos sin orden → set
• Si necesitas pares clave-valor → dict
• Si los datos no deben cambiar → tuple

15 Cheat sheet final

# Lo que se usa el 90% del tiempo:

[Link](x)
[Link]()
[Link](key=..., reverse=...)
[Link](otra)
lista[1:3] # slicing
lista[::-1] # invertir
[x for x in lista if cond] # comprehension
len(), sum(), sorted(), enumerate(), zip()

6
Listas en Python Ing. de Sistemas

Documento generado para uso académico — Ing. de Sistemas