Python - Passing object value instead of reference

Question

In Python, as I understand it, variables are really references to objects in the given namespace. So in the following example, it is unsurprising that when noise changes in the global namespace, the value returned by cat.noise changes, as the reference in the setattr line is using the reference of noise, not its underlying value.

class Cat(object):
    pass

noise = "meow"

setattr(Cat, "noise", property(lambda self: noise))

cat = Cat()
cat.noise
# Outputs "meow"

noise = "purrrrr"
cat.noise
# Outputs "purrrrr"

That being said, is there a way to pass the value of noise when calling setattr as above? I figured that I could isolate the namespace by using a function, and that did work:

class Cat(object):
    pass

noise = "meow"

def setproperties(cls, k, v):
    setattr(cls, k, property(lambda self: v))

setproperties(Cat, "noise", noise)

cat = Cat()
cat.noise
# Outputs "meow"

noise = "purrrrr"
cat.noise
# Still outputs "meow"

Is it possible to do so without passing the object through a function (without using eval or the like)? And as a secondary question, is my reasoning about what goes on under the hood correct?

EDIT

As per the request for a less contrived example in the comments, consider the following. Imagine I am trying to dynamically set attributes in Cat, based on the values of its friend Dog:

class Dog(object):
    noise = 'woof'
    adorable = True

class Cat(object):
    friend = Dog

friend_attrs = filter(lambda attr: not attr.startswith('__'), Dog.__dict__)

for attr in friend_attrs:
    setattr(Cat, "friend_" + attr, property(lambda self: getattr(self.friend, attr)))

cat = Cat()

cat.friend_noise
# Outputs True

cat.friend_adorable
# Outputs True

Why do you use a property, and not the value directly itself? — user707650
– user707650, Commented Nov 17, 2016 at 21:06
@Evert unfortunately, in the real-world example I'm working with it does need to be a property, because the lambda function is more complicated. I know the example above is a bit contrived... — aensm
– aensm, Commented Nov 17, 2016 at 21:08
"it does need to be a property, because the lambda function is more complicated" - what's the problem exactly? Can you give a less contrived example? — ali_m
– ali_m, Commented Nov 17, 2016 at 21:14

sardok · Accepted Answer · 2016-11-17 21:21:59Z

2

Just pass the value of noise to setattr function. E.g.

class C(object):
    pass


noise = 'mrrrr'

setattr(C, 'noise', noise)

c = C()

c.noise
# outputs 'mrrrr'

noise = 'qwe'

c.noise
# outputs 'mrrrr'

Edit: For case where getter function is needed for some reason.

You may use intermediate value.

class D(object):
    pass


 noise = 'mrrrr'

 setattr(D, '_noise', noise)

 setattr(D, 'noise', property(lambda self: self._noise))

 d = D()

 d.noise
 # Outputs 'mrrrr'

 noise = 'pheew'

 d.noise
 # Outputs 'mrrrr'

Edit 2: using partial functions.

import functools

class E(object):
    pass


noise = 'mrrrr'

getter = lambda _, noise: noise

partial = functools.partial(getter, noise=noise)

setattr(E, 'noise', property(partial))

e = E()

e.noise
# Outputs 'mrrrr'

noise = 'fooooo'

e.noise
# Outputs 'mrrrr'

edited Nov 17, 2016 at 21:21

answered Nov 17, 2016 at 21:05

sardok

1,1161 gold badge10 silver badges20 bronze badges

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

2 Comments

aensm Over a year ago

Unfortunately, that is not an option. The example is a bit contrived, but in the real-world example I'm working with it does need to be a property.

sardok Over a year ago

Added another piece of code, which uses intermediate value and property function.

Eli Korvigo · Accepted Answer · 2016-11-17 21:23:48Z

1

This happens, because in Python functions (including lambdas) use symbolic binding, i.e. your lambda points at the variable, not at its value. To overcome this you should enclose that variable (create a closure):

noise = "meow"
f1 = lambda self: noise
f2 = (lambda x: (lambda self: x))(noise)

noise = "mur"
print(f1(None))  # -> "mur"
print(f2(None))  # -> "meow"

But you have already found that yourself by using a function to enclose the operation. This is Pythonic.

answered Nov 17, 2016 at 21:23

Eli Korvigo

10.5k6 gold badges50 silver badges75 bronze badges

Comments

Blckknght · Accepted Answer · 2016-11-17 21:43:52Z

Python functions (including lambda functions) refer to non-local variables by name. That means they'll get the latest value of that variable, not the one it had when the function was defined (indeed, the variable need not have been defined at all when the function was defined).

One way to work around this is to put the value as a default value for an argument to the function. The default value is evaluated at the function definition time, not when the function is called (this is why mutable default arguments are often problematic).

Try something like this:

for attr in friend_attrs:
    setattr(Cat, "friend_" + attr,
            property(lambda self, attr=attr: # added attr=attr default here!
                     getattr(self.friend, attr))) # attr is the lambda's arg here

hpaulj · Accepted Answer · 2016-11-17 22:26:34Z

With

setattr(Cat, "noise", property(lambda self: noise))

just defines the property as a function that returns the value of the global noise variable. It is similar to

def make_noise(self):
   return noise

The 2nd case is a little more complicated. The property now returns the value of v, which was defined during creation.

I can produce the same sort of behavior with a simple function:

In [268]: bar = 'barstring'
In [269]: def foo():
     ...:     return bar     # returns the global
     ...: 
In [270]: foo()
Out[270]: 'barstring'
In [271]: bar = 'xxx'
In [272]: foo()
Out[272]: 'xxx'

but if I pass bar as a keyword, I can lock in the value, to the current one:

In [273]: def foo1(bar=bar):  
     ...:     return bar       
     ...: 
In [274]: foo1()
Out[274]: 'xxx'
In [275]: bar = 'ooo'
In [276]: foo1()
Out[276]: 'xxx'
In [277]: foo()
Out[277]: 'ooo'

But if I make bar mutable (e.g. a list)

In [278]: bar=['one']
In [279]: foo()
Out[279]: ['one']
In [280]: def foo1(bar=bar):
     ...:     return bar
     ...: 
In [281]: foo1()
Out[281]: ['one']
In [282]: bar[0]='two'
In [283]: foo1()
Out[283]: ['two']

foo1 returns an item from its __defaults__ (if I don't give it an argument). foo continues to access the global, because there's no local binding for bar.

In [289]: foo1.__defaults__
Out[289]: (['two'],)
In [290]: foo.__defaults__

At heart this is a question of where the variable is bound - locally, in some container function, or globally.

Mutable defaults like this can be useful, but they can also be a cause of errors.

============

Another example of local binding

In [297]: def make_foo(bar):
     ...:     def foo():
     ...:         print(locals())
     ...:         return bar
     ...:     return foo
     ...: 
In [298]: foo2=make_foo('test')
In [299]: foo2()
{'bar': 'test'}
Out[299]: 'test'

foo looks the same, but now bar references the variable bound in its locals. partial and your setproperties do the same thing.

Collectives™ on Stack Overflow

Python - Passing object value instead of reference

EDIT

4 Answers 4

2 Comments

Comments

Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

EDIT

4 Answers 4

2 Comments

Comments

Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related