Dominando las Estructuras de Datos de Python

Introducción

Esta sección introduce estructuras de datos en forma de tuplas y diccionarios.

Tipos de datos primitivos

Python tiene algunos tipos primitivos de datos:

Enteros
Números de punto flotante
Cadenas (texto)

Los aprendimos en la introducción.

Tipo None

email_address = None

None se utiliza a menudo como un marcador de posición para un valor opcional o faltante. Se evalúa como False en las condiciones.

if email_address:
    send_email(email_address, msg)

Estructuras de datos

Los programas reales tienen datos más complejos. Por ejemplo, información sobre una inversión en acciones:

100 acciones de GOOG a $490,10

Este es un "objeto" con tres partes:

Nombre o símbolo de la acción ("GOOG", una cadena de texto)
Número de acciones (100, un entero)
Precio (490,10, un número de punto flotante)

Tuplas

Una tupla es una colección de valores agrupados juntos.

Ejemplo:

s = ('GOOG', 100, 490.1)

A veces se omiten los () en la sintaxis.

s = 'GOOG', 100, 490.1

Casos especiales (tupla de 0 elementos, tupla de 1 elemento).

t = ()            ## Una tupla vacía
w = ('GOOG', )    ## Una tupla con 1 elemento

Las tuplas se utilizan a menudo para representar registros o estructuras simples. Típicamente, es un solo objeto con múltiples partes. Una buena analogía: Una tupla es como una sola fila en una tabla de base de datos.

Los contenidos de la tupla están ordenados (como una matriz).

s = ('GOOG', 100, 490.1)
name = s[0]                 ## 'GOOG'
shares = s[1]               ## 100
price = s[2]                ## 490.1

Sin embargo, los contenidos no se pueden modificar.

>>> s[1] = 75
TypeError: object does not support item assignment

Sin embargo, se puede crear una nueva tupla basada en una tupla actual.

s = (s[0], 75, s[2])

Empaquetado de tuplas

Las tuplas se tratan más de empaquetar elementos relacionados en una sola entidad.

s = ('GOOG', 100, 490.1)

Luego, es fácil pasar la tupla a otras partes de un programa como un solo objeto.

Desempaquetado de tuplas

Para usar la tupla en otro lugar, se pueden desempaquetar sus partes en variables.

name, shares, price = s
print('Cost', shares * price)

El número de variables en el lado izquierdo debe coincidir con la estructura de la tupla.

name, shares = s     ## ERROR
Traceback (most recent call last):
...
ValueError: too many values to unpack

Tuplas vs. Listas

Las tuplas se parecen a listas de solo lectura. Sin embargo, las tuplas se utilizan con más frecuencia para un único elemento que consta de múltiples partes. Las listas suelen ser una colección de elementos distintos, por lo general todos del mismo tipo.

record = ('GOOG', 100, 490.1)       ## Una tupla que representa un registro en un portafolio

symbols = [ 'GOOG', 'AAPL', 'IBM' ]  ## Una Lista que representa tres símbolos de acciones

Diccionarios

Un diccionario es una asignación de claves a valores. A veces también se le llama tabla hash o arreglo asociativo. Las claves sirven como índices para acceder a los valores.

s = {
    'name': 'GOOG',
   'shares': 100,
    'price': 490.1
}

Operaciones comunes

Para obtener valores de un diccionario, use los nombres de las claves.

>>> print(s['name'], s['shares'])
GOOG 100
>>> s['price']
490.10
>>>

Para agregar o modificar valores, asigne usando los nombres de las claves.

>>> s['shares'] = 75
>>> s['date'] = '6/6/2007'
>>>

Para eliminar un valor, use la instrucción del.

>>> del s['date']
>>>

¿Por qué usar diccionarios?

Los diccionarios son útiles cuando hay muchos valores diferentes y esos valores pueden ser modificados o manipulados. Los diccionarios hacen que su código sea más legible.

s['price']
## vs
s[2]

En los últimos ejercicios, escribió un programa que lee un archivo de datos portfolio.csv. Usando el módulo csv, es fácil leer el archivo línea por línea.

>>> import csv
>>> f = open('portfolio.csv')
>>> rows = csv.reader(f)
>>> next(rows)
['name','shares', 'price']
>>> row = next(rows)
>>> row
['AA', '100', '32.20']
>>>

Aunque leer el archivo es fácil, a menudo desea hacer más con los datos que solo leerlos. Por ejemplo, tal vez desee almacenarlos y comenzar a realizar algunos cálculos con ellos. Lamentablemente, una "fila" cruda de datos no le da suficiente información para trabajar. Por ejemplo, incluso un cálculo matemático simple no funciona:

>>> row = ['AA', '100', '32.20']
>>> cost = row[1] * row[2]
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
TypeError: can't multiply sequence by non-int of type'str'
>>>

Para hacer más, generalmente desea interpretar los datos crudos de alguna manera y convertirlos en un tipo de objeto más útil para poder trabajar con ellos más adelante. Dos opciones simples son tuplas o diccionarios.

Ejercicio 2.1: Tuplas

En el prompt interactivo, cree la siguiente tupla que representa la fila anterior, pero con las columnas numéricas convertidas a números adecuados:

>>> t = (row[0], int(row[1]), float(row[2]))
>>> t
('AA', 100, 32.2)
>>>

Con esto, ahora puede calcular el costo total multiplicando las acciones y el precio:

>>> cost = t[1] * t[2]
>>> cost
3220.0000000000005
>>>

¿Está rota la matemática en Python? ¿Qué pasa con la respuesta de 3220.0000000000005?

Este es un artefacto del hardware de punto flotante de su computadora que solo puede representar con precisión decimales en Base-2, no en Base-10. Para cálculos tan simples que involucran decimales en Base-10, se introducen pequeños errores. Esto es normal, aunque quizás un poco sorprendente si nunca lo ha visto antes.

Esto sucede en todos los lenguajes de programación que usan decimales de punto flotante, pero a menudo se oculta al imprimir. Por ejemplo:

>>> print(f'{cost:0.2f}')
3220.00
>>>

Las tuplas son de solo lectura. Verifíquelo intentando cambiar el número de acciones a 75.

>>> t[1] = 75
Traceback (most recent call last):
    File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
>>>

Aunque no puede cambiar el contenido de la tupla, siempre puede crear una tupla completamente nueva que reemplace a la vieja.

>>> t = (t[0], 75, t[2])
>>> t
('AA', 75, 32.2)
>>>

Cada vez que reasigna un nombre de variable existente de esta manera, el valor antiguo se descarta. Aunque la asignación anterior puede parecer que está modificando la tupla, en realidad está creando una nueva tupla y desechando la vieja.

Las tuplas a menudo se usan para empacar y desempaquetar valores en variables. Pruebe lo siguiente:

>>> name, shares, price = t
>>> name
'AA'
>>> shares
75
>>> price
32.2
>>>

Tome las variables anteriores y empáquelas nuevamente en una tupla

>>> t = (name, 2*shares, price)
>>> t
('AA', 150, 32.2)
>>>

Ejercicio 2.2: Diccionarios como estructura de datos

Una alternativa a una tupla es crear un diccionario en su lugar.

>>> d = {
        'name' : row[0],
       'shares' : int(row[1]),
        'price'  : float(row[2])
    }
>>> d
{'name': 'AA','shares': 100, 'price': 32.2 }
>>>

Calcula el costo total de esta cartera:

>>> cost = d['shares'] * d['price']
>>> cost
3220.0000000000005
>>>

Compara este ejemplo con el mismo cálculo que involucra tuplas arriba. Cambia el número de acciones a 75.

>>> d['shares'] = 75
>>> d
{'name': 'AA','shares': 75, 'price': 32.2 }
>>>

A diferencia de las tuplas, los diccionarios se pueden modificar libremente. Agrega algunos atributos:

>>> d['date'] = (6, 11, 2007)
>>> d['account'] = 12345
>>> d
{'name': 'AA','shares': 75, 'price':32.2, 'date': (6, 11, 2007), 'account': 12345}
>>>

Ejercicio 2.3: Algunas operaciones adicionales de diccionarios

Si conviertes un diccionario en una lista, obtendrás todas sus claves:

>>> list(d)
['name','shares', 'price', 'date', 'account']
>>>

Del mismo modo, si usas la instrucción for para iterar sobre un diccionario, obtendrás las claves:

>>> for k in d:
        print('k =', k)

k = name
k = shares
k = price
k = date
k = account
>>>

Prueba esta variante que realiza una búsqueda al mismo tiempo:

>>> for k in d:
        print(k, '=', d[k])

name = AA
shares = 75
price = 32.2
date = (6, 11, 2007)
account = 12345
>>>

También puedes obtener todas las claves usando el método keys():

>>> keys = d.keys()
>>> keys
dict_keys(['name','shares', 'price', 'date', 'account'])
>>>

keys() es un poco inusual en que devuelve un objeto especial dict_keys.

Este es una superposición sobre el diccionario original que siempre te da las claves actuales, incluso si el diccionario cambia. Por ejemplo, prueba esto:

>>> del d['account']
>>> keys
dict_keys(['name','shares', 'price', 'date'])
>>>

Observa cuidadosamente que 'account' desapareció de keys aunque no llamaste a d.keys() nuevamente.

Una forma más elegante de trabajar con claves y valores juntos es usar el método items(). Esto te da tuplas (clave, valor):

>>> items = d.items()
>>> items
dict_items([('name', 'AA'), ('shares', 75), ('price', 32.2), ('date', (6, 11, 2007))])
>>> for k, v in d.items():
        print(k, '=', v)

name = AA
shares = 75
price = 32.2
date = (6, 11, 2007)
>>>

Si tienes tuplas como items, puedes crear un diccionario usando la función dict(). Prueba:

>>> items
dict_items([('name', 'AA'), ('shares', 75), ('price', 32.2), ('date', (6, 11, 2007))])
>>> d = dict(items)
>>> d
{'name': 'AA','shares': 75, 'price':32.2, 'date': (6, 11, 2007)}
>>>

Resumen

¡Felicitaciones! Has completado el laboratorio de Tipos de Datos y Estructuras de Datos. Puedes practicar más laboratorios en LabEx para mejorar tus habilidades.