Trouver les méthodes dont dispose un objet Python

Question

Étant donné un objet Python de quelque nature que ce soit, existe-t-il un moyen simple d'obtenir la liste de toutes les méthodes dont dispose cet objet ?

Ou,

si cela n'est pas possible, existe-t-il au moins un moyen simple de vérifier s'il existe une méthode particulière autre que simplement vérifier si une erreur se produit lorsque la méthode est appelée ?

Answer 1

Il semble que vous puissiez utiliser ce code, en remplaçant « objet » par l'objet qui vous intéresse :

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

Je l'ai découvert à ce site.Espérons que cela devrait fournir plus de détails !

Answer 2

Vous pouvez utiliser le dir() fonction pour obtenir une liste de tous les attributs d’un module.Essayez ceci sur la ligne de commande pour voir comment cela fonctionne.

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

Vous pouvez également utiliser le hasattr(module_name, "attr_name") fonction pour savoir si un module possède un attribut spécifique.

Voir le Guide d'introspection Python pour plus d'informations.

Answer 3

La méthode la plus simple consiste à utiliser dir(objectname).Il affichera toutes les méthodes disponibles pour cet objet.Un truc sympa.

Answer 4

Pour vérifier s’il a une méthode particulière :

hasattr(object,"method")

Answer 5

Je crois que ce que tu veux, c'est quelque chose comme ça :

une liste d'attributs d'un objet

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

dir (...)

dir([object]) -> list of strings

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

Sinon, renvoie une liste alphabétique de noms comprenant (certains) les attributs de l'objet donné et les 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 les attributs récursivement 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']

---

Alors que je vérifiais votre problème, j'ai décidé de démontrer ma réflexion, 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("")

J'espère avoir contribué :).

Answer 6

En plus des réponses plus directes, je m'en voudrais de ne pas mentionner Python.Appuyez sur « onglet » pour voir les méthodes disponibles, avec saisie semi-automatique.

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.

Answer 7

Si vous voulez spécifiquement méthodes, Tu devrais utiliser inspecter.ismethod.

Pour les noms de méthodes :

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 également être utile (pour les extensions intégrées, C, Cython sans la directive du compilateur "binding").

Answer 8

Ouvrez le shell bash (ctrl+alt+T sur Ubuntu).Démarrez le shell python3 dedans.Créez un objet pour observer les méthodes.Ajoutez simplement un point après et appuyez deux fois sur "tabulation" et vous verrez quelque chose comme ça :

 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

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 via __getattr__ et __getattribute__, permettant de créer une méthode "au moment de 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 une méthode qui n'existe pas dans le dictionnaire d'objets...

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

Answer 10

Le moyen le plus simple d'obtenir la liste des méthodes d'un objet est d'utiliser help() commande.

%help(object)

Il répertoriera toutes les méthodes disponibles/importantes associées à cet objet.

Par exemple:

help(str)

Answer 11

On peut créer un getAttrs fonction qui renverra 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(' '))

Cela reviendrait

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

Il n'existe aucun moyen fiable de répertorier toutes les méthodes d'un objet. dir(object) est généralement utile, mais dans certains cas, il peut ne pas répertorier toutes les méthodes.Selon dir() Documentation: "Avec une dispute, tentative pour renvoyer une liste d'attributs valides pour cet objet."

Vérifier que la méthode existe peut être effectué en callable(getattr(object, method)) comme déjà mentionné là-bas.

Answer 13

... existe-t-il au moins un moyen simple de vérifier s'il existe une méthode particulière autre que simplement vérifier 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 manière Pythonique, ce que vous cherchez peut-être :

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

Answer 14

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

Answer 15

Afin de rechercher une méthode spécifique dans tout un module

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