Question

我有一个使用线程计时器的脚本，可以随机操作2个常用列表。

因为类实例操作了线程计时器上的列表，所以我无法将变量传递给类＆amp;背部。

...所有类的实例都需要操作一个最新的列表。

因此，这些列表的范围设置为全局。但是，我需要将范围放在类级别，但需要由多个类操作。

澄清......

这是基本的程序结构：

Global list variable_1
Global list variable_2

class MasterClass:
    # this creates instances of the threaded classes. 
    There are 50+ instances of MasterClass creating thousands
    of instances of ThreadedClass1, 2, & 3.  All manipulate
    global list variables 1 & 2.

class ThreadedClass1:
    # threaded classes manipulate global list variables 1 & 2 on random timers.

class ThreadedClass2:

class ThreadedClass3:

问题：对于MasterClass的每个实例，我需要一个单独的列表变量1＆amp; 2.由MasterClass实例调用的每个ThreadedClasses实例必须只操作该MasterClass实例拥有的列表变量。

基本上我需要相当于一个全局列表变量，但我需要它由MasterClass实例封装，并且只能由MasterClass的该实例调用的任何ThreadedClasses实例操作。

这是怎么做到的？

Answer 1

如果我理解正确，你应该能够使它们成为MasterClass的实例变量并将它们传递给构造函数。

例如

class MasterClass:
    def __init__(self):
        self.variable_1 = [...]
        self.variable_2 = [...]
        self.tc1 = ThreadedClass1(self.variable_1, self.variable_2)
        self.tc2 = ThreadedClass2(self.variable_1, self.variable_2)
        self.tc3 = ThreadedClass3(self.variable_1, self.variable_2)

或者在

中传递整个实例

class MasterClass:
    def __init__(self):
        self.variable_1 = [...]
        self.variable_2 = [...]
        self.tc1 = ThreadedClass1(self)
        self.tc2 = ThreadedClass2(self)
        self.tc3 = ThreadedClass3(self)

class ThreadedClass1:
    def __init__(self, parent):
        self.mc = parent

等

Answer 2

尝试将MasterClass的实例传递给ThreadedClasses的每个生成实例。

然后，在MasterClass中定义线程保存方法，这将使用variable_1，variable_2执行操作。 ThreadedClasses不得直接触及此列表，只能通过调用这些方法。

小例子（检查subclassing from object）：

import threading


class ThreadedClassBase(object):
    def __init__(self, master, *args, **kwargs):
        self.master = master

    def do_something(self):
        self.master.append(1, 'some_value')
        value = self.master.getitem(1, 0)


class ThreadedClass1(ThreadedClassBase):
    def __init__(self, *args, **kwargs):
        super(ThreadedClass1, self).__init__(*args, **kwargs)
        # ...

# same for ThreadedClass2, 3


class MasterClass(object):
    def __init__(self, *args, **kwargs):
        self.variable_1 = list()
        self.variable_2 = list()
        self.lock = threading.Lock()
        for i in range(50):
            ThreadedClass1(master=self)
            # create new thread

    def append(list_nb, value):
        with self.lock:
            getattr('variable_' + list_nb).append(value)

    def getitem(list_nb, index):
        with self.lock:
            return getattr('variable_' + list_nb)[index]

Python：如何跨多个类封装变量？

2 个答案: