Creating objects from static properties in python

Question

I have a Category class which has different names for each categories, the names of the categories can be unknown, good and bad, all categories share the same behavior so i don't want to create sub classes for each type of category, the problem comes when i am trying to create the different categories in this way:

Category.GOOD

This statement should return a category object with his name setting to 'good' so i try the following:

class Category(object):                                                                                                            

  def __init__(self, name):                                                                                                      
      self.name = name                                                                                                           

  @property
  def GOOD(self):
      category = Category(name='good')                                                                                           
      return category                                                                                                            

  @property
  def BAD(self): 
      category = Category(name='bad')                                                                                            
      return category

Then i created and use the category with the following output:

c = Category.GOOD
c.name
AttributeError: 'property' object has no attribute 'name'

Realizing that this doesn't work i try a java like approach:

class Category(object):                                                                                                          

    GOOD = Category(name='good')
    BAD = Category(name='bad')                                                                                                   

    def __init__(self, name):
        self.name = name

What i get here is a undefined name "Category" error, so my question is if there is a pythonic way to create a category object like this.

You cannot do this out-of-the-box with a property; you'd have to create your own descriptor instead, or just use a classmethod and call GOOD(), as given below. — Martijn Pieters
– Martijn Pieters, Commented Jan 15, 2013 at 14:19
@MartijnPieters -- It's not possible to create a descriptor with this behavior is it? The problem is that he's accessing the descriptor on the class (which is just an attribute and none of the special descriptor magic comes into play) — mgilson
– mgilson, Commented Jan 15, 2013 at 14:23
@mgilson: descriptors are invoked for classes as well; classmethod is a descriptor too. function.__get__(None, cls) gives a 'unbound method' in Python 2 (returns self in Python 3), so it is definitely invoked! — Martijn Pieters
– Martijn Pieters, Commented Jan 15, 2013 at 14:25
@MartijnPieters -- Hmmm... Alright then. Time to go re-read about descriptors :) — mgilson
– mgilson, Commented Jan 15, 2013 at 14:25

Daniel Roseman · Accepted Answer · 2013-01-15 14:15:54Z

2

You probably want to use classmethods:

class Category(object):

    @classmethod
    def GOOD(cls):
        category = cls(name='GOOD')
        return category

Now you can do c = Category.GOOD().

answered Jan 15, 2013 at 14:15

Daniel Roseman

602k68 gold badges910 silver badges923 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

jeromej · Accepted Answer · 2013-04-23 02:51:48Z

2

You cannot do this with a property; you either have to use a classmethod, or create your own descriptor for that:

class classproperty(property):
    def __get__(self, inst, cls):
        return self.fget(cls)

I'm abusing the property decorator here; it implements __set__ and __del__ as well, but we can just ignore those here for convenience sake.

Then use that instead of property:

class Category(object):
    def __init__(self, name):
        self.name = name

    @classproperty
    def GOOD(cls):
        return cls(name='good')

    @classproperty
    def BAD(cls):
        return cls(name='bad')

Now accessing Category.GOOD works:

>>> Category.GOOD
<__main__.Category object at 0x10f49df50>
>>> Category.GOOD.name
'good'

edited Apr 23, 2013 at 2:51

jeromej

12k3 gold badges46 silver badges66 bronze badges

answered Jan 15, 2013 at 14:29

Martijn Pieters

1.1m326 gold badges4.2k silver badges3.4k bronze badges

1 Comment

mgilson Over a year ago

Upvoted. In hind-sight, it seems clear that descriptors would need to work on classes (and not just instances) in order to have classmethod or staticmethod work. And to think that I've had the wrong idea about these things since I taught myself descriptors a couple months ago...

Constantinius · Accepted Answer · 2013-01-15 14:14:30Z

1

I'd use module variables for this. Consider you have the module category.py:

class Category(object):
    # stuff...

now you put the two global objects in it:

GOOD = Category(name='good')
BAD = Category(name='bad')

You can use it like that:

from path.to.category import GOOD, BAD

I don't say that this is pythonic but I think this approach is elegant.

answered Jan 15, 2013 at 14:14

Constantinius

35.2k9 gold badges79 silver badges85 bronze badges

Comments

Vladimir · Accepted Answer · 2013-01-15 14:26:39Z

0

The main point that you could not use class definition inside that class definition itself. So the most straight way to achieve what you are want is to use class/static methods as shown below, or even package constants.

class Category(object):
    def __init__(self, name):
        self.name = name

    @classmethod
    def GOOD(cls):
        return Category(name='good')

    @classmethod
    def BAD(cls):
        return Category(name='bad')

print Category.GOOD().name

or

class Category(object):
    def __init__(self, name):
        self.name = name

    @staticmethod
    def GOOD():
        return Category(name='good')

    @staticmethod
    def BAD():
        return Category(name='bad')

print Category.GOOD().name

edited Jan 15, 2013 at 14:26

answered Jan 15, 2013 at 14:21

Vladimir

10.6k4 gold badges30 silver badges37 bronze badges

4 Comments

Vladimir Over a year ago

You're right -- just copied code from testing another ideas. Fixed. Thank you.

mgilson Over a year ago

As a side note, I didn't like writing GOOD in all caps. It seemed too much like yelling ... In any event, this looks correct now :)

Vladimir Over a year ago

Yes, you're completely right that all-caps function name violates python naming convention. But the question was about feature implementation and not about code style. Hence, the less code changes introduced the more understandable answer is.

mgilson Over a year ago

Yeah, that's fine (not changing it is the right thing to do). I just wanted you to know that I wasn't yelling at you ... I try to be a friendly fellow around here for the most part ...

Collectives™ on Stack Overflow

Creating objects from static properties in python

4 Answers 4

Comments

1 Comment

Comments

4 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

Comments

1 Comment

Comments

4 Comments

Your Answer

Sign up or log in

Post as a guest

Related