我认为这最好用元类来完成，以便处理运行时和子类方法装饰。我没有看到用类装饰器自动处理子类的优雅方法。

from types import FunctionType

# check if an object should be decorated
def do_decorate(attr, value):
    return ('__' not in attr and
            isinstance(value, FunctionType) and
            getattr(value, 'decorate', True))

# decorate all instance methods (unless excluded) with the same decorator
def decorate_all(decorator):
    class DecorateAll(type):
        def __new__(cls, name, bases, dct):
            for attr, value in dct.iteritems():
                if do_decorate(attr, value):
                    dct[attr] = decorator(value)
            return super(DecorateAll, cls).__new__(cls, name, bases, dct)
        def __setattr__(self, attr, value):
            if do_decorate(attr, value):
                value = decorator(value)
            super(DecorateAll, self).__setattr__(attr, value)
    return DecorateAll

# decorator to exclude methods
def dont_decorate(f):
    f.decorate = False
    return f

下面是一个使用它的例子（Python 2，但在Python 3中做了一些小的修改）：

def printer(f):
    print f
    return f

class Foo(object):
    __metaclass__ = decorate_all(printer)
    def bar(self):
        pass
    @dont_decorate
    def baz(self):
        pass
    @classmethod
    def test(self):
        pass
# prints
# <function bar at 0x04EB59B0>

class AnotherName(Foo):
    def blah(self):
        pass
# prints
# <function blah at 0x04EB5930>

Foo.qux = lambda: 1
# prints
# <function <lambda> at 0x04EB57F0>

你可以这样做（虽然不确定这是否是最优雅的方式）：

def get_all_instance_methods(x):
    return filter(callable, map(lambda d: getattr(x, d), dir(x)))

至于cls.method_name，您将不得不使用getattr(cls, method_name)。

这是@agf的答案的更新版本，它使用python 3，添加了类型提示（传递mypy），添加了docstring，并做了一个非常小的重构，装饰器在方法执行之前和之后都做了一些事情。

from functools import wraps
from types import FunctionType
from typing import Any, Callable, Dict, Tuple

def dont_decorate(f: Callable) -> Callable:
    """Decorator to exclude methods from autodecoration."""
    f._decorate = False  # type: ignore[attr-defined]
    return f

def my_decorator(f: Callable) -> Callable:
    """Dummy decorator which prints before and after the function it decorates."""

    @wraps(f)
    def wrapper(*args: Any, **kwargs: Any) -> Any:
        """Wraps provided function and prints before and after."""
        print(f"Calling decorated function {f.__name__}")
        return_val = f(*args, **kwargs)
        print(f"Called decorated function {f.__name__}")
        return return_val

    return wrapper

def decorate_all(decorator: Callable) -> type:
    """Decorate all instance methods (unless excluded) with the same decorator."""

    class DecorateAll(type):
        """Decorate all instance methods (unless excluded) with the same decorator."""

        @classmethod
        def do_decorate(cls, attr: str, value: Any) -> bool:
            """Checks if an object should be decorated."""
            return (
                "__" not in attr
                and isinstance(value, FunctionType)
                and getattr(value, "_decorate", True)
            )

        def __new__(
            cls, name: str, bases: Tuple[type, ...], dct: Dict[str, Any]
        ) -> type:
            for attr, value in dct.items():
                if cls.do_decorate(attr, value):
                    dct[attr] = decorator(value)
            return super().__new__(cls, name, bases, dct)

        def __setattr__(self, attr: str, value: Any) -> None:
            if self.do_decorate(attr, value):
                value = decorator(value)
            super().__setattr__(attr, value)

    return DecorateAll

和它的使用示例：

# Mypy does not support dynamically computed metaclasses.
class Foo(metaclass=decorate_all(decorator=my_decorator)):  # type: ignore[misc]
    """Dummy class."""

    def foo(self) -> None:
        """Should be decorated."""
        print("foo")

    @dont_decorate
    def test(self) -> None:
        """Should not be decorated."""
        print("test")

class Bar(Foo):
    """Dummy class."""

    def bar(self) -> None:
        """Should be decorated."""
        print("bar")


foo = Foo()
foo.foo()
# Calling decorated function foo
# foo
# Called decorated function foo
foo.test()
# test

bar = Bar()
bar.foo()
# Calling decorated function foo
# foo
# Called decorated function foo
bar.bar()
# Calling decorated function bar
# bar
# Called decorated function bar
bar.test()
# test