Mis apuntes · Aprende Python desde PHP

Se guardan solos en este navegador mientras escribes. Puedes usar Markdown. Al descargarlos, la primera línea es tu enlace personal al curso.

Lección 14 de 47 · Colecciones en acción y matrices ✦ WebMCP implementado

Mezclar colecciones: merge, update y desempaquetado

8 min de lectura 3 retos

Casi siempre acabas con dos colecciones que hay que juntar: las tareas de hoy y las de mañana, la configuración por defecto y la del usuario, las etiquetas de dos tareas. Python tiene un operador o un método para cada caso, y la clave es saber cuál cambia la original y cuál te da una nueva.

¿De dónde vienen los nombres?

update = inglés update (actualizar)
Mete en un diccionario (o set) las parejas de otro, cambiando el original. Es el array_replace de PHP, pero por referencia.
extend = inglés extend (extender, alargar)
Alarga una lista con todos los elementos de otra, sin crear una nueva.
| (pipe) = del inglés pipe (tubería) y, en matemáticas de conjuntos, la unión (OR)
Une dos diccionarios o dos sets en uno nuevo. En PHP | es un OR de bits y la unión de arrays es +.
desempaquetar * y ** = unpacking (sacar del paquete)
Con * sacas los elementos de una lista (o set, tupla) y con ** las parejas de un diccionario, para ponerlos dentro de otra colección. Es el spread ...$a de PHP.
En 4 ideas
1/4

Listas: a + b crea una nueva; a.extend(b) alarga la original; [*a, *b] también crea una nueva. En PHP: array_merge($a, $b) y [...$a, ...$b].

1 · Listas: +, extend y desempaquetar

Juntar listas es pegar dos tiras de papel. Hay tres formas, y la diferencia es qué le pasa a las tiras originales.

Pythonmain.py
hoy = ["Comprar pan", "Llamar al banco"]
manana = ["Repasar Python", "Hacer deporte"]

# + crea una lista NUEVA y deja las dos como estaban.
# En PHP: $todas = array_merge($hoy, $manana);
todas = hoy + manana
print(todas)
print(hoy, manana)

# [*a, *b] hace lo mismo y deja meter más cosas por el camino.
# En PHP: $todas = [...$hoy, "Descansar", ...$manana];
con_extra = [*hoy, "Descansar", *manana]
print(con_extra)

# extend() cambia la lista de la izquierda y no devuelve nada.
# En PHP: array_push($hoy, ...$manana);
hoy.extend(manana)
print(hoy)

# * repite: útil para rellenar.
print(["pendiente"] * 3)
PHP 8.5index.php
<?php
declare(strict_types=1);

$hoy = ["Comprar pan", "Llamar al banco"];
$manana = ["Repasar Python", "Hacer deporte"];

$todas = array_merge($hoy, $manana);
$conExtra = [...$hoy, "Descansar", ...$manana];
array_push($hoy, ...$manana);

echo implode(" | ", $todas) . PHP_EOL;
echo implode(" | ", $conExtra) . PHP_EOL;
echo implode(" | ", $hoy) . PHP_EOL;
Pythonmain.py
hoy = ["Comprar pan", "Llamar al banco"]
manana = ["Repasar Python", "Hacer deporte"]

todas = hoy + manana
con_extra = [*hoy, "Descansar", *manana]
hoy.extend(manana)

print(" | ".join(todas))
print(" | ".join(con_extra))
print(" | ".join(hoy))

¿Por qué? · En PHP no existe

¿Por qué + y extend si hacen lo mismo?

No hacen lo mismo: a + b crea otra lista (usa memoria nueva y la original queda intacta) y a.extend(b) alarga a (no crea nada y cambia lo que otros vean en a). Si vas a juntar dentro de un bucle, extend es mucho más barato: con a = a + b copias la lista entera en cada vuelta.

En PHP array_merge siempre devuelve un array nuevo, así que no tienes esa elección. Python te deja decidir porque las listas son objetos que se comparten: quien tenga otro nombre para esa lista verá el cambio de extend, y no el de +.

2 · Diccionarios: |, update y {a, b}

Mezclar diccionarios es lo más habitual con la configuración: unos valores por defecto y encima lo que el usuario ha cambiado. La regla es siempre la misma: si una clave está en los dos, gana el de la derecha.

Pythonmain.py
por_defecto = {"titulo": "Sin título", "prioridad": 1, "hecha": False}
del_usuario = {"titulo": "Comprar pan", "prioridad": 3}

# En PHP: $tarea = array_merge($porDefecto, $delUsuario);
tarea = por_defecto | del_usuario
print(tarea)

# Lo mismo, con desempaquetado (sirve en cualquier versión de Python 3.5+).
print({**por_defecto, **del_usuario})

# El orden importa: aquí ganan los valores por defecto.
print(del_usuario | por_defecto)

# update() cambia el diccionario de la izquierda.
# En PHP: $porDefecto = array_replace($porDefecto, $delUsuario);
por_defecto.update(del_usuario)
print(por_defecto)

# |= es la forma corta de update.
extras = {"etiquetas": ["casa"]}
por_defecto |= extras
print(por_defecto)

# update también acepta parejas con nombre.
por_defecto.update(hecha=True)
print(por_defecto["hecha"])
PHP 8.5index.php
<?php
declare(strict_types=1);

$porDefecto = ["titulo" => "Sin título", "prioridad" => 1];
$delUsuario = ["titulo" => "Comprar pan", "hecha" => true];

$gananUsuario = array_merge($porDefecto, $delUsuario);
$ganaDefecto = $porDefecto + $delUsuario;
$spread = [...$porDefecto, ...$delUsuario];

echo json_encode($gananUsuario) . PHP_EOL;
echo json_encode($ganaDefecto) . PHP_EOL;
echo json_encode($spread) . PHP_EOL;
Pythonmain.py
import json

por_defecto = {"titulo": "Sin título", "prioridad": 1}
del_usuario = {"titulo": "Comprar pan", "hecha": True}

ganan_usuario = por_defecto | del_usuario
gana_defecto = del_usuario | por_defecto
spread = {**por_defecto, **del_usuario}

print(json.dumps(ganan_usuario, ensure_ascii=False))
print(json.dumps(gana_defecto, ensure_ascii=False))
print(json.dumps(spread, ensure_ascii=False))
#Quiero…En PHPEn Python¿Cambia la original?
1Gana el de la derecha, resultado nuevoarray_merge($a, $b)a | b o {**a, **b}No
2Gana el de la izquierda, resultado nuevo$a + $bb | aNo
3Gana el de la derecha, en el sitio$a = array_replace($a, $b)a.update(b) o a |= bSí

¿Por qué? · En PHP no existe

¿Por qué gana el de la derecha?

Porque se lee en orden, como escribir en un papel: lo último que escribes tapa lo anterior. Así por_defecto | del_usuario se lee «los valores por defecto, y encima los del usuario». Es el mismo orden que usan array_merge y el spread de PHP, y el contrario del + de PHP, que es una fuente clásica de errores.

3 · La mezcla es superficial

a | b (y update, y {**a, **b}) solo mira las claves de arriba. Si el valor de una clave es otro diccionario, lo reemplaza entero en vez de mezclarlo. Es el mismo comportamiento que array_merge de PHP, frente al array_merge_recursive.

Pythonmain.py
base = {"titulo": "Comprar pan", "ajustes": {"aviso": True, "color": "azul"}}
cambios = {"ajustes": {"color": "rojo"}}

# El "ajustes" de la derecha reemplaza al de la izquierda: se pierde "aviso".
print(base | cambios)


def mezcla_profunda(a, b):
    # Mezcla por dentro los diccionarios que haya en los dos lados.
    resultado = dict(a)
    for clave, valor in b.items():
        if isinstance(valor, dict) and isinstance(resultado.get(clave), dict):
            resultado[clave] = mezcla_profunda(resultado[clave], valor)
        else:
            resultado[clave] = valor
    return resultado


print(mezcla_profunda(base, cambios))

4 · Conjuntos: unión, intersección y diferencia

Con los conjuntos, mezclar es hacer los diagramas de Venn del cole. Cada operación tiene un símbolo y un método con nombre.

#Quiero…SímboloMétodoEn PHP
1Todo lo de los dos (unión)a | ba.union(b)array_unique(array_merge($a, $b))
2Solo lo común (intersección)a & ba.intersection(b)array_intersect($a, $b)
3Lo de a que no está en ba - ba.difference(b)array_diff($a, $b)
4Lo que no es común (en uno solo)a ^ ba.symmetric_difference(b)array_merge(array_diff(...), array_diff(...))
5Añadir al conjunto en el sitioa |= ba.update(b)—
Pythonmain.py
etiquetas_pan = {"casa", "compras", "urgente"}
etiquetas_banco = {"dinero", "casa", "urgente"}

print(sorted(etiquetas_pan | etiquetas_banco))
print(sorted(etiquetas_pan & etiquetas_banco))
print(sorted(etiquetas_pan - etiquetas_banco))
print(sorted(etiquetas_pan ^ etiquetas_banco))

# Preguntas sobre grupos: ¿es subconjunto? ¿no comparten nada?
print({"casa"} <= etiquetas_pan)
print(etiquetas_pan.isdisjoint({"ocio", "viaje"}))

# Con varios a la vez: set().union(*lista_de_sets)
todos = set().union(etiquetas_pan, etiquetas_banco, {"estudio"})
print(sorted(todos))

5 · Tuplas y textos: también se pegan

Una tupla no se puede cambiar, pero sí crear otra más larga. Con + pegas dos tuplas (o dos textos). Con * repites.

Pythonmain.py
inicio = (1, "Comprar pan")
fin = (False,)

# En PHP: [...$inicio, ...$fin]
print(inicio + fin)
print(inicio * 2)
print("Tarea: " + "pan")
print("-" * 10)

# Mezclar tipos distintos da error: una tupla no se pega a una lista.
try:
    inicio + [1, 2]
except TypeError as error:
    print("TypeError:", error)

# Para pasar de una a otra, conviértela.
print(list(inicio) + [1, 2])

¿Por qué? · En PHP no existe

¿Por qué + falla entre una tupla y una lista?

Porque Python no adivina qué quieres. Si pegas tupla + lista, ¿el resultado debe ser una tupla (inmutable) o una lista (mutable)? Cualquier elección sería una sorpresa. PHP, que tiene un solo tipo array, nunca tiene que decidir; Python te obliga a decirlo (list(t) + l o t + tuple(l)).

6 · Un caso completo: dos agendas en una

Juntamos todo: dos agendas de horas por tarea, que hay que unir sumando las horas de las tareas que están en las dos (aquí | no vale, porque se queda con una de las dos).

Pythonmain.py
lunes = {"Comprar pan": 1, "Repasar Python": 2}
martes = {"Repasar Python": 3, "Hacer deporte": 1}

# MAL para sumar: | se queda con el de la derecha.
print(lunes | martes)

# BIEN: recorremos la segunda y vamos sumando a una copia de la primera.
total = dict(lunes)
for tarea, horas in martes.items():
    total[tarea] = total.get(tarea, 0) + horas
print(total)

# Con Counter es una suma directa (se ve en la lección 15).
from collections import Counter

print(dict(Counter(lunes) + Counter(martes)))

La pregunta que te vas a hacer

Vale, pero… ¿y si quiero mezclar listas de diccionarios, como filas de una tabla?

Es lo mismo que array_merge de PHP con listas de arrays: filas_a + filas_b junta las dos listas. Si lo que quieres es unir por una clave (como un JOIN de SQL: las filas con el mismo id), lo normal es indexar una de las dos por esa clave con un diccionario. Lo verás en la lección «Adiós for anidados».

Hora de practicar

Retos · 0/3 resueltos

Reto 1 de 3

La tarea con sus valores por defecto

Hay unos valores por defecto y lo que ha escrito el usuario. Imprime el diccionario mezclado donde los valores del usuario ganan: {'titulo': 'Comprar pan', 'prioridad': 3, 'hecha': False}. Es el array_merge($porDefecto, $delUsuario) de PHP.

Al pulsar Comprobar, unos tests ocultos prueban tu código en tu navegador, con Python 3.14.

Pythonmain.py · editable

Resumen

Lo que te llevas de esta lección

  1. Listas: a + b o [*a, *b] crean una nueva; a.extend(b) cambia a (en PHP, array_merge, [...$a, ...$b], array_push).
  2. Diccionarios: a | b o {**a, **b} crean uno nuevo; a.update(b) o a |= b cambian a. Gana el de la derecha (en PHP, array_merge; el + de PHP hace lo contrario).
  3. Conjuntos: | une, & es lo común, - resta y ^ es lo no común (en PHP, array_merge, array_intersect, array_diff).
  4. Superficial: | no mezcla los diccionarios de dentro; si hace falta, función recursiva (en PHP, array_merge_recursive).
  5. Una tupla no se pega a una lista: convierte una de las dos antes (list(t) + l).

Para recordarlo: «Derecha manda, la barra une, el & comparte»

DDerecha manda
en a | b gana b si repiten clave
BBarra une
| es la unión (OR)
&Ampersand comparte
& es lo que tienen en común

Y al revés que en PHP: + pega listas y | mezcla diccionarios. Si quieres cambiar la original, método (extend, update); si quieres una nueva, operador.