Question

I find myself repeating a common pattern when trying to execute code across multiple objects.

Arg_list_one = ["first","second", "so on"]
Arg_list_two = ["first","second", "so on"]


MANIFEST = [ ]

class connection(object):
    def __init__(self, args):
        ...
        MANIFEST.append(self)
    def Run(self):
        ...

connection(Arg_list_one)
connection(Arg_list_two)

[conn.Run() for conn in MANIFEST]

Is this a pattern (or anti-pattern)? Or just something that I made up?

Are there other, better, ways of doing this?

Answer 1

Why would you need a list of all objects ever created? Many of those may belong to completely unrelated pieces of your application! A given piece of code shouldn’t assume it’s the only one to user a class. Especially since there’s usually no need to:

• A function creates a bunch of objects and then does something to all of them? Put the objects into a temporary, locally-scoped list.
• Need to share some objects between functions? Put them in a list, pass the list to whoever should see the objects.
• Instances of some class share some of these object? Make a list of them and put them in the class.
• Et cetera, you see where this is going.

A more practical and less stylistic issue is that this list would keep every single object of that class that’s ever instanciated alive forever. And they say one can’t create memory leaks in Python… (This can be avoided with weak reference, but would make the code much more complex to transparently remove dead references.)

The solution is barely more typing and saves you a whole lot of headaches later on. Next you’ll use local variables to save yourself a return?

connections = [Connection(arg_list_one), Connection(arg_list_two)]
for connection in connections:
    connection.run()

That said, there may be situations where such a list may be useful (with a fix for said memory leak, of course). I just don’t see anything close to that in your example, and I think such situations are very rare.