Как посмотреть все методы объекта python

В Python доступ к методам объекта можно получить с помощью встроенных инструментов. Чаще всего применяются функции dir() и inspect.getmembers(). Первая возвращает список всех атрибутов объекта, включая методы, а вторая позволяет фильтровать только функции и получить больше информации о каждом методе.

Использование dir() удобно для быстрого обзора. Например, вызов dir(str) выведет список доступных методов строкового типа. Однако результат будет содержать не только методы, но и служебные атрибуты, начинающиеся с двойного подчёркивания.

Для более точного анализа подходит модуль inspect. С его помощью можно отфильтровать методы через inspect.isfunction или inspect.ismethod. Такой подход полезен при изучении сторонних библиотек или при автоматизации документирования.

Комбинация этих инструментов позволяет быстро ориентироваться в возможностях объекта и выбирать нужные методы без необходимости обращаться к документации вручную.

Использование встроенной функции dir()

Функция dir() возвращает список атрибутов и методов объекта. Для любого экземпляра класса или встроенного типа можно вызвать dir(obj), чтобы получить доступные имена.

Пример для списка: print(dir([])) выведет методы append, extend, pop и другие. Это позволяет быстро увидеть, чем можно оперировать при работе с объектом.

Чтобы выделить только методы, можно отфильтровать результат:

[m for m in dir(obj) if callable(getattr(obj, m))]. Такой приём исключает свойства и оставляет только вызываемые элементы.

Для пользовательских классов dir() также покажет методы, включая унаследованные от базовых классов. Это удобно для изучения структуры объекта без чтения документации или исходного кода.

Фильтрация только методов среди атрибутов

При вызове dir() возвращаются и методы, и обычные атрибуты. Чтобы оставить только методы, нужно проверять каждый элемент с помощью callable(). Например:

methods = [name for name in dir(obj) if callable(getattr(obj, name))]

Такой подход исключает свойства и константы, оставляя только вызываемые элементы. Если требуется убрать магические методы, можно добавить фильтр:

methods = [name for name in dir(obj) if callable(getattr(obj, name)) and not name.startswith("__")]

Вместо callable() можно использовать inspect.ismethod() или inspect.isfunction(), если нужно разделить методы экземпляра и функции класса:

import inspect
methods = [name for name, val in inspect.getmembers(obj, inspect.ismethod)]

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

Применение функции callable() для проверки

Пример:

class Example:
def method(self):
pass
obj = Example()
methods = [name for name in dir(obj) if callable(getattr(obj, name))]
print(methods)

В этом примере:

• dir(obj) возвращает все имена атрибутов объекта.
• getattr(obj, name) извлекает атрибут по имени.
• callable() отбирает только те атрибуты, которые можно вызвать.

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

methods = [name for name in dir(obj)
if callable(getattr(obj, name)) and not name.startswith("__")]

Итоговый список будет содержать только пользовательские методы класса.

Получение списка методов через модуль inspect

Модуль inspect предоставляет функцию getmembers(), позволяющую извлечь все атрибуты объекта с возможностью фильтрации. Чтобы получить только методы, используется предикат inspect.isfunction или inspect.ismethod.

Пример для пользовательского класса:

import inspect
class Demo:
def a(self): pass
def b(self): pass
methods = inspect.getmembers(Demo, predicate=inspect.isfunction)
print([name for name, _ in methods])

В результате будет выведен список имён методов: ['a', 'b']. Такой подход исключает обычные атрибуты и переменные класса.

Для экземпляра объекта можно применить inspect.ismethod:

obj = Demo()
methods = inspect.getmembers(obj, predicate=inspect.ismethod)
print([name for name, _ in methods])

Методы будут возвращены в связанной форме, что полезно при анализе экземпляров.

Комбинируя разные предикаты, можно получать не только функции, но и статические или классовые методы. Это делает inspect удобным инструментом для построения утилит автодокументации и анализа кода.

Ниже – компактный, надёжный способ получить только методы, определённые в теле класса (включая обычные методы, @staticmethod и @classmethod), без унаследованных и без dunder-методов по умолчанию.

import inspect
import types
from typing import List, Tuple
def list_user_methods(cls, include_private: bool = False) -> List[Tuple[str, inspect.Signature]]:
result = []
for name, member in vars(cls).items():
if not include_private and name.startswith('_'):
continue
# распаковать статический/классовый метод в исходную функцию
if isinstance(member, staticmethod) or isinstance(member, classmethod):
func = member.func
elif isinstance(member, (types.FunctionType, types.BuiltinFunctionType)):
func = member
else:
continue
try:
sig = inspect.signature(func)
except (ValueError, TypeError):
sig = None
result.append((name, sig))
return result
пример использования
class Base:
def inherited(self): pass
class Demo(Base):
def instance(self, x): pass
@staticmethod
def stat(a, b=1): pass
@classmethod
def clsmethod(cls, y): pass
def _private(self): pass
print(list_user_methods(Demo))            # по умолчанию без приватных
print(list_user_methods(Demo, True))      # включая приватные

Почему этот метод надёжнее:

• Читает только словарь класса (vars(cls)) – не захватывает унаследованные атрибуты.
• Корректно распознаёт и распаковывает staticmethod и classmethod.
• Позволяет явно исключать dunder/приватные имена через флаг include_private.

Рекомендации:

• Если нужен список для экземпляра – применяйте к его классу: list_user_methods(obj.__class__).
• Если требуется сигнатура для документации – используйте возвращаемые inspect.Signature и форматируйте через str(sig).
• Для динамически создаваемых методов (через метаклассы или setattr) проверьте, что они присутствуют в vars(cls); в противном случае придется включать дополнительную логику поиска в метаклассах.

Определение унаследованных методов объекта

Основные подходы:

1. Использование функции dir() совместно с проверкой принадлежности методу классу:

   class A:
   def method_a(self):
   pass
   class B(A):
   def method_b(self):
   pass
   obj = B()
   inherited_methods = [m for m in dir(obj)
   if callable(getattr(obj, m))
   and not m in B.dict]
   print(inherited_methods)

   Список inherited_methods содержит методы, унаследованные от класса A.

2. Использование модуля inspect для фильтрации методов:

   import inspect
   methods = inspect.getmembers(B, predicate=inspect.isfunction)
   inherited = [name for name, func in methods if name not in B.dict]
   print(inherited)

   Метод getmembers возвращает все функции класса, после чего исключаются методы, определённые в самом классе.

3. Рекурсивное определение всех родительских методов:

   def get_inherited_methods(cls):
   inherited = []
   for base in cls.__bases__:
   inherited += [name for name in base.__dict__ if callable(base.__dict__[name])]
   inherited += get_inherited_methods(base)
   return inherited
   print(get_inherited_methods(B))

   Подходит для сложных иерархий классов с несколькими уровнями наследования.

Рекомендации при работе с унаследованными методами:

• Использовать __dict__ для точного отделения методов базового класса от собственных.
• Применять inspect, если требуется фильтровать только функции, исключая атрибуты и свойства.
• Для анализа больших иерархий рекомендуется рекурсивный обход через __bases__.

Сортировка и фильтрация встроенных методов:

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

Этот подход исключает специальные методы и упорядочивает список по алфавиту, облегчая поиск нужной функции.

import inspect
methods = [m for m, _ in inspect.getmembers(obj, inspect.isroutine)]

Так вы получите только вызываемые элементы объекта, исключив свойства и атрибуты.

Для отладки удобно отображать методы в столбцах или с дополнительной информацией о типе:

for i, method in enumerate(methods, 1):
print(f"{i:2}: {method}")

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

for i in range(0, len(methods), 10):
print(methods[i:i+10])

Такой подход снижает перегрузку информации и ускоряет анализ структуры объекта.

Для автоматической отладки можно объединять фильтры по типу и ключевым словам:

filtered = [m for m in methods if 'get' in m]

Это особенно полезно при работе с объектами больших библиотек, где методами часто оперируют динамически.

Вопрос-ответ:

Какие функции Python позволяют узнать, какие методы есть у объекта?

В Python для получения списка методов объекта чаще всего используют функции dir() и inspect.getmembers(). Функция dir() возвращает все атрибуты объекта, включая методы, а inspect.getmembers() позволяет фильтровать только методы с помощью предиката inspect.isfunction или inspect.ismethod.

Можно ли получить список только публичных методов объекта без скрытых и встроенных?

Да, это можно сделать с помощью функции dir(), а затем исключить все атрибуты, которые начинаются с двойного подчеркивания __. Например, [m for m in dir(obj) if not m.startswith('__')] вернёт только методы, которые обычно используются напрямую пользователем.

В чём разница между методами и атрибутами объекта при просмотре списка с dir()?

Методы — это функции, которые определены внутри класса объекта и могут быть вызваны через объект. Атрибуты — это данные, хранящиеся внутри объекта, включая переменные экземпляра и свойства. Функция dir() показывает и то, и другое, поэтому чтобы получить только методы, нужно дополнительно фильтровать результат с помощью callable() или функций модуля inspect.

Как получить методы объекта, включая те, что унаследованы от родительских классов?

Функция dir() уже возвращает все методы, включая унаследованные. Если нужно работать с модулем inspect, можно использовать inspect.getmembers(obj, predicate=inspect.isroutine), что вернёт все функции и методы объекта, независимо от того, определены ли они в его классе или наследуются.

Можно ли получить список методов без использования встроенной функции dir()?

Да, можно через модуль inspect. Например, inspect.getmembers(obj, predicate=inspect.isfunction) вернёт функции, а inspect.getmembers(obj, predicate=inspect.ismethod) — методы экземпляра. Такой подход позволяет точнее контролировать, что именно вы хотите увидеть, в отличие от dir(), который возвращает и данные, и методы.

Как в Python получить список всех методов объекта, включая встроенные и пользовательские?

В Python для получения списка методов объекта чаще всего используют функцию dir(). Она возвращает все атрибуты объекта, среди которых есть методы и свойства. Например, если у вас есть объект my_obj, список его методов можно получить так: dir(my_obj). Этот способ покажет и встроенные методы, такие как init или str, и методы, которые вы добавили сами. Если нужно выделить только функции, можно пройтись по результату dir() и с помощью функции callable() отфильтровать методы, оставив только вызываемые атрибуты.