Apuntes de Python

Apariencia

📙 Clase 06 — Slicing (rebanar) ​

Fase 1 · Estructuras de datos y bucles ⬅️ Volver al índice de clases

🎯 Qué aprendí ​

  • Sacar un trozo de una lista o texto con [inicio:fin].
  • El tercer número (paso) y el truco estrella [::-1] para voltear.
  • Copiar una lista con [:] y modificar tramos con asignación a un slice.

📖 PARTE TEÓRICA ​

✂️ 1. La idea: [inicio:fin] ​

Slicing = obtener una rebanada (sublista o subcadena) indicando desde dónde y hasta dónde. La forma es secuencia[inicio:fin], donde inicio se incluye y fin se excluye.

python
L = [0, 1, 2, 3, 4, 5]
print(L[1:4])     # [1, 2, 3]   ← del índice 1 al 3 (el 4 NO se incluye)
índice:   0    1    2    3    4    5
        [ 0 ][ 1 ][ 2 ][ 3 ][ 4 ][ 5 ]
             └──── L[1:4] ────┘  (1,2,3 — el 4 queda fuera)

⚠️ El final es exclusivo (igual que range): L[1:4] toma los índices 1, 2 y 3, no el 4.

🔲 2. Omitir inicio o fin ​

Si omites un extremo, Python asume "desde el principio" o "hasta el final".

python
L = [0, 1, 2, 3, 4, 5]
print(L[:3])      # [0, 1, 2]        desde el inicio hasta el índice 2
print(L[3:])      # [3, 4, 5]        desde el índice 3 hasta el final
print(L[:])       # [0,1,2,3,4,5]    TODO (y además es una COPIA, ver §5)

🔢 3. Índices negativos ​

Cuentan desde el final, como en la Clase 01.

python
L = [0, 1, 2, 3, 4, 5]
print(L[-2:])     # [4, 5]       los dos últimos
print(L[:-1])     # [0,1,2,3,4]  todos menos el último

⏩ 4. El tercer número: paso ​

secuencia[inicio:fin:paso] — el paso dice de cuánto en cuánto avanzar. Un paso negativo recorre al revés.

python
L = [0, 1, 2, 3, 4, 5]
print(L[::2])     # [0, 2, 4]        de 2 en 2 (índices pares)
print(L[1::2])    # [1, 3, 5]        de 2 en 2 empezando en 1
print(L[::-1])    # [5, 4, 3, 2, 1, 0]   ¡VOLTEADO!  (paso -1)

🧪 Tip de entrevista: "¿Cómo inviertes una lista o un texto?" → [::-1]. Es el truco más famoso del slicing.

🔤 5. Funciona igual en textos ​

Un str es una secuencia de caracteres: se rebana idéntico.

python
s = "Python"
print(s[0:3])     # Pyt
print(s[::-1])    # nohtyP    ← invertir un texto (útil para "¿es palíndromo?")

📄 6. Copiar con [:] y modificar tramos ​

L[:] crea una copia (resuelve el aliasing de la Clase 01). Y puedes asignar a un slice para reemplazar todo un tramo.

python
# Copia real (no aliasing):
L = [0, 1, 2, 3, 4, 5]
copia = L[:]
copia.append(9)
print(L)          # [0, 1, 2, 3, 4, 5]        ← intacta
print(copia)      # [0, 1, 2, 3, 4, 5, 9]

# Reemplazar un tramo:
L2 = [0, 1, 2, 3, 4, 5]
L2[1:3] = [20, 30]        # reemplaza los índices 1 y 2
print(L2)         # [0, 20, 30, 3, 4, 5]

🖥️ EN TU APP DE ESCRITORIO ​

Slicing es tu herramienta para mostrar tramos de datos sin tocar la lista original: paginación, "últimos N", vistas previas, orden inverso…

python
tareas = ["t1", "t2", "t3", "t4", "t5", "t6", "t7"]

# Mostrar solo la "página 1" (primeras 5) en la GUI:
POR_PAGINA = 5
pagina_1 = tareas[:POR_PAGINA]          # ['t1'..'t5']
pagina_2 = tareas[POR_PAGINA:2*POR_PAGINA]  # ['t6', 't7']

# Mostrar las tareas más recientes primero (invertir para pintar):
for t in tareas[::-1]:
    ctk.CTkLabel(lista, text=t).pack()

# Vista previa de un texto largo en una etiqueta:
descripcion = entry.get()
resumen = descripcion[:40] + "…" if len(descripcion) > 40 else descripcion
label_preview.configure(text=resumen)
En tu appSlicing te da
Paginar resultadosdatos[inicio:fin] por página
"Ver últimos 5"datos[-5:]
Mostrar recientes primerodatos[::-1]
Recorte de texto para un Labeltexto[:40]
Copiar la lista antes de filtrardatos[:] (sin dañar la original)

💡 Slicing no modifica la lista original (salvo que asignes a un slice): siempre te da una rebanada nueva. Perfecto para preparar "lo que se muestra" sin tocar "lo que se guarda".

🗄️ CON BASE DE DATOS (caso de uso) ​

En una BD real la paginación se hace con LIMIT/OFFSET en el SQL (más eficiente). Pero mientras trabajas con los datos ya cargados en memoria (una lista de filas), el slicing es la forma rápida de paginarlos:

python
filas = con.execute("SELECT * FROM tareas").fetchall()   # lista de filas
primeras_10 = filas[:10]        # "página 1" desde memoria

🗄️ A escala grande preferirás SELECT ... LIMIT 10 OFFSET 0 (traer solo lo que muestras). El slicing es genial para prototipos y listas pequeñas.

🏋️ EJERCICIOS CON SOLUCIÓN ​

Ejercicio 1 — Los del medio ​

De L = [10, 20, 30, 40, 50], obtén [20, 30, 40] con slicing.

Ver solución
python
L = [10, 20, 30, 40, 50]
print(L[1:4])    # [20, 30, 40]

Ejercicio 2 — Palíndromo ​

Escribe una expresión que diga si "reconocer" se lee igual al derecho y al revés.

Ver solución
python
palabra = "reconocer"
print(palabra == palabra[::-1])   # True   (invertida es igual → palíndromo)

Ejercicio 3 — Últimos tres ​

De historial = [1, 2, 3, 4, 5, 6], muestra solo los tres últimos.

Ver solución
python
historial = [1, 2, 3, 4, 5, 6]
print(historial[-3:])   # [4, 5, 6]

Ejercicio 4 — Copia segura con slicing ​

Copia datos = [1, 2, 3] usando slicing, agrega un 4 a la copia y demuestra que el original no cambió.

Ver solución
python
datos = [1, 2, 3]
copia = datos[:]        # copia real
copia.append(4)
print(datos)   # [1, 2, 3]
print(copia)   # [1, 2, 3, 4]

❓ Preguntas y respuestas (autoevaluación) ​

1. En L[2:5], ¿qué índices toma?

El 2, 3 y 4. El 5 se excluye (el final es exclusivo).

2. ¿Qué hace L[::-1]?

Devuelve la secuencia invertida (paso -1). Funciona igual en listas y textos.

3. ¿Cómo copias una lista con slicing y por qué querrías?

Con L[:]. Evita el aliasing: modificar la copia no toca la original.

4. ¿L[:3] modifica la lista original?

No. Slicing devuelve una rebanada nueva; la original queda intacta (salvo que asignes a un slice).

📎 Apuntes relacionados ​

➡️ Siguiente ​

Clase 07 · List comprehensions — crear listas en una sola línea, la forma pythónica.