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

Просмотр методов объекта в Python

Просмотр методов и атрибутов объекта — ценный навык для отладки, исследования кода и работы с неизвестными библиотеками. Python предоставляет множество способов для этого.

1. Функция dir()

dir() — самый простой способ получить список атрибутов и методов:

class Car:
    def __init__(self, brand):
        self.brand = brand
    
    def drive(self):
        return f"{self.brand} едет"
    
    def stop(self):
        return "Машина остановилась"

car = Car("Toyota")

# Получить ВСЕ атрибуты и методы
methods = dir(car)
print(methods)
# ['__class__', '__delattr__', '__dict__', '__dir__', ..., 'brand', 'drive', 'stop']

# Отфильтровать только пользовательские методы
custom_methods = [m for m in dir(car) if not m.startswith('_')]
print(custom_methods)  # ['brand', 'drive', 'stop']

2. Функция type()

object_list = ["test", 42, [1, 2, 3], {"key": "value"}]

for obj in object_list:
    print(f"{obj} -> {type(obj).__name__}")
    # test -> str
    # 42 -> int
    # [1, 2, 3] -> list
    # {'key': 'value'} -> dict

# Получить тип объекта
object_type = type(car)
print(object_type)  # <class '__main__.Car'>
print(object_type.__name__)  # Car

3. Функция vars() и dict

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def greet(self):
        return f"Привет, я {self.name}"

person = Person("John", 30)

# Получить все атрибуты экземпляра
print(vars(person))  # {'name': 'John', 'age': 30}
print(person.__dict__)  # {'name': 'John', 'age': 30}

# Для класса
print(vars(Person))  # Словарь с методами класса

# Проверить наличие атрибута
if 'name' in vars(person):
    print(f"Есть имя: {person.name}")

4. Функция getattr() и hasattr()

class Config:
    debug = True
    timeout = 30
    
    def get_info(self):
        return "Config instance"

config = Config()

# Проверить наличие атрибута
if hasattr(config, 'debug'):
    print(f"debug = {getattr(config, 'debug')}")

if hasattr(config, 'unknown'):
    print("Есть unknown")
else:
    print("Нет unknown")

# Получить значение с дефолтом
value = getattr(config, 'unknown', 'default_value')
print(value)  # default_value

# Получить все методы
methods = [m for m in dir(config) if callable(getattr(config, m))]
print(methods)  # ['get_info', ...]

5. Inspect модуль — детальный анализ

import inspect

class DataProcessor:
    """Обработчик данных"""
    
    def __init__(self, name):
        self.name = name
    
    def process(self, data: list) -> dict:
        """Обработать данные"""
        return {"result": len(data)}
    
    def validate(self, value: int = 0) -> bool:
        """Проверить значение"""
        return value > 0

processor = DataProcessor("MyProcessor")

# Получить все члены класса
members = inspect.getmembers(processor)
for name, value in members:
    if not name.startswith('_'):
        print(f"{name}: {type(value).__name__}")

# Получить только методы
methods = inspect.getmembers(processor, predicate=inspect.ismethod)
for name, method in methods:
    if not name.startswith('_'):
        print(f"Метод: {name}")

# Получить сигнатуру функции
sig = inspect.signature(processor.process)
print(f"Параметры process: {sig}")
# Параметры process: (data: list) -> dict

for param_name, param in sig.parameters.items():
    print(f"  {param_name}: {param.annotation}")

# Получить исходный код
print(inspect.getsource(processor.process))

# Получить документацию
print(inspect.getdoc(processor.process))
# Обработать данные

6. Функция callable()

class Service:
    def execute(self):
        return "Executed"

service = Service()

# Проверить, является ли атрибут вызываемым
for attr_name in dir(service):
    if not attr_name.startswith('_'):
        attr = getattr(service, attr_name)
        is_callable = callable(attr)
        print(f"{attr_name}: callable={is_callable}")
        # execute: callable=True

7. Функция help()

from datetime import datetime

# Получить справку по объекту
help(datetime.now)

# Или интерактивно в REPL
# >>> help(str.replace)
# Help on method_descriptor:
#
# replace(...)
#     S.replace(old, new[, count]) -> str
#     Return a copy of S with all occurrences of substring old replaced by new.

# Для пользовательского класса
help(DataProcessor)

8. Полезная функция для исследования

def explore_object(obj):
    """Комплексное исследование объекта"""
    print(f"\n=== Исследование объекта {type(obj).__name__} ===")
    
    # Тип
    print(f"\nТип: {type(obj)}")
    
    # Атрибуты
    print(f"\nАтрибуты (vars):")
    for key, value in vars(obj).items():
        print(f"  {key} = {repr(value)[:60]}")
    
    # Методы
    print(f"\nМетоды:")
    for name in dir(obj):
        if not name.startswith('_'):
            attr = getattr(obj, name)
            if callable(attr):
                sig = inspect.signature(attr) if hasattr(inspect, 'signature') else ''
                print(f"  {name}{sig}")
    
    # Свойства
    print(f"\nСвойства (properties):")
    for name, attr in inspect.getmembers(type(obj)):
        if isinstance(attr, property):
            print(f"  {name}")

# Использование
explore_object(datetime.now())

9. Получить сигнатуру и аннотации

import inspect
from typing import List, Dict

class API:
    def fetch_users(self, limit: int = 10, offset: int = 0) -> List[Dict]:
        """Получить пользователей"""
        return []

api = API()

# Сигнатура
sig = inspect.signature(api.fetch_users)
print(f"Сигнатура: {sig}")
# Сигнатура: (limit: int = 10, offset: int = 0) -> List[Dict]

# Аннотации
print(f"Аннотации: {api.fetch_users.__annotations__}")
# Аннотации: {'limit': <class 'int'>, 'offset': <class 'int'>, 'return': typing.List[typing.Dict]}

# Параметры
for param_name, param in sig.parameters.items():
    print(f"  {param_name}:")
    print(f"    Аннотация: {param.annotation}")
    print(f"    Дефолт: {param.default}")
    print(f"    Kind: {param.kind}")

10. Интроспекция с doc и name

class Example:
    """Класс с документацией"""
    
    def method(self):
        """Метод с документацией"""
        pass

example = Example()

# Имя
print(f"Имя класса: {example.__class__.__name__}")
print(f"Имя метода: {example.method.__name__}")

# Документация
print(f"Документ класса: {Example.__doc__}")
print(f"Документ метода: {example.method.__doc__}")

# Модуль
print(f"Модуль: {Example.__module__}")

# MRO (Method Resolution Order)
print(f"MRO: {Example.__mro__}")

11. Практический пример — Debug helper

def debug_object(obj, verbose=False):
    """Отладочная функция для объектов"""
    print(f"\n{'='*60}")
    print(f"ОБЪЕКТ: {type(obj).__name__}")
    print(f"{'='*60}")
    
    # Инстанс атрибуты
    print(f"\nИнстанс атрибуты:")
    if hasattr(obj, '__dict__'):
        for key, val in obj.__dict__.items():
            val_str = str(val)[:50]
            print(f"  .{key} = {val_str}")
    
    # Публичные методы
    print(f"\nПубличные методы:")
    for name in sorted(dir(obj)):
        if not name.startswith('_'):
            attr = getattr(obj, name)
            if callable(attr):
                print(f"  .{name}()")
    
    # Тип и базовые классы
    print(f"\nТип: {type(obj)}")
    if hasattr(obj.__class__, '__bases__'):
        print(f"Базовые классы: {obj.__class__.__bases__}")
    
    if verbose:
        print(f"\nВсе атрибуты (include dunder):")
        for name in sorted(dir(obj)):
            print(f"  .{name}")
    
    print(f"\n{'='*60}\n")

# Использование
from collections import OrderedDict
debug_object(OrderedDict())

Best Practices

• dir() — быстрый обзор доступных методов
• inspect модуль — когда нужна детальная информация
• help() — встроенная справка
• hasattr/getattr — безопасный доступ к атрибутам
• vars() — для просмотра инстанс атрибутов
• type() — для определения типа
• callable() — для проверки вызываемости

Эти инструменты незаменимы при разработке, отладке и работе с неизвестными библиотеками.