Python 方法重写，签名重要吗？

Question

可以说我有

class Super():
  def method1():
    pass

class Sub(Super):
  def method1(param1, param2, param3):
      stuff

这是正确的吗？对method1的调用总是会转到子类吗？我的计划是有 2 个子类，每个子类都使用不同的参数覆盖 method1

Answer 1

在Python中，方法只是附加到类的字典中的键值对。当您从基类派生类时，实质上是说方法名称将首先查看派生类字典，然后查看基类字典。为了“重写”一个方法，您只需在派生类中重新声明该方法即可。

那么，如果更改派生类中重写方法的签名会怎样？如果调用是在派生实例上，则一切正常，但如果在基实例上进行调用，则会收到错误，因为基类对同一方法名称使用不同的签名。

然而，在常见的情况下，您希望派生类方法具有附加参数，并且您希望方法调用在基类上也不会出现错误。这称为“里氏替换原则”（或LSP），它保证如果人从基地切换到派生实例或反之亦然，他们不必修改代码。要在 Python 中执行此操作，您需要使用以下技术设计基类：

class Base:
    # simply allow additional args in base class
    def hello(self, name, *args, **kwargs):
        print("Hello", name)

class Derived(Base):
      # derived class also has unused optional args so people can
      # derive new class from this class as well while maintaining LSP
      def hello(self, name, age=None, *args, **kwargs):
          super(Derived, self).hello(name, age, *args, **kwargs) 
          print('Your age is ', age)

b = Base()
d = Derived()

b.hello('Alice')        # works on base, without additional params
b.hello('Bob', age=24)  # works on base, with additional params
d.hello('Rick')         # works on derived, without additional params
d.hello('John', age=30) # works on derived, with additional params

上面将打印：

    Hello Alice
    Hello Bob
    Hello Rick
    Your age is  None
    Hello John
    Your age is  30

.
Play with this code

Answer 2

Python 将允许这样做，但如果 method1() 旨在从外部代码执行，那么您可能需要重新考虑这一点，因为它违反了 LSP 因此并不总是能正常工作。

Answer 3

如果可以使用默认参数，你可以这样做：

>>> class Super():
...   def method1(self):
...     print("Super")
...
>>> class Sub(Super):
...   def method1(self, param1="X"):
...     super(Sub, self).method1()
...     print("Sub" + param1)
...
>>> sup = Super()
>>> sub = Sub()
>>> sup.method1()
Super
>>> sub.method1()
Super
SubX

Answer 4

在Python中，所有类方法都是“虚拟的”（就C++而言）。因此，就您的代码而言，如果您想在超类中调用 method1() ，它必须是：

class Super():
    def method1(self):
        pass

class Sub(Super):
    def method1(self, param1, param2, param3):
       super(Sub, self).method1() # a proxy object, see http://docs.python.org/library/functions.html#super
       pass

并且方法签名确实很重要。你不能调用这样的方法：

sub = Sub()
sub.method1() 

Answer 5

它会起作用：

>>> class Foo(object):
...   def Bar(self):
...     print 'Foo'
...   def Baz(self):
...     self.Bar()
... 
>>> class Foo2(Foo):
...   def Bar(self):
...     print 'Foo2'
... 
>>> foo = Foo()
>>> foo.Baz()
Foo
>>> 
>>> foo2 = Foo2()
>>> foo2.Baz()
Foo2

但是，通常不建议这样做。看看 S.Lott 的回答：具有相同名称和不同参数的方法有代码味道。

Answer 6

签名重要吗？

不，它不会，但当重写的方法与基本方法不匹配时，PyCharm 会生成警告。
方法“Baz.method1()”的签名与类“Foo”中基方法的签名不匹配

您可以通过添加 typing.Optional 作为键入提示。如果所有参数均为 None，您还可以使用 locals() 调用基本方法。

from typing import Any, Optional
from inspect import signature


class Foo(object):
    def __init__(self):
        pass

    def method1(self):
        print('foo')


class Baz(Foo):
    def __init__(self):
        super(Foo, self).__init__()

    def method1(self, param1: Optional[str] = None, param2: Optional[Any] = None, param3: Optional[Any] = None):
        parameters, copy_of_locals = signature(self.method1).parameters, locals().copy()
        if not next((param for param in parameters if copy_of_locals[param] is not None), None):
            super().method1()
            return
        print('baz')

Output:

baz = Baz()
baz.method1()
>>> 'foo'
baz.method1(param1 = 'dcdb')
>>> 'baz'