Segmentos 🍕 — Python: Listas

• Sintaxis de los segmentos
• Selección de elementos
• Asignación de segmento
• Segmentos como valores
• Relación entre START y STOP

Ahora que ya conoces cómo trabajar con elementos individuales, vamos a explorar una herramienta muy interesante que Python ofrece para manejar subconjuntos completos de una lista, los segmentos (slices).

Sintaxis de los segmentos

Un segmento se registra de la misma manera que se registra una referencia a un elemento de la lista por índice:

some_list[START:STOP:STEP]

Un segmento tiene tres parámetros:

• START es el índice del primer elemento en la selección.
• STOP es el índice del elemento de la lista, antes del cual el segmento debería terminar. El propio elemento con el índice STOP no se incluirá en la selección.
• STEP es el paso de los índices seleccionados.

l = [1, 2, 3, 4, 5]
# Segmento desde el índice cero hasta el tercero con paso 1
segmento = l[0:3:1]
print(segmento) # => [1, 2, 3]

# Segmento desde el índice cero hasta el tercero con paso 2
segmento = l[0:3:2]
print(segmento) # => [1, 3]

Sin embargo, cualquiera de los tres parámetros del segmento puede omitirse y se usará el valor predeterminado para el parámetro correspondiente:

• Por defecto, START significa "desde el principio de la lista".
• Por defecto, STOP significa "hasta el final de la lista".
• Por defecto, STEP significa "tomar cada elemento".

Aquí hay algunos ejemplos con diferentes conjuntos de parámetros:

• [:] o [::] es toda la lista.
• [::2] son los elementos impares por orden.
• [1::2] son los elementos pares por orden.
• [::-1] son todos los elementos en orden inverso.
• [5:] son todos los elementos desde el sexto en adelante.
• [:5] son todos los elementos, hasta el quinto sin incluirlo.
• [-2:1:-1] son todos los elementos desde el penúltimo al tercero en orden inverso. En todos los casos, cuando se selecciona de un índice mayor a uno más pequeño, es necesario indicar el paso.

Ahora veamos cómo se pueden utilizar los segmentos.

Selección de elementos

Los segmentos trabajan no solo con listas, sino también con tuplas, e incluso con cadenas. El resultado de una selección siempre es un nuevo valor del tipo correspondiente - lista, tupla, cadena:

word = 'hello'
print(word[2:])  # => llo

user_data = ('Juan', 'juan@example.com', 'student',)
print(user_data[1::])  # ('juan@example.com', 'student')

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print(numbers[1::2])  # [2, 4, 6, 8, 10]

Asignación de segmento

A diferencia de las cadenas y las tuplas, las listas son mutables. Una de las formas de modificarlas es asignar un nuevo valor a un segmento de la lista. Puedes asignar una lista de nuevos elementos a un segmento con un paso específico:

l = [1, 2, 3, 4, 5, 6]
l[::2] = [0, 0, 0]
print(l)  # => [0, 2, 0, 4, 0, 6]

El segmento [::2] significa que seleccionamos elementos con un paso de 2, es decir, tomamos cada segundo elemento. La lista [0, 0, 0] es la lista que asignamos a los elementos seleccionados. El segmento l[::2] ahora contiene los elementos con los índices 0, 2 y 4 (es decir, 1, 3 y 5). Asignar [0, 0, 0] a estos elementos los reemplaza por ceros. Como resultado, la lista l ahora es [0, 2, 0, 4, 0, 6].

Si intentas asignar una cantidad incorrecta de elementos a un segmento con un paso, obtendrás un error:

l = [1, 2, 3, 4]
l[::2] = [5, 6, 7]
# Traceback (most recent call last):
#   File "<stdin>", line 1, in <module>
# ValueError: attempt to assign sequence of size 3 to extended slice of size 2

Si el segmento es continuo, es decir, el paso no está especificado y los índices son consecutivos, entonces se nos da más libertad. A este tipo de segmento se le puede asignar más elementos, lo que hará que la lista crezca, o menos, lo que resultará en una lista truncada:

l = [1, 2, 3]
l[2:] = [4, 5]
print(l)  # => [1, 2, 4, 5]
l[1:-1] = [100]
print(l)  # => [1, 100, 5]
l[:] = []
print(l)  # => []

Al principio, la lista crece, luego se reduce, y al final se vuelve completamente vacía, todo gracias a la sintaxis compacta pero potente de los segmentos.

Segmentos como valores

Aunque los segmentos tienen un soporte especial desde el punto de vista de la sintaxis, podemos crear y usar los segmentos por sí mismos, como valores ordinarios.

Puedes construir un valor de segmento con la función slice():

first_two = slice(2)
each_odd = slice(None, None, 2)
print(each_odd)  # => slice(None, None, 2)
l = [1, 2, 3, 4, 5]
print(l[first_two])  # => [1, 2]
print(l[each_odd])  # => [1, 3, 5]

La función slice() toma de uno a tres parámetros, los mismos START, STOP y STEP. Cuando se llama a una función con un parámetro, se llama con el parámetro STOP.

Si quieres omitir uno de los parámetros, reemplázalo con None. También puedes usar None en las anotaciones de segmento entre corchetes cuadrados, donde también significará omitir un valor.

En lugar de los parámetros de segmento, pueden haber cualquier tipo de expresiones, siempre que estas expresiones se calculen en números enteros o None.

Relación entre START y STOP

En un segmento, el elemento con el índice STOP no se incluye en el resultado, a diferencia del elemento con el índice START.

Puedes usar esta característica, sin importar qué índice no negativo n elijas, para cualquier lista se cumplirá la igualdad especificada:

l = [1, 2, 3, 4, 5]
n = 2
l == l[:n] + l[n:] # True

Miremos este ejemplo:

word = 'Hello!'
print(word[:2] + word[2:])  # => 'Hello!'
print(word[:4] + word[4:])  # => 'Hello!'
print(word[:0] + word[0:] == word)  # => True
print(word[:100] + word[100:] == word)  # => True

Esta propiedad es útil para usar cuando estás analizando algún texto. Solo necesitas mover la posición de corte de la cadena al principio y al resto, sin preocuparte de que alguna información en el límite de corte se pierda.