标签: python-internals

据我所知,该range()函数实际上是Python 3中的一个对象类型,它可以动态生成其内容,类似于生成器.

在这种情况下,我预计下面的行会花费大量的时间,因为为了确定1千万亿是否在该范围内,必须生成一个千万亿的值:

1000000000000000 in range(1000000000000001)

此外:似乎无论我添加多少个零,计算或多或少都需要相同的时间(基本上是瞬时的).

我也试过这样的事情,但计算仍然几乎是即时的:

1000000000000000000000 in range(0,1000000000000000000001,10) # count by tens

如果我尝试实现自己的范围功能,结果就不那么好了!!

def my_crappy_range(N):
    i = 0
    while i < N:
        yield i
        i += 1
    return

range()在引擎盖下做的对象是什么让它如此之快？

选择Martijn Pieters的答案是因为它的完整性,但也看到了abarnert的第一个答案,可以很好地讨论在Python 3中range成为一个完整的序列意味着什么,以及关于__contains__Python实现中函数优化的潜在不一致的一些信息/警告.abarnert的另一个答案更详细,并为那些对Python 3中的优化背后的历史感兴趣的人提供了链接(并且缺乏xrangePython 2中的优化).poke和wim的答案为感兴趣的人提供了相关的C源代码和解释.

我想了解内置函数的property工作原理.令我困惑的是,property它也可以用作装饰器,但它只在用作内置函数时才需要参数,而不是用作装饰器时.

这个例子来自文档:

class C(object):
    def __init__(self):
        self._x = None

    def getx(self):
        return self._x
    def setx(self, value):
        self._x = value
    def delx(self):
        del self._x
    x = property(getx, setx, delx, "I'm the 'x' property.")

property的论点是getx,setx,delx和文档字符串.

在下面的代码中property用作装饰器.它的对象是x函数,但在上面的代码中,参数中没有对象函数的位置.

class C(object):
    def __init__(self):
        self._x = None

    @property
    def x(self):
        """I'm the 'x' property."""
        return self._x

    @x.setter
    def x(self, value):
        self._x = value

    @x.deleter
    def x(self):
        del self._x

而且,如何在 …

__slots__Python中的目的是什么- 特别是关于我何时想要使用它,何时不想使用它？

为什么以下在Python中出现意外行为？

>>> a = 256
>>> b = 256
>>> a is b
True           # This is an expected result
>>> a = 257
>>> b = 257
>>> a is b
False          # What happened here? Why is this False?
>>> 257 is 257
True           # Yet the literal numbers compare properly

我使用的是Python 2.5.2.尝试一些不同版本的Python,似乎Python 2.3.3显示了99到100之间的上述行为.

基于以上所述,我可以假设Python在内部实现,使得"小"整数以不同于大整数的方式存储,is运算符可以区分.为什么泄漏抽象？当我不知道它们是否是数字时,比较两个任意对象以查看它们是否相同的更好的方法是什么？

字典在Python 3.6中排序(至少在CPython实现下),与之前的版本不同.这似乎是一个重大变化,但它只是文档中的一小段.它被描述为CPython实现细节而不是语言特性,但也暗示这可能成为未来的标准.

在保留元素顺序的同时,新字典实现如何比旧字典实现更好？

以下是文档中的文字:

dict()现在使用PyPy开创的"紧凑"表示.与Python 3.5相比,新dict()的内存使用量减少了20%到25%.PEP 468(在函数中保留**kwargs的顺序.)由此实现.这个新实现的顺序保留方面被认为是一个实现细节,不应该依赖(这可能会在未来发生变化,但是在更改语言规范之前,希望在几种版本的语言中使用这个新的dict实现为所有当前和未来的Python实现强制命令保留语义;这也有助于保持与随机迭代顺序仍然有效的语言的旧版本的向后兼容性,例如Python 3.5).(由INADA Naoki在issue 27350中提供.最初由Raymond Hettinger提出的想法.)

2017年12月更新:Python 3.7 保证了dict保留插入顺序

在Python for*nix中,是否会time.sleep()阻塞线程或进程？

我真的不能想到为什么python需要del关键字(并且大多数语言似乎没有类似的关键字).例如,不是删除变量,而是可以分配None给它.从字典中删除时,del可以添加方法.

是否有任何理由保留delpython,或者它是Python垃圾收集前几天的遗迹？

将浮点数与整数进行比较时,某些值对的评估时间比其他类似值的值要长得多.

例如:

>>> import timeit
>>> timeit.timeit("562949953420000.7 < 562949953421000") # run 1 million times
0.5387085462592742

但是如果浮点数或整数变小或变大一定量,则比较运行得更快:

>>> timeit.timeit("562949953420000.7 < 562949953422000") # integer increased by 1000
0.1481498428446173
>>> timeit.timeit("562949953423001.8 < 562949953421000") # float increased by 3001.1
0.1459577925548956

更改比较运算符(例如,使用==或>替代)不会以任何明显的方式影响时间.

这并不仅仅与幅度有关,因为选择更大或更小的值可以导致更快的比较,因此我怀疑它是由于位排列的一些不幸的方式.

显然,对于大多数用例来说,比较这些值的速度要快得多.我只是好奇为什么Python似乎更多地使用一些值而不是其他值.

>>> timeit.timeit("'x' in ('x',)")
0.04869917374131205
>>> timeit.timeit("'x' == 'x'")
0.06144205736110564

也适用于具有多个元素的元组,两个版本似乎线性增长:

>>> timeit.timeit("'x' in ('x', 'y')")
0.04866674801541748
>>> timeit.timeit("'x' == 'x' or 'x' == 'y'")
0.06565782838087131
>>> timeit.timeit("'x' in ('y', 'x')")
0.08975995576448526
>>> timeit.timeit("'x' == 'y' or 'x' == 'y'")
0.12992391047427532

基于此,我认为我应该完全开始使用in到处而不是==!

什么是全球解释器锁,为什么它是一个问题？

围绕从Python中删除GIL已经产生了很多噪音,我想知道为什么这么重要.我自己从未编写过编译器或解释器,所以不要节俭细节,我可能需要他们理解.