问题：为什么[]比list（）快？
我最近比较了[]和的处理速度，并list()惊讶地发现它的[]运行速度是的三倍以上list()。我跑了相同的测试与{}和dict()，结果几乎相同：[]和{}两个花了大约0.128sec /百万次，而list()并dict()把每个粗0.428sec /万次。
为什么是这样？不要[]和{}（可能()和''，太）立即传回了一些空的股票面值的副本，而其明确命名同行（list()，dict()，tuple()，str()）完全去创建一个对象，他们是否真的有元素？
我不知道这两种方法有何不同，但我很想找出答案。我在文档中或SO上都找不到答案，而寻找空括号却比我预期的要麻烦得多。
通过分别调用timeit.timeit("[]")和timeit.timeit("list()")，和timeit.timeit("{}")和timeit.timeit("dict()")来比较列表和字典，以获得计时结果。我正在运行Python 2.7.9。
我最近发现“ 为什么True慢于if？ ”比较了if Trueto 的性能，if 1并且似乎触及了类似的文字对全局场景；也许也值得考虑。
回答 0
因为[]和{}是文字语法。Python可以创建字节码仅用于创建列表或字典对象：
>>> import dis
>>> dis.dis(compile('[]', '', 'eval'))
1 0 BUILD_LIST 0
3 RETURN_VALUE
>>> dis.dis(compile('{}', '', 'eval'))
1 0 BUILD_MAP 0
3 RETURN_VALUE list()和dict()是单独的对象。它们的名称需要解析，必须包含堆栈以推入参数，必须存储框架以供以后检索，并且必须进行调用。这都需要更多时间。
对于空的情况，这意味着您至少要有一个LOAD_NAME（必须在全局命名空间以及__builtin__模块中进行搜索），后跟一个CALL_FUNCTION必须保留当前帧的：
>>> dis.dis(compile('list()', '', 'eval'))
1 0 LOAD_NAME 0 (list)
3 CALL_FUNCTION 0
6 RETURN_VALUE
>>> dis.dis(compile('dict()', '', 'eval'))
1 0 LOAD_NAME 0 (dict)
3 CALL_FUNCTION 0
6 RETURN_VALUE 您可以使用以下命令分别计时名称查找timeit：
>>> import timeit
>>> timeit.timeit('list', number=10**7)
0.30749011039733887
>>> timeit.timeit('dict', number=10**7)
0.4215109348297119时间差异可能是字典哈希冲突。从调用这些对象的时间中减去这些时间，然后将结果与使用文字的时间进行比较：
>>> timeit.timeit('[]', number=10**7)
0.30478692054748535
>>> timeit.timeit('{}', number=10**7)
0.31482696533203125
>>> timeit.timeit('list()', number=10**7)
0.9991960525512695
>>> timeit.timeit('dict()', number=10**7)
1.0200958251953125因此，1.00 - 0.31 - 0.30 == 0.39每1000万次调用必须调用该对象花费了额外的几秒钟。
您可以通过将全局名称别名为本地名称来避免全局查找成本（使用timeit设置，绑定到名称的所有内容都是本地名称）：
>>> timeit.timeit('_list', '_list = list', number=10**7)
0.1866450309753418
>>> timeit.timeit('_dict', '_dict = dict', number=10**7)
0.19016098976135254
>>> timeit.timeit('_list()', '_list = list', number=10**7)
0.841480016708374
>>> timeit.timeit('_dict()', '_dict = dict', number=10**7)
0.7233691215515137但您永远无法克服这些CALL_FUNCTION成本。
回答 1
list()需要全局查找和函数调用，但需要[]编译为一条指令。看到：
Python 2.7.3
>>> import dis
>>> print dis.dis(lambda: list())
1 0 LOAD_GLOBAL 0 (list)
3 CALL_FUNCTION 0
6 RETURN_VALUE
None
>>> print dis.dis(lambda: [])
1 0 BUILD_LIST 0
3 RETURN_VALUE
None回答 2
因为list是一个功能转化说一个字符串列表对象，而[]用于创建一个列表蝙蝠。尝试一下（可能对您更有意义）：
x = "wham bam"
a = list(x)
>>> a
["w", "h", "a", "m", ...]而
y = ["wham bam"]
>>> y
["wham bam"]为您提供包含您所输入内容的实际列表。
回答 3
至此，答案非常好，并完全涵盖了这个问题。对于那些感兴趣的人，我将进一步从字节码中删除。我正在使用CPython的最新仓库；在这方面，旧版本的行为类似，但可能会稍作更改。
这是每个BUILD_LIST针对for []和CALL_FUNCTIONfor 的执行情况的细分list()。
该BUILD_LIST指令：
您应该只查看恐怖：
PyObject *list = PyList_New(oparg);
if (list == NULL)
goto error;
while (--oparg >= 0) {
PyObject *item = POP();
PyList_SET_ITEM(list, oparg, item);
}
PUSH(list);
DISPATCH();我知道那令人费解。这是多么简单：
- 使用创建新列表
PyList_New（主要是为新的列表对象分配内存），以oparg信号指示堆栈上的参数数量。开门见山。 - 检查是否没有问题
if (list==NULL)。 - 使用
PyList_SET_ITEM（宏）添加位于堆栈上的所有参数（在我们的示例中此参数未执行）。
难怪它很快！它是为创建新列表而定制的，仅此而已:-)
该CALL_FUNCTION指令：
窥视代码处理时，这是您看到的第一件事CALL_FUNCTION：
PyObject **sp, *res;
sp = stack_pointer;
res = call_function(&sp, oparg, NULL);
stack_pointer = sp;
PUSH(res);
if (res == NULL) {
goto error;
}
DISPATCH();看起来很无害吧？好吧，不是，不幸的call_function是，不是一个会立即调用该函数的直截了当的家伙，它不会。相反，它从堆栈中获取对象，获取堆栈中的所有参数，然后根据对象的类型进行切换。它是：
PyCFunction_Type？不，它是list，list是类型的不PyCFunctionPyMethodType？不，请参见前面。PyFunctionType？不，请参见前面。
我们正在调用list类型，传入的参数call_function是PyList_Type。CPython现在必须调用一个泛型函数来处理名为的所有可调用对象_PyObject_FastCallKeywords，还有更多函数调用。
该函数再次检查某些函数类型（我不明白为什么），然后在为kwargs创建字典后，如果需要，继续调用_PyObject_FastCallDict。
_PyObject_FastCallDict终于把我们带到某个地方！执行后甚至更多的检查 它抓住了tp_call从插槽type中的type我们在通过了，那就是它抓住type.tp_call。然后，它根据传入的参数来创建元组_PyStack_AsTuple，最后可以最终进行调用！
tp_call，它将匹配type.__call__并最终创建列表对象。它调用与之__new__对应的列表PyType_GenericNew并为其分配内存PyType_GenericAlloc：这实际上是它与追上的部分PyList_New，最后。所有以前的内容对于以通用方式处理对象都是必需的。
最后，使用任何可用参数type_call调用list.__init__并初始化列表，然后继续返回原来的方式。:-)
最后，记住 LOAD_NAME，这是另一个在这里做出贡献的家伙。
很容易看到，在处理我们的输入时，Python通常必须跳过圈以真正找到合适的C函数来完成工作。它不具有立即调用它的功能，因为它是动态的，有人可能会掩盖list（并且男孩会做很多人做的事情），因此必须采取另一条路。
这是哪里 list()损失很多的地方：正在探索的Python需要做以找出它应该做什么。
另一方面，字面语法恰好意味着一回事。它无法更改，并且始终以预定的方式运行。
脚注：所有功能名称均可能从一个版本更改为另一个版本。关键点仍然存在，并且很可能在将来的任何版本中都存在，这是动态查找使事情变慢的原因。
回答 4
为什么
[]要比list()？
最大的原因是Python list()就像用户定义的函数一样对待，这意味着您可以通过别名别名来拦截它list并做一些不同的事情（例如使用您自己的子类列表或双端队列）。
它将立即使用创建新的内置列表实例[]。
我的解释旨在为您提供直觉。
说明
[] 通常称为文字语法。
在语法中，这称为“列表显示”。从文档：
列表显示是括在方括号中的一系列可能为空的表达式：
list_display ::= "[" [starred_list | comprehension] "]"列表显示将产生一个新的列表对象，其内容由表达式列表或理解列表指定。提供逗号分隔的表达式列表时，将按从左到右的顺序评估其元素，并将其按此顺序放入列表对象中。提供理解后，将根据理解产生的元素来构建列表。
简而言之，这意味着将list创建一个内置类型的对象。
不能回避这一点-这意味着Python可以尽快完成它。
另一方面，list()可以list使用内置列表构造函数拦截创建内置对象的过程。
例如，假设我们希望创建噪音较大的列表：
class List(list):
def __init__(self, iterable=None):
if iterable is None:
super().__init__()
else:
super().__init__(iterable)
print('List initialized.')然后，我们可以list在模块级别的全局范围内截取该名称，然后在创建时list，实际上创建了子类型列表：
>>> list = List
>>> a_list = list()
List initialized.
>>> type(a_list)
<class '__main__.List'>同样，我们可以将其从全局命名空间中删除
del list并将其放在内置命名空间中：
import builtins
builtins.list = List现在：
>>> list_0 = list()
List initialized.
>>> type(list_0)
<class '__main__.List'>并注意列表显示无条件创建列表：
>>> list_1 = []
>>> type(list_1)
<class 'list'>我们可能只是暂时执行此操作，所以请撤消更改-首先List从内置文件中删除新对象：
>>> del builtins.list
>>> builtins.list
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: module 'builtins' has no attribute 'list'
>>> list()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
NameError: name 'list' is not defined哦，不，我们失去了原来的踪迹。
不用担心，我们仍然可以得到list-它是列表文字的类型：
>>> builtins.list = type([])
>>> list()
[]所以…
为什么
[]要比list()？
如我们所见-我们可以覆盖list-但是我们不能截取文字类型的创建。使用时，list我们必须进行查找以查看是否存在任何内容。
然后，我们必须调用已查找的任何可调用对象。从语法上：
调用使用一系列可能为空的参数来调用可调用对象（例如，函数）：
call ::= primary "(" [argument_list [","] | comprehension] ")"
我们可以看到它对任何名称都具有相同的作用，而不仅仅是列表：
>>> import dis
>>> dis.dis('list()')
1 0 LOAD_NAME 0 (list)
2 CALL_FUNCTION 0
4 RETURN_VALUE
>>> dis.dis('doesnotexist()')
1 0 LOAD_NAME 0 (doesnotexist)
2 CALL_FUNCTION 0
4 RETURN_VALUE因为[]在Python字节码级别没有函数调用：
>>> dis.dis('[]')
1 0 BUILD_LIST 0
2 RETURN_VALUE它只是直接建立列表而无需在字节码级别进行任何查找或调用。
结论
我们已经证明了list可以使用范围规则用用户代码拦截，并且可以list()查找可调用对象然后调用它。
而[]列表显示或文字显示则避免了名称查找和函数调用。