深入详解Python中动态方法调用的各种方法

目录

• 引言
• 一、基础动态调用方法
• 1.1 使用getattr()函数
• 1.2 使用operator.methodcaller()
• 二、反射机制与高级动态调用
• 2.1 Python反射机制详解
• 2.2 安全性与错误处理
• 三、高级模式与应用场景
• 3.1 命令模式与动态调用
• 3.2 插件系统实现
• 四、性能优化与最佳实践
• 4.1 性能优化策略
• 4.2 设计模式与架构建议
• 五、实战应用案例
• 5.1 Web路由系统
• 5.2 数据处理管道
• 总结
• 关键技术回顾
• 实践价值
• 应用建议

在Python编程中，我们经常会遇到需要根据​​运行时条件​​动态调用对象方法的场景。这种能力在框架开发、插件系统、配置驱动编程等高级应用中尤为重要。与传统的硬编码方法调用不同，基于字符串的方法调用提供了极大的​​灵活性​​和​​可扩展性​​，使程序能够适应不断变化的需求。

Python作为一门动态语言，天生支持​​反射​​和​​内省​​机制，允许程序在运行时检查、修改甚至创建新的对象结构。通过字符串形式的方法名调用对象方法，正是这种动态特性的典型体现。无论是简单的脚本工具还是复杂的企业级应用，掌握动态方法调用技术都能显著提升代码的适应性和可维护性。

本文将深入探讨Python中动态方法调用的各种技术，从基础实现到高级应用，结合Python Cookbook的经典内容和实际开发场景，为读者提供一套完整的解决方案。无论您是库开发者、API设计师还是应用程序程序员，这些知识都将帮助您编写更加​​灵活​​和​​强大​​的Python代码。

getattr()是Python中最直接、最常用的动态方法调用工具。它接受一个对象和一个字符串形式的方法名，返回对应的方法引用，然后我们可以像普通函数一样调用它。

class Calculator:
    def add(self, a, b):
        return a + b
    
    def subtract(self, a, b):
        return a - b
    
    def multiply(self, a, b):
        return a * b
    
    def divide(self, a, b):
        if b != 0:
            return a / b
        raise ValueError("除数不能为零")

# 创建计算器实例
calc = Calculator()

# 动态调用方法
method_name = "add"
result = getattr(calc, method_name)(5, 3)
print(f"5 + 3 = {result}")  # 输出: 5 + 3 = 8

method_name = "multiply"
result = getattr(calc, method_name)(4, 6)
print(f"4 × 6 = {result}")  # 输出: 4 × 6 = 24

这种方法的优势在于​​简单直观​​，但需要确保方法名存在且参数匹配。为了增强代码的健壮性，通常结合hasattr()进行存在性检查。

def safe_dynamic_call(obj, method_name, *args, **kwargs):
    """安全地动态调用方法"""
    if hasattr(obj, method_name):
        method = getattr(obj, method_name)
        if callable(method):
            return method(*args, **kwargs)
        else:
            raise AttributeError(f"'{method_name}' 不是可调用方法")
    else:
        raise AttributeError(f"对象没有 '{method_name}' 方法")

# 安全调用示例
try:
    result = safe_dynamic_call(calc, "add", 10, 5)
    print(f"安全调用结果: {result}")
except AttributeError as e:
    print(f"调用失败: {e}")

operator.methodcaller()提供了一种函数式编程风格的动态调用方式。它创建一个可调用对象，该对象在调用时会将参数传递给指定的方法。

import operator

class TextProcessor:
    def __init__(self, text):
        self.text = text
    
    def uppercase(self):
        return self.text.upper()
    
    def lowercase(self):
        return self.text.lower()
    
    def reverse(self):
        return self.text[::-1]

processor = TextProcessor("Hello World")

# 使用methodcaller创建调用器
upper_caller = operator.methodcaller('uppercase')
lower_caller = operator.methodcaller('lowercase')
reverse_caller = operator.methodcaller('reverse')

print(upper_caller(processor))   # 输出: HELLO WORLD
print(lower_caller(processor))   # 输出: hello world
print(reverse_caller(processor)) # 输出: dlroW olleH

operator.methodcaller()特别适合需要​​重复调用​​相同方法但不同参数的场景，如排序操作。

# 在排序中使用methodcaller
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def get_name(self):
        return self.name
    
    def get_age(self):
        return self.age

people = [
    Person("Alice", 25),
    Person("Bob", 30),
    Person("Charlie", 20)
]

# 按年龄排序
people.sort(key=operator.methodcaller('get_age'))
for person in people:
    print(f"{person.name}: {person.age}")

反射是Python动态方法调用的核心机制，它允许程序在运行时检查、访问和修改对象的结构。Python提供了一系列内置函数支持反射操作。

class AdvancedExample:
    def __init__(self, value):
        self.value = value
        self._private_data = "敏感信息"
    
    def public_method(self):
        return f"公共方法: {self.value}"
    
    def _protected_method(self):
        return "受保护的方法"
    
    def __private_method(self):
        return "私有方法"
    
    def dynamic_processor(self, data):
        return f"处理数据: {data}"

# 创建实例
obj = AdvancedExample(42)

# 使用dir()查看所有属性和方法
print("所有属性和方法:")
for attr in dir(obj):
    if not attr.startswith('__'):  # 过滤掉内置特殊方法
        print(f" - {attr}")

# 检查属性存在性
print(f"是否有public_method: {hasattr(obj, 'public_method')}")
print(f"是否有不存在的方法: {hasattr(obj, 'nonexistent')}")

# 动态设置属性
setattr(obj, 'new_attribute', '动态添加的属性')
print(f"新属性: {getattr(obj, 'new_attribute')}")

# 动态调用
if hasattr(obj, 'dynamic_processor'):
    method = getattr(obj, 'dynamic_processor')
    result = method("测试数据")
    print(result)

反射机制使程序能够​​自适应​​不同的对象结构，特别适合框架开发和通用工具的实现。

动态方法调用虽然强大，但也带来了安全风险。不安全的动态调用可能导致​​任意代码执行​​或​​属性泄露​​。因此，实施适当的安全措施至关重要。

class SafeDynamicDispatcher:
    """安全的方法调用分发器"""
    
    def __init__(self, obj, allowed_methods=None):
        self.obj = obj
        # 设置允许调用的方法白名单
        self.allowed_methods = allowed_methods or []
        
        # 自动添加所有公共方法到白名单
        if not self.allowed_methods:
            for attr_name in dir(self.obj):
                attr = getattr(self.obj, attr_name)
                if (callable(attr) and 
                    not attr_name.startswith('_') and 
                    not attr_name.startswith('_')):
                    self.allowed_methods.append(attr_name)
    
    def call_method(self, method_name, *args, **kwargs):
        """安全地调用方法"""
        # 方法名验证
        if not isinstance(method_name, str):
            raise TypeError("方法名必须是字符串")
        
        # 白名单检查
        if method_name not in self.allowed_methods:
            raise PermissionError(f"方法 '{method_name}' 不在允许的调用列表中")
        
        # 存在性检查
        if not hasattr(self.obj, method_name):
            raise AttributeError(f"对象没有 '{method_name}' 方法")
        
        method = getattr(self.obj, method_name)
        
        # 可调用性检查
        if not callable(method):
            raise TypeError(f"'{method_name}' 不是可调用方法")
        
        # 执行调用
        try:
            return method(*args, **kwargs)
        except Exception as e:
            raise RuntimeError(f"方法调用失败: {e}") from e

# 使用安全分发器
calculator = Calculator()
dispatcher = SafeDynamicDispatcher(calculator)

try:
    result = dispatcher.call_method('add', 10, 5)
    print(f"安全调用结果: {result}")
    
    # 尝试调用不存在的方法
    dispatcher.call_method('dangerous_method')
except (PermissionError, AttributeError, RuntimeError) as e:
    print(f"调用失败: {e}")

这种安全模式通过​​白名单机制​​和​​多层验证​​，有效防止了恶意或错误的动态调用。

动态方法调用是实现​​命令模式​​的理想技术。命令模式将请求封装为对象，使我们可以参数化其他对象，并支持请求的排队、记录和撤销。

class CommandProcessor:
    """基于动态方法调用的命令处理器"""
    
    def __init__(self, target_object):
        self.target = target_object
        self.history = []  # 命令历史记录
        self.undo_stack = []  # 撤销栈
    
    def execute_command(self, command_name, *args, **kwargs):
        """执行命令"""
        if not hasattr(self.target, command_name):
            raise ValueError(f"未知命令: {command_name}")
        
        method = getattr(self.target, command_name)
        
        try:
            # 执行命令
            result = method(*args, **kwargs)
            # 记录命令历史
            self.history.append({
                'command': command_name,
                'args': args,
                'kwargs': kwargs,
                'result': result
            })
            return result
        except Exception as e:
            print(f"命令执行失败: {e}")
            raise
    
    def get_command_history(self):
        """获取命令历史"""
        return self.history.copy()
    
    def replay_commands(self, history_records):
        """重放命令序列"""
        results = []
        for record in history_records:
            result = self.execute_command(
                record['command'], 
                *record['args'], 
                **record['kwargs']
            )
            results.append(result)
        return results

# 应用示例
class DocumentEditor:
    def __init__(self):
        self.content = ""
        self.clipboard = ""
    
    def insert_text(self, text, position=None):
        """插入文本"""
        if position is None:
            self.content += text
        else:
            self.content = self.content[:position] + text + self.content[position:]
        return self.content
    
    def delete_text(self, start, end):
        """删除文本"""
        deleted = self.content[start:end]
        self.content = self.content[:start] + self.content[end:]
        return deleted
    
    def copy_text(self, start, end):
        """复制文本"""
        self.clipboard = self.content[start:end]
        return self.clipboard
    
    def paste_text(self, position=None):
        """粘贴文本"""
        if not self.clipboard:
            return self.content
        return self.insert_text(self.clipboard, position)

# 使用命令处理器
editor = DocumentEditor()
processor = CommandProcessor(editor)

# 执行一系列编辑命令
processor.execute_command('insert_text', 'Hello, World!')
processor.execute_command('copy_text', 7, 12)  # 复制"World"
processor.execute_command('insert_text', ' Python', 12)

print(f"最终内容: {editor.content}")
print(f"命令历史: {[cmd['command'] for cmd in processor.get_command_history()]}")

命令模式结合动态调用提供了​​强大的操作序列化​​能力，特别适合需要实现撤销/重做功能的应用程序。

动态方法调用是构建​​插件系统​​的核心技术。通过动态加载和调用插件方法，可以实现高度可扩展的应用程序架构。

import importlib
import inspect
from typing import Dict, List, Any

class PluginManager:
    """基于动态方法调用的插件管理器"""
    
    def __init__(self):
        self.plugins = {}
        self.hooks = {}
    
    def load_plugin(self, plugin_module_name, plugin_class_name):
        """动态加载插件"""
        try:
            # 动态导入模块
            module = importlib.import_module(plugin_module_name)
            # 获取插件类
            plugin_class = getattr(module, plugin_class_name)
            # 创建插件实例
            plugin_instance = plugin_class()
            
            # 注册插件
            self.plugins[plugin_class_name] = plugin_instance
            
            # 自动注册插件方法作为钩子
            self._register_plugin_hooks(plugin_instance, plugin_class_name)
            
            print(f"插件加载成功: {plugin_class_name}")
            return True
            
        except (ImportError, AttributeError) as e:
            print(f"插件加载失败: {e}")
            return False
    
    def _register_plugin_hooks(self, plugin_instance, plugin_name):
        """注册插件钩子方法"""
        for method_name in dir(plugin_instance):
            method = getattr(plugin_instance, method_name)
            
            # 检查是否是钩子方法（以hook_开头）
            if (callable(method) and 
                method_name.startswith('hook_') and 
                not method_name.startswith('__')):
                
                hook_name = method_name[5:]  # 去掉'hook_'前缀
                
                if hook_name not in self.hooks:
                    self.hooks[hook_name] = []
                
                self.hooks[hook_name].append({
                    'plugin': plugin_name,
                    'method': method
                })
                
                print(f"注册钩子: {hook_name} -> {plugin_name}.{method_name}")
    
    def call_hook(self, hook_name, *args, **kwargs):
        """调用钩子方法"""
        if hook_name not in self.hooks:
            print(f"警告: 未找到钩子 '{hook_name}'")
            return []
        
        results = []
        for hook in self.hooks[hook_name]:
            try:
                result = hook['method'](*args, **kwargs)
                results.append({
                    'plugin': hook['plugin'],
                    'result': result
                })
            except Exception as e:
                print(f"钩子执行失败 {hook['plugin']}.{hook_name}: {e}")
        
        return results

# 插件基类
class BasePlugin:
    """插件基类"""
    
    def __init__(self):
        self.name = self.__class__.__name__
    
    def plugin_init(self):
        """插件初始化方法"""
        pass
    
    def plugin_cleanup(self):
        """插件清理方法"""
        pass

# 示例插件
class TextFilterPlugin(BasePlugin):
    """文本过滤插件"""
    
    def hook_text_process(self, text):
        """文本处理钩子"""
        # 简单的文本过滤逻辑
        filtered_text = text.replace('不良词汇', '***')
        return filtered_text
    
    def hook_text_analyze(self, text):
        """文本分析钩子"""
        word_count = len(text.split())
        return {'word_count': word_count}

class FormatPlugin(BasePlugin):
    """格式处理插件"""
    
    def hook_text_format(self, text):
        """文本格式化钩子"""
        return text.upper()

# 使用插件系统
def main():
    manager = PluginManager()
    
    # 加载插件
    manager.load_plugin(__name__, 'TextFilterPlugin')  # 加载当前模块的插件
    manager.load_plugin(__name__, 'FormatPlugin')
    
    # 处理文本
    sample_text = "这是一个包含不良词汇的测试文本"
    
    # 调用文本处理钩子
    processed_results = manager.call_hook('text_process', sample_text)
    for result in processed_results:
        print(f"{result['plugin']} 处理结果: {result['result']}")
    
    # 调用文本分析钩子
    analysis_results = manager.call_hook('text_analyze', sample_text)
    for result in analysis_results:
        print(f"{result['plugin']} 分析结果: {result['result']}")

if __name__ == "__main__":
    main()

这种插件架构通过动态方法调用实现了​​高度解耦​​和​​可扩展性​​，新功能的添加只需实现新的插件类，无需修改主程序代码。

虽然动态方法调用提供了灵活性，但可能带来性能开销。在性能敏感的场景中，需要采取优化措施。

import time
from functools import lru_cache

class OptimizedDynamicCaller:
    """性能优化的动态调用器"""
    
    def __init__(self, obj):
        self.obj = obj
        self._method_cache = {}
        self._attribute_cache = {}
    
    @lru_cache(maxsize=128)
    def get_cached_method(self, method_name):
        """缓存方法查找结果"""
        if hasattr(self.obj, method_name):
            method = getattr(self.obj, method_name)
            if callable(method):
                return method
        return None
    
    def call_method(self, method_name, *args, **kwargs):
        """优化的方法调用"""
        # 首先尝试缓存
        method = self.get_cached_method(method_name)
        
        if method is None:
            # 缓存未命中，重新查找
            if not hasattr(self.obj, method_name):
                raise AttributeError(f"方法不存在: {method_name}")
            
            method = getattr(self.obj, method_name)
            if not callable(method):
                raise TypeError(f"不是可调用方法: {method_name}")
        
        return method(*args, **kwargs)

class PerformanceCriticalClass:
    def method1(self, x):
        return x * 2
    
    def method2(self, x, y):
        return x + y

# 性能对比测试
obj = PerformanceCriticalClass()
optimized_caller = OptimizedDynamicCaller(obj)

# 测试标准getattr性能
start_time = time.time()
for i in range(10000):
    getattr(obj, 'method1')(i)
standard_time = time.time() - start_time

# 测试优化调用器性能
start_time = time.time()
for i in range(10000):
    optimized_caller.call_method('method1', i)
optimized_time = time.time() - start_time

print(f"标准getattr耗时: {standard_time:.4f}秒")
print(f"优化调用器耗时: {optimized_time:.4f}秒")
print(f"性能提升: {standard_time/optimized_time:.2f}倍")

通过​​方法缓存​​和​​预验证​​等技术，可以显著降低动态调用的性能开销。

在实际项目中应用动态方法调用时，遵循适当的设计模式和架构原则至关重要。

​​工厂模式与动态调用结合​​

class DynamicFactory:
    """基于动态调用的对象工厂"""
    
    def __init__(self):
        self.creators = {}
    
    def register_creator(self, product_type, creator_method):
        """注册创建器"""
        self.creators[product_type] = creator_method
    
    def create_product(self, product_type, *args, **kwargs):
        """动态创建产品"""
        if product_type not in self.creators:
            raise ValueError(f"未知产品类型: {product_type}")
        
        creator = self.creators[product_type]
        return creator(*args, **kwargs)
    
    def create_from_config(self, config):
        """根据配置动态创建对象"""
        product_type = config.get('type')
        init_args = config.get('args', [])
        init_kwargs = config.get('kwargs', {})
        
        return self.create_product(product_type, *init_args, **init_kwargs)

# 使用示例
class ProductA:
    def __init__(self, name):
        self.name = name
    
    def operate(self):
        return f"ProductA操作: {self.name}"

class ProductB:
    def __init__(self, value, multiplier=1):
        self.value = value * multiplier
    
    def operate(self):
        return f"ProductB操作: {self.value}"

# 配置驱动创建
factory = DynamicFactory()
factory.register_creator('product_a', ProductA)
factory.register_creator('product_b', ProductB)

# 根据配置动态创建
configs = [
    {'type': 'product_a', 'args': ['测试产品']},
    {'type': 'product_b', 'kwargs': {'value': 10, 'multiplier': 2}}
]

products = []
for config in configs:
    product = factory.create_from_config(config)
    products.append(product)

for product in products:
    print(product.operate())

这种模式将​​配置与代码分离​​，使系统更加灵活和可配置。

动态方法调用在Web框架的路由系统中有着重要应用，可以实现请求URL到处理方法的动态映射。

class WebRouter:
    """简单的Web路由系统"""
    
    def __init__(self):
        self.routes = {}
        self.error_handlers = {}
    
    def route(self, path, methods=None):
        """路由装饰器"""
        methods = methods or ['GET']
        
        def decorator(handler):
            if path not in self.routes:
                self.routes[path] = {}
            for method in methods:
                self.routes[path][method.upper()] = handler
            return handler
        return decorator
    
    def error_handler(self, status_code):
        """错误处理装饰器"""
        def decorator(handler):
            self.error_handlers[status_code] = handler
            return handler
        return decorator
    
    def handle_request(self, path, method='GET', **params):
        """处理请求"""
        method = method.upper()
        
        # 查找路由处理器
        if path in self.routes and method in self.routes[path]:
            handler = self.routes[path][method]
            try:
                return handler(**params)
            except Exception as e:
                # 处理内部错误
                if 500 in self.error_handlers:
                    return self.error_handlers[500](e)
                raise
        else:
            # 处理404错误
            if 404 in self.error_handlers:
                return self.error_handlers[404](path)
            return f"404 Not Found: {path}"

# 创建路由实例
router = WebRouter()

@router.route('/')
def index_handler():
    return "欢迎访问首页"

@router.route('/user', methods=['GET', 'POST'])
def user_handler():
    return "用户页面"

@router.route('/user/<user_id>')
def user_detail_handler(user_id):
    return f"用户详情: {user_id}"

@router.error_handler(404)
def not_found_handler(path):
    return f"页面未找到: {path}"

@router.error_handler(500)
def internal_error_handler(error):
    return f"服务器内部错误: {error}"

# 模拟请求处理
print(router.handle_request('/'))
print(router.handle_request('/user', 'POST'))
print(router.handle_request('/user/123'))
print(router.handle_request('/unknown'))

这种路由系统通过动态方法调用实现了​​灵活的请求处理​​，是现代Web框架的核心组件。

动态方法调用可以用于构建灵活的数据处理管道，其中每个处理步骤都可以动态配置和组合。

class DataPipeline:
    """可配置的数据处理管道"""
    
    def __init__(self):
        self.processors = []
        self.context = {}
    
    def add_processor(self, processor_name, *args, **kwargs):
        """添加处理器"""
        self.processors.append({
            'name': processor_name,
            'args': args,
            'kwargs': kwargs
        })
        return self  # 支持链式调用
    
    def set_context(self, key, value):
        """设置处理上下文"""
        self.context[key] = value
        return self
    
    def execute(self, data):
        """执行数据处理管道"""
        current_data = data
        
        for processor_config in self.processors:
            processor_name = processor_config['name']
            
            # 动态获取处理器方法
            if not hasattr(self, processor_name):
                raise AttributeError(f"未知处理器: {processor_name}")
            
            processor_method = getattr(self, processor_name)
            
            # 准备参数
            args = processor_config['args']
            kwargs = processor_config['kwargs']
            
            # 执行处理
            try:
                current_data = processor_method(current_data, *args, **kwargs)
                self.context['last_result'] = current_data
            except Exception as e:
                print(f"处理器执行失败 {processor_name}: {e}")
                raise
        
        return current_data
    
    # 定义各种处理器方法
    def filter_empty(self, data):
        """过滤空值"""
        if isinstance(data, list):
            return [item for item in data if item not in [None, '', []]]
        return data
    
    def transform_uppercase(self, data):
        """转换为大写"""
        if isinstance(data, str):
            return data.upper()
        elif isinstance(data, list):
            return [item.upper() if isinstance(item, str) else item for item in data]
        return data
    
    def calculate_statistics(self, data):
        """计算统计信息"""
        if isinstance(data, list):
            stats = {
                'count': len(data),
                'sum': sum(data) if all(isinstance(x, (int, float)) for x in data) else None,
                'average': sum(data)/len(data) if all(isinstance(x, (int, float)) for x in data) else None
            }
            return stats
        return data

# 使用数据处理管道
pipeline = DataPipeline()

# 构建处理流程
result = (pipeline
    .add_processor('filter_empty')
    .add_processor('transform_uppercase')
    .set_context('source', 'dynamic_pipeline')
    .execute(['hello', '', 'world', None, 'python']))

print(f"处理结果: {result}")

# 数值数据处理
numbers = [1, 2, 3, 4, 5]
stats = (DataPipeline()
    .add_processor('calculate_statistics')
    .execute(numbers))

print(f"统计结果: {stats}")

这种管道模式通过动态方法调用实现了​​高度可配置的数据处理流程​​，每个处理步骤都可以独立开发和测试。

Python中基于字符串的动态方法调用是一项​​强大而灵活​​的技术，它充分利用了语言的动态特性，为各种高级编程场景提供了解决方案。通过本文的探讨，我们系统学习了从基础实现到高级应用的全套技术方案。

​​基础调用机制​​：getattr()和operator.methodcaller()提供了最直接的动态调用方式

​​反射与内省​​：通过hasattr()、getattr()、setattr()等函数实现运行时对象操作

​​安全模式​​：白名单验证、参数检查和异常处理确保动态调用的安全性

​​高级应用模式​​：命令模式、插件系统、Web路由等实际应用场景

​​性能优化​​：方法缓存、预验证等技术降低动态调用的开销

​​架构设计​​：工厂模式、管道处理等架构层面的最佳实践

掌握动态方法调用技术带来的主要好处包括：

• ​​代码灵活性​​：运行时决定调用逻辑，适应变化的需求
• ​​架构可扩展性​​：插件系统和模块化设计使系统易于扩展
• ​​配置驱动开发​​：将行为配置外部化，提高系统可维护性
• ​​框架开发能力​​：为高级库和框架开发奠定技术基础

在实际项目中应用动态方法调用时，建议：

• ​​谨慎使用​​：在确实需要动态性的场景使用，避免过度工程
• ​​安全第一​​：实施适当的安全措施，防止任意代码执行
• ​​性能考量​​：在性能敏感场景进行优化，避免不必要的开销
• ​​文档完善​​：为动态接口提供清晰的文档和使用示例

动态方法调用体现了Python的​​动态语言特性​​和​​元编程能力​​，是高级Python开发的重要技术。通过合理运用本文介绍的技术，您将能够构建更加​​灵活​​、​​可扩展​​的Python应用程序，解决复杂的软件开发挑战。

​​进一步学习方向​​：

• 深入理解Python描述符协议和属性访问机制
• 研究元编程和元类在动态调用中的高级应用
• 探索异步编程中的动态方法调用模式
• 学习大型开源项目中动态调用的实际应用案例

掌握动态方法调用技术将使您从Python使用者转变为​​架构师​​，能够设计出适应复杂需求的高质量软件系统。

到此这篇关于深入详解Python中动态方法调用的各种方法的文章就介绍到这了,更多相关Python动态方法调用内容请搜索风君子博客以前的文章或继续浏览下面的相关文章希望大家以后多多支持风君子博客！

您可能感兴趣的文章:

• Python 动态变量名定义与调用方法
• Python调用C/C++动态链接库的方法详解
• 从基础到高级详解Python中调用父类方法的完全指南
• Python处理函数调用超时方法的详细教学
• Python如何调用另一个类的方法和属性
• Python跨文件调用函数的五种实用方法
• Python处理函数调用超时的四种方法