Quand utiliser un dictionnaire vs tuple en Python

L'exemple spécifique à l'esprit est une liste de noms de fichiers et leurs tailles. Je ne peux pas décider si chaque élément de la liste doit être de la forme {"filename": "blabla", "size": 123}ou simplement ("blabla", 123). Un dictionnaire me semble plus logique car accéder à la taille, par exemple, file["size"]est plus explicatif que file[1]... mais je n'en suis pas vraiment sûr. Pensées?

J'utiliserais un namedtuple:

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

Maintenant, vous pouvez utiliser file.sizeet file.filenamedans votre programme, qui est à mon humble avis la forme la plus lisible. Remarque namedtuplecrée des objets immuables comme les tuples, et ils sont plus légers que les dictionnaires, comme décrit ici .

{"nom de fichier": "blabla", "taille": 123}, ou tout simplement ("blabla", 123)

C'est la question séculaire de savoir si encoder votre format / schéma en bande ou hors bande.

Vous échangez de la mémoire pour obtenir la lisibilité et la portabilité qui découlent de l'expression du format des données directement dans les données. Si vous ne le faites pas, sachez que le premier champ est le nom du fichier et le second la taille doit être conservé ailleurs. Cela économise de la mémoire mais cela coûte lisibilité et portabilité. Qu'est-ce qui va coûter plus cher à votre entreprise?

Quant à la question immuable, rappelez-vous immuable ne signifie pas inutile face au changement. Cela signifie que nous devons récupérer plus de mémoire, effectuer la modification dans une copie et utiliser la nouvelle copie. Ce n'est pas gratuit, mais ce n'est souvent pas une rupture. Nous utilisons des chaînes immuables pour changer les choses tout le temps.

Une autre considération est l'extensibilité. Lorsque vous stockez des données uniquement de manière positionnelle, sans coder les informations de format, vous êtes alors condamné à un seul héritage, ce qui n'est rien d'autre que la pratique de concaténer des champs supplémentaires après les champs établis. Je peux définir un 3ème champ pour être la date de création et toujours être compatible avec votre format puisque je définis d'abord la seconde et la même manière.

Cependant, ce que je ne peux pas faire, c'est rassembler deux formats définis indépendamment qui ont des champs qui se chevauchent, d'autres pas, les stocker dans un format et les utiliser pour des choses qui ne connaissent que l'un ou l'autre des formats.

Pour ce faire, je dois encoder les informations de format depuis le début. Je dois dire "ce champ est le nom du fichier". Cela permet un héritage multiple.

Vous êtes probablement habitué à ce que l'héritage ne s'exprime que dans le contexte des objets, mais les mêmes idées fonctionnent pour les formats de données car, eh bien, les objets sont stockés dans des formats de données. C'est exactement le même problème.

Donc, utilisez celui que vous pensez avoir le plus besoin. J'atteins la flexibilité à moins que je puisse indiquer une bonne raison de ne pas le faire.

J'utiliserais une classe avec deux propriétés. file.sizeest plus agréable que l'un file[1]ou l' autre file["size"].

Simple, c'est mieux que complexe.

Les noms de fichiers sont-ils uniques? Si tel est le cas, vous pouvez supprimer entièrement la liste et utiliser simplement un dictionnaire pur pour tous les fichiers. par exemple (un site Web hypothétique)

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

etc...

Maintenant, vous n'obtenez pas "nom" et "taille", vous utilisez simplement la clé et la valeur, mais souvent c'est plus naturel. YMMV.

Si vous voulez vraiment une "taille" pour plus de clarté, ou si vous avez besoin de plus d'une valeur pour le fichier, alors:

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

En python, le dictionnaire est un objet mutable. De l'autre côté, le tuple est un objet immuable.

si vous devez changer la clé du dictionnaire, paire de valeurs souvent ou à chaque fois. je suggère le dictionnaire à utiliser.

si vous avez des données fixes / statiques, je suggère d'utiliser le tuple.

# 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'

Mais, impossible de modifier les données de tuple à l'aide de l'opérateur d'affectation.