但是,我决定进行一些测试,并实现这个函数(以懒惰和存储形式展平包含Ints或[Int] s的数组[Any]),结果表明存储的形式更快,即使刚刚使用迭代元素！这意味着,不知何故,迭代生成器比在内存中构造新数组花费更多的时间,然后迭代它.

令人难以置信的是,它甚至比同一程序的python实现慢约5-70％,随着输入的减少而恶化. Swift是用-O标志构建的.

这里有三个测试用例1.小输入,混合; 2.大输入,[Int]显性,3.大输入,Int显性：

迅速

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)

蟒蛇

A1 = [list(range(1,101)),list(range(101,106)),list(range(107,112)),list(range(115,126))]
A2 = list(range(1,6)) * 2000
A3 = [31] * 10000

生成器和数组构建器：

迅速

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
}

蟒蛇

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个)：

迅速

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 *

蟒蛇

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程序员)会有这样的情况：如果我们试图合成一个不可变对象(比如一个字符串),我们首先应该将源提供给一个生成函数来展开它,然后手将输出关闭到一个join()方法,该方法适用于单个浅序列.相反,看起来最有效的策略是通过数组进行序列化;将源展开到中间数组,然后构造数组的输出.

是构建一个完整的新数组,然后通过它迭代它比原始数组上的延迟迭代更快？为什么？

(Possibly related javascript question)

编辑

这是测试代码：

迅速

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))

蟒蛇

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,ΔG2

print(time_f(A1,cycles=100000))
print(time_f(A3,cycles=1000))
print(time_f(A2,cycles=1000))