¿Tiene Python algo así como clases internas anónimas de Java?

Question

En Java puede definir una nueva clase en línea utilizando clases internas anónimas. Esto es útil cuando necesita reescribir solo un método de la clase.

Supongamos que desea crear una subclase de OptionParser que anule solo un único método (por ejemplo, exit()). En Java se puede escribir algo como esto:

new OptionParser() { 

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

Esta pieza de código crea una clase anónima que se extiende OptionParser y anular sólo el método exit().

¿Hay un modismo similar en Python? ¿Qué idioma se usa en estas circunstancias?

Answer 1

Puede usar la función integrada type(name, bases, dict) para crear clases sobre la marcha. Por ejemplo:

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

Desde OptionParser no es una clase de nuevo estilo, que tiene que incluir explícitamente object en la lista de clases base.

Answer 2

Java utiliza clases anónimas principalmente para imitar cierres o simplemente bloques de código. Dado que en Python se puede pasar fácilmente por métodos que no hay necesidad de una construcción tan torpe como clases internas anónimas:

def printStuff(): 
    print "hello" 

def doit(what): 
    what() 

doit(printStuff) 

Editar: Soy consciente de que esto no es lo que se necesita en este caso especial. Acabo de describir la solución python más común para el problema más comúnmente por clases internas anónimas en Java.

Answer 3

En python tiene funciones anónimas, declaradas mediante la instrucción lambda. No me gustan mucho, no son tan legibles y tienen una funcionalidad limitada.

Sin embargo, lo que está hablando puede ser implementado en Python con un enfoque completamente diferente:

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

def meth_b(obj): 
    print "b" 

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

Answer 4

Python probablemente tiene mejores maneras de resolver su problema. Si pudiera proporcionar detalles más específicos de lo que quiere hacer, sería útil.

Por ejemplo, si necesita cambiar el método que se llama en un punto específico del código, puede hacerlo pasando la función como un parámetro (las funciones son objetos de primera clase en python, puede pasarlos a funciones, etc.) También puede crear funciones anónimas lambda (pero están restringidas a una sola expresión).

Además, dado que el pitón es muy dinámico, puede cambiar los métodos de un objeto después de que se ha creado object.method1 = alternative_impl1, aunque en realidad es un poco más complicado, ve gnud's answer

Answer 5

Esto se puede hacer de tres maneras:

1. subclase apropiada (por supuesto)
2. un método personalizado que se invoca con el objeto como un argumento
3. (lo que es probable que desee) - la adición de un nuevo método para un objeto (o r reemplazando a uno existente).

Ejemplo de la opción 3 (editado para eliminar el uso de la "nueva" módulo - Está obsoleto, yo no sabía):

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 6

Bueno, las clases son objetos de primera clase, para que pueda crear ellos en métodos si quieres. p.ej.

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 

Pero, realmente, ¿por qué no simplemente definir la clase en el nivel normal? Si necesita personalizarlo, ponga la personalización como argumentos en __init__.

(editar: fija los errores de escritura en código)

Answer 7

Python no soporta este (clases anónimas) directamente, sino a causa de su sintaxis concisa que no es realmente necesario:

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

p = MyOptionParser() 

El único Lo malo es que agregas MyOptionParser a tu espacio de nombres, pero como señaló John Fouhy, puedes ocultarlo dentro de una función si vas a hacerlo varias veces.

Answer 8

siempre se puede ocultar clase por variables:

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

en lugar de

var = new ...() {}; 

Answer 9

#!/usr/bin/env python 
import os;os.system("""ruby << 'GOZER' 
anonymous_class = Class.new do 
    def hi(name) 
    puts "Hello: #{name}." 
    end 

    def too_late(message) 
    exit 1 
    end 
end 

anonymous_ghoul = anonymous_class.new 
anonymous_ghoul.hi("Egon Spengler") 
anonymous_ghoul.too_late <<-quote 

There's something very import I forgot to tell you. 

Don't cross the streams. 

It would be bad. 

quote 
GOZER""")