Rebanado (slicing) en Python: cadenas, listas y tuplas

Principiante20 min6 ejercicios80 XP

Esta lección es una traducción del original en inglés.Read in English Avisar de un error de traducción

Antes de empezar

Cadenas en Python: crear, acceder, rebanar y manipular texto Listas en Python: cómo crearlas, modificarlas y recorrerlas

0/6 ejercicios

Imagina una pizza cortada en 8 porciones, numeradas del 0 al 7. No siempre quieres la pizza entera. A veces quieres de la porción 2 a la 5. A veces quieres una porción sí y otra no. A veces quieres las tres últimas.

El rebanado (slicing) en Python te permite tomar una porción de cualquier secuencia (una lista, una cadena o una tupla) con la misma notación sencilla. Es una de las características más elegantes de Python y, cuando lo aprendas, lo usarás en todas partes.

En esta lección aprenderás la notación start:stop:step, cómo funcionan los índices negativos, cómo invertir cualquier secuencia y los patrones de rebanado que los programadores de Python usan a diario.

¿Cómo funciona el rebanado básico?

La sintaxis básica de una porción es sequence[start:stop]. Te da los elementos desde el índice start hasta el índice stop, pero sin incluirlo. Piensa en ello como un intervalo semiabierto.

Rebanado básico con start:stop

fruits = ['apple', 'banana', 'cherry', 'date', 'elderberry']

# Get items at index 1, 2 (stops before 3)

print(fruits[1:3]) # ['banana', 'cherry']

# Get the first three items

print(fruits[0:3]) # ['apple', 'banana', 'cherry']

# Get items from index 2 to the end

print(fruits[2:5]) # ['cherry', 'date', 'elderberry']

Salida

['banana', 'cherry']
['apple', 'banana', 'cherry']
['cherry', 'date', 'elderberry']

La regla de "parar antes" puede parecer rara al principio. Pero tiene una ventaja: fruits[0:3] te da exactamente 3 elementos. El número de elementos de una porción siempre es stop - start.

Omitir start y stop

numbers = [10, 20, 30, 40, 50, 60]

# First three items (omit start)

print(numbers[:3]) # [10, 20, 30]

# Everything from index 3 onward (omit stop)

print(numbers[3:]) # [40, 50, 60]

# Copy the entire list (omit both)

copy = numbers[:]

print(copy) # [10, 20, 30, 40, 50, 60]

Salida

[10, 20, 30]
[40, 50, 60]
[10, 20, 30, 40, 50, 60]

¿Qué hace el parámetro step?

La sintaxis completa de una porción es sequence[start:stop:step]. El paso (step) controla cuántos elementos se saltan entre uno tomado y el siguiente. Con un paso de 2 tomas un elemento sí y otro no. Con un paso de 3 tomas uno de cada tres.

Usar el parámetro step

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Every other item

print(numbers[::2]) # [0, 2, 4, 6, 8]

# Every other item starting from index 1

print(numbers[1::2]) # [1, 3, 5, 7, 9]

# Every third item

print(numbers[::3]) # [0, 3, 6, 9]

# From index 1 to 7, every 2nd item

print(numbers[1:7:2]) # [1, 3, 5]

Salida

[0, 2, 4, 6, 8]
[1, 3, 5, 7, 9]
[0, 3, 6, 9]
[1, 3, 5]

Cuando usas un paso, por defecto se empieza en 0 y se llega hasta el final de la secuencia. Solo tienes que indicar el inicio y la parada si quieres acotar el rango.

¿Cómo funcionan los índices negativos en el rebanado?

Los índices negativos cuentan desde el final de la secuencia. -1 es el último elemento, -2 el penúltimo, y así sucesivamente. Puedes usar números negativos en cualquier parte de la porción: en start, en stop o en step.

Rebanado con índices negativos

letters = ['a', 'b', 'c', 'd', 'e', 'f']

# Last three items

print(letters[-3:]) # ['d', 'e', 'f']

# Everything except the last two

print(letters[:-2]) # ['a', 'b', 'c', 'd']

# From second-to-last to last

print(letters[-2:]) # ['e', 'f']

Salida

['d', 'e', 'f']
['a', 'b', 'c', 'd']
['e', 'f']

Los índices negativos son utilísimos cuando quieres elementos contando desde el final. Por ejemplo, my_list[-3:] siempre te da los tres últimos elementos, sea cual sea la longitud de la lista.

Rebanado negativo con cadenas

word = 'Python'

# Remove first and last character

print(word[1:-1]) # ytho

# Last 4 characters

print(word[-4:]) # thon

# First 2 characters

print(word[:2]) # Py

Salida

ytho
thon
Py

Cómo invertir una secuencia con [::-1]

Un paso negativo le dice a Python que vaya hacia atrás. El patrón más común es [::-1], que invierte la secuencia entera. Sin inicio, sin parada y con paso -1: recorre del final al principio.

Invertir con [::-1]

# Reverse a list

numbers = [1, 2, 3, 4, 5]

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

# Reverse a string

word = 'hello'

print(word[::-1]) # olleh

# Reverse a tuple

coords = (10, 20, 30, 40)

print(coords[::-1]) # (40, 30, 20, 10)

Salida

[5, 4, 3, 2, 1]
olleh
(40, 30, 20, 10)

Puedes combinar un paso negativo con start y stop para invertir solo una parte. Con un paso negativo, start debe ser mayor que stop, porque vas hacia atrás.

Paso negativo con start y stop

numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

# Reverse items from index 7 down to index 2 (not including 2)

print(numbers[7:2:-1]) # [7, 6, 5, 4, 3]

# Every other item, reversed

print(numbers[::-2]) # [9, 7, 5, 3, 1]

Salida

[7, 6, 5, 4, 3]
[9, 7, 5, 3, 1]

Rebanado de cadenas, listas y tuplas

La misma sintaxis [start:stop:step] funciona con todos los tipos de secuencia. La única diferencia es lo que obtienes: al rebanar una lista obtienes una lista, al rebanar una cadena obtienes una cadena y al rebanar una tupla obtienes una tupla.

El rebanado conserva el tipo

# Slicing a string -> string

name = 'Alexander'

print(name[0:4]) # Alex

print(type(name[0:4])) # <class 'str'>

# Slicing a list -> list

scores = [90, 85, 77, 92, 88]

print(scores[1:4]) # [85, 77, 92]

# Slicing a tuple -> tuple

point = (10, 20, 30, 40, 50)

print(point[::2]) # (10, 30, 50)

Salida

Alex
<class 'str'>
[85, 77, 92]
(10, 30, 50)

Patrones de rebanado imprescindibles en Python

Estos son los patrones de rebanado que más vas a ver y usar. Tómalos como tu referencia rápida.

Seis patrones de rebanado esenciales

data = ['a', 'b', 'c', 'd', 'e', 'f', 'g']

# First N items

print(data[:3]) # ['a', 'b', 'c']

# Last N items

print(data[-3:]) # ['e', 'f', 'g']

# Remove first item

print(data[1:]) # ['b', 'c', 'd', 'e', 'f', 'g']

# Remove last item

print(data[:-1]) # ['a', 'b', 'c', 'd', 'e', 'f']

# Middle items (remove first and last)

print(data[1:-1]) # ['b', 'c', 'd', 'e', 'f']

# Reverse the whole thing

print(data[::-1]) # ['g', 'f', 'e', 'd', 'c', 'b', 'a']

Salida

['a', 'b', 'c']
['e', 'f', 'g']
['b', 'c', 'd', 'e', 'f', 'g']
['a', 'b', 'c', 'd', 'e', 'f']
['b', 'c', 'd', 'e', 'f']
['g', 'f', 'e', 'd', 'c', 'b', 'a']

También puedes usar el rebanado en el lado izquierdo de una asignación para reemplazar una parte de una lista. Esto se llama asignación por porciones (slice assignment).

Asignación por porciones (solo listas)

colors = ['red', 'green', 'blue', 'yellow', 'purple']

# Replace items at index 1 and 2

colors[1:3] = ['lime', 'sky']

print(colors) # ['red', 'lime', 'sky', 'yellow', 'purple']

# You can even replace with a different number of items

colors[1:3] = ['orange']

print(colors) # ['red', 'orange', 'yellow', 'purple']

Salida

['red', 'lime', 'sky', 'yellow', 'purple']
['red', 'orange', 'yellow', 'purple']

Ejercicios de práctica

Obtén los elementos del medio

Escribe el código

Dada la lista animals, usa el rebanado para imprimir solo los tres elementos del medio: ['cat', 'dog', 'elephant'].

animals = ['ant', 'bear', 'cat', 'dog', 'elephant', 'fox', 'giraffe']

# Print the middle three items using slicing

Predice la salida de la porción

Predice la salida

¿Qué imprime este código? Piensa bien en los índices negativos.

word = 'programming'
print(word[-4:])

Escribe el código y ejecútalo para comprobar tu predicción.

# What does this print?

word = 'programming'

print(word[-4:])

Extrae los elementos con índice par

Escribe el código

Dada la lista letters, usa el rebanado con un paso para imprimir solo los elementos con índice par (0, 2, 4, 6). El resultado debe ser ['a', 'c', 'e', 'g'].

letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']

# Print items at even indices using slicing

Invierte una palabra

Escribe el código

Usa el rebanado para invertir la cadena word e imprime el resultado. La salida debe ser nohtyp.

word = 'python'

# Reverse the word using slicing and print it

Corrige el error de rebanado

Corrige el error

Este código intenta obtener los tres últimos elementos de una lista, pero usa la porción equivocada. Corrige el error para que imprima ['date', 'elderberry', 'fig'].

fruits = ['apple', 'banana', 'cherry', 'date', 'elderberry', 'fig']

# Bug: this doesn't get the last three items

last_three = fruits[3:0]

print(last_three)

Detector de palíndromos

Escribe el código

Escribe una función llamada is_palindrome(text) que devuelva True si el texto se lee igual en ambos sentidos, y False en caso contrario. Usa el rebanado para invertir la cadena. Convierte antes el texto a minúsculas para que la comprobación no distinga entre mayúsculas y minúsculas.

Pruébala con estas llamadas:

print(is_palindrome('racecar'))
print(is_palindrome('Python'))
print(is_palindrome('Madam'))

¿Cómo funciona el rebanado básico?

¿Qué hace el parámetro step?

¿Cómo funcionan los índices negativos en el rebanado?

Cómo invertir una secuencia con [::-1]

Rebanado de cadenas, listas y tuplas

Patrones de rebanado imprescindibles en Python

Ejercicios de práctica

Tutoriales relacionados