Secuencias

Listas y tuplas en Python son objetos que contienen listas de datos a los que se accede mediante un índice, de forma similar a los arreglos (vectores o matrices) de otros lenguajes. Pertenecen a un tipo de datos que Python llama secuencias y que incluyen también a las cadenas de texto.

Antes de entrar en las diferencias entre los tipos de secuencias, veamos lo que tienen en común:

  • No hay un límite a la cantidad de elementos que pueden contener.
  • Pueden contener cualquier tipo de objeto, incluyendo otras secuencias. Por ejemplo, la forma de crear una matriz en Python es crear una lista de listas.
  • No es necesario saber el tamaño (cantidad de elementos) que tendrá la secuencia al momento de crearla.
  • Soportan algunas funciones nativas de python:
    • len(secuencia): devuelve la cantidad de elementos de la lista, tupla o cadena.
    • max(secuencia): devuelve el mayor elemento.
    • min(secuencia): devuelve el menor elemento.
  • Tienen dos métodos comunes:
    • secuencia.index(‘x’): devuelve el índice de la primera ocurrencia de ‘x’ en la secuencia.
    • secuencia.count(‘x’): devuelve el número de veces que aparece ‘x’ en la secuencia
  • Los elementos de la secuencia se acceden vía subíndices, que se indican entre corchetes [] después del nombre de la variable que contiene a la secuencia:
    • secuencia[0]: devuelve el primer elemento
    • secuencia[2]: devuelve el tercer elemento (notar que se numeran desde 0 y no desde 1).
    • secuencia[i]: devuelve el elemento i-1 de la secuencia.
    • secuencia[-1]: devuelve el último elemento.

Si sabes algo de PHP o Javascript verás que las secuencias en Python son muy similares a los arreglos en estos lenguajes. Veamos ahora con más detalles otras características importantes de las secuencias.

Join (unión)

Podemos tomar una secuencia (cuyos elementos sean cadenas) y transformarla en una cadena, usando la función join(). Esta función coloca un separador entre dos elementos de la secuencia. Si guardamos nuestro separador en una variable s, debemos escribir:

s.join(secuencia)

Por ejemplo, para separar con guiones una lista de números, hacemos:

>>> '-'.join(['1', '2', '3', '4', '5', '6'])
'1-2-3-4-5-6'
>>> ''.join(['1', '2', '3', '4', '5', '6']) # el separador puede ser la cadena vacía
'123456'
>>> ' es menor que '.join(['1', '2', '3', '4', '5', '6']) # o una palabra o frase completa
'1 es menor que 2 es menor que 3 es menor que 4 es menor que 5 es menor que 6'

Rebanadas (slices)

Se puede obtener una parte de la secuencia original usando secuencia[x:y:z], con x, y, z enteros. Lo anterior devuelve una nueva secuencia con las siguientes características:

  • Del mismo tipo que la original (una rebanada de una lista es una lista, una rebanada de una tupla es una tupla, y una rebanada de una cadena es una cadena).
  • Conteniendo los elementos desde secuencia[x] hasta secuencia[y-1] (no incluye a secuencia[y]).
  • Salteándose z elementos cada vez.

Por ejemplo, para obtener los números impares en una lista del 1 al 10, podemos hacer lo siguiente:

>>> [1, 2, 3, 4, 5, 6, 7, 8, 9, 10][0:10:2] # desde el elemento 0 al elemento 9, de 2 en 2.
[1, 3, 5, 7, 9]

Para obtener el segundo y tercer elemento de una tupla:

>>> (1, 2, 3, 4)[1:3]
(2, 3)

El tercer parámetro puede omitirse y eso quiere decir que no se deben saltear elementos (se asumirá z = 1). De hecho, también pueden omitirse los demás: si se omite x se tomarán todos los elementos desde el primero, y si se omite “y” se tomarán todos los elementos hasta el final. Por lo tanto:

  • sec[:4] devuelve los primeros 4 elementos (0, 1, 2, 3).
  • sec[4:] devuelve los elementos desde el 5º hasta el último.
  • sec[:] crea una secuencia con todos los elementos de la primera y es de hecho la forma usual de copiar una secuencia.

Iterables

Tal y como se explicó en el capítulo 3, las listas y tuplas se pueden recorrer elemento a elemento con el bucle for. La explicación de Eugenia Bahit es muy clara, por lo que solamente agregaré que el bucle for puede recorrer cualquier tipo de secuencia, y como las cadenas son secuencias, se las puede recorrer letra a letra:

>>> saludo = "hola"
>>> for letra in saludo:
...    print "letra = ", letra
...
letra = h
letra = o
letra = l
letra = a

Operador de pertenencia

Para probar si un elemento pertenece a una secuencia, usamos el operador in. Ejemplos:

>>> 'o' in 'hola' # ¿'o' pertenece a la cadena 'hola'?
True
>>> 1 in (1, 2) # ¿1 pertenece a la tupla (1, 2)?
True
>>> 'a' in ['b', 'c'] # ¿'a' pertenece a la lista ['b', 'c']?
False
>>> 'a' not in ['b', 'c'] # ¿'a' NO pertenece a la lista ['b', 'c']?
True

Concatenación (suma)

La suma de dos secuencias a y b genera una nueva secuencia que contiene los elementos de ambas y en la que los elementos de b aparecen luego de los elementos de a. Las secuencias deben ser del mismo tipo (no es posible sumar cadenas y tuplas, o tuplas y listas, por ejemplo):

>>> 'ho' + 'la'
'hola'
>>> (1, 2) + (3, 4) + (5, 6)
(1, 2, 3, 4, 5, 6)
>>> (1, 2) + [3, 4]
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: can only concatenate tuple (not "list") to tuple

Multiplicación

Python define la multiplicación de secuencias por un número entero n. El resultado de la operación es el mismo que el de sumar la secuencia a sí misma n veces.

>>> 'a' * 5
'aaaaa'
>>> 'ab' * 2
'abab'
>>> (4, 5) * 3
(4, 5, 4, 5, 4, 5)

[tipexperto titulo = “Nota”] Si sabes PHP, verás que lo siguiente es muy similar a cómo funciona la función list() de PHP.[/tipexperto]

Desempaquetado (unpacking)

Python permite asignar los elementos de una secuencia a diferentes variables. No se requiere un operador especial, el desempaquetado es automático cuando se asigna (usando =) una secuencia a una lista de variables. De forma algo más simple: del lado izquierdo del signo de igual se escribe una lista de variables separadas por comas, y del lado derecho la secuencia que será desempaquetada.

La cantidad de variables del lado izquierdo debe ser la misma que la cantidad de elementos de la secuencia. Como esto puede sonar complicado, mejor veamos algunos ejemplos:

>>> a, b, c, d = 'hola'
>>> print a
'h'
>>> print b
'o'
>>> print c
'l'
>>> print d
'a'
>>> a, b = [1, 2]
>>> print a
1
>>> print b
2
>>> a, b = 'hola' #ERROR: ¡4 valores en la secuencia y solamente 2 variables!
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: too many values to unpack

Esto es lo que todas las secuencias tienen en común. Veamos ahora las particularidades de cada una.

Listas

Las listas en Python son equivalentes a los arreglos en PHP o en Javascript. Para crear una lista, simplemente se declaran sus elementos entre corchetes:

>>> mi_lista = [1, 'b', 'd', 23]
>>> mi_lista_vacia = [] # crea una lista sin elementos

Para agregar elementos a una lista, se utiliza el método append:

>>> mi_lista.append(10)
>>> print mi_lista
[1, 'b', 'd', 23, 10]

Para modificar un elemento particular de una lista, se asigna el nuevo valor al subíndice correspondiente:

>>> mi_lista[0] = 2
>>> print mi_lista
[2, 'b', 'd', 23, 10]

Incluso se pueden reemplazar trozos de una lista con otra, o con trozos de otra, usando la notación de rebanadas (slices):

>>> mi_lista[0:2] = [3, 4] # reemplazar los dos primeros elementos de la lista con los elementos de [3, 4]
>>> print mi_lista
[3, 4, 'd', 23, 10]

Es importante notar que lo anterior no es lo mismo que asignar una secuencia entera a un índice:

>>> mi_lista[0] = [3, 4] # el primer elemento de mi_lista es ahora la lista [3, 4]
>>> print mi_lista
[[3, 4], 4, 'd', 23, 10]

Las listas poseen algunos métodos propios: se puede eliminar un elemento con mi_lista.remove(), reordenar la lista con mi_lista.sort(), o invertir el orden de sus elementos con mi_lista.reverse(). Para una lista completa, lee la documentación sobre Mutable Sequence Types. Todas las secuencias pueden ser transformadas a listas usando la función list().

Tuplas

Las tuplas son como las listas, excepto que son inmutables (sus elementos no pueden ser modificados). Se identifican fácilmente porque en vez de usar corchetes, se definen entre paréntesis. En lo demás, funcionan igual a las listas y al resto de las secuencias.

>>> mi_tupla = (3, 4, 'b', 'd')
>>> mi_tupla[2] = 'hola' # ERROR: ¡la tupla no se puede modificar!
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

Python genera tuplas de forma automática cuando encuentra valores separados por comas en el código, aunque no estén delimitados por paréntesis. Esta generación automática es lo contrario del desempaquetado, y se llama, lógicamente, empaquetado (packing) de valores. Esto nos permite simular retorno de múltiples valores en las funciones, o intercambiar los valores de dos variables sin crear una variable auxiliar:

var1, var2 = x, y

En este caso, Python crea una tupla (x, y) (empaquetado), e inmediatamente asigna el primer elemento a var1, y el segundo a var2 (desempaquetado)

def mi_funcion():
 # código de la función
 ...
 return x, y

Aunque se especifiquen 2 variables, en realidad python crea la tupla (x, y) y eso es lo que devuelve. En el código que llama a la función, podemos escribir

var1, var2 = mi_funcion()

Gracias al desempaquetado, var1 obtiene el valor de “x” y var2 el de “y”. Todas las secuencias pueden ser transformadas a tuplas usando la función tuple().

Cadenas

Las cadenas son secuencias cuyos elementos son los caracteres individuales. Por la importancia que tiene el texto en casi cualquier programa y dado que las cadenas tienen muchas operaciones específicas que no están definidas para las demás secuencias.

En el capítulo de la próxima semana, detallaremos las características únicas de las cadenas de texto en Python.