标签: python-internals

有人可以解释以下内容吗？

为什么id相同,但列表不同？

>>> [] is []
False
>>> id([]) == id([])
True

列表创建有区别吗？

>>> id(list()) == id(list())
False
>>> id([]) == id([])
True

为什么会这样？我得到两个不同的列表.为什么不只有一个,三个或更多？

>>> [].__repr__
<method-wrapper '__repr__' of list object at 0x7fd2be868128>
>>> [].__repr__
<method-wrapper '__repr__' of list object at 0x7fd2be868170>
>>> [].__repr__
<method-wrapper '__repr__' of list object at 0x7fd2be868128>
>>> [].__repr__
<method-wrapper '__repr__' of list object at 0x7fd2be868170>

如果您运行x = 'y' 'z'在Python中,你得到x设置'yz',这意味着当Python看到彼此相邻的多个字符串某种字符串连接的发生.

但这是什么样的串联？它实际上正在运行'y' + 'z'还是正在运行''.join('y','z')或其他什么？

我list(x for x in a)用三个不同的 CPython 版本进行了测试。Ona = [0]比 on 快得多a = []：

 3.9.0 64-bit       3.9.0 32-bit       3.7.8 64-bit
a = []  a = [0]    a = []  a = [0]    a = []  a = [0]

465 ns  412 ns     543 ns  515 ns     513 ns  457 ns   
450 ns  406 ns     544 ns  515 ns     506 ns  491 ns   
456 ns  408 ns     551 ns  513 ns     515 ns  487 ns   
455 …

我们都知道这eval很危险,即使你隐藏了危险的函数,因为你可以使用Python的内省功能深入挖掘并重新提取它们.例如,即使您删除__builtins__,也可以使用它来检索它们

[c for c in ().__class__.__base__.__subclasses__()  
 if c.__name__ == 'catch_warnings'][0]()._module.__builtins__

但是,我见过的每个例子都使用属性访问.如果我禁用所有内置函数并禁用属性访问(通过使用Python令牌化程序对输入进行标记,并在具有属性访问令牌时拒绝它),该怎么办？

在你问之前,不,对于我的用例,我不需要其中任何一个,所以它不会太瘫痪.

我想要做的是让SymPy的同情功能更安全.目前,它对输入进行了标记,对其进行了一些转换,并在命名空间中对其进行了演绎.但它不安全,因为它允许属性访问(即使它真的不需要它).

Beazley第100页提到:

>>>python.__closure__
(<cell at 0x67f50: str object at 0x69230>,)
>>>python.__closure__[0].cell_contents

我的理解是这__closure__是一个列表但是这些单元格和str对象是什么？这看起来像一个单元组？

我在这里遇到了这个功能.

我对这将如何实现感到困惑 - 如何key通过cmp_to_key知道给定元素的"位置"而不检查给定元素与其他感兴趣元素的比较来生成函数？

我想知道为什么repr(int)比快str(int).使用以下代码段:

ROUNDS = 10000

def concat_strings_str():
    return ''.join(map(str, range(ROUNDS)))

def concat_strings_repr():
    return ''.join(map(repr, range(ROUNDS)))

%timeit concat_strings_str()
%timeit concat_strings_repr()

我得到了这些时间(python 3.5.2,但与2.7.12的结果非常相似):

 1.9 ms ± 17.9 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
 1.38 ms ± 9.07 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)

如果我走在正确的道路上,同样的功能long_to_decimal_string就会在引擎盖下面调用.

我错了什么或者我还缺少什么？

更新:这可能没有什么用int的__repr__或__str__方法,但之间的差异repr()和str(),如int.__str__和 …

尝试一些代码并做一些微基准测试我发现float在包含整数的字符串上使用函数比int在同一个字符串上使用快2倍.

>>> python -m timeit int('1')
1000000 loops, best of 3: 0.548 usec per loop

>>> python -m timeit float('1')
1000000 loops, best of 3: 0.273 usec per loop

在测试int(float('1'))哪个运行时比裸机短时,它变得更加奇怪int('1').

>>> python -m timeit int(float('1'))
1000000 loops, best of 3: 0.457 usec per loop

我在运行cPython 2.7.6的Windows 7和使用cPython 2.7.6的Linux Mint 16下测试了代码.

我必须补充一点,只有Python 2受到影响,Python 3显示了运行时之间的差异(不显着)差异.

我知道这些微基准测试得到的信息很容易被滥用,但我很好奇为什么函数的运行时存在这样的差异.

我试图找到的实现int和float而不同的资料来源,我不能找到它.

我为该input()功能提供的输入有多大？

不幸的是,没有简单的方法来测试它.在使用了大量的复制粘贴之后,我input无法在我提供的任何输入上失败.(我最终放弃了)

该文档的input功能,并没有提及关于这样的东西:

如果prompt参数存在,则将其写入标准输出而不带尾随换行符.然后,该函数从输入中读取一行,将其转换为字符串(剥离尾部换行符),然后返回该行.读取EOF时,EOFError会引发.

那么,我猜是没有限制的？有没有人知道是否有,如果有,多少钱？

class Foo:
    def __getitem__(self, item):
        print('getitem', item)
        if item == 6:
            raise IndexError
        return item**2
    def __len__(self):
        print('len')
        return 3

class Bar:
    def __iter__(self):
        print('iter')
        return iter([3, 5, 42, 69])
    def __len__(self):
        print('len')
        return 3

演示:

>>> list(Foo())
len
getitem 0
getitem 1
getitem 2
getitem 3
getitem 4
getitem 5
getitem 6
[0, 1, 4, 9, 16, 25]
>>> list(Bar())
iter
len
[3, 5, 42, 69]

为什么list打电话__len__？它似乎没有使用任何明显的结果.一个for循环不会做.迭代器协议中的任何地方都没有提到这个,它只谈及__iter__和__next__. …