Mailing List Archive

Guenther Sohler wrote at 2024-1-9 08:14 +0100:
>when i run this code
>
>a = cube([10,1,1])
>b = a
>
>i'd like to extend the behaviour of the assignment operator
>a shall not only contain the cube, but the cube shall also know which
>variable name it
>was assigned to, lately. I'd like to use that for improved user interaction.

`Acquisition` (--> `PyPI`) implements something similar.

It does not work for variables -- but for attribute access.
Look at the following code:

```
from Acquisition import Implicit

class AccessAwareContainer(Implicit):
...

class AccessAwareContent(Implicit):
...

container = AccessAwareContainer()
container.content = AccessAwareContent()
```

When you now assign `content = container.content`, then
`content` knows that it has been accessed via `container`.


If fact `content` is not a true `AccessAwareContent` instance
but a wrapper proxy for it. It mostly behaves like an
`AccessAwareContent` object but has additional information
(e.g. it knows the access parent).


It works via a special `__getattribute__` method, essentially
implemented by:

```
def __getattribute__(self, k):
v = super().__getattribute__(k)
return v.__of__(self) if hasattr(v, "__of__") else v
```

Your use case could be implemented similarly (again not for variables
and all objects, but for special classes (and maybe special objects)).

Your `__getattribute__` could look like:
```
def __getattribute__(self, k):
v = super().__getattribute__(k)
try:
v.name = k
except TypeError: pass
return v
```
--
https://mail.python.org/mailman/listinfo/python-list

Guenther,

It is best not to suggest a drastic fix for a more limited problem.

As a general rule, many programming languages only have a pointer concept
even vaguely along the lines you want for garbage collection purposes. An
area of memory may have stored alongside it how many other things point at
it but not which ones. As long as it is decremented when a pointer leaves,
it works.

If you want to design objects that can store additional info when invoked
properly, go for it. No change to python would be needed. In your example,
you could create an object initialized by cube([10,1,1], "a") which now
might remember that something called "a" once pointed at it. But you then
have to figure out how to ensure than when "a" is deleted or reset or goes
out of the current environment, that things are properly updated.

I am not so sure how easy it would be to change the language so it pays
attention to what it is giving a pointer too and then goes and tells ...



-----Original Message-----
From: Python-list <python-list-bounces+avi.e.gross=gmail.com@python.org> On
Behalf Of Guenther Sohler via Python-list
Sent: Tuesday, January 9, 2024 2:15 AM
To: python-list@python.org
Subject: extend behaviour of assignment operator

Hi,

when i run this code

a = cube([10,1,1])
b = a

i'd like to extend the behaviour of the assignment operator
a shall not only contain the cube, but the cube shall also know which
variable name it
was assigned to, lately. I'd like to use that for improved user interaction.

effective code should be:

a=cube([10,1,1])
a.name='a'

b=a
b.name='b' # i am aware that a.name also changes


can decorators also be used with assignment operators ?

thank you for your hints
--
https://mail.python.org/mailman/listinfo/python-list

--
https://mail.python.org/mailman/listinfo/python-list