Listas, tuplas y slicing
Domine las operaciones con listas de Python, la sintaxis de slicing y la inmutabilidad de las tuplas mediante ejemplos prácticos basados en desafíos clásicos de programación.
Listas, tuplas y slicing es una lección gratuita de Coding Interview Prep en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Coding Interview Prep, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Coding Interview Prep incluye 4 lecciones en total.
Listas de Python: arrays dinámicos
Una list de Python es un array dinámico que puede contener cualquier cosa y crece automáticamente. Está ordenada, se puede modificar y ofrece acceso O(1) inmediato mediante índice. El código muestra los conceptos básicos.
nums = [3, 1, 4, 1, 5]
print(nums[0]) # 3
print(nums[-1]) # 5 (last element)
nums.append(9)
print(len(nums)) # 6Operaciones habituales con listas
Aprenda estas operaciones de memoria: append y pop al final son O(1), pero insert al principio es O(n). Evite remove en bucles ajustados: vuelve a recorrer la lista cada vez.
stack = []
stack.append(1)
stack.append(2)
stack.append(3)
print(stack.pop()) # 3 O(1)
print(stack) # [1, 2]
# insert at index 0 is O(n)
stack.insert(0, 0)
print(stack) # [0, 1, 2]Explicación de la sintaxis de slicing
El slicing se escribe como lst[start:stop:step] y se detiene justo antes de stop. El truco clásico: un step de -1 invierte una lista sin modificarla. El código explica cada forma.
a = [0, 1, 2, 3, 4, 5]
print(a[1:4]) # [1, 2, 3]
print(a[:3]) # [0, 1, 2]
print(a[3:]) # [3, 4, 5]
print(a[::2]) # [0, 2, 4] every other
print(a[::-1]) # [5, 4, 3, 2, 1, 0] reversedEl slicing crea copias superficiales
Un detalle importante: el slicing siempre crea una lista nueva, por lo que modificar el resultado no afecta a la original. Sin embargo, la copia es superficial, así que las listas anidadas siguen compartiéndose. Téngalo en cuenta.
original = [1, 2, 3]
copy = original[:] # shallow copy
copy[0] = 99
print(original) # [1, 2, 3] unchanged
# Nested list pitfall
nested = [[1, 2], [3, 4]]
shallow = nested[:]
shallow[0][0] = 99
print(nested) # [[99, 2], [3, 4]] changed!Tuplas: secuencias inmutables
Una tuple utiliza paréntesis y no se puede modificar una vez creada. Como es hashable, puede ser una clave de un diccionario o un elemento de un conjunto; resulta perfecta para pares (fila, columna) en problemas con cuadrículas.
point = (3, 7)
print(point[0]) # 3
# Use as dict key
grid = {}
grid[(0, 0)] = 'start'
grid[(2, 3)] = 'end'
print(grid[(0, 0)]) # start
# Unpacking
x, y = point
print(x, y) # 3 7Cuándo utilizar una tupla en lugar de una lista
Elija una tuple cuando los datos no deban cambiar, y una list cuando sí deban hacerlo. Las tuplas también usan un poco menos de memoria, algo que se acumula dentro de los heaps grandes de Dijkstra.
import sys
a_list = [1, 2, 3, 4, 5]
a_tuple = (1, 2, 3, 4, 5)
print(sys.getsizeof(a_list)) # e.g. 104 bytes
print(sys.getsizeof(a_tuple)) # e.g. 80 bytes
# Tuple returned from function
def min_max(nums):
return min(nums), max(nums)
lo, hi = min_max([3, 1, 4, 1, 5])
print(lo, hi) # 1 5Errores off-by-one en el slicing
Los errores off-by-one son la principal trampa en los problemas de arrays. Recuerde que lst[i:j] devuelve exactamente j-i elementos. Para dividir por la mitad, la parte izquierda es lst[:mid] y la derecha, lst[mid:].
lst = [1, 2, 3, 4, 5, 6]
mid = len(lst) // 2 # 3
left = lst[:mid] # [1, 2, 3]
right = lst[mid:] # [4, 5, 6]
print(left, right)
# How many elements?
print(len(lst[2:5])) # 3 (indices 2,3,4)Índices negativos en entrevistas técnicas
Python tiene negative indices: lst[-1] es el último elemento y lst[-2], el anterior. Prefiera lst[-1] a lst[len(lst)-1]; los entrevistadores suelen fijarse en la versión más limpia.
s = 'abcde'
print(s[-1]) # 'e'
print(s[-3:]) # 'cde'
print(s[:-2]) # 'abc' (all except last 2)
nums = [10, 20, 30, 40]
print(nums[-2]) # 30
nums[-1] = 99
print(nums) # [10, 20, 30, 99]Ordenación y comparación de listas
La ordenación de Python utiliza Timsort (O(n log n), estable). lst.sort() modifica la lista en el propio lugar; sorted(lst) devuelve una nueva. Utilice la opción key para establecer un orden personalizado. Consulte el código.
words = ['banana', 'fig', 'apple', 'kiwi']
words.sort(key=len)
print(words) # ['fig', 'kiwi', 'apple', 'banana']
nums = [3, 1, 4, 1, 5]
print(sorted(nums, reverse=True)) # [5, 4, 3, 1, 1]
print(nums) # unchanged: [3, 1, 4, 1, 5]Modificar listas durante la iteración
Una trampa clásica: nunca añada ni elimine elementos mientras recorre una lista; se saltará elementos o el programa fallará. En su lugar, cree una lista nueva mediante una comprensión.
# WRONG — skips elements
nums = [1, 2, 3, 4, 5]
for n in nums:
if n % 2 == 0:
nums.remove(n) # skips 4!
print(nums) # [1, 3, 5]... but 4 got skipped? Actually removes 2,4
# CORRECT — build new list
nums = [1, 2, 3, 4, 5]
nums = [n for n in nums if n % 2 != 0]
print(nums) # [1, 3, 5]Desempaquetado de tuplas en bucles
El tuple unpacking mantiene limpios los bucles: enumerate proporciona (index, value) y zip recorre dos listas a la vez. La sintaxis *rest captura el resto en su propia variable. Consulte el código.
nums = [10, 20, 30]
for i, v in enumerate(nums):
print(i, v)
# 0 10 / 1 20 / 2 30
a = [1, 2, 3]
b = ['x', 'y', 'z']
for x, y in zip(a, b):
print(x, y)
first, *rest = [1, 2, 3, 4]
print(first, rest) # 1 [2, 3, 4]Comprobación rápida
Comprobación rápida: demuestre cuánto ha aprendido sobre las listas, las tuplas y el slicing de Python. Puede hacerlo. 💪
Resumen de la lección
Resumen: las lists son arrays dinámicos con append O(1), el slicing siempre devuelve una copia nueva y las tuples son inmutables y hashable. A continuación: diccionarios y conjuntos.
Preguntas frecuentes
¿La lección «Listas, tuplas y slicing» es gratis?
Sí — el texto completo de «Listas, tuplas y slicing» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Coding Interview Prep, actualiza a CoddyKit PRO. El curso de Coding Interview Prep incluye 4 lecciones en total.
¿Qué aprenderé en «Listas, tuplas y slicing»?
Domine las operaciones con listas de Python, la sintaxis de slicing y la inmutabilidad de las tuplas mediante ejemplos prácticos basados en desafíos clásicos de programación. Practicas Coding Interview Prep con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Coding Interview Prep?
No se requiere experiencia previa. Coding Interview Prep en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.
¿Cuánto tiempo toma la lección «Listas, tuplas y slicing»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Coding Interview Prep?
Sí. Cada lección de Coding Interview Prep incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Listas, tuplas y slicing
- Diccionarios y conjuntos en Python
- Comprensiones y funciones integradas
- Funciones, cierres y lambda