鸿蒙PC适配llvm-gcc-compat编译安装第三方库itertools，打造Rust 第三方迭代器增强库

欢迎加入开源鸿蒙PC社区： https://harmonypc.csdn.net/
欢迎在PC社区平台申请新建项目：https://atomgit.com/OpenHarmonyPCDeveloper
AtomGit 仓库地址：https://atomgit.com/OpenHarmonyPCDeveloper/ohos_rust_cargo

本文讲解鸿蒙 PC 端 Rust 开发环境搭建，鸿蒙基于 musl 库、强制二进制签名，无法直接使用通用 Linux 编译产物。需借助鸿蒙专属包管理器 Harmonybrew，提供两套编译方案：方案一安装 llvm-gcc-compat，零配置开箱即用；方案二仅安装 ohos-sdk，需手动配置 Cargo 链接器，二者都依托 ohos-sdk 完成自动签名编译。

可以来参考一下这个文章搭建环境OpenHarmony 鸿蒙 PC + CodeArts IDE 实现 Rust开发完整开发环境搭建指南

一、Rust itertools 是什么

itertools是 Rust 第三方迭代器增强库，标准库Iterator功能比较单薄，这个库补充大量实用迭代工具：

1. 排列、组合、笛卡尔积、带重复组合（算法常用）
2. 分组、去重、窗口滑动、相邻配对、交叉合并
3. 批量变换、折叠、分块、平铺、链式处理
4. 惰性迭代，性能高，内存占用小

二、第一步创建 Rust 项目并安装依赖

你之前报错是因为在 Python 文件夹执行cargo，必须先建 Rust 项目：

# 1. 退出python目录，新建rust项目cd/storage/Users/currentUser/workspace/code/cargonew iter_democditer_demo# 2. 添加itertools依赖cargoadditertools

此时项目内会生成Cargo.toml，里面自动写入依赖：

[dependencies] itertools = "0.13"

三、完整可运行 main.rs（复制覆盖全部内容）

useitertools::Itertools;fnmain(){// ========== 1. 笛卡尔积 cartesian_product ==========letnums=[1,2];letchars=['a','b'];letproduct:Vec<_>=nums.iter().cartesian_product(chars.iter()).collect();println!("笛卡尔积: {:?}",product);// ========== 2. 全排列 permutations ==========letarr=[1,2,3];letperm:Vec<_>=arr.iter().permutations(2).collect();println!("2元素全排列: {:?}",perm);// ========== 3. 组合 combinations ==========letcomb:Vec<_>=arr.iter().combinations(2).collect();println!("2元素组合: {:?}",comb);// ========== 4. 可重复组合 combinations_with_replacement ==========letcomb_rep:Vec<_>=[1,2].iter().combinations_with_replacement(2).collect();println!("可重复组合: {:?}",comb_rep);println!("----------------------------------------");// ========== 5. chain 拼接迭代器 ==========letch:Vec<_>=[1,2].iter().chain([3,4].iter()).collect();println!("chain拼接: {:?}",ch);// ========== 6. tuple_windows 滑动窗口 ==========letslide:Vec<_>=[10,20,30,40].iter().tuple_windows::<(_,_)>().collect();println!("相邻二元滑动窗口: {:?}",slide);// ========== 7. chunk_by 分组（替代废弃 group_by） ==========letdata=vec![1,1,2,2,2,3];letgroups:Vec<_>=data.iter().chunk_by(|&&x|x).into_iter().map(|(k,g)|(k,g.collect::<Vec<_>>())).collect();println!("分组结果: {:?}",groups);// ========== 8. unique 去重 ==========letdup=[1,2,2,3,3,3];letuniq:Vec<_>=dup.iter().unique().collect();println!("去重: {:?}",uniq);// ========== 9. interleave 交叉合并 ==========leta=[1,3,5];letb=[2,4,6];letinter:Vec<_>=a.iter().interleave(b.iter()).collect();println!("交叉合并: {:?}",inter);// ========== 10. reduce 累加（替代废弃 fold1，into_iter 取出数值而非引用） ==========letsum=[1,2,3,4].into_iter().reduce(|a,b|a+b);println!("累加总和: {:?}",sum.unwrap());}

四、运行命令

在iter_demo目录执行：

cargorun

五、输出结果预览

笛卡尔积: [(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b')] 2元素全排列: [[1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2]] 2元素组合: [[1, 2], [1, 3], [2, 3]] 可重复组合: [[1, 1], [1, 2], [2, 2]] ---------------------------------------- chain拼接: [1, 2, 3, 4] 相邻二元滑动窗口: [(10, 20), (20, 30), (30, 40)] 分组结果: [(1, [1, 1]), (2, [2, 2, 2]), (3, [3])] 去重: [1, 2, 3] 交叉合并: [1, 2, 3, 4, 5, 6] 累加总和: 10

这段代码是itertools库十大高频迭代器工具示例，itertools是Rust标准迭代器的增强扩展库，提供Python itertools同款组合、排列、分组、窗口、去重等能力。

前置依赖说明

使用前必须在Cargo.toml添加依赖：

[dependencies] itertools = "0.13"

导入：use itertools::Itertools;，所有扩展方法都通过这个trait挂载到迭代器上。

1. cartesian_product 笛卡尔积

letnums=[1,2];letchars=['a','b'];letproduct:Vec<_>=nums.iter().cartesian_product(chars.iter()).collect();println!("笛卡尔积: {:?}",product);

作用

两个迭代器所有元素两两配对，数学笛卡尔积，顺序：(第一个迭代器元素, 第二个迭代器元素)

输出

笛卡尔积: [(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b')]

关键点

• cartesian_product(另一迭代器)，不消耗原数组，.iter()产出引用
• 适合多维度枚举、双循环简化

2. permutations 全排列

letarr=[1,2,3];letperm:Vec<_>=arr.iter().permutations(2).collect();println!("2元素全排列: {:?}",perm);

作用

从序列中选k个元素，有序、不重复选取，元素顺序不同算两种结果（排列）

输出

2元素全排列: [[1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2]]

区分重点

排列关心顺序，[1,2]和[2,1]是不同项；参数2代表每组长度为2。
如果不传参数.permutations()会生成全部元素的完整全排列。

3. combinations 组合

letcomb:Vec<_>=arr.iter().combinations(2).collect();println!("2元素组合: {:?}",comb);

作用

选k个元素，无序、不重复选取，只保留升序唯一一组

输出

2元素组合: [[1, 2], [1, 3], [2, 3]]

和permutations对比

组合只保留不重复集合，没有反向项；排列区分顺序。

4. combinations_with_replacement 可重复组合

letcomb_rep:Vec<_>=[1,2].iter().combinations_with_replacement(2).collect();println!("可重复组合: {:?}",comb_rep);

作用

允许同一个元素重复选取，无序组合

输出

可重复组合: [[1, 1], [1, 2], [2, 2]]

使用场景

骰子、可重复抽奖、多选可重复场景

5. chain 迭代器拼接

letch:Vec<_>=[1,2].iter().chain([3,4].iter()).collect();println!("chain拼接: {:?}",ch);

作用

把多个迭代器首尾拼接成一个，标准库也有chain，但itertools支持多链链式调用

输出

chain拼接: [1, 2, 3, 4]

拓展

iter1.chain(iter2).chain(iter3)拼接任意数量序列

6. tuple_windows 固定长度滑动窗口

letslide:Vec<_>=[10,20,30,40].iter().tuple_windows::<(_,_)>().collect();println!("相邻二元滑动窗口: {:?}",slide);

作用

滑动窗口，一次性返回元组，无需手动zip，泛型指定窗口长度
<(_, _)>= 窗口大小2；<(_,_,_)>= 窗口大小3

输出

相邻二元滑动窗口: [(10, 20), (20, 30), (30, 40)]

对比标准库

标准库只有.windows()返回切片，tuple_windows直接返回元组，解构更方便。

7. chunk_by 按条件分组

letdata=vec![1,1,2,2,2,3];letgroups:Vec<_>=data.iter().chunk_by(|&&x|x).into_iter().map(|(k,g)|(k,g.collect::<Vec<_>>())).collect();println!("分组结果: {:?}",groups);

作用

相邻且key相同的元素分为一组，key由闭包生成

执行流程

1. chunk_by(|&&x| x)：用元素自身作为分组key
2. 返回Chunk迭代器，每个item是(key, 同组元素迭代器)
3. map把每组迭代器收集成Vec，方便打印

输出

分组结果: [(1, [1, 1]), (2, [2, 2, 2]), (3, [3])]

注意

只对连续相同key分组，不全局分组；如果需要全局分组要配合sorted先排序。

8. unique 迭代器去重

letdup=[1,2,2,3,3,3];letuniq:Vec<_>=dup.iter().unique().collect();println!("去重: {:?}",uniq);

作用

遍历迭代器，自动过滤重复元素，保留第一次出现的值

输出

去重: [1, 2, 3]

拓展变体

• unique_by(|x| 关键字)：按自定义字段去重

9. interleave 交叉合并两个迭代器

leta=[1,3,5];letb=[2,4,6];letinter:Vec<_>=a.iter().interleave(b.iter()).collect();println!("交叉合并: {:?}",inter);

作用

交替取a一个、b一个，穿插合并

输出

交叉合并: [1, 2, 3, 4, 5, 6]

长短序列规则

如果两个迭代器长度不同，短的耗尽后，直接追加长迭代器剩余元素。

10. reduce 迭代器归约求和（标准库原生，itertools兼容）

letsum=[1,2,3,4].into_iter().reduce(|a,b|a+b);println!("累加总和: {:?}",sum.unwrap());

作用

迭代器累计聚合，第一个值作为初始累加器，依次和下一个元素运算

细节区分

1. .into_iter()：获取数组所有权，得到数字i32，不是引用，才能直接相加
2. reduce返回Option<T>：空迭代器返回None，所以用.unwrap()
3. 替代旧版itertools废弃的fold1，现在标准库自带reduce

输出

累加总和: 10

同类方法

• fold(初始值, 闭包)：可自定义初始值
• sum()：数字专用求和简化写法

完整运行输出汇总

笛卡尔积: [(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b')] 2元素全排列: [[1, 2], [1, 3], [2, 1], [2, 3], [3, 1], [3, 2]] 2元素组合: [[1, 2], [1, 3], [2, 3]] 可重复组合: [[1, 1], [1, 2], [2, 2]] ---------------------------------------- chain拼接: [1, 2, 3, 4] 相邻二元滑动窗口: [(10, 20), (20, 30), (30, 40)] 分组结果: [(1, [1, 1]), (2, [2, 2, 2]), (3, [3])] 去重: [1, 2, 3] 交叉合并: [1, 2, 3, 4, 5, 6] 累加总和: 10

核心使用场景总结

1. 组合/排列：算法枚举、密码生成、选项遍历
2. 窗口/分组：时序数据、日志分段、相邻差值计算
3. 合并交叉：多路数据流合并
4. 去重笛卡尔积：多条件筛选、多维匹配

关键注意点

1. 必须在 Rust 项目根目录（存在Cargo.toml）执行cargo命令，不能在 Python 文件夹运行；
2. 代码头部use itertools::prelude::*;一次性导入所有拓展迭代器方法；
3. Rust 迭代器惰性求值，.collect()才会把结果转成集合打印；
4. group_by使用前数据最好排序，否则相同元素不连续会分成多组。