Python: Using class variables to keep track of all objects

Question

I'm struggling with the best way to implement the following in python:

I have a simulation that generates a variety of shapes. At each run of the simulation code, new shapes composed of new line objects are generated, but these objects need to be persistent across multiple runs.

Each line is described by a polyline-encoded string. Each time a new line is generated I need to verify that the same line doesn't already exists. If it does, I want to return the original, if not, I want to create a new one.

I also need to keep track of all created objects so that at the end of multiple simulation runs, I can get them all back and send them to a database.

My first approach is to use the itertools.count iterator as a class variable, and get a new id on creation (I need to keep both the id and string for legacy reasons).

class Line(object):
    new_id = itertools.count(start=1).next
    lines = []

    def __init__(self, coord_string):
        self.coord_string = coord_string
        self.id = Line.new_id()
        Line.lines.append(self)

    @staticmethod
    def from_coord_string(coord_string):
        lines = [l.coord_string for l in Line.lines]
        try:
            ind = lines.index(path)
            return Line.links(ind)
        except ValueError:
            return Line(coord_string)

I'm also keeping track of all created objects in the a class variable. This lets me check to see if a Line has been created already, or get easy access to all of them later, i.e.:

all_lines = Line.lines
dump_to_db(all_lines)

What are the downsides to using class variables like this? Is there a better, or more efficient way to implement this?

You're basically looking for the object pool pattern. Implementing it as a static method on a class is ill-advised, as you'll never be able to decouple your object pool from your objects — Alexander
– Alexander, Commented Jul 4, 2017 at 19:12
Also, your id generation isn't thread safe, so it's totally possible to end up with 2o objects with the same line. — Alexander
– Alexander, Commented Jul 4, 2017 at 19:14

Alexander · Accepted Answer · 2017-07-04 19:31:40Z

1

I would do something like this:

from itertools import *
from multiprocessing import Lock

class Line(object):
    def __init__(self, ID, coord_string):
        self.id = ID
        self.coord_string = coord_string

class LineFactory(object):
    latestId = 0
    idLock = Lock()

    def __init__(self):
        self.lines = {} # Dict mapping coord_string to Line objects

    def make_new_id(self):
        with self.idLock:
            newId = self.latestId
            self.latestId += 1
        return newId

    def new_line(self, coord_string):
        if not coord_string in self.lines:
            self.lines[coord_string] = Line(self.make_new_id(), coord_string)

        return self.lines[coord_string]

    def get_all_lines(self):
        return self.lines.values

answered Jul 4, 2017 at 19:31

Alexander

63.9k13 gold badges106 silver badges177 bronze badges

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

2 Comments

ShadowRanger Over a year ago

The OP's solution using itertools.count would (at least on CPython) avoid the need for the lock; moving to manually reading and modifying latestId creates the need for the lock.

Alexander Over a year ago

Heh, this was from 3 years ago, I don’t remember any of this. I’m not a fan of this mutable factory, at all.

Collectives™ on Stack Overflow

Python: Using class variables to keep track of all objects

1 Answer 1

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related