Encontrar lo que los métodos de un objeto de Python tiene

Question

Dado un objeto de Python de cualquier tipo, hay una manera fácil de obtener la lista de todos los métodos que este objeto tiene?

O,

si esto no es posible, hay al menos una manera fácil de comprobar si se dispone de un método en particular que no sea simplemente la comprobación de si se produce un error cuando se llama al método?

Answer 1

Parece que usted puede utilizar este código, en sustitución de 'objeto' con el objeto de que usted está interesado en:

object_methods = [method_name for method_name in dir(object)
                  if callable(getattr(object, method_name))]

Lo descubrí en este sitio.Es de esperar, que debería proporcionar más detalles!

Answer 2

Usted puede utilizar el construido en dir() función para obtener una lista de todos los atributos de un módulo.Intente esto en la línea de comandos para ver cómo funciona.

>>> import moduleName
>>> dir(moduleName)

También, usted puede utilizar el hasattr(module_name, "attr_name") función para saber si un módulo tiene un atributo específico.

Ver el Guía de Python para la introspección para obtener más información.

Answer 3

El método más simple es utilizar dir(objectname).Se mostrarán todos los métodos disponibles para ese objeto.Truco fresco.

Answer 4

Para comprobar si tiene un método particular:

hasattr(object,"method")

Answer 5

Yo creo que lo que quieres es algo como esto:

una lista de los atributos de un objeto

En mi humilde opinión, la función integrada dir() puede hacer este trabajo para usted.Tomado de help(dir) salida en el interprete de Python:

dir(...)

dir([object]) -> list of strings

Si se llama sin argumentos, devolver los nombres en el ámbito actual.

Otra cosa, devuelva una lista en orden alfabético de los nombres que comprende (algunos de) los atributos de un objeto dado, y de los atributos accesibles desde la misma.

Si el objeto proporciona un método denominado __dir__, será utilizado;de lo contrario, el valor predeterminado dir() se usa una lógica y devuelve:

• para un objeto de módulo:el módulo de atributos.
• para un objeto de la clase:sus atributos, y de forma recursiva los atributos de sus bases.
• para cualquier otro objeto:sus atributos, su clase, sus atributos, y de forma recursiva los atributos de su clase de la base de clases.

Por ejemplo:

$ python
Python 2.7.6 (default, Jun 22 2015, 17:58:13) 
[GCC 4.8.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.

>>> a = "I am a string"
>>>
>>> type(a)
<class 'str'>
>>>
>>> dir(a)
['__add__', '__class__', '__contains__', '__delattr__', '__doc__',
'__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__',
'__getnewargs__', '__getslice__', '__gt__', '__hash__', '__init__',
'__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__',
'__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__',
'__setattr__', '__sizeof__', '__str__', '__subclasshook__',
'_formatter_field_name_split', '_formatter_parser', 'capitalize',
'center', 'count', 'decode', 'encode', 'endswith', 'expandtabs', 'find',
'format', 'index', 'isalnum', 'isalpha', 'isdigit', 'islower', 'isspace',
'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'partition',
'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip',
'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title',
'translate', 'upper', 'zfill']

---

Como estaba revisando el problema, me he decidido a demostrar que mi tren de pensamiento, con un mejor formato de la salida de dir().

dir_attributes.py (Python 2.7.6)

#!/usr/bin/python
""" Demonstrates the usage of dir(), with better output. """

__author__ = "ivanleoncz"

obj = "I am a string."
count = 0

print "\nObject Data: %s" % obj
print "Object Type: %s\n" % type(obj)

for method in dir(obj):
    # the comma at the end of the print, makes it printing 
    # in the same line, 4 times (count)
    print "| {0: <20}".format(method),
    count += 1
    if count == 4:
        count = 0
        print

dir_attributes.py (Python 3.4.3)

#!/usr/bin/python3
""" Demonstrates the usage of dir(), with better output. """

__author__ = "ivanleoncz"

obj = "I am a string."
count = 0

print("\nObject Data: ", obj)
print("Object Type: ", type(obj),"\n")

for method in dir(obj):
    # the end=" " at the end of the print statement, 
    # makes it printing in the same line, 4 times (count)
    print("|    {:20}".format(method), end=" ")
    count += 1
    if count == 4:
        count = 0
        print("")

Espero haber contribuido :).

Answer 6

En la parte superior de la más respuestas directas, sería negligente de mi parte no mencionar iPython.Hit 'ficha' a ver los métodos disponibles, con la función de autocompletar.

Y una vez que haya encontrado un método, intenta lo siguiente:

help(object.method) 

para ver el pydocs, método de firma, etc.

Ahh... REPL.

Answer 7

Si usted desea específicamente métodos, usted debe utilizar inspeccionar.ismethod.

Para los nombres de método:

import inspect
method_names = [attr for attr in dir(self) if inspect.ismethod(getattr(self, attr))]

Para los métodos de sí mismos:

import inspect
methods = [member for member in [getattr(self, attr) for attr in dir(self)] if inspect.ismethod(member)]

A veces inspect.isroutine puede ser útil también (construido-ins, extensiones en C, Cython sin el "vinculante" de la directiva del compilador).

Answer 8

Abrir la shell de bash (ctrl+alt+T en Ubuntu).Inicio python3 shell en ella.Crear el objeto de observar los métodos de.Sólo añadir un punto después de esto, y presione dos veces el botón "tab" y verás algo como esto:

 user@note:~$ python3
 Python 3.4.3 (default, Nov 17 2016, 01:08:31) 
 [GCC 4.8.4] on linux
 Type "help", "copyright", "credits" or "license" for more information.
 >>> import readline
 >>> readline.parse_and_bind("tab: complete")
 >>> s = "Any object. Now it's a string"
 >>> s. # here tab should be pressed twice
 s.__add__(           s.__rmod__(          s.istitle(
 s.__class__(         s.__rmul__(          s.isupper(
 s.__contains__(      s.__setattr__(       s.join(
 s.__delattr__(       s.__sizeof__(        s.ljust(
 s.__dir__(           s.__str__(           s.lower(
 s.__doc__            s.__subclasshook__(  s.lstrip(
 s.__eq__(            s.capitalize(        s.maketrans(
 s.__format__(        s.casefold(          s.partition(
 s.__ge__(            s.center(            s.replace(
 s.__getattribute__(  s.count(             s.rfind(
 s.__getitem__(       s.encode(            s.rindex(
 s.__getnewargs__(    s.endswith(          s.rjust(
 s.__gt__(            s.expandtabs(        s.rpartition(
 s.__hash__(          s.find(              s.rsplit(
 s.__init__(          s.format(            s.rstrip(
 s.__iter__(          s.format_map(        s.split(
 s.__le__(            s.index(             s.splitlines(
 s.__len__(           s.isalnum(           s.startswith(
 s.__lt__(            s.isalpha(           s.strip(
 s.__mod__(           s.isdecimal(         s.swapcase(
 s.__mul__(           s.isdigit(           s.title(
 s.__ne__(            s.isidentifier(      s.translate(
 s.__new__(           s.islower(           s.upper(
 s.__reduce__(        s.isnumeric(         s.zfill(
 s.__reduce_ex__(     s.isprintable(       
 s.__repr__(          s.isspace(           

Answer 9

El problema con todos los métodos que se indican aquí es que usted NO PUEDE estar seguro de que un método no existe.

En Python se puede interceptar el punto de llamar a través de __getattr__ y __getattribute__, haciendo posible la creación de método "en tiempo de ejecución"

Ejemplo:

class MoreMethod(object):
    def some_method(self, x):
        return x
    def __getattr__(self, *args):
        return lambda x: x*2

Si se ejecuta, usted puede llamar a método que no existe en el diccionario de objeto...

>>> o = MoreMethod()
>>> o.some_method(5)
5
>>> dir(o)
['__class__', '__delattr__', '__dict__', '__doc__', '__format__', '__getattr__', '__getattribute__', '__hash__', '__init__', '__module__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'some_method']
>>> o.i_dont_care_of_the_name(5)
10

Y es por eso que el uso de la Más fácil pedir perdón que permiso paradigmas en Python.

Answer 10

La forma más sencilla de obtener la lista de métodos de un objeto es el uso de help() comando.

%help(object)

Aparecerá una lista de todos los disponibles/métodos importantes asociados con ese objeto.

Por ejemplo:

help(str)

Answer 11

Uno puede crear una getAttrs función que devuelve un objeto del que se puede llamar de nombres de propiedad

def getAttrs(object):
  return filter(lambda m: callable(getattr(object, m)), dir(object))

print getAttrs('Foo bar'.split(' '))

Que había que volver

['__add__', '__class__', '__contains__', '__delattr__', '__delitem__',
 '__delslice__', '__eq__', '__format__', '__ge__', '__getattribute__', 
 '__getitem__', '__getslice__', '__gt__', '__iadd__', '__imul__', '__init__', 
 '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', 
 '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', 
 '__setattr__', '__setitem__', '__setslice__', '__sizeof__', '__str__', 
 '__subclasshook__', 'append', 'count', 'extend', 'index', 'insert', 'pop', 
 'remove', 'reverse', 'sort']

Answer 12

No existe una manera fiable a la lista de todos los métodos del objeto. dir(object) generalmente es útil, pero en algunos casos puede que no la lista de todos los métodos.De acuerdo a dir() documentación: "Con un argumento, intento para devolver una lista de los atributos válidos para ese objeto."

La comprobación de que existe un método puede ser realizado por callable(getattr(object, method)) como ya se ha mencionado allí.

Answer 13

...hay al menos una manera fácil de comprobar si se dispone de un método en particular que no sea simplemente la comprobación de si se produce un error cuando se llama al método

Mientras que "Más fácil pedir perdón que permiso"es sin duda el Python manera, lo que usted está buscando tal vez:

d={'foo':'bar', 'spam':'eggs'}
if 'get' in dir(d):
    d.get('foo')
# OUT: 'bar'

Answer 14

Toma una lista como un objeto

obj = []

list(filter(lambda x:callable(getattr(obj,x)),obj.__dir__()))

Usted obtener:

['__add__',
 '__class__',
 '__contains__',
 '__delattr__',
 '__delitem__',
 '__dir__',
 '__eq__',
 '__format__',
 '__ge__',
 '__getattribute__',
 '__getitem__',
 '__gt__',
 '__iadd__',
 '__imul__',
 '__init__',
 '__init_subclass__',
 '__iter__',
 '__le__',
 '__len__',
 '__lt__',
 '__mul__',
 '__ne__',
 '__new__',
 '__reduce__',
 '__reduce_ex__',
 '__repr__',
 '__reversed__',
 '__rmul__',
 '__setattr__',
 '__setitem__',
 '__sizeof__',
 '__str__',
 '__subclasshook__',
 'append',
 'clear',
 'copy',
 'count',
 'extend',
 'index',
 'insert',
 'pop',
 'remove',
 'reverse',
 'sort']

Answer 15

Con el fin de buscar un método específico en un módulo entero

for method in dir(module) :
  if "keyword_of_methode" in method :
   print(method, end="\n")