Dies ist Rust von Python aus aufrufen, um zu beschleunigen! PyO3-Tutorial: Wrapping Classes Part ➀
Es wird eine Fortsetzung von sein.
Das Ziel,
Definieren Sie eine Rust-Klasse (struct + method) und rufen Sie sie von Python aus auf
Es war,
Das letzte Mal habe ich erklärt, wie man eine in Rust geschriebene Klasse aus Python aufruft.
Der Klassenkonstruktor und der Property Getter, Setter könnten auch von Python über PyO3 aufgerufen werden.
Dieses Mal werde ich einige Klassenmethoden hinzufügen und erklären, wie man über PyO3 vom Typ "Rust in Python" konvertiert.
Siehe ** PyO3s Git-Repository ** (hier),
Ich werde erklären, wie das Rust-Objekt mit PyO3 an die Python-Seite übergeben wird.
Vec -> ListHashmap -> DictVec -> TupleEtc.
Verwenden Sie das von load new --lib example bis zum letzten Mal erstellte Projekt.
Natürlich gibt es kein Problem, auch wenn Sie ein neues erstellen.
Als Zusammenfassung habe ich es das letzte Mal möglich gemacht, den getter und setter des Klassenkonstruktors und der Eigenschaft num von Python über PyO3 aufzurufen.
Unten ist der Code, den ich das letzte Mal ausgefüllt habe.
//lib.rs
use pyo3::prelude::*;
use pyo3::{wrap_pyfunction};
// ======================RUST CLASS TO PYTHON ======================================
/// Class for demonstration
// this class, MyClass can be called from python
#[pyclass(module = "my_class")]
struct MyClass {
num: i32,
debug: bool,
}
#[pymethods]
impl MyClass{
#[new]
fn new(num:i32, debug:bool) -> Self{
MyClass{
num: num,
debug: debug
}
}
#[getter]
fn get_num(&self) -> PyResult<i32>{
Ok(self.num)
}
#[setter]
fn set_num(&mut self, num: i32) -> PyResult<()>{
self.num = num;
Ok(())
}
}
// =================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))?;
m.add_class::<MyClass>()?;
Ok(())
}
Dieses Mal werden wir dieser MyClass 6 Funktionen hinzufügen.
Das Folgende ist sofort der Code.
//lib.rs
use pyo3::types::PyType;
use pyo3::types::PyInt;
use pyo3::types::PyList;
use pyo3::types::PyTuple;
use pyo3::types::PyDateTime;
use std::collections::HashMap;
#[pymethods]
impl MyClass{
fn test1(&self) -> PyResult<bool>{
if self.num > 3{
Ok(true)
}else{
Ok(false)
}
}
fn test2(&self) -> PyResult<String>{
if self.debug == true{
let result: &str = "your debug is True";
Ok(result.to_string())
}else{
let result: &str = "your debug is False";
Ok(result.to_string())
}
}
fn test3<'py>(&self, py: Python<'py>) -> PyResult<&'py PyList>{
let mut vec = vec![1,2,3];
let result = PyList::new(py, &vec);
Ok(result)
}
fn test4(&self, py: Python) -> PyResult<PyObject>{
let mut map = HashMap::new();
map.insert("key1", 1);
map.insert("key2", 2);
map.insert("key3", 3);
assert_eq!(map["key1"], 1);
assert_eq!(map["key2"], 2);
assert_eq!(map["key3"], 3);
Ok(map.to_object(py))
}
fn test5(&self) -> PyResult<f64>{
let result:f64 = 1.23;
Ok(result)
}
fn test6<'py>(&self, py: Python<'py>, dt: &PyDateTime) -> PyResult<&'py PyTuple>{
let mut vec = vec![3,4,5];
let result = PyTuple::new(py, &vec);
Ok(result)
}
}
fn test1 Über PyO3 wird "Rust's Bool" an "Python's Bool" übergeben.
fn test2
Übergabe von Rust's String an Python's str über PyO3.
fn test3
Übergabe von Rust's Vec an Python's List über PyO3.
Ich verstehe nicht, wie ich das schreiben soll. ..
fn test4 Übergabe von "Rust's Hashmap" an "Python's Dict" über PyO3.
fn test5
Übergabe von Rust's f64 an Python's float über PyO3.
fn test6 Übergabe von "Rust's Vec" an "Pythons Tupel" über PyO3. Zu diesem Zeitpunkt wird "Python Datetime" als Argument der Funktion empfangen. Ich verstehe nicht, wie ich das schreiben soll. ..
In Bezug auf Test3 und Test6 verstehe ich nicht, wie man ehrlich schreibt, aber ich werde den Test ausführen.
Indem Sie Cargo.toml und setup.py wie zuvor vorbereiten,
python setup.py install
Sie können mit bauen.
Bereiten Sie dann test.py wie folgt vor und führen Sie den Test aus.
test.py
import test_library
if __name__ == "__main__":
# Testing class
print("\ntest for class")
num = 2
debug = True
test = test_library.MyClass(num=num, debug=debug)
print(test.num) # getter test
test.num = 4 # setter test
print(test.num)
result = test.test1()
print(result)
print(type(result))
result = test.test2()
print(result)
print(type(result))
result = test.test3()
print(result)
print(type(result))
result = test.test4()
print(result)
print(type(result))
result = test.test5()
print(result)
print(type(result))
import datetime
now = datetime.datetime.now()
result = test.test6(now)
print(result)
print(type(result))
Dieses Mal habe ich einige Klassenmethoden hinzugefügt und erklärt, wie man über PyO3 von Rust zu Python konvertiert. Obwohl es sich relativ einfacher zu verstehen anfühlt als "Cython", wird die Version von "PyO3" selbst ständig aktualisiert. Daher ist es am besten, sie unter Berücksichtigung der Version zu entwickeln (Fix). Oder Sie sollten Git richtig folgen und auf die Änderung des API-Namens achten.
Rust ist jedoch interessant, deshalb werde ich weiter studieren.
Diesmal hier.
Ende.
Recommended Posts