Constatação de que os métodos de um objeto Python tem
https://stackoverflow.com/questions/34439
-
09-06-2019 - |
italiano
english
français
española
中国
日本の
العربية
Deutsch
한국어
Português
RussianPergunta
Dado um Python objeto de qualquer tipo, há uma maneira fácil de obter a lista de todos os métodos que este objeto tem?
Ou,
se isso não for possível, existe pelo menos uma maneira fácil de verificar se ele tem um método diferente de simplesmente verificar se um erro ocorre quando o método é chamado?
Solução
Parece que você pode usar este código, a substituição de "objeto", com o objeto que você está interessado em:
object_methods = [method_name for method_name in dir(object)
if callable(getattr(object, method_name))]
Descobri-o no este site.Espero, que deve fornecer mais alguns detalhes!
Outras dicas
Você pode usar o construída em dir() função para obter uma lista de todos os atributos de um módulo.Tente isso no linha de comando para ver como ele funciona.
>>> import moduleName
>>> dir(moduleName)
Além disso, você pode usar o hasattr(module_name, "attr_name") função para saber se um módulo tem um atributo específico.
Ver o Guia para Python introspecção para obter mais informações.
O método mais simples é usar dir(objectname).Ele irá exibir todos os métodos disponíveis para esse objeto.Legal o truque.
Para verificar se ele tem um método específico:
hasattr(object,"method")
Eu acredito que o que você deseja é algo como isto:
uma lista de atributos de um objeto
Na minha humilde opinião, o built-in função de dir() pode fazer este trabalho para você.Tomadas de help(dir) saída do Python Shell:
dir(...)
dir([object]) -> list of stringsSe chamado sem argumentos, retornar os nomes no escopo atual.
Outra coisa, retornar uma lista em ordem alfabética de nomes composto de (alguns dos) os atributos de um determinado objeto, e de atributos acessível a partir do mesmo.
Se o objeto fornece um método chamado
__dir__, ele será usado;caso contrário, o padrão dir() a lógica é usada e retorna:
- para um módulo de objecto:o módulo de atributos.
- para um objeto de classe:seus atributos, e recursivamente os atributos de suas bases.
- para qualquer outro objeto:seus atributos, sua classe de atributos e recursivamente os atributos de sua classe classes base.
Por exemplo:
$ 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 eu estava verificando o seu problema, eu decidi demonstrar o meu trem de pensamento, com melhor formatação da saída 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 eu tenha contribuído :).
Se você deseja especificamente métodos, você deve usar inspecionar.ismethod.
Para nomes de método:
import inspect
method_names = [attr for attr in dir(self) if inspect.ismethod(getattr(self, attr))]
Para os métodos próprios:
import inspect
methods = [member for member in [getattr(self, attr) for attr in dir(self)] if inspect.ismethod(member)]
Às vezes inspect.isroutine pode ser útil também (built-ins, extensões C, Cython sem o "enlace" directiva de compilador).
Abra o shell bash (ctrl+alt+T no Ubuntu).Iniciar python3 shell.Criar o objecto a observar métodos.Basta adicionar um ponto a seguir e pressione duas vezes "guia" e você verá algo como isso:
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(
O problema com todos os métodos aqui indicado é que você NÃO PODE ter certeza de que um método não existe.
Em Python, você pode interceptar a ponto de chamar thru __getattr__ e __getattribute__, tornando possível a criação de um método em tempo de execução"
Exemplo:
class MoreMethod(object):
def some_method(self, x):
return x
def __getattr__(self, *args):
return lambda x: x*2
Se você executá-lo, você pode chamar o método não existente no objeto de dicionário...
>>> 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
E é por isso que você usar o Mais fácil pedir perdão do que permissão paradigmas em Python.
A maneira mais simples para obter a lista de métodos de qualquer objeto é usar help() de comando.
%help(object)
Ele irá listar todos os disponíveis/importantes métodos associados a esse objeto.
Por exemplo:
help(str)
Pode-se criar uma getAttrs função que irá retornar um objeto possa ser chamado de nomes de propriedade
def getAttrs(object):
return filter(lambda m: callable(getattr(object, m)), dir(object))
print getAttrs('Foo bar'.split(' '))
Que iria voltar
['__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']
Não há nenhuma maneira confiável a lista de todos os métodos do objeto. dir(object) normalmente é útil, mas em alguns casos pode não lista todos os métodos.De acordo com a dir() documentação: "Com um argumento, tentativa para retornar uma lista de atributos válidos para o objeto."
A verificação de que existe um método pode ser feito por callable(getattr(object, method)) como já mencionado lá.
...existe pelo menos uma maneira fácil de verificar se ele tem um método diferente de simplesmente verificar se um erro ocorre quando o método é chamado
Enquanto "Mais fácil pedir perdão do que permissão"é, certamente, o Pythonic forma, o que você está procurando, talvez:
d={'foo':'bar', 'spam':'eggs'}
if 'get' in dir(d):
d.get('foo')
# OUT: 'bar'
Dê uma lista de como um objeto
obj = []
list(filter(lambda x:callable(getattr(obj,x)),obj.__dir__()))
Você obtém:
['__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']
Na busca de um método específico em um módulo inteiro
for method in dir(module) :
if "keyword_of_methode" in method :
print(method, end="\n")
