#include <stddef.h>
void fmul(const float* a, const float* b, float* out, size_t n) {
    for (size_t i = 0; i < n; ++i) out[i] = a[i] * b[i];
}

gcc -O3 -fPIC -shared -o libfmul.so fmul.c

pip install cffi

from array import array
from pathlib import Path
from cffi import FFI

# через FFI подгружаем разделяемую библиотеку в Python-код
ffi = FFI()
ffi.cdef("void fmul(const float* a,const float* b,float* out,size_t n);")
C = ffi.dlopen(str(Path(__file__).with_name("libfmul.so")))

class F32Vec:
    # используем __slots__ для более компактного и производительного представления объектов класса
    __slots__ = ("a",)

    # требуем, чтобы наш класс конструировался из float-массива Python
    def __init__(self, data):
        self.a = (
            data
            if isinstance(data, array) and data.typecode == "f"
            else array("f", data)
        )

    def __len__(self):
        return len(self.a)

    def _mul_arr(self, other):
        if len(self.a) != len(other):
            raise ValueError("len mismatch")

        # готовим выходной массив
        out = array("f", [0.0]) * len(self.a)

        # вызываем через FFI C-функцию fmul
        C.fmul(
            ffi.from_buffer("float[]", self.a),
            ffi.from_buffer("float[]", other),
            ffi.from_buffer("float[]", out),
            len(self.a),
        )
        return F32Vec(out)

    # перегружаем операторы умножения, чтобы поэлементное произведение работало как в numpy
    def __mul__(self, other):
        if isinstance(other, F32Vec):
            return self._mul_arr(other.a)
        if isinstance(other, (int, float)):
            return self._mul_arr(array("f", [float(other)]) * len(self.a))
        return self._mul_arr(array("f", other))

    __rmul__ = __mul__

    def tolist(self):
        return list(self.a)

    def __repr__(self):
        return f"F32Vec({list(self.a)})"


if __name__ == "__main__":
    x = F32Vec([0.0, 0.5, 1.0, 1.5])
    y = F32Vec([1.0, 2.0, 3.0, 4.0])

    print(x._mul_arr(y.a))
    print((x * y).tolist())
    print((x * 2.0))
    print((2.0 * x).tolist())

python3 fmul.py
F32Vec([0.0, 1.0, 3.0, 6.0])
[0.0, 1.0, 3.0, 6.0]
F32Vec([0.0, 1.0, 2.0, 3.0])
[0.0, 1.0, 2.0, 3.0]

pip install numba

import numpy as np
from numba import njit

@njit
def fmul_numba(a, b, out, n):
    for i in range(n):
        out[i] = a[i] * b[i]

out = np.empty(4, dtype=np.float64)
fmul_numba(np.array([0.0, 0.5, 1.0, 1.5]), np.array([1.0, 2.0, 3.0, 4.0]), out, 4)
print(out)

python3 numba_demo.py
[0. 1. 3. 6.]

pip install pythran

# pythran export fmul_pythran(float[], float[], float[], int)
def fmul_pythran(a, b, out, n):
    for i in range(n):
        out[i] = a[i] * b[i]

import numpy as np
from fmul_pythran import fmul_pythran
import sys

print(sys.modules["fmul_pythran"])

out = np.empty(4, dtype=np.float64)
fmul_pythran(np.array([0.0, 0.5, 1.0, 1.5]), np.array([1.0, 2.0, 3.0, 4.0]), out, 4)
print(out)

pythran fmul_pythran.py
ls
fmul_pythran.cpython-312-x86_64-linux-gnu.so  fmul_pythran.py  pythran_demo.py
python3 pythran_demo.py
<module 'fmul_pythran' from './fmul_pythran...so'>
[0. 1. 3. 6.]

from time import perf_counter_ns as pc_ns

def work(n):
    s = 0
    for i in range(n):
        s += i*i
    return s

if __name__ == "__main__":
    t = pc_ns()
    work(1000000)
    dt = pc_ns() - t
    print(f"{dt/1e6:.3f} ms")

python3 pc_ns_demo.py 
23.767 ms

import timeit
from pc_ns_demo import work

rs = timeit.repeat(lambda: work(1000000), number=10, repeat=10)

print("runs:")
for i, t in enumerate(rs, 1):
    print(f"  {i:02d}: {t/10*1e3:.3f} ms") 

bs = min(rs)
print(f"min: {bs/10*1e3:.3f} ms")

python3 timeit_demo.py 
runs:
  01: 23.849 ms
  ...
  10: 23.650 ms
min: 23.650 ms

python3 -m timeit -n 10 -r 10 -u msec -s "from pc_ns_demo import work" "work(1000000)"
10 loops, best of 10: 23.5 msec per loop

python3 -m cProfile -o prof.bin pc_ns_demo.py
24.467 ms

python -c "import pstats;p=pstats.Stats('prof.bin');p.sort_stats('tottime').print_stats(20)"
Fri Dec 19 06:00:17 2025    prof.bin

         7 function calls in 0.024 seconds

   Ordered by: internal time

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.024    0.024    0.024    0.024 pc_ns_demo.py:3(work)
   ...

import cProfile
import pstats
from io import StringIO
from pc_ns_demo import work

def kek(a, b, c):
    return work(a) + work(b) + work(c)

pr = cProfile.Profile()
pr.enable()
print(kek(1000000, 2000000, 3000000))
pr.disable()

s = StringIO()
pstats.Stats(pr, stream=s).sort_stats("cumtime").print_stats(5)
print(s.getvalue())

python3 cprofile_demo.py
11999993000001000000
         6 function calls in 0.146 seconds

   Ordered by: cumulative time

   ncalls  tottime  percall  cumtime  percall filename:lineno(function)
        1    0.000    0.000    0.146    0.146 /home/mikhail/cprofile_demo.py:6(kek)
        3    0.146    0.049    0.146    0.049 /home/mikhail/pc_ns_demo.py:3(work)
...