Есть ли в Python что-то вроде анонимных внутренних классов Java?

Java использует анонимные классы в основном для имитации замыканий или просто блоков кода. Поскольку в Python вы можете легко передавать методы, нет необходимости в такой неуклюжей конструкции, как анонимные внутренние классы:

def printStuff():
   print "hello"

def doit(what):
   what()

doit(printStuff) 

Обновлено: я знаю, что это не то, что нужно в этом особом случае. Я только что описал наиболее распространенное решение проблемы с помощью Python, которое чаще всего используется анонимными внутренними классами в Java.

В python у вас есть анонимные функции, объявленные с помощью лямбда-выражения. Мне они не очень нравятся - они не очень читабельны и имеют ограниченный функционал.

Однако то, о чем вы говорите, может быть реализовано на python с совершенно другим подходом:

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

def meth_b(obj):
  print "b"

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

У Python, вероятно, есть лучшие способы решить вашу проблему. Если бы вы могли предоставить более конкретную информацию о том, что вы хотите сделать, это поможет.

Например, если вам нужно изменить метод, вызываемый в определенной точке кода, вы можете сделать это, передав функцию в качестве параметра (функции являются объектами первого класса в python, вы можете передавать их функциям и т. д.). Вы также можете создавать анонимные функции lambda (но они ограничены одним выражением).

Кроме того, поскольку python очень динамичен, вы можете изменять методы объекта после его создания object.method1 = alternative_impl1, хотя на самом деле это немного сложнее, см. ответ gnud

Вы можете сделать это тремя способами:

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()

Ну, классы - это объекты первого класса, поэтому вы можете создавать их в методах, если хотите. например

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__.

(править: исправлены опечатки в коде)

Python не поддерживает это напрямую (анонимные классы), но из-за его краткого синтаксиса в этом нет необходимости:

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

p = MyOptionParser()

Единственным недостатком является то, что вы добавляете MyOptionParser в свое пространство имен, но, как указал Джон Фухи, вы можете скрыть это внутри функции, если собираетесь делать это несколько раз.

Вы можете использовать встроенную функцию type(name, bases, dict) для создания классов на лету. Например:

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

Поскольку OptionParser не является классом нового стиля, вы должны явно включить object в список базовых классов.

Вы всегда можете скрыть класс по переменным:

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

вместо

 var = new ...() {};

Это то, что вы бы сделали в 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()

Я делаю это в 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, поэтому двойное подчеркивание означало бы «больше не использовать его» и могло бы измениться на без подчеркивания, если я начну использовать его где-нибудь еще.

Будучи извращенцем, вы можете использовать одноразовое имя _ для имени производного класса:

class _(OptionParser):

    def exit(self):
        pass  # your override impl