En tancar la lliçó anterior quedava un assemblatge pendent. La v0.8 sabia portar moltes tasques, però repartides en llistes paral·leles que calia sincronitzar a mà; la v0.9 sap descriure una tasca impecablement, però només en porta una. Les dues peces encaixen de manera gairebé òbvia: si una tasca és un diccionari i una llista guarda moltes coses del mateix tipus, aleshores l'agenda d'Estudi Alba és una llista de diccionaris. Aquesta lliçó tracta d'això —de combinar estructures— i de l'última que faltava per conèixer: la tupla, una seqüència immutable que ja t'has trobat sense saber-ho cada vegada que una funció retornava dos valors a 04-02. En acabar sabràs llegir sense dubtar expressions com agenda[0]["responsable"], triar amb criteri entre llista, diccionari i tupla, i TascaFàcil haurà assolit la v0.10 amb tot el seu menú funcionant sobre una col·lecció real.

1. Què és una tupla
2. Immutabilitat: quan tupla i quan llista
3. Desempaquetatge
4. Retornar diversos valors és retornar una tupla
5. Tuples com a claus i namedtuple
6. Estructures imbricades: els tres patrons
7. Llegir una expressió encadenada
8. Recórrer estructures imbricades
9. Còpia superficial i còpia profunda
10. Triar l'estructura adequada
11. TascaFàcil v0.10: l'agenda de l'estudi
12. Errors comuns i consells
13. Exercicis
14. Conclusió

Una tupla és una seqüència ordenada de valors, com una llista, però immutable: un cop creada no s'hi pot afegir, treure ni canviar res. S'escriu amb parèntesis, encara que el que de debò crea la tupla són les comes.

Índexs, talls, len(), in i el recorregut amb for funcionen exactament igual que en una llista; l'única cosa que no funciona és modificar. Les tres últimes assignacions són les que despisten tothom: els parèntesis són opcionals, la tupla buida s'escriu () i la tupla d'un element exigeix la coma final, perquè sense ella els parèntesis són d'agrupació i el resultat és el valor de dins. Les constants que fas servir des de 04-04 —PRIORITATS = ("alta", "mitjana", "baixa")— són precisament tuples, i ara saps per què: són dades fixes que el programa no ha de canviar mai.

La pregunta que ho decideix és: els elements són coses diferents amb un paper fix, o moltes coses iguals? Una coordenada (x, y), una data (2026, 8, 4) o una fila de dades són tuples: nombre fix de posicions, cadascuna amb el seu significat. Els responsables de l'estudi són una llista: pot créixer, minvar i reordenar-se. La immutabilitat té tres avantatges pràctics: protegeix les dades que no han de canviar, permet fer servir la tupla com a clau de diccionari o element d'un conjunt, i documenta la intenció a qui llegeix el codi, perquè una tupla diu «això és un registre tancat». La contrapartida és que per canviar alguna cosa cal construir una tupla nova.

Desempaquetar és repartir els elements d'una seqüència en diverses variables d'una sola vegada. És una de les coses que fan que Python sigui còmode, i ja ho has fet servir sense anomenar-ho a for clau, valor in tasca.items().

El nombre de noms a l'esquerra ha de coincidir exactament amb el d'elements; si no, ValueError: too many values to unpack. L'intercanvi en una línia funciona perquè el costat dret s'avalua sencer abans d'assignar: primer es construeix la tupla (5, 3) i després es reparteix. L'asterisc recull «la resta» en una llista, i només n'hi pot haver un per desempaquetatge. El guió baix _ és una convenció, no una regla del llenguatge: una variable normal el nom de la qual anuncia que el seu valor s'ignorarà.

A 04-02 vas aprendre que una funció pot retornar diversos valors i va quedar dit que s'explicaria aquí. Ja tens totes les peces: return a, b construeix una tupla i la retorna; l'assignació múltiple en la crida és un desempaquetatge.

És a dir: una funció sempre retorna un únic valor; el que passa és que aquest valor pot ser una tupla amb diverses coses a dins. Aquella registrar_tasca() de la v0.7, que «retornava quatre valors», retornava en realitat una tupla de quatre elements que es desempaquetava en la crida. Consell de disseny: si tornes d'una funció amb més de tres o quatre valors, o si qui la crida ha de recordar l'ordre exacte, probablement el que vols retornar és un diccionari, on cada dada porta el seu nom. És just el canvi que va fer la v0.9.

En ser immutable, una tupla pot ser clau d'un diccionari. Això permet indexar per una combinació de dades:

Amb una llista com a clau seria impossible (TypeError: unhashable type). Aquest patró és habitual per a taules de doble entrada: persona i dia, producte i mes, fila i columna. Existeix també namedtuple, del mòdul collections, que és una tupla els camps de la qual tenen nom: Tasca = namedtuple("Tasca", "titol responsable dies") permet escriure t.responsable en lloc de t[1]. La menciono perquè la reconeguis si la trobes; en aquest curs farem servir diccionaris per al mateix, i al mòdul 7 veuràs l'eina definitiva, les classes.

Llistes, diccionaris i tuples es poden ficar uns dins dels altres sense límit, però a la pràctica gairebé tot el que necessitaràs són tres combinacions. La primera és la llista de diccionaris —«molts registres»—, la forma natural d'una agenda, un catàleg o una taula:

Diccionari de llistes —«grups de coses», quan vols anar directe al nom del grup. I diccionari de diccionaris —«fitxes indexades per un identificador únic»:

S'hi accedeix amb agenda[0]["titol"], per_responsable["Marta"][0] i equip["Marta"]["rol"] respectivament. La taula de decisió completa és a la secció 10.

Una expressió com agenda[0]["responsable"] fa por la primera vegada i deixa de fer-ne tan bon punt saps que es llegeix d'esquerra a dreta, un pas cada vegada:

1. agenda → la llista completa de tasques.
2. agenda[0] → el primer element d'aquesta llista, que resulta ser un diccionari.
3. agenda[0]["responsable"] → el valor de la clau "responsable" d'aquest diccionari, "Marta".

El truc per no perdre't: cada claudàtor baixa un nivell de l'arbre. Si dubtes, imprimeix els passos intermedis al REPL: print(agenda[0]) ensenya el diccionari sencer i print(type(agenda[0])) diu en quin tipus estàs aturat. Els errors són informatius: TypeError: list indices must be integers significa que has fet servir una clau de text on hi havia una llista, i KeyError, que la clau no existeix en aquell diccionari. Amb la pràctica es llegeixen d'una ullada: agenda[1]["titol"] és "Menu Sole", equip["Marta"]["rol"] és "coordinadora", per_responsable["Marta"][1] és "Flyer estiu", i agenda[0]["dies"] = 4 modifica la tasca al lloc sense cap problema.

Recórrer una llista de diccionaris és un for normal en què cada element resulta ser un diccionari:

Aquí es veu per què valia la pena el canvi: ordenar per dies, que a 05-01 era una expressió retorçada amb titols.index(t), ara és simplement key=lambda t: t["dies"]. Recórrer un diccionari de llistes exigeix dos nivells de bucle, el segon dins del primer; amb un diccionari de diccionaris el patró és el mateix:

Fixa't en el desempaquetatge directe a la capçalera: for responsable, titols in ...items() separa clau i valor sense línies extra, i funciona sempre que l'estructura interna sigui coneguda.

Aquí apareix un error clàssic que només es manifesta amb estructures imbricades: .copy() copia la llista, però no copia el que hi ha a dins.

La llista copia és nova, però els seus elements són els mateixos diccionaris que els d'agenda: s'ha duplicat la caixa, no el contingut.

La regla pràctica: si l'estructura té un sol nivell, la còpia superficial n'hi ha prou; si hi ha llistes o diccionaris a dins i els modificaràs, necessites deepcopy. I no facis servir deepcopy per defecte: és més lenta, i la majoria de vegades el que vols precisament és que la funció modifiqui l'agenda de debò.

Un consell que estalvia molta feina: tria l'estructura pensant en l'operació més freqüent. Si el que més fas és recórrer-ho tot i ordenar, llista de diccionaris; si el que més fas és «dóna'm la fitxa de X», diccionari de diccionaris. I si necessites les dues coses, mantenir una llista i construir l'agrupament quan calgui sol ser més simple que sostenir dues estructures sincronitzades —l'error que ja vam cometre amb les llistes paral·leles.

Arribem a l'assemblatge: l'agenda és una llista de diccionaris i totes les opcions del menú es refan sobre ella, que creix a sis per incloure el resum per responsable. Les llistes paral·leles de la v0.8 desapareixen per sempre.

Els punts que convé entendre bé:

• triar_tasca retorna el diccionari, no un índex. I com que el diccionari és mutable i es passa per referència, canviar_prioritat(tasca) modifica la tasca dins de l'agenda sense necessitat de saber en quina posició era. Compara això amb els cinc pop coordinats de la v0.8.
• sorted(enumerate(agenda, start=1), key=lambda p: ORDRE_PRIORITAT[p[1]["prioritat"]]) ordena per l'ordre lògic de les prioritats —fent servir un diccionari com a taula de traducció— sense perdre el número real de cada tasca: enumerate produeix parells (numero, tasca) i el key mira dins del segon element del parell. Així el llistat surt ordenat però els números continuen servint per triar, i triar_tasca pot reutilitzar mostrar_llistat en lloc de repetir el bucle (DRY, 04-04).
• sum(1 for t in agenda if t["completada"]) compta les completades sense bucle explícit, i sum(t['dies'] for t in agenda) acumula els dies: comprensions de 05-01 usades dins de sum.
• resum.setdefault(responsable, {...}) crea la fitxa del responsable la primera vegada que apareix i la retorna les següents: el patró de recompte de 05-03, aquí construint un diccionari de diccionaris sobre la marxa. I {n.capitalize() for n in EQUIP} - set(resum) és un conjunt per comprensió menys un altre conjunt: qui de l'equip no té res assignat, en una línia. Finalment, if not agenda: aprofita que una llista buida és falsa (02-04) i es llegeix millor que len(agenda) == 0.

Amb això TascaFàcil fa per fi el que la Marta necessita, i queda un sol cap solt, el que dóna títol a la pròxima lliçó: en tancar el programa, tot desapareix.

Oblidar la coma a la tupla d'un element. ("Marta") és una cadena; ("Marta",) és una tupla. Es nota quan len() retorna 5 en comptes d'1. I modificar una tupla dóna TypeError: si necessites canviar valors, fes servir una llista.

Desempaquetar amb un nombre de noms diferent. a, b = (1, 2, 3) llança ValueError; fes servir a, *resta = ... si no saps quants elements vindran. Confondre els nivells en una expressió encadenada. agenda["titol"] falla perquè agenda és una llista: primer cal triar un element (agenda[0]) i després la clau. Si et perds, imprimeix els passos intermedis. I copiar en superfície una estructura imbricada no protegeix els diccionaris de dins: fes servir copy.deepcopy quan vulguis un arbre independent.

Consell: mantén homogènia la llista de diccionaris. Que tots tinguin les mateixes claus és el que permet recórrer-la sense comprovacions; si un registre pot no tenir un camp, dóna-li un valor per defecte en crear-lo en lloc d'ometre la clau. I no imbriquis més de tres nivells: dades["a"][0]["b"][2]["c"] és indesxifrable i fràgil. Extreu subestructures a variables amb nom (tasca = agenda[i]) o replanteja el disseny; a partir de certa complexitat, el que demana el problema són classes.

Digues què imprimeix cada línia i quins errors es produeixen.

Amb l'agenda de sota, escriu les expressions o el codi necessaris per obtenir: els títols de les tasques de prioritat alta; el total de dies pendents (els de les tasques no completades); la tasca amb més dies; la llista de títols ordenada alfabèticament ignorant majúscules; i un diccionari {responsable: nombre_de_tasques}.

Escriu agrupar_per_responsable(agenda) que retorni un diccionari de llistes amb els títols de cada persona, incloent-hi els membres d'EQUIP que no tinguin cap tasca (amb llista buida). Després escriu pintar_grups(grups) que ho imprimeixi amb els responsables ordenats per nombre de tasques descendent i els títols alfabèticament.

Solució 1.

("Marta",) té un element; ("Marta") és la cadena "Marta", la longitud de la qual és 5. L'intercanvi deixa a = 2 i b = 1 perquè el costat dret s'avalua sencer abans d'assignar. *resta recull el que sobra en una llista. copia és una còpia superficial: els seus elements són els mateixos diccionaris, així que el 99 es veu a l'original. I l'última línia falla perquè agenda és una llista i "titol" no és un índex: faltava baixar un nivell amb agenda[0]["titol"].

Solució 2.

Dos detalls. max(agenda, key=...) retorna el diccionari sencer, no els dies, per això cal ["titol"] per veure'n el nom. I el key=str.lower de l'ordre alfabètic és el de 05-02: sense ell, «menu Sole» aniria primer per començar en minúscula.

Solució 3.

El diccionari per comprensió inicial garanteix que tots els membres de l'equip apareguin, encara que no tinguin tasques: sense ell, la Nuria es quedaria fora de l'informe. El setdefault que ve després cobreix el cas contrari —un responsable que no sigui a EQUIP—, així que la funció no es trenca amb dades inesperades. I key=lambda p: -len(p[1]) ordena de més a menys fent servir el truc del signe negatiu, alternativa a reverse=True quan el criteri és numèric.

Una tupla és una seqüència immutable: el que la crea són les comes, la d'un element necessita la coma final (x,), i el seu paper natural és el registre de camps fixos, la constant i el valor retornat. El desempaquetatge reparteix els seus elements en variables (titol, responsable, dies = tasca), permet l'intercanvi en una línia i admet *resta per recollir el que sobra. Amb això queda tancada la promesa de 04-02: retornar diversos valors és retornar una tupla, i una funció sempre retorna un únic objecte. En ser immutables, les tuples serveixen com a claus de diccionari per indexar per combinacions, i namedtuple existeix per si te la trobes.

Les estructures imbricades es redueixen a la pràctica a tres patrons: llista de diccionaris per a molts registres, diccionari de llistes per agrupar i diccionari de diccionaris per a fitxes indexades. Es llegeixen d'esquerra a dreta baixant un nivell per cada claudàtor, es recorren amb bucles imbricats i desempaquetatge al for, i amaguen un parany: la còpia superficial no duplica l'interior, per a això hi ha copy.deepcopy. TascaFàcil ha assolit la v0.10, i és un programa de debò: l'agenda és una llista de diccionaris, el llistat surt numerat i ordenat per prioritat, triar_tasca retorna la tasca que després es modifica al lloc, i un resum agrupa la feina per responsable assenyalant qui està lliure. Les llistes paral·leles de la v0.8 i els seus riscos de desincronització han desaparegut del tot. Però continua havent-hi un final infeliç: quan la Marta tanca el programa, l'agenda sencera s'evapora. Tota aquesta estructura viu només a la memòria. A Desar dades en fitxers: text, CSV i JSON aprendràs a escriure-la al disc i a recuperar-la en arrencar, de manera que la feina de l'estudi continuï allà demà al matí. És l'últim cap solt del mòdul.