Python 如何从另一个类调用一个类的方法？

我想从另一个类调用一个类的方法。我想做这样的事

class A:
    def meth(self):
        B.meth1()

class B:
    def meth1(self):
        pass

a = A()
a.meth()

我得到以下错误：

TypeError: unbound method meth1() must be called with B instance as first argument (got nothing instead)

我做错了什么

更新：

class A:
    def meth(self, data):
        if data[0] == '/':
            B.handleCOMMAND(data)

class B:
    def __init__(self):
        self.state = 'CHAT'

    def handleCOMMAND(self, data):
        if data.strip().split()[1] == 'send':
             self.state == 'RECV-FILE'

上面的例子可能有点模糊。以下是我真正打算做的：

class A:
    def meth(self, data):
        if data[0] == '/':
            B.handleCOMMAND(data)

class B:
    def handleCOMMAND(self, data):
        """
        Some code to handle some command.
        """

更新2:

class A:
    def meth(self, data):
        if data[0] == '/':
            B.handleCOMMAND(data)

class B:
    def __init__(self):
        self.state = 'CHAT'

    def handleCOMMAND(self, data):
        if data.strip().split()[1] == 'send':
             self.state == 'RECV-FILE'

我面临的主要问题是：

“self.state”是类B中的一个实例变量。根据类A的“data”meth（）获取的内容，需要调用类B的handleCOMMAND，该命令应该会更改“self.state”的值

class A:
    def meth(self):
        "create instance of B class"
        b = B()
        b.meth1()

还可以将B.meth1（）声明为静态：

class B:
    @staticmethod
    def meth1():
        pass

然后你可以这样称呼它：

class A:
    def meth(self):
        "create instance of B class"
        B.meth1()

还可以将B.meth1（）声明为静态：

class B:
    @staticmethod
    def meth1():
        pass

然后你可以这样称呼它：

class A:
    def meth(self):
        "create instance of B class"
        B.meth1()

这里B.meth1是一个实例方法，您正试图将其用作类方法。您可以将B.meth1重新定义为classmethod：

class B:
  @classmethod
  def meth1(cls):
    pass

或者，您可以通过实例化B类将其作为实例方法调用：

class A:
    def meth(self):
        B().meth1()

这里B.meth1是一个实例方法，您正试图将其用作类方法。您可以将B.meth1重新定义为classmethod：

class B:
  @classmethod
  def meth1(cls):
    pass

或者，您可以通过实例化B类将其作为实例方法调用：

class A:
    def meth(self):
        B().meth1()

---

除非有实例可调用，否则不能调用实例方法

如果不知道您的设计目标是什么，就不可能告诉您实例应该来自哪里，但是有两种特别常见的模式

首先，该方法可以将

B

实例作为参数。例如：

class A:
    def meth(self, b):
        b.meth1()

class B:
    def meth1(self):
        pass

a = A()
b = B()
a.meth(b)

class A:
    def __init__(self, b):
        self.b = b
    def meth(self):
        self.b.meth1()

class B:
    def meth1(self):
        pass

b = B()   
a = A(b)
a.meth()

class A:
    def __init__(self):
        self.b = B()
    def meth(self):
        self.b.meth1()

class B:
    def meth1(self):
        pass

a = A()
a.meth()

为了使这更具体，假设

A

是

汽车

，

B

是

收费公路

，而

我的汽车.驾驶（我的路）

必须呼叫

我的路.支付通行费（）

---

或者，每个

A

实例可以拥有一个

B

实例作为成员。例如：

class A:
    def meth(self, b):
        b.meth1()

class B:
    def meth1(self):
        pass

a = A()
b = B()
a.meth(b)

class A:
    def __init__(self, b):
        self.b = b
    def meth(self):
        self.b.meth1()

class B:
    def meth1(self):
        pass

b = B()   
a = A(b)
a.meth()

class A:
    def __init__(self):
        self.b = B()
    def meth(self):
        self.b.meth1()

class B:
    def meth1(self):
        pass

a = A()
a.meth()

为了使这更具体，假设

A

再次是

Car

，

B

是服务中心，

mycar.schedule\u service（）

需要调用

mycar.service\u center.get\u next\u appointment（）

---

作为后者的变体，每个

B

实例可以是

a

实例整体的一部分，由

a

实例自动构造。例如：

class A:
    def meth(self, b):
        b.meth1()

class B:
    def meth1(self):
        pass

a = A()
b = B()
a.meth(b)

class A:
    def __init__(self, b):
        self.b = b
    def meth(self):
        self.b.meth1()

class B:
    def meth1(self):
        pass

b = B()   
a = A(b)
a.meth()

class A:
    def __init__(self):
        self.b = B()
    def meth(self):
        self.b.meth1()

class B:
    def meth1(self):
        pass

a = A()
a.meth()

---

对于本例，再次假设

A

是

汽车

，而

B

是

发动机

。因此，

my\u car.drive（）

开始调用

my\u car.engine.start（）

。但是，与独立存在且被许多汽车使用的

服务中心不同，
引擎只被它所属的汽车使用，因此没有充分的理由单独创建引擎并将其传递给汽车（除非你正在为汽车工厂建模）.
除非有实例可供调用，否则不能调用实例方法

如果不知道您的设计目标是什么，就不可能告诉您实例应该来自哪里，但是有两种特别常见的模式

首先，该方法可以将
B
实例作为参数。例如：

class A:
    def meth(self, b):
        b.meth1()

class B:
    def meth1(self):
        pass

a = A()
b = B()
a.meth(b)

class A:
    def __init__(self, b):
        self.b = b
    def meth(self):
        self.b.meth1()

class B:
    def meth1(self):
        pass

b = B()   
a = A(b)
a.meth()

class A:
    def __init__(self):
        self.b = B()
    def meth(self):
        self.b.meth1()

class B:
    def meth1(self):
        pass

a = A()
a.meth()

为了使这更具体，假设
A
是
汽车
，
B
是
收费公路
，而
我的汽车.驾驶（我的路）
必须呼叫
我的路.支付通行费（）


或者，每个
A
实例可以拥有一个
B
实例作为成员。例如：

class A:
    def meth(self, b):
        b.meth1()

class B:
    def meth1(self):
        pass

a = A()
b = B()
a.meth(b)

class A:
    def __init__(self, b):
        self.b = b
    def meth(self):
        self.b.meth1()

class B:
    def meth1(self):
        pass

b = B()   
a = A(b)
a.meth()

class A:
    def __init__(self):
        self.b = B()
    def meth(self):
        self.b.meth1()

class B:
    def meth1(self):
        pass

a = A()
a.meth()

为了使这更具体，假设
A
再次是
Car
，
B
是服务中心，
mycar.schedule\u service（）
需要调用
mycar.service\u center.get\u next\u appointment（）


作为后者的变体，每个
B
实例可以是
a
实例整体的一部分，由
a
实例自动构造。例如：

class A:
    def meth(self, b):
        b.meth1()

class B:
    def meth1(self):
        pass

a = A()
b = B()
a.meth(b)

class A:
    def __init__(self, b):
        self.b = b
    def meth(self):
        self.b.meth1()

class B:
    def meth1(self):
        pass

b = B()   
a = A(b)
a.meth()

class A:
    def __init__(self):
        self.b = B()
    def meth(self):
        self.b.meth1()

class B:
    def meth1(self):
        pass

a = A()
a.meth()

对于本例，再次假设
A
是
汽车
，而
B
是
发动机
。因此，
my\u car.drive（）
开始调用
my\u car.engine.start（）
。但是，与独立存在且被许多汽车使用的
服务中心不同，
引擎只由它所属的汽车使用，因此没有充分的理由单独创建引擎并将其传递给汽车（除非你正在为汽车工厂建模）。
B被用作静态类

class A:
    def meth(self):
        B.meth1()

class B:
    @staticmethod
    def meth1():
        pass

a = A()
a.meth()

B被用作静态类

class A:
    def meth(self):
        B.meth1()

class B:
    @staticmethod
    def meth1():
        pass

a = A()
a.meth()

你希望它的效果是什么？一般来说，
B
方法需要一个
B
实例才能工作，但如果您是从
a
调用的，则没有
B
实例。（如果
B.meth1
不需要实例，则将其改为classmethod。如果它甚至不需要该类，则将其从类中取出并将其变为函数。）如果您只希望能够为类a使用其中一个类B方法，则应为此使用。这就是你想要的吗？也许你想要
B.meth1
成为
staticmethod
？没有更多的细节，真的很难确定任何事情。@RyanSaxe:这可能是答案，但肯定不能保证，甚至可能不是最有可能的答案。（正如mgilson所说，在不知道他的设计的情况下，不可能确定。）这是非常正确的，这就是为什么我问他这是否是他想要的……但他问的方式似乎是他想要能够从类A中的类B调用方法，这就是继承。你所说的最有可能的可能性是什么意思？他问什么的可能性？你希望结果是什么？一般来说，
B
方法需要一个
B
实例才能工作，但如果您是从
a
调用的，则没有
B
实例。（如果
B.meth1
不需要实例，则将其改为classmethod