Python extremely dynamic class properties

Question

To create a property in a class you simply do self.property = value. I want to be able to have the properties in this class completely dependent on a parameter. Let us call this class Foo.

instances of the Foo class would take a list of tuples:

l = [("first","foo"),("second","bar"),("anything","you get the point")]
bar = Foo(l)

now the instance of the Foo class we assigned to bar would have the following properties:

bar.first
#foo
bar.second
#bar
bar.anything
#you get the point

Is this even remotely possible? How?

Look at [`setattr`](http://docs.python.org/2/library/functions.html#setattr). — BrenBarn, Oct 06 '13 at 02:38
You might also want to see [`namedtuple`](http://docs.python.org/2/library/collections.html#collections.namedtuple). — Waleed Khan, Oct 06 '13 at 02:40
setattr worked perfectly! thanks. and I'll look into namedtuple — Ryan Saxe, Oct 06 '13 at 02:43

score 6 · Answer 1 · answered Oct 06 '13 at 02:59

6

I thought of another answer you could use using type(). It's completely different to my current answer so I've added a different answer:

>>> bar = type('Foo', (), dict(l))()
>>> bar.first
'foo'
>>> bar.second
'bar'
>>> bar.anything
'you get the point'

type() returns a class, not an instance, hence the extra () at the end.

answered Oct 06 '13 at 02:59

TerryA

58,805
11
114
143

2

this is extremely creative and compressed...+1 – Ryan Saxe Oct 06 '13 at 03:06
This is cool. Yesterday, I learnt to do the same in javascript with `Function` and today I learnt to do it in python. SO is OSM. – thefourtheye Oct 06 '13 at 03:21
1

@thefourtheye: You can even build functions on the fly, using `types.FunctionType`. Of course you first need to get a code object (by compiling one, borrowing one from another function, generating bytecode by hand, …). Normally, there are better ways to do that in Python… but almost anything you can think of is possible. – abarnert Oct 06 '13 at 03:30

score 4 · Accepted Answer · answered Oct 06 '13 at 02:41

4

These are called attributes, rather than properties. With that in mind, the method setattr() becomes more obvious:

class Foo(object):
    def __init__(self, l):
        for k, v in l:
            setattr(self, k, v)

This takes each key-value pair in l and sets the attribute k on the new instance of Foo (self) to v.

Using your example:

l = [("first","foo"),("second","bar"),("anything","you get the point")]
bar = Foo(l)

print bar.first
#foo
print bar.second
#bar
print bar.anything
#you get the point

answered Oct 06 '13 at 02:41

johnsyweb

136,902
23
188
247

1

What's the difference with `setattr(Foo...` and `setattr(self...`? – TerryA Oct 06 '13 at 02:43
I believe it is because self is each specific class where Foo is the general one so it will make all Foo classes have that. Not sure though, I'm just speculating – Ryan Saxe Oct 06 '13 at 02:46
2

@Haidro: `self` sets the attribute for the current *instance*, rather than for the `class`. – johnsyweb Oct 06 '13 at 02:47
1

@Johnsyweb Ah, so it's probably safer to use `self` :). +1 – TerryA Oct 06 '13 at 02:48

Krzysztof Kosiński · Answer 3 · 2013-10-06T03:18:07.193

There are two ways to do this:

Use setattr like this. This approach is feasible if you only need to process the initial list once, when the object is constructed.
```
class Foo:
  def __init__(self, l):
    for (a, b) in l:
      setattr(self, a, b)
```
Define a custom __getattr__ method. Preferably, you would store the properties in a dict for faster lookup, but you can also search the original list. This is better if you want to later modify the list and want this to be reflected in the attributes of the object.
```
class Foo:
  def __init__(self, l):
    self.l = l
  def __getattr__(self, name):
    for a in self.l:
      if a[0] == name:
        return a[1]
    return None
```

in `__getattr__` you need to have `self.l`, not `l` – Ryan Saxe Oct 06 '13 at 03:03 — Ryan Saxe, Oct 06 '13 at 03:03

TerryA · Answer 4 · 2013-10-06T02:57:44.647

2

Something like this?

>>> class Foo:
...     def __init__(self, mylist):
...         for k, v in mylist:
...             setattr(self, k, v)
... 
>>> l = [("first","foo"),("second","bar"),("anything","you get the point")]
>>> bar = Foo(l)
>>> bar.first
'foo'
>>> bar.second
'bar'
>>> bar.anything
'you get the point'

Using setattr you can do this by passing in the list and just iterating through it.

edited Oct 06 '13 at 02:57

answered Oct 06 '13 at 02:41

TerryA

58,805
11
114
143

score -1 · Answer 5 · answered Oct 06 '13 at 02:43

setattr works.

>>> class Foo:
...   def __init__(self,yahoo):
...     for k,v in yahoo:
...       setattr(self,k,v)
...
>>> l = [("first","foo"),("second","bar"),("anything","you get the point")]
>>> bar = Foo(l)
>>> print bar.first
foo
>>> print bar.second
bar
>>> print bar.anything
you get the point

Python extremely dynamic class properties

5 Answers5

Linked