Comment créer dynamiquement une fonction avec la même signature qu'une autre fonction?

Question

Je suis occupé à créer une métaclasse qui remplace une fonction de remplacement sur une classe par une nouvelle avec une implémentation correcte. La fonction d'origine pourrait utiliser n'importe quelle signature. Mon problème est que je n'arrive pas à comprendre comment créer une nouvelle fonction avec la même signature que l'ancienne. Comment ferais-je cela?

Mise à jour

Cela n'a rien à voir avec la question réelle qui est « Comment puis-je créer dynamiquement une fonction avec la même signature que une autre fonction? » mais j'ajoute ceci pour montrer pourquoi je ne peux pas utiliser de sous-classes. J'essaye d'implémenter quelque chose comme Scala Case Classes en Python. (Pas l'aspect pattern matching seulement les propriétés générées automatiquement, eq, méthodes de hachage et str.)

Je veux quelque chose comme ceci: Pour autant que je peux voir

>>> class MyCaseClass(): 
...  __metaclass__ = CaseMetaClass 
...  def __init__(self, a, b): 
...   pass 

>>> instance = MyCaseClass(1, 'x') 
>>> instance.a 
1 
>>> instance.b 
'x' 
>>> str(instance) 
MyCaseClass(1, 'x') 

, il n'y a aucun moyen que avec des sous-classes.

Answer 1

Je crois functools.wraps ne reproduit pas la signature d'appel d'origine. Cependant, decorator module Michele Simionato fait:

import decorator 

class FooType(type): 
    def __init__(cls,name,bases,clsdict): 
     @decorator.decorator   
     def modify_stub(func, *args,**kw): 
      return func(*args,**kw)+' + new' 
     setattr(cls,'stub',modify_stub(clsdict['stub'])) 
class Foo(object): 
    __metaclass__=FooType 
    def stub(self,a,b,c): 
     return 'original' 


foo=Foo() 
help(foo.stub) 
# Help on method stub in module __main__: 

# stub(self, a, b, c) method of __main__.Foo instance 

print(foo.stub(1,2,3)) 
# original + new 

Answer 2

Il est possible pour ce faire, en utilisant inspect.getargspecs. Il y a même un PEP in place pour le rendre plus facile. Mais ce n'est pas une bonne chose à faire. Pouvez-vous imaginer combien d'un cauchemar de débogage/maintenance ce serait d'avoir vos fonctions dynamiquement créé au moment de l'exécution - et pas seulement cela, mais fait par une métaclasse ?! Je ne comprends pas pourquoi vous devez remplacer le talon dynamiquement; ne pouvez-vous pas simplement changer le code lorsque vous voulez changer la fonction? Je veux dire, supposons que vous avez une classe

class Spam(object): 
    def ham(self, a, b): 
     return NotImplemented 

Puisque vous ne savez pas ce qu'il est censé faire, la métaclasse ne peut réellement mettre en œuvre toutes les fonctionnalités. Si vous saviez ce que ham devait faire, vous pouvez le faire dans ham ou l'une de ses classes parentes, au lieu de renvoyer NotImplemented.

Answer 3

utilisation functools.wraps

>>> from functools import wraps 
>>> def f(a,b): 
    return a+b 
>>> @wraps(f) 
def f2(*args): 
    print(args) 
    return f(*args) 
>>> f2(2,5) 
(2, 5) 
7