1. 使用高效的数据结构

选择合适的数据结构可以显著提升代码性能。

示例:

  • 列表 vs 集合:如果需要频繁检查元素是否存在,使用集合(set)而不是列表(list),因为集合的查找时间复杂度是 O(1),而列表是 O(n)。

    # 低效
    my_list = [1, 2, 3, 4, 5]
    if 3 in my_list:  # O(n)
        print("Found")
    
    # 高效
    my_set = {1, 2, 3, 4, 5}
    if 3 in my_set:  # O(1)
        print("Found")
    
  • 字典 vs 列表:如果需要通过键快速查找值,使用字典(dict)而不是列表。

    # 低效
    my_list = [("a", 1), ("b", 2), ("c", 3)]
    for key, value in my_list:
        if key == "b":
            print(value)
    
    # 高效
    my_dict = {"a": 1, "b": 2, "c": 3}
    print(my_dict["b"])  # O(1)
    

2. 减少循环中的计算

将循环中不变的计算移到循环外,避免重复计算。

示例:

  • 低效

    for i in range(len(my_list)):
        result = my_list[i] * math.sqrt(100)  # 每次循环都计算 math.sqrt(100)
    
  • 高效

    sqrt_value = math.sqrt(100)  # 计算一次
    for i in range(len(my_list)):
        result = my_list[i] * sqrt_value
    

3. 使用生成器(Generator)

生成器可以节省内存,特别是在处理大数据集时。

示例:

  • 低效

    def get_squares(n):
        return [x**2 for x in range(n)]  # 返回列表,占用大量内存
    
  • 高效

    def get_squares(n):
        for x in range(n):
            yield x**2  # 生成器,惰性计算
    

4. 避免不必要的函数调用

函数调用有一定的开销,尤其是在循环中频繁调用简单函数时。

示例:

  • 低效

    def add(a, b):
        return a + b
    
    result = 0
    for i in range(1000):
        result = add(result, i)  # 频繁调用函数
    
  • 高效

    result = 0
    for i in range(1000):
        result += i  # 直接操作
    

5. 使用内置函数和库

Python 的内置函数和标准库通常是用 C 实现的,性能更高。

示例:

  • 低效

    my_list = [1, 2, 3, 4, 5]
    squared_list = []
    for x in my_list:
        squared_list.append(x**2)
    
  • 高效

    my_list = [1, 2, 3, 4, 5]
    squared_list = map(lambda x: x**2, my_list)  # 使用 map
    

6. 利用缓存(Memoization)

对于重复计算的函数,可以使用缓存来存储结果,避免重复计算。

示例:

  • 低效

    def fibonacci(n):
        if n <= 1:
            return n
        return fibonacci(n-1) + fibonacci(n-2)  # 重复计算
    
  • 高效

    from functools import lru_cache
    
    @lru_cache(maxsize=None)
    def fibonacci(n):
        if n <= 1:
            return n
        return fibonacci(n-1) + fibonacci(n-2)  # 结果被缓存
    

7. 使用位运算代替算术运算

位运算通常比算术运算更快,尤其是在处理整数时。

示例:

  • 低效

    if number % 2 == 0:  # 判断偶数
        number = number // 2  # 除以2
    
  • 高效

    if number & 1 == 0:  # 使用位运算判断偶数
        number >>= 1  # 使用位运算除以2
    

8. 减少全局变量的使用

访问局部变量比访问全局变量更快。

示例:

  • 低效

    global_var = 10
    
    def add_to_global(x):
        return x + global_var  # 访问全局变量
    
  • 高效

    def add_to_local(x, local_var):
        return x + local_var  # 访问局部变量
    

9. 使用 join 拼接字符串

在拼接大量字符串时,使用 join 比直接使用 + 更高效。

示例:

  • 低效

    result = ""
    for s in my_list:
        result += s  # 每次拼接都会创建新字符串
    
  • 高效

    result = "".join(my_list)  # 一次性拼接
    

10. 使用 NumPy 或 Pandas 处理数值数据

对于数值计算或数据处理任务,使用 NumPy 或 Pandas 可以显著提升性能。

示例:

  • 低效

    my_list = [1, 2, 3, 4, 5]
    squared_list = [x**2 for x in my_list]
    
  • 高效

    import numpy as np
    my_array = np.array([1, 2, 3, 4, 5])
    squared_array = my_array**2  # 向量化操作
    

11. 避免不必要的对象创建

在循环中创建对象会增加内存和计算开销。

示例:

  • 低效

    for i in range(1000):
        my_dict = {"a": 1, "b": 2}  # 每次循环都创建新字典
    
  • 高效

    my_dict = {"a": 1, "b": 2}
    for i in range(1000):
        # 复用字典
        pass
    

总结

高性能编码的核心在于:

  1. 选择合适的数据结构和算法
  2. 减少不必要的计算和内存开销
  3. 利用语言特性和工具(如生成器、缓存、内置函数等)。