“是”的类型关键字可能相当于Python中的相等运算符

Question

对于 Python 中的某些类型，is 运算符似乎等同于 == 运算符。例如：

>>> 1 is 1
True
>>> "a spoon" is "a spoon"
True
>>> (1 == 1) is (2 == 2)
True

然而，情况并非总是如此：

>>> [] == []
True
>>> [] is []
False

这对于可变类型（例如列表）是有意义的。然而，诸如元组之类的不可变类型似乎表现出相同的行为：

>>> (1, 2) == (1, 2)
True
>>> (1, 2) is (1, 2)
False

这引发了几个问题：

1. == / is 等价性与不变性相关吗？
2. 上述行为是指定的还是实施细节？
3. 最重要的是（也是最基本的），我如何知道赋值是否会导致生成对象的副本，或者生成对其的引用？

更新： 如果赋值总是通过引用，为什么下面的代码不打印 2？：

>>> a = 1
>>> b = a
>>> a = 2
>>> b
1

为什么这不等于下面的 C 代码片段：

int a = 1;
int *b = &a;
a = 2;
printf("%d\n", *b);

对于这个问题的新颖性表示歉意，但我是一个 Python 新手并认为理解这一点很重要。您是否建议阅读任何书籍来理解此类问题？

Answer 1

is 运算符测试两个对象在物理上是否相同，这意味着它们在内存中是否具有相同的地址。这也可以使用 id() 函数进行测试：

>>> a = 1
>>> b = 1
>>> a is b
True
>>> id(a) == id(b)
True

另一方面，== 运算符测试语义相等性。这也可以通过实现 __eq__() 函数由自定义类覆盖。从语义上讲，如果两个不同的列表的元素都相等，则它们相等，但从物理上讲，它们将是不同的对象。

像字符串和元组这样的不可变类型可能会被 Python 实现池化，因此两个文字字符串对象实际上在物理上是相同的。但这并不意味着您始终可以使用 is 来比较这些类型，如以下示例所示：

>>> "foobar" is "foobar"   # The interpreter knows that the string literals are
True                       # equal and creates only one shared object.
>>> a = "foobar"
>>> b = "foobar"
>>> a is b        # "foobar" comes from the pool, so it is still the same object.
True
>>> b = "foo"     # Here, we construct another string "foobar" dynamically that is
>>> b += "bar"    # physically not the same as the pooled "foobar".
>>> a == b
True
>>> a is b
False

Python 中的赋值总是将对对象的引用绑定到变量名称，并且从不暗示副本。

更新

与 C 类似，认为 Python 变量始终是指针：

>>> a = 1
>>> b = a
>>> a = 2
>>> b
1

大致相当于：

const int ONE = 1;
const int TWO = 2;

int *a = &ONE;
int *b = a;  /* b points to 1 */
a = &TWO;    /* a points to 2, b still points to 1 */

Answer 2

==/等价性与不变性相关吗？

否。

请参阅Python '== ' 与 'is' 比较字符串，'is' 有时会失败，为什么？ 为什么它适用于字符串，以及 Python“is”运算符在整数上的表现出乎意料为什么它对整数起作用（因此布尔值对于相同的原因）。

上述行为是指定的还是实现细节？

实施细节。

我如何知道赋值是否会导致生成对象的副本或对其进行引用？

分配始终是通过引用进行的。仅当您显式使用 copy.copy （或类似的东西）时才会完成复制。

编辑：“通过引用”我并不是指 C++ 中的引用。 Python 的赋值将重新绑定变量。它更像是

// int* a, *b;
a = new int(1);
b = a;
a = new int(2);
printf("%d\n", *b);

Answer 3

如果您有 C 或 C++ 背景，那么可能更容易理解 Python 中的所有变量实际上都是指针。因此，该语句

 a = 1

确实大致类似于

 Object *a = new Integer(1);

is 运算符检查指针是否相等，而 == 运算符则涉及依赖于对象类型的计算。

这个方案有点复杂，如果对象是不可变的（例如整数），那么出于效率原因，上面的代码确实有点像

 int *a = getFromCacheOrCreateNewInteger(1);

有时（但这是一个实现细节）不可变对象可能是相同的对象 < code>is 即使它们是从逻辑角度独立创建的（例如，1+1 可能是 2-1，但不能保证）：

>>> 1+2 is 2+1
True
>>> 99999+1 is 1+99999
False
>>> 

添加更多令人困惑的是，即使Python中的所有变量确实都是指针，令人惊讶的是Python中也没有指针概念，换句话说，没有办法传递一个函数来存储你的变量中的某些内容。

为此，您需要传递名称（如果变量是全局变量）或传递要调用的 setter 函数（如果变量是局部变量）。这其实并不是一个大烦恼，因为在大多数情况下你只需要多个返回值，而 Python 已经很好地处理了这个问题：

def foo(x):
    return x+1, x-1

a, b = foo(12)

另一个额外的烦恼是，如果你真的需要为没有名称的局部变量（例如元素）传递 setter列表）它不能是匿名 lambda，因为赋值是一个语句，而 lambda 只允许单个表达式 >。但是，您可以为此定义本地函数...

def foo(x, setter):
    setter(x + 1)

def bar():
    mylocal = [1,2,3]

    def setFirst(value):
        mylocal[0] = value

    foo(32, setFirst)

（好吧。我撒谎了...确实可以使用 lambda 值：mylocal.__setitem__(0, value) 但这或多或少是不需要的事件；lambda 在 Python 中是如此令人讨厌，以至于一旦他们发现这是可能的，就会在该语言中添加另一个限制来禁止它;-))。

如果您想更改命名的本地变量，这在 Python 2.x 中是不可能的（但在 Python 3.x 和 nonlocal 中是可能的）。

关于何时执行复制以及何时仅复制指针的问题，答案非常简单。 Python 永远不会自动创建副本...如果你想创建副本，你必须自己显式地执行。这就是为什么常见的代码如下：

class Polygon:
    def __init__(pointlist):
        self.pointlist = pointlist[:]

[:] 表示法在这里意味着类实例想要存储传递的列表的副本，这样如果您使用点列表创建一个Polygon实例，然后修改该列表，然后几何图形不会改变。