Maya Python 性能优化指南

import maya.cmds as cmds
 
# 简单但在循环中会很慢
for i in range(1000):
    pos = cmds.xform(f"obj_{i}", query=True, worldSpace=True, translation=True)

# ========== 使用 maya.cmds (慢) ==========
import maya.cmds as cmds
import time
 
start = time.time()
positions = []
for i in range(5000):
    pos = cmds.xform(f"pSphere1.vtx[{i}]", query=True, worldSpace=True, translation=True)
    positions.append(pos)
print(f"cmds 耗时: {time.time() - start:.2f}秒")
 
# ========== 使用 maya.api.OpenMaya (快) ==========
import maya.api.OpenMaya as om
import time
 
start = time.time()
 
# 获取 mesh
sel = om.MSelectionList()
sel.add("pSphere1")
dag_path = sel.getDagPath(0)
mesh_fn = om.MFnMesh(dag_path)
 
# 一次性获取所有顶点位置
positions = mesh_fn.getPoints(om.MSpace.kWorld)
print(f"API 2.0 耗时: {time.time() - start:.2f}秒")

import maya.cmds as cmds
import maya.api.OpenMaya as om
 
def optimize_skincluster_weights(mesh_name, skin_cluster):
    """
    优化蒙皮权重的混合策略示例
    """
    # 使用 cmds 进行简单的查询和 UI 操作
    if not cmds.objExists(mesh_name):
        cmds.warning(f"{mesh_name} 不存在")
        return
    
    # 使用 API 2.0 进行密集的数据处理
    sel = om.MSelectionList()
    sel.add(skin_cluster)
    sel.add(mesh_name)
    
    skin_obj = sel.getDependNode(0)
    mesh_dag = sel.getDagPath(1)
    
    skin_fn = om.MFnSkinCluster(skin_obj)
    
    # 批量获取权重
    mesh_fn = om.MFnMesh(mesh_dag)
    comp_fn = om.MFnSingleIndexedComponent()
    vert_comp = comp_fn.create(om.MFn.kMeshVertComponent)
    comp_fn.setCompleteData(mesh_fn.numVertices)
    
    weights, num_influences = skin_fn.getWeights(mesh_dag, vert_comp)
    
    # ... 处理权重数据 ...
    
    # 使用 cmds 创建 UI 反馈
    cmds.confirmDialog(title="完成", message=f"处理了 {mesh_fn.numVertices} 个顶点")

import maya.cmds as cmds
 
# ========== 不推荐：每次操作都刷新视口 ==========
def create_cubes_slow(count):
    for i in range(count):
        cmds.polyCube(name=f"cube_{i}")
        cmds.move(i * 2, 0, 0)
 
# ========== 推荐：暂停视口刷新 ==========
def create_cubes_fast(count):
    cmds.refresh(suspend=True)
    try:
        for i in range(count):
            cmds.polyCube(name=f"cube_{i}")
            cmds.move(i * 2, 0, 0)
    finally:
        cmds.refresh(suspend=False)
        cmds.refresh()  # 强制刷新一次
 
# 使用上下文管理器（更优雅）
from contextlib import contextmanager
 
@contextmanager
def suspend_refresh():
    """暂停视口刷新的上下文管理器"""
    cmds.refresh(suspend=True)
    try:
        yield
    finally:
        cmds.refresh(suspend=False)
        cmds.refresh()
 
# 使用方式
with suspend_refresh():
    for i in range(1000):
        cmds.polyCube(name=f"cube_{i}")

import maya.cmds as cmds
 
# ========== 不推荐：每次操作都记录撤销 ==========
def batch_operation_slow():
    for i in range(10000):
        cmds.setAttr(f"obj_{i}.translateX", i * 0.1)
 
# ========== 推荐：批量操作作为单个撤销块 ==========
def batch_operation_chunk():
    cmds.undoInfo(openChunk=True)
    try:
        for i in range(10000):
            cmds.setAttr(f"obj_{i}.translateX", i * 0.1)
    finally:
        cmds.undoInfo(closeChunk=True)
 
# ========== 更激进：完全暂停撤销 ==========
def batch_operation_no_undo():
    cmds.undoInfo(stateWithoutFlush=False)
    try:
        for i in range(10000):
            cmds.setAttr(f"obj_{i}.translateX", i * 0.1)
    finally:
        cmds.undoInfo(stateWithoutFlush=True)
 
# 上下文管理器版本
@contextmanager
def suspend_undo():
    """暂停撤销的上下文管理器"""
    cmds.undoInfo(stateWithoutFlush=False)
    try:
        yield
    finally:
        cmds.undoInfo(stateWithoutFlush=True)
 
# 单个撤销块的上下文管理器
@contextmanager
def undo_chunk(chunk_name="operation"):
    """将操作合并为单个撤销块"""
    cmds.undoInfo(openChunk=True, chunkName=chunk_name)
    try:
        yield
    finally:
        cmds.undoInfo(closeChunk=True)
 
# 使用方式
with suspend_undo():
    # 这些操作不会被记录到撤销队列
    for i in range(10000):
        cmds.setAttr(f"obj_{i}.translateX", i * 0.1)

from contextlib import contextmanager
import maya.cmds as cmds
 
@contextmanager
def batch_context(suspend_refresh=True, suspend_undo=True, restore_selection=True):
    """
    批处理操作的综合上下文管理器
    
    Args:
        suspend_refresh: 是否暂停视口刷新
        suspend_undo: 是否暂停撤销队列
        restore_selection: 是否恢复操作前的选择
    """
    # 保存当前状态
    prev_selection = cmds.ls(selection=True) if restore_selection else []
    
    # 暂停刷新
    if suspend_refresh:
        cmds.refresh(suspend=True)
    
    # 暂停撤销
    if suspend_undo:
        cmds.undoInfo(stateWithoutFlush=False)
    
    try:
        yield
    finally:
        # 恢复撤销
        if suspend_undo:
            cmds.undoInfo(stateWithoutFlush=True)
        
        # 恢复刷新
        if suspend_refresh:
            cmds.refresh(suspend=False)
            cmds.refresh()
        
        # 恢复选择
        if restore_selection and prev_selection:
            cmds.select(prev_selection, replace=True)
 
# 使用示例
with batch_context():
    for i in range(5000):
        cmds.polyCube(name=f"cube_{i}")
        cmds.move(i * 2, 0, 0)

import maya.api.OpenMaya as om
import maya.cmds as cmds
 
# ========== 慢：逐顶点访问 ==========
def get_vertex_positions_slow(mesh_name):
    positions = []
    vertex_count = cmds.polyEvaluate(mesh_name, vertex=True)
    for i in range(vertex_count):
        pos = cmds.xform(f"{mesh_name}.vtx[{i}]", query=True, worldSpace=True, translation=True)
        positions.append(pos)
    return positions
 
# ========== 快：批量访问 ==========
def get_vertex_positions_fast(mesh_name):
    sel = om.MSelectionList()
    sel.add(mesh_name)
    dag_path = sel.getDagPath(0)
    mesh_fn = om.MFnMesh(dag_path)
    
    # 一次性获取所有顶点位置
    positions = mesh_fn.getPoints(om.MSpace.kWorld)
    return positions

import maya.api.OpenMaya as om
 
def iterate_vertices_api(mesh_name):
    """使用 API 2.0 迭代器遍历顶点"""
    sel = om.MSelectionList()
    sel.add(mesh_name)
    dag_path = sel.getDagPath(0)
    
    # 创建顶点迭代器
    vert_iter = om.MItMeshVertex(dag_path)
    
    results = []
    while not vert_iter.isDone():
        # 获取当前顶点信息
        vertex_id = vert_iter.index()
        position = vert_iter.position(om.MSpace.kWorld)
        normal = vert_iter.getNormal()
        
        results.append({
            'id': vertex_id,
            'position': position,
            'normal': normal
        })
        
        vert_iter.next()
    
    return results
 
def iterate_edges_api(mesh_name):
    """使用 API 2.0 迭代器遍历边"""
    sel = om.MSelectionList()
    sel.add(mesh_name)
    dag_path = sel.getDagPath(0)
    
    edge_iter = om.MItMeshEdge(dag_path)
    
    edge_lengths = []
    while not edge_iter.isDone():
        length = edge_iter.length()
        edge_lengths.append(length)
        edge_iter.next()
    
    return edge_lengths

import maya.api.OpenMaya as om
import maya.cmds as cmds
 
# ========== 慢：逐顶点设置位置 ==========
def set_positions_slow(mesh_name, new_positions):
    for i, pos in enumerate(new_positions):
        cmds.xform(f"{mesh_name}.vtx[{i}]", worldSpace=True, translation=pos)
 
# ========== 快：批量设置位置 ==========
def set_positions_fast(mesh_name, new_positions):
    sel = om.MSelectionList()
    sel.add(mesh_name)
    dag_path = sel.getDagPath(0)
    mesh_fn = om.MFnMesh(dag_path)
    
    # 将 Python 列表转换为 MPointArray
    point_array = om.MPointArray(new_positions)
    
    # 一次性设置所有顶点位置
    mesh_fn.setPoints(point_array, om.MSpace.kWorld)

import maya.cmds as cmds
import maya.api.OpenMaya as om
import maya.api.OpenMayaAnim as oma
 
# ========== 慢：使用 cmds.skinPercent 逐顶点获取 ==========
def get_skin_weights_slow(mesh_name, skin_cluster):
    """
    对于 10,000 顶点的模型，可能需要 30-60 秒
    """
    joints = cmds.skinCluster(skin_cluster, query=True, influence=True)
    vertex_count = cmds.polyEvaluate(mesh_name, vertex=True)
    
    all_weights = []
    for i in range(vertex_count):
        vtx = f"{mesh_name}.vtx[{i}]"
        weights = {}
        for jnt in joints:
            weight = cmds.skinPercent(skin_cluster, vtx, query=True, transform=jnt)
            weights[jnt] = weight
        all_weights.append(weights)
    
    return all_weights
 
# ========== 快：使用 API 2.0 批量获取 ==========
def get_skin_weights_fast(mesh_name, skin_cluster):
    """
    对于 10,000 顶点的模型，通常只需要 0.1-0.5 秒
    性能提升：100-300 倍
    """
    sel = om.MSelectionList()
    sel.add(skin_cluster)
    sel.add(mesh_name)
    
    skin_obj = sel.getDependNode(0)
    mesh_dag = sel.getDagPath(1)
    
    skin_fn = oma.MFnSkinCluster(skin_obj)
    
    # 创建包含所有顶点的组件
    mesh_fn = om.MFnMesh(mesh_dag)
    vert_count = mesh_fn.numVertices
    
    comp_fn = om.MFnSingleIndexedComponent()
    vert_comp = comp_fn.create(om.MFn.kMeshVertComponent)
    comp_fn.setCompleteData(vert_count)
    
    # 批量获取权重
    weights, num_influences = skin_fn.getWeights(mesh_dag, vert_comp)
    
    # 将一维数组转换为二维结构
    weights_2d = []
    for i in range(vert_count):
        start_idx = i * num_influences
        end_idx = start_idx + num_influences
        vert_weights = list(weights[start_idx:end_idx])
        weights_2d.append(vert_weights)
    
    # 获取影响对象名称
    influence_objects = skin_fn.influenceObjects()
    influence_names = [om.MFnDagNode(obj).partialPathName() for obj in influence_objects]
    
    return weights_2d, influence_names

# ========== 慢：使用 cmds.skinPercent 逐顶点设置 ==========
def set_skin_weights_slow(mesh_name, skin_cluster, weights_data):
    for i, weights in enumerate(weights_data):
        vtx = f"{mesh_name}.vtx[{i}]"
        transform_values = [(jnt, weight) for jnt, weight in weights.items()]
        cmds.skinPercent(skin_cluster, vtx, transformValue=transform_values)
 
# ========== 快：使用 API 2.0 批量设置 ==========
def set_skin_weights_fast(mesh_name, skin_cluster, weights_2d, influence_names=None):
    """
    weights_2d: 二维权重数组 [[w1, w2, w3...], [w1, w2, w3...], ...]
    influence_names: 影响对象名称列表（可选）
    """
    sel = om.MSelectionList()
    sel.add(skin_cluster)
    sel.add(mesh_name)
    
    skin_obj = sel.getDependNode(0)
    mesh_dag = sel.getDagPath(1)
    
    skin_fn = oma.MFnSkinCluster(skin_obj)
    
    # 创建组件
    mesh_fn = om.MFnMesh(mesh_dag)
    comp_fn = om.MFnSingleIndexedComponent()
    vert_comp = comp_fn.create(om.MFn.kMeshVertComponent)
    comp_fn.setCompleteData(mesh_fn.numVertices)
    
    # 将二维数组展平为一维
    flat_weights = []
    for vert_weights in weights_2d:
        flat_weights.extend(vert_weights)
    
    # 转换为 MDoubleArray
    weight_array = om.MDoubleArray(flat_weights)
    
    # 批量设置权重
    skin_fn.setWeights(mesh_dag, vert_comp, om.MIntArray(), weight_array, normalize=True)

import maya.cmds as cmds
 
# ========== 不推荐：重复查询 ==========
def process_meshes_slow():
    all_meshes = cmds.ls(type='mesh')
    for mesh in all_meshes:
        if cmds.objExists(mesh):  # 重复查询
            if cmds.nodeType(mesh) == 'mesh':  # 已经知道是 mesh 了
                parent = cmds.listRelatives(mesh, parent=True)[0]
                # ... 更多操作
 
# ========== 推荐：缓存结果 ==========
def process_meshes_fast():
    all_meshes = cmds.ls(type='mesh', long=True)  # 使用长名称避免歧义
    
    for mesh in all_meshes:
        # 已经通过 ls 查询到，不需要再检查存在
        parent = cmds.listRelatives(mesh, parent=True, fullPath=True)
        if not parent:
            continue
        parent = parent[0]
        # ... 更多操作

import maya.cmds as cmds
 
# ========== 不推荐：获取所有信息 ==========
def get_transform_info_slow(obj):
    # cmds.xform 默认会查询大量信息
    all_info = cmds.xform(obj, query=True)
    translation = cmds.xform(obj, query=True, worldSpace=True, translation=True)
    rotation = cmds.xform(obj, query=True, worldSpace=True, rotation=True)
    scale = cmds.xform(obj, query=True, worldSpace=True, scale=True)
    return translation, rotation, scale
 
# ========== 推荐：精确查询 ==========
def get_transform_info_fast(obj):
    # 只查询需要的信息，一次性查询
    translation = cmds.xform(obj, q=True, ws=True, t=True)
    rotation = cmds.xform(obj, q=True, ws=True, ro=True)
    scale = cmds.xform(obj, q=True, ws=True, s=True)
    return translation, rotation, scale

import maya.cmds as cmds
 
# ========== 不推荐：多次选择操作 ==========
def select_objects_slow(objects):
    cmds.select(clear=True)
    for obj in objects:
        cmds.select(obj, add=True)
 
# ========== 推荐：一次性选择 ==========
def select_objects_fast(objects):
    if objects:
        cmds.select(objects, replace=True)
    else:
        cmds.select(clear=True)

# ========== 不推荐：使用列表进行成员检查 ==========
def find_duplicates_slow(objects):
    seen = []  # 列表的 'in' 操作是 O(n)
    duplicates = []
    
    for obj in objects:
        if obj in seen:  # 每次都要遍历整个列表
            duplicates.append(obj)
        else:
            seen.append(obj)
    
    return duplicates
 
# ========== 推荐：使用集合 ==========
def find_duplicates_fast(objects):
    seen = set()  # 集合的 'in' 操作是 O(1)
    duplicates = []
    
    for obj in objects:
        if obj in seen:
            duplicates.append(obj)
        else:
            seen.add(obj)
    
    return duplicates
 
# ========== 更好：使用 Counter ==========
from collections import Counter
 
def find_duplicates_best(objects):
    counts = Counter(objects)
    return [obj for obj, count in counts.items() if count > 1]

import maya.cmds as cmds
 
# ========== 不推荐：循环中的字符串拼接 ==========
def create_hierarchy_slow(count):
    for i in range(count):
        # 字符串格式化在 Python 2.x 中相对较慢
        name = "obj_" + str(i)
        cmds.createNode("transform", name=name)
 
# ========== 推荐：使用 f-string (Python 3.6+) ==========
def create_hierarchy_fast(count):
    for i in range(count):
        name = f"obj_{i}"
        cmds.createNode("transform", name=name)
 
# ========== 或者使用 .format() ==========
def create_hierarchy_format(count):
    for i in range(count):
        name = "obj_{}".format(i)
        cmds.createNode("transform", name=name)

import maya.cmds as cmds
 
# ========== 较慢：append 到列表 ==========
def collect_positions_slow(objects):
    positions = []
    for obj in objects:
        pos = cmds.xform(obj, q=True, ws=True, t=True)
        positions.append(pos)
    return positions
 
# ========== 较快：列表推导 ==========
def collect_positions_fast(objects):
    return [cmds.xform(obj, q=True, ws=True, t=True) for obj in objects]
 
# ========== 当需要条件过滤时 ==========
def collect_visible_positions(objects):
    return [
        cmds.xform(obj, q=True, ws=True, t=True) 
        for obj in objects 
        if cmds.getAttr(f"{obj}.visibility")
    ]

import timeit
import maya.cmds as cmds
 
# 测试单次执行时间
def test_function():
    cmds.polyCube()
    cmds.delete(cmds.ls(type='polyCube'))
 
# 执行 100 次并计算平均时间
time_taken = timeit.timeit(test_function, number=100)
print(f"平均执行时间: {time_taken/100:.4f} 秒")

import time
from contextlib import contextmanager
 
@contextmanager
def timer(name="操作"):
    """简单的计时上下文管理器"""
    start = time.time()
    yield
    elapsed = time.time() - start
    print(f"{name} 耗时: {elapsed:.4f} 秒")
 
# 使用方式
with timer("创建 1000 个立方体"):
    for i in range(1000):
        cmds.polyCube()

import cProfile
import pstats
import io
 
def profile_function(func, *args, **kwargs):
    """
    分析函数的性能
    """
    profiler = cProfile.Profile()
    profiler.enable()
    
    result = func(*args, **kwargs)
    
    profiler.disable()
    
    # 输出统计信息
    s = io.StringIO
 
 
```python
import cProfile
import pstats
import io
 
def profile_function(func, *args, **kwargs):
    """
    分析函数的性能
    """
    profiler = cProfile.Profile()
    profiler.enable()
    
    result = func(*args, **kwargs)
    
    profiler.disable()
    
    # 输出统计信息
    s = io.StringIO()
    ps = pstats.Stats(profiler, stream=s)
    ps.sort_stats('cumulative')  # 按累计时间排序
    ps.print_stats(20)  # 打印前 20 个最慢的函数
    
    print(s.getvalue())
    return result
 
# 使用示例
def my_slow_function():
    import maya.cmds as cmds
    for i in range(1000):
        cmds.polyCube()
        cmds.move(i, 0, 0)
 
profile_function(my_slow_function)

import time
import functools
 
def performance_monitor(func):
    """
    装饰器：监控函数执行时间
    """
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start = time.time()
        result = func(*args, **kwargs)
        elapsed = time.time() - start
        print(f"{func.__name__} 执行时间: {elapsed:.4f} 秒")
        return result
    return wrapper
 
# 使用方式
@performance_monitor
def create_many_cubes(count):
    import maya.cmds as cmds
    for i in range(count):
        cmds.polyCube(name=f"cube_{i}")
 
create_many_cubes(100)
# 输出: create_many_cubes 执行时间: 2.3456 秒

import maya.cmds as cmds
 
# 启动 Maya Profiler
cmds.profiler(sampling=True)
 
# 执行要分析的代码
for i in range(1000):
    cmds.polyCube()
 
# 停止 profiler 并保存结果
cmds.profiler(sampling=False)
 
# 在 Maya 中打开 Profiler 窗口查看结果
# Windows > General Editors > Profiler

# 在 Maya 的 Python 环境中安装 NumPy (如果没有)
# mayapy -m pip install numpy
 
import numpy as np
import maya.api.OpenMaya as om

import maya.api.OpenMaya as om
import maya.cmds as cmds
import numpy as np
 
# ========== 不使用 NumPy（较慢）==========
def offset_vertices_slow(mesh_name, offset):
    """将所有顶点沿法线方向偏移"""
    sel = om.MSelectionList()
    sel.add(mesh_name)
    dag_path = sel.getDagPath(0)
    mesh_fn = om.MFnMesh(dag_path)
    
    positions = mesh_fn.getPoints(om.MSpace.kWorld)
    normals = mesh_fn.getVertexNormals(False, om.MSpace.kWorld)
    
    new_positions = []
    for i, pos in enumerate(positions):
        normal = normals[i]
        new_pos = om.MPoint(
            pos.x + normal.x * offset,
            pos.y + normal.y * offset,
            pos.z + normal.z * offset
        )
        new_positions.append(new_pos)
    
    mesh_fn.setPoints(new_positions, om.MSpace.kWorld)
 
# ========== 使用 NumPy（快得多）==========
def offset_vertices_fast(mesh_name, offset):
    """使用 NumPy 向量化操作"""
    sel = om.MSelectionList()
    sel.add(mesh_name)
    dag_path = sel.getDagPath(0)
    mesh_fn = om.MFnMesh(dag_path)
    
    # 获取数据
    positions = mesh_fn.getPoints(om.MSpace.kWorld)
    normals = mesh_fn.getVertexNormals(False, om.MSpace.kWorld)
    
    # 转换为 NumPy 数组
    pos_array = np.array([[p.x, p.y, p.z] for p in positions])
    norm_array = np.array([[n.x, n.y, n.z] for n in normals])
    
    # 向量化操作（快得多）
    new_pos_array = pos_array + norm_array * offset
    
    # 转换回 MPointArray
    new_positions = om.MPointArray([
        om.MPoint(p[0], p[1], p[2]) 
        for p in new_pos_array
    ])
    
    mesh_fn.setPoints(new_positions, om.MSpace.kWorld)

import numpy as np
import maya.api.OpenMaya as om
import maya.api.OpenMayaAnim as oma
 
def normalize_weights_numpy(weights_2d):
    """
    使用 NumPy 归一化蒙皮权重
    
    Args:
        weights_2d: 二维权重数组 [[w1, w2, w3...], ...]
    
    Returns:
        归一化后的权重数组
    """
    # 转换为 NumPy 数组
    weights_np = np.array(weights_2d)
    
    # 计算每行的和
    row_sums = weights_np.sum(axis=1, keepdims=True)
    
    # 避免除以零
    row_sums[row_sums == 0] = 1.0
    
    # 归一化
    normalized = weights_np / row_sums
    
    return normalized.tolist()
 
def smooth_weights_numpy(weights_2d, iterations=1):
    """
    使用 NumPy 平滑权重
    """
    weights_np = np.array(weights_2d)
    
    for _ in range(iterations):
        # 简单的平滑算法：每个顶点的权重与邻居权重的平均
        smoothed = np.copy(weights_np)
        for i in range(1, len(weights_np) - 1):
            smoothed[i] = (weights_np[i-1] + weights_np[i] + weights_np[i+1]) / 3.0
        weights_np = smoothed
    
    return weights_np.tolist()

from concurrent.futures import ThreadPoolExecutor, as_completed
import maya.cmds as cmds
import maya.utils as utils
 
def process_mesh(mesh_name):
    """处理单个 mesh 的函数"""
    # 必须在主线程执行的 Maya 命令
    def maya_operation():
        vert_count = cmds.polyEvaluate(mesh_name, vertex=True)
        # ... 更多操作
        return vert_count
    
    # 使用 maya.utils.executeInMainThreadWithResult 确保在主线程执行
    result = utils.executeInMainThreadWithResult(maya_operation)
    return mesh_name, result
 
def process_all_meshes_parallel(mesh_list, max_workers=4):
    """
    并行处理多个 meshes
    
    注意：由于 Maya 的线程限制，实际性能提升可能有限
    """
    results = {}
    
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        # 提交所有任务
        future_to_mesh = {
            executor.submit(process_mesh, mesh): mesh 
            for mesh in mesh_list
        }
        
        # 收集结果
        for future in as_completed(future_to_mesh):
            mesh_name, result = future.result()
            results[mesh_name] = result
    
    return results

from multiprocessing import Pool
import numpy as np
 
def compute_intensive_task(data):
    """
    CPU 密集型任务，不涉及 Maya API 调用
    例如：复杂的数学计算、数据处理等
    """
    # 使用 NumPy 进行计算
    result = np.sqrt(np.sum(np.array(data) ** 2))
    return result
 
def parallel_compute(data_list, processes=4):
    """
    使用多进程进行并行计算
    
    注意：只适用于不需要访问 Maya 场景的纯计算任务
    """
    with Pool(processes=processes) as pool:
        results = pool.map(compute_intensive_task, data_list)
    
    return results
 
# 使用示例
data_sets = [
    [1, 2, 3, 4, 5] * 1000,
    [6, 7, 8, 9, 10] * 1000,
    [11, 12, 13, 14, 15] * 1000,
]
 
results = parallel_compute(data_sets)

from functools import lru_cache
import maya.cmds as cmds
 
# ========== 不推荐：重复计算 ==========
def get_mesh_info(mesh_name):
    """每次都重新计算"""
    vert_count = cmds.polyEvaluate(mesh_name, vertex=True)
    face_count = cmds.polyEvaluate(mesh_name, face=True)
    return vert_count, face_count
 
# 如果在循环中多次调用同一个 mesh，会重复计算
for i in range(100):
    info = get_mesh_info("pSphere1")  # 每次都重新计算
 
# ========== 推荐：使用缓存 ==========
@lru_cache(maxsize=128)
def get_mesh_info_cached(mesh_name):
    """结果会被缓存"""
    vert_count = cmds.polyEvaluate(mesh_name, vertex=True)
    face_count = cmds.polyEvaluate(mesh_name, face=True)
    return vert_count, face_count
 
# 第一次调用会计算，后续调用直接返回缓存结果
for i in range(100):
    info = get_mesh_info_cached("pSphere1")  # 只有第一次会计算

class MeshCache:
    """
    手动管理 mesh 信息缓存
    """
    def __init__(self):
        self._cache = {}
    
    def get_mesh_info(self, mesh_name, force_refresh=False):
        """
        获取 mesh 信息，使用缓存
        
        Args:
            mesh_name: mesh 名称
            force_refresh: 是否强制刷新缓存
        """
        if force_refresh or mesh_name not in self._cache:
            # 计算并缓存
            vert_count = cmds.polyEvaluate(mesh_name, vertex=True)
            face_count = cmds.polyEvaluate(mesh_name, face=True)
            edge_count = cmds.polyEvaluate(mesh_name, edge=True)
            
            self._cache[mesh_name] = {
                'vertices': vert_count,
                'faces': face_count,
                'edges': edge_count
            }
        
        return self._cache[mesh_name]
    
    def clear_cache(self, mesh_name=None):
        """清除缓存"""
        if mesh_name:
            self._cache.pop(mesh_name, None)
        else:
            self._cache.clear()
 
# 使用示例
cache = MeshCache()
 
# 第一次获取会计算
info1 = cache.get_mesh_info("pSphere1")
 
# 后续获取使用缓存
info2 = cache.get_mesh_info("pSphere1")
 
# 强制刷新
info3 = cache.get_mesh_info("pSphere1", force_refresh=True)

class LazyMeshData:
    """
    懒加载 mesh 数据
    只有在实际访问时才计算
    """
    def __init__(self, mesh_name):
        self.mesh_name = mesh_name
        self._positions = None
        self._normals = None
        self._uvs = None
    
    @property
    def positions(self):
        """懒加载顶点位置"""
        if self._positions is None:
            import maya.api.OpenMaya as om
            sel = om.MSelectionList()
            sel.add(self.mesh_name)
            dag_path = sel.getDagPath(0)
            mesh_fn = om.MFnMesh(dag_path)
            self._positions = mesh_fn.getPoints(om.MSpace.kWorld)
        return self._positions
    
    @property
    def normals(self):
        """懒加载顶点法线"""
        if self._normals is None:
            import maya.api.OpenMaya as om
            sel = om.MSelectionList()
            sel.add(self.mesh_name)
            dag_path = sel.getDagPath(0)
            mesh_fn = om.MFnMesh(dag_path)
            self._normals = mesh_fn.getVertexNormals(False, om.MSpace.kWorld)
        return self._normals
    
    @property
    def uvs(self):
        """懒加载 UV 坐标"""
        if self._uvs is None:
            import maya.api.OpenMaya as om
            sel = om.MSelectionList()
            sel.add(self.mesh_name)
            dag_path = sel.getDagPath(0)
            mesh_fn = om.MFnMesh(dag_path)
            self._uvs = mesh_fn.getUVs()
        return self._uvs
    
    def clear_cache(self):
        """清除所有缓存数据"""
        self._positions = None
        self._normals = None
        self._uvs = None
 
# 使用示例
mesh_data = LazyMeshData("pSphere1")
 
# 只有在访问时才会计算
positions = mesh_data.positions  # 这时才计算位置
 
# 再次访问使用缓存
positions_again = mesh_data.positions  # 直接返回缓存

import maya.cmds as cmds
 
# ========== 不推荐 ==========
def bad_example():
    meshes = cmds.ls(type='mesh')
    for mesh in meshes:
        # 每次都查询父节点
        parent = cmds.listRelatives(mesh, parent=True)
        if parent:
            # 每次都查询类型
            if cmds.nodeType(parent[0]) == 'transform':
                # 每次都查询可见性
                if cmds.getAttr(f"{parent[0]}.visibility"):
                    print(f"{parent[0]} 是可见的")
 
# ========== 推荐 ==========
def good_example():
    meshes = cmds.ls(type='mesh', long=True)
    
    # 批量查询所有需要的信息
    mesh_data = []
    for mesh in meshes:
        parent = cmds.listRelatives(mesh, parent=True, fullPath=True)
        if not parent:
            continue
        parent = parent[0]
        
        # 一次性查询所有需要的属性
        is_visible = cmds.getAttr(f"{parent}.visibility")
        
        mesh_data.append({
            'mesh': mesh,
            'parent': parent,
            'visible': is_visible
        })
    
    # 使用预处理的数据
    for data in mesh_data:
        if data['visible']:
            print(f"{data['parent']} 是可见的")

import maya.cmds as cmds
 
# ========== 不推荐：逐个属性设置 ==========
def set_transform_slow(obj, tx, ty, tz, rx, ry, rz):
    cmds.setAttr(f"{obj}.translateX", tx)
    cmds.setAttr(f"{obj}.translateY", ty)
    cmds.setAttr(f"{obj}.translateZ", tz)
    cmds.setAttr(f"{obj}.rotateX", rx)
    cmds.setAttr(f"{obj}.rotateY", ry)
    cmds.setAttr(f"{obj}.rotateZ", rz)
 
# ========== 推荐：批量设置 ==========
def set_transform_fast(obj, tx, ty, tz, rx, ry, rz):
    cmds.setAttr(f"{obj}.translate", tx, ty, tz, type='double3')
    cmds.setAttr(f"{obj}.rotate", rx, ry, rz, type='double3')
 
# ========== 更好：使用 xform ==========
def set_transform_better(obj, tx, ty, tz, rx, ry, rz):
    cmds.xform(obj, translation=(tx, ty, tz), rotation=(rx, ry, rz))

import maya.cmds as cmds
 
# ========== 不推荐：频繁的字符串格式化 ==========
def query_attributes_slow(obj, indices):
    results = []
    for i in indices:
        # 每次都构造属性名称字符串
        attr_name = f"{obj}.vtx[{i}]"
        value = cmds.getAttr(attr_name)
        results.append(value)
    return results
 
# ========== 推荐：减少字符串操作 ==========
def query_attributes_fast(obj, indices):
    # 如果可能，使用批量操作
    # 或者至少预构造字符串
    attr_template = f"{obj}.vtx[{{}}]"
    results = []
    for i in indices:
        value = cmds.getAttr(attr_template.format(i))
        results.append(value)
    return results
 
# ========== 最好：使用 API 批量操作 ==========
def query_attributes_best(obj, indices):
    import maya.api.OpenMaya as om
    sel = om.MSelectionList()
    sel.add(obj)
    dag_path = sel.getDagPath(0)
    mesh_fn = om.MFnMesh(dag_path)
    
    # 批量获取所有位置
    all_positions = mesh_fn.getPoints(om.MSpace.kWorld)
    
    # 只返回需要的索引
    return [all_positions[i] for i in indices]

import maya.cmds as cmds
 
# ========== 不推荐：O(n²) 复杂度 ==========
def find_closest_objects_slow(objects):
    """找到每个物体最近的其他物体"""
    closest = {}
    
    for obj1 in objects:
        pos1 = cmds.xform(obj1, q=True, ws=True, t=True)
        min_distance = float('inf')
        closest_obj = None
        
        for obj2 in objects:
            if obj1 == obj2:
                continue
            pos2 = cmds.xform(obj2, q=True, ws=True, t=True)
            
            # 计算距离
            distance = sum((a - b) ** 2 for a, b in zip(pos1, pos2)) ** 0.5
            
            if distance < min_distance:
                min_distance = distance
                closest_obj = obj2
        
        closest[obj1] = closest_obj
    
    return closest
 
# ========== 推荐：预计算位置，使用更好的算法 ==========
def find_closest_objects_fast(objects):
    """使用预计算和优化的数据结构"""
    import numpy as np
    from scipy.spatial import cKDTree
    
    # 预计算所有位置
    positions = []
    for obj in objects:
        pos = cmds.xform(obj, q=True, ws=True, t=True)
        positions.append(pos)
    
    # 使用 KD-Tree 进行快速最近邻搜索
    positions_np = np.array(positions)
    tree = cKDTree(positions_np)
    
    closest = {}
    for i, obj in enumerate(objects):
        # 找到最近的 2 个点（第一个是自己，第二个是最近的其他点）
        distances, indices = tree.query(positions_np[i], k=2)
        closest_idx = indices[1]
        closest[obj] = objects[closest_idx]
    
    return closest

import maya.api.OpenMaya as om
import maya.cmds as cmds
 
def process_large_mesh_bad(mesh_name):
    """不释放内存的例子"""
    sel = om.MSelectionList()
    sel.add(mesh_name)
    dag_path = sel.getDagPath(0)
    mesh_fn = om.MFnMesh(dag_path)
    
    # 获取大量数据
    positions = mesh_fn.getPoints(om.MSpace.kWorld)
    normals = mesh_fn.getVertexNormals(False, om.MSpace.kWorld)
    
    # 处理数据...
    result = len(positions)
    
    # positions 和 normals 占用的内存会一直保留到函数结束
    return result
 
def process_large_mesh_good(mesh_name):
    """主动释放内存"""
    sel = om.MSelectionList()
    sel.add(mesh_name)
    dag_path = sel.getDagPath(0)
    mesh_fn = om.MFnMesh(dag_path)
    
    # 获取数据
    positions = mesh_fn.getPoints(om.MSpace.kWorld)
    
    # 处理数据
    result = len(positions)
    
    # 主动删除不再需要的大型对象
    del positions
    
    return result

import maya.cmds as cmds
 
# ========== 占用更多内存：返回完整列表 ==========
def get_all_transforms():
    """一次性返回所有 transforms"""
    return cmds.ls(type='transform')
 
# ========== 节省内存：使用生成器 ==========
def iter_transforms():
    """逐个生成 transforms"""
    all_transforms = cmds.ls(type='transform')
    for transform in all_transforms:
        yield transform
 
# 使用列表（一次性加载所有到内存）
all_trans = get_all_transforms()
for trans in all_trans:
    # 处理...
    pass
 
# 使用生成器（逐个处理，节省内存）
for trans in iter_transforms():
    # 处理...
    pass

import maya.cmds as cmds
 
def process_many_objects_batched(objects, batch_size=100):
    """
    分批处理大量对象，避免一次性占用过多内存
    """
    total = len(objects)
    
    for i in range(0, total, batch_size):
        batch = objects[i:i+batch_size]
        
        # 处理这批对象
        for obj in batch:
            # ... 处理逻辑
            pass
        
        # 可选：在批次之间清理内存
        import gc
        gc.collect()
        
        # 更新进度
        progress = min(i + batch_size, total) / total * 100
        print(f"进度: {progress:.1f}%")

import maya.cmds as cmds
import maya.api.OpenMaya as om
import time
from contextlib import contextmanager
 
# ========== 辅助上下文管理器 ==========
@contextmanager
def optimized_context():
    """优化的上下文管理器"""
    # 保存当前选择
    prev_selection = cmds.ls(selection=True)
    
    # 暂停刷新和撤销
    cmds.refresh(suspend=True)
    cmds.undoInfo(stateWithoutFlush=False)
    
    try:
        yield
    finally:
        # 恢复状态
        cmds.undoInfo(stateWithoutFlush=True)
        cmds.refresh(suspend=False)
        cmds.refresh()
        
        # 恢复选择
        if prev_selection:
            cmds.select(prev_selection)
 
# ========== 未优化版本（慢）==========
def place_assets_slow(asset_path, terrain_mesh, count=1000):
    """
    未优化的版本
    预计耗时：对于 1000 个资产可能需要 5-10 分钟
    """
    print("开始导入资产（未优化）...")
    start = time.time()
    
    for i in range(count):
        # 导入资产
        imported = cmds.file(asset_path, i=True, returnNewNodes=True)
        asset_transform = imported[0]
        
        # 重命名
        asset_name = cmds.rename(asset_transform, f"asset_{i}")
        
        # 随机位置
        import random
        x = random.uniform(-100, 100)
        z = random.uniform(-100, 100)
        
        # 查询地形高度（逐个查询，很慢）
        pos = (x, 0, z)
        cmds.xform(asset_name, translation=pos)
        
        # 使用 closestPointOnSurface 查询高度
        cpom = cmds.createNode('closestPointOnMesh')
        cmds.connectAttr(f"{terrain_mesh}.worldMesh[0]", f"{cpom}.inMesh")
        cmds.setAttr(f"{cpom}.inPosition", x, 0, z)
        
        y = cmds.getAttr(f"{cpom}.position.positionY")
        cmds.delete(cpom)
        
        # 设置最终位置
        cmds.xform(asset_name, translation=(x, y, z))
        
        # 随机旋转
        rotation_y = random.uniform(0, 360)
        cmds.xform(asset_name, rotation=(0, rotation_y, 0))
    
    elapsed = time.time() - start
    print(f"完成！耗时: {elapsed:.2f} 秒")
 
# ========== 优化版本（快）==========
def place_assets_optimized(asset_path, terrain_mesh, count=1000):
    """
    优化的版本
    预计耗时：对于 1000 个资产可能只需要 10-30 秒
    性能提升：20-60 倍
    """
    import random
    import numpy as np
    
    print("开始导入资产（优化）...")
    start = time.time()
    
    # 1. 预处理地形数据（一次性获取）
    sel = om.MSelectionList()
    sel.add(terrain_mesh)
    terrain_dag = sel.getDagPath(0)
    terrain_fn = om.MFnMesh(terrain_dag)
    
    # 2. 预生成所有随机位置
    positions_2d = []
    for i in range(count):
        x = random.uniform(-100, 100)
        z = random.uniform(-100, 100)
        positions_2d.append((x, z))
    
    # 3. 批量查询地形高度（使用 API 2.0）
    def get_height_on_terrain(x, z):
        """使用 MFnMesh.closestPoint 查询高度"""
        point = om.MPoint(x, 0, z)
        closest_point = terrain_fn.closestPoint(point, om.MSpace.kWorld)[0]
        return closest_point.y
    
    heights = [get_height_on_terrain(x, z) for x, z in positions_2d]
    
    # 4. 预生成所有旋转
    rotations = [random.uniform(0, 360) for _ in range(count)]
    
    # 5. 在优化上下文中导入和摆放资产
    with optimized_context():
        # 创建父组
        main_group = cmds.createNode('transform', name='assets_group')
        
        for i in range(count):
            # 导入资产（使用 reference 更快）
            namespace = f"asset_{i}"
            ref_node = cmds.file(
                asset_path, 
                reference=True, 
                namespace=namespace,
                returnNewNodes=True
            )
            
            # 获取引用的顶层节点
            ref_nodes = cmds.referenceQuery(ref_node[0], nodes=True)
            transforms = cmds.ls(ref_nodes, type='transform', long=True)
            top_node = None
            for trans in transforms:
                if not cmds.listRelatives(trans, parent=True):
                    top_node = trans
                    break
            
            if not top_node:
                continue
            
            # 重命名（可选）
            asset_name = cmds.rename(top_node, f"asset_{i}")
            
            # 父级到主组
            cmds.parent(asset_name, main_group)
            
            # 批量设置变换（使用预计算的数据）
            x, z = positions_2d[i]
            y = heights[i]
            rotation_y = rotations[i]
            
            # 一次性设置所有变换属性
            cmds.xform(
                asset_name, 
                translation=(x, y, z),
                rotation=(0, rotation_y, 0),
                worldSpace=True
            )
            
            # 显示进度（每100个输出一次，避免过多IO）
            if (i + 1) % 100 == 0:
                print(f"已处理: {i+1}/{count}")
    
    elapsed = time.time() - start
    print(f"完成！耗时: {elapsed:.2f} 秒")
    print(f"平均每个资产: {elapsed/count*1000:.2f} 毫秒")
 
# ========== 使用示例 ==========
def demo_asset_placement():
    """演示资产摆放"""
    # 创建一个测试地形
    terrain = cmds.polyPlane(name='terrain', width=200, height=200, sx=50, sy=50)[0]
    
    # 创建一个简单的测试资产
    test_asset = cmds.polyCube(name='test_asset')[0]
    test_asset_path = cmds.file(rename='/tmp/test_asset.ma')
    cmds.file(save=True, type='mayaAscii')
    cmds.file(new=True, force=True)
    
    # 重新创建地形
    terrain = cmds.polyPlane(name='terrain', width=200, height=200, sx=50, sy=50)[0]
    
    # 测试未优化版本（少量资产）
    place_assets_slow(test_asset_path, terrain, count=10)
    
    # 清理
    cmds.file(new=True, force=True)
    terrain = cmds.polyPlane(name='terrain', width=200, height=200, sx=50, sy=50)[0]
    
    # 测试优化版本（大量资产）
    place_assets_optimized(test_asset_path, terrain, count=1000)
 

import maya.cmds as cmds
 
# ========== 不推荐：每次都解析完整路径 ==========
def modify_hierarchy_slow(root):
    """每次都重新构建路径字符串"""
    children = cmds.listRelatives(root, children=True, fullPath=True) or []
    
    for child in children:
        # 每次都用字符串拼接
        cmds.setAttr(f"{child}.visibility", 1)
        
        grandchildren = cmds.listRelatives(child, children=True, fullPath=True) or []
        for grandchild in grandchildren:
            cmds.setAttr(f"{grandchild}.visibility", 1)
 
# ========== 推荐：使用长名称，避免歧义 ==========
def modify_hierarchy_fast(root):
    """使用 fullPath 避免歧义和重复查询"""
    # 一次性获取所有后代
    descendants = cmds.listRelatives(root, allDescendents=True, fullPath=True) or []
    
    # 批量操作
    for node in descendants:
        cmds.setAttr(f"{node}.visibility", 1)

import timeit
 
obj_name = "pCube1"
attr_name = "translateX"
 
# 测试不同的字符串格式化方法
def test_concatenation():
    return obj_name + "." + attr_name
 
def test_format():
    return "{}.{}".format(obj_name, attr_name)
 
def test_fstring():
    return f"{obj_name}.{attr_name}"
 
def test_percent():
    return "%s.%s" % (obj_name, attr_name)
 
# 性能测试
iterations = 100000
 
print("字符串格式化性能对比（100,000 次迭代）：")
print(f"+ 拼接: {timeit.timeit(test_concatenation, number=iterations):.4f}秒")
print(f"format(): {timeit.timeit(test_format, number=iterations):.4f}秒")
print(f"f-string: {timeit.timeit(test_fstring, number=iterations):.4f}秒")
print(f"% 格式化: {timeit.timeit(test_percent, number=iterations):.4f}秒")
 
# 结果（仅供参考）：
# + 拼接: 0.0156秒
# format(): 0.0312秒
# f-string: 0.0189秒（Python 3.6+，推荐使用）
# % 格式化: 0.0198秒

import maya.api.OpenMaya as om
import maya.cmds as cmds
 
# ========== 使用 cmds（较慢）==========
def traverse_hierarchy_cmds(root):
    """使用 cmds 遍历层次结构"""
    all_descendants = []
    
    def recurse(node):
        children = cmds.listRelatives(node, children=True, fullPath=True) or []
        for child in children:
            all_descendants.append(child)
            recurse(child)
    
    recurse(root)
    return all_descendants
 
# ========== 使用 API 2.0（快）==========
def traverse_hierarchy_api(root):
    """使用 API 2.0 的 DAG 迭代器"""
    all_descendants = []
    
    sel = om.MSelectionList()
    sel.add(root)
    root_dag = sel.getDagPath(0)
    
    # 使用 DAG 迭代器
    dag_iter = om.MItDag()
    dag_iter.reset(root_dag, om.MItDag.kDepthFirst)
    
    while not dag_iter.isDone():
        current_dag = dag_iter.getPath()
        all_descendants.append(current_dag.fullPathName())
        dag_iter.next()
    
    return all_descendants
 
# ========== 更快：使用 cmds.listRelatives 的 allDescendents 标志 ==========
def traverse_hierarchy_fastest(root):
    """最简单且高效的方法"""
    return cmds.listRelatives(root, allDescendents=True, fullPath=True) or []

import maya.api.OpenMaya as om
import maya.cmds as cmds
 
# ========== 使用 cmds（中等速度）==========
def find_meshes_in_hierarchy_cmds(root):
    """使用 cmds 查找层次结构中的所有 mesh"""
    descendants = cmds.listRelatives(root, allDescendents=True, fullPath=True) or []
    meshes = []
    
    for node in descendants:
        shapes = cmds.listRelatives(node, shapes=True, fullPath=True) or []
        for shape in shapes:
            if cmds.nodeType(shape) == 'mesh':
                meshes.append(shape)
    
    return meshes
 
# ========== 使用 API 2.0（更快）==========
def find_meshes_in_hierarchy_api(root):
    """使用 API 2.0 迭代器过滤 mesh"""
    meshes = []
    
    sel = om.MSelectionList()
    sel.add(root)
    root_dag = sel.getDagPath(0)
    
    # 使用带类型过滤的迭代器
    dag_iter = om.MItDag(om.MItDag.kDepthFirst, om.MFn.kMesh)
    dag_iter.reset(root_dag)
    
    while not dag_iter.isDone():
        dag_path = dag_iter.getPath()
        meshes.append(dag_path.fullPathName())
        dag_iter.next()
    
    return meshes
 
# ========== 最简单的方法 ==========
def find_meshes_in_hierarchy_simple(root):
    """使用 cmds.listRelatives 的 type 标志"""
    return cmds.listRelatives(root, allDescendents=True, type='mesh', fullPath=True) or []

import maya.cmds as cmds
 
# ========== 不推荐：为每个对象创建 script job ==========
def setup_monitors_bad(objects):
    """为每个对象创建监视器（糟糕的做法）"""
    job_ids = []
    
    for obj in objects:
        # 每个对象一个 script job
        job_id = cmds.scriptJob(
            attributeChange=[f"{obj}.translateX", lambda o=obj: on_transform_changed(o)]
        )
        job_ids.append(job_id)
    
    return job_ids
 
# ========== 推荐：使用单个 script job 监视场景变化 ==========
def setup_monitor_good(objects):
    """使用单个 script job 监视所有对象"""
    # 将需要监视的对象存储在集合中
    global monitored_objects
    monitored_objects = set(objects)
    
    # 创建单个 script job
    job_id = cmds.scriptJob(
        event=["timeChanged", on_scene_changed]
    )
    
    return job_id
 
def on_scene_changed():
    """统一的场景变化处理函数"""
    global monitored_objects
    
    for obj in monitored_objects:
        if cmds.objExists(obj):
            # 处理变化
            pass

import maya.cmds as cmds
 
class ScriptJobManager:
    """Script Job 管理器"""
    
    def __init__(self):
        self.job_ids = []
    
    def add_job(self, *args, **kwargs):
        """添加 script job"""
        job_id = cmds.scriptJob(*args, **kwargs)
        self.job_ids.append(job_id)
        return job_id
    
    def clear_all(self):
        """清理所有 script jobs"""
        for job_id in self.job_ids:
            if cmds.scriptJob(exists=job_id):
                cmds.scriptJob(kill=job_id, force=True)
        self.job_ids.clear()
    
    def __del__(self):
        """析构时自动清理"""
        self.clear_all()
 
# 使用示例
job_manager = ScriptJobManager()
 
# 添加 jobs
job_manager.add_job(event=["SelectionChanged", on_selection_changed])
job_manager.add_job(event=["timeChanged", on_time_changed])
 
# 清理
job_manager.clear_all()

import maya.cmds as cmds
import time
 
# ========== 不推荐：耗时的回调函数 ==========
def slow_callback():
    """每次事件都执行耗时操作"""
    # 这会严重拖慢 Maya
    all_meshes = cmds.ls(type='mesh')
    for mesh in all_meshes:
        cmds.polyEvaluate(mesh, vertex=True)
 
# ========== 推荐：使用节流（throttle）==========
class ThrottledCallback:
    """节流回调类"""
    
    def __init__(self, func, min_interval=0.1):
        self.func = func
        self.min_interval = min_interval
        self.last_call_time = 0
    
    def __call__(self, *args, **kwargs):
        current_time = time.time()
        
        if current_time - self.last_call_time >= self.min_interval:
            self.last_call_time = current_time
            return self.func(*args, **kwargs)
 
# 使用示例
def expensive_operation():
    """耗时操作"""
    print("执行耗时操作")
    # ... 耗时代码
 
# 创建节流版本（最多每100ms执行一次）
throttled_op = ThrottledCallback(expensive_operation, min_interval=0.1)
 
# 注册 script job
job_id = cmds.scriptJob(event=["timeChanged", throttled_op])

import sys
import maya.api.OpenMaya as om
 
def maya_useNewAPI():
    """告诉 Maya 使用 API 2.0"""
    pass
 
class OptimizedTransformCommand(om.MPxCommand):
    """优化的变换命令"""
    
    kPluginCmdName = "optimizedTransform"
    
    def __init__(self):
        om.MPxCommand.__init__(self)
    
    @staticmethod
    def cmdCreator():
        return OptimizedTransformCommand()
    
    def doIt(self, args):
        """命令执行"""
        # 解析参数
        arg_data = om.MArgParser(self.syntax(), args)
        
        # 获取选择
        selection = om.MGlobal.getActiveSelectionList()
        
        if selection.isEmpty():
            om.MGlobal.displayWarning("请选择至少一个对象")
            return
        
        # 批量处理所有选择的对象
        translation = om.MVector(
            arg_data.flagArgumentDouble('tx', 0) if arg_data.isFlagSet('tx') else 0,
            arg_data.flagArgumentDouble('ty', 0) if arg_data.isFlagSet('ty') else 0,
            arg_data.flagArgumentDouble('tz', 0) if arg_data.isFlagSet('tz') else 0
        )
        
        for i in range(selection.length()):
            dag_path = selection.getDagPath(i)
            transform_fn = om.MFnTransform(dag_path)
            
            # 使用 API 直接操作
            current_trans = transform_fn.translation(om.MSpace.kWorld)
            new_trans = current_trans + translation
            transform_fn.setTranslation(new_trans, om.MSpace.kWorld)
        
        self.setResult("成功处理 {} 个对象".format(selection.length()))
    
    @staticmethod
    def syntaxCreator():
        """定义命令语法"""
        syntax = om.MSyntax()
        syntax.addFlag('tx', 'translateX', om.MSyntax.kDouble)
        syntax.addFlag('ty', 'translateY', om.MSyntax.kDouble)
        syntax.addFlag('tz', 'translateZ', om.MSyntax.kDouble)
        return syntax
 
# 插件初始化和卸载
def initializePlugin(plugin):
    plugin_fn = om.MFnPlugin(plugin)
    try:
        plugin_fn.registerCommand(
            OptimizedTransformCommand.kPluginCmdName,
            OptimizedTransformCommand.cmdCreator,
            OptimizedTransformCommand.syntaxCreator
        )
    except:
        sys.stderr.write(f"注册命令失败: {OptimizedTransformCommand.kPluginCmdName}")
        raise
 
def uninitializePlugin(plugin):
    plugin_fn = om.MFnPlugin(plugin)
    try:
        plugin_fn.deregisterCommand(OptimizedTransformCommand.kPluginCmdName)
    except:
        sys.stderr.write(f"注销命令失败: {OptimizedTransformCommand.kPluginCmdName}")
        raise

import maya.cmds as cmds
 
# 加载插件
cmds.loadPlugin('/path/to/optimizedTransformPlugin.py')
 
# 使用自定义命令
cmds.select('pCube*')
cmds.optimizedTransform(tx=5, ty=10, tz=0)
 
# 卸载插件
cmds.unloadPlugin('optimizedTransformPlugin.py')

# 文件: fast_math.pyx
import numpy as np
cimport numpy as np
cimport cython
 
@cython.boundscheck(False)
@cython.wraparound(False)
def fast_normalize_weights(double[:, :] weights):
    """
    使用 Cython 加速权重归一化
    """
    cdef int n_verts = weights.shape[0]
    cdef int n_influences = weights.shape[1]
    cdef int i, j
    cdef double row_sum
    
    cdef np.ndarray[np.float64_t, ndim=2] result = np.empty((n_verts, n_influences))
    
    for i in range(n_verts):
        row_sum = 0.0
        for j in range(n_influences):
            row_sum += weights[i, j]
        
        if row_sum > 0:
            for j in range(n_influences):
                result[i, j] = weights[i, j] / row_sum
        else:
            for j in range(n_influences):
                result[i, j] = 0.0
    
    return result

# setup.py
from distutils.core import setup
from Cython.Build import cythonize
import numpy
 
setup(
    ext_modules=cythonize("fast_math.pyx"),
    include_dirs=[numpy.get_include()]
)
 
# 编译命令:
# mayapy setup.py build_ext --inplace
 
# 在 Maya 中使用:
import fast_math
import numpy as np
 
weights = np.random.rand(10000, 5)
normalized = fast_math.fast_normalize_weights(weights)

# ========== 性能代码审查模板 ==========
 
"""
函数名: process_large_dataset()
预期用途: 处理 10,000+ 顶点的 mesh
 
性能审查：
1. API 选择：✓ 使用了 maya.api.OpenMaya
2. 批处理：✓ 使用了上下文管理器
3. 循环优化：✓ 避免了嵌套循环
4. 缓存：✓ 缓存了查询结果
5. 内存：✓ 及时释放了大型数组
 
测试结果：
- 10,000 顶点: 0.5 秒
- 100,000 顶点: 3.2 秒
- 内存占用: < 100MB
 
批准人: [名字]
日期: 2024-01-01
"""

import maya.cmds as cmds
import maya.api.OpenMaya as om
import time
import json
 
class PerformanceBenchmark:
    """性能基准测试类"""
    
    def __init__(self, name="性能测试"):
        self.name = name
        self.results = {}
    
    def test(self, test_name, func, *args, **kwargs):
        """执行单个测试"""
        print(f"\n运行测试: {test_name}")
        
        # 预热（避免首次调用的开销）
        func(*args, **kwargs)
        
        # 正式测试
        iterations = kwargs.pop('iterations', 1)
        times = []
        
        for i in range(iterations):
            start = time.time()
            result = func(*args, **kwargs)
            elapsed = time.time() - start
            times.append(elapsed)
        
        # 统计
        avg_time = sum(times) / len(times)
        min_time = min(times)
        max_time = max(times)
        
        self.results[test_name] = {
            'average': avg_time,
            'min': min_time,
            'max': max_time,
            'iterations': iterations
        }
        
        print(f"  平均: {avg_time:.4f}秒")
        print(f"  最快: {min_time:.4f}秒")
        print(f"  最慢: {max_time:.4f}秒")
        
        return result
    
    def compare(self, baseline_name, comparison_name):
        """比较两个测试的性能"""
        if baseline_name not in self.results or comparison_name not in self.results:
            print("测试不存在")
            return
        
        baseline = self.results[baseline_name]['average']
        comparison = self.results[comparison_name]['average']
        
        speedup = baseline / comparison
        percent_improvement = ((baseline - comparison) / baseline) * 100
        
        print(f"\n性能对比:")
        print(f"  {baseline_name}: {baseline:.4f}秒")
        print(f"  {comparison_name}: {comparison:.4f}秒")
        print(f"  加速比: {speedup:.2f}x")
        print(f"  性能提升: {percent_improvement:.1f}%")
    
    def save_results(self, filepath):
        """保存结果到 JSON 文件"""
        with open(filepath, 'w') as f:
            json.dump(self.results, f, indent=2)
        print(f"\n结果已保存到: {filepath}")
    
    def print_summary(self):
        """打印摘要"""
        print(f"\n{'='*50}")
        print(f"{self.name} - 测试摘要")
        print(f"{'='*50}")
        
        for test_name, result in self.results.items():
            print(f"\n{test_name}:")
            print(f"  平均时间: {result['average']:.4f}秒")
            print(f"  迭代次数: {result['iterations']}")
 
# ========== 使用示例 ==========
def run_benchmarks():
    """运行完整的性能测试套件"""
    # 创建测试场景
    cmds.file(new=True, force=True)
    mesh = cmds.polySphere(subdivisionsX=100, subdivisionsY=100, radius=5)[0]
    
    benchmark = PerformanceBenchmark("Maya Python 性能测试")
    
    # 测试 1: cmds vs API
    def test_cmds():
        positions = []
        vert_count = cmds.polyEvaluate(mesh, vertex=True)
        for i in range(vert_count):
            pos = cmds.xform(f"{mesh}.vtx[{i}]", q=True, ws=True, t=True)
            positions.append(pos)
        return positions
    
    def test_api():
        sel = om.MSelectionList()
        sel.add(mesh)
        dag_path = sel.getDagPath(0)
        mesh_fn = om.MFnMesh(dag_path)
        return mesh_fn.getPoints(om.MSpace.kWorld)
    
    benchmark.test("cmds_逐顶点查询", test_cmds, iterations=3)
    benchmark.test("API_批量查询", test_api, iterations=3)
    benchmark.compare("cmds_逐顶点查询", "API_批量查询")
    
    # 打印摘要
    benchmark.print_summary()
    
    # 保存结果
    benchmark.save_results("/tmp/maya_performance_benchmark.json")
 
# 运行基准测试
# run_benchmarks()