在日常的 Python 开发中，我们经常需要深入探究某个类的内部结构，尤其是当我们面对庞大的第三方库或复杂的遗留代码时。你是否曾经遇到过这样的情况：面对一个未知的类，你想快速知道它提供了哪些功能，或者你需要根据配置文件动态地调用类中的特定方法？这时，获取类中方法的列表就变得至关重要。通过掌握这一技巧，我们不仅能更深入地理解代码的设计意图，还能编写出更加灵活、具有 AI 原生特性的元程序。
在今天的这篇文章中，我们将不仅仅满足于“列出名字”，而是会带你深入探讨 Python 反射机制的奥秘。我们将从 2026 年现代开发视角出发，结合 AI 辅助编程和类型安全的最新趋势，通过多种不同的方式来实现这一目标，并分析它们各自背后的工作原理和适用场景。无论你是刚刚入门 Python 的新手，还是希望提升代码洞察力的资深开发者，这篇文章都将为你提供实用的知识和技巧。
为什么我们需要获取类的方法列表？
在正式开始之前，让我们先明确一下在实际开发中哪些场景会用到这些技术。这不仅仅是学术练习，而是具有实际应用价值的操作，特别是在现代软件工程中：
- API 探测与适配器模式：当你使用一个庞大的库（如 Pandas 或 TensorFlow）时，可能不清楚某个对象具体支持哪些操作。通过动态获取方法列表，你可以编写智能适配器，自动兼容不同版本的库。
- 动态调用与插件系统：在编写插件系统或处理配置文件驱动的任务时，你可能需要根据字符串名称来调用方法。这是构建可扩展架构的核心。
- AI 辅助的调试与测试：在 2026 年，我们经常与 AI 结对编程。获取清晰的方法列表有助于 AI 理解上下文，从而生成更准确的代码补全或自动化测试代码。
准备工作：我们的测试类
为了演示接下来的各种方法，让我们首先定义一个稍微复杂一点的 ModernService 类。它不仅包含了普通方法，还涵盖了静态方法、类方法以及异步方法，这些都是我们在现代异步编程中经常遇到的。
class ModernService:
"""一个用于演示现代 Python 类方法获取的示例类"""
def __init__(self, service_name: str):
self.service_name = service_name
self._internal_state = "active"
async def fetch_data(self, query: str):
"""模拟异步数据获取"""
return f"Data for {query} from {self.service_name}"
def sync_process(self):
return f"Processing sync logic"
@staticmethod
def health_check():
return "Service is healthy"
@classmethod
def get_version(cls):
return "1.0.2-beta"
def _private_logic(self):
return "Internal logic"
方法一：使用 dir() 函数
dir() 是 Python 内置的函数，它可能是最快速、最直接的方式来探索对象的属性。如果不带参数，它返回当前作用域内的名称；如果带参数（如我们的类名），它返回该对象属性名称的列表。
#### 工作原理
INLINECODEf8c30162 的强大之处在于它不仅返回对象自身 INLINECODE50315974 中的属性，还会返回继承自父类的属性。这意味着如果你有一个继承自 INLINECODEb2b673ab 的类，INLINECODEfeb4307c 也会列出 INLINECODE7379a6fc 类中的方法（如 INLINECODEad787d78 等）。这对于我们需要全面了解一个对象的能力非常有帮助。
#### 代码实现与过滤
由于 INLINECODEb5d20c62 返回的列表中包含了所有属性（包括数据属性和魔术方法），我们需要对其进行过滤。我们可以结合 INLINECODEcb4110b9 函数（判断对象是否可调用）和 getattr() 函数（获取属性值）来实现。
# 1. 获取 dir() 的原始输出
# 注意：dir() 返回的是一个字符串列表
all_attributes = dir(ModernService)
print(f"原始属性数量: {len(all_attributes)}")
# 2. 筛选出我们定义的方法
# 逻辑：遍历属性名，获取对应的属性值，检查是否可调用，并排除魔术方法
def get_user_defined_methods(cls):
methods_list = []
for method_name in dir(cls):
# 跳过魔术方法
if method_name.startswith("__"):
continue
# 获取属性对象
try:
attr = getattr(cls, method_name)
except AttributeError:
continue
# 检查是否可调用（方法、函数等）
if callable(attr):
methods_list.append(method_name)
return methods_list
methods = get_user_defined_methods(ModernService)
print(f"过滤后的可调用方法: {methods}")
输出结果：
过滤后的可调用方法: [‘fetch_data‘, ‘get_version‘, ‘health_check‘, ‘sync_process‘]
深入解析：
这里的关键在于列表推导式中的条件判断：
- INLINECODE5b005837：这确保了我们获取的不仅仅是属性（比如变量 INLINECODE9b2d4670），而是可以被调用的函数或方法。
- INLINECODE1c89133a：这是最简单的魔术方法过滤方式。大多数内置的魔术方法（如 INLINECODE527ef984,
__str__）都是以双下划线开头的。
最佳实践提示： 虽然 INLINECODE54f0528e 很方便，但在处理动态属性或描述符时可能会有副作用。在生产环境中，如果你需要更加结构化的数据，建议使用下文提到的 INLINECODE62323d0c 模块。
方法二：使用 inspect 模块
如果你需要更专业、更严格的内省功能，Python 的 inspect 模块是标准库中的不二之选。它提供了许多针对活动对象（如模块、类、方法、函数、回溯、帧对象和代码对象）的函数。
#### 为什么选择 inspect？
相比于 INLINECODEbf886669 这种比较“粗暴”的枚举，INLINECODEda170967 能够区分方法、函数、生成器甚至是协程函数。这对于编写复杂的调试工具或支持异步逻辑的框架非常有用。特别是当你的代码中混合了 INLINECODE85a19b73 和普通 INLINECODEe7cebf73 时，inspect 能帮你准确识别。
#### 代码示例：精细过滤
INLINECODE646ba6a9 函数会返回对象的所有成员列表。我们可以利用它的 INLINECODE302a0f2c 参数来过滤出特定的类型。
import inspect
def analyze_class_structure(cls):
print(f"
=== 正在分析类: {cls.__name__} ===")
# 获取所有成员
all_members = inspect.getmembers(cls)
# 分类存储
methods = []
static_methods = []
class_methods = []
coroutines = []
for name, member in all_members:
# 跳过私有成员和魔术方法
if name.startswith("_"):
continue
# 检查是否是函数（在类定义体中，方法被视为函数）
if inspect.isfunction(member):
# 进一步检查是否是协程函数
if inspect.iscoroutinefunction(member):
coroutines.append(name)
else:
methods.append(name)
# 检查静态方法
# 注意：静态方法在类字典中是描述符，getattr后是函数
# 这里我们用 inspect.isstaticmethod 判断原始成员
elif inspect.isstaticmethod(member, cls) or isinstance(inspect.getattr_static(cls, name), staticmethod):
static_methods.append(name)
# 检查类方法
# 类方法在定义时是绑定方法对象
elif inspect.ismethod(member) or isinstance(inspect.getattr_static(cls, name), classmethod):
class_methods.append(name)
print(f"[普通实例方法]: {methods}")
print(f"[异步方法]: {coroutines}")
print(f"[静态方法]: {static_methods}")
print(f"[类方法]: {class_methods}")
print("=" * 30)
analyze_class_structure(ModernService)
输出结果：
=== 正在分析类: ModernService ===
[普通实例方法]: [‘sync_process‘]
[异步方法]: [‘fetch_data‘]
[静态方法]: [‘health_check‘]
[类方法]: [‘get_version‘]
==============================
2026年视角的提示： 在现代微服务架构中，区分异步方法和同步方法对于性能监控至关重要。使用 inspect.iscoroutinefunction 可以让我们自动识别哪些接口是异步的，从而在路由注册时应用不同的中间件。
方法三：使用 INLINECODE7e205371 函数与 INLINECODEd5985b16 属性
INLINECODE04ad5466 函数实际上是一个封装了 INLINECODEbaac50fd 属性的内置函数。直接访问 __dict__ 是性能最高的方式，但它只包含当前类直接定义的属性，不包含继承的属性。
#### 什么时候应该用 dict？
当你需要极高的性能，或者你非常确定你在做什么，并且只想访问当前类定义的属性而不希望有任何隐式的查找时，直接访问 __dict__ 是最快的方式。它避免了函数调用的开销，并且明确地告诉阅读代码的人：“我在直接操作命名空间”。
# 直接遍历 __dict__ 的键
# 这比 vars() 更显式地表明我们在访问底层数据结构
def get_direct_methods(cls):
methods_list = []
for key, value in cls.__dict__.items():
# 检查是否是函数（普通方法）或特殊的描述符
if isinstance(value, (staticmethod, classmethod)):
methods_list.append(key)
elif inspect.isfunction(value):
methods_list.append(key)
return methods_list
print(f"直接定义的方法: {get_direct_methods(ModernService)}")
深度实战：构建一个智能的 API 路由注册器
让我们把所学知识结合起来，构建一个实战案例。假设我们在 2026 年开发一个基于 FastAPI 风格的轻量级 Web 框架，我们需要自动将类中的方法注册为 HTTP 路由。我们希望这个类能够自动区分普通方法和异步方法，并处理私有方法的过滤。
这是一个典型的元编程应用场景，它展示了反射机制在实际工程中的威力。
class AutoRouter:
"""
能够自动扫描类并将方法注册为路由的装饰器/基类
"""
def __init__(self, prefix: str = "/api"):
self.prefix = prefix
self.routes = {}
def __call__(self, cls):
# 这里我们结合了 inspect 和 dir 的优点
# 1. 使用 dir() 获取所有可调用接口（包括继承的 mixin）
# 2. 使用 inspect 判断类型（同步 vs 异步）
print(f"注册路由: Scanning class {cls.__name__}...")
for name in dir(cls):
if name.startswith("_"):
continue
# 获取未绑定的方法/函数
# 使用 inspect.getattr_static 可以避免触发属性描述符的 __get__，更安全
func = inspect.getattr_static(cls, name)
# 判断是否是函数（排除非调用的属性）
if inspect.isfunction(func):
# 判断是否是异步函数
is_async = inspect.iscoroutinefunction(func)
# 生成路由路径
route_path = f"{self.prefix}/{name}"
# 模拟注册路由
handler_type = "ASYNC" if is_async else "SYNC"
self.routes[route_path] = {"type": handler_type, "handler": name}
print(f" -> Registered [{handler_type}] {route_path} -> {name}")
# 将注册信息注入到类中，方便后续查看
cls._routes = self.routes
return cls
# 使用我们的自动路由注册器
@AutoRouter(prefix="/v1/user")
class UserService:
def __init__(self):
pass
def get_profile(self):
return "Profile Data"
async def update_settings(self):
return "Settings Updated"
def _internal_cache_flush(self):
pass
# 检查结果
print("
最终路由表:", UserService._routes)
在这个例子中，我们没有硬编码任何路由。这体现了“约定优于配置”的现代开发理念。只要我们遵循命名约定（不使用下划线开头），框架就能自动识别并注册我们的功能。
2026 前端趋势：开发工作流与 AI 的深度融合
在当下的开发环境中，我们不仅要关注代码本身的实现，更要关注如何利用最新的工具链来提升效率。获取类方法列表这一看似基础的操作，在 AI 辅助编程 时代焕发了新的生机。
#### 1. 让 AI 更好地理解你的代码
当我们使用像 Cursor、Windsurf 或 GitHub Copilot 这样的 AI 编程助手时，我们实际上是在与一个能够理解代码上下文的智能体协作。当你问 AI “我的类里有哪些方法是公开的 API？” 时，AI 本质上就是在后台运行类似 inspect.getmembers() 的逻辑。
实战技巧： 我们可以在提示词中显式地利用这一机制。例如，你可以这样提示 AI：
> “请使用 INLINECODE2a5b232c 模块分析 INLINECODE994bf752 类，忽略所有以 _ 开头的方法，并为剩余的每个异步方法生成对应的 Pydantic 模型。”
通过这种方式，我们将“列出方法”这一操作提升为了“生成代码架构”的起点。
#### 2. Agentic AI 与动态工具调用
2026 年是 Agentic AI（自主智能体）爆发的元年。构建一个能够自主解决问题的 Agent，核心在于其“工具箱”。而这个工具箱，往往就是 Python 类中的一个个方法。
想象一下，我们正在构建一个自动化运维 Agent。它需要根据当前的故障日志，自动选择合适的修复脚本。这些脚本就是类中的方法。通过反射机制，Agent 可以动态地列出可用工具（方法列表），检查它们的参数签名（通过 inspect.signature），并在运行时安全地执行它们。
# 模拟 Agent 思考过程
class OperationsAgent:
def __init__(self):
self.tools = self._load_tools()
def _load_tools(self):
# 动态获取当前类中所有非私有方法作为可用工具
available_tools = []
for name, method in inspect.getmembers(self, predicate=inspect.ismethod):
if not name.startswith("_"):
# 获取方法签名，让 AI 知道需要传什么参数
sig = inspect.signature(method)
available_tools.append({
"name": name,
"description": method.__doc__ or "No description",
"params": str(sig)
})
return available_tools
def restart_service(self, service_name: str):
"""重启指定的微服务"""
print(f"Executing: Restarting {service_name}...")
return f"{service_name} restarted."
def clear_cache(self):
"""清理系统缓存"""
print("Executing: Clearing cache...")
return "Cache cleared."
# Agent 启动时自动感知能力
agent = OperationsAgent()
print(f"Agent 具备能力: {[tool[‘name‘] for tool in agent.tools]}")
#### 3. 多模态开发与文档自动生成
在处理包含数百个方法的遗留系统时，手动维护 API 文档是痛苦的。利用反射，我们可以编写脚本，自动扫描代码库，生成包含方法签名、文档字符串甚至调用示例的 Markdown 文档。更进一步，结合 LLM，我们可以为每个方法自动生成“使用场景说明”和“常见错误排查指南”，这大大降低了团队的知识共享成本。
总结与最佳实践
获取 Python 类的方法列表是通往高级元编程的一扇大门。通过这篇文章，我们从最简单的 INLINECODE54374b6e 函数开始，一路探索到了底层的 INLINECODE8d2c39c8 属性和强大的 inspect 模块。为了帮助你在项目中做出明智的选择，我们总结以下决策指南：
- 快速调试与探索：优先使用
dir()。它全面且无需导入模块。 - 框架开发与类型检查：必须使用
inspect。它能正确区分函数、方法、协程和描述符，是构建鲁棒系统的基石。 - 极端性能优化：在只有类定义且需要极致速度时，直接访问
__dict__。 - 私有API过滤：请根据项目规范统一过滤
_开头的方法。记住，Python 中的“私有”更多是一种约定，而非强制。 - AI 协作开发：当你需要让 AI 理解你的类结构时，使用
inspect生成的结构化数据是比纯代码文本更高效的上下文输入。
希望这些技巧能帮助你在未来的项目中写出更灵活、更强大的 Python 代码。下一次当你面对一个陌生的类，或者需要编写一个能够自动处理类的 AI Agent 时，不妨试试这些方法，看看它的“内心世界”究竟藏了什么。