PYO3是Python -> Rust / Rust-> Python的第三方库
参考的官方地址： https://pyo3.rs/main/module.html
创建Python模块（打包）
利用pymodule宏创建模块：
use pyo3::prelude::*;
// 创建一个功能
#[pyfunction]
fn double(x: usize) -> usize {
x * 2
}
/// 这个功能以函数的形式拓展在模块当中
#[pymodule]
fn my_extension(py: Python<'_>, m: &PyModule) -> PyResult<()> {
// 拓展的函数名字就叫做double, m是拓展的自带参数
m.add_function(wrap_pyfunction!(double, m)?)?;
Ok(())
}
// 我们可以看一下这个过程宏的源码
#[proc_macro_attribute]
pub fn pymodule(args: TokenStream, input: TokenStream) -> TokenStream {
parse_macro_input!(args as Nothing);
// 整体还是可以理解的，把我们输入的函数转换为ast, 并看看ast语法便以上有没有错误
let mut ast = parse_macro_input!(input as syn::ItemFn);
let options = match PyModuleOptions::from_attrs(&mut ast.attrs) {
Ok(options) => options,
Err(e) => return e.into_compile_error().into(),
};
if let Err(err) = process_functions_in_module(&mut ast) {
return err.into_compile_error().into();
}
// 贴心的位子自动写注释，不过我这里的注释打爆出来一直都是None, 不知道啥情况。
let doc = get_doc(&ast.attrs, None);
// 没有问题就把doc文档（我们Pycharm查看库的时候看到的内玩应一同打包。)
let expanded = pymodule_impl(&ast.sig.ident, options, doc, &ast.vis);
quote!(
#ast
#expanded
)
.into()
}
Pymodule肯定不止能打包函数，还可以打包类的，后面的部分会讲到。
Python模块可以分文件创建相应的内容，不过这一块太简单了，参考官网就可以了。
Python函数
该#[pyfunction]属性用于从 Rust 函数定义 Python 函数。还是一样的，我们随便看一下源码：
// 相较于上面的module, 这个宏就简单很多，当然我不可能取深究最低层的代码，太浪费时间了
#[proc_macro_attribute]
pub fn pyfunction(attr: TokenStream, input: TokenStream) -> TokenStream {
// 把我们的Fn 强制转换成PyFuction类型，然后把就强转
let mut ast = parse_macro_input!(input as syn::ItemFn);
let options = parse_macro_input!(attr as PyFunctionOptions);
let expanded = build_py_function(&mut ast, options).unwrap_or_compile_error();
// 这个宏强转TokenStream
quote!(
#ast
#expanded
)
.into()
}
根据官方文档，我们可以字此基础上做如下操作：
// 重命名
#[pyfunction]
#[pyo3(name = "test2")]
pub fn b(){
println!("Hello I am Lihua")
}
import rust_give_python as ru
if __name__ == '__main__':
ru.test2()
Hello I am Lihua
由于Rust的多线程是真正的多线程，所以我们很想使用类似于闭包的方法让Rust中运行Python的代码，但是比较可惜的是目前， Rust 中的 s 和 Python 中的 callable之间没有转换。这个想法目前还是不可行的，真的是麻中麻。
Python 类
除了函数，我们有时候还需要定义类来更进一步的对Python进行提速封装。官网是这么说的：公开了一组由 Rust 的 proc 宏系统提供支持的属性，用于将 Python 类定义为 Rust 结构。
这一节的宏更类似与修饰器，问题不大，我们直接开冲
#[Pyclass]
定义类数据部分结构的宏。一般选择用结构体定义，也可以接受枚举类型，其他类型不行：
#[proc_macro_attribute]
pub fn pyclass(attr: TokenStream, input: TokenStream) -> TokenStream {
use syn::Item;
// 分语法解析分词并查看有没有错误
let item = parse_macro_input!(input as Item);
match item {
// 这两个地方用的不同语法分析函数，我把struct分析函数放在了下面
Item::Struct(struct_) => pyclass_impl(attr, struct_, methods_type()),
Item::Enum(enum_) => pyclass_enum_impl(attr, enum_, methods_type()),
unsupported => {
syn::Error::new_spanned(unsupported, "#[pyclass] only supports structs and enums.")
.into_compile_error()
.into()
}
}
}
// struct的分析函数
fn pyclass_impl(
attrs: TokenStream,
mut ast: syn::ItemStruct,
methods_type: PyClassMethodsType,
) -> TokenStream {
// 用这个宏价检查结构参数语法
let args = parse_macro_input!(attrs with PyClassArgs::parse_stuct_args);
// 强转py_class
let expanded = build_py_class(&mut ast, args, methods_type).unwrap_or_compile_error();
// 打包
quote!(
#ast
#expanded
)
.into()
}
#[pymethods]
类肯定不能只有结构体，还应该有相应的method方法（类里面的执行代码不叫函数叫方法！！）。来看源码：
pub fn pymethods(_: TokenStream, input: TokenStream) -> TokenStream {
// 编译的时候给一个feature变量？ 主要是看拓展的方法是否为多个
// 之后用pymethods_impl去做语法转换
let methods_type = if cfg!(feature = "multiple-pymethods") {
PyClassMethodsType::Inventory
} else {
PyClassMethodsType::Specialization
};
pymethods_impl(input, methods_type)
}
// 在这里就直接利用quote宏打包了，expand使用的构造pymethod的方法。针对源码非常感兴趣的化自己去看呗
fn pymethods_impl(input: TokenStream, methods_type: PyClassMethodsType) -> TokenStream {
let mut ast = parse_macro_input!(input as syn::ItemImpl);
let expanded = build_py_methods(&mut ast, methods_type).unwrap_or_compile_error();
quote!(
#ast
#expanded
)
.into()
}
-
#[new]
有类就要有实例化嘛， 还有一些常见的方法，不是说你放了Pymodule就能调用了。Rust 方法名称在这里并不重要,我们不是定义完方法就直接可以用Rust的方法名称调用的 所以Rust为我们提供了一些服务名称，首先就是我们实例化的__new__方法.
#[pyclass] pub struct test_class{ pub name: String, pub id:i32, } #[pymethods] impl test_class { #[new] //我们新建一个new方法让类可以在Python中被创建。 fn new() -> test_class{ test_class{name: String::from("hello"), id:1} } } import rust_give_python as ru if __name__ == '__main__': ru.test_class()#[new]方法必须返回T: Into<PyClassInitializer<Self>>orPyResult<T> where T: Into<PyClassInitializer<Self>>。不过我们在构造new的时候一般返回对象本身嘛，不过这也是后话了 -
[#pyo3(get,set,name = “*”)]
对于我们定义好的类来说，虽然他内部的属性已经有了定义的值/ 分配的内存，可是我们刚刚也说过名字毫无意义。我们根本不值到它真正的属性名字叫什么，**而且没有实现__dict__魔法方法你找不到的，，**所以我们就需要用pyo3定义get, set简单的查值和设置值。我们还可以使用name字段位属性重新设定名字
#[pyclass] pub struct test_class{ #[pyo3(get,set)] pub name: String, #[pyo3(get,name="iddd")] pub id:i32, } import rust_give_python as ru if __name__ == '__main__': a = ru.test_class() print(a.name) a.name = "Hello" print(a.iddd) // 要想改变值必须要有set才可以 try: a.iddd = 10 print("set ok") print(a.iddd) except: print("can't set a.iddd") hello 1 can't set a.iddd -
同时上面的表达等价位#[getter] #[setter]
pub struct test_class{ #[pyo3(get,set)] pub name: String, #[pyo3(get,name="iddd")] pub id:i32, pub year:i32 } #[pymethods] impl test_class { #[new] fn new() -> test_class{ test_class{name: String::from("hello"), id:1,year:80} } #[getter] fn get_year(&self) ->PyResult<i32>{ Ok(self.year) } #[setter] fn set_year(&mut self, value:i32){ self.year = value; } import rust_give_python as ru if __name__ == '__main__': a = ru.test_class() a.year = 10 print(a.year) 10
#[classmethod]
除了参数之外，类还需要提供其他方法。classmethod为自定义类创建类方法， 不过我一般不咋用，官网的例子在这：
// 这个例子真的看起来没啥用就不演示
#[pymethods]
impl MyClass {
#[classmethod]
fn cls_method(cls: &PyType) -> PyResult<i32> {
Ok(10)
}
}
扫一扫
898
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
