Quando usare un dizionario vs tupla in Python

L'esempio specifico in mente è un elenco di nomi di file e le loro dimensioni. Non riesco a decidere se ciascun elemento nell'elenco deve essere del modulo {"filename": "blabla", "size": 123}o solo ("blabla", 123). Un dizionario mi sembra più logico perché accedere alle dimensioni, ad esempio, file["size"]è più esplicativo di file[1]... ma non lo so per certo. Pensieri?

Vorrei usare un namedtuple:

from collections import namedtuple
Filesize = namedtuple('Filesize', 'filename size')
file = Filesize(filename="blabla", size=123)

Ora puoi usare file.sizee file.filenamenel tuo programma, che è IMHO il modulo più leggibile. Nota namedtuplecrea oggetti immutabili come le tuple e sono più leggeri dei dizionari, come descritto qui .

{"nome file": "blabla", "size": 123} o semplicemente ("blabla", 123)

Questa è l'annosa domanda se codificare il formato / schema in banda o fuori banda.

Scambia un po 'di memoria per ottenere la leggibilità e la portabilità che deriva dall'esprimere il formato dei dati direttamente nei dati. Se non lo fai, devi sapere che il primo campo è il nome del file e il secondo è che la dimensione deve essere mantenuta altrove. Ciò consente di risparmiare memoria ma costa leggibilità e portabilità. Quale costerà alla tua azienda più soldi?

Per quanto riguarda l'immutabile problema, ricorda che l'immutabile non significa inutile di fronte al cambiamento. Significa che dobbiamo acquisire più memoria, apportare la modifica in una copia e utilizzare la nuova copia. Non è gratuito ma spesso non è un affare. Usiamo stringhe immutabili per cambiare le cose continuamente.

Un'altra considerazione è l'estensibilità. Quando memorizzi i dati solo in posizione, senza codificare le informazioni sul formato, sei condannato a un'unica eredità, che in realtà non è altro che la pratica di concatenare campi aggiuntivi dopo i campi stabiliti. Posso definire un terzo campo per essere la data di creazione ed essere ancora compatibile con il tuo formato poiché definisco il primo e il secondo allo stesso modo.

Tuttavia, ciò che non posso fare è riunire due formati definiti in modo indipendente che hanno alcuni campi sovrapposti, altri no, archiviarli in un formato e renderli utili a cose che conoscono solo l'uno o l'altro formato.

Per fare ciò ho bisogno di codificare le informazioni sul formato dall'inizio. Devo dire "questo campo è il nome del file". Ciò consente l'ereditarietà multipla.

Probabilmente sei abituato all'eredità espressa solo nel contesto degli oggetti, ma le stesse idee funzionano per i formati di dati perché, beh, gli oggetti sono memorizzati in formati di dati. È esattamente lo stesso problema.

Quindi usa quello che ritieni abbia più probabilità di avere bisogno. Cerco flessibilità a meno che non possa indicare una buona ragione per non farlo.

Vorrei usare una classe con due proprietà. file.sizeè più bello di file[1]o file["size"].

Semplice è meglio di complesso.

I nomi dei file sono unici? In tal caso, è possibile eliminare completamente l'elenco e utilizzare un dizionario puro per tutti i file. ad es. (un sito Web ipotetico)

{ 
  "/index.html" : 5467,
  "/about.html" : 3425,
  "/css/main.css" : 9876
}

eccetera...

Ora, non ottieni "nome" e "dimensione", usi semplicemente chiave e valore, ma spesso questo è più naturale. YMMV.

Se vuoi davvero una "dimensione" per chiarezza o hai bisogno di più di un valore per il file, allora:

{ 
   "/index.html" : { "size": 5467, "mime_type" : "foo" },
   "/about.html" : { "size": 3425, "mime_type" : "foo" }
   "/css/main.css" : { "size": 9876, "mime_type" : "bar" }
}

In Python, il dizionario è oggetto mutabile. Dall'altro lato, la tupla è un oggetto immutabile.

se devi cambiare la chiave del dizionario, abbina valore spesso o ogni volta. suggerisco dizionario da usare.

se hai dati fissi / statici, suggerisco di usare la tupla.

# dictionary define.
a = {}
a['test'] = 'first value'

# tuple define.
b = ()
b = b+(1,)

# here, we can change dictionary value for key 'test'
a['test'] = 'second'

Tuttavia, non è possibile modificare i dati della tupla utilizzando l'operatore di assegnazione.