¿Cómo obtengo la lista de métodos en una clase de Python?

Quiero iterar a través de los métodos en una clase, o manejar objetos de clase o instancia de manera diferente en función de los métodos presentes. ¿Cómo obtengo una lista de métodos de clase?

Ver también:

• ¿Cómo puedo enumerar los métodos en un módulo Python 2.5?
• Bucle sobre un método de objeto Python / IronPython
• Encontrar los métodos que tiene un objeto
• ¿Cómo miro dentro de un objeto Python?
• ¿Cómo realizo la introspección en un objeto en Python 2.x?
• ¿Cómo obtener una lista completa de los métodos y atributos del objeto?
• ¿Descubrir qué funciones están disponibles desde una instancia de clase en python?

Un ejemplo (enumerando los métodos de la optparse.OptionParserclase):

>>> from optparse import OptionParser
>>> import inspect
#python2
>>> inspect.getmembers(OptionParser, predicate=inspect.ismethod)
[([('__init__', <unbound method OptionParser.__init__>),
...
 ('add_option', <unbound method OptionParser.add_option>),
 ('add_option_group', <unbound method OptionParser.add_option_group>),
 ('add_options', <unbound method OptionParser.add_options>),
 ('check_values', <unbound method OptionParser.check_values>),
 ('destroy', <unbound method OptionParser.destroy>),
 ('disable_interspersed_args',
  <unbound method OptionParser.disable_interspersed_args>),
 ('enable_interspersed_args',
  <unbound method OptionParser.enable_interspersed_args>),
 ('error', <unbound method OptionParser.error>),
 ('exit', <unbound method OptionParser.exit>),
 ('expand_prog_name', <unbound method OptionParser.expand_prog_name>),
 ...
 ]
# python3
>>> inspect.getmembers(OptionParser, predicate=inspect.isfunction)
...

Observe que getmembersdevuelve una lista de 2 tuplas. El primer elemento es el nombre del miembro, el segundo elemento es el valor.

También puede pasar una instancia a getmembers:

>>> parser = OptionParser()
>>> inspect.getmembers(parser, predicate=inspect.ismethod)
...

Existe el dir(theobject)método para enumerar todos los campos y métodos de su objeto (como una tupla) y el módulo de inspección (como escritura de codeape) para enumerar los campos y métodos con su documento (en "" ").

Debido a que todo (incluso los campos) podrían llamarse en Python, no estoy seguro de que haya una función incorporada para enumerar solo los métodos. Es posible que desee probar si el objeto que atraviesa dires invocable o no.

Python 3.x responde sin bibliotecas externas

method_list = [func for func in dir(Foo) if callable(getattr(Foo, func))]

resultado excluido de dunder:

method_list = [func for func in dir(Foo) if callable(getattr(Foo, func)) and not func.startswith("__")]

Supongamos que desea conocer todos los métodos asociados con la clase de lista Solo escriba lo siguiente

 print (dir(list))

Lo anterior le dará todos los métodos de la clase de lista

Prueba la propiedad __dict__.

También puede importar el FunctionType de los tipos y probarlo con class.__dict__:

from types import FunctionType

class Foo:
    def bar(self): pass
    def baz(self): pass

def methods(cls):
    return [x for x, y in cls.__dict__.items() if type(y) == FunctionType]

methods(Foo)  # ['bar', 'baz']

Tenga en cuenta que debe considerar si desea que los métodos de las clases base que se heredan (pero no se reemplacen) se incluyan en el resultado. Las operaciones dir()y inspect.getmembers()incluyen métodos de clase base, pero el uso del __dict__atributo no.

Esto también funciona:

mymodule.py

def foo(x)
   return 'foo'
def bar()
   return 'bar'

En otro archivo

import inspect
import mymodule
method_list = [ func[0] for func in inspect.getmembers(mymodule, predicate=inspect.isroutine) if callable(getattr(mymodule, func[0])) ]

salida:

['foo', 'bar']

De los documentos de Python:

inspect.isroutine (objeto)

Return true if the object is a user-defined or built-in function or method.

def find_defining_class(obj, meth_name):
    for ty in type(obj).mro():
        if meth_name in ty.__dict__:
            return ty

Entonces

print find_defining_class(car, 'speedometer') 

Think Python página 210

Hay este enfoque:

[getattr(obj, m) for m in dir(obj) if not m.startswith('__')]

Cuando se trata de una instancia de clase , quizás sería mejor devolver una lista con las referencias de métodos en lugar de solo nombres¹. Si ese es tu objetivo, así como

1. Usando no import
2. Excluir métodos privados (p __init__. Ej. ) De la lista

Puede ser de utilidad. En pocas palabras, para una clase como

class Ghost:
    def boo(self, who):
        return f'Who you gonna call? {who}'

Podríamos verificar la recuperación de la instancia con

>>> g = Ghost()
>>> methods = [getattr(g, m) for m in dir(g) if not m.startswith('__')]
>>> print(methods)
[<bound method Ghost.boo of <__main__.Ghost object at ...>>]

Entonces puede llamarlo de inmediato:

>>> for method in methods:
...     print(method('GHOSTBUSTERS'))
...
Who you gonna call? GHOSTBUSTERS

¹ Un caso de uso:

Usé esto para pruebas unitarias . Tenía una clase en la que todos los métodos realizaban variaciones del mismo proceso, lo que conducía a largas pruebas, cada una a solo un toque de distancia de las demás. DRY era un sueño lejano.

Pensé que debería tener una sola prueba para todos los métodos, así que hice la iteración anterior.

Aunque me di cuenta de que en su lugar debería refactorizar el código en sí mismo para que sea compatible con DRY de todos modos ... esto aún puede servir a un alma puntiaguda al azar en el futuro.

Simplemente mantengo esto allí, porque las respuestas mejor calificadas no son claras .

Esta es una prueba simple con una clase no habitual basada en Enum.

# -*- coding: utf-8 -*-
import sys, inspect
from enum import Enum

class my_enum(Enum):
    """Enum base class my_enum"""
    M_ONE = -1
    ZERO = 0
    ONE = 1
    TWO = 2
    THREE = 3

    def is_natural(self):
            return (self.value > 0)
    def is_negative(self):
            return (self.value < 0)

def is_clean_name(name):
    return not name.startswith('_') and not name.endswith('_')
def clean_names(lst):
    return [ n for n in lst if is_clean_name(n) ]
def get_items(cls,lst):
    try:
            res = [ getattr(cls,n) for n in lst ]
    except Exception as e:
            res = (Exception, type(e), e)
            pass
    return res


print( sys.version )

dir_res = clean_names( dir(my_enum) )
inspect_res = clean_names( [ x[0] for x in inspect.getmembers(my_enum) ] )
dict_res = clean_names( my_enum.__dict__.keys() )

print( '## names ##' )
print( dir_res )
print( inspect_res )
print( dict_res )

print( '## items ##' )
print( get_items(my_enum,dir_res) )
print( get_items(my_enum,inspect_res) )
print( get_items(my_enum,dict_res) )

Y esto es resultados de salida.

3.7.7 (default, Mar 10 2020, 13:18:53) 
[GCC 9.2.1 20200306]
## names ##
['M_ONE', 'ONE', 'THREE', 'TWO', 'ZERO']
['M_ONE', 'ONE', 'THREE', 'TWO', 'ZERO', 'name', 'value']
['is_natural', 'is_negative', 'M_ONE', 'ZERO', 'ONE', 'TWO', 'THREE']
## items ##
[<my_enum.M_ONE: -1>, <my_enum.ONE: 1>, <my_enum.THREE: 3>, <my_enum.TWO: 2>, <my_enum.ZERO: 0>]
(<class 'Exception'>, <class 'AttributeError'>, AttributeError('name'))
[<function my_enum.is_natural at 0xb78a1fa4>, <function my_enum.is_negative at 0xb78ae854>, <my_enum.M_ONE: -1>, <my_enum.ZERO: 0>, <my_enum.ONE: 1>, <my_enum.TWO: 2>, <my_enum.THREE: 3>]

Entonces lo que tenemos:

• dir proporcionar datos no completos
• inspect.getmembers proporcionar datos no completos y proporcionar claves internas a las que no se puede acceder con getattr()
• __dict__.keys()proporcionar resultados completos y confiables

¿Por qué los votos son tan erróneos? ¿Y dónde me equivoco? ¿Y dónde equivocado otras personas cuyas respuestas tienen votos tan bajos?

methods = [(func, getattr(o, func)) for func in dir(o) if callable(getattr(o, func))]

da una lista idéntica a

methods = inspect.getmembers(o, predicate=inspect.ismethod)

hace.

Puede enumerar todos los métodos en una clase de Python utilizando el siguiente código

dir(className)

Esto devolverá una lista de todos los nombres de los métodos en la clase

Si su método es un método "regular" y no un método statimethod, classmethodetc.
Se me ocurrió un pequeño truco:

for k, v in your_class.__dict__.items():
    if "function" in str(v):
        print(k)

Esto puede extenderse a otro tipo de métodos cambiando la "función" en la ifcondición correspondiente.
Probado en python 2.7.

Sé que esta es una publicación antigua, pero acabo de escribir esta función y la dejaré aquí en caso de que alguien tropiece buscando una respuesta:

def classMethods(the_class,class_only=False,instance_only=False,exclude_internal=True):

    def acceptMethod(tup):
        #internal function that analyzes the tuples returned by getmembers tup[1] is the 
        #actual member object
        is_method = inspect.ismethod(tup[1])
        if is_method:
            bound_to = tup[1].im_self
            internal = tup[1].im_func.func_name[:2] == '__' and tup[1].im_func.func_name[-2:] == '__'
            if internal and exclude_internal:
                include = False
            else:
                include = (bound_to == the_class and not instance_only) or (bound_to == None and not class_only)
        else:
            include = False
        return include
    #uses filter to return results according to internal function and arguments
    return filter(acceptMethod,inspect.getmembers(the_class))

Esto es solo una observación. "codificar" parece ser un método para objetos de cadena

str_1 = 'a'
str_1.encode('utf-8')
>>> b'a'

Sin embargo, si se inspecciona str1 en busca de métodos, se devuelve una lista vacía

inspect.getmember(str_1, predicate=inspect.ismethod)
>>> []

Entonces, tal vez estoy equivocado, pero el problema parece no ser simple.

class CPerson:
    def __init__(self, age):
        self._age = age

    def run(self):
        pass

    @property
    def age(self): return self._age

    @staticmethod
    def my_static_method(): print("Life is short, you need Python")

    @classmethod
    def say(cls, msg): return msg


test_class = CPerson
# print(dir(test_class))  # list all the fields and methods of your object
print([(name, t) for name, t in test_class.__dict__.items() if type(t).__name__ == 'function' and not name.startswith('__')])
print([(name, t) for name, t in test_class.__dict__.items() if type(t).__name__ != 'function' and not name.startswith('__')])

salida

[('run', <function CPerson.run at 0x0000000002AD3268>)]
[('age', <property object at 0x0000000002368688>), ('my_static_method', <staticmethod object at 0x0000000002ACBD68>), ('say', <classmethod object at 0x0000000002ACF0B8>)]

Si desea enumerar solo los métodos de una clase python

import numpy as np
print(np.random.__all__)