组合 ，可以是笛卡尔积 ，即任意组合 ，如奶茶咖啡等各种口味 ，也可以是循环组合，即按照固定搭配，如天干地支。这2种组合都用到itertools库

1 , 笛卡尔积

from itertools import product杯型 = ['中杯','大杯','超大杯']冷热 = ['冷','热']for item in product(杯型,冷热):    print(item)# 如果需要列表，直接 list(item) 即可# print(list(item))# 输出# ('中杯', '冷')# ('中杯', '热')# ('大杯', '冷')# ('大杯', '热')# ('超大杯', '冷')# ('超大杯', '热')# product() 有个 repeat 参数 ，接受自然数。# repeat = 0 ，输出为空# repeat = 1 ，和不写它是一个效果，默认值# repeat = 2 ，相当于 product(杯型,冷热,杯型,冷热)# 输出如# ['中杯', '冷', '中杯', '冷']# ['中杯', '冷', '中杯', '热']# ['中杯', '冷', '大杯', '冷']# ['中杯', '冷', '大杯', '热']# ['中杯', '冷', '超大杯', '冷']# ['中杯', '冷', '超大杯', '热']# 其他以此类推

2 , 循环组合

生成天干地支组合

方法一：列表推导式 + 取模

天干 = ["甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸"]地支 = ["子", "丑", "寅", "卯", "辰", "巳", "午", "未", "申", "酉", "戌", "亥"]天干地支组合 = [天干[i % 10] + 地支[i % 12] for i in range(60)]

解释一下：

取余 ≠ 取模

我们的场景几乎不涉及负数 ，所以只知道哪个是求小学数学里面的商，哪个是求小学数学里面的余数就行。

不同的编程语言实现的不一样，在python里面：

7 // 3 是 整除（也叫地板除 ，floor division），它求的是商（数学里的 2）。

7 % 3 是 取模（正数情况下叫取余也行，最好不这样说），它求的是余数（数学里的 1）。

也就是说，在被除数和除数都是正数时，Python 的 % 就是小学数学里面的“余数”。数学课上学到的 被除数 = 除数 × 商 + 余数，在这里就是：

7 == 3 * 2 + 1

7 // 3 得到商 2， 7 % 3 得到余数 1

不必纠结 ，用到什么学什么。

python 列表从 0 开始 ，如果你是从 R 或 Matlab 等转过来的 ，要区分。

有些是可以自主设置的，比如Power Query 里面的 M 语言 ，polars 库的 with_row_index() 等都可以设置从什么开始

这里的 range(60) 实际生成的是 0 到 59

当 i = 0 , i % 10 = 0 , i % 12 = 0 , 

天干[i % 10] 就是 天干[0] 就是 甲 ，

地支[i % 12] 就是 地支[0] 就是 子 ，

所以组合是 甲子

当 i = 1 , i % 10 = 1 , i % 12 = 1 , 

天干[i % 10] 就是 天干[1] 就是 乙 ，

地支[i % 12] 就是 地支[1] 就是 丑 ，

所以组合是 乙丑

当 i = 9 , i % 10 = 9 , i % 12 = 9 , 

天干[i % 10] 就是 天干[9] 就是 癸 ，

地支[i % 12] 就是 地支[9] 就是 酉 ，

所以组合是 癸酉

此时天干已经循环一遍了，从头开始是甲，但是地支还没有结束，从第11个戌开始

当 i = 10 , i % 10 = 0 , i % 12 = 10 , 

天干[i % 10] 就是 天干[10] 就是 甲 ，

地支[i % 12] 就是 地支[10] 就是 戌 ，

所以组合是 甲戌

当 i = 59 , i % 10 = 9 , i % 12 = 11 , 

天干[i % 10] 就是 天干[9] 就是 癸 ，

地支[i % 12] 就是 地支[11] 就是 亥 ，

所以组合是 癸亥

至此 ，一个循环结束 ，我们的人生也走过了大半了 ，按照吴站长的话就是 时间像一头野驴呀，跑起来就不停

这个方法依赖于先计算出来最小公倍数，且参数多了不方便，无法动态调整。

方法二：用 itertools.cycle

from itertools import cycle, islicefrom math import lcm天干 = ["甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸"]地支 = ["子", "丑", "寅", "卯", "辰", "巳", "午", "未", "申", "酉", "戌", "亥"]def cyclic_zip(*lists):    最小公倍数 = lcm(*[len(lst) for lst in lists])    # 也可以用高阶函数map     # 最小公倍数 = lcm(*map(len, lists))    组合 = zip(*(cycle(lst) for lst in lists))    return islice(组合, 最小公倍数)# cyclic_zip(天干,地支) 这个东西就像一个压缩包，把东西都挤在一堆隐藏起来了# list 就是一个魔法，能让它现出原形 ，得到一个列表一个周期的组合_60年 = list(cyclic_zip(天干,地支))print(一个周期的组合_60年)# 要是120年的2个周期呢？# return islice(组合, 最小公倍数) 改成 return islice(组合, 2 * 最小公倍数)

*lists：接收任意数量的位置参数，全部打包进一个元组 lists。

返回值：一个惰性迭代器，逐个产生元组，每个元组包含各个列表当前对应的元素。惰性迭代器 不必纠结是什么 ，这个 * 是一个用法而已，叫解包(unpack) ，在这里的作用就是把传进来的各个列表组合到一起

步骤拆解：

1 , 计算组合总数

lcm(map(len, lists)) 或 lcm([len(lst) for lst in lists])

lists 是一个包含所有输入列表的元组，例如传入 (天干,地支)，则 lists = (["甲",...], ["子",...])。

map(len, lists) 返回一个迭代器，生成每个列表的长度：[10, 12]。

这个是函数式编程常用到的 ，map 、reduce 等 ，括号里面有 其他函数名字 和 参数，不必深究，先用起来，熟练了再一点点理解

lcm(*...)可以接收多个整数参数，计算它们的最小公倍数。

前面的 * 将 map 产生的可迭代对象解包成独立参数，即 lcm(10, 12) → 60。

因此 lcm(*map(len, lists)) 的结果就是所有列表长度的最小公倍数，也就是循环配对完成一个完整周期的总步数。

2 , 无限循环每个列表

(cycle(lst) for lst in lists)

生成器表达式 (cycle(lst) for lst in lists) 会对每个列表生成对应的 cycle 迭代器。

说人话版 ：这个能让2个列表一直生成下去，无限循环

对于天干"甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸", 

"甲", "乙", "丙", "丁", "戊", "己", "庚", "辛", "壬", "癸"

对于地支"子", "丑", "寅", "卯", "辰", "巳", "午", "未", "申", "酉","戌", "亥", 

"子", "丑", "寅", "卯", "辰", "巳", "午", "未", "申", "酉", "戌", "亥"

3 , 逐列配对

zip , 是拉链的意思，衣服上的拉链，都是一对一对的，左边一个右边一个。所以zip的参数也是这样，2个参数的话，左边取1个，右边取1个，组合成一个元组。

例如zip( [1,2] , ['a','b']) 生成 (1,'a') 和 (2,'b')

注：你会看到单引号和双引号混着用，这就是python的特点，怎么写都行。但是其他语言，如rust，一些文件格式也不一样 ，如 toml ，yaml ，json。无所谓好坏，先不要去想它，用起来就行，单引号不行就换双引号，遇到报错就搜一下，熟练了再去细想。

zip 通常以最短输入的长度为准。zip( [1,2,3] , ['a','b']) 生成 (1, 'a') 和 (2, 'b') ，3 被丢了，因为没有对应的。

zip( [1,2] , ['a','b','c']) 生成 (1, 'a') 和 (2, 'b') ，c 被丢了，因为没有对应的。

但这里所有输入都是 cycle 迭代器，它们永不枯竭，因此 zip 会一直产出元组，永不停止。

又出现了这个 迭代器 ，简单理解就是 迭代 == 不断生成 ，器 就是 东西所以迭代器就是一个可以不断生成某些东西的东西，至于不断到什么时候才断，看你传入的是什么，传入的是有限的东西，到头了就断，传入的是无限的，那就不断。

正好cycle出来的东西是无限的，所以 zip + cycle 就是源源不断的生成。

前面 zip 参数中的 * 解包：把生成器表达式产生的多个 cycle 迭代器作为独立的参数传给 zip。

如果有3个列表 zip(cycle(A), cycle(B), cycle(C))，则每个元组包含三个元素。

4 , 截取恰好一个完整周期

islice(iterable, stop) 从中取出前 stop 个元素。

这里的 stop 就是前面计算的最小公倍数，如60。

因此 islice 就会恰好取出60个配对，也就是“甲子”到“癸亥”的完整六十甲子。

这种写法支持任意多个列表（3个、4个……）关键点在于 *lists 和 zip 以及 lcm 都能处理任意数量的参数

截取数量精确：islice 的停止值是该 LCM，无论几个列表，都能保证刚好取完索引再次同步前的所有组合。

这个东西的作用就是当不想生成所有组合时，提高性能，简化结果。比如跨境电商里面，某些产品的组合打包进行广告推广，按照季节不同循环推广等，或者是物流方式与货的组合，或者是多账户收款与平台账期组合等，总之用起来才是硬道理。

此篇文字已经很多了，后续再写跨境电商相关的。