Python 2中scipy.weave替代方案问询（适配Python 3环境）

Got it — since scipy.weave was removed in Python 3, you’ve got three solid alternatives to replace that inline C code functionality. Let’s walk through each one with examples that map to your original snippet:

CFFI lets you embed and compile C code directly in your Python script, just like weave.inline did. It’s the most drop-in replacement for your existing code structure.

First install it:

pip install cffi

Then adapt your code like this:

from cffi import FFI
import numpy as np

ffi = FFI()

# Your original support_code (C-code2) goes here
support_code = """
// Example support code: a helper function
double square(double x) {
    return x * x;
}
"""

# Wrap your original code (C-code1) in a named function with clear inputs
code = support_code + """
void my_computation(double *a, double *b, double *c, int array_length) {
    // Your original C-code1 logic here — example:
    for (int i = 0; i < array_length; i++) {
        c[i] = square(a[i]) + b[i];
    }
}
"""

# Define the function interface for Python to call
ffi.cdef("""
void my_computation(double *a, double *b, double *c, int array_length);
""")

# Compile and load the C code (equivalent to weave.inline's compilation step)
lib = ffi.verify(code)

# Prepare your numpy arrays (same as your original `a`, `b`, `c`)
a = np.array([1.0, 2.0, 3.0], dtype=np.double)
b = np.array([4.0, 5.0, 6.0], dtype=np.double)
c = np.zeros_like(a)

# Convert numpy arrays to C-compatible pointers
a_ptr = ffi.cast("double *", a.ctypes.data)
b_ptr = ffi.cast("double *", b.ctypes.data)
c_ptr = ffi.cast("double *", c.ctypes.data)

# Run the compiled C function
lib.my_computation(a_ptr, b_ptr, c_ptr, len(a))

# Now `c` holds your computed result
print(c)

If you want to package your code into a reusable module instead of inline snippets, Cython is the way to go. It lets you write hybrid Python/C code that compiles to fast extensions.

First install Cython:

pip install cython

Step 1: Write a .pyx file (my_computation.pyx) #

# Your original support_code (C-code2) can go here as C declarations
cdef extern:
    double square(double x)

# Implement your C-code1 logic in a Cython function
def compute(double[:] a, double[:] b, double[:] c):
    cdef int i, n = a.shape[0]
    for i in range(n):
        # Your original calculation here — example using the support function
        c[i] = square(a[i]) + b[i]

# Define any support functions from C-code2
cdef double square(double x):
    return x * x

Step 2: Write a setup.py to compile the extension #

from setuptools import setup
from Cython.Build import cythonize
import numpy as np

setup(
    ext_modules=cythonize("my_computation.pyx"),
    include_dirs=[np.get_include()]
)

Step 3: Compile and use the module #

python setup.py build_ext --inplace

Then in your Python script:

import numpy as np
import my_computation

a = np.array([1.0, 2.0, 3.0])
b = np.array([4.0, 5.0, 6.0])
c = np.zeros_like(a)

my_computation.compute(a, b, c)
print(c)

If your original C code is just numerical loops, Numba can compile pure Python code to near-C speed with zero C syntax. It’s the simplest option if you don’t want to write raw C.

Install Numba first:

pip install numba

Then rewrite your logic in Python with a Numba decorator:

import numba
import numpy as np

# The @numba.jit decorator compiles this function to machine code
@numba.jit(nopython=True)
def compute(a, b, c):
    n = len(a)
    for i in range(n):
        # Your original calculation logic translated to Python — example:
        c[i] = (a[i] ** 2) + b[i]

a = np.array([1.0, 2.0, 3.0])
b = np.array([4.0, 5.0, 6.0])
c = np.zeros_like(a)

compute(a, b, c)
print(c)

内容的提问来源于stack exchange，提问作者Jeroen Bertels