zip 组合
核心概念
zip() 将两个迭代器"拉链式"组合在一起,每次从两个迭代器各取一个元素组成一个元组 (A, B)。当任意一个迭代器耗尽时,zip 就停止——以较短的那个为准。zip 是惰性适配器,不会立即执行,需要消费器驱动。它常用于并行遍历两个集合、给元素配对索引、以及合并多源数据。
rust
fn main() {
let names = vec!["Alice", "Bob", "Charlie"];
let scores = vec![92, 85, 78];
// zip 将两个迭代器配对
let paired: Vec<(&&str, &i32)> = names.iter().zip(scores.iter()).collect();
println!("配对: {:?}", paired);
// 常见用法:直接在 for 循环中解构
for (name, score) in names.iter().zip(scores.iter()) {
println!(" {} 得了 {} 分", name, score);
}
// 长度不同时以较短的为准
let a = vec![1, 2, 3, 4, 5];
let b = vec!["x", "y", "z"];
let zipped: Vec<_> = a.iter().zip(b.iter()).collect();
println!("长度不同: {:?}", zipped); // 只有3对
}zip 的截断行为
rust
fn main() {
let long = vec![1, 2, 3, 4, 5, 6, 7, 8];
let short = vec!["a", "b", "c"];
// 以短的为准,多余的元素被忽略
let result: Vec<_> = long.iter().zip(short.iter()).collect();
println!("截断: {:?}", result); // [(1,"a"), (2,"b"), (3,"c")]
// 两个都为空
let empty1: Vec<i32> = vec![];
let empty2: Vec<&str> = vec![];
let result: Vec<_> = empty1.iter().zip(empty2.iter()).collect();
println!("空zip: {:?}", result); // []
// 一个为空
let result: Vec<_> = long.iter().zip(empty2.iter()).collect();
println!("一空: {:?}", result); // []
// 与无穷迭代器配合
let data = vec!["a", "b", "c", "d"];
let indexed: Vec<_> = (0..).zip(data.iter()).collect();
println!("无穷+有限: {:?}", indexed); // [(0,"a"), (1,"b"), ...]
}zip 与 enumerate 的关系
rust
fn main() {
let items = vec!["苹果", "香蕉", "橘子"];
// enumerate 其实就是 zip 的特殊情况
// enumerate() 等价于 (0..).zip(iter)
let with_enum: Vec<_> = items.iter().enumerate().collect();
let with_zip: Vec<_> = (0..).zip(items.iter()).collect();
println!("enumerate: {:?}", with_enum);
println!("zip(0..): {:?}", with_zip);
// 但 zip 更灵活:可以从任意数字开始
let from_100: Vec<_> = (100..).zip(items.iter()).collect();
println!("从100开始: {:?}", from_100);
// 或者用自定义序列
let labels = vec!["A", "B", "C"];
let labeled: Vec<_> = labels.iter().zip(items.iter()).collect();
println!("自定义标签: {:?}", labeled);
}多个迭代器的 zip
rust
fn main() {
let names = vec!["张三", "李四", "王五"];
let ages = vec![25, 30, 28];
let cities = vec!["北京", "上海", "广州"];
// 链式 zip:三个迭代器
let combined: Vec<_> = names.iter()
.zip(ages.iter())
.zip(cities.iter())
.map(|((name, age), city)| {
format!("{}, {}岁, {}", name, age, city)
})
.collect();
println!("三路zip:");
for info in &combined {
println!(" {}", info);
}
// 四个迭代器
let scores = vec![92.0, 85.5, 78.0];
let records: Vec<_> = names.iter()
.zip(ages.iter())
.zip(cities.iter())
.zip(scores.iter())
.map(|(((name, age), city), score)| {
format!("{} | {} | {} | {:.1}分", name, age, city, score)
})
.collect();
println!("\n四路zip:");
for record in &records {
println!(" {}", record);
}
}zip 与 unzip
rust
fn main() {
let data = vec![(1, "a"), (2, "b"), (3, "c"), (4, "d")];
// unzip:zip 的逆操作,将元组迭代器拆分为两个集合
let (numbers, letters): (Vec<i32>, Vec<&str>) = data.into_iter().unzip();
println!("numbers: {:?}", numbers);
println!("letters: {:?}", letters);
// 先 zip 再 unzip(round-trip)
let keys = vec!["name", "age", "city"];
let values = vec!["张三", "25", "北京"];
let pairs: Vec<_> = keys.iter().zip(values.iter()).collect();
println!("pairs: {:?}", pairs);
let (k, v): (Vec<_>, Vec<_>) = keys.iter()
.zip(values.iter())
.unzip();
println!("keys: {:?}", k);
println!("values: {:?}", v);
}基本示例
用 zip 实现向量运算和数据合并:
rust
fn main() {
// === 向量运算 ===
let vec_a = vec![1.0, 2.0, 3.0, 4.0];
let vec_b = vec![5.0, 6.0, 7.0, 8.0];
// 向量加法
let sum: Vec<f64> = vec_a.iter()
.zip(vec_b.iter())
.map(|(&a, &b)| a + b)
.collect();
println!("加法: {:?}", sum);
// 点积
let dot_product: f64 = vec_a.iter()
.zip(vec_b.iter())
.map(|(&a, &b)| a * b)
.sum();
println!("点积: {:.1}", dot_product);
// 逐元素比较
let comparison: Vec<&str> = vec_a.iter()
.zip(vec_b.iter())
.map(|(&a, &b)| {
if a > b { ">" } else if a < b { "<" } else { "=" }
})
.collect();
println!("比较: {:?}", comparison);
// === 数据合并 ===
let headers = vec!["姓名", "年龄", "城市", "职业"];
let row1 = vec!["张三", "25", "北京", "工程师"];
let row2 = vec!["李四", "30", "上海", "设计师"];
// 将表头和数据行配对
println!("\n=== 记录1 ===");
for (header, value) in headers.iter().zip(row1.iter()) {
println!(" {}: {}", header, value);
}
println!("\n=== 记录2 ===");
for (header, value) in headers.iter().zip(row2.iter()) {
println!(" {}: {}", header, value);
}
// 构建 HashMap
use std::collections::HashMap;
let record: HashMap<&str, &str> = headers.iter()
.zip(row1.iter())
.map(|(&h, &v)| (h, v))
.collect();
println!("\nHashMap: {:?}", record);
// === 差异比较 ===
let old_prices = vec![100, 200, 300, 400, 500];
let new_prices = vec![110, 190, 320, 400, 480];
let products = vec!["A", "B", "C", "D", "E"];
println!("\n=== 价格变动 ===");
products.iter()
.zip(old_prices.iter().zip(new_prices.iter()))
.for_each(|(name, (&old, &new))| {
let diff = new - old;
let symbol = if diff > 0 { "+" } else { "" };
println!(" 产品{}: {} → {} ({}{})", name, old, new, symbol, diff);
});
}常见问题
问题一:zip 两个长度不同的迭代器会怎样?
以较短的为准。较长迭代器中多余的元素被忽略,不会报错。如果需要以较长的为准并补充默认值,标准库没有直接提供,但可以用 itertools crate 的 zip_longest。
问题二:zip 可以组合两个以上的迭代器吗?
标准库的 zip 一次只能组合两个。要组合三个以上,可以链式调用 .zip(iter1).zip(iter2),但需要嵌套解构 ((a, b), c)。itertools crate 提供了 izip! 宏支持多路 zip。
问题三:zip 和 enumerate 有什么关系?
enumerate() 等价于 (0..).zip(iter)。zip 更通用——可以用任意迭代器作为索引源。
问题四:zip 可以用于不同类型的迭代器吗?
可以。zip 的两个迭代器可以产出完全不同的类型,结果是 (A, B) 元组。
适用场景
- 并行遍历:同时遍历两个相关集合
- 数据配对:表头与数据行、键与值
- 向量运算:逐元素加减乘除、点积
- 差异比较:比较两组数据的变化
注意事项
zip以较短迭代器的长度为准zip是惰性的,需要消费器驱动- 多路 zip 需要嵌套,解构时层次较深
unzip是zip的逆操作enumerate()是(0..).zip(iter)的快捷方式- zip 不要求两个迭代器的元素类型相同
总结
zip() 将两个迭代器拉链式组合,每次各取一个元素组成 (A, B) 元组。当任意一个迭代器耗尽时停止(以短为准)。zip 常用于并行遍历两个集合、数据配对、向量运算和差异比较。多个迭代器可以链式 zip,但需要嵌套解构。unzip() 是 zip 的逆操作,将元组迭代器拆为两个集合。enumerate() 本质上就是 (0..).zip(iter) 的语法糖。zip 不要求两个迭代器的元素类型相同。