向量化对象清单上的减量运算

Question

Is there a pythonic/efficient way to carry out a simple decrement operation on each element (or more accurately a subset of the elements) in a list of objects of an arbitrary class?

I potentially have a large-ish (~ 10K) list of objects, each of which is updated periodically on the basis of a countdown "time to update" (TTU) value.

The simple way to handle this would be to decrement this value in each element as below:

def BatesNumber(start = 0):
    n = start
    while True:
        yield n
        n += 1

class foo:
    index = BatesNumber()

    def __init__(self, ttu):
        self.id = next(foo.index)
        self.time = ttu
        self.ttu = ttu

    def __repr__(self):
        return "#{}:{}/{}".format(self.id, self.ttu, self.time)

    def Decrement(self):
        self.ttu -= 1

    def Reset(self):
        print("Reset {} to {}".format(self.id, self.time))
        self.ttu = self.time

    def IsReadyForUpdate(self):
        if self.ttu == 0:
            return True
        else:
            return False



bar = [foo(i) for i in range(10, 20, 2)]

for n in range(50):
    for p in bar:
        if p.IsReadyForUpdate():
            print("{} {}".format(n, p))
            p.Reset()
        else:
            p.Decrement()

So I guess what I am after is some Pythonic way of "vectorising" the decrement operation - ie decrement all the elements in the list in a suitably elegant way; and, ideally, returning those elements which require update/reset.

I could (although it seems a bit unnecessarily horrible) produce a list which is ordered on the TTU value, and have all the TTU values relative to their neighbour. That way I would only require one decrement per cycle, but then when I reset the counter I have the pain of rebuilding the list. I suppose that this would be better for a very long list with quite high TTU values.

I presume the best/Pythonic way to check which of the elements is ready for update is using a list comprehension.

Any advice?

Answer 1

Perhaps you could replace your flat list with a priority queue using the heapq module. The priorities would be the current time, plus the object's ttu . When the current time matched the top element's priority, you'd pop it off, do whatever your updating was, and then push it back into the queue with a new priority.

The code would look something like this:

import heapq

items = [foo(i) for i in range(10,20)]

queue = [(f.ttu, f.id, f) for f in items]
heapq.heapify(queue)

for t in range(50):
    while t >= queue[0][0]:
        _, _, f = heapq.heappop(queue)
        # update f here
        heapq.heappush(queue, (t + f.ttu, f.id, f))

I'm using the object's id attribute as a tie breaker when two objects need to be updated at the same time. If you wanted to, you could make the priority queue implementation easier by implementing a __lt__ operator in the objects to allow them to be compared directly. If you made them track their own update times, the queue could just contain the objects directly (like the items list) rather than tuples to make them sort in order of priority.

Something like:

class foo:
    index = BatesNumber()

    def __init__(self, ttu):
        self.id = next(index)
        self.next_update = ttu
        self.ttu = ttu

    def __lt__(self, other):
        return (self.next_update, self.id) < (other.next_update, other.id)

    # ideally you'd also write __eq__, __gt__, etc. methods, but heapq only needs __lt__

    def update(self):
        self.next_update += self.ttu
        # maybe do other update stuff here?

By the way, your BatesNumber class is essentially identical to itertools.count .

Answer 2

I think your code is already good; maybe you could add a single method called something like "beat" for performing both things:

• checking if the object is ready to update and in that case handle the update,
• or decrement in the other case;

it would make your loop a little cleaner and simpler. It won't help much for the "vectorization" part of your question but it would go deeper in the "object oriented" way of programming.

For the "vectorization" part; will your list change much during the whole process? One idea could be: have a separate Numpy array containing the values to be decremented and have the table matching your list by the index. Of course it will not be very convenient if you have to suppress instances during the computation but if it isn't the case, it may be the way to go.