Colecciones

Tuplas (tuple)

Representan colecciones ordenadas e inmutables de elementos. Usan () entre sus valores. Una vez creada la tupla, no es posible alterarla, no se pueden cambiar los valores ni agregar nuevos.

Las tuplas son el tipo compuesto más simple de todos y bastante común de ser usado en Python, de la misma forma que anteriormente vimos que la string "ABC" es una secuencia de caracteres, con las tuplas conseguimos hacer una secuencia de valores que pueden ser de cualquier tipo.

En Python siempre que uno o más objetos sean encadenados con , esto será interpretado como un objeto del tipo tupla.

La característica más interesante de las tuplas se llama unpacking o desempaquetado. El desempaquetado permite hacer la operación contraria de la asignación.

# Asignación, podría no tener paréntesis
>>> persona = ("David", 37, "Vila Velha", "[email protected]")
# Desempaquetado
>>> nombre, edad, ciudad, email = persona
>>> print("Nombre:", nombre)
Nombre: David
>>> print("Edad:", edad)
Edad: 37
>>> print("Ciudad:", ciudad)
Ciudad: Vila Velha
>>> print("Email:", email)
Email: david@example.com
>>> persona[0]
'David'
>>> persona[1]
37
>>>

Listas (list)

Representan colecciones ordenadas y mutables de elementos. Usan [] entre sus valores. Las listas son bastante similares a las tuplas y la mayoría de las operaciones que podemos hacer con tuplas también podemos hacerlas con las listas, la diferencia es que podemos agregar, eliminar y reordenar elementos, es decir, son mutables.

>>> frutas = ["manzana", "banana", "naranja", "fresa"]
>>> print(frutas)
['manzana', 'banana', 'naranja', 'fresa']
>>> type(frutas)
<class 'list'>
>>> print(frutas[0])
manzana
>>> print(frutas[1])
banana
# Agregar mora al final
>>> frutas.append("mora")
# Insertar piña en la posición 0
>>> frutas.insert(0, "piña")
# Insertar aguacate en la posición 3
>>> frutas.insert(3, "aguacate")
>>> print(frutas)
['piña', 'manzana', 'banana', 'aguacate', 'naranja', 'fresa', 'mora']
>>>
# Sumando listas
>>> frutas2 = ["maracuyá","uva"]
>>> nueva_frutas = frutas + frutas2
>>> print(nueva_frutas)
['piña', 'manzana', 'banana', 'aguacate', 'naranja', 'fresa', 'mora', 'maracuyá', 'uva']
# Eliminando banana de la nueva lista
>>> nueva_frutas.remove("banana")
>>> print(nueva_frutas)
['piña', 'manzana', 'aguacate', 'naranja', 'fresa', 'mora', 'maracuyá', 'uva']
# Eliminando el último elemento
>>> nueva_frutas.pop()
'uva'
>>> print(nueva_frutas)
['piña', 'manzana', 'aguacate', 'naranja', 'fresa', 'mora', 'maracuyá']
>>>

Conjuntos (set)

Representan colecciones no ordenadas y sin duplicados de elementos. Por defecto, no poseen un orden específico, lo que significa que no hay garantía de cuál elemento será considerado el "primer" elemento. De esta forma generalmente se transforman los sets en alguna lista ordenada para impresión. Existe un conjunto llamado frozenset (fset) que no permite agregar y eliminar.

>>> colores
{'azul', 'rojo', 'verde'}
>>> colores = {"rojo", "verde", "azul"}
>>> colores
{'azul', 'rojo', 'verde'}
>>> type(colores)
<class 'set'>
>>># Voy a forzar la entrada de dos rojos que no deberían repetirse.
>>> colores = {"rojo", "verde", "azul", "rojo"}
>>> type(colores)
<class 'set'>
>>> colores
{'azul', 'rojo', 'verde'} # Aun así eliminó el rojo extra.
>>># Agregando y eliminando colores
>>> colores.add("amarillo")
>>> colores.remove("verde")
>>> print("azul" in colores)
>>># Observa la función print aquí verifica si tenemos las claves y no muestra su valor.
True
>>> print("negro" in colores)  # Salida: False
False
>>> print(colores)
{'azul', 'rojo', 'amarillo'}
>>># Necesitamos otros recursos para imprimir un set, que serán vistos más adelante. No te preocupes por esto ahora.
>>> for color in colores:
...     print(color)
...
azul
rojo
amarillo

Diccionarios (dict)

Representan colecciones de pares clave-valor, donde cada valor se accede a través de su clave. Los diccionarios son una mezcla entre set y list.

>>> persona = {
...     "nombre": "David",
...     "edad": 36,
...     "ciudad": "Vila Velha",
...     "email": "[email protected]"
... }
>>> print("Nombre:", persona["nombre"])
Nombre: David
>>> print("Edad:", persona["edad"])
Edad: 36
>>> print("Ciudad:", persona["ciudad"])
Ciudad: Vila Velha
>>> print("Email:", persona["email"])
Email: david@example.com
>>># Agregando un nuevo par clave-valor al diccionario
>>> persona["telefono"] = "(11) 01234-5678"
>>># Modificando un valor existente en el diccionario
>>> persona["edad"] = 37
>>># Eliminando un par clave-valor del diccionario
>>> del persona["email"]
>>> print(persona)
{'nombre': 'David', 'edad': 37, 'ciudad': 'Vila Velha', 'telefono': '(11) 01234-5678'}
>>>

También podemos tener objetos compuestos

producto = {
    "nombre": "Bolígrafo",
    "colores": ["azul", "blanco"],
    "precio": 3.23,
    "dimension" {
        "altura": 12.1,
        "ancho":  0.8,
    },
    "en_stock": True,
    "codigo": 45678,
    "codebar": None,
}

# Y para iniciar vacío
cliente = {}
# o
cliente = dict()

También es posible combinar dos diccionarios.

>>> cliente = {"nombre": "David", "ciudad": "Vila Velha"}
>>> extra = {"cpf": "123456789-00"}
>>> final = {**cliente, **extra}
>>> print(final)
{'nombre': 'David', 'ciudad': 'Vila Velha', 'cpf': '123456789-00'}

O haciendo update in place.

cliente.update({"estado": "es"})
>>> print(cliente)
{'nombre': 'David', 'ciudad': 'Vila Velha', 'estado': 'es'}

Si una clave no existe en el diccionario, Python lanza un error llamado KeyError

print(cliente["telefono"])
...
KeyError 'telefono'

Para evitar el error podemos usar el método get que busca la clave y si no existe devuelve un valor por defecto que inicialmente es None

print(cliente.get("telefono"))
'None'
# Definiendo el valor de retorno por defecto como (00)99999-9999
print(cliente.get("telefono", "(00)99999-9999"))
'(00)99999-9999'

Bytesarray (bytearray)

Representan secuencias mutables de bytes que almacenan una secuencia de bytes. Es similar al tipo de dato bytes, pero con la diferencia fundamental de que un bytearray puede modificarse, mientras que un objeto bytes es inmutable. Esto hace que esta estructura sea adecuada para situaciones en las que necesitas alterar datos a nivel de byte de forma eficiente.

>>> datos = bytearray(b'RellO')
>>> datos[0] = 72  # Modificando el primer byte a 'H'
>>> datos[4] = 111  # Modificando el último byte a 'o'
>>> datos.append(33) # Agregando el byte '!'
>>> print(datos)
bytearray(b'Hello!')
>>> datos.extend(b' World')  # Agregando una secuencia de bytes
>>> print(datos)  # Salida: bytearray(b'Hello World!')
bytearray(b'Hello! World')
>>> lista_bytes = list(datos) # Convirtiendo un bytearray a una lista de bytes
>>> print(lista_bytes)
[72, 101, 108, 108, 111, 33, 32, 87, 111, 114, 108, 100]
>>>