Ahora que sabemos qué son las clases, los objetos, las funciones, y los métodos es el momento de revisitar estos objetos para descubrir su verdadero potencial.

Veremos a continuación algunos métodos útiles de estos objetos. Evidentemente, no es necesario que los memoricéis, pero si, al menos, recordar que existen para cuando os hagan falta.

Diccionarios

D.has_key(k)
Comprueba si el diccionario tiene la clave k. Es equivalente a la sintaxis k in D.

D.items()
Devuelve una lista de tuplas con pares clave-valor.

D.keys()
Devuelve una lista de las claves del diccionario.

D.pop(k[, d])
Borra la clave k del diccionario y devuelve su valor. Si no se encuentra dicha clave se devuelve d si se especificó el parámetro o bien se lanza una excepción.

D.values()
Devuelve una lista de los valores del diccionario.

Cadenas

S.count(sub[, start[, end]])
Devuelve el número de veces que se encuentra sub en la cadena. Los parámetros opcionales start y end definen una subcadena en la que buscar.

S.find(sub[, start[, end]])
Devuelve la posición en la que se encontró por primera vez sub en la cadena o -1 si no se encontró.

S.join(sequence)
Devuelve una cadena resultante de concatenar las cadenas de la secuencia seq separadas por nuestra cadena.

S.partition(sep)
Busca el separador sep en la cadena y devuelve una tupla con la subcadena hasta dicho separador, el separador en si, y la subcadena del separador hasta el final de la cadena. Si no se encuentra el separador, la tupla contendrá la cadena en si y dos cadenas vacías.

S.replace(old, new[, count])
Devuelve una cadena en la que se han reemplazado todas las ocurrencias de la cadena old por la cadena new. Si se especifica el parámetro count, este indica el número máximo de ocurrencias a reemplazar.

S.split([sep [,maxsplit]])
Devuelve una lista conteniendo las subcadenas en las que se divide nuestra cadena al dividirlas por el delimitador sep. En el caso de que no se especifique sep, se usan espacios. Si se especifica maxsplit, este indica el número máximo de particiones a realizar.

Listas

L.append(object)
Añade un objeto al final de la lista.

L.count(value)
Devuelve el número de veces que se encontró value en la lista.

L.extend(iterable)
Añade los elementos del iterable a la lista.

L.index(value[, start[, stop]])
Devuelve la posición en la que se encontró la primera ocurrencia de value. Si se especifican, start y stop definen una sublista en la que buscar.

L.insert(index, object)
Inserta el objeto object en la posición index.

L.pop([index])
Devuelve el valor en la posición index y lo elimina de la lista. Si no se especifica la posición, se utiliza el último elemento de la lista.

L.remove(value)
Eliminar la primera ocurrencia de value en la lista.

L.reverse()
Invierte la lista. Esta función trabaja sobre la propia lista desde la que se invoca el método, no sobre una copia.

L.sort(cmp=None, key=None, reverse=False)
Ordena la lista. Si se especifica cmp, este debe ser una función que tome como parámetro dos valores x e y de la lista y devuelva -1 si x es menor que y, 0 si son iguales y 1 si x es mayor que y.

El parámetro reverse es un booleano que indica si se debe ordenar la lista de forma inversa, lo que sería equivalente a llamar primero a L.sort() y después a L.reverse().

Por último, si se especifica, el parámetro key debe ser una función que tome un elemento de la lista y devuelva una clave a utilizar a la hora de comparar, en lugar del elemento en si.

Listas

La lista es un tipo de colección ordenada. Sería equivalente a lo que en otros lenguajes se conoce por arrays, o vectores.

Las listas pueden contener cualquier tipo de dato: números, cadenas, booleanos, … y también listas.

Crear una lista es tan sencillo como indicar entre corchetes, y separados por comas, los valores que queremos incluir en la lista:

l = [22, True, "una lista", [1, 2]]

Podemos acceder a cada uno de los elementos de la lista escribiendo el nombre de la lista e indicando el índice del elemento entre corchetes. Ten en cuenta sin embargo que el índice del primer elemento de la lista es 0, y no 1:

mi_var = l[0] # mi_var vale 22

Si queremos acceder a un elemento de una lista incluida dentro de otra lista tendremos que utilizar dos veces este operador, primero para indicar a qué posición de la lista exterior queremos acceder, y el segundo para seleccionar el elemento de la lista interior:

mi_var = l[3][0] # mi_var vale 1

También podemos utilizar este operador para modificar un elemento de la lista si lo colocamos en la parte izquierda de una asignación:

l[0] = 99 # l vale [99, True, "una lista", [1, 2]]

El uso de los corchetes para acceder y modificar los elementos de una lista es común en muchos lenguajes, pero Python nos depara varias sorpresas muy agradables.

Una curiosidad sobre el operador [] de Python es que podemos utilizar también números negativos. Si se utiliza un número negativo como índice, esto se traduce en que el índice empieza a contar desde el final, hacia la izquierda; es decir, con [-1] accederíamos al último elemento de la lista, con [-2] al penúltimo, con [-3], al antepenúltimo, y así sucesivamente.

Otra cosa inusual es lo que en Python se conoce como slicing o particionado, y que consiste en ampliar este mecanismo para permitir seleccionar porciones de la lista. Si en lugar de un número escribimos dos números inicio y fin separados por dos puntos (inicio:fin) Python interpretará que queremos una lista que vaya desde la posición inicio a la posición fin, sin incluir este último. Si escribimos tres números (inicio:fin:salto) en lugar de dos, el tercero se utiliza para determinar cada cuantas posiciones añadir un elemento a la lista.

mi_var = l[0:2]   # mi_var vale [99, True]
mi_var = l[0:4:2] # mi_var vale [99, "una lista"]

Los números negativos también se pueden utilizar, con el mismo comportamiento que se comentó anteriormente.

Hay que mencionar así mismo que no es necesario indicar el principio y el final del slicing, sino que, si estos se omiten, se usarán por defecto las posiciones de inicio y final de la lista respectivamente:

mi_var = l[1:]  # mi_var vale [True, "una lista", [1, 2]]
mi_var = l[:2]  # mi_var vale [99, True]
mi_var = l[:]   # mi_var vale [99, True, "una lista", [1, 2]]
mi_var = l[::2] # mi_var vale [99, "una lista"]

También podemos utilizar este mecanismo para modificar la lista:

l[0:2] = [0, 1] # l vale [0, 1, "una lista", [1, 2]]

pudiendo incluso modificar el tamaño de la lista si la lista de la parte derecha de la asignación tiene un tamaño menor o mayor que el de la selección de la parte izquierda de la asignación:

l[0:2] = [False] # l vale [False, "una lista", [1, 2]]

En todo caso las listas ofrecen mecanismos más cómodos para ser modificadas a través de las funciones de la clase correspondiente, aunque no veremos estos mecanismos hasta más adelante, después de explicar lo que son las clases, los objetos y las funciones.

Tuplas

Todo lo que hemos explicado sobre las listas se aplica también a las tuplas, a excepción de la forma de definirla, en la que se utiliza paréntesis en lugar de corchetes.

t = (1, 2, True, "python")

En realidad el constructor de la tupla es la coma, no el paréntesis, pero el intérprete muestra los paréntesis, y nosotros deberíamos utilizarlos, por claridad.

>>> t = 1, 2, 3
>>> type(t)
type “tuple”

Además hay que tener en cuenta que es necesario añadir una coma para tuplas de un solo elemento, para diferenciarlo de un elemento entre paréntesis.

>>> t = (1)
>>> type(t)
type “int”
>>> t = (1,)
>>> type(t)
type “tuple”

Para referirnos a elementos de una tupla, como en una lista, se usa el operador []:

mi_var = t[0] # mi_var es 1
mi_var = t[0:2] # mi_var es (1, 2)

Podemos utilizar el operador [] debido a que las tuplas, al igual que las listas, forman parte de un tipo de objetos llamados secuencias. Permitirme un pequeño inciso para indicaros que las cadenas de texto también son secuencias, por lo que no os extrañará que podamos hacer cosas como estas:

c = "hola mundo"
c[0]   # h
c[5:]  # mundo
c[::3] # hauo

Volviendo al tema de las tuplas, su diferencia con las listas estriba en que las tuplas no poseen estos mecanismos de modificación tan útiles de los que hablábamos al final de la anterior sección. También son inmutables, es decir, sus valores no se pueden modificar una vez creada; y de tamaño fijo. A cambio las tuplas son más “ligeras” que las listas, por lo que si el uso que le vas a dar a tu colección es muy básico, puedes utilizar tuplas en lugar de listas y ahorrar memoria.

Diccionarios

Los diccionarios, también llamados matrices asociativas, deben su nombre a que son colecciones que relacionan una clave y un valor. Por ejemplo, veamos un diccionario de películas y directores:

d = {"Love Actually ": "Richard Curtis",
     "Kill Bill": "Tarantino",
     "Amélie": "Jean-Pierre Jeunet"}

El primer valor se trata de la clave y el segundo del valor asociado a la clave. Como clave podemos utilizar cualquier valor inmutable: podríamos usar números, cadenas, booleanos, tuplas, … pero no listas o diccionarios, dado que son mutables. Esto es así porque los diccionarios se implementan como tablas hash, y a la hora de introducir un nuevo par clave-valor en el diccionario se calcula el hash de la clave para después poder encontrar la entrada correspondiente rápidamente. Si se modificara el objeto clave después de haber sido introducido en el diccionario, evidentemente, su hash también cambiaría y no podría ser encontrado.

La diferencia principal entre los diccionarios y las listas o las tuplas es que a los valores almacenados en un diccionario se les accede no por su índice, porque de hecho no tienen orden, sino por su clave, utilizando de nuevo el operador [].

d["Love Actually "] # devuelve "Richard Curtis"

Al igual que en listas y tuplas también se puede utilizar este operador para reasignar valores.

d["Kill Bill"] = "Quentin Tarantino"

Sin embargo en este caso no se puede utilizar slicing, entre otras cosas porque los diccionarios no son secuencias, si no mappings (mapeados, asociaciones).