post

Python sp-ar:Estructuras de Datos

Contents

Introducción

Las estructuras de datos son básicamente eso—estructuras que pueden agrupar datos. En otras palabras, se usan para almacenar una colección de datos relacionados.

Python viene con cuatro estructuras de datos—Lista, tuplo, diccionario y set. Veremos cómo se usa cada una de ellas y cómo nos hacen la vida más fácil.

Listas

Una lista es una estructura de datos que contiene una colección ordenada de cosas, es decir, puedes almacenar una secuencia de cosas en una lista. Esto es fácil de imaginar si pensamos en una lista de la compra donde apuntas las cosas que vas a comprar, excepto que probablemente en tu lista de la compra tienes cada cosa en una línea mientras que en Python se separan por comas.

La lista de cosas deberá estar entre corchetes para que Python entienda que estás especificando una lista. Una vez creada la lista, puedes añadir, quitar o buscar cosas en la lista. Como podemos añadir y quitar cosas, decimos que esa lista es de un tipo de datos mutable, o sea, este tipo puede ser alterado.

Rápida Introducción a los Objetos y Clases

Aunque he estado retrasando la discusión de objetos y clases hasta ahora, es necesaria una pequeña explicación para que puedas entender mejor las listas. Exploraremos este tema en detalle más tarde, en su propio capítulo.
Una lista es un ejemplo del uso de objetos y clases. Cuando usamos una variable i y le asignamos un valor, digamos el entero 5, se puede pensar que creamos un objeto (instancia) i de clase (tipo) int. De hecho, puedes leer help(int) para entenderlo mejor.

Una clase también puede tener métodos, funciones definidas para usarse únicamente con respecto a esa clase. Sólo se pueden usar esas funciones cuando se tiene un objeto de esa clase. Por ejemplo, Python tiene un método append para la clase lista que permite añadir una cosa al final de la lista. Por ejemplo, mi_lista.append('una cosa') añadirá esa cadena a la lista mi_lista.
Nótese el uso de la notación con punto para acceder a los métodos de los objetos.

Una clase también puede tener campos que no son otra cosa que variables definidas para usarse únicamente con respecto a esa clase. Puedes usar esas variables/nombres sólamente si tienes un objeto de esa clase. A los campos también se accede mediante la notación con punto, por ejemplo, mi_lista.campo.

Ejemplo:

#!/usr/bin/python
# Archivo: using_list.py

# Ésta es mi lista de la compra
shoplist = ['manzana', 'mango', 'zanahoria', 'plátano']

print('Tengo que comprar', len(shoplist), 'cosas')

print('Esas cosas son:', end=' ')

for item in shoplist:
    print(item, end=' ')

print('nTambién tengo que comprar arroz.')
shoplist.append('arroz')
print('Mi lista de la compra es ahora', shoplist)

print('Ahora pondré mi lista en orden.')
shoplist.sort()
print('La lista ordenada es', shoplist)

print('La primera cosa que voy a comprar es', shoplist[0])
olditem = shoplist[0]
del shoplist[0]
print('He comprado el', olditem)
print('Mi lista de la compra es ahora', shoplist)

Salida:

   $ python using_list.py
   Tengo que comprar 4 cosas.
   Esas cosas son: manzana mango zanahoria plátano
   También tengo que comprar arroz.
   Mi lista de la compra es ahora ['manzana', 'mango', 'zanahoria', 'plátano', 'arroz']
   Ahora pondré mi lista en orden.
   La lista ordenada es ['arroz', 'mango', 'manzana', 'plátano', 'zanahoria']
   La primera cosa que voy a comprar es arroz
   He comprado el arroz
   Mi lista de la compra es ahora ['manzana', 'mango', 'zanahoria', 'plátano']

Cómo Funciona

La variable shoplist es una lista de la compra para alguien que va a ir al mercado. En shoplist, sólo almacenamos cadenas de nombres de las cosas a comprar, pero puedes añadir cualquier tipo de objeto a la lista incluidos números e incluso otras listas.

También hemos usado el bucle for..in para iterar sobre las cosas de la lista. Para ahora, ya te has debido dar cuenta de que una lista es también una secuencia. Lo especial de las secuencias será discutido en otra sección más tarde.

Observa el uso de la palabra-clave end como argumento de la función print para indicar que queremos terminar la frase con un espacio en lugar del final de línea habitual.

Después, añadimos una cosa a la lista usando el método append del objeto lista, como hemos discutido antes. Entonces, comprobamos que la cosa ha sido efectivamente añadida a la lista mediante la impresión del contenido de la lista símplemente pasando la lista a la sentencia print que la imprime perfectamente.

Después, ordenamos la lista usando el método sort de la lista. Es importante entender que este método afecta a la propia lista y no devuelve una lista modificada—esto es distinto de cómo funcionan las cadenas. Esto es lo que queremos decir cuando decimos que las listas son mutables y las cadenas son inmutables.

A continuación, cuando terminamos de comprar una cosa en el mercado, queremos quitarla de la lista. Lo conseguimos usando la sentencia del. Aquí mencionamos qué cosa de la listas queremos quitar y la sentencia del la quita de la lista para nosotros. Especificamos que queremos eliminar la primera cosa de la lista y por eso usamos del shoplist[0] (recuerda que Python empieza a contar desde 0).

Si quieres saber todos los métodos definidos por el objeto lista, mira help(list) para ver los detalles.

Tuplas

Las tuplas son usadas para mantener juntos múltiples objetos. Piense que ellas son muy similares a las listas, pero sin la extensa funcionalidad que brinda esta clase. La característica mas notable de las tuplas es que son inmutables como las cadenas de caracteres, es decir no se pueden modificar.

Una tupla se define especificando elementos separados por comas en el interior de paréntesis opcionales.

Las tuplas son usadas en casos cuando una instrucción o una función definida por el usuario puede asumir con toda seguridad que la colección de valores, es decir los valores de la tupla no van a cambiar.

Ejemplo:

#!/usr/bin/python
# Archivo: using_tuple.py

zoo = ('piton', 'elefante', 'pinguino') # recuerde que los paréntesis son opcionales
print('El numero de animales en el zoológico es:', len(zoo))

nuevo_zoo = 'mono', 'camello', zoo
print('El numero de jaulas en el zoológico es:', len(nuevo_zoo))
print('Todos los animales del nuevo zoológico son:', nuevo_zoo)
print('Los animales traídos del zoológico viejo son:', nuevo_zoo[2])
print('El ultimo animal traído del zoológico viejo es:', nuevo_zoo[2][2])
print('El numero de animales en el nuevo zoológico es:', len(nuevo_zoo)-1+len(nuevo_zoo[2]))

Salida:

   $ python using_tuple.py
   El numero de animales en el zoológico es: 3
   El numero de jaulas en el zoológico es: 3
   Todos los animales del nuevo zoológico son: ('mono', 'camello', ('piton', 'elefante', 'pinguino'))
   Los animales traídos del zoológico viejo son: ('piton', 'elefante', 'pinguino')
   El ultimo animal traído del zoológico viejo es: pinguino
   El numero de animales en el nuevo zoológico es: 5

Como Funciona:

La variable zoo es una tupla de elementos. Vemos que la función len puede ser usada para obtener la longitud de una tupla, esto indica que la tupla también es una secuencia.

Ahora vamos a mover los animales a un nuevo zoológico por que el viejo va a ser cerrado. Por lo tanto, la tupla nuevo_zoo contendrá algunos animales que ya estaban ahí junto con los animales traídos del viejo zoológico. De vuelta a la realidad, observe que una tupla contenida en otra tupla no pierde su identidad.

Podemos acceder a los elementos en una tupla especificando la posición del elemento rodeado por un par de corchetes como lo hicimos para las listas. Este es llamado operador de indexación. Especificando nuevo_zoo[2] accedimos al tercer elemento en nuevo_zoo y especificando nuevo_zoo[2][2] podemos acceder al tercer elemento en el interior del tercer elemento de la tupla nuevo_zoo. Esto le sera mucho mas sencillo, une vez que entienda el lenguaje.

Paréntesis
Aunque los paréntesis son opcionales, yo prefiero tenerlos siempre para hacer obvio que es una tupla, específicamente porqué esto evita la ambigüedad. Por ejemplo print(1,2,3) y print( (1,2,3) ) significan dos cosas diferentes – la primera imprime 3 números mientras que la ultima imprime una tupla (la cual contiene tres números).
Tuplas con 0 o 1 elementos
Una tupla vacía es construida con un par de paréntesis vacíos como mivacia = (). Sin embargo una tupla con un solo elemento no es tan simple, se debe especificar esta usando una coma seguido del primer (y único) elemento, entonces Python puede diferenciar entre una tupla y un par de paréntesis rodeando a un objeto, es decir, usted debe especificar solo = (2 , ) si quiere una tupla conteniendo el elemento 2.
Nota para programadores de Perl
Una lista en el interior de otra lista no pierde su identidad, es decir, las listas no son aplanadas como en Perl. Lo mismo aplica para una tupla dentro de una tupla, o una tupla dentro de una lista o una lista dentro de una tupla etc. Hasta donde a Python le interesa, estos son objetos almacenados usando otro objeto, eso es todo.

Diccionarios

Un diccionario es como un directorio donde se encuentra la dirección o información de contacto para una persona, solo conociendo su nombre, es decir nosotros asociamos llaves (nombre) con un valor (información) Tenga en cuenta que la llave debe ser única, si usted tiene 2 personas con exactamente el mismo nombre no podría encontrar la informacion correcta.

Note que solo puede usar objetos inmutables (como cadenas de caracteres) para las llaves de un diccionario, pero puede usar objetos inmutables y mutables para los valores de este. Básicamente esto significa que debería usar solo objetos simples para las llaves.

Pares de claves y valores son especificados en un diccionario usando la notación d = {clave1: valor1, clave2: valor2}. Observe que los pares clave-valor son separados por un dos puntos, los pares son separados entre ellos por comas y todo es encerrado por un par de llaves.

Recuerde que los pares clave-valor de un diccionario no son ordenados de manera alguna. Si quiere un orden en particular, entonces tendrá que ordenarlos antes de usarlos.

Los diccionarios que va a usar son instancias/objetos de la clase dict.

Ejeplo:

#!/usr/bin/python
# Archivo: using_dict.py

# 'di' es la abreviatura para 'di'rectorio

di = {  'Swaroop'  : 'swaroop@swaroopch.com',
        'Larry'    : 'larry@wall.org',
        'Matsumoto': 'matz@ruby-lang.org',
        'Spammer'  : 'spammer@hotmail.com'
    }

print("La dirección de Swaroop es", di['Swaroop'])

# Borrando un par clave-valor
del di['Spammer']

print('nHay {0} contactos en el directorion'.format(len(di)))

for nombre, direccion in di.items():
    print('Contacto {0} en {1}'.format(nombre, direccion))

# Añadiendo un par clave-valor
di['Guido'] = 'guido@python.org'

if 'Guido' in di:
    print("nLa dirección de Guido es", di['Guido'])

Salida:

  $ python using_dict.py
  La dirección de Swaroop es swaroop@swaroopch.com

  Hay 3 contactos en el directorio

  Contacto Swaroop en swaroop@swaroopch.com
  Contacto Matsumoto en matz@ruby-lang.org
  Contacto Larry en larry@wall.org

  La dirección de Guido es guido@python.org

Como Funciona:

Usando la notación anteriormente discutida creamos el diccionario di. Luego accedemos a los pares clave-valor especificando la clave al operador de indexado como fue discutido con las listas y tuplas. Note lo simple que es la sintaxis.

Podemos eliminar pares clave-valor con nuestro viejo amigo – la instrucción del. Simplemente le especificamos a del el diccionario y el indexado para la clave que va a ser eliminada. No es necesario conocer el valor que le corresponde a la calve para esta operación.

Ahora, vamos a acceder a cada par clave-valor del diccionario usando el método items del diccionario el cual retorna una lista de tuplas, donde cada tupla contiene un par de elementos – la clave seguida por el valor. Luego recuperamos el par correspondiente a cada ciclo de bucle for..in y se lo asignamos a las variables nombre y direccion, para después imprimir estos valores en el bloque for.

Podemos añadir nuevos pares clave-valor, simplemente usando el operador de indexación para acceder a la clave y asignar un valor, como lo hicimos para Guido en el anterior ejemplo.

También podemos verificar si un par clave-valor existe usando el operador in.

Para mostrar los métodos de la clase dict, revise help(dict).

Argumentos por Palabra Clave y Diccionarios
Como una observación diferente, si ha usado argumentos por palabra clave en sus funciones, entonces ya ha tratado con diccionarios!. Solo piense en esto – el par clave-valor lo especifica en la lista de parámetros de la definición para la función y cuando accede a las variables dentro de su función, es solo una clave de un diccionario (el cual es llamado tabla simbólica en terminología de diseño del compilador).

Secuencias

Advertisements