programacion - Encontrar qué métodos tiene un objeto Python

programacion orientada a objetos python pdf

Question

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

O,

si esto no es posible, ¿hay al menos una manera fácil de verificar si tiene un método en particular que no sea simplemente verificar si ocurre un error cuando se llama al método?

Answer 1

... hay al menos una forma fácil de verificar si tiene un método particular que no sea simplemente verificar si se produce un error cuando se llama al método

Si bien " Más fácil pedir perdón que permiso " es sin duda la forma pitónica, lo que está buscando quizás:

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

Answer 2

Abra el shell bash (ctrl + alt + T en Ubuntu). Iniciar el shell de python3 en él. Crear objeto para observar métodos de. Solo agrega un punto después de él y presiona dos veces "pestaña" y verás algo como eso:

 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 times
 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 3

Además de las respuestas más directas, sería negligente si no mencionara iPython . Pulse ''pestaña'' para ver los métodos disponibles, con autocompletar.

Y una vez que hayas encontrado un método, prueba:

help(object.method) 

Para ver los pydocs, método de firma, etc.

Ahh ... REPL .

Answer 4

Creo que lo que quieres es algo como esto:

una lista de atributos de un objeto

En mi humilde opinión, la función incorporada dir() puede hacer este trabajo por usted. Tomado de la salida de help(dir) en tu Python Shell:

dir (...)

dir([object]) -> list of strings

Si se llama sin un argumento, devuelve los nombres en el alcance actual.

De lo contrario, devuelve una lista alfabética de nombres que comprenden (algunos de) los atributos del objeto dado, y de los atributos que se pueden alcanzar a partir de él.

Si el objeto proporciona un método llamado __dir__ , se utilizará; de lo contrario, se utiliza la lógica dir () predeterminada y devuelve:

• para un objeto de módulo: los atributos del módulo.
• para un objeto de clase: sus atributos, y recursivamente los atributos de sus bases.
• para cualquier otro objeto: sus atributos, los atributos de su clase y recursivamente los atributos de las clases base de su clase.

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'']

Cuando estaba revisando su problema, decidí demostrar mi línea 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 que haya contribuido :).

Answer 5

El método más simple es usar dir(objectname) . Mostrará todos los métodos disponibles para ese objeto. Buen truco.

Answer 6

El problema con todos los métodos indicados aquí es que NO puede asegurarse de que no exista un método.

En Python, puede interceptar el punto que llama a través de __getattr__ y __getattribute__ , lo que hace posible crear el 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 lo ejecuta, puede llamar al método no existente en el diccionario de objetos ...

>>> 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 usa los paradigmas de permiso más fáciles de pedir perdón que de Python.

Answer 7

La forma más sencilla de obtener una lista de métodos de cualquier objeto es usar el comando help() .

%help(object)

Enumera todos los métodos disponibles / importantes asociados con ese objeto.

Por ejemplo:

help(str)

Answer 8

No hay una forma confiable de enumerar todos los métodos de los objetos. dir(object) suele ser útil, pero en algunos casos puede que no incluya todos los métodos. De acuerdo con la documentación de dir() : "Con un argumento, intente devolver una lista de atributos válidos para ese objeto".

La comprobación de que el método existe se puede realizar mediante callable(getattr(object, method)) como ya se mencionó allí.

Answer 9

Para buscar un método específico en un módulo completo.

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

Answer 10

Para comprobar si tiene un método particular:

hasattr(object,"method")

Answer 11

Parece que puede usar este código, reemplazando ''objeto'' con el objeto que le interesa:

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

Lo descubrí en este sitio , ¡espero que eso proporcione más detalles!

Answer 12

Puede usar la función dir() incorporada para obtener una lista de todos los atributos que tiene un módulo. Intenta esto en la línea de comandos para ver cómo funciona.

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

Además, puede utilizar la función hasattr(module_name, "attr_name") para averiguar si un módulo tiene un atributo específico.

Consulte la guía de introspección de Python para obtener más información.

Answer 13

Si desea métodos específicos, debe utilizar inspect.ismethod .

Para nombres de métodos:

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

Para los propios métodos:

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 (para incorporaciones, extensiones C, Cython sin la directiva de compilación "vinculante").

Answer 14

Tomar una lista como un objeto

obj = []

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

Usted obtiene:

[''__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

Uno puede crear una función getAttrs que devolverá los nombres de propiedades que se pueden getAttrs un objeto

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

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

Eso regresaria

[''__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'']