CODEWITHSUNDEEP
pythonclassattributes
Woltan
Woltan

Reputation: 14023

Is there a "standard" basic class in python?

I am looking for a way to create a basic python "object" which I can externally assign attributes to.
Currently I am doing it the following way:

I define an empty class with

class C(object):
    pass

and then I instantiate an object and assign attributes like this:

c = C()
c.attr = 2

Coming to my question

Is there a way to instantiate an empty class object, which I can then assign attributes like shown above without defining a class C?

Is there maybe an other better way to accomplish what I am after?

Upvotes: 1

Views: 155

Answers (3)

Lauritz V. Thaulow
Lauritz V. Thaulow

Reputation: 51015

Is there a way to instantiate an empty class object, which I can then assign attributes like shown above without defining a class C?

Yes:

>>> C = type("C", (object,), {})
>>> c = C()
>>> c.attr = 2

But as you can see, it's not much of an improvement, and the end result is the same -- it's just another way of creating the same class C.

Addendum:

You can make it prettier by "hiding" it in a function:

def attr_holder(cls=type("C", (object,), {})):
    return cls()

c = attr_holder()
c.attr = 2

Though this is just reinventing the wheel -- replace the two line function with 

class attr_holder(object):
    pass

and it'll work exactly the same, and we've come full circle. So: go with what David or Reorx suggests.

Upvotes: 4

Reorx
Reorx

Reputation: 3001

I had come to the same question long ago, and then create this class to use in many of my projects:

class DotDict(dict):
    """
    retrieve value of dict in dot style
    """
    def __getattr__(self, key):
        try:
            return self[key]
        except KeyError:
            raise AttributeError('has no attribute %s' % key)

    def __setattr__(self, key, value):
        self[key] = value

    def __delattr__(self, key):
        try:
            del self[key]
        except KeyError:
            raise AttributeError(key)

    def __str__(self):
        return '<DotDict %s >' % self.__to_dict()

    def __to_dict(self):
        return dict(self)

When I want a object to store data or want to retrieve value easily from a dict, I always use this class.

Additionally, it can help me serialize the attributes that I set in the object, and reversely get the original dict when needed.

So I think this may be a good solution in many situations, though other tricks look simple, they are not very helpful further.

Upvotes: 2

David Heffernan
David Heffernan

Reputation: 613402

It looks like you are looking for a flexible container that has no methods and can take attributes with arbitrary names. That's a dict.

d = dict()
d['myattr'] = 42

If you prefer the attribute syntax that you get with a class (c.myattr = 42), then use a class just as per the code in your question.

Upvotes: 6

Related Questions