迭代实用程序

# '基。迭代器。有状态`-Type

Stateful(itr)

可以通过几种不同的方式查看此迭代器包装器。

它提供了一个围绕迭代器及其迭代状态的可变包装器。
它将像迭代器这样的抽象变成像`通道’这样的抽象。
它是一个迭代器，在生成元素时，它会在所有情况下变为自己的REST迭代器。

'Stateful’提供了通常的迭代器接口。与其他可变迭代器的情况一样（例如, '基地。道')，如果迭代在早期阶段停止（例如，使用 `break'在循环中 `for'），通过继续迭代相同的迭代对象，可以从同一点恢复迭代（相比之下，不可变迭代器将从一开始重新启动）。

例子

julia> a = Iterators.Stateful("abcdef");

julia> isempty(a)
false

julia> popfirst!(a)
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> collect(Iterators.take(a, 3))
3-element Vector{Char}:
 'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase)
 'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)
 'd': ASCII/Unicode U+0064 (category Ll: Letter, lowercase)

julia> collect(a)
2-element Vector{Char}:
 'e': ASCII/Unicode U+0065 (category Ll: Letter, lowercase)
 'f': ASCII/Unicode U+0066 (category Ll: Letter, lowercase)

julia> Iterators.reset!(a); popfirst!(a)
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> Iterators.reset!(a, "hello"); popfirst!(a)
'h': ASCII/Unicode U+0068 (category Ll: Letter, lowercase)

julia> a = Iterators.Stateful([1,1,1,2,3,4]);

julia> for x in a; x == 1 || break; end

julia> peek(a)
3

julia> sum(a) # Суммировать оставшиеся элементы
7

# '基。迭代器。zip'-Function</no-翻译>

zip(iters...)

在同一时间运行多个迭代器，直到其中任何一个被耗尽。迭代器值类型’zip’是其子迭代器值的元组。

Zip函数以这样一种方式安排对嵌套迭代器的调用，即当另一个迭代器在当前迭代中完成工作时，有状态迭代器将不会继续工作。

'Zip()'函数输出一个没有参数的空元组的无限迭代器。

另请参阅说明 '枚举', '基地。splat'。

例子

julia> a = 1:5
1:5

julia> b = ["e","d","b","c","a"]
5-element Vector{String}:
 "e"
 "d"
 "b"
 "c"
 "a"

julia> c = zip(a,b)
zip(1:5, ["e", "d", "b", "c", "a"])

朱莉娅>长度(c)
5

朱莉娅>第一(c)
(1,"e")

# '基。迭代器。枚举'-Function

enumerate(iter)

输出`(i,x)`的迭代器，其中`i`是从1开始的计数器，`x`是来自此迭代器的`i’th值。当您不仅需要迭代的`x`值，还需要已经执行的迭代次数时，这很有用。

请注意``i`可能不适用于索引`iter'，或者它可能索引另一个元素。如果`iter`具有不以1开头的索引，并且可能与字符串，字典等相关，则会发生这种情况。如果要确保’i`是索引，请参阅`pairs(IndexLinear(),iter)`方法的描述。

例子

julia> a = ["a", "b", "c"];

julia> for (index, value) in enumerate(a)
           println("$index $value")
       end
1 a
2 b
3 c

julia> str = "naïve";

julia> for (i, val) in enumerate(str)
           print("i = ", i, ", val = ", val, ", ")
           try @show(str[i]) catch e println(e) end
       end
i = 1, val = n, str[i] = 'n'
i = 2, val = a, str[i] = 'a'
i = 3, val = ï, str[i] = 'ï'
i = 4, val = v, StringIndexError("naïve", 4)
i = 5, val = e, str[i] = 'v'

# '基。迭代器。rest'-Function

rest(iter, state)

一个迭代器，它输出与`iter’相同的元素，但从指定的`state’开始。

另请参阅说明 '迭代器。滴`, '迭代器。剥`, '基地。休息'。

例子

julia> collect(Iterators.rest([1,2,3,4], 2))
3-element Vector{Int64}:
 2
 3
 4

# '基。迭代器。countfrom'-Function

countfrom(start=1, step=1)

一个迭代器，从"开始"开始计算，增量为"步骤"。

例子

julia> for v in Iterators.countfrom(5, 2)
           v > 10 && break
           println(v)
       end
5
7
9

# '基。迭代器。取'-Function

take(iter, n)

输出’iter`的前`n’个元素的迭代器。

另请参阅说明 '下降', '剥离', '第一`, '基地。拿！`.

例子

julia> a = 1:2:11
1:2:11

julia> collect(a)
6-element Vector{Int64}:
  1
  3
  5
  7
  9
 11

julia> collect(Iterators.take(a,3))
3-element Vector{Int64}:
 1
 3
 5

# '基。迭代器。takewhile'-Function

takewhile(pred, iter)

一个迭代器，它从"iter"创建一个元素，而谓词"pred"的值为true，然后丢弃每个元素。

兼容性：Julia1.4

此功能需要至少1.4的Julia版本。

例子

julia> s = collect(1:5)
5-element Vector{Int64}:
 1
 2
 3
 4
 5

julia> collect(Iterators.takewhile(<(3),s))
2-element Vector{Int64}:
 1
 2

# '基。迭代器。drop'-Function

drop(iter, n)

一个迭代器，它创建除`iter`的前’n’个元素之外的所有元素。

例子

julia> a = 1:2:11
1:2:11

julia> collect(a)
6-element Vector{Int64}:
  1
  3
  5
  7
  9
 11

julia> collect(Iterators.drop(a,4))
2-element Vector{Int64}:
  9
 11

# '基。迭代器。dropwhile'-Function

dropwhile(pred, iter)

当谓词"pred"为true时，从"iter"中丢弃元素的迭代器，然后返回每个元素。

兼容性：Julia1.4

此功能需要至少1.4的Julia版本。

例子

julia> s = collect(1:5)
5-element Vector{Int64}:
 1
 2
 3
 4
 5

julia>collect(迭代器。同时(<(3),s))
3元素向量{Int64}:
 3
 4
 5

# '基。迭代器。循环'-Function</no-翻译>

cycle(iter[, n::Int])

对’iter’执行永恒循环的迭代器。如果设置了’n`，则`iter’循环重复指定的次数。如果对象’iter’为空，则`cycle(iter)`和`cycle(iter,n)`都将为空。

'迭代器。cycle`iter,n)'是递延等价物 '基地。重复`'(vector,n)'，而 '迭代器。repeated`'(iter,n)'--递延等价物 '基地。填写''(item,n)'。

兼容性：Julia1.11

在Julia1.11中添加了`cycle(iter,n)'方法。

例子

julia> for (i, v) in enumerate(Iterators.cycle("hello"))
           print(v)
           i > 10 && break
       end
hellohelloh

julia> foreach(print, Iterators.cycle(['j', 'u', 'l', 'i', 'a'], 3))
juliajuliajulia

julia> repeat([1,2,3], 4) == collect(Iterators.cycle([1,2,3], 4))
true

julia> fill([1,2,3], 4) == collect(Iterators.repeated([1,2,3], 4))
true

# '基。迭代器。重复`-Function

repeated(x[, n::Int])

不断创建值`x’的迭代器。如果指定了’n`，则创建`x’指定的次数（相当于’take(repeated(x),n)`）。

另请参阅说明 '填充'并与 '迭代器。循环'。

例子

julia> a = Iterators.repeated([1 2], 4);

julia> collect(a)
4-element Vector{Matrix{Int64}}:
 [1 2]
 [1 2]
 [1 2]
 [1 2]

julia> ans == fill([1 2], 4)
true

julia> Iterators.cycle([1 2], 4) |> collect |> println
[1, 2, 1, 2, 1, 2, 1, 2]

# '基。迭代器。产品'-Function</no-翻译>

product(iters...)

返回多个迭代器的乘积的迭代器。每个创建的元素都是一个元组，其`i’th元素来自参数的`i’th迭代器。第一个迭代器变化最快。

另请参阅说明 '拉链', '迭代器。展平'。

例子

julia> collect(Iterators.product(1:2, 3:5))
2×3 Matrix{Tuple{Int64, Int64}}:
 (1, 3)  (1, 4)  (1, 5)
 (2, 3)  (2, 4)  (2, 5)

julia>ans==[(x,y)for x in1:2,y in3:5]#构建一个包含迭代器的生成器。产品
真的

# '基。迭代器。展平`-Function

flatten(iter)

如果指定了输出迭代器的迭代器，则返回输出这些迭代器的元素的迭代器。换句话说，为参数的迭代器元素执行连接。

例子

julia> collect(Iterators.flatten((1:2, 8:9)))
4-element Vector{Int64}:
 1
 2
 8
 9

julia> [(x,y) for x in 0:1 for y in 'a':'c']  # собирает генераторы, включающие Iterators.flatten
6-element Vector{Tuple{Int64, Char}}:
 (0, 'a')
 (0, 'b')
 (0, 'c')
 (1, 'a')
 (1, 'b')
 (1, 'c')

# '基。迭代器。flatmap'-Function

Iterators.flatmap(f, iterators...)

等价于'flatten(map(f,iterators。..))`.

另请参阅说明 '迭代器。展平'和 '迭代器。地图'。

兼容性：Julia1.9

此功能在Julia1.9中添加。

例子

julia> Iterators.flatmap(n -> -n:2:n, 1:3) |> collect
9-element Vector{Int64}:
 -1
  1
 -2
  0
  2
 -3
 -1
  1
  3

julia> stack(n -> -n:2:n, 1:3)
ERROR: DimensionMismatch: stack expects uniform slices, got axes(x) == (1:3,) while first had (1:2,)
[...]

julia> Iterators.flatmap(n -> (-n, 10n), 1:2) |> collect
4-element Vector{Int64}:
 -1
 10
 -2
 20

julia> ans == vec(stack(n -> (-n, 10n), 1:2))
true

# '基。迭代器。分区'-Function

partition(collection, n)

一次遍历’n’项的集合。

例子

julia> collect(Iterators.partition([1,2,3,4,5], 2))
3-element Vector{SubArray{Int64, 1, Vector{Int64}, Tuple{UnitRange{Int64}}, true}}:
 [1, 2]
 [3, 4]
 [5]

# '基。迭代器。map'-Function

Iterators.map(f, iterators...)

创建延迟映射。这是编写`(f(args)的不同语法。..）对于zip中的args（迭代器。..))`.

兼容性：Julia1.6

此功能需要至少1.6的Julia版本。

例子

julia> collect(Iterators.map(x -> x^2, 1:3))
3-element Vector{Int64}:
 1
 4
 9

# '基。迭代器。过滤器'-Function

Iterators.filter(flt, itr)

如果指定了预测函数’flt’和可迭代对象’itr`，它返回可迭代对象，迭代后输出来自`itr`和`flt(x)`的元素`x'。初始迭代器的顺序被保留。

这个函数被放在一边，这意味着它被保证及时返回。，将使用额外的空间，并且’flt’不会通过调用’filter’来调用。 `Flt’调用将在迭代返回的可迭代对象时执行。这些调用不会被缓存，并且会在迭代时进行重复调用。

从"过滤器"返回的迭代器的后续延迟转换，例如使用"迭代器"执行的转换。反向’或’循环'，也将延迟对`flt’的调用，直到对返回的可迭代对象执行收集或迭代。如果过滤器谓词是非确定性的，或者其返回值取决于`itr`元素的迭代顺序，则具有延迟转换的组合可能导致意外行为。如果这是不可取的，请确保`flt`是纯函数，或者在进一步转换之前组装`filter’的中间迭代器。

厘米。 '基地。filter'获取有关数组筛选的直接实现的信息。

例子

julia> f = Iterators.filter(isodd, [1, 2, 3, 4, 5])
Base.Iterators.Filter{typeof(isodd), Vector{Int64}}(isodd, [1, 2, 3, 4, 5])

julia> foreach(println, f)
1
3
5

julia> [x for x in [1, 2, 3, 4, 5] if isodd(x)]  # собирает генератор для Iterators.filter
3-element Vector{Int64}:
 1
 3
 5

# '基。迭代器。累积`-Function

Iterators.accumulate(f, itr; [init])

如果指定了具有两个参数`f`和迭代器`itr`的函数，则它返回一个新的迭代器，该迭代器依次将`f`应用于前一个值和下一个元素`itr'。

这实际上是一个延迟版本。 '基地。累加`。

兼容性：Julia1.5

在Julia1.5中添加了命名的’init’参数。

例子

julia> a = Iterators.accumulate(+, [1,2,3,4]);

julia> foreach(println, a)
1
3
6
10

julia> b = Iterators.accumulate(/, (2, 5, 2, 5); init = 100);

julia> collect(b)
4-element Vector{Float64}:
 50.0
 10.0
  5.0
  1.0

# '基。迭代器。反向'-Function

Iterators.reverse(itr)

如果指定了迭代器’itr`，那么’reverse(itr)'是对同一个集合的迭代器，但顺序相反。这个迭代器是"延迟的"，因为它不创建集合的副本以便以相反的顺序迭代它。厘米。 '基地。反向'以获取有关简单实现的信息。

（默认情况下，'迭代器。返回Reverse’对象，将`itr’包含在shell中，如果定义了适当的方法，则可以迭代 'iterate'，但某些类型的’itr’可能实现’迭代器的更专门的行为。反转'。)

并非所有类型的`T’迭代器都支持逆序迭代。如果’T’不支持它，迭代’迭代器。reverse(itr::T)将返回错误。 'MethodError'，因为+迭代器没有`iterate`方法。反向{T}`. （要实现这些方法，初始迭代器是'itr::T`可以从对象`+r::Iterators获得。反向{T}'使用’r.itr'。更一般地说，你可以使用’迭代器。反向(r)`。)

例子

julia> foreach(println, Iterators.reverse(1:5))
5
4
3
2
1

# '基。迭代器。只有'-Function

only(x)

返回集合`x`或outputs的单个元素 'ArgumentError'，如果集合包含多个项目或不包含任何项目。

另请参阅说明 '第一`和 '最后`。

兼容性：Julia1.4

此方法需要至少1.4的Julia版本。

例子

julia> only(["a"])
"a"

julia> only("a")
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> only(())
ERROR: ArgumentError: Tuple contains 0 elements, must contain exactly 1 element
Stacktrace:
[...]

julia> only(('a', 'b'))
ERROR: ArgumentError: Tuple contains 2 elements, must contain exactly 1 element
Stacktrace:
[...]

# '基。迭代器。剥离`-Function

peel(iter)

返回第一个元素和剩余元素的迭代器。

如果迭代器为空，则返回’nothing`（类似于`iterate'）。

兼容性：Julia1.7

如果迭代器为空，则在以前的版本中返回BoundsError错误。

另请参阅说明 '迭代器。滴`, '迭代器。取'。

例子

julia> (a, rest) = Iterators.peel("abc");

julia> a
'a': ASCII/Unicode U+0061 (category Ll: Letter, lowercase)

julia> collect(rest)
2-element Vector{Char}:
 'b': ASCII/Unicode U+0062 (category Ll: Letter, lowercase)
 'c': ASCII/Unicode U+0063 (category Ll: Letter, lowercase)