Python 在不实例化类的情况下传递数据accross Classess_Python_Oop

Python 在不实例化类的情况下传递数据accross Classess

python oop

Python 在不实例化类的情况下传递数据accross Classess,python,oop,Python,Oop,我有两个类需要在彼此之间传递数据。第一个类实例化第二个类。第二个类需要能够将信息传递回第一个类。但是，我无法再次从类2中实例化ClassOne。这两个类都运行一个共享计时器，在该计时器中它们轮询不同的内容，因此当它们共享计时器时，它们无法共享它们轮询的对象我目前的解决方案（有效）是将一个方法传递给ClassTwo，并用于发送数据备份，但我觉得这可能有点老套，而且是错误的方法 classOne(): def __init__(self,timer): self.clas

我有两个类需要在彼此之间传递数据。第一个类实例化第二个类。第二个类需要能够将信息传递回第一个类。但是，我无法再次从类2中实例化

ClassOne

。这两个类都运行一个共享计时器，在该计时器中它们轮询不同的内容，因此当它们共享计时器时，它们无法共享它们轮询的对象

我目前的解决方案（有效）是将一个方法传递给

ClassTwo

，并用于发送数据备份，但我觉得这可能有点老套，而且是错误的方法

classOne():

    def __init__(self,timer):
        self.classTwo = classTwo(self.process_alerts,timer)
        self.classTwo.start

    def process_alerts(alert_msg):
        print alert_msg 


classTwo():

    def __init__(proses_alerts,timer)
        self.process_alerts = process_alerts  # <----- class ones method

    def start(self):
        check for alerts:
            if alert found: 
                self.alert(alert_msg)


    def alert(self,alert_msg):
        self.process_alert(alert_msg)  # <----- ClassOnes method

classOne（）：
def uuu init uuuu（自我，计时器）：
self.classTwo=classTwo（self.process\u警报、计时器）
self.class2.start
def过程警报（警报消息）：
打印警报消息
第二类（）：
定义初始化（进程警报、计时器）
self.process_alerts=process_alerts#没有任何东西可以阻止您将当前的ClassOne
实例（self
）传递给它自己的ClassTwo
实例：
class ClassOne(object):
    def __init__(self):
        self.two = ClassTwo(self)
        self.two.start()

   def process_alert(self, msg):
       print msg

class ClassTwo(object):
    def __init__(self, parent):
        self.parent = parent

    def start(self):
        while True:
            if self.has_message():
                self.parent.process_alert(self.get_message())

注意，在这个上下文中，“parent”表示它是一个包含关系（“has a”），它与继承无关（“is a”）
如果您的问题是ClassOne
负责实例化ClassTwo
（这确实引入了强耦合），您可以更改ClassOne
，这样需要一个工厂：
class ClassOne(object):
    def __init__(self, factory):
        self.other = factory(self)
        self.other.start()

#等
然后将class2
作为工厂传递：
c1 = ClassOne(ClassTwo)  

因此，您可以通过正确的接口传递任何返回对象的内容（使单元测试更容易）
或者-至少在您（我假设是条带化的）示例中-您可以让ClassOne
将自身传递给ClassTwo.start（）
，并明确地将ClassTwo
实例传递给ClassOne
，即：
class ClassOne(object):
    def __init__(self, other):
        self.other.start(self)

    def process_alert(self, msg):
        print msg


class ClassTwo(object):
    def start(self, parent):
        while True:
            if self.has_message():
                parent.process_alert(self.get_message())


c2 = ClassTwo()
c1 = ClassOne(c2)

或者更简单的方法是删除对class2的调用。从ClassOne
启动，您不需要在ClassOne中引用class2
实例
class ClassOne(object):

    def process_alert(self, msg):
        print msg


class ClassTwo(object):
    def start(self, parent):
        while True:
            if self.has_message():
                parent.process_alert(self.get_message())


c1 = ClassOne()
c2 = ClassTwo()
c2.start(c1)

它尽可能地解耦，但仅当ClassTwo
只需要start（）
中的ClassOne
实例，并且从start
和ClassOne
调用的方法也不需要保留对ClassTwo
实例的引用时，它才起作用
 没有任何东西阻止您将当前的ClassOne
实例（self
）传递给它自己的ClassTwo
实例：
class ClassOne(object):
    def __init__(self):
        self.two = ClassTwo(self)
        self.two.start()

   def process_alert(self, msg):
       print msg

class ClassTwo(object):
    def __init__(self, parent):
        self.parent = parent

    def start(self):
        while True:
            if self.has_message():
                self.parent.process_alert(self.get_message())

注意，在这个上下文中，“parent”表示它是一个包含关系（“has a”），它与继承无关（“is a”）
如果您的问题是ClassOne
负责实例化ClassTwo
（这确实引入了强耦合），您可以更改ClassOne
，这样需要一个工厂：
class ClassOne(object):
    def __init__(self, factory):
        self.other = factory(self)
        self.other.start()

#等
然后将class2
作为工厂传递：
c1 = ClassOne(ClassTwo)  

因此，您可以通过正确的接口传递任何返回对象的内容（使单元测试更容易）
或者-至少在您（我假设是条带化的）示例中-您可以让ClassOne
将自身传递给ClassTwo.start（）
，并明确地将ClassTwo
实例传递给ClassOne
，即：
class ClassOne(object):
    def __init__(self, other):
        self.other.start(self)

    def process_alert(self, msg):
        print msg


class ClassTwo(object):
    def start(self, parent):
        while True:
            if self.has_message():
                parent.process_alert(self.get_message())


c2 = ClassTwo()
c1 = ClassOne(c2)

或者更简单的方法是删除对class2的调用。从ClassOne
启动，您不需要在ClassOne中引用class2
实例
class ClassOne(object):

    def process_alert(self, msg):
        print msg


class ClassTwo(object):
    def start(self, parent):
        while True:
            if self.has_message():
                parent.process_alert(self.get_message())


c1 = ClassOne()
c2 = ClassTwo()
c2.start(c1)

它尽可能地解耦，但仅当ClassTwo
只需要start（）
中的ClassOne
实例，并且从start
和ClassOne
调用的方法也不需要保留对ClassTwo
实例的引用时，它才起作用
 您可以删除/最小化类之间的耦合！我发现这种映射非常适合通过跨网络通信来共享数据
通过使用Queue，可以将这两个类解耦。生产者（ClassTwo
）可以检查消息，并将它们发布到队列中。它不再需要知道如何正确地实例化一个类或与之交互，它只是传递一条消息
然后，ClassOne
实例可以在消息可用时从队列中提取消息。这也有助于独立地缩放每个实例
ClassTwo -> publish to queue -> Class One pulls from queue.

这也有助于测试，因为这两个类是完全隔离的，您可以为任何一个类提供一个队列

队列通常还提供在消息可用之前支持阻塞的操作，因此您不必管理超时。
您可以删除/最小化类之间的耦合！我发现这种映射非常适合通过跨网络通信来共享数据
通过使用Queue，可以将这两个类解耦。生产者（ClassTwo
）可以检查消息，并将它们发布到队列中。它不再需要知道如何正确地实例化一个类或与之交互，它只是传递一条消息
然后，ClassOne
实例可以在消息可用时从队列中提取消息。这也有助于独立地缩放每个实例
ClassTwo -> publish to queue -> Class One pulls from queue.

这也有助于测试，因为这两个类是完全隔离的，您可以为任何一个类提供一个队列

队列通常还提供在消息可用之前支持阻塞的操作，因此您不必管理超时。
未来提示：在注释中放置标记，这样代码仍然有效：）。您可以将@staticmethod
注释添加到过程警报中。为什么不从类1继承类2<代码>类二（一）：…
因为我使用的计时器应用程序重载了3个方法，所以两个类都需要包含这些方法并返回不同的信息。我看不出矛盾。未来的提示：在注释中放置标记，以便