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中，一旦分配了基本浮点数或整数，除非直接引用它，否则就不会更改。当您使用对象Floats或Integers时，我认为这是可行的，但前提是将另一个变量分配给相同的引用。将输入更改为先前的方程式不会对AFAIK起作用。

无论如何，似乎发生了与我不熟悉的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。

上一个方程的乘积是否会受到后来更改输入运算符的影响？

1 个答案: