Python's sad, unimaginative Enum
From:
andrew cooke <andrew@...>
Date:
Sat, 11 May 2013 11:03:33 -0400
Python is about to get an Enum. See http://www.python.org/dev/peps/pep-0435/
And it's sad.
It's not awful. It just fails to do anything particularly well - it's an
awkward compromise whose only real achievement is not doing anything new.
What would you expect a Pythonic enum to look like?
class Colour(Enum):
red
green
> print(Colour.red == Colour.green)
false
That's about the minimum, right? But it doesn't do that. The above would
require new syntax, so instead you have to define values:
class Colour(Enum):
red = 1
green = 1
Still, at least the mistake above would raise an error. Wouldn't it? Nope.
That's a feature. If you mess up on the non-optional values then you get
"aliases". Because that's something I've waited all my life for, while I
never make mistakes... Or something. The something being that they are
smoking fucking crack.
But you could just as well type:
class Colour:
red = 1
green = 2
so what does Enum get you? It provides a bit of metaclass goop to let you
iterate over values, etc. Whoop.
So, you go hunting around in the docs to see if there's any way at all of
avoiding the need to assign values manually. And there is:
Colour = Enum('Colour', 'red, green')
which suffers from the same problems as namedtuples:
- you need to repeat the class name (in a string, which your IDE is
unlikely to check)
- the parameters are themselves in a string, which your IDE is
unlikely to parse and provide in auto-complete (they can be separate
strings, in a sequence, but that doesn't really help).
Now if two potentially useful library classes are suffering from the same
problems than isn't that a BIT OF A HINT to try make things better? Nope. It
just shows how important it is to not be imaginative. Or something (crack).
And it gets worse. What values do you think the above provides?
Strings? That would makes sense (red = 'red'), in that it would display
nicely and is going to provide easy to debug values. So nope.
Integers from zero? I mean that's how Python counts indices and there's "only
one way to do it" so that's how Python counts enums, right? Nope.
OK, so bit fields? That way we can do cool Colour.red | Colour.green and
make the C programmers feel at home? Nope.
Give up? I'll tell you. It counts from 1. Presumably because it's really
common to use the "if not enum" idiom. In someone's crack-addled dreams.
Like I said at the start. None of this is really awful. It's just lame.
It's design by committee that finds the least offensive, least imaginative,
least useful solution.
One big pile of meh.
Andrew
Enum
From:
Peter Norvig <pnorvig@...>
Date:
Sat, 11 May 2013 11:37:40 -0700
If you don't like writing "red = 1; green = 2" etc you can just do
Colour = Enum('Colour', 'red green blue ...')
this is fucking useless
From:
Bryce <bryce.culhane@...>
Date:
Sat, 11 May 2013 14:55:56 -0700
whatever happened to 'There should be one-- and preferably only one
--obvious way to do it.'
Re: Enum
From:
andrew cooke <andrew@...>
Date:
Sat, 11 May 2013 15:12:27 -0400
I can't believe who I am saying this to... but dude, read the article before
you comment.
Andrew
What would be imaginative?
From:
andrew cooke <andrew@...>
Date:
Sat, 11 May 2013 15:33:53 -0400
Maybe Python needs to start considering something like atoms? That would
address the need to hde names in strings and might also provide a more
suitable value type for enums.
Is there some (new?) syntax that could give a named scope, to avoid the need
to repeat class names?
It seems like there are underlying language issues that need a more
imaginative solution...
Andrew
I agree with you #nt
From:
Luigi Monaco <monaco@...>
Date:
Sat, 11 May 2013 22:03:37 +0200
no text
Frustration Understood
From:
Ethan Furman <ethan@...>
Date:
Sun, 12 May 2013 05:03:32 -0700
I certainly understand your frustrations, and I share some of them, but I feel your characterization is a bit unfair.
(Disclaimer, I'm the author of the Enum code.)
The driving goal was to make something useful, that would meet 90%+ of the use cases out there, while allowing for
fairly easy subclassing so the special cases could be (relatively) easily handled.
For example, the auto numbering Enum (which I like to have myself) with easy cast to int is:
class AutoNumber(Enum):
def __new__(cls):
value = len(cls.__members__) + 1
obj = object.__new__(cls)
obj._value = value
return obj
def __int__(self):
return self._value
class Color(AutoNumber):
red = ()
green = ()
blue = ()
And if you don't want it to start at one (again, something I tend to agree with, although I also understand Barry's
feeling that enums are something rather than nothing) just take out the + 1 on the value line.
Some good feedback here
From:
Nick Coghlan <ncoghlan@...>
Date:
Sun, 12 May 2013 21:18:45 +1000
I believe your concerns about aliasing and the values assigned by the
functional API are well founded, so I've taken the liberty of turning
those into proposals on the issue tracker as aspects we should revisit
once the basic enum implementation is in place.
Regarding the lack of magic in the definition syntax, that's driven
largely by the way we plan to use them in the standard library. I've
written more about the design in general at
http://python-notes.boredomandlaziness.org/en/latest/python3/enum_creation.html
Cheers,
Nick.
--
Nick Coghlan | ncoghlan@... | Brisbane, Australia
Atoms in python
From:
Jonathan Hunt <j@...>
Date:
Mon, 13 May 2013 00:34:26 -0700
I'm not so pessimitic about enums in python, but I think atoms are an
interesting idea.
You can do something easily just by wrapping a string.
http://www.me.net.nz/blog/atoms-slash-symbols-in-python/
About "Python's sad, unimaginative Enum"
From:
"Yves Daoust" <yves.daoust@...>
Date:
Mon, 13 May 2013 09:05:50 +0200
I don't want to be as harsh as Andrew, but I don't love the declaration
syntax of these Enums either.
Explicit numbering is tedious an error prone, so auto-numbering is an
absolute must.
(In my understanding, the true purpose of enums is to define symbolic
values, whatever their internal representation; practical needs have called
for the support for bit-field masks, hardware-defined constants or
enforcement of other "hard-coded" values, which should remain the
exception.)
I find the syntax for auto-numbering too heavy: one equal sign, two
parenthesis and a newline per item at too much to my taste (at least four
keystrokes, of which two are shifted). A single coma would be far enough
(the unimaginative way J).
By the way, some notation for compact representation of bit-field masks
could be welcome, like Mask= :5 and Mask = :5:7, instead of obscure
0x00000020, 0x000000E0 or similar.
Regards,
Yves Daoust
Re: Python's sad, unimaginative Enum
From:
Duncan Booth <kupuguy@...>
Date:
Fri, 17 May 2013 15:19:04 +0100
While most of what you wrote is subjective, you are wrong on one factual point:
> What would you expect a Pythonic enum to look like?
>
> class Colour(Enum):
> red
> green
>
> > print(Colour.red == Colour.green)
> false
> That's about the minimum, right? But it doesn't do that. The above would
> require new syntax
No, that is syntactically valid, and it is even easy to implement
something that behaves in the way you expect, however the PEP authors
chose not to go that way (probably for very good reasons):
>>> import collections, itertools
>>> class AutoEnum(type):
@classmethod
def __prepare__(metacls, name, bases):
return collections.defaultdict(itertools.count().__next__)
def __new__(cls, name, bases, classdict):
result = type.__new__(cls, name, bases, dict(classdict))
return result
>>> class Enum(metaclass=AutoEnum): pass
>>> class MyClass(Enum):
a
b
>>> MyClass.a
1
>>> MyClass.b
2
An alternative.
From:
Francisco Mota <fmota91@...>
Date:
Sun, 23 Jun 2013 22:08:36 +0100
If you want to work with the standard Enum and still have automatic
counting, the easiest (IMO) way is to declare an Enum as follows:
import itertools
_count = itertools.count()
class Color(Enum):
red = _count.next()
green = _count.next()
blue = _count.next()
fuchsia = _count.next()
...
Python 2 and 3 compatible alternative.
From:
John Hagen <hagen_06@...>
Date:
Wed, 10 Jun 2015 22:02:44 -0400
Francisco Mota's answer does not work on Python 3. .next() is no longer de=
fined on itertools.count()
For a version that works on both Python 2 (presuming you have installed enu=
m34) and Python 3:
import enumimport itertools_enum_value =3D itertools.count(1)
class Color(enum.Enum): red =3D next(_enum_value) green =3D next(_enu=
m_value) blue =3D next(_enum_value) fuchsia =3D next(_enum_value) =
=
autoenum on PyPI
From:
John Hagen <hagen_06@...>
Date:
Sun, 10 Apr 2016 20:27:55 +0000
Another alternative is to use autoenum from PyPI: https://pypi.python.org/p=
ypi/autoenum/1.0.1
What ended up there
From:
"Angerer, Philipp" <Philipp.Angerer@...-soft.com>
Date:
Fri, 17 Aug 2018 10:25:14 +0000
SXTigJlzIGFjdHVhbGx5IG5vdCBiYWQgYXQgYWxsLiBKdXN0IHVzZSBhdXRvKCk6DQoNCmZyb20g
ZW51bSBpbXBvcnQgRW51bSwgYXV0bw0KDQpjbGFzcyBNeUVudW0oRW51bSk6DQogICAgYSA9IGF1
dG8oKQ0KICAgIGIgPSBhdXRvKCkNCg0KYXNzZXJ0IE15RW51bS5hIGlzIG5vdCBNeUVudW0uYg0K
DQpBbmQgcGVvcGxlIGNvbXBhcmUgZW51bSBlbnRyaWVzIHdpdGgg4oCcaXPigJ0sIGp1c3QgbGlr
ZSB0aGUgb25lIHRydWUgd2F5IGlzIOKAnGlmIGZvbyBpcyBOb25l4oCdIGluc3RlYWQgb2Yg4oCc
aWYgZm9vID09IE5vbmXigJ0uDQo=
=?UTF-8?B?VGhlIGJlc3QgY3VzdG9taXplZCBmcmVpZ2h0IHNvbHV0aW9uIGZyb20gRWFzZSBmcmVpZ2h0?=
From:
Tina <freight@...>
Date:
Thu, 27 Jun 2024 17:22:32 +0800 (GMT+08:00)
CkhpCgoKCgpHcmVldGluZ3MgZnJvbSBFYXNlRnJlaWdodCEgSSdtIFRpbmEsIHRoZSBGcmVpZ2h0
IE1hbmFnZXIgYXQgRWFzZUZyZWlnaHQsIGFuIEFJIGZyZWlnaHQgYWdlbnQgbmV0d29yayBlc3Rh
Ymxpc2hlZCB1bmRlciBOZXRlYXNlLCBhIENoaW5lc2UgcHVibGljbHkgbGlzdGVkIGNvbXBhbnkg
aW4gMjAwMS4gV2l0aCAxNSB5ZWFycyBvZiBleHBlcmllbmNlIGluIHRoZSBpbXBvcnQgYW5kIGV4
cG9ydCBpbmR1c3RyeSwgd2UgaGF2ZSBnYXRoZXJlZCBvdmVyIDEwLDAwMCBDaGluZXNlIGZyZWln
aHQgYWdlbnRzIHRvIGVuc3VyZSBvdXIgY3VzdG9tZXJzIHJlY2VpdmUgZWZmaWNpZW50IGFuZCBj
b3N0LWVmZmVjdGl2ZSBmcmVpZ2h0IHNlcnZpY2VzLgoKCldlIHN1cHBvcnQgeW91OgoxLk11bHRp
cGxlIGZyZWlnaHQgcXVvdGF0aW9ucyB0byBlbnN1cmUgeW91IGNob29zZSB0aGUgYmVzdCBzb2x1
dGlvbi4KMi5UaGUgcXVvdGF0aW9uIGRldGFpbHMgYXJlIHNwZWNpZmljIGFuZCBjb21wcmVoZW5z
aXZlLCBwcm92aWRpbmcgYSBjbGVhciB1bmRlcnN0YW5kaW5nIG9mIGVhY2ggY29zdCBpbnZvbHZl
ZC4KMy5UcmFuc3BhcmVudCBwcmljaW5nLCBubyBtaWRkbGVtYW4gbWFya3Vwcy4KNC5PZmZlcmlu
ZyBhIHZhcmlldHkgb2Ygc2hpcHBpbmcgbWV0aG9kcyBmb3IgZmxleGlibGUgc2VsZWN0aW9uIGJh
c2VkIG9uIHNwZWNpZmljIG5lZWRzLgoKCgoKCldlIGJlbGlldmUgaW4gb3VyIGFiaWxpdHkgdG8g
cHJvdmlkZSB5b3Ugd2l0aCBjdXN0b21pemVkIHNlcnZpY2VzLCBlYXJuaW5nIHlvdXIgcmVjb2du
aXRpb24gdGhyb3VnaCBvdXIgcHJvZmVzc2lvbmFsaXNtLCBjYXBhYmlsaXRpZXMsIHNwZWVkLCBh
bmQgZWZmaWNpZW5jeSwgZW5zdXJpbmcgeW91IGVuam95IHRoZSBiZXN0IHNoaXBwaW5nIHNvbHV0
aW9ucy5QbGVhc2Uga2luZGx5IGNvbnRhY3QgdXMgbm93IGZvciBmcmVlIGNvbnRhaW5lciBzaGlw
cGluZyBxdW90ZSEKCgoKCkJlc3QgcmVnYXJkcywKVGluYSBYaWUKUHJvZHVjdCBPcGVyYXRpb25z
CgpFYXNlRnJlaWdodChOZXRFYXNlKQoKV2Vic2l0ZTpmcmVpZ2h0LmZhY3RvcnkuMTYzLmNvbQpF
LW1haWw6dGluYTAzQGVhc2VmcmllZ2h0aW5jLmNvbQoKCgpBZGRyZXNzOk5ldGVhc2XCreKAlDM5
OSBXYW5nc2hhbmcgUm9hZCwgQmluamlhbmcgRGlzdHJpY3QsIEhhbmd6aG91CgoKCgoKCgoKSWYg
eW91IGRvbid0IHdhbnQgdG8gcmVjZWl2ZSBvdXIgZW1haWxzLCB5b3UgY2FuIGVhc2lseSB1bnN1
YnNjcmliZSBoZXJlLgoKCg0KDQo=
=?UTF-8?B?RXhjbHVzaXZlIEVhc2VGcmVpZ2h0IEZyZWlnaHQgU2VydmljZXMgdGFpbG9yZWQganVzdCBmb3IgeW91?=
From:
Tina <freight@...>
Date:
Wed, 3 Jul 2024 10:33:46 +0800 (GMT+08:00)
CkhpCgoKCgpIaSxuaWNlIHRvIGNvbnRhY3QgeW91IGFnYWluISBJJ20gVGluYSwgZnJlaWdodCBt
YW5hZ2VyIG9mIEVhc2VmcmVpZ2h0LCBmcm9tIHRoZSBBSSBmcmVpZ2h0IGFnZW50IG5ldHdvcmsg
b2YgTmV0RWFzZSwgYSBsaXN0ZWQgY29tcGFueSBpbiBDaGluYS5XZSBhcmUgbm90IGp1c3QgeW91
ciBwb2ludCBvZiBjb250YWN0IHdpdGggZnJlaWdodCBhZ2VudHMsIGJ1dCB5b3VyIGdsb2JhbCB0
cmFkZSBwYXJ0bmVyLCBvZmZlcmluZyBpbnNpZ2h0cyBhbmQgYWR2aWNlIHRvIG5hdmlnYXRlIHRo
ZSBjb21wbGV4aXRpZXMgb2YgaW50ZXJuYXRpb25hbCBzaGlwcGluZy4KCgpXZSBzdXBwb3J0IHlv
dToKIDEuT2ZmZXJzIGRlZGljYXRlZCBvbmUtb24tb25lIGN1c3RvbWVyIHNlcnZpY2UgcmVwcmVz
ZW50YXRpdmVzIGFuZCBwcm9tcHQgcXVvdGF0aW9ucwogMi5PZmZlciB0YWlsb3JlZCBmcmVpZ2h0
IHNvbHV0aW9ucyB0byBtZWV0IHRoZSB1bmlxdWUgcmVxdWlyZW1lbnRzIG9mIG91ciBjbGllbnRz
LgogMy5Qcm92aWRpbmcgcmVsaWFibGUgZnJlaWdodCBwYXJ0bmVycyBhbmQgaGF2ZSBvZmZpY2Vz
IGluIG1ham9yIHBvcnRzIGZvciBvbi1zaXRlIGF1ZGl0cwoKCk91ciBjdXN0b21lciBzdXBwb3J0
IHRlYW0gaXMgYWx3YXlzIHJlYWR5IHRvIGFzc2lzdCB3aXRoIGFueSBpbnF1aXJpZXMsIGVuc3Vy
aW5nIGEgc21vb3RoIGFuZCB3b3JyeS1mcmVlIGV4cGVyaWVuY2UuUGxlYXNlIGtpbmRseSByZXBs
eSB0byBnZXQgdGhlIGxhdGVzdCBmcmVlIG9mIGNoYXJnZSBDaGluYSBzaGlwcGluZyBxdW90ZXMh
CgoKCgoKQmVzdCByZWdhcmRzLApUaW5hIFhpZQpQcm9kdWN0IE9wZXJhdGlvbnMKCkVhc2VGcmVp
Z2h0KE5ldEVhc2UpCgpXZWJzaXRlOmZyZWlnaHQuZmFjdG9yeS4xNjMuY29tCkUtbWFpbDp0aW5h
MDNAZWFzZWZyaWVnaHRpbmMuY29tCgoKCkFkZHJlc3M6TmV0ZWFzZcKt4oCUMzk5IFdhbmdzaGFu
ZyBSb2FkLCBCaW5qaWFuZyBEaXN0cmljdCwgSGFuZ3pob3UKCgoKCgoKCgpJZiB5b3UgZG9uJ3Qg
d2FudCB0byByZWNlaXZlIG91ciBlbWFpbHMsIHlvdSBjYW4gZWFzaWx5IHVuc3Vic2NyaWJlIGhl
cmUuCgoKCuWcqDIwMjQtMDYtMjfvvIxUaW5hIDxmcmVpZ2h0QHNlYW1sZXNzbG9naXN0aWNzb2x1
dGlvbnMuY29tPiDlhpnpgZM6LS0tLS3ljp/lp4vpgq7ku7YtLS0tLQog5Y+R5Lu25Lq677yaIFRp
bmEgPGZyZWlnaHRAc2VhbWxlc3Nsb2dpc3RpY3NvbHV0aW9ucy5jb20+CiDlj5Hku7bml7bpl7Q6
IDIwMjTlubQwNuaciDI35pelIOWRqOWbmwog5pS25Lu25Lq677yaIFtjb21wdXRlK3B5dGhvbnNz
YWQwQGFjb29rZS5vcmddCiDkuLvpopjvvJogVGhlIGJlc3QgY3VzdG9taXplZCBmcmVpZ2h0IHNv
bHV0aW9uIGZyb20gRWFzZSBmcmVpZ2h0CgoKSGkKCgoKCkdyZWV0aW5ncyBmcm9tIEVhc2VGcmVp
Z2h0ISBJJ20gVGluYSwgdGhlIEZyZWlnaHQgTWFuYWdlciBhdCBFYXNlRnJlaWdodCwgYW4gQUkg
ZnJlaWdodCBhZ2VudCBuZXR3b3JrIGVzdGFibGlzaGVkIHVuZGVyIE5ldGVhc2UsIGEgQ2hpbmVz
ZSBwdWJsaWNseSBsaXN0ZWQgY29tcGFueSBpbiAyMDAxLiBXaXRoIDE1IHllYXJzIG9mIGV4cGVy
aWVuY2UgaW4gdGhlIGltcG9ydCBhbmQgZXhwb3J0IGluZHVzdHJ5LCB3ZSBoYXZlIGdhdGhlcmVk
IG92ZXIgMTAsMDAwIENoaW5lc2UgZnJlaWdodCBhZ2VudHMgdG8gZW5zdXJlIG91ciBjdXN0b21l
cnMgcmVjZWl2ZSBlZmZpY2llbnQgYW5kIGNvc3QtZWZmZWN0aXZlIGZyZWlnaHQgc2VydmljZXMu
CgoKV2Ugc3VwcG9ydCB5b3U6CiAxLk11bHRpcGxlIGZyZWlnaHQgcXVvdGF0aW9ucyB0byBlbnN1
cmUgeW91IGNob29zZSB0aGUgYmVzdCBzb2x1dGlvbi4KIDIuVGhlIHF1b3RhdGlvbiBkZXRhaWxz
IGFyZSBzcGVjaWZpYyBhbmQgY29tcHJlaGVuc2l2ZSwgcHJvdmlkaW5nIGEgY2xlYXIgdW5kZXJz
dGFuZGluZyBvZiBlYWNoIGNvc3QgaW52b2x2ZWQuCiAzLlRyYW5zcGFyZW50IHByaWNpbmcsIG5v
IG1pZGRsZW1hbiBtYXJrdXBzLgogNC5PZmZlcmluZyBhIHZhcmlldHkgb2Ygc2hpcHBpbmcgbWV0
aG9kcyBmb3IgZmxleGlibGUgc2VsZWN0aW9uIGJhc2VkIG9uIHNwZWNpZmljIG5lZWRzLgoKCgoK
CldlIGJlbGlldmUgaW4gb3VyIGFiaWxpdHkgdG8gcHJvdmlkZSB5b3Ugd2l0aCBjdXN0b21pemVk
IHNlcnZpY2VzLCBlYXJuaW5nIHlvdXIgcmVjb2duaXRpb24gdGhyb3VnaCBvdXIgcHJvZmVzc2lv
bmFsaXNtLCBjYXBhYmlsaXRpZXMsIHNwZWVkLCBhbmQgZWZmaWNpZW5jeSwgZW5zdXJpbmcgeW91
IGVuam95IHRoZSBiZXN0IHNoaXBwaW5nIHNvbHV0aW9ucy5QbGVhc2Uga2luZGx5IGNvbnRhY3Qg
dXMgbm93IGZvciBmcmVlIGNvbnRhaW5lciBzaGlwcGluZyBxdW90ZSEKCgoKCkJlc3QgcmVnYXJk
cywKVGluYSBYaWUKUHJvZHVjdCBPcGVyYXRpb25zCgpFYXNlRnJlaWdodChOZXRFYXNlKQoKV2Vi
c2l0ZTpmcmVpZ2h0LmZhY3RvcnkuMTYzLmNvbQpFLW1haWw6dGluYTAzQGVhc2VmcmllZ2h0aW5j
LmNvbQoKCgpBZGRyZXNzOk5ldGVhc2XCreKAlDM5OSBXYW5nc2hhbmcgUm9hZCwgQmluamlhbmcg
RGlzdHJpY3QsIEhhbmd6aG91CgoKCgoKCgoKSWYgeW91IGRvbid0IHdhbnQgdG8gcmVjZWl2ZSBv
dXIgZW1haWxzLCB5b3UgY2FuIGVhc2lseSB1bnN1YnNjcmliZSBoZXJlLgoKCgoKDQoNCg==
=?UTF-8?B?VGhlIGJlc3QgY3VzdG9taXplZCBmcmVpZ2h0IHNvbHV0aW9uIGZyb20gRWFzZSBmcmVpZ2h0?=
From:
Tina <freight@...>
Date:
Fri, 2 Aug 2024 18:34:16 +0800 (GMT+08:00)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=?UTF-8?B?RXhjbHVzaXZlIEVhc2VGcmVpZ2h0IEZyZWlnaHQgU2VydmljZXMgdGFpbG9yZWQganVzdCBmb3IgeW91?=
From:
Tina <freight@...>
Date:
Tue, 6 Aug 2024 14:49:20 +0800 (GMT+08:00)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 on this post