标签: python-internals

在实例化和检索元素时,元组和列表之间是否存在性能差异？

为什么x**4.0比快x**4？我正在使用CPython 3.5.2.

$ python -m timeit "for x in range(100):" " x**4.0"
  10000 loops, best of 3: 24.2 usec per loop

$ python -m timeit "for x in range(100):" " x**4"
  10000 loops, best of 3: 30.6 usec per loop

我尝试改变我所提出的力量,看看它是如何动作的,例如,如果我将x提升到10或16的力量,它会从30跳到35,但如果我将10.0提升为浮动,它只是移动大约24.1~4.

我想它可能与浮点转换和2的幂有关,但我真的不知道.

我注意到在两种情况下,2的幂都更快,我想因为这些计算对于解释器/计算机而言更加原生/容易.但是,对于浮子,它几乎没有移动.2.0 => 24.1~4 & 128.0 => 24.1~4 但 2 => 29 & 128 => 62

它是一个链表,一个数组？我四处搜寻,只发现有人在猜测.我的C知识不足以查看源代码.

如何从类定义中的列表推导中访问其他类变量？以下适用于Python 2但在Python 3中失败:

class Foo:
    x = 5
    y = [x for i in range(1)]

Python 3.2给出了错误:

NameError: global name 'x' is not defined

尝试Foo.x也不起作用.有关如何在Python 3中执行此操作的任何想法？

一个稍微复杂的激励示例:

from collections import namedtuple
class StateDatabase:
    State = namedtuple('State', ['name', 'capital'])
    db = [State(*args) for args in [
        ['Alabama', 'Montgomery'],
        ['Alaska', 'Juneau'],
        # ...
    ]]

在这个例子中,apply()本来是一个不错的解决方法,但它遗憾地从Python 3中删除.

注意:此问题仅供参考.我很有兴趣看到Python内部有多深入,可以使用它.

不久前,在一个问题内部开始讨论是否可以在调用之后/期间修改传递给print语句的字符串print.例如,考虑功能:

def print_something():
    print('This cat was scared.')

现在,当print运行时,输出到终端应该显示:

This dog was scared.

请注意,"cat"一词已被"dog"一词取代.在某处某处能够修改那些内部缓冲区来改变打印的内容.假设这是在没有原始代码作者的明确许可的情况下完成的(因此,黑客/劫持).

这个评论从智者@abarnert,尤其让我思考:

有几种方法可以做到这一点,但它们都非常丑陋,永远不应该完成.最简单的方法是code将函数内的对象替换为 具有不同co_consts 列表的对象.接下来可能会进入C API来访问str的内部缓冲区.[...]

所以,看起来这实际上是可行的.

这是我解决这个问题的天真方式:

>>> import inspect
>>> exec(inspect.getsource(print_something).replace('cat', 'dog'))
>>> print_something()
This dog was scared.

当然,这exec很糟糕,但这并没有真正回答这个问题,因为在 print调用时/后调用时它实际上并没有修改任何内容.

如果@abarnert解释了它会怎么做？

我希望array.array比列表更快,因为数组似乎是未装箱的.

但是,我得到以下结果:

In [1]: import array

In [2]: L = list(range(100000000))

In [3]: A = array.array('l', range(100000000))

In [4]: %timeit sum(L)
1 loop, best of 3: 667 ms per loop

In [5]: %timeit sum(A)
1 loop, best of 3: 1.41 s per loop

In [6]: %timeit sum(L)
1 loop, best of 3: 627 ms per loop

In [7]: %timeit sum(A)
1 loop, best of 3: 1.39 s per loop

可能是造成这种差异的原因是什么？

我创建了两个名单l1和l2,但每一个具有不同的创建方法:

import sys

l1 = [None] * 10
l2 = [None for _ in range(10)]

print('Size of l1 =', sys.getsizeof(l1))
print('Size of l2 =', sys.getsizeof(l2))

但输出让我感到惊讶:

Size of l1 = 144
Size of l2 = 192

使用列表推导创建的列表在内存中的大小更大,但是这两个列表在Python中是相同的.

这是为什么？这是CPython内部的一些东西,还是其他一些解释？

Apparently list(a) doesn't overallocate, [x for x in a] overallocates at some points, and [*a] overallocates all the time?

Here are sizes n from 0 to 12 and the resulting sizes in bytes for the three methods:

0 56 56 56
1 64 88 88
2 72 88 96
3 80 88 104
4 88 88 112
5 96 120 120
6 104 120 128
7 112 120 136
8 120 120 152
9 128 184 184
10 136 …

我不明白如何通过'任意'顺序完成字典或python中的循环.

我的意思是,它是一种编程语言,所以语言中的所有内容都必须100%确定,对吗？Python必须有某种算法来决定选择字典或集合的哪一部分,第一,第二等等.

我错过了什么？

我正在玩timeit并注意到对一个小字符串做一个简单的列表理解比在一个小的单个字符串列表上做同样的操作要花费更长的时间.任何解释？这几乎是1.35倍的时间.

>>> from timeit import timeit
>>> timeit("[x for x in 'abc']")
2.0691067844831528
>>> timeit("[x for x in ['a', 'b', 'c']]")
1.5286479570345861

在较低的水平上发生了什么导致这种情况？