生成一个递增序列, 但每次递增的步距（间隔）是个随机数

方法1：利用现成的List.Random函数，先生成一个随机序列：

RL = List.Random(10)

将此序列逐次叠加：

= List.Accumulate(RL, [a={}, b=0], (former, current)=> [b=former[b]+Number.Round(current*10, 0), a=former[a] & {b}])[a]

方法2：如果不事先生成随机序列，也可每次迭代累加时 临时加一个随机数：

List.Accumulate({1..10}, [a={}, b=0], (former, current)=> [b=former[b]+Number.Round(Number.Random()*10, 0), a=former[a] & {b}])[a]

以上两种方法， 临时“变量”b实则记录里的一个字段，在不支持变量赋值的M语言里可以取代传统语言里的变量作用。真正把每次叠加的结果保存下来并返回随机递增序列的是a

方法3：利用List.TransformMany函数

该函数的语法是：

List.TransformMany( list, (X)=> function_1, (X, Y)=> function_2)

其语意是：先将第一参数list里的每个元素X作为参数代入function_1里去运算，得到另一个列list_2，也就是第二参数。这个过程几乎等于List.Transform，所以可以把第二参数看作是内嵌了一个List.Transform。

然后把原始list的每个元素X 跟list_2在相同位置上的元素Y 配对成一对, 每一对（X, Y）作为两个参数代入function_2，运算后返回单元素，按同样的顺序排列成新的（单）列。

看一下下面的例子就会很好理解上面的解释：

= List.TransformMany({1..10}, (X)=> {X+10}, (X, Y)=> Text.From(X) & "-" & Text.From(Y))

如果list只是单值（标量）元素构成的列，而且经过function_1生成的列list_2依然是单值（标量）元素构成的列，那么list和 list_2对应位置的元素两两组合再进一步运算 似乎没必要经过第三参数function_2，直接在function_1里一步搞定是完全可以的，这种情况下用TransformMany似乎没有意义。

但，如果这两个列的元素不是单值呢？例如在第一次function_1时 在初始列表list的每个位置都生成一个11..15的列，相当于list_2是列中套列：

= List.TransformMany({1..10}, (X)=> {11..15}, (X, Y)=> Text.From(X) & "-" & Text.From(Y))

可见，第三参数在运算之前将初始列从1到10每个元素分别与嵌套的列1到5各自组合：

对于第一次function_1，如果按照前面理解的，相当于内嵌了一个List.Transform：

= List.Transform({1..10}, (X)=> {11..15})

只是List.Transform不会自己将其展开：

因此，List.TransformMany的第二参数虽然起到了与List.Transform同样的作用，但到了其第三参数与初始列配对时 却不是简单地同位置上一一对应，也就是说，第三参数里的Y不是对第二参数返回的list_2的简单复制，而是自动地展开，等于又多执行了一步ExpandList类似的操作。于是初始列list与list_2之间形成了笛卡尔积。

但这个自动添加的ExpandList操作也就仅限一次。要是第二参数返回的是多于两层嵌套的列，到达第三参数的list_2不会一直展开到最内部的单值（标量）元素：

= List.TransformMany({1..10}, (X)=> {{11..15}, {21..25}}, (X, Y)=> [a= X, b= Y])

一次展开后：

上图例子中，由于list_2的每个元素是{11..15}或{21..25}}，即使展开一次，也是{11..15}和{21..25}这样的列（--复合值，而不是单值11，12，13，...，15，21，22，...，25）与原始列的每个元素去组对。

那么，如果初始列的某些元素也是复合结构，会自动将其展开吗？

= List.TransformMany({1,{21,22,23}, 3..10}, (X)=> {try X{1} otherwise X}, (X, Y)=> [a= X, b= Y])

显然不能。只有经过第一参数变换后的派生列 如遇复合结构的元素 才会自动展开。

总而言之，List.TransformMany不仅让我们省写了List.Transform（在第二参数起到相同作用），而且省却了ExpandList。在与初始列“合并 形成笛卡尔积”时，由于M想要两表合并必须要有公共列，即使像笛卡尔积这样纯完全外连接 并不需要公共列的时候 我们也不得不在两表分别添加索引列这样的的额外步骤，这样算来，List.TransformMany至少为我们省却了五个步骤。看来，将TransformMany中的Many理解成一个函数合并了多个步骤不无道理。

前面说了，当初始列（list）以及它的派生列（list_2）都是单值元素时，TransformMany将这两列的相同位置的元素组对在一起进一步运算（第三参数）；当有元素是（嵌套）列，且这些嵌套列的元素全部是单值时，TransformMany则将嵌套列全部展开成单列，再与初始列的各个元素交叉组合成一个个对，再做进一步运算。

但当有元素嵌套的列 其元素不能全部是单值（包括又是列 或Table等其它复合结构），就不再展开，仍然像第一种情况那样只是简单把两列中同位置的元素加以组对：

= List.TransformMany({1..10}, (X)=> {Table.FromList({"a", "b", "c", "d"}, null, {"Letters"})}, (X, Y)=> Y)

也就是前面说的：自动展开只限于一次。

鉴于“自动展开只限于一次”那个特性，如果不管是初始列list还是其派生列list_2，含有某个非单值的元素，且该元素内嵌的 又是全单值元素的列，按理TransformMany会将内嵌列全部展开，但此时我们又不想让它展开，仍然以简单的同位置组对方式，则可以在list_2表达式外面再加个花括号，形成多层嵌套：

= List.TransformMany({1..10}, (X)=> {{1..5}}, (X, Y)=> Y)

利用这个特性，我们来回到最初话题：怎样利用List.TransformMany生成不规则间隔的递增序列。

先生成表示10个间隔的随机序列：

RL = {1,3,2,5,4,2,1,4,6,3}

显然最后生成的递增序列应该是{ 1,4,6,11,15,17,18,22,28,31}，也就是每个元素都是之前所有元素之和。

当然这个题目完全可以用更直接简单的函数，用TransformMany简直就是杀鸡用牛刀。但正因为简单，可以借此更容易理解TransformMany的机理。

下一步 = List.TransformMany({1..10}, (X)=> {RL}, (X, Y)=> Y)

为了不让RL展开（就是要在初始列的每个位置都放上这个随机序列），我们在其两边再套个{ }

然后根据初始列的每个元素值N 取这随机数列的前N个数：

= List.TransformMany({1..10}, (X)=> {RL}, (X, Y)=> List.FirstN(Y, X))

再加个List.Sum就成了：

= List.TransformMany({1..10}, (X)=> {RL}, (X, Y)=> List.Sum(List.FirstN(Y, X)))

再拿一个《Power Query 模拟Excel绝对引用》里的例子 来试着改用List.TransformMany。

他的思路是：先用Text.Split把字符串按空格拆分成List；

然后第二步：用List.Transform+Text.Length套路遍历这个List，求出每个项的长度，

第三步：用{1..List.Count(a)}，或List.Positions获得该List的顺序列，相当于新添一个索引列；

第四步：按照该索引列 顺序地取得原List的每个项，并从头累加到当前顺序位置：

之所以要新添一个反映List各个项的位置的顺序列，是因为List不能直接获取每个项自己在整个列里的位置（顺序号）

现在我们按照同样的思路和解题步骤，但换个M函数。

首先，将文本转成列是必不可少的：

文字列 = List.Transform(List.RemoveItems(Text.Split("我们部门 一起 去 旅游", " "), {""}), (x)=> Text.Length(x))

其次，为了获得每个项在列中的位置，顺序（索引）列也不能缺席（这里的顺序列变个花样写，意义不变）。

然后，以该顺序列出发，将顺序号与文字列里的每项 按位置一一组对。同样不能将所有文字项与全部顺序号交叉对应。所以要在文字列外面再套个{ }：

= List.TransformMany({1..List.Count(文字列)}, each {文字列}, (x, y)=> ......)

第三参数（省略号部分）就跟前面随机序列累加 是一样的了。

不过这次略微换个写法 换换口味，把FirstN提前到第二参数就截取得到 文字列在当前顺序位置之前的部分：

再举个例子：从下列中提取数字。

先将文本转换成List，每项对应于1个字符。由于没有分隔符，不能用Text.Split或SplitAny，用

第1步 = List.Transform(源[规格型号], Splitter.SplitTextByRepeatedLengths(1))

然后保留数字：

第2步 = List.Transform(第1步, (x)=> List.Select(x, (y)=> List.ContainsAny({y}, {"0".."9"})))

再还原成文本：

第3步 = List.Transform(第2步, each Text.Combine(_))

如果要将上面三个步骤合在一起，会形成多个嵌套， 很不直观。

现在试着用List.TransformMany

总结一下List.TransformMany的机理：

先对初始列（第一参数list）进行类似List.Transform那样的变换（第二参数），生成派生列list_2，然后根据派生列list_2的元素是否单值还是复合结构值 进行组对--如果都是单值，则从两列中按照在列中的相同位置各取一个元素 组对成一对；如果list_2有元素是复合结构，则将该元素展开（仅一次）成多个元素，这多个元素与初始列的所有元素两两组合成多个对（笛卡尔积）。最后将这些组对好了的元素对 送入第三参数进行下一个变换。最终仍然形成一个列 作为结果返回。

= List.TransformMany({1..5}, each List.Reverse({_..5}), (X,Y)=> Text.Combine({Text.From(X)..Text.From(Y)}) )

lst = [l for l in range(1, 6)]

s = ['wehui'[n-1: p] for n in lst for p in range(len(lst), n-1, -1)]

print(s)