Python Enum class (avec tostring fromstring)

J'ai trouvé une façon simple à mettre en œuvre(hack) un enum en Python:

class MyEnum:
  VAL1, VAL2, VAL3 = range(3)

Je peux appeler cela ainsi:

bob = MyEnum.VAL1

Sexy!

Bien, maintenant, je veux être en mesure d'obtenir la valeur numérique si une chaîne de caractères ou une chaîne de caractères, si, étant donné une valeur numérique. Disons que je veux les cordes pour correspondre exactement à la clé Enum est

Du mieux que je pouvais penser, c'est quelque chose comme ceci:

class MyEnum:
  VAL1, VAL2, VAL3 = range(3)
  @classmethod
  def tostring(cls, val):
    if (val == cls.VAL1):
      return "VAL1"
    elif (val == cls.VAL2):
      return "VAL2"
    elif (val == cls.VAL3):
      return "VAL3"
    else:
      return None
  @classmethod
  def fromstring(cls, str):
    if (str.upper() == "VAL1"):
      return cls.VAL1
    elif (str.upper() == "VAL2"):
      return cls.VAL2
    elif (str.upper() == "VAL2"):
      return cls.VAL2
    else:
      return None

ou quelque chose comme ça (ignore comment je suis attraper invalide cas)

Est-il un meilleur, plus python centrée sur le moyen de faire ce que je fais ci-dessus? Ou est déjà au-dessus aussi concis qu'il obtient.

Il semble que il doit y avoir une meilleure façon de le faire.

Ce montant de if/else indique toujours que c'est une mauvaise solution 😉
double possible de What est la meilleure façon de mettre en œuvre un 'enum' en Python?
vous pouvez modifier votre réponse.

OriginalL'auteur Nick | 2010-12-17

10

Eh bien, voici ce que vous avez demandé:
```
class MyEnum:
  VAL1, VAL2, VAL3 = range(3)
  @classmethod
  def tostring(cls, val):
    for k,v in vars(cls).iteritems():
        if v==val:
            return k

  @classmethod
  def fromstring(cls, str):
      return getattr(cls, str.upper(), None)

print MyEnum.fromstring('Val1')
print MyEnum.tostring(2)
```
Mais je n'ai vraiment pas obtenir le point de Enums en Python. Il a un riche type de système ainsi que les générateurs et les coroutines pour gérer les états.

Je sais que je n'ai pas été à l'aide des Enums en Python pour les plus de 12 ans, peut-être que vous pouvez vous débarrasser d'eux aussi 😉

MyEnum.tostring(3) renvoie None. Je devrais probablement être MyEnum.tostring(MyEnum.VAL3)
C'est parce que range commence à 0. tostring(2) donne VAL3. Malheureux noms (*[1-9]). Autant que je sache, C/C++ enum commence à 0 aussi.
"tostring" et "fromsring" sont certainement javesque. Python n'a pas besoin de ces trucs.
Si les énumérations ne sont pas de toute utilisation en Python, c'est bizarre la façon dont beaucoup de gens ont senti le besoin de mettre en place quelque chose comme au cours des années. Une façon, personnellement, je les utiliser est de donner des noms à des choses comme des numéros de magie et de faire mes scripts plus descriptif et lisible.
Non seulement, c'est bizarre la façon dont beaucoup de gens ont senti le besoin de les mettre en œuvre; ils en quelque sorte retrouvé dans la bibliothèque standard! Clairement il y a un utilitaire pour eux.

OriginalL'auteur Jochen Ritzel

[Le temps passe...]

La nouvelle Python Enum a finalement atterri en 3.4, et a également été réalignés. Si la réponse à votre question est maintenant de les utiliser. 🙂

Un exemple:

>>> from enum import Enum
>>> class Modes(Enum) :
...    Mode1 = "M1"
...    Mode2 = "M2"
...    Mode3 = "M3"
...

>>> Modes.Mode1
<Modes.Mode1: 'M1'>

>>> Modes.Mode1.value
'M1'

>>> Modes.Mode1.value
'M1'

>>> Modes['Mode1']    # index/key notation for name lookup
<Modes.Mode1: 'M1'>

>>> Modes('M1')       # call notation for value lookup
<Modes.Mode1: 'M1'>

>>> Modes("XXX")      # example error
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
  File "C:\Anaconda3\lib\enum.py", line 291, in __call__
    return cls.__new__(cls, value)
  File "C:\Anaconda3\lib\enum.py", line 533, in __new__
    return cls._missing_(value)
  File "C:\Anaconda3\lib\enum.py", line 546, in _missing_
    raise ValueError("%r is not a valid %s" % (value, cls.__name__))
ValueError: 'XXX' is not a valid Modes

OriginalL'auteur Ethan Furman

7

Utiliser un dict:
```
MyEnum = {'VAL1': 1, 'VAL2':2, 'VAL3':3}
```
Pas de classes nécessaires. Dicts avoir votre classe battre parce que 1.) ils sont incroyablement efficace, 2.) avoir un tas de méthodes incroyable cuit, et 3.) sont un langage universel de construire. Ils sont également extensible:
```
MyEnum['VAL4'] = 4
```
Il n'est pas sage de mettre en œuvre C++ (ou autre langue), la fonctionnalité de Python. Si vous vous trouvez "le piratage d'un enum" ou quelque chose de cette nature, vous pouvez parier la ferme, vous ne le font pas le Python.

Si vous voulez aller à l'inverse, de manière à construire une autre dict. (par exemple, {'1':'VAL1', ...}

Si je dois construire une 2ème dictionnaire d'aller dans l'autre sens, ce qui viole le single-point-de-la définition de la valeur préférée dans n'importe quelle langue. Comment voulez-vous répondre à cette inquiétude?
L'extensibilité n'est pas une fonctionnalité pour les énumérations.

OriginalL'auteur Rafe Kettler

Voir:
Comment puis-je représenter un 'Enum' en Python?

Celui-ci est intéressant:

class EnumMeta(type):
  def __getattr__(self, name):
    return self.values.index(name)

  def __setattr__(self, name, value):  # this makes it read-only
    raise NotImplementedError

  def __str__(self):
    args = {'name':self.__name__, 'values':', '.join(self.values)}
    return '{name}({values})'.format(**args)

  def to_str(self, index):
    return self.values[index]

class Animal(object):
  __metaclass__ = EnumMeta
  values = ['Horse','Dog','Cat']

Utilisation:

In [1]: Animal.to_str(Animal.Dog)
Out[1]: 'Dog'
In [2]: Animal.Dog
Out[2]: 1
In [3]: str(Animal)
Out[3]: 'Animal(Horse, Dog, Cat)'

C'est simple et léger. Sont-ils des inconvénients de cette approche?

EDIT:
Autant que je sache, les énumérations ne sont pas très pythonic en tant que concept, c'est pourquoi ils n'ont pas été mis en œuvre en premier lieu. Je n'ai jamais utilisé, et ne peuvent pas voir les cas d'utilisation pour en Python. Les énumérations sont utiles dans les langages à typage statique, parce qu'ils ne sont pas dynamiques 😉

OriginalL'auteur Paweł Prażak

Cela va faire ce que vous voulez et généralise votre application tout en réduisant légèrement la chaudière-plaque de code:

class EnumBase: # base class of all Enums
    @classmethod
    def tostring(cls, value):
        return dict((v,k) for k,v in cls.__dict__.iteritems())[value]

    @classmethod
    def fromstring(cls, name):
        return cls.__dict__[name]

class MyEnum(EnumBase): VAL1, VAL2, VAL3 = range(3)

print MyEnum.fromstring('VAL1')
# 0
print MyEnum.tostring(1)
# VAL2

OriginalL'auteur martineau

Vous pouvez utiliser les dictionnaires:

class MyEnum:
    VAL1, VAL2, VAL3 = range(3)
    __toString = { VAL1 : "VAL1", VAL2 : "VAL2", VAL3 : "VAL3" }

    @classmethod
    def tostring(cls, val):
        return cls.__toString.get(val)

    @classmethod
    def fromstring(cls, str):
        i = str.upper()
        for k,v in cls.__toString.iteritems():
            if v == i:
                return k
        return None


print MyEnum.tostring(MyEnum.VAL1)
print MyEnum.fromstring("VAL1")

Edit : THC4k réponses, c'est certainement mieux. Mais à gauche de la mine comme un exemple d'implémentation naïve.

Menant une double soulignement (= name mangling) sont... bien, pas mal, mais je n'ai jamais vu ce cas hypothétique où ils ont un petit avantage, contrairement à l'usage habituel de cas où ils ont juste casser des trucs.
Je vais prendre note de cela.

OriginalL'auteur Rod

Vous ne devriez pas avoir à coder en dur vos valeurs à l'intérieur de la classe - il vaut mieux avoir un énumérateur de l'usine.
Tout ça, c'est juste ajouter quelques nicetirs fournis par Python, par exemple, remplacer la represntation méthode ou un attribut:

class Enumerator(object):
    def __init__(self, *names):
        self._values = dict((value, index) for index, value in enumerate (names))
    def __getattribute__(self, attr):
        try:
            return object.__getattribute__(self,"_values")[attr]
        except KeyError:
            return object.__getattribute__(self, attr)
    def __getitem__(self, item):
        if isinstance (item, int):
            return self._values.keys()[self._values.values().index(item)]
        return self._values[item]
    def __repr__(self):
        return repr(self._values.keys())

Maintenant l'utiliser:

>>> enum = Enumerator("val1", "val2", "val3")
>>> enum
['val3', 'val2', 'val1']
>>> enum.val2
1
>>> enum["val1"]
0
>>> enum[2]
'val3'

(btw, les gens dans le Python développeurs liste de parler de ce sujet,plus nous risquons de nous
plus complète, et avec suffisamment de fonctionnalités, la mise en œuvre de ce mode natif par Python 3.3)

OriginalL'auteur jsbueno

Vous devez vous connecter pour publier un commentaire.