Je pense que l'utilisation de chacun est beaucoup trop subjective pour que je puisse entrer là-dessus, alors je vais m'en tenir aux chiffres.
J'ai comparé le temps nécessaire pour créer et changer une variable dans un dict, une classe new_style et une classe new_style avec des slots.
Voici le code que j'ai utilisé pour le tester (c'est un peu brouillon mais ça fait le travail.)
import timeit
class Foo(object):
def __init__(self):
self.foo1 = 'test'
self.foo2 = 'test'
self.foo3 = 'test'
def create_dict():
foo_dict = {}
foo_dict['foo1'] = 'test'
foo_dict['foo2'] = 'test'
foo_dict['foo3'] = 'test'
return foo_dict
class Bar(object):
__slots__ = ['foo1', 'foo2', 'foo3']
def __init__(self):
self.foo1 = 'test'
self.foo2 = 'test'
self.foo3 = 'test'
tmit = timeit.timeit
print 'Creating...\n'
print 'Dict: ' + str(tmit('create_dict()', 'from __main__ import create_dict'))
print 'Class: ' + str(tmit('Foo()', 'from __main__ import Foo'))
print 'Class with slots: ' + str(tmit('Bar()', 'from __main__ import Bar'))
print '\nChanging a variable...\n'
print 'Dict: ' + str((tmit('create_dict()[\'foo3\'] = "Changed"', 'from __main__ import create_dict') - tmit('create_dict()', 'from __main__ import create_dict')))
print 'Class: ' + str((tmit('Foo().foo3 = "Changed"', 'from __main__ import Foo') - tmit('Foo()', 'from __main__ import Foo')))
print 'Class with slots: ' + str((tmit('Bar().foo3 = "Changed"', 'from __main__ import Bar') - tmit('Bar()', 'from __main__ import Bar')))
Et voici la sortie ...
Création ...
Dict: 0.817466186345
Class: 1.60829183597
Class_with_slots: 1.28776730003
Changer une variable ...
Dict: 0.0735140918748
Class: 0.111714198313
Class_with_slots: 0.10618612142
Donc, si vous ne faites que stocker des variables, vous avez besoin de vitesse, et cela ne vous obligera pas à faire beaucoup de calculs, je vous recommande d'utiliser un dict (vous pouvez toujours créer une fonction qui ressemble à une méthode). Mais, si vous avez vraiment besoin de classes, rappelez-vous - utilisez toujours __ slots __ .
Remarque:
J'ai testé la «classe» avec les classes new_style et old_style. Il s'avère que les classes old_style sont plus rapides à créer mais plus lentes à modifier (pas de beaucoup mais significatives si vous créez beaucoup de classes dans une boucle serrée (astuce: vous le faites mal)).
Les temps de création et de modification des variables peuvent également différer sur votre ordinateur car le mien est ancien et lent. Assurez-vous de le tester vous-même pour voir les «vrais» résultats.
Éditer:
J'ai testé plus tard le namedtuple: je ne peux pas le modifier mais pour créer les 10000 échantillons (ou quelque chose comme ça), il a fallu 1,4 seconde, donc le dictionnaire est en effet le plus rapide.
Si je change la fonction dict pour inclure les clés et les valeurs et pour renvoyer le dict au lieu de la variable contenant le dict lorsque je le crée, cela me donne 0,65 au lieu de 0,8 seconde.
class Foo(dict):
pass
La création est comme une classe avec des slots et la modification de la variable est la plus lente (0,17 seconde) donc n'utilisez pas ces classes . optez pour un dict (speed) ou pour la classe dérivée de object ('syntax candy')
dict
peut avoir un sens, vers. avantage: lorsque vous déboguez, dites simplementprint(request)
et vous verrez facilement toutes les informations d'état. avec l'approche plus classique, vous devrez écrire vos__str__
méthodes personnalisées , ce qui est nul si vous devez le faire tout le temps.