标签: python-internals

让我们说你有一套:

foo = {1, 2, 3, 4, 5}

在我正在阅读的书中,Pro Python,它说使用foo.pop()将弹出该选择中的任意数字.但是......当我尝试它时,它pops 1, then 2, then 3...是否随意做,或者这只是巧合？

在容器类中,当我想迭代其项目(或其项目的变换或其项目的子集)时,我可以编写生成器(如f)或返回生成器(如g):

class SomeContainer:
    def __init__(self):
        self.data = [1, 'two', 3, 'four']

    def f(self):
        for e in self.data: yield e + e

    def g(self):
        return (e + e for e in self.data)

sc = SomeContainer()
for x in sc.f(): print(x)
for x in sc.g(): print(x)

我不需要通过信息将信息传递给发生器send.

显然两种方式都表现相同(在表面).

1. 哪种方法更可取,为什么？

2. 哪种方法可以减少开销,或者具有其他我未能发现的优势？

这个问题要求解释如何在各种语言中实现异常处理，但它没有收到任何 Python 响应。

我对 Python 特别感兴趣，因为 Python 以某种方式“鼓励”通过EAFP 原理抛出和捕获异常。

我从其他 SO 答案中了解到，如果预计很少引发异常，try/catch 块比 if/else 语句便宜，并且调用深度很重要，因为填充堆栈跟踪很昂贵。这可能主要适用于所有编程语言。

但是，python 的特别之处在于 EAFP 原则的高优先级。因此，python 异常是如何在参考实现 (CPython) 中内部实现的？

在调查另一个问题时,我发现了以下内容:

>>> class A:
...   def m(self): return 42
... 
>>> a = A()

这是预期的:

>>> A.m == A.m
True
>>> a.m == a.m
True

但是,这我也没有想到:

>>> a.m is a.m
False

尤其不是这个:

>>> A.m is A.m
False

Python似乎为每个方法访问创建新对象.为什么我看到这种行为？也就是说,它为什么不能每个类重用一个对象,每个实例一个？

如果仍然引用了某些部分,python垃圾收集器是否会清除复合对象

例如

def foo():
    A = [ [1, 3, 5, 7], [2, 4, 6, 8]]
    return A[1]
B = foo()

会A[0]被垃圾收集吗？

有没有办法通过代码确认相同的？

单元测试模块时遇到了一个令人困惑的问题.该模块实际上是铸造值,我想比较这些值.

是有区别的使用比较==和is(部分,我小心的区别)

>>> 0.0 is 0.0
True   # as expected
>>> float(0.0) is 0.0
True   # as expected

正如预期到现在,但这是我的"问题":

>>> float(0) is 0.0
False
>>> float(0) is float(0)
False

为什么？至少最后一个对我来说真的很困惑.内部表示float(0)和float(0.0)应该是平等的.与之比较==正如预期的那样.

为什么范围允许非默认参数(stop)遵循默认参数(start)？

例证:

>>> r = range(1, 2, 3)
>>> print(r.start, r.stop, r.step)
1 2 3
>>> r = range(10)
>>> print(r.start, r.stop, r.step)
0 10 1

试图模仿签名是一个明显的违规行为:

def my_range(start=0, stop, end=1):
    pass

我知道它实现的事实C可能允许在Pythonland中违反的行为.

我猜这是为了使API更加用户友好,但我没有找到任何来源备份它(源代码并没有说明多少,而PEP 457只说明了多么range奇怪).有谁知道为什么这样做了？

有几种方法可以在python中构造字典,例如:

keyvals = [('foo', 1), ('bar', 'bar'), ('baz', 100)]

dict(keyvals)

和

dkwargs = {'foo': 1, 'bar': 'bar', 'baz': 100}

dict(**dkwargs)

当你对这些基准进行测

In [0]: %timeit dict(keyvals)
667 ns ± 38 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

In [1]: %timeit dict(**dkwargs)
225 ns ± 7.09 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

你看到第一种方法比第二种方法快3倍.为什么是这样？

Python 3.8（或 CPython 3.8？）添加了警告

SyntaxWarning: "is" with a literal. Did you mean "=="?

对于代码0 is 0。

我理解的警告，我知道之间的区别is和==。

但是，我也知道 CPython 会缓存小整数的对象并在其他情况下共享它。（出于好奇，我再次检查了代码（标头）。小整数被缓存在tstate->interp->small_ints. 中 0，1并且更加特殊，并且全局存储在_PyLong_Zero和 中_PyLong_One。所有新创建的ints 都是 viaPyLong_FromLong并且首先检查它是否是一个小整数整数和缓存。）

鉴于这种背景，如果你知道你有一个int对象，你可以说支票x is 0应该是安全的，对吧？此外，您可以推导出0 is 0应该始终是True，对吗？或者这是 CPython 的一个实现细节而其他解释器没有遵循这个？哪个解释器不遵循这个？

尽管这个更通用的问题（我只是好奇），请考虑这个更具体的（示例）代码：

def sum1a(*args):
    y = 0
    for x in args:
        if y is 0:
            y = x …

ctxPython AST 表示中的参数是什么？例如：

>>> print(ast.dump(ast.parse('-a')))
Module(body=[Expr(value=UnaryOp(op=USub(), operand=Name(id='a', ctx=Load())))])

换句话说，这ctx=Load()意味着什么或做什么？我从文档中看到的唯一信息是 ctx 可能是以下之一：

expr_context = Load | Store | Del | AugLoad | AugStore | Param

https://docs.python.org/3.7/library/ast.html。有人可以解释一下各种情况expr_context以及它们的作用吗？我想 lhs 和 rhs 是存储/加载：

>>> print(ast.dump(ast.parse('b=-a')))
Module(body=[Assign(targets=[Name(id='b', ctx=Store())], value=UnaryOp(op=USub(), operand=Name(id='a', ctx=Load())))])

但除此之外，还有哪些其他选择？

更新：另外，是的，还有另一个与此类似的问题，Python AST：几个语义不清楚，例如 expr_context，但接受的答案以 开头，"After some more testing and guessing:..."并且它在细节上相当简单（至少可以说）。我希望真正了解该ast模块的人可以提供更全面的答案。