Question

Quelle est la bonne façon de boucler sur les méthodes d'un objet Python et les appeler?

Compte tenu de l'objet:

class SomeTest():
  def something1(self):
    print "something 1"
  def something2(self):
    print "something 2"

Pas de solution correcte

Autres conseils

Vous pouvez utiliser le module inspecter pour obtenir les membres de la classe (ou par exemple):

>>> class C(object):
...     a = 'blah'
...     def b(self):
...             pass
... 
...
>>> c = C()
>>> inspect.getmembers(c, inspect.ismethod)
[('b', <bound method C.b of <__main__.C object at 0x100498250>>)]

GetMembers () retourne une liste de tuples, chaque tuple (nom, membre). Le second argument de GetMembers () est le prédicat, qui filtre la liste de retour (dans ce cas, le retour des objets seulement de la méthode)

Méthodes par rapport aux fonctions et d'autres types de appelables ...

(Pour répondre à la question dans les commentaires dans le poste inconnu.)

D'abord, il convient de noter que, en plus des méthodes définies par l'utilisateur, il existe des méthodes intégrées et une méthode intégrée est, comme le doc http://docs.python.org/reference/datamodel.html dit, "vraiment un déguisement différent d'une fonction intégrée"( qui est une enveloppe autour d'une fonction C).

En ce qui concerne les méthodes définies par l'utilisateur, comme la citation cité de Unknown dit:

  

Un objet de la méthode définie par l'utilisateur combine   une classe, une instance de classe (ou None)   et tout objet appelable (normalement un   fonction définie par l'utilisateur).

Mais cela ne signifie pas que « tout ce qui définit __call__ et est attaché à un objet est une méthode. » Une méthode est une appelable, mais un appelable est pas nécessairement une méthode. méthodes définies par l'utilisateur sont interfacées sur ce que dit la citation.

Espérons que cette sortie (de Python 2.5.2 que j'ai à portée de main) montrera la distinction:

IDLE 1.2.2      
>>> class A(object):
    x = 7


>>> A  # show the class object
<class '__main__.A'>
>>> a = A()
>>> a  # show the instance
<__main__.A object at 0x021AFBF0>
>>> def test_func(self):
    print self.x


>>> type(test_func)  # what type is it?
<type 'function'>
>>> dir(test_func)  # what does it have?
['__call__', '__class__', '__delattr__', '__dict__', '__doc__', '__get__',
 '__getattribute__', '__hash__', '__init__', '__module__', '__name__',
 '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__',
 '__str__', 'func_closure', 'func_code', 'func_defaults', 'func_dict',
 'func_doc', 'func_globals', 'func_name']
>>> # But now let's put test_func on the class...
>>> A.test = test_func
>>> type(A.test)  # What type does this show?
<type 'instancemethod'>
>>> dir(A.test)  # And what does it have?
['__call__', '__class__', '__cmp__', '__delattr__', '__doc__', '__get__',
 '__getattribute__', '__hash__', '__init__', '__new__', '__reduce__',
 '__reduce_ex__', '__repr__', '__setattr__', '__str__', 'im_class',
 'im_func', 'im_self']
>>> # See, we just got a wrapper, and the function is in 'im_func'...
>>> getattr(A.test, 'im_func')
<function test_func at 0x0219F4B0>
>>> # Now to show bound vs. unbound methods...
>>> getattr(a.test, 'im_self') # Accessing it via the instance
<__main__.A object at 0x021AFBF0>
>>> # The instance is itself 'im_self'
>>> a.test()
7
>>> getattr(A.test, 'im_self') # Accessing it via the class returns None...
>>> print getattr(A.test, 'im_self')
None
>>> # It's unbound when accessed that way, so there's no instance in there
>>> # Which is why the following fails...
>>> A.test()

Traceback (most recent call last):
  File "<pyshell#25>", line 1, in <module>
    A.test()
TypeError: unbound method test_func() must be called with A instance as
first argument (got nothing instead)
>>>

- édition pour ajouter la sortie supplémentaire suivante, qui concerne également ...

>>> class B(object):
    pass

>>> b = B()
>>> b.test = test_func  # Putting the function on the instance, not class
>>> type(b.test)
<type 'function'>
>>> 

J'ajoute habitude plus de sortie, mais vous pouvez aussi faire une classe un attribut d'une autre classe ou une instance, et, même si les classes sont appelables, vous n'obtenez une méthode. Les méthodes sont mises en œuvre en utilisant des descripteurs non données, donc chercher des descripteurs si vous voulez plus d'informations sur la façon dont ils travaillent.

Cet extrait de code appellera tout ce qu'il trouvera dans obj et stocker les résultats dans la cartographie, où la clé est le nom d'attribut - dict((k, v()) for (k, v) in obj.__dict__.iteritems() if k.startswith('something'))

Modifier

Daniel, vous avez tort.

http://docs.python.org/reference/datamodel.html

  

Méthodes définies par l'utilisateur

     

A défini par l'utilisateur méthode objet associe une classe, une instance de classe (ou   Aucun) et tout objet appelable (normalement une fonction définie par l'utilisateur).

Par conséquent, tout ce qui __call__ définit et est attachée à un objet est un procédé.

Réponse

La bonne façon de voir quels sont les éléments d'un objet a est d'utiliser la fonction dir ().

Il est évident que cet exemple ne fonctionne que pour les fonctions qui ne prennent pas d'arguments.

a=SomeTest()
for varname in dir(a):
    var = getattr(a, varname)
    if hasattr(var, "__call__"):
        var()
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top