这有点与这个问题 https://stackoverflow.com/questions/40669193/explain-swift-iterators/40672317#40672317，其中假设使用生成器（迭代器）遍历嵌套数组对于迭代元素来说是最佳选择，只要您不需要存储结果，而如果您只想存储结果，则使用重复数组串联是最好的展平阵列。
然而，我决定做一些测试，并实现这个函数（将数组展平）[Any]包含任一Ints or [Int]s) 在惰性和存储形式中，事实证明存储形式更快，即使仅用于迭代元素！这意味着不知何故，迭代生成器比两者都花费更多的时间建造内存中的一个新数组，以及then迭代that.
令人难以置信的是，它甚至比普通计算机慢 5-70% 左右。python实施相同的计划，投入越少，情况就越糟。 Swift 是用-O flag.
这是三个测试用例 1. 小输入，混合； 2.输入量大，[Int]占主导地位，3.大投入，Int主导的：
Swift
let array1: [Any] = [Array(1...100), Array(101...105), 106,
Array(107...111), 112, 113, 114, Array(115...125)]
let array2: [Any] = Array(repeating: Array(1...5), count: 2000)
let array3: [Any] = Array(repeating: 31, count: 10000)
Python
A1 = [list(range(1, 101)), list(range(101, 106)), 106,
list(range(107, 112)), 112, 113, 114, list(range(115, 126))]
A2 = list(range(1, 6)) * 2000
A3 = [31] * 10000
生成器和数组生成器：
Swift
func chain(_ segments: [Any]) -> AnyIterator<Int>{
var i = 0
var j = 0
return AnyIterator<Int> {
while i < segments.count {
switch segments[i] {
case let e as Int:
i += 1
return e
case let E as [Int]:
if j < E.count {
let val = E[j]
j += 1
return val
}
j = 0
i += 1
default:
return nil
}
}
return nil
}
}
func flatten_array(_ segments: [Any]) -> [Int] {
var result = [Int]()
for segment in segments {
switch segment {
case let segment as Int:
result.append(segment)
case let segment as [Int]:
result.append(contentsOf: segment)
default:
break
}
}
return result
}
Python
def chain(L):
for i in L:
if type(i) is int:
yield i
elif type(i) is list:
yield from i
def flatten_list(L):
result = []
for i in L:
if type(i) is int:
result.append(i)
elif type(i) is list:
result.extend(i)
return result
基准测试结果（第一个测试用例 100000 次循环，其他测试用例 1000 次）：
Swift
test case 1 (small mixed input)
Filling an array : 0.068221092224121094 s
Filling an array, and looping through it : 0.074559926986694336 s
Looping through a generator : 1.5902719497680664 s *
Materializing the generator to an array : 1.759943962097168 s *
test case 2 (large input, [Int] s)
Filling an array : 0.20634698867797852 s
Filling an array, and looping through it : 0.21031379699707031 s
Looping through a generator : 1.3505551815032959 s *
Materializing the generator to an array : 1.4733860492706299 s *
test case 3 (large input, Int s)
Filling an array : 0.27392101287841797 s
Filling an array, and looping through it : 0.27670192718505859 s
Looping through a generator : 0.85304021835327148 s
Materializing the generator to an array : 1.0027849674224854 s *
Python
test case 1 (small mixed input)
Filling an array : 0.1622014045715332 s
Filling an array, and looping through it : 0.4312894344329834 s
Looping through a generator : 0.6839139461517334 s
Materializing the generator to an array : 0.5300459861755371 s
test case 2 (large input, [int] s)
Filling an array : 1.029205083847046 s
Filling an array, and looping through it : 1.2195289134979248 s
Looping through a generator : 1.0876803398132324 s
Materializing the generator to an array : 0.8958714008331299 s
test case 3 (large input, int s)
Filling an array : 1.0181667804718018 s
Filling an array, and looping through it : 1.244570255279541 s
Looping through a generator : 1.1220412254333496 s
Materializing the generator to an array : 0.9486079216003418 s
显然，Swift 非常非常擅长构建数组。但为什么它的生成器如此慢，在某些情况下甚至比 Python 还慢？ （标有*表中。）使用极大的输入（> 100,000,000 个元素，几乎使 Swift 崩溃）进行测试表明，即使在极限情况下，生成器在最好的情况下也比数组填充慢至少 3.25 倍。
如果这确实是该语言固有的，那么它会产生一些有趣的含义。例如，常识（无论如何对我作为一个Python程序员来说）都会认为，如果我们试图合成一个不可变的对象（如字符串），我们应该首先将源提供给生成函数来展开它，然后手工关闭输出到joined()适用于单个浅层序列的方法。相反，看起来最有效的策略是通过数组进行序列化；将源展开为中间数组，然后从该数组构造输出。
构建一个全新的数组然后迭代它是否比原始数组上的惰性迭代更快？为什么？
(可能相关的javascript问题 https://stackoverflow.com/questions/32983296/why-is-using-a-generator-function-slower-than-filling-and-iterating-an-array-in)
Edit
这是测试代码：
Swift
func time(test_array: [Any], cycles: Int = 1000000) -> (array_iterate: Double,
array_store : Double,
generate_iterate: Double,
generate_store: Double) {
func start() -> Double { return Date().timeIntervalSince1970 }
func lap(_ t0: Double) -> Double {
return Date().timeIntervalSince1970 - t0
}
var t0 = start()
for _ in 0..<cycles {
for e in flatten_array(test_array) { e + 1 }
}
let ΔE1 = lap(t0)
t0 = start()
for _ in 0..<cycles {
let array: [Int] = flatten_array(test_array)
}
let ΔE2 = lap(t0)
t0 = start()
for _ in 0..<cycles {
let G = chain(test_array)
while let g = G.next() { g + 1 }
}
let ΔG1 = lap(t0)
t0 = start()
for _ in 0..<cycles {
let array: [Int] = Array(chain(test_array))
}
let ΔG2 = lap(t0)
return (ΔE1, ΔE2, ΔG1, ΔG2)
}
print(time(test_array: array1, cycles: 100000))
print(time(test_array: array2, cycles: 1000))
print(time(test_array: array3, cycles: 1000))
Python
def time_f(test_array, cycles = 1000000):
lap = lambda t0: time() - t0
t0 = time()
for _ in range(cycles):
for e in flatten_list(test_array):
e + 1
ΔE1 = lap(t0)
t0 = time()
for _ in range(cycles):
array = flatten_list(test_array)
ΔE2 = lap(t0)
t0 = time()
for _ in range(cycles):
for g in chain(test_array):
g + 1
ΔG1 = lap(t0)
t0 = time()
for _ in range(cycles):
array = list(chain(test_array))
ΔG2 = lap(t0)
return ΔE1, ΔE2, ΔG1, ΔG2
print(time_f(A1, cycles=100000))
print(time_f(A3, cycles=1000))
print(time_f(A2, cycles=1000))
