Can I keep a list of references, that auto update in the list?

Question

In its essence, I do this:

a = True
b = False
ls = [a, b]

a = False

print(ls)
> [True, False]

And what happens is that whatever happens to a is decoupled from the list after the first inclusion. Is there any way to update a and also have the list updating itself, in a clean way?

Of course I could simply do ls[0] = False and be done. But in a large project, with many moving parts, I'd like to avoid non-descriptive bracket indexing.

I assume I could do some messy construct of an instantiated class, and then iterate over the attributes, but that sounds like messy business. Or is it?

`ls` is a `tuple` and tuples are *immutable*. Changing it to a list does not solve the problem but you can't expect a tuple to update. — Ma0, Sep 13 '18 at 08:07
`a` is a name for an object. If you assign to `a` you don't change the object you change what `a` references. — Peter Wood, Sep 13 '18 at 08:09
In short: no. Assignment to a symbol (variable name) only ever affects that symbol. Unless you mutate mutable objects, such effects never propagate. — deceze, Sep 13 '18 at 08:10
Data structures and algorithms are complimentary. This is too broad a question really. You need to think about what you want to achieve with your data structures. — Peter Wood, Sep 13 '18 at 08:11
Possible duplicate of [Pointers in Python?](https://stackoverflow.com/questions/3106689/pointers-in-python) — lucidbrot, Sep 13 '18 at 08:12
Use a named tuple (in the collections module) instead of a list. — DisappointedByUnaccountableMod, Sep 13 '18 at 08:12
@barny tuples are immutable and more appropriate for heterogeneous data. Lists are more appropriate for homogeneous data. — Peter Wood, Sep 13 '18 at 08:14
I think https://stackoverflow.com/a/14110487/7026806 is a good solution, actually. — komodovaran_, Sep 13 '18 at 08:15
@barny why? I've sung the praises of [**`namedtuple`**](https://docs.python.org/3/library/collections.html#collections.namedtuple) many times. This isn't an appropriate usage. A `namedtuple` [is-a](https://en.wikipedia.org/wiki/Is-a) `tuple`. — Peter Wood, Sep 13 '18 at 08:24

101 · Accepted Answer · 2022-09-14T08:12:23.820

If you want to avoid indexing and have easy to read attributes then you could just use a class that has class attributes:

class Data:
    a = True

and keep multiple references to it:

data = Data
data2 = Data  # or similarly data2 = data

data.a = False
print(data2.a)
# False

Note that if you instantiate the class you'll need to keep a reference to the instance rather than the class as the original class won't be updated anymore:

data = Data()
data2 = data

data.a = 123
print(data2.a)
# 123

# original class remains unchanged
print(Data().a)
# True

From Python 3.7 you can use a dataclass, which makes instantiation with custom data simpler:

from dataclasses import dataclass

@dataclass
class Data:
    a = True

data = Data(a=False)
data2 = data
print(data2.a)
# False

Finally, if you do care about variable states then there's a good chance you'll be working within a class anyway, in which case you could use a property:

class SomeClass:
    def __init__(self):
        self.a = False
        self.b = True

    @property
    def ls(self):
        return self.a, self.b
    
some_class = SomeClass()
some_class.a = True
print(some_class.ls)
# True, True

It's probably worth noting that this only works in Py >= 3.7 — roganjosh, Sep 13 '18 at 08:26
This is probably the densest approach, coupled with an `__iter__: yield` method to make it list-like. — komodovaran_, Sep 13 '18 at 08:52

score 0 · Answer 2 · answered Sep 13 '18 at 08:20

I suggest you this quite simple solution defining ls as a function instead of a simple list. In this way, ls() will always returns the updated values of aand b. The code is very close to your original code:

a = True
b = False

ls = lambda:[a,b]

a = False
print(ls())  # [False, False]

b = True
print(ls())  # [False, True]

Can I keep a list of references, that auto update in the list?

2 Answers2