Appelez Rust de Python pour accélérer! Tutoriel PyO3: Emballage d'une partie de fonction simple ➁

Aperçu

1. Il n'est pas préférable en termes de vitesse d'écrire l'algorithme en Pyhton ~
2. Très bien, recherchez quelque chose d'écrit autour de C, C ++ et appelez-le depuis Python pour l'accélérer.
3. Je ne trouve pas de bonne bibliothèque,
4. Oh, s'il a été écrit dans une langue appelée Rust
5. Rust peut-il être appelé depuis Python? ??

C'est Appelez Rust de Python pour accélérer! Tutoriel PyO3: Emballage d'une partie de fonction simple ➀

Ce sera une continuation de.

L'objectif de cette fois

Cette fois, --Ajout de lib.rs --Ajoutez setup.py et compilez réellement

Je continuerai à le faire.

Le but ultime est Être capable d'appeler facilement des fonctions et des classes (comme des choses?) Écrit en rust à partir de python est.

Passer des fonctions Rust à Python

//lib.Continuation de rs
use pyo3::{wrap_pyfunction};

// ======================CREATING MODULE FOR PYTHON==================================================
/// This module is a python module implemented in Rust.
#[pymodule]
fn test_library(py: Python, m: &PyModule) -> PyResult<()> {
    m.add_wrapped(wrap_pyfunction!(get_prime_numbers))?;

    Ok(())
}

ici, #[pymodule]Décorateurtest_libraryDéclare être un module python.

Et la fonction précédente `` get_prime_numbers '',

m.add_wrapped(wrap_pyfunction!(get_prime_numbers))?;

Enveloppé comme une fonction dans ce module.

Enfin, c'est ʻOk (()) `, et ce module est défini comme une fonction.

PyResult<()> 

Je suis un peu inquiet qu'il renvoie un PyResult vide (la fonction Void peut être enveloppée avec ça), J'ai écrit le tutoriel tel quel, en supposant que cette zone est magique.

Créer setup.py

Nous allons créer le familier setup.py qui a également été utilisé en Cython. Cette fois, c'est simple et facile.

setup.py

from setuptools import setup
from setuptools_rust import Binding, RustExtension

setup(name='test_library',
        version='0.1',
        rust_extensions=[
            RustExtension('test_library', 'Cargo.toml',
                binding=Binding.PyO3)],
            zip_safe=False)

name='test_library',

Peut être appelé du côté Python comme ʻimport test_library`.

RustExtension('test_library', 'Cargo.toml',
                binding=Binding.PyO3)],

Ensuite, transformez le module test_library dans lib.rs en une bibliothèque par pyo3. À ce stade, il est très facile d'écrire simplement la dépendance à utiliser comme Cargo.toml. ..

Essayez de construire

Maintenant que nous sommes prêts, construisons et appelons la fonction à partir de Python.

python setup.py install

Et tester le code

test.py

import test_library 
import time
import sys

def get_prime_numbers(n: int):
    flags = [True for _ in range(n+2)]

    upper = int(n ** 0.5)
    for i in range(2, upper+1):
        if not flags[i]:
            continue

        prime = i

        j = prime * 2
        while j <= n:
            flags[j] = False
            j += prime

    primes = []
    for i in range(2, n+1):
        if flags[i]:
            primes.append(i)

    return primes

if __name__  == "__main__":
    # just calling rust function from created library
    a = 123
    b = 456
    c = test_library.sum_as_string(a, b)

    print(c)


    
    # just calling rust function from created library, to find primes
    # rust is (of course) a lot faster than python
    # if you wanna call python function, python test.py, 
    # if you wanna call rust   function, python test.py --rust
    
    use_rust = len(sys.argv) == 2 and sys.argv[1] == "--rust"
    n = 10000


    t1 = time.time()
    for _ in range(10):
        if use_rust:
            primes = test_library.get_prime_numbers(n)
        else:
            primes = get_prime_numbers(n)

    t2 = time.time()

    print(f"time took is: {t2-t1} sec")

Extrait de Run Rust Module from Python (PyO3)

Éxécuter.

python test.py

Une fonction basée sur python s'exécute sur

python test.py --rust

Appelle une fonction basée sur Rust.

résultat,

$ python test.py
time took is: 0.013466835021972656 sec

$ python test.py --rust
time took is: 0.0005574226379394531 sec

Et la différence de vitesse d'exécution est devenue perceptible.

Résumé

Le but ultime est Être capable d'appeler facilement des fonctions et des classes (comme des choses?) Écrit en rust à partir de python C'était, Cette fois, j'ai expliqué comment appeler une fonction écrite en Rust depuis Python. La seule conversion de type que j'ai encore couverte est Vec-> List, donc j'écrirai sur les autres types dans le prochain article. Cependant, la description ne change pas beaucoup, c'est donc facile.

De plus, j'aimerais écrire sur la façon d'analyser le truc de classe de Rust (méthode Struct +) en tant qu'objet de classe du côté Python.

Cette fois par ici.

fin.