Aplicaciones web con Python

Estructuras de datos: Colecciones

2005 - Instituto Tecnológico de Mexicali

https://tinyurl.com/pyitm2025

Estructuras de datos: Colecciones

Las colecciones son objetos que agrupan datos, permitiendo organizarlos y manipularlos eficientemente. Además, son iterables, es decir, que se pueden recorrer con un bucle for.

• Propósito general: list, tuple, set, dict
• Propósito específico: named_tuple(), deque, ChainMap, Counter, OrderedDict, UserDict, UserList, UserString.

Estructuras de datos, colecciones: Conjuntos (set)

Un conjunto(set) es una secuencia inmutable de objetos únicos cuyo orden no está garantizado.

Operaciones con conjuntos

Creacion de conjuntos vacíos

• Los conjuntos vacíos se pueden crear con la función set()

  >>> frutas = set()
  >>> frutas
  {}
  
  >>> type(frutas)
  <class 'set'>
  

Creacion de conjuntos con valores

Un conjunto con al menos un elemento puede crearse con set() o con {}:

>>> frutas1 = set(["pera",])
>>> type(frutas1)
<class 'set'>

>>> frutas2 = {"pera",}
>>> type(frutas2)
<class 'set'>

Nota: Si se intenta crear un conjunto vacío con {} se creará un diccionario, no un conjunto.

Los conjuntos eliminan duplicados automaticamente

Ya que los conjuntos no pueden tener elementos duplicados, estos son útiles para eliminar elementos duplicados de una lista.

>>> frutas = ['manzana', 'naranja', 'manzana', 'pera', 'naranja', 'banana']
>>> set(frutas)
{'manzana', 'naranja', 'pera', 'banana'}

Pertenencia/no pertenencia de conjuntos

>>> frutas
{'manzana', 'naranja', 'pera', 'banana'}

Subconjuntos

>>> frutas = {'manzana', 'naranja', 'pera', 'banana'}
>>> frutas_tropicales = {'mango', 'piña', 'banana', 'maracuyá'}

¿ frutas es un subconjunto de frutas_tropicales ?

Usando el método issubset o el operador <=

>>> frutas.issubset(frutas_tropicales)
False

>>> frutas <= frutas_tropicales
False

Subconjuntos

>>> frutas = {'manzana', 'naranja', 'pera', 'banana'}
>>> frutas_completas = {'manzana', 'naranja', 'banana', 'pera', 'uva', 'fresa', 'mango'}

¿ frutas es unsubconjunto de frutas_completas ?

Usando el método issubset o el operador <=

>>> frutas.issubset(frutas_completas)
True

>>> frutas <= frutas_completas
True

Superconjuntos

>>> frutas = {'manzana', 'naranja', 'pera', 'banana'}
>>> frutas_completas = {'manzana', 'naranja', 'banana', 'pera', 'uva', 'fresa', 'mango'}

¿ frutas_completas es un superconjunto de frutas ?

Usando el método issuperset o el operador >=

>>> frutas_completas.issuperset(frutas)
True

>>> frutas_completas > frutas
True

Superconjuntos

>>> frutas = {'manzana', 'naranja', 'pera', 'banana'}
>>> frutas_tropicales = {'mango', 'piña', 'banana', 'maracuyá'}

¿ frutas_tropicales es un superconjunto de frutas ?

Usando el método issuperset o el operador >=

>>> frutas_tropicales.issuperset(frutas)
False

>>> frutas_tropicales >= frutas
False

Superconjuntos

>>> frutas = {'manzana', 'naranja', 'pera', 'banana'}
>>> frutas_tropicales = {'mango', 'piña', 'banana', 'maracuyá'}

¿ frutas es un superconjunto de si mismo ?

>>> frutas.issuperset(frutas)
True

Union

frutas = {'manzana', 'naranja', 'pera', 'banana'}
frutas_tropicales = {'mango', 'piña', 'banana', 'maracuyá'}
frutas_completas = {'manzana', 'naranja', 'banana', 'pera', 'uva', 'fresa', 'mango'}

Unión de frutas y frutas_tropicales

Usando el método union() o el operador |

>>> frutas.union(frutas_tropicales)
{'manzana', 'naranja', 'piña', 'banana', 'mango', 'pera', 'maracuyá'}

>>> frutas | frutas_tropicales
{'manzana', 'naranja', 'piña', 'banana', 'mango', 'pera', 'maracuyá'}

Union

frutas = {'manzana', 'naranja', 'pera', 'banana'}
frutas_tropicales = {'mango', 'piña', 'banana', 'maracuyá'}
frutas_completas = {'manzana', 'naranja', 'banana', 'pera', 'uva', 'fresa', 'mango'}

Unión de multiples conjuntos

>>> frutas | frutas_tropicales | frutas_completas
{'manzana', 'naranja', 'piña', 'uva', 'fresa', 'mango', 'banana', 'pera', 'maracuyá'}

Union

frutas = {'manzana', 'naranja', 'pera', 'banana'}
frutas_tropicales = {'mango', 'piña', 'banana', 'maracuyá'}
frutas_completas = {'manzana', 'naranja', 'banana', 'pera', 'uva', 'fresa', 'mango'}

Unión de un conjunto consigo mismo

>>> frutas | frutas == frutas
True

Union con un conjunto vacío

>>> frutas | set() == frutas
True

Estructuras de datos, colecciones: Diccionarios (dict)

Colección mutable de pares llave-valor. Las llaves deben ser únicas e inmutables, mientras que los valores pueden ser de cualquier tipo. Permiten acceso rápido [O(1)] a los valores mediante sus llaves.

Características generales

• Otros nombres: Hashmaps, memoria asociativa, arreglos asociativos
• Es un mapa de un valor hashable (key) a un objeto (value).
  • Llave (key): Cualquier objeto o valor inmutable: números, texto. No: list, dict
  • Valor (value): Cualquier objeto.
• A partir de Python 3.7, el orden de las llaves esta garantizado en el orden de inserción.

Operaciones soportadas más comunes:

• Pertenencia/No pertenencia al conjunto de llaves.
• Acceso/inserción y borrado de pares llave/valor.
• Iteración sobre llaves y valores
• Union/Concatenación
• Intersección
• diferencia

Creación de diccionarios vacíos

Mediante la funcion dict() o {}

>>> dict()
{}

>>> {}
{}

Creación de diccionarios no vacíos con dict()

Creación de diccionarios no vacíos con {}

frutas =  {'manzana': 'roja', 'banana': 'amarilla', 'uva': 'morada'}

Creación de diccionarios con llaves repetidas

Se queda con el ultimo valor asignado a la llave

>>> dict([('manzana', 'roja'), ('banana', 'amarilla'), ('manzana', 'verde')])
{'manzana': 'verde', 'banana': 'amarilla'}

Las llaves pueden ser cualquier objeto inmutable

>>> {'foo': 'bar', 777: 'A sus ordenes jefe', 3.1416: 'pi', (1,2): 'coordenadas'}

{'foo': 'bar', 777: 'A sus ordenes jefe', 3.1416: 'pi', (1, 2): 'coordenadas'}

Pero no objetos mutables

>>> {(1,2): 'coordenadas'}
{(1,2): 'coordenadas'}

>>> {[1,2]: 'coordenadas'}
Traceback (most recent call last):
  File "<python-input-55>", line 1, in <module>
    {[1,2]: 'coordenadas'}
TypeError: unhashable type: 'list'

Pertenencia y no pertenencia

frutas_precios = {'manzana': 1.50, 'banana': 0.75, 'naranja': 0.90, 'uva': 2.00}

Asignación directa con corchetes

La forma más común

frutas_origen = {}
frutas_origen['manzana'] = 'Chile'
frutas_origen['banana'] = 'Ecuador'
frutas_origen['naranja'] = 'España'

Método update()

Muy útil para agregar múltiples elementos a la vez o fusionar diccionarios.

• Duplica 'naranja' con valor 'España' (duplicado)
• Agrega 'uva' con valor 'Perú'
• Cambia 'manzana', ahora tiene valor ``

>>> frutas_origen.update({'naranja': 'España', 'uva': 'Perú', 'manzana': 'Mexico' })
>>> frutas_origen
{'manzana': 'Mexico', 'banana': 'Ecuador', 'naranja': 'España', 'uva': 'Perú'}

Método setdefault()

Agrega un elemento, pero si la llave no existe, se define un valor por defecto.

>>> frutas_origen.setdefault('banana', 'Colombia')
'Ecuador'

>>> frutas_origen
{'manzana': 'Mexico', 'banana': 'Ecuador', 'naranja': 'España', 'uva': 'Perú'}

>>> frutas_origen.setdefault('tomate', 'Canada')
'Canada'

>>> frutas_origen
{'manzana': 'Mexico', 'banana': 'Ecuador', 'naranja': 'España', 'uva': 'Perú', 'tomate': 'Canada'}

Eliminación de valores

frutas_origen = {'manzana': 'Chile', 'banana': 'Ecuador', 'naranja': 'España', 'uva': 'Perú'}

>>> del frutas_origen['naranja']
>>> frutas_origen
{'manzana': 'Mexico', 'banana': 'Ecuador', 'uva': 'Perú', 'tomate': 'Canada'}

>>> del frutas_origen['mandarina']
Traceback (most recent call last):
  File "<python-input-70>", line 1, in <module>
    del frutas_origen['mandarina']
        ~~~~~~~~~~~~~^^^^^^^^^^^^^
KeyError: 'mandarina'

Extraer valores usando pop()

>>> frutas_origen = {'manzana': 'Mexico', 'banana': 'Ecuador', 'uva': 'Perú', 'tomate': 'Canada'}

>>> origen_banana = frutas_origen.pop('banana')
>>> origen_banana
'Ecuador'

>>> frutas_origen
{'manzana': 'Mexico', 'uva': 'Perú', 'tomate': 'Canada'}

>>> frutas_origen.pop('mandarina')
Traceback (most recent call last):
  File "<python-input-98>", line 1, in <module>
    frutas_origen.pop('mandarina')
    ~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^
KeyError: 'mandarina'

>>> origen_mandarina = frutas_origen.pop('mandarina', 'Desconocido')
>>> origen_mandarina
'Desconocido'

Extraer una llave y el valor con popitem()

Con popitem() podemos usar un diccionario como una pila LIFO.

>>> frutas_precios = {'manzana': 1.50, 'banana': 0.75, 'naranja': 0.90, 'uva': 2.00}

Eliminando todo el contenido del diccionario con clear()

>>> frutas_precios = {'manzana': 1.50, 'banana': 0.75, 'naranja': 0.90, 'uva': 2.00}
>>> frutas_precios.clear()
>>> frutas_precios
{}

Iteración de un diccionario

for fruta in frutas_precios:
    print(f'{fruta}: ${frutas_precios[fruta]}')

for fruta in frutas_precios.keys():
    print(f'{fruta}: ${frutas_precios[fruta]}')

for precio in frutas_precios.values():
    print(precio)

for _ , precio in frutas_precios.items():
    print(precio)

Con llaves y valores

for fruta, precio in frutas_precios.items():
    print(f'{fruta}: ${precio}')

La longitud de un diccionario

frutas_precios = {'manzana': 1.50, 'banana': 0.75, 'naranja': 0.90, 'uva': 2.00}
longitud = len(frutas_precios)
print(longitud)  # Imprime 4

Concatenación de diccionarios

El operador + no está soportado en diccionarios.

>>> {} + {}
Traceback (most recent call last):
  File "<python-input-102>", line 1, in <module>
    {} + {}
    ~~~^~~~
TypeError: unsupported operand type(s) for +: 'dict' and 'dict'

Union de diccionarios

El operador de union | esta soportado:

frutas_precios = {'manzana': 1.50, 'banana': 0.75, 'naranja': 0.90, 'uva': 2.00}
frutas_otras = {'pera': 1.20, 'manzana': 1.70, 'kiwi': 2.50}

frutas_combinadas = frutas_precios | frutas_otras
print(frutas_combinadas)

# Imprime {'manzana': 1.7, 'banana': 0.75, 'naranja': 0.9, 'uva': 2.0, 'pera': 1.2, 'kiwi': 2.5}

Esto es equivalente:

frutas_combinadas = {**frutas_precios, **frutas_otras}
print(frutas_combinadas)
# Imprime {'manzana': 1.7, 'banana': 0.75, 'naranja': 0.9, 'uva': 2.0, 'pera': 1.2, 'kiwi': 2.5}

Intersección de diccionarios

El operador & se puede usar sobre las llaves del diccionario. Regresa un conjunto(set) con las llaves en común de ambos diccionarios.

frutas_precios = {'manzana': 1.50, 'banana': 0.75, 'naranja': 0.90, 'uva': 2.00}
frutas_otras = {'pera': 1.20, 'manzana': 1.70, 'kiwi': 2.50}

>>> frutas_precios.keys() & frutas_otras.keys()
{'manzana'}

Diferencia

Son las claves presentes en un diccionario pero no en otro.

Similar a la intersección, se usan las vistas de las claves y la operación de diferencia de conjuntos (-)

claves_solo_en_frutas_precios = frutas_precios.keys() - frutas_otras.keys()
print(claves_solo_en_frutas_precios) #Output: {'banana', 'naranja', 'uva'}

claves_solo_en_frutas_otras = frutas_otras.keys() - frutas_precios.keys()
print(claves_solo_en_frutas_otras) #Output: {'pera', 'kiwi'}

Diferencia simétrica

Son las claves que están presentes en uno u otro diccionario, pero no en ambos.

frutas_precios = {'manzana': 1.50, 'banana': 0.75, 'naranja': 0.90, 'uva': 2.00}
frutas_otras = {'pera': 1.20, 'manzana': 1.70, 'kiwi': 2.50}

claves_diferencia_simetrica = frutas_precios.keys() ^ frutas_otras.keys()
print(claves_diferencia_simetrica) #Output: {'banana', 'naranja', 'uva', 'pera', 'kiwi'}

Diccionarios vs Conjuntos

• Los diccionarios almacenan pares clave-valor, donde las claves deben ser únicas e inmutables, permitiendo un acceso eficiente a los valores mediante sus claves. Son ideales para representar datos con una estructura de "etiqueta-valor", como configuraciones, registros o bases de datos sencillas.
• Los conjuntos, por otro lado, almacenan colecciones desordenadas de elementos únicos. Se utilizan principalmente para eliminar duplicados de una secuencia, verificar la pertenencia de un elemento a una colección de forma eficiente y realizar operaciones de conjuntos como unión, intersección y diferencia.

Resumen

• Los diccionarios y los conjuntos son estructuras de datos fundamentales en Python, aunque con propósitos distintos.
• Los diccionarios se centran en la correspondencia clave-valor para el acceso a datos, mientras que los conjuntos se enfocan en la unicidad y las operaciones matemáticas de conjuntos.

Siguiente: Operaciones y operadores →