提升 Python 程序运行性能，使代码运行更流畅更快，以及压缩代码，减小代码大小，下面的方法仅供大家参考，有什么更好的方法在评论区说说。

1. 使用 NumPy/SciPy 替代纯 Python 循环

Python 原生循环效率低，而 NumPy 和 SciPy 的底层用 C 实现，能并行处理数组操作。

import numpy as np

# 低效写法：纯Python循环
def sum_squares_python(n):
    result = 0
    for i in range(n):
        result += i ** 2
    return result

# 高效写法：NumPy向量化
def sum_squares_numpy(n):
    arr = np.arange(n)
    return np.sum(arr ** 2)

# 测试性能
%timeit sum_squares_python(1000)  # 约1.2ms
%timeit sum_squares_numpy(1000)   # 约3.5μs（快340倍）

2. 使用 JIT 编译（如 Numba）

Numba 能将 Python 函数编译为机器码，大幅提升数值计算速度。

from numba import jit

# 未优化的函数
def calculate_pi(n):
    s = 0.0
    for i in range(n):
        s += (-1) ** i / (2 * i + 1)
    return 4 * s

# 使用Numba优化
@jit(nopython=True)
def calculate_pi_numba(n):
    s = 0.0
    for i in range(n):
        s += (-1) ** i / (2 * i + 1)
    return 4 * s

# 测试性能
%timeit calculate_pi(100000)      # 约18ms
%timeit calculate_pi_numba(100000) # 约17μs（快1000倍）

3. 使用生成器（Generator）减少内存占用

生成器按需生成数据，避免一次性创建大列表。

# 低效写法：创建完整列表
def get_squares_list(n):
    return [i ** 2 for i in range(n)]

# 高效写法：使用生成器
def get_squares_generator(n):
    for i in range(n):
        yield i ** 2

# 内存占用对比
import sys
print(sys.getsizeof(get_squares_list(1000)))    # 8,856 字节
print(sys.getsizeof(get_squares_generator(1000))) # 112 字节

4. 使用集合（Set）和字典（Dict）进行快速查找

集合和字典的查找时间复杂度为 O (1)，远快于列表的 O (n)。

# 低效写法：列表查找
def list_lookup(lst, target):
    return target in lst

# 高效写法：集合查找
def set_lookup(s, target):
    return target in s

# 测试性能
data = list(range(10000))
data_set = set(data)
%timeit list_lookup(data, 9999)  # 约4.8μs
%timeit set_lookup(data_set, 9999)  # 约60ns（快80倍）

5. 使用 Cython 将 Python 与 C 结合

Cython 允许在 Python 中嵌入 C 代码，适合计算密集型任务。

# 普通Python函数
def fib_python(n):
    a, b = 0, 1
    for _ in range(n):
        a, b = b, a + b
    return a

# Cython优化版本（需编译）
# 保存为fib.pyx
def fib_cython(int n):
    cdef int a = 0, b = 1, i
    for i in range(n):
        a, b = b, a + b
    return a

# 测试性能（编译后）
%timeit fib_python(1000)    # 约4.5μs
%timeit fib_cython(1000)    # 约0.5μs（快9倍）

6. 使用多进程 / 多线程处理并行任务

对于 CPU 密集型任务使用multiprocessing，I/O 密集型使用threading或asyncio。

import multiprocessing

def process_chunk(chunk):
    return sum(i * i for i in chunk)

# 数据分块
data = list(range(1000000))
chunks = [data[i:i+100000] for i in range(0, len(data), 100000)]

# 单进程
%timeit sum(process_chunk(chunk) for chunk in chunks)  # 约150ms

# 多进程
with multiprocessing.Pool(processes=4) as pool:
    %timeit sum(pool.map(process_chunk, chunks))  # 约50ms（快3倍）

7. 使用内置函数和库替代自定义实现

Python 内置函数（如sum()、map()）和标准库（如itertools）经过高度优化。

# 低效写法：自定义求和
def custom_sum(lst):
    s = 0
    for x in lst:
        s += x
    return s

# 高效写法：使用内置sum
def builtin_sum(lst):
    return sum(lst)

# 测试性能
data = list(range(1000))
%timeit custom_sum(data)    # 约2.5μs
%timeit builtin_sum(data)   # 约0.5μs（快5倍）

减少代码大小的方法

1. 使用列表 / 字典推导式：替代冗长的循环。

# 原代码
squares = []
for i in range(10):
    squares.append(i ** 2)

# 压缩后
squares = [i ** 2 for i in range(10)]

2、合并导入语句：

# 原代码
import numpy
import pandas

# 压缩后
import numpy as np, pandas as pd

3、使用 lambda 函数：替代简单的 def 函数。

# 原代码
def add(a, b):
    return a + b

# 压缩后
add = lambda a, b: a + b

4、移除注释和空行：虽然不影响功能，但能减少代码行数。

5、使用内置函数和标准库：避免重复造轮子。

6、使用 f-strings：替代%或.format()，代码更简洁。

# 原代码
name = "Alice"
age = 30
message = "Hello, my name is %s and I'm %d years old." % (name, age)

# 压缩后
message = f"Hello, my name is {name} and I'm {age} years old."

7、使用条件表达式：

# 原代码
if x > 10:
    y = "Large"
else:
    y = "Small"

# 压缩后
y = "Large" if x > 10 else "Small"

通过以上方法，你的 Python 代码不仅能运行得更快，还能更简洁高效！