Rust 数据分析利器polars用法详解
<div id="navCategory"><h5 class="catalogue">目录</h5><ul class="first_class_ul"><li>一、toml</li><li>二、main.rs</li><li>三、其它</li><ul class="second_class_ul"><li>1、feature问题</li><li>2、版本迭代</li></ul></ul></div><p>Polars虽牛刀小试，就显博大精深，在数据分析上，未来有重要一席。<br />下面主要列举一些常见用法。</p><p class="maodian"></p><h2>一、toml</h2>
<p>需要说明的是，在Rust中，不少的功能都需要对应features引入设置，这些需要特别注意，否则编译通不过。<br />以下polars的版本是0.42。<br />相关依赖项如下：</p>
<div class="jb51code"><pre class="brush:plain;">
polars = { version = "0.42", features = ["lazy","dtype-struct","dtype-array","polars-io","dtype-datetime","dtype-date","range","temporal","rank","serde","csv","ndarray","parquet","strings","list_eval"] }
rand = "0.8.5"
chrono = "0.4.38"
serde_json = "1.0.124"
itertools = "0.13"</pre></div>
<p class="maodian"></p><h2>二、main.rs</h2>
<p>部分函数功能还没有完成，用todo标示，请大家注意。</p>
<div class="jb51code"><pre class="brush:plain;">#!
use aggregations::AggList;
use polars::prelude::*;
use std::time::Instant;
use serde_json::*;
use chrono::{NaiveDate};
fnmain(){
//create_df_by_series();
//create_df_by_df_macro();
//df_apply();
// 需要把相关函数放在里面即可，这里不一一列示。
//df_to_vec_tuples_by_izip();
//write_read_parquet_files();
//date_to_str_in_column();
//str_to_datetime_date_cast_in_df();
//create_list_in_df_by_apply();
//unnest_struct_in_df();
//as_struct_in_df();
//struct_apply_in_df();
//create_list_in_df();
//structs_in_df();
//df_to_structs_by_zip();
//df_to_structs_by_iter_version_0_4_2();
//create_list_in_df();
eval_in_df();
}
fn create_df_by_series(){
println!("------------- create_df_by_series test ---------------- ");
let s1 = Series::new("from vec", vec!);
let s2 = Series::new("from slice", &);
let s3 = Series::new("from array", ["rust", "go", "julia"]);
let df = DataFrame::new(vec!).unwrap();
println!("{:?}", &df);
}
fn create_df_by_df_macro(){
println!("------------- create_df_by_macro test ---------------- ");
let df1: DataFrame = df!("D1" => &,"D2" => &).unwrap();
let df2 = df1
.lazy()
.select(&[
col("D1").count().alias("total"),
col("D1").filter(col("D1").gt(lit(2))).count().alias("D1 > 3"),
])
.collect()
.unwrap();
println!("{}", df2);
}
fn rank(){
println!("------------- rank test ---------------- ");
// 注意：toml => feature : rank
let mut df = df!(
"scores" => ["A", "A", "A", "B", "C", "B"],
"class" =>
).unwrap();
let df = df
.clone().lazy()
.with_column(col("class")
.rank(RankOptions{method: RankMethod::Ordinal, descending: false}, None)
.over()
.alias("rank_")
).sort_by_exprs(, Default::default())
;
println!("{:?}", df.collect().unwrap().head(Some(3)));
}
fn head_tail_sort(){
println!("------------------head_tail_sort test-------------------");
letdf = df!(
"scores" => ["A", "B", "C", "B", "A", "B"],
"class" =>
).unwrap();
let head = df.head(Some(3));
let tail = df.tail(Some(3));
// 对value列进行sort,生成新的series，并进行排序
let sort = df.lazy().select().collect();
println!("df head :{:?}",head);
println!("df tail:{:?}",tail);
println!("df sort:{:?}",sort);
}
fn filter_group_by_agg(){
println!("----------filter_group_by_agg test--------------");
use rand::{thread_rng, Rng};
let mut arr = ;
thread_rng().fill(&mut arr);
let df = df! (
"nrs" => &,
"names" => &,
"random" => &arr,
"groups" => &["A", "A", "B", "C", "B"],
).unwrap();
let df2 = df.clone().lazy().filter(col("groups").eq(lit("A"))).collect().unwrap();
println!("df2 :{:?}",df2);
println!("{}", &df);
let out = df
.lazy()
.group_by()
.agg([
sum("nrs"), // sum nrs by groups
col("random").count().alias("count"), // count group members
// sum random where name != null
col("random")
.filter(col("names").is_not_null())
.sum()
.name()
.suffix("_sum"),
col("names").reverse().alias("reversed names"),
])
.collect().unwrap();
println!("{}", out);
}
fn filter_by_exclude(){
println!("----------filter_by_exclude----------------------");
let df = df!(
"code" => &["600036.SH".to_string(),"600036.SH".to_string(),"600036.SH".to_string()],
"date" =>&[NaiveDate::from_ymd_opt(2015, 3, 14).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 15).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 16).unwrap(),],
"close" => &,
"open" => &,
"high" => &,
"low" => &,
).unwrap();
let lst = df["date"].as_list().slice(1,1);
println!("s :{:?}",lst);
// 下面all() 可以用col(*)替代；
let df_filter = df.lazy().select()]).collect().unwrap();
println!("df_filter :{}",df_filter);
}
fn windows_over(){
println!("------------- windows_over test ---------------- ");
letdf = df!(
"key" => ["a", "a", "a", "a", "b", "c"],
"value" =>
).unwrap();
// over()函数：col("value").min().over(),表示：请根据col("key")进行分类，再对分类得到的组求最小值操作；
let df = df
.clone().lazy()
.with_column(col("value")
.min() // .max(), .mean()
.over()
.alias("over_min"))
.with_column(col("value").max().over().alias("over_max"));
println!("{:?}", df.collect().unwrap().head(Some(10)));
}
//read_csv
fn lazy_read_csv(){
println!("------------- lazy_read_csv test ---------------- ");
// features => lazy and csv
// 请根据自己文件情况进行设置
let filepath ="../my_duckdb/src/test.csv";
// CSV数据格式
// 600036.XSHG,2079/7/24,3345.9,3357.8,3326.7,3357,33589,69181710.57,1
// 600036.XSHG,2079/7/25,3346,3357.9,3326.8,3357.1,33590,69184251.47,1
let polars_lazy_csv_time= Instant::now();
let p = LazyCsvReader::new(filepath)
.with_try_parse_dates(true)//需要增加Available on crate feature temporal only.
.with_has_header(true)
.finish().unwrap();
letdf = p.collect().expect("error to dataframe!");
println!("polars lazy 读出csv的行和列数：{:?}",df.shape());
println!("polars lazy 读csv 花时： {:?} 秒！", polars_lazy_csv_time.elapsed().as_secs_f32());
}
fn read_csv(){
println!("------------- read_csv test ---------------- ");
// features => polars-io
use std::fs::File;
let csv_time= Instant::now();
let filepath = "../my_duckdb/src/test.csv";
// CSV数据格式
// 600036.XSHG,2079/7/24,3345.9,3357.8,3326.7,3357,33589,69181710.57,1
// 600036.XSHG,2079/7/25,3346,3357.9,3326.8,3357.1,33590,69184251.47,1
let file = File::open(filepath)
.expect("could not read file");
let df = CsvReader::new(file).finish().unwrap();
//println!("df:{:?}",df);
println!("读出csv的行和列数：{:?}",df.shape());
println!("读csv 花时： {:?} 秒！",csv_time.elapsed().as_secs_f32());
}
fn read_csv2(){
println!("------------- read_csv2 test ---------------- ");
// features => polars-io
// 具体按自己目录路径下的文件
let filepath = "../my_duckdb/src/test.csv"; //请根据自已文件情况进行设置
// CSV数据格式
// 600036.XSHG,2079/7/24,3345.9,3357.8,3326.7,3357,33589,69181710.57,1
// 600036.XSHG,2079/7/25,3346,3357.9,3326.8,3357.1,33590,69184251.47,1
let df = CsvReadOptions::default()
.with_has_header(true)
.try_into_reader_with_file_path(Some(filepath.into())).unwrap()
.finish().unwrap();
println!("read_csv2 => df {:?}",df)
}
fn parse_date_csv(){
println!("------------- parse_date_csv test ---------------- ");
// features => polars-io
let filepath = "../my_duckdb/src/test.csv";
// 读出csv，并对csv中date类型进行转换
// CSV数据格式
// 600036.XSHG,2019/7/24,3345.9,3357.8,3326.7,3357,33589,69181710.57,1
// 600036.XSHG,2019/7/25,3346,3357.9,3326.8,3357.1,33590,69184251.47,1
let df = CsvReadOptions::default()
.map_parse_options(|parse_options| parse_options.with_try_parse_dates(true))
.try_into_reader_with_file_path(Some(filepath.into()))
.unwrap()
.finish()
.unwrap();
println!("{}", &df);
}
fn write_csv_df(){
println!("-----------write_csv_df test -------------------------");
// toml features => csv
// features => polars-io
let mut df = df!(
"code" => &["600036.SH".to_string(),"600036.SH".to_string(),"600036.SH".to_string()],
"date" =>&[NaiveDate::from_ymd_opt(2015, 3, 14).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 15).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 16).unwrap(),],
"close" => &,
"open" => &,
"high" => &,
"low" => &,
).unwrap();
let mut file = std::fs::File::create("600036SH.csv").unwrap();
CsvWriter::new(&mut file).finish(&mut df).unwrap();
}
fn iter_dataframe_as_row() {
println!("------------- iter_dataframe_as_row test ---------------- ");
let starttime = Instant::now();
let df: DataFrame = df!("D1" => &,"D2" => &).unwrap();
let (_row,_col) = df.shape();
for i in 0.._row{
let mut rows = Vec::new();
for j in 0.._col{
let value = df.get(i).unwrap();
rows.push(value);
}
}
println!("dataframe按行遍历cost time :{:?} seconds!",starttime.elapsed().as_secs_f32());
}
fn join_concat(){
println!("------------- join_concat test ---------------- ");
// 创建表结构，内部有空数据
let df = df! [
// 表头 对应数据
"Model" => ["iPhone XS", "iPhone 12", "iPhone 13", "iPhone 14", "Samsung S11", "Samsung S12", "Mi A1", "Mi A2"],
"Company" => ["Apple", "Apple", "Apple", "Apple", "Samsung", "Samsung", "Xiao Mi", "Xiao Mi"],
"Sales" => ,
"Comment" => ,
].unwrap();
let df_price = df! [
"Model" => ["iPhone XS", "iPhone 12", "iPhone 13", "iPhone 14", "Samsung S11", "Samsung S12", "Mi A1", "Mi A2"],
"Price" => ,
"Discount" => ,
].unwrap();
// 合并
// join()接收5个参数，分别是：要合并的DataFrame，左表主键，右表主键，合并方式
letdf_join = df.join(&df_price, ["Model"], ["Model"], JoinArgs::from(JoinType::Inner)).unwrap();
println!("{:?}", &df_join);
let df_v1 = df!(
"a"=> &,
"b"=> &,
).unwrap();
let df_v2 = df!(
"a"=> &,
"b"=> &,
).unwrap();
let df_vertical_concat = concat(
,
UnionArgs::default(),
).unwrap()
.collect().unwrap();
println!("{}", &df_vertical_concat);
}
fn get_slice_scalar_from_df(){
println!("------------- get_slice_scalar_from_df test ---------------- ");
let df: DataFrame = df!("D1" => &,"D2" => &).unwrap();
// slice(1,4): 从第2行开始(包含)，各列向下共取4行
let slice = &df.slice(1,4);
println!("slice :{:?}",&slice);
// 获取第2列第3个值的标量
let scalar =df.get(3).unwrap();
println!("saclar :{:?}",scalar);
}
fn replace_drop_col(){
println!("------------- replace_drop_col test ---------------- ");
// toml :features => replace
let mut df: DataFrame = df!("D1" => &,"D2" => &).unwrap();
let new_s1 = Series::new("", &); // ""为名字不变；
// D1列进行替换
let df2 = df.replace("D1", new_s1).unwrap();
// 删除D2列
let df3 = df2.drop_many(&["D2"]);
println!("df3:{:?}",df3);
}
fn drop_null_fill_null(){
println!("------------- drop_null_fill_null test ---------------- ");
let df: DataFrame = df!("D1" => &,"D2" => &).unwrap();
// 取当前列第一个非空的值填充后面的空值
let df2 = df.fill_null(FillNullStrategy::Forward(None)).unwrap();
// Forward(Option)：向后遍历，用遇到的第一个非空值（或给定下标位置的值）填充后面的空值
// Backward(Option)：向前遍历，用遇到的第一个非空值（或给定下标位置的值）填充前面的空值
// Mean：用算术平均值填充
// Min：用最小值填充
// Max: 用最大值填充
// Zero：用0填充
// One：用1填充
// MaxBound：用数据类型的取值范围的上界填充
// MinBound：用数据类型的取值范围的下界填充
println!("fill_null :{:?}", df2);
// 删除D1列中的None值
let df3 = df2.drop_nulls(Some(&["D1"])).unwrap();
println!("drop_nulls :{:?}",df3);
}
fn compute_return(){
println!("-----------compute_return test -----------------------");
let df = df!(
"code" => &["600036.SH".to_string(),"600036.SH".to_string(),"600036.SH".to_string()],
"date" =>&[NaiveDate::from_ymd_opt(2015, 3, 14).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 15).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 16).unwrap(),],
"close" => &,
"open" => &,
"high" => &,
"low" => &,
).unwrap();
let _df = df
.clone()
.lazy()
.with_columns([(col("close")/col("close").first()-lit(1.0)).alias("ret")])
.collect().unwrap();
println!("_df :{}",_df)
}
fn standardlize_center(){
println!("------------- standardlize_center test ---------------- ");
let df: DataFrame = df!("D1" => &,"D2" => &).unwrap();
// 进行标准化：对所有的列，每个值除以本列最大值
// cast(): 由int =>Float64
let standardization = df.lazy().select();
// 对于标准化后的列，进行中心化
let center = standardization
.select()
.collect()
.unwrap();
println!("standardlize : {:?}",center);
}
fn create_list_in_df_by_apply(){
println!("----------creat_list_in_df_by_apply test ------------------------");
let df = df!(
"lang" => &["go","rust", "go", "julia","julia","rust","rust"],
"users" => &,
"year" =>&["2020","2021","2022","2023","2024","2025","2026"]
).unwrap();
println!("df :{}",df);
let out = df
.clone()
.lazy()
.group_by()
.agg([
col("users")
.apply(|s| {
let v = s.i32().unwrap();
let out = v
.into_iter()
.map(|v| match v {
Some(v_) => v_ ,
_ => 0
})
.collect::<Vec<i32>>();
Ok(Some(Series::new("_", out)))
}, GetOutput::default())
.alias("aggr_vec"),
])
//.with_column(col("aggr_sum").list().alias("aggr_sum_first"))
.collect()
.unwrap();
println!("{}", out);
}
fn create_struct_in_df_by_apply(){
println!("-----------------create_struct_in_df_by_apply test -------------------------");
// TOML features => "dtype-struct"
use polars::prelude::*;
let df = df!(
"keys" => &["a", "a", "b"],
"values" => &,
).unwrap();
let out = df
.clone()
.lazy()
.with_column(col("values").apply(
|s| {
let s = s.i32()?;
let out_1: Vec<Option<i32>> = s.into_iter().map(|v| match v {
Some(v_) => Some(v_ * 10),
_ => None,
}).collect();
let out_2: Vec<Option<i32>> = s.into_iter().map(|v| match v {
Some(v_) => Some(v_ * 20),
_ => None,
}).collect();
let out = df! (
"v1" => &out_1,
"v2" => &out_2,
).unwrap()
.into_struct("vals")
.into_series();
Ok(Some(out))
},
GetOutput::default()))
.collect()
.unwrap();
println!("{}", out);
}
fn field_value_counts(){
println!("--------------field_value_counts test---------------");
let ratings = df!(
"Movie"=> &["Cars", "IT", "ET", "Cars", "Up", "IT", "Cars", "ET", "Up", "ET"],
"Theatre"=> &["NE", "ME", "IL", "ND", "NE", "SD", "NE", "IL", "IL", "SD"],
"Avg_Rating"=> &,
"Count"=> &,
).unwrap();
println!("{}", &ratings);
let out = ratings
.clone()
.lazy()
.select()
.collect().unwrap();
println!("{}", &out);
}
// 宏
macro_rules! structs_to_dataframe {
($input:expr, [$($field:ident),+]) => {
{
// Extract the field values into separate vectors
$(let mut $field = Vec::new();)*
for e in $input.into_iter() {
$($field.push(e.$field);)*
}
df! {
$(stringify!($field) => $field,)*
}
}
};
}
macro_rules! dataframe_to_structs_todo {
($df:expr, $StructName:ident,[$($field:ident),+]) => {
{
// 把df 对应的fields =>Vec<StructName>,
let mut vec:Vec<$StructName> = Vec::new();
vec
}
};
}
fn df_to_structs_by_macro_todo(){
println!("---------------df_to_structs_by_macro_todo test -------------------");
let df = df!(
"date" =>&[NaiveDate::from_ymd_opt(2015, 3, 14).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 15).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 16).unwrap(),],
"close" => &,
"open" => &,
"high" => &,
"low" => &,
).unwrap();
// 把df =>Vec<Bar>
struct Bar {
date:NaiveDate,
close:f64,
open:f64,
high:f64,
low:f64,
}
impl Bar {
fn bar(date:NaiveDate, close:f64,open:f64,high:f64,low:f64) -> Self{
Bar{date,close,open,high,low}
}
}
let bars: Vec<Bar> = dataframe_to_structs_todo!(df, Bar,);
println!("df:{:?}",df);
}
fn structs_to_df_by_macro(){
println!(" ---------------- structs_to_df_by_macro test -----------------------");
struct Bar {
date:NaiveDate,
close:f64,
open:f64,
high:f64,
low:f64,
}
impl Bar {
fn new(date:NaiveDate, close:f64,open:f64,high:f64,low:f64) -> Self{
Bar{date,close,open,high,low}
}
}
let test_bars:Vec<Bar> = vec![Bar::new(NaiveDate::from_ymd_opt(2024,1,1).unwrap(),10.1,10.12,10.2,9.99),
Bar::new(NaiveDate::from_ymd_opt(2024,1,2).unwrap(),10.2,10.22,10.3,10.1)];
let df = structs_to_dataframe!(test_bars, ).unwrap();
println!("df:{:?}",df);
}
// polars: version 0.41.3=>work; version0.42 => no work!
// fn df_to_structs_by_iter_version_0_4_1(){
// println!("---------------df_to_structs_by_iter test----------------");
// // toml :features => "dtype-struct"
// let now = Instant::now();
// #
// struct Bar {
// code :String,
// date:NaiveDate,
// close:f64,
// open:f64,
// high:f64,
// low:f64,
// }
// impl Bar {
// fn new(code:String,date:NaiveDate, close:f64,open:f64,high:f64,low:f64) -> Self{
// Bar{code,date,close,open,high,low}
// }
// }
// let df = df!(
// "code" => &["600036.SH".to_string(),"600036.SH".to_string(),"600036.SH".to_string()],
// "date" =>&[NaiveDate::from_ymd_opt(2015, 3, 14).unwrap(),
// NaiveDate::from_ymd_opt(2015, 3, 15).unwrap(),
// NaiveDate::from_ymd_opt(2015, 3, 16).unwrap(),],
// "close" => &,
// "open" => &,
// "high" => &,
// "low" => &,
// ).unwrap();
// let mut bars:Vec<Bar> = Vec::new();
// let rows_data = df.into_struct("bars");
// let start_date = NaiveDate::from_ymd_opt(1970, 1, 2).unwrap();
// forrow_data in &rows_data {
// let code = row_data.get(0).unwrap();
// let mut new_code = "".to_string();
// if let &AnyValue::String(value) = code{
// new_code = value.to_string();
// }
// let mut new_date = NaiveDate::from_ymd_opt(2000,1,1).unwrap();
// let since_days = start_date.signed_duration_since(NaiveDate::from_ymd_opt(1,1,1).unwrap());
// let date = row_data.get(1).unwrap();
// if let &AnyValue::Date(dt) = date {
// let tmp_date = NaiveDate::from_num_days_from_ce_opt(dt).unwrap();
// new_date = tmp_date.checked_add_signed(since_days).unwrap();
// }
// let open =row_data.extract::<f64>().unwrap();
// let high = row_data.extract::<f64>().unwrap();
// let close =row_data.extract::<f64>().unwrap();
// let low = row_data.extract::<f64>().unwrap();
// bars.push(Bar::new(new_code,new_date,close,open,high,low));
// }
// println!("df_to_structs2 => structchunk : cost time :{:?}",now.elapsed().as_secs_f32());
// println!("bars :{:?}",bars);
// }
//polars version >=0.42
fn df_to_structs_by_iter_version_0_4_2(){
println!("---------------df_to_structs_by_iter_version_0_4_2 test----------------");
// toml :features => "dtype-struct"
let now = Instant::now();
#
struct Bar {
code :String,
date:NaiveDate,
close:f64,
open:f64,
high:f64,
low:f64,
}
impl Bar {
fn new(code:String,date:NaiveDate, close:f64,open:f64,high:f64,low:f64) -> Self{
Bar{code,date,close,open,high,low}
}
}
let df = df!(
"code" => &["600036.SH".to_string(),"600036.SH".to_string(),"600036.SH".to_string()],
"date" =>&[NaiveDate::from_ymd_opt(2015, 3, 14).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 15).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 16).unwrap(),],
"close" => &,
"open" => &,
"high" => &,
"low" => &,
).unwrap();
let mut bars:Vec<Bar> = Vec::new();
let rows = df.into_struct("bars").into_series();
let start_date = NaiveDate::from_ymd_opt(1970, 1, 2).unwrap();
for i in 0..rows.len(){
let row_values = &rows.get(i).unwrap();
//println!("i:{} row_values:{}",i,row_values);
let values:Vec<AnyValue> = row_values._iter_struct_av().map(|v|v).collect();
let code = &values;
let mut new_code = "".to_string();
if let &AnyValue::String(value) = &code{
new_code = value.to_string();
}
let mut new_date = NaiveDate::from_ymd_opt(2000,1,1).unwrap();
let since_days = start_date.signed_duration_since(NaiveDate::from_ymd_opt(1,1,1).unwrap());
let date = &values;
if let &AnyValue::Date(dt) = date {
let tmp_date = NaiveDate::from_num_days_from_ce_opt(dt).unwrap();
new_date = tmp_date.checked_add_signed(since_days).unwrap();
}
let open= values.extract::<f64>().unwrap();
let high= values.extract::<f64>().unwrap();
let close = values.extract::<f64>().unwrap();
let low = values.extract::<f64>().unwrap();
//println!("code :{},date:{} open:{} high:{} close:{} low:{}",new_code,date,open,high,close,low);
bars.push(Bar::new(new_code,new_date,close,open,high,low));
}
println!("df_to_structs_by_iter_version_0_4_2 : cost time :{:?}",now.elapsed().as_secs_f32());
println!("bars :{:?}",bars);
}
fn df_to_structs_by_zip(){
println!("-----------df_to_structs_by_zip test --------------------");
// 同样适用df -> struct ,tuple，hashmap 等
let now = Instant::now();
#
struct Bar {
code :String,
date:NaiveDate,
close:f64,
open:f64,
high:f64,
low:f64,
}
impl Bar {
fn new(code:String,date:NaiveDate, close:f64,open:f64,high:f64,low:f64) -> Self{
Bar{code,date,close,open,high,low}
}
}
let df = df!(
"code" => &["600036.SH".to_string(),"600036.SH".to_string(),"600036.SH".to_string()],
"date" =>&[NaiveDate::from_ymd_opt(2015, 3, 14).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 15).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 16).unwrap(),],
"close" => &,
"open" => &,
"high" => &,
"low" => &,
).unwrap();
let bars : Vec<Bar> = df["code"].str().unwrap().iter()
.zip(df["date"].date().unwrap().as_date_iter())
.zip(df["close"].f64().unwrap().iter())
.zip(df["open"].f64().unwrap().iter())
.zip(df["high"].f64().unwrap().iter())
.zip(df["low"].f64().unwrap().iter())
.map(|(((((code,date),close),open),high),low)|
Bar::new(code.unwrap().to_string(),
date.unwrap(),
close.unwrap(),
open.unwrap(),
high.unwrap(),
low.unwrap())).collect();
println!("df_to_structs_by_zip => zip : cost time :{:?} seconds!",now.elapsed().as_secs_f32());
println!("bars :{:?}",bars);
//izip! from itertools --其它参考--，省各种复杂的括号！
//use itertools::izip;
//izip!(code, date, close, open,high,low).collect::<Vec<_>>() // Vec of 4-tuples
}
fn df_to_vec_tuples_by_izip(){
println!("-------------df_to_tuple_by_izip test---------------");
use itertools::izip;
// In my real code this is generated from two joined DFs.
let df = df!(
"code" => &["600036.sh".to_string(),"600036.sh".to_string(),"600036.sh".to_string()],
"date" => &[NaiveDate::from_ymd_opt(2015, 3, 14).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 15).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 16).unwrap(),],
"close" => &,
"open" => &,
"high" => &,
"low" => &,
).unwrap();
let mut dates = df.column("date").unwrap().date().unwrap().as_date_iter();
let mut codes = df.column("code").unwrap().str().unwrap().iter();
let mut closes = df.column("close").unwrap().f64().unwrap().iter();
let mut tuples = Vec::new();
for (date, code, close) in izip!(&mut dates, &mut codes, &mut closes)
{
//println!("{:?} {:?} {:?}", date.unwrap(), code.unwrap(), close.unwrap());
tuples.push((date.unwrap(),code.unwrap(),close.unwrap()));
}
// 或这种方式
let tuples2 = izip!(&mut dates, &mut codes, &mut closes).collect::<Vec<_>>();
println!("tuples:{:?}",tuples);
println!("tuples2 :{:?}",tuples2);
}
fn series_to_vec(){
println!("------------series_to_vec test-----------------------");
let df = df!(
"date" =>&[NaiveDate::from_ymd_opt(2015, 3, 14).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 15).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 16).unwrap(),],
).unwrap();
let vec :Vec<Option<NaiveDate>>= df["date"].date().unwrap().as_date_iter().collect();
println!("vec :{:?}",vec)
}
fn series_to_vec2(){
println!("------------series_to_vec2 test----------------------");
let df = df!("lang" =>&["rust","go","julia"],).unwrap();
let vec:Vec<Option<&str>> = df["date"].str().unwrap()
.into_iter()
.map(|s|
match s{
Some(v_) => Some(v_),
_ => None,
}).collect();
println!("vec:{:?}",vec);
}
fn structs_in_df(){
println!("-----------structs_in_df test -----------------");
// feature => dtype-struct
let df = df!(
"code" => &["600036.SH".to_string(),"600036.SH".to_string(),"600036.SH".to_string()],
"date" =>&[NaiveDate::from_ymd_opt(2015, 3, 14).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 15).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 16).unwrap(),],
"close" => &,
"open" => &,
"high" => &,
"low" => &,
).unwrap()
.into_struct("bars")
.into_series();
println!("{}", &df);
// how to get series from struct column?
let out = df.struct_().unwrap().field_by_name("close").unwrap();
println!("out :{}",out);
// how to get struct value in df
}
fn list_in_df(){
println!("-------------list_in_df test ------------------------------");
let df = df!(
"code" => &["600036.SH".to_string(),"600036.SH".to_string(),"600036.SH".to_string()],
"date" =>&[NaiveDate::from_ymd_opt(2015, 3, 14).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 15).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 16).unwrap(),],
"close" => &,
"open" => &,
"high" => &,
"low" => &,
).unwrap();
let lst = df["close"].as_list().get(0).unwrap();
println!("lst :{:?}",lst);
}
fn serialize_df_to_json(){
println!("--------------- serialize_df_to_json test -----------------------");
// toml features => serde
let df = df!(
"code" => &["600036.SH".to_string(),"600036.SH".to_string(),"600036.SH".to_string()],
"date" =>&[NaiveDate::from_ymd_opt(2015, 3, 14).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 15).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 16).unwrap(),],
"close" => &,
"open" => &,
"high" => &,
"low" => &,
).unwrap();
let df_json = serde_json::to_value(&df).unwrap();
println!("df_json {df_json}");
}
fn serialize_df_to_binary_todo(){
println!("---------serialize_df_to_binary_todo test -------------");
// toml features => serde
let df = df!(
"code" => &["600036.SH".to_string(),"600036.SH".to_string(),"600036.SH".to_string()],
"date" =>&[NaiveDate::from_ymd_opt(2015, 3, 14).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 15).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 16).unwrap(),],
"close" => &,
"open" => &,
"high" => &,
"low" => &,
).unwrap();
// todo
//let df_binary = serde_json::to_value(&df).unwrap();
//println!("df_json {df_binary}");
}
fn df_to_ndarray(){
println!("-------------- df_to_ndarray test ------------------------");
// toml features =>ndarray
let df = df!(
"code" => &["600036.SH".to_string(),"600036.SH".to_string(),"600036.SH".to_string()],
"date" =>&[NaiveDate::from_ymd_opt(2015, 3, 14).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 15).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 16).unwrap(),],
"close" => &,
"open" => &,
"high" => &,
"low" => &,
).unwrap();
// ndarray 化： 先去除非f64列
let df_filter = df.lazy().select()]).collect().unwrap();
let ndarray = df_filter.to_ndarray::<Float64Type>(IndexOrder::Fortran).unwrap();
println!("ndarray :{}",ndarray);
}
fn df_apply(){
println!("--------------df_apply--------------------");
// df_apply: apply应用于df的一列
// 将其中的"code"列小写改成大写
// mut !
let mut df = df!(
"code" => &["600036.sh".to_string(),"600036.sh".to_string(),"600036.sh".to_string()],
"date" => &[NaiveDate::from_ymd_opt(2015, 3, 14).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 15).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 16).unwrap(),],
"close" => &,
"open" => &,
"high" => &,
"low" => &,
).unwrap();
//
fn code_to_uppercase(code_val: &Series) -> Series {
code_val.str()
.unwrap()
.into_iter()
.map(|opt_code: Option<&str>| {
opt_code.map(|code: &str| code.to_uppercase())
})
.collect::<StringChunked>()
.into_series()
}
// 对 code列进行str_to_upper操作 ,把本列的小写改成大写,有两种方法
// method 1
//df.apply("code", code_to_uppercase).unwrap();
// method 2
df.apply_at_idx(0, code_to_uppercase).unwrap(); // 对第0列，即首列进行操作
println!("df {}",df);
}
fn write_read_parquet_files(){
println!("------------ write_read_parquet_files test -------------------------");
// features =>parquet
let mut df = df!(
"code" => &["600036.sh".to_string(),"600036.sh".to_string(),"600036.sh".to_string()],
"date" => &[NaiveDate::from_ymd_opt(2015, 3, 14).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 15).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 16).unwrap(),],
"close" => &,
"open" => &,
"high" => &,
"low" => &,
).unwrap();
write_parquet(&mut df);
let df_ = read_parquet("600036SH.parquet");
let _df_ = scan_parquet("600036SH.parquet").select().collect().unwrap();
assert_eq!(df,df_);
assert_eq!(df,_df_);
println!("pass write_read parquet test!");
fn write_parquet(df : &mut DataFrame){
let mut file = std::fs::File::create("600036SH.parquet").unwrap();
ParquetWriter::new(&mut file).finish(df).unwrap();
}
fn read_parquet(filepath:&str) ->DataFrame{
let mut file = std::fs::File::open(filepath).unwrap();
let df = ParquetReader::new(&mut file).finish().unwrap();
df
}
fn scan_parquet(filepath:&str) ->LazyFrame{
let args = ScanArgsParquet::default();
let lf = LazyFrame::scan_parquet(filepath, args).unwrap();
lf
}
}
fn date_to_str_in_column(){
println!("---------------date_t0_str test----------------------");
// feature => temporal
let mut df = df!(
"code" => &["600036.sh".to_string(),"600036.sh".to_string(),"600036.sh".to_string()],
"date" => &[NaiveDate::from_ymd_opt(2015, 3, 14).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 15).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 16).unwrap(),],
"close" => &,
"open" => &,
"high" => &,
"low" => &,
).unwrap();
// 增加一列，把date -> date_str
let df = df
.clone()
.lazy()
.with_columns().dt().to_string("%Y-%h-%d").alias("date_str")])
.collect()
.unwrap();
println!("df:{}",df);
}
fn when_logicial_in_df(){
println!("------------------when_condition_in_df test----------------------");
let df = df!("name" =>&["c","julia","go","python","rust","c#","matlab"],
"run-time"=>&).unwrap();
// 当运行速度要在之间为true,其它为false
let df_conditional = df
.clone()
.lazy()
.select([
col("run-time"),
when(col("run-time").lt_eq(1.50).and(col("run-time").gt_eq(1.0)))
.then(lit(true))
.otherwise(lit(false))
.alias("speed_conditional"),
])
.collect().unwrap();
println!("{}", &df_conditional);
}
fn str_to_datetime_date_cast_in_df(){
println!("--------------str_to_datetime_date_cast_in_df test---------------------------");
// features => strings 否则str()有问题！
let df = df!(
"custom" => &["Tom","Jack","Rose"],
"login" => &["2024-08-14","2024-08-12","2023-08-09"],//首次登陆日期
"order" => &["2024-08-14 10:15:32","2024-08-14 11:22:32","2024-08-14 14:12:52"],//下单时间
"send" => &["2024-08-15 10:25:38","2024-08-15 14:28:38","2024-08-16 09:07:32"],//快递时间
).unwrap();
let out = df
.lazy()
.with_columns()
.with_columns([col("login").str().to_datetime(
Some(TimeUnit::Microseconds),
None,
StrptimeOptions::default(),
lit("raise")).alias("login_dtime")])
.with_columns([
col("order").str().strptime(
DataType::Datetime(TimeUnit::Milliseconds, None),
StrptimeOptions::default(),
lit("raise"),
).alias("order_dtime"),
col("send").str().strptime(
DataType::Datetime(TimeUnit::Milliseconds, None),
StrptimeOptions::default(),
lit("raise"), // raise an error if the parsing fails
).alias("send_dtime"),
])
.with_columns([(col("send_dtime") - col("order_dtime"))
.alias("duration(seconds)")
.dt()
.total_seconds()])
.collect().unwrap();
println!("out :{}",out);
}
fn unnest_struct_in_df(){
println!("--------------- unnest_struct_in_df test---------------------");
// unnest() =>将dataframe中struct列执行展开操作
// 生成带struct的dataframe
let mut df: DataFrame = df!("company" => &["ailibaba", "baidu"],
"profit" => &).unwrap();
let series = df.clone().into_struct("info").into_series();
let mut _df = df.insert_column(0, series).unwrap();
println!("_df :{}",df);
// unnest() <=> into_struct
let out = df.lazy()
.with_column(col("info").struct_().rename_fields(vec!["co.".to_string(), "pl".to_string()]))
// 将struct所有字段展开
.unnest(["info"])
.collect()
.unwrap();
println!("out :{}", out);
// _df :shape: (2, 3)
// ┌───────────────────────────┬──────────┬──────────────┐
// │ info ┆ company┆ profit │
// │ --- ┆ --- ┆ --- │
// │ struct ┆ str ┆ f64 │
// ╞═══════════════════════════╪══════════╪══════════════╡
// │ {"ailibaba",7.77277778e8} ┆ ailibaba ┆ 7.77277778e8 │
// │ {"baidu",8.6556e7} ┆ baidu ┆ 8.6556e7 │
// └───────────────────────────┴──────────┴──────────────┘
// out :shape: (2, 4)
// ┌──────────┬──────────────┬──────────┬──────────────┐
// │ co. ┆ pl ┆ company┆ profit │
// │ --- ┆ --- ┆ --- ┆ --- │
// │ str ┆ f64 ┆ str ┆ f64 │
// ╞══════════╪══════════════╪══════════╪══════════════╡
// │ ailibaba ┆ 7.77277778e8 ┆ ailibaba ┆ 7.77277778e8 │
// │ baidu ┆ 8.6556e7 ┆ baidu ┆ 8.6556e7 │
// └──────────┴──────────────┴──────────┴──────────────┘
}
fn as_struct_in_df(){
println!("---------- as_struct_in_df test ----------------------");
// features = >lazy
let df: DataFrame = df!("company" => &["ailibaba", "baidu"],
"profit" => &).unwrap();
// as_struct: 生成相关struct列
let _df = df.clone().lazy()
.with_columns(
)
.alias("info")])
.collect()
.unwrap();
let df_= df.clone().lazy()
.with_columns(
)
.alias("info")])
.collect()
.unwrap();
assert_eq!(_df,df_);
println!("df :{}",_df);
// df :shape: (2, 3)
// ┌──────────┬──────────────┬───────────────────────────┐
// │ company┆ profit ┆ info │
// │ --- ┆ --- ┆ --- │
// │ str ┆ f64 ┆ struct │
// ╞══════════╪══════════════╪═══════════════════════════╡
// │ ailibaba ┆ 7.77277778e8 ┆ {"ailibaba",7.77277778e8} │
// │ baidu ┆ 8.6556e7 ┆ {"baidu",8.6556e7} │
// └──────────┴──────────────┴───────────────────────────┘
}
fn struct_apply_in_df(){
println!("------------ struct_apply_in_df test---------------------");
// features => "dtype-struct"
let df = df!(
"lang" => &["julia", "go", "rust","c","c++"],
"ratings" => &["AAAA", "AAA", "AAAAA","AAAA","AAA"],
"users" =>&,
"references"=>&
).unwrap();
// 需求：生成一列struct {lang,ratings,users},并应用apply对struct进行操作,具体见表：
let out = df
.lazy()
.with_columns([
// 得到 struct 列
as_struct(vec!)
// 应用 apply
.apply(
|s| {
// 从series得到struct
let ss = s.struct_().unwrap();
// 拆出 Series
let s_lang = ss.field_by_name("lang").unwrap();
let s_ratings = ss.field_by_name("ratings").unwrap();
let s_users = ss.field_by_name("users").unwrap();
// downcast the `Series` to their known type
let _s_lang = s_lang.str().unwrap();
let _s_ratings = s_ratings.str().unwrap();
let _s_users = s_users.i32().unwrap();
// zip series`
let out: StringChunked = _s_lang
.into_iter()
.zip(_s_ratings)
.zip(_s_users)
.map(|((opt_lang, opt_rating),opt_user)| match (opt_lang, opt_rating,opt_user) {
(Some(la), Some(ra),Some(us)) => Some(format!("{}-{}-{}",la,ra,us)),
_ => None,
})
.collect();
Ok(Some(out.into_series()))
},
GetOutput::from_type(DataType::String),
)
.alias("links-three"),
])
.collect().unwrap();
println!("{}", out);
// shape: (5, 5)
// ┌───────┬─────────┬───────┬────────────┬────────────────┐
// │ lang┆ ratings ┆ users ┆ references ┆ links-three │
// │ --- ┆ --- ┆ --- ┆ --- ┆ --- │
// │ str ┆ str ┆ i32 ┆ i32 ┆ str │
// ╞═══════╪═════════╪═══════╪════════════╪════════════════╡
// │ julia ┆ AAAA ┆ 201 ┆ 5 ┆ julia-AAAA-201 │
// │ go ┆ AAA ┆ 303 ┆ 6 ┆ go-AAA-303 │
// │ rust┆ AAAAA ┆ 278 ┆ 9 ┆ rust-AAAAA-278 │
// │ c ┆ AAAA ┆ 99 ┆ 4 ┆ c-AAAA-99 │
// │ c++ ┆ AAA ┆ 87 ┆ 1 ┆ c++-AAA-87 │
// └───────┴─────────┴───────┴────────────┴────────────────┘
}
fn create_list_in_df(){
// polars中list的元素可以是不同的类型，对应DataType::Object.
struct Info{
code :String,
is_H :bool,
}
impl Info{
pub fn new(code:String,is_h:bool) -> Self{
Self{code:code,is_H:is_h}
}
}
// 需要注意，一般自定义类型，如果不实现NameFrom trait，是不能放在DataFrame中去的。
// list元素如何在df!时生成？
// data不可以Vec<Vec<f64>>模式
// 注：内部两列close数据可以不一样长。
let data = vec!),
Series::new("close",)];
let code = vec!["600036SH","600000SH"];
// info不可以是Vec<Info>模式，因为Info模式没有实现NameFrom trait
let info = [Info::new("600036".to_string(),true),
Info::new("600000".to_string(),true)];
// 以下不可以
//let df = df!("data"=>data, "code" =>code,"info" =>info).unwrap();
let df = df!("data"=>data, "code" =>code).unwrap();
println!("df :{}",df);
// df :shape: (2, 2)
// ┌──────────────────────┬──────────┐
// │ data ┆ code │
// │ --- ┆ --- │
// │ list ┆ str │
// ╞══════════════════════╪══════════╡
// │ ┆ 600036SH │
// │ ┆ 600000SH │
// └──────────────────────┴──────────┘
//如何取出list 列中的值; 比如第2行，第1列的数据
let values= &df["data"].get(1).unwrap();
let value = match &values {
&AnyValue::List(s) =>{
let tmp = s.get(0).unwrap();
let val = tmp.extract::<f64>().unwrap();
Some(val)
},
_ => None,
};
println!("value:{:?}",value);
}
//
fn eval_in_df(){
println!("----------- eval_in_df test ----------------------------");
//feature => list_eval
let mut df = df!(
"code" => &["600036.sh".to_string(),"600036.sh".to_string(),"600036.sh".to_string()],
"date" => &[NaiveDate::from_ymd_opt(2015, 3, 14).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 15).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 16).unwrap(),],
"close" => &,
"open"=> &,
"high"=> &,
"low" => &,
"comments" =>&["666","very well!","8888"],
).unwrap();
// col(""):表示column列中的每一个元素
// eval：对list中元素执行表达式任务,比如排序，类型转换等等
// eval：基本上前面会有一个list()
let out = df.lazy()
.with_columns([
col("comments")
.str()
.split(lit(" "))
.list()
.eval(col("")
.cast(DataType::Int64)
.is_null(), false) // false:是指是否并行，这里设置为false
.list()
.sum()
.alias("sum")])
.collect().unwrap();
println!("{}", &out);
// shape: (3, 8)
// ┌───────────┬────────────┬───────┬──────┬──────┬──────┬────────────┬─────┐
// │ code ┆ date ┆ close ┆ open ┆ high ┆ low┆ comments ┆ sum │
// │ --- ┆ --- ┆ --- ┆ ---┆ ---┆ ---┆ --- ┆ --- │
// │ str ┆ date ┆ f64 ┆ f64┆ f64┆ f64┆ str ┆ u32 │
// ╞═══════════╪════════════╪═══════╪══════╪══════╪══════╪════════════╪═════╡
// │ 600036.sh ┆ 2015-03-14 ┆ 1.21┆ 1.22 ┆ 1.22 ┆ 1.19 ┆ 666 ┆ 0 │
// │ 600036.sh ┆ 2015-03-15 ┆ 1.22┆ 1.21 ┆ 1.25 ┆ 1.2┆ very well! ┆ 2 │
// │ 600036.sh ┆ 2015-03-16 ┆ 1.23┆ 1.23 ┆ 1.24 ┆ 1.21 ┆ 8888 ┆ 0 │
// └───────────┴────────────┴───────┴──────┴──────┴──────┴────────────┴─────┘
}
// regex
fn array_in_df(){
//todo!
}</pre></div>
<p class="maodian"></p><h2>三、其它</h2>
<p class="maodian"></p><h3>1、feature问题</h3>
<p>可以看出，polars的features是非常多的，主要的有：</p>
<div class="jb51code"><pre class="brush:plain;">polars = { version = "0.42", features = ["lazy","dtype-struct","dtype-array","polars-io","dtype-datetime","dtype-date","range","temporal","rank","serde","csv","ndarray","parquet","strings","list_eval"] }</pre></div>
<p>这些还不是全部的。features多带来的问题是，你一定要把features加全，否则编译通不过。明明感觉没有问题，但是却会带来不少的困惑。</p>
<p class="maodian"></p><h3>2、版本迭代</h3>
<p>polars库python版本已经1.0，对外接口已经稳定；但rust项目还处于快速迭代状态，对外接口经常会有变化。</p>
<p>下面我写的一个函数，就是可以在0.41.3版本下以下可以运行的，在0.42下就会报错。我在上面也提供了0.42版本上可以运行的修改代码：即df_to_structs_by_iter_version_0_4_2()。</p>
<div class="jb51code"><pre class="brush:plain;">//polars: version 0.41.3=>work; version0.42 => no work!
fn df_to_structs_by_iter_version_0_4_1(){
println!("---------------df_to_structs_by_iter test----------------");
// toml :features => "dtype-struct"
let now = Instant::now();
#
struct Bar {
code :String,
date:NaiveDate,
close:f64,
open:f64,
high:f64,
low:f64,
}
impl Bar {
fn new(code:String,date:NaiveDate, close:f64,open:f64,high:f64,low:f64) -> Self{
Bar{code,date,close,open,high,low}
}
}
let df = df!(
"code" => &["600036.SH".to_string(),"600036.SH".to_string(),"600036.SH".to_string()],
"date" =>&[NaiveDate::from_ymd_opt(2015, 3, 14).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 15).unwrap(),
NaiveDate::from_ymd_opt(2015, 3, 16).unwrap(),],
"close" => &,
"open" => &,
"high" => &,
"low" => &,
).unwrap();
let mut bars:Vec<Bar> = Vec::new();
let rows_data = df.into_struct("bars");
let start_date = NaiveDate::from_ymd_opt(1970, 1, 2).unwrap();
forrow_data in &rows_data {
let code = row_data.get(0).unwrap();
let mut new_code = "".to_string();
if let &AnyValue::String(value) = code{
new_code = value.to_string();
}
let mut new_date = NaiveDate::from_ymd_opt(2000,1,1).unwrap();
let since_days = start_date.signed_duration_since(NaiveDate::from_ymd_opt(1,1,1).unwrap());
let date = row_data.get(1).unwrap();
if let &AnyValue::Date(dt) = date {
let tmp_date = NaiveDate::from_num_days_from_ce_opt(dt).unwrap();
new_date = tmp_date.checked_add_signed(since_days).unwrap();
}
let open =row_data.extract::<f64>().unwrap();
let high = row_data.extract::<f64>().unwrap();
let close =row_data.extract::<f64>().unwrap();
let low = row_data.extract::<f64>().unwrap();
bars.push(Bar::new(new_code,new_date,close,open,high,low));
}
println!("df_to_structs2 => structchunk : cost time :{:?}",now.elapsed().as_secs_f32());
println!("bars :{:?}",bars);
}</pre></div>
<p>到此这篇关于Rust : 数据分析利器polars用法的文章就介绍到这了,更多相关Rust polars用法内容请搜索琼殿技术社区以前的文章或继续浏览下面的相关文章希望大家以后多多支持琼殿技术社区！</p>
<div class="art_xg">
<b>您可能感兴趣的文章:</b><ul><li>在Rust中要用Struct和Enum组织数据的原因解析</li><li>Rust 数据类型详解</li><li>rust的nutyp验证和validator验证数据的方法示例详解</li><li>Rust语言数据类型的具体使用</li><li>Rust中的Box<T>之堆上的数据与递归类型详解</li></ul>
</div>
</div>
<!--endmain-->
頁:
[1]