Comment puis-je passer d'une méthode en tant que paramètre dans Python

Est-il possible de passer d'une méthode en tant que paramètre à une méthode?

self.method2(self.method1)

def method1(self):
    return 'hello world'

def method2(self, methodToRun):
    result = methodToRun.call()
    return result

InformationsquelleAutor Dan | 2009-04-01

parameter-passing python

211

Oui, il est, il suffit d'utiliser le nom de la méthode, comme vous l'avez écrit. Méthodes/fonctions sont des objets en Python, tout comme toute autre chose, et vous pouvez les passer autour de la façon dont vous faites des variables. En fait, vous pouvez penser à une méthode (ou fonction) comme une variable dont la valeur est le callable code objet.

Pour info, il n'y a pas de call méthode, je pense qu'il est appelé __call__, mais vous n'avez pas à appeler explicitement:
```
def method1():
    return 'hello world'

def method2(methodToRun):
    result = methodToRun()
    return result

method2(method1)
```
Si vous voulais method1 être appelée avec des arguments, les choses deviennent un peu plus compliqué. method2 doit être écrit avec un peu d'informations sur la façon de passer des arguments à method1, et il a besoin d'obtenir des valeurs pour les arguments de quelque part. Par exemple, si method1 est censé prendre un seul argument:
```
def method1(spam):
    return 'hello ' + str(spam)
```
ensuite, vous pouvez écrire method2 de l'appeler avec un argument qui est transmis:
```
def method2(methodToRun, spam_value):
    return methodToRun(spam_value)
```
ou avec un argument qu'il calcule lui-même:
```
def method2(methodToRun):
    spam_value = compute_some_value()
    return methodToRun(spam_value)
```
Vous pouvez étendre cela à d'autres combinaisons de valeurs passées et des valeurs calculées, comme
```
def method1(spam, ham):
    return 'hello ' + str(spam) + ' and ' + str(ham)

def method2(methodToRun, ham_value):
    spam_value = compute_some_value()
    return methodToRun(spam_value, ham_value)
```
ou même avec le mot-clé arguments
```
def method2(methodToRun, ham_value):
    spam_value = compute_some_value()
    return methodToRun(spam_value, ham=ham_value)
```
Si vous ne savez pas, lors de l'écriture de method2, quels arguments methodToRun va prendre, vous pouvez également utiliser l'argument du déballage à l'appeler de façon générique:
```
def method1(spam, ham):
    return 'hello ' + str(spam) + ' and ' + str(ham)

def method2(methodToRun, positional_arguments, keyword_arguments):
    return methodToRun(*positional_arguments, **keyword_arguments)

method2(method1, ['spam'], {'ham': 'ham'})
```
Dans ce cas positional_arguments doit être une liste ou un tuple ou similaire, et keyword_arguments est un dict ou similaire. Dans method2 vous pouvez modifier positional_arguments et keyword_arguments (par exemple, d'ajouter ou de supprimer certains arguments ou de modifier les valeurs) avant d'appeler method1.
- Z comment puis-je passer des arguments à la méthode 1?
- l'esprit de partage un lien ou poster une réponse à votre question? Comment passer des arguments à la méthode 1
- J'imagine une façon serait de passer les arguments que vous voulez utiliser avec method1 à method2, ainsi def method1(arg1, arg2) et def method2(method, arg1, arg2)
- J'ai édité la réponse à parler de comment vous pouvez passer des arguments.
- La question est à propos des méthodes de l'objet. Dans tous les exemples, vous utilisez les fonctions de la place. Donc, ce n'est pas la réponse à la question posée.
- Non, votre sens de l'observation ne justifie pas la conclusion que ce n'est pas de répondre à la question. Si vous voulez prétendre que le cœur de ma réponse, c'est à dire "des Méthodes/fonctions sont des objets en Python, tout comme toute autre chose, et vous pouvez les passer autour de la façon dont vous faites des variables", ne répond pas à la question posée, vous pourriez soulever ce point.
- La réponse n'est pas de montrer comment passer des méthodes de l'objet par opposition à des fonctions classiques -- quelque chose qui n'est pas totalement évident,
- Ah, j'ai bien fait de ne considérer que évident, ou au moins d'une extension de la façon dont vous passez fonctions autour, donc je ne pense pas que de montrer que. J'aurais trouvé l'initiale de commentaires plus utile si elle dit que la réponse pourrait être améliorée par l'ajout d'un exemple de comment passer d'une méthode (par opposition à une fonction), plutôt que de réclamer ce n'est pas une réponse à tout.
InformationsquelleAutor David Z
32

Oui c'est possible. Il vous suffit d'appeler:
```
class Foo(object):
    def method1(self):
        pass
    def method2(self, method):
        return method()

foo = Foo()
foo.method2(foo.method1)
```
- que faire si il n'y a pas d'instance foo?
- Vous n'avez tout simplement pas besoin de foo, par exemple: def method1(): pass def method2(method) return method() method2(method1)
InformationsquelleAutor

Ici est votre exemple de ré-écrit pour montrer un stand-alone de travail exemple:

class Test:
    def method1(self):
        return 'hello world'

    def method2(self, methodToRun):
        result = methodToRun()
        return result

    def method3(self):
        return self.method2(self.method1)

test = Test()

print test.method3()

InformationsquelleAutor Trent

5

Oui; fonctions (méthodes) sont des objets de première classe en Python. Les ouvrages suivants:
```
def foo(f):
    print "Running parameter f()."
    f()

def bar():
    print "In bar()."

foo(bar)
```
Sorties:
```
Running parameter f().
In bar().
```
Ces sortes de questions sont triviales pour répondre à l'aide de l'interpréteur Python ou, pour plus de fonctionnalités, le IPython shell.

InformationsquelleAutor lt_kije
2

Méthodes sont des objets comme les autres. De sorte que vous pouvez les transmettre autour de, de les stocker dans des listes et des dicts, faire ce que vous voulez avec eux. La chose de spécial à leur sujet est qu'ils sont remboursables les objets de sorte que vous pouvez invoquer __call__ sur eux. __call__ est appelée automatiquement lorsque vous appelez la méthode avec ou sans arguments donc, vous avez juste besoin d'écrire methodToRun().

InformationsquelleAutor Vasil
2

Si vous souhaitez passer d'une méthode d'une classe comme un argument, mais n'ont pas encore l'objet sur lequel vous allez d'appeler, vous pouvez simplement passer de l'objet une fois que vous avez comme premier argument (c'est à dire le "soi" est un argument).
```
class FooBar:

    def __init__(self, prefix):
        self.prefix = prefix

    def foo(self, name):
        print "%s %s" % (self.prefix, name)


def bar(some_method):
    foobar = FooBar("Hello")
    some_method(foobar, "World")

bar(FooBar.foo)
```
Cela print "Hello World"

InformationsquelleAutor FrontSide
1

Beaucoup de bonnes réponses, mais étrange que personne n'a mentionné l'aide d'un lambda fonction.

Donc, si vous n'avez pas d'arguments, les choses deviennent assez trivial:
```
def method1():
    return 'hello world'

def method2(methodToRun):
    result = methodToRun()
    return result

method2(method1)
```
Mais dire que vous en avez un (ou plusieurs) des arguments en method1:
```
def method1(spam):
    return 'hello ' + str(spam)

def method2(methodToRun):
    result = methodToRun()
    return result
```
Alors vous pouvez simplement appeler method2 comme method2(lambda: method1('world')).
```
method2(lambda: method1('world'))
>>> hello world
method2(lambda: method1('reader'))
>>> hello reader
```
Je trouve cela beaucoup plus propre que les autres réponses mentionnées ici.

InformationsquelleAutor Scrotch

Vous devez vous connecter pour publier un commentaire.