Question

例如：

a = some_process_that_generates_integer_result()
b = a

有人告诉我， b 和 a 将指向同一块整数对象，因此 b 会修改该对象的引用计数。代码在 Python-ast.c ：

中的函数PyObject* ast2obj_expr(void* _o)中执行

static PyObject* ast2obj_object(void *o)
{
    if (!o)
        o = Py_None;
    Py_INCREF((PyObject*)o);
    return (PyObject*)o;
}

......

case Num_kind:
    result = PyType_GenericNew(Num_type, NULL, NULL);
    if (!result) goto failed;
    value = ast2obj_object(o->v.Num.n);
    if (!value) goto failed;
    if (PyObject_SetAttrString(result, "n", value) == -1)
            goto failed;
    Py_DECREF(value);
    break;

但是，我认为在没有所有权变更的情况下修改引用计数实际上是徒劳的。我期望的是每个包含原始值（浮点数，整数等）的变量总是有自己的值，而不是引用同一个对象。

在执行我的简单测试代码时，我发现上面的Num_kind分支中的断点永远不会到达：

def some_function(x, y):
    return (x+y)*（x-y)

a = some_function(666666,66666)
print a

b = a
print a
print b

b = a + 999999
print a
print b

b = a
print a
print b

我正在使用Debian提供的python2.7-dbg程序。我确信程序和源代码匹配，因为许多其他断点正常工作。

那么，CPython实际上对原始类型对象做了什么？

Answer 1

首先，Python中没有“原始对象”。一切都是同类的对象，它们都在语言层面以相同的方式处理。因此，无论分配的值如何，以下分配的工作方式都相同：

a = some_process_that_generates_integer_result()
b = a

在Python中，分配始终引用副本。因此无论函数返回什么，它的引用都被复制到变量a中。然后在第二行中，引用再次复制到变量b中。因此，两个变量都将引用完全相同的对象。

您可以使用id()函数轻松验证这一点，该函数会告诉您对象的身份：

print id(a)
print id(b)

这将两次打印相同的识别号码。但是请注意，这样做会更多次地复制引用：它不是传递到函数的变量，而是引用的副本。

这与您经常区分“按值调用”和“按引用调用”的其他语言不同。前者意味着您创建值的副本并将其传递给函数，这意味着为该值分配了新内存;后者意味着传递实际引用，并且对该引用的更改也会影响原始变量。

Python所做的通常被称为“通过赋值调用”：传递参数的每个函数调用本质上是对新变量的赋值（然后可用于函数）。并且作业会复制参考。

当一切都是对象时，这实际上是一个非常简单的策略。正如我上面所说，整数所发生的事情与其他对象的情况没有什么不同。关于整数的唯一“特殊”事情是它们是不可变的，所以你不能改变它们的值。这意味着整数对象始终引用完全相同的值。这样可以轻松地与多个值共享对象（在内存中）。产生新结果的每个操作都会为您提供不同的对象，因此当您执行一系列算术运算时，您实际上正在更改变量指向的对象。

其他不可变对象也会发生同样的情况，例如字符串。产生更改字符串的每个操作都会为您提供不同的字符串对象。

具有可变对象的分配也是相同的。只是改变这些对象的价值是可能的，因此它们看起来不同。考虑这个例子：

a = [1] # creates a new list object
b = a # copies the reference to that same list object
c = [2] # creates a new list object
b = a + c # concats the two lists and creates a new list object
d = b
# at this point, we have *three* list objects
d.append(3) # mutates the list object
print(d)
print(b) # same result since b and d reference the same list object

现在回到你的问题和你引用的C代码，你实际上正在查看CPython的错误部分以获得解释。 AST是解析器在解析文件时创建的抽象语法树。它反映了程序的语法结构，但却没有说明实际的运行时行为。

您为Num_kind展示的代码实际上负责创建Num AST对象。使用ast module时，您可以了解这一点：

>>> import ast
>>> doc = ast.parse('foo = 5')

# the document contains an assignment
>>> doc.body[0]
<_ast.Assign object at 0x0000000002322278>

# the target of that assignment has the id `foo`
>>> doc.body[0].targets[0].id
'foo'

# and the value of that assignment is the `Num` object that was
# created in that C code, with that `n` property containing the value
>>> doc.body[0].value
<_ast.Num object at 0x00000000023224E0>
>>> doc.body[0].value.n
5

如果您想了解Python代码的实际评估，首先应该查看字节代码。字节代码是虚拟机在运行时执行的内容。您可以使用dis module查看Python代码的字节代码：

>>> def test():
        foo = 5

>>> import dis
>>> dis.dis(test)
  2           0 LOAD_CONST               1 (5)
              3 STORE_FAST               0 (foo)
              6 LOAD_CONST               0 (None)
              9 RETURN_VALUE

如您所见，此处有两个主要的字节代码说明：LOAD_CONST和STORE_FAST。 LOAD_CONST只会将一个常量值加载到评估堆栈中。在这个例子中，我们只是加载一个常数，但我们也可以从函数调用中加载值（尝试使用dis模块来弄清楚它是如何工作的。）

作业本身是使用STORE_FAST制作的。字节码解释器为该指令执行the following：

TARGET(STORE_FAST)
{
    v = POP();
    SETLOCAL(oparg, v);
    FAST_DISPATCH();
}

所以它基本上从堆栈中获取值（对整数对象的引用），然后调用SETLOCAL，它基本上只是将值赋给局部变量。

但请注意，这不会增加该值的引用计数。这就是LOAD_CONST或从任何地方获取值的任何其他字节代码指令所发生的情况：

TARGET(LOAD_CONST)
{
    x = GETITEM(consts, oparg);
    Py_INCREF(x);
    PUSH(x);
    FAST_DISPATCH();
}

所以tl; dr：Python中的赋值始终是引用副本。每当使用值时，也会复制引用（但在许多其他情况下，复制引用仅存在一小段时间）。 AST负责创建解析程序的对象表示（仅语法），而字节代码解释器运行先前编译的字节代码，以便在运行时执行实际操作并处理实际对象。

当对原始类型变量执行“=”时，CPython实际上做了什么？

1 个答案: