Как узнать, какие методы есть у объекта Python

Для многих объектов вы можете использовать этот код, заменив «объект» на интересующий вас объект:

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

Я обнаружил это на diveintopython.net (сейчас в архиве). Надеюсь, это даст дополнительную информацию!

Если вы получили AttributeError, вы можете использовать это вместо:

getattr( не терпит абстрактных виртуальных подклассов python3.6 в стиле панд. Этот код делает то же, что и выше, и игнорирует исключения.

import pandas as pd
df = pd.DataFrame([[10, 20, 30], [100, 200, 300]],
                  columns=['foo', 'bar', 'baz'])
def get_methods(object, spacing=20):
  methodList = []
  for method_name in dir(object):
    try:
        if callable(getattr(object, method_name)):
            methodList.append(str(method_name))
    except:
        methodList.append(str(method_name))
  processFunc = (lambda s: ' '.join(s.split())) or (lambda s: s)
  for method in methodList:
    try:
        print(str(method.ljust(spacing)) + ' ' +
              processFunc(str(getattr(object, method).__doc__)[0:90]))
    except:
        print(method.ljust(spacing) + ' ' + ' getattr() failed')

get_methods(df['foo'])

Вы можете использовать встроенную функцию dir(), чтобы получить список всех атрибутов, которые имеет модуль. Попробуйте это в командной строке, чтобы увидеть, как это работает.

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

Кроме того, вы можете использовать функцию hasattr(module_name, "attr_name"), чтобы узнать, есть ли у модуля определенный атрибут.

Дополнительную информацию см. В Руководстве по интроспекции Python.

Самый простой способ - использовать dir(objectname). Он отобразит все методы, доступные для этого объекта. Классный трюк.

Я считаю, что вам нужно что-то вроде этого:

список атрибутов объекта

Эту работу может выполнить встроенная функция dir().

Взято из help(dir) вывода вашей оболочки Python:

реж (...)

dir([object]) -> list of strings

Если вызывается без аргумента, вернуть имена в текущей области.

В противном случае верните отсортированный по алфавиту список имен, содержащих (некоторые из) атрибутов данного объекта, и атрибутов, доступных из него.

Если объект предоставляет метод с именем __dir__, он будет использован; в противном случае используется логика dir () по умолчанию, которая возвращает:

• для объекта модуля: атрибуты модуля.
• для объекта класса: его атрибуты и рекурсивно атрибуты его баз.
• для любого другого объекта: его атрибуты, атрибуты его класса и рекурсивно атрибуты базовых классов его класса.

Например:

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

Чтобы проверить, есть ли у него конкретный метод:

hasattr(object,"method")

Помимо более прямых ответов, было бы упущением, если бы я не упомянул IPython.

Нажмите Tab, чтобы увидеть доступные методы с автозаполнением.

И как только вы найдете метод, попробуйте:

help(object.method)

чтобы увидеть pydocs, подпись метода и т. д.

Ах ... REPL.

Если вам конкретно нужны методы, вам следует использовать inspect .ismethod.

Для названий методов:

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

Для самих методов:

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

Иногда может оказаться полезным inspect.isroutine (для встроенных модулей C расширения, Cython без "привязки" директивы компилятора).

Самый простой способ получить список методов любого объекта - использовать команду help().

%help(object)

В нем будут перечислены все доступные / важные методы, связанные с этим объектом.

Например:

help(str)

Откройте оболочку Bash (Ctrl + Alt + T в Ubuntu). Запустите в нем оболочку Python 3. Создайте объект для наблюдения за методами. Просто добавьте точку после нее и дважды нажмите Tab, и вы увидите что-то вроде этого:

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(

Проблема со всеми указанными здесь методами заключается в том, что вы не можете быть уверенным, что метод не существует.

В Python вы можете перехватывать вызов точки через __getattr__ и __getattribute__, что позволяет создать метод во время выполнения.

Пример:

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

Если вы его выполните, вы можете вызвать несуществующие методы в словаре объектов ...

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

Вот почему вы используете парадигмы Проще просить прощения, чем разрешения в Python.

Предположим, у нас есть Python obj. Затем, чтобы увидеть все имеющиеся у него методы, в том числе окруженные __ (магические методы):

print(dir(obj))

Чтобы увидеть только методы, доступные через инфиксную (точечную) нотацию, нужно:

[m for m in dir(obj) if not m.startswith('__')]

Нет надежного способа перечислить все методы объекта. dir(object) обычно бывает полезным, но в некоторых случаях он может не перечислять все методы. Согласно dir() документации: «С аргументом, <сильный > попытаться вернуть список допустимых атрибутов для этого объекта "

Проверка того, существует ли метод, может быть выполнена callable(getattr(object, method)), как уже упоминалось там.

import moduleName
for x in dir(moduleName):
    print(x)

Это должно работать :)

Можно создать getAttrs функцию, которая будет возвращать имена вызываемых свойств объекта.

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

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

Это вернется

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

Возьмите список как объект

obj = []

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

Ты получаешь:

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

Для поиска определенного метода во всем модуле

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

... есть хотя бы простой способ проверить, есть ли у него конкретный метод, кроме простой проверки, возникает ли ошибка при вызове метода

Хотя проще просить прощения, чем разрешения, безусловно, питонический путь, вы можете искать:

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

Вы можете использовать dir (), который предопределен в Python.

import module_name
dir(module_name)

Вы также можете передать объект в dir () как

dir(object_name)

Если объект является объектом предопределенного класса, такого как int, str и т. Д., Он отображает методы в нем (вы можете знать эти методы как встроенные функции). Если этот объект создан для определенного пользователем класса, он отображает все методы, данные в этом классе.

Я выполнил следующую функцию (get_object_functions), которая получает объект (object_) в качестве аргумента и возвращает список (functions), содержащий все методы (включая статические методы и методы класса), определенные в классе объекта :

def get_object_functions(object_):
    functions = [attr_name
                 for attr_name in dir(object_)
                 if str(type(getattr(object_,
                                     attr_name))) in ("<class 'function'>",
                                                      "<class 'method'>")]
    return functions

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        print(f'My name is {self.name}')

    @staticmethod
    def say_hi():
        print('hi')

    @classmethod
    def reproduce(cls, name):
        return cls(name, 0)


person = Person('Rafael', 27)
print(get_object_functions(person))

['__init__', 'introduce', 'reproduce', 'say_hi']