Python 有类似 Java 的匿名内部类的东西吗？

Question

在 Java 中，您可以使用匿名内部类内联定义一个新类。 当您只需要重写类的单个方法时，这非常有用。

假设您要创建仅重写单个方法（例如 exit()）的 OptionParser 子类。 在 Java 中，您可以编写如下内容：

new OptionParser () {

    public void exit() {
        // body of the method
    }
};

这段代码创建一个扩展 OptionParser 的匿名类，并仅覆盖 exit() 方法。

Python中有类似的习惯用法吗？ 在这些情况下使用哪种习语？

Answer 1

您可以使用 type(name, bases, dict) 用于动态创建类的内置函数。 例如：

op = type("MyOptionParser", (OptionParser,object), {"foo": lambda self: "foo" })
op().foo()

由于 OptionParser 不是新式类，因此您必须在基类列表中显式包含 object。

Answer 2

您可以通过三种方式完成此操作：

1. 正确的子类（当然）
2. 是您使用对象作为参数调用的自定义方法
3. （您可能想要的）——向对象添加新方法（或替换现有方法）。

选项 3 的示例（经过编辑以删除“新”模块的使用——它已被弃用，我不知道）：

import types
class someclass(object):
    val = "Value"
    def some_method(self):
        print self.val

def some_method_upper(self):
    print self.val.upper()

obj = someclass()
obj.some_method()

obj.some_method = types.MethodType(some_method_upper, obj)
obj.some_method()

Answer 3

Java 使用匿名类主要是为了模仿闭包或简单的代码块。 由于在 Python 中您可以轻松地传递方法，因此不需要像匿名内部类那样笨重的构造：

def printStuff():
   print "hello"

def doit(what):
   what()

doit(printStuff) 

编辑：我知道这不是这种特殊情况下所需要的。 我刚刚描述了 Java 中匿名内部类最常见的问题的最常见的 Python 解决方案。

Answer 4

好吧，类是第一类对象，因此如果需要，您可以在方法中创建它们。 例如

from optparse import OptionParser
def make_custom_op(i):
  class MyOP(OptionParser):
    def exit(self):
      print 'custom exit called', i
  return MyOP

custom_op_class = make_custom_op(3)
custom_op = custom_op_class()

custom_op.exit()          # prints 'custom exit called 3'
dir(custom_op)            # shows all the regular attributes of an OptionParser

，但是，实际上，为什么不直接在正常级别定义类呢？ 如果您需要自定义它，请将自定义内容作为参数放入 __init__ 中。

（编辑：修复了代码中的键入错误）

Answer 5

Python 不直接支持这一点（匿名类），但由于其简洁的语法，这实际上并不是必需的：

class MyOptionParser(OptionParser):
    def exit(self, status=0, msg=None):
        # body of method

p = MyOptionParser()

唯一的缺点是您将 MyOptionParser 添加到您的命名空间中，但正如 John Fouhy 指出的那样，您可以将其隐藏在函数中，如果您将多次执行此操作。

Answer 6

Python 可能有更好的方法来解决您的问题。 如果您可以提供有关您想要做什么的更具体的细节，将会有所帮助。

例如，如果您需要更改代码中特定点调用的方法，您可以通过将函数作为参数传递来完成此操作（函数是 python 中的第一类对象，您可以将它们传递给函数等）。 您还可以创建匿名 lambda 函数（但它们仅限于单个表达式）。

另外，由于 python 非常动态，因此您可以在创建对象后更改对象的方法 object.method1 = Alternative_impl1，尽管它实际上有点复杂，请参阅 gnud 的答案

Answer 7

在 python 中，您有使用 lambda 语句声明的匿名函数。 我不太喜欢它们——它们的可读性较差，而且功能有限。

然而，你所讨论的可能是用完全不同的方法在 python 中实现的：

class a(object):
  def meth_a(self):
    print "a"

def meth_b(obj):
  print "b"

b = a()
b.__class__.meth_a = meth_b

Answer 8

您始终可以通过变量隐藏类：

 class var(...):
     pass
 var = var()

而不是

 var = new ...() {};

Answer 9

这就是你在 Python 3.7 中要做的事情

#!/usr/bin/env python3
class ExmapleClass:
    def exit(self):
        print('this should NOT print since we are going to override')

ExmapleClass= type('', (ExmapleClass,), {'exit': lambda self: print('you should see this printed only')})()
ExmapleClass.exit()

Answer 10

我在 python3 中通常使用内部类执行此操作，

class SomeSerializer():
    class __Paginator(Paginator):
        page_size = 10

    # defining it for e.g. Rest:
    pagination_class = __Paginator

    # you could also be accessing it to e.g. create an instance via method:
    def get_paginator(self):
        return self.__Paginator()

因为我使用了双下划线，这将“重整”与内部类的想法混合在一起，从外部您仍然可以使用 SomeSerializer._SomeSerializer__Paginator 访问内部类，并且子类，但 SomeSerializer.__Paginator 将不起作用，如果您希望它更加“匿名”，这可能是也可能不是您的愿望。

不过，如果您不需要重整，我建议使用带有单个下划线的“私有”表示法。

就我而言，我需要的是一个快速子类来设置一些类属性，然后将其分配给我的 RestSerializer 类的类属性，因此双下划线表示“根本不再使用它”并且可能会更改为没有下划线，如果我开始在其他地方重用它。

Answer 11

反常的是，您可以使用一次性名称 _ 作为派生类名称：

class _(OptionParser):

    def exit(self):
        pass  # your override impl

Answer 12

这是执行 Maciej 的方法的更奇特的方式。
我定义了以下装饰器：

def newinstance(*args, **kwargs):
    def decorator(cls):
        return cls(*args, **kwargs)
    return decorator

以下代码大致相同（也适用于参数！）

// java

MyClass obj = new MyClass(arg) {
    public void method() {
        // body of the method
    }
};

# python

@newinstance(arg)
class obj(MyClass):
    def method(self):
        pass # body of the method

如果您想定义“内部”类实例，则可以在类/方法/函数中使用此代码。