web-dev-qa-db-fra.com

Quand utiliser un dictionnaire vs Tuple dans 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 juste ("blabla", 123). Un dictionnaire me semble plus logique car pour accéder à la taille, par exemple file["size"] est plus explicatif que file[1]... mais je ne sais pas vraiment avec certitude. Pensées?

pythondictionary
31
clb

J'utiliserais un namedtuple:

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

Vous pouvez maintenant utiliser file.size et file.filename dans votre programme, qui est à mon humble avis la forme la plus lisible. Remarque namedtuple crée des objets immuables comme les tuples, et ils sont plus légers que les dictionnaires, comme décrit ici .

78
Doc Brown

{"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 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 être toujours compatible avec votre format puisque je définis d'abord le premier et le deuxième de la même manière.

Cependant, ce que je ne peux pas faire, c'est réunir deux formats définis indépendamment qui ont des champs qui se chevauchent, d'autres non, 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.

18
candied_orange

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

Simple, c'est mieux que complexe.

7
JacquesB

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 vraiment voulez 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" }
}
5
user949300

En python, le dictionnaire est un objet mutable. De l'autre côté, 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 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, pas en mesure de modifier les données Tuple à l'aide de l'opérateur d'affectation.

0
Deepen Patel