python - 之后改变输入运算符会影响之前方程的乘积吗？

Question

这个有点难以解释，所以让我通过一个例子向您展示我所指的内容:

from statistics import mean
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import style
import random


# xs = np.array([1,2,3,4,5,6], dtype=np.float64)
# ys = np.array([5,4,6,5,6,7], dtype=np.float64)

def create_dataset(hm, variance, step=2, correlation=False):
    val = 1
    ys = [] # empty list
    for i in range(hm):
        y = val + random.randrange(-variance, variance)
        ys.append(y)
        if correlation and correlation == 'pos':
        val += step
        elif correlation and correlation == 'neg':
        val -= step

    xs = [i for i in range(len(ys))]
    return np.array(xs, dtype=np.float64), np.array(ys, dtype=np.float64)

现在让我们创建一个数据集:

xs, ys = create_dataset(30, 12, 2, correlation='pos')
print("X series: %s\n\nY series: %s" % (xs, ys))

示例输出:

X series: [  0.   1.   2.   3.   4.   5.   6.   7.   8.   9.  10.  11.  12.  13.  14.
  15.  16.  17.  18.  19.  20.  21.  22.  23.  24.  25.  26.  27.  28.  29.]

Y series: [  1.  -6.  10.   9.  -1.  13.  24.  21.  14.  12.  17.  29.  23.  37.  32.
  36.  25.  27.  27.  47.  36.  32.  51.  37.  50.  47.  61.  45.  65.  59.]

来自 OOP 背景的我对此有点困惑:

if correlation and correlation == 'pos':
   val += step

如您所见，在 y 已分配后，val 发生了更改。但它似乎仍然影响 y 后分配。因此，这看起来就像某种方程引用保存在内存中，并且可以通过更改其任何运算符来影响结果。

为什么以及如何在 Python 中实现这一点？在 C# 或 Java 中，一旦分配了原始 float 或整数就不会改变，除非直接引用它。当您使用对象浮​​点数或整数时，我认为这是可能的，但前提是另一个变量被分配给相同的引用。据我所知，更改先前方程的输入也不会做到这一点。

无论如何，似乎有一些与Python相关的事情我不熟悉。

Answer 1

随机方差使得很难看出 val 发生了什么。那么让我们简化一下这个函数:

In [16]: def create_dataset(hm, step=2, correlation='pos'):
    ...:     val = 1
    ...:     ys = [] # empty list
    ...:     for i in range(hm):
    ...:         y = val
    ...:         ys.append(y)
    ...:         if correlation and correlation == 'pos':
    ...:             val += step
    ...:         elif correlation and correlation == 'neg':
    ...:             val -= step
    ...:     return ys

In [17]: create_dataset(5, 2, "pos")
Out[17]: [1, 3, 5, 7, 9]
In [18]: create_dataset(5, 2, "neg")
Out[18]: [1, -1, -3, -5, -7]

这正是我所期望的。 val 按 step 递增(或递减)，每次迭代一次。新值将在下一个循环中存储在ys中。

In [19]: val = 0
In [20]: val += 12
In [21]: val
Out[21]: 12
In [22]: val *= 2
In [23]: val
Out[23]: 24

对于像这样的数字 val -= 12 等同于:

In [24]: val = val - 12
In [25]: val
Out[25]: 12

新编号已分配给 val。

“+”和“+=”转换为方法调用:

val + 12  => val.__add__(12)
val +=12  => val.__iadd__(12)

这些方法是为每种对象类型定义的，因此详细信息可能会因类型而异。

对于列表和 numpy 数组等可变对象，“+”和“+=”之间的差异更为显着，有时会导致迭代出现问题。

我相信 C 和/或 C++ 有 i++ 操作。这有点像 a += 1。