正如其他人所提到的，预播种列表的最简单方法是使用NoneType对象。

话虽如此，在决定这是必要的之前，您应该了解Python列表的实际工作方式。

在列表的CPython实现中，底层数组总是创建有开销空间，大小逐渐增大(4、8、16、25、35、46、58、72、88、106、126、148、173、201、233、269、309、354、405、462、526、598、679、771、874、990、1120等)，因此调整列表的大小几乎不会经常发生。

由于这种行为，大多数list.append()函数的追加复杂度都是O(1)，只有在跨越其中一个边界时复杂度才会增加，此时复杂度将为O(n)。在S.Lott的答案中，这种行为导致了执行时间的最小增加。

来源:Python列表实现

如果使用NumPy，就会出现Python中的预分配问题，因为NumPy有更多类似c的数组。在这种情况下，预分配关注的是数据的形状和默认值。

如果要在大量列表上进行数值计算并希望获得性能，可以考虑NumPy。

对于某些应用程序，字典可能是您正在寻找的。例如，在find_totient方法中，我发现使用字典更方便，因为我没有零索引。

def totient(n):
    totient = 0

    if n == 1:
        totient = 1
    else:
        for i in range(1, n):
            if math.gcd(i, n) == 1:
                totient += 1
    return totient

def find_totients(max):
    totients = dict()
    for i in range(1,max+1):
        totients[i] = totient(i)

    print('Totients:')
    for i in range(1,max+1):
        print(i,totients[i])

这个问题也可以用预分配的列表来解决:

def find_totients(max):
    totients = None*(max+1)
    for i in range(1,max+1):
        totients[i] = totient(i)

    print('Totients:')
    for i in range(1,max+1):
        print(i,totients[i])

我觉得这不是很优雅，而且容易产生错误，因为我存储的是None，如果我不小心错误地使用它们，它可能会抛出异常，而且因为我需要考虑映射让我避免的边缘情况。

没错，字典的效率不会那么高，但正如其他人评论的那样，速度上的微小差异并不总是值得冒重大维护风险。

最快的方法-使用* like list1 = [False] * 1_000_000

比较所有常用方法(列表追加、预分配、for和while)，我发现使用*可以获得最高效的执行时间。

import time

large_int = 10_000_000
start_time = time.time()

# Test 1: List comprehension
l1 = [False for _ in range(large_int)]
end_time_1 = time.time()

# Test 2: Using *
l2 = [False] * large_int
end_time_2 = time.time()

# Test 3: Using append with for loop & range
l3 = []
for _ in range(large_int):
    l3.append(False)
end_time_3 = time.time()

# Test 4: Using append with while loop
l4, i = [], 0
while i < large_int:
    l4.append(False)
    i += 1
end_time_4 = time.time()

# Results
diff_1 = end_time_1 - start_time
diff_2 = end_time_2 - end_time_1
diff_3 = end_time_3 - end_time_2
diff_4 = end_time_4 - end_time_3
print(f"Test 1. {diff_1:.4f} seconds")
print(f"Test 2. {diff_2:.4f} seconds")
print(f"Test 3. {diff_3:.4f} seconds")
print(f"Test 4. {diff_4:.4f} seconds")

print("\nTest 2 is faster than - ")
print(f"            Test 1 by - {(diff_1 / diff_2 * 100 - 1):,.0f}%")
print(f"            Test 3 by - {(diff_3 / diff_2 * 100 - 1):,.0f}%")
print(f"            Test 4 by - {(diff_4 / diff_2 * 100 - 1):,.0f}%")

正如其他人所提到的，预播种列表的最简单方法是使用NoneType对象。

话虽如此，在决定这是必要的之前，您应该了解Python列表的实际工作方式。

在列表的CPython实现中，底层数组总是创建有开销空间，大小逐渐增大(4、8、16、25、35、46、58、72、88、106、126、148、173、201、233、269、309、354、405、462、526、598、679、771、874、990、1120等)，因此调整列表的大小几乎不会经常发生。

由于这种行为，大多数list.append()函数的追加复杂度都是O(1)，只有在跨越其中一个边界时复杂度才会增加，此时复杂度将为O(n)。在S.Lott的答案中，这种行为导致了执行时间的最小增加。

来源:Python列表实现

我运行了S.Lott的代码，通过预分配获得了同样10%的性能提升。我使用发电机尝试了Ned Batchelder的想法，并能够看到发电机的性能优于doAllocate。对于我的项目来说，10%的改进很重要，所以感谢每个人，因为这对我有帮助。

def doAppend(size=10000):
    result = []
    for i in range(size):
        message = "some unique object %d" % ( i, )
        result.append(message)
    return result

def doAllocate(size=10000):
    result = size*[None]
    for i in range(size):
        message = "some unique object %d" % ( i, )
        result[i] = message
    return result

def doGen(size=10000):
    return list("some unique object %d" % ( i, ) for i in xrange(size))

size = 1000
@print_timing
def testAppend():
    for i in xrange(size):
        doAppend()

@print_timing
def testAlloc():
    for i in xrange(size):
        doAllocate()

@print_timing
def testGen():
    for i in xrange(size):
        doGen()


testAppend()
testAlloc()
testGen()

输出

testAppend took 14440.000ms
testAlloc took 13580.000ms
testGen took 13430.000ms