Python Slicing: Guía completa con ejemplos y trucos útiles

Python slicing: entenderlo bien cambia cómo escribes código

Hay un momento cuando estás aprendiendo Python en el que ves algo como esto:

texto[::-1]

Y piensas: vale… esto hace algo… pero ¿qué está pasando aquí? 🤔

A partir de ahí empiezas a ver slicing en todas partes. Y no es casualidad: es una de esas herramientas pequeñas que, bien usadas, te simplifican muchísimo el código.

---

La base: cómo funciona slicing

La estructura es siempre esta:

[inicio:fin:paso]

• inicio: desde dónde empiezas
• fin: hasta dónde llegas (sin incluirlo)
• paso: cada cuánto avanzas

Ejemplo simple:

s = "abcdef"
print(s[1:4])  # "bcd"

---

---

El famoso [::-1]

texto = "python"
print(texto[::-1])  # "nohtyp"

Aquí pasa algo interesante:

• no defines inicio → empieza desde el final
• no defines fin → llega hasta el principio
• paso = -1 → va hacia atrás

Resultado: inviertes la cadena 🔁

---

[::1] vs [::-1]

texto = "hola"

print(texto[::1])   # "hola"
print(texto[::-1])  # "aloh"

• [::1] → recorrido normal
• [::-1] → recorrido inverso

---

Saltar elementos

Esto es más útil de lo que parece:

nums = [0, 1, 2, 3, 4, 5]
print(nums[::2])  # [0, 2, 4]

Te quedas con uno sí, uno no.

Y en reversa:

print(nums[::-2])  # [5, 3, 1]

---

Quitar elementos fácilmente

Quitar el último:

nums = [1, 2, 3, 4]
print(nums[:-1])  # [1, 2, 3]

Quitar el primero:

print(nums[1:])  # [2, 3, 4]

Son pequeños detalles, pero hacen el código mucho más limpio.

---

Copiar listas sin liarla

nums = [1, 2, 3]
copia = nums[:]

Esto crea una copia real (no una referencia).

Muy típico en preguntas de entrevistas ⚠️

---

Palíndromos en una línea

Este patrón aparece muchísimo:

def is_palindrome(s):
    return s == s[::-1]

Simple, directo y difícil de mejorar.

---

---

Rotar listas (nivel entrevista)

Este ya sube un poco el nivel:

nums = [1, 2, 3, 4, 5]
k = 2

rotated = nums[-k:] + nums[:-k]
print(rotated)  # [4, 5, 1, 2, 3]

Lo que haces:

• coges los últimos k
• los pones delante
• añades el resto

---

Invertir solo una parte

nums = [1, 2, 3, 4, 5]
nums[1:4] = nums[1:4][::-1]

print(nums)  # [1, 4, 3, 2, 5]

Esto ya es de los que hacen que alguien mire tu código con más atención 👀

---

Qué hacen [:1], [:2] o [:3]

Aquí ya no estás usando el paso, sino el valor de fin.

Por ejemplo:

nums = [0, 1, 2, 3, 4, 5]

print(nums[:1])  # [0]
print(nums[:2])  # [0, 1]
print(nums[:3])  # [0, 1, 2]

Lo que significa realmente es:

[inicio:fin]

Como no indicas inicio, Python empieza automáticamente desde el principio.

Y hay un detalle importante:

el índice final nunca se incluye

Por eso:

• [:1] → coge solo el índice 0
• [:2] → coge 0 y 1
• [:3] → coge 0, 1 y 2

---

---

También puedes combinarlo con paso:

nums[:5:2]
# [0, 2, 4]

Aquí haces:

• desde el principio
• hasta el índice 5 (sin incluirlo)
• saltando de 2 en 2

---

Idea mental que me funciona

Cada vez que veo slicing, lo reduzco a esto:

inicio → fin → paso

Y dos reglas rápidas:

• el fin nunca se incluye
• los índices negativos empiezan desde el final
• si falta inicio → empieza desde el principio
• si falta fin → llega hasta el final
• si falta paso → avanza de 1 en 1

---

❓ FAQ

¿Qué es slicing en Python?

Slicing en Python es una técnica para acceder a partes de una secuencia como strings, listas o tuplas utilizando la sintaxis [inicio:fin:paso].

¿Qué significa [::-1] en Python?

La expresión [::-1] invierte una secuencia en Python, recorriéndola desde el final hasta el principio.

¿Cuál es la diferencia entre [::1] y [::-1]?

[::1] recorre la secuencia normalmente sin cambios, mientras que [::-1] la invierte completamente.

¿Se puede usar slicing en listas y strings?

Sí, slicing funciona con cualquier tipo de secuencia en Python como listas, strings y tuplas.