Trouver les méthodes d'un objet Python

vous pouvez utiliser la fonction intégrée dir() pour obtenir une liste de tous les attributs d'un module. Essayez ceci sur la ligne de commande pour voir comment il fonctionne.

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

aussi, vous pouvez utiliser la fonction hasattr(module_name, "attr_name") pour savoir si un module a un attribut spécifique.

Voir la Guide de Python introspection pour plus d'informations.

la méthode La plus simple est d'utiliser dir(objectname) . Il affiche toutes les méthodes disponibles pour cet objet. Truc génial.

pour vérifier s'il a une méthode particulière:

hasattr(object,"method")

en plus des réponses plus directes, je serais négligent si Je ne mentionnais pas iPython . Cliquez sur " tab " pour voir les méthodes disponibles, avec autocompletion.

et une fois que vous avez trouvé une méthode, essayez:

help(object.method) 

pour voir les pydocs, la signature de la méthode, etc.

Ahh... REPL .

je crois que ce que vous voulez est quelque chose comme ceci:

liste d'attributs d'un objet

À mon humble avis, la fonction intégrée dir() peut faire ce travail pour vous. Tiré de help(dir) sortie sur votre Shell Python:

dir(...)

dir([object]) -> list of strings

s'il est appelé sans argument, retournez les noms dans la portée actuelle.

sinon, retournez une liste alphabétique de noms comprenant (en partie) les attributs de l'objet donné, et des attributs accessibles à partir de celui-ci.

Si l'objet fournit une méthode nommée __dir__ , il sera utilisé; sinon la logique dir() par défaut est utilisée et renvoie:

• pour un objet module: les attributs du module.
• pour un objet de classe: ses attributs, et récursivement les attributs de ses bases.
• pour tout autre objet: ses attributs, les attributs de sa classe, et récursivement les attributs des classes de base de sa classe.

par exemple:

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

comme je vérifiais votre question, j'ai décidé de démontrer mon train de pensée, avec un meilleur formatage de la sortie 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("")

Espère que j'ai contribué :).

si vous voulez spécifiquement méthodes , vous devez utiliser inspecter.ismethod .

pour les noms de méthode:

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

pour les méthodes elles-mêmes:

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

parfois inspect.isroutine peut être utile aussi (pour les built-ins, extensions C, Cython sans la directive "binding" compilateur).

le problème avec toutes les méthodes indiquées ici est que vous ne pouvez pas être sûr qu'une méthode n'existe pas.

en Python vous pouvez intercepter le point appelant thru __getattr__ et __getattribute__ , ce qui permet de créer la méthode "à l'exécution"

Exemple:

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

si vous l'exécutez, vous pouvez appeler méthode non existante dans le dictionnaire d'objet...

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

Et c'est pourquoi vous utilisez le plus facile de demander pardon que la permission paradigmes en Python.

la façon la plus simple d'obtenir la liste des méthodes de n'importe quel objet est d'utiliser la commande help() .

%help(object)

il énumérera toutes les méthodes disponibles/importantes associées à cet objet.

par exemple:

help(str)

Ouvrir un shell bash (ctrl+alt+T sur Ubuntu). Lancez l'interpréteur de commande python3 dedans. Créer un objet pour observer les méthodes de. Il suffit d'ajouter un point après lui et appuyez deux fois "tab" et vous verrez quelque chose comme cela:

 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(           

on peut créer une fonction getAttrs qui retournera les noms de propriétés appelables d'un objet

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

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

Que serais de retour

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

il n'y a pas de moyen fiable pour lister toutes les méthodes de l'objet. dir(object) est habituellement utile, mais dans certains cas, il peut ne pas énumérer toutes les méthodes. Selon dir() documentation : " avec un argument, tentative de retourner une liste d'attributs valides pour cet objet."

Vérifier que la méthode existe peut être fait par callable(getattr(object, method)) comme déjà mentionné.

...y a-t-il au moins un moyen facile de vérifier si elle a une méthode particulière autre que la simple vérification si une erreur se produit lorsque la méthode est appelée

alors que " plus facile de demander pardon que la permission "est certainement la voie pythonique, ce que vous cherchez peut-être:

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

prendre une liste comme objet

obj = []

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

, Vous obtenez:

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

afin de rechercher une méthode spécifique dans un module entier

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