Python 当Numpy/Scipy指针复制到局部变量时，它们会发生什么情况？

我知道numpy数组是指针数组。我知道在python中定义指针是可能的。但我想知道，如果我让一个变量等于numpy向量中的一个元素，它仍然是指针还是去引用？有没有办法让我找到或测试这个

    v = self.viewCoefs[sz][sv][sa]

    gw = v[0]
    G0 = v[1]
    G1 = v[2]
    G2 = v[3]
    alpha0 = v[4]
    alpha1 = v[5]
    alpha2 = v[6]
    beta0 = v[7]
    beta1 = v[8]
    beta2 = v[9]
    beta3 = v[10]
    gamma0 = v[11]
    gamma1 = v[12]
    gamma2 = v[12]
    gamma3 = v[12]
    gamma4 = v[13]
    delta0 = v[14]
    delta1 = v[15]
    delta2 = v[16]
    delta3 = v[17]
    delta4 = v[18]
    delta5 = v[19]
    zeta_prime_0 = v[20]
    zeta_prime_1 = v[21]
    zeta_prime_2 = v[22]
    Gamma_prime_0 = v[23]
    Gamma_prime_1 = v[24]
    Gamma_prime_2 = v[25]
    Gamma_prime_3 = v[26]

范例

    import scipy
    vec = scipy.randn(10)
    vecptr = vec # vecptr is a pointer to vec
    vecval = scipy.copy(vec) # vecval is not a pointer.

    var = vec[3] # is var pointer or is it copied by value ???

    print(type(var)) # returns numpy.float64.  does this mean its a 1x1 numpy vec and therefore  a pointer ?

    v = self.viewCoefs[sz][sv][sa]

    gw = v[0]
    G0 = v[1]
    G1 = v[2]
    G2 = v[3]
    alpha0 = v[4]
    alpha1 = v[5]
    alpha2 = v[6]
    beta0 = v[7]
    beta1 = v[8]
    beta2 = v[9]
    beta3 = v[10]
    gamma0 = v[11]
    gamma1 = v[12]
    gamma2 = v[12]
    gamma3 = v[12]
    gamma4 = v[13]
    delta0 = v[14]
    delta1 = v[15]
    delta2 = v[16]
    delta3 = v[17]
    delta4 = v[18]
    delta5 = v[19]
    zeta_prime_0 = v[20]
    zeta_prime_1 = v[21]
    zeta_prime_2 = v[22]
    Gamma_prime_0 = v[23]
    Gamma_prime_1 = v[24]
    Gamma_prime_2 = v[25]
    Gamma_prime_3 = v[26]

我问的原因是，我真正想知道的是；下面的代码会增加我的记忆吗？我试图为返回的向量创建更有意义的变量名

    v = self.viewCoefs[sz][sv][sa]

    gw = v[0]
    G0 = v[1]
    G1 = v[2]
    G2 = v[3]
    alpha0 = v[4]
    alpha1 = v[5]
    alpha2 = v[6]
    beta0 = v[7]
    beta1 = v[8]
    beta2 = v[9]
    beta3 = v[10]
    gamma0 = v[11]
    gamma1 = v[12]
    gamma2 = v[12]
    gamma3 = v[12]
    gamma4 = v[13]
    delta0 = v[14]
    delta1 = v[15]
    delta2 = v[16]
    delta3 = v[17]
    delta4 = v[18]
    delta5 = v[19]
    zeta_prime_0 = v[20]
    zeta_prime_1 = v[21]
    zeta_prime_2 = v[22]
    Gamma_prime_0 = v[23]
    Gamma_prime_1 = v[24]
    Gamma_prime_2 = v[25]
    Gamma_prime_3 = v[26]

因为我有很多东西要学

    v = self.viewCoefs[sz][sv][sa]

    gw = v[0]
    G0 = v[1]
    G1 = v[2]
    G2 = v[3]
    alpha0 = v[4]
    alpha1 = v[5]
    alpha2 = v[6]
    beta0 = v[7]
    beta1 = v[8]
    beta2 = v[9]
    beta3 = v[10]
    gamma0 = v[11]
    gamma1 = v[12]
    gamma2 = v[12]
    gamma3 = v[12]
    gamma4 = v[13]
    delta0 = v[14]
    delta1 = v[15]
    delta2 = v[16]
    delta3 = v[17]
    delta4 = v[18]
    delta5 = v[19]
    zeta_prime_0 = v[20]
    zeta_prime_1 = v[21]
    zeta_prime_2 = v[22]
    Gamma_prime_0 = v[23]
    Gamma_prime_1 = v[24]
    Gamma_prime_2 = v[25]
    Gamma_prime_3 = v[26]

    p0 = alpha0 + alpha1*scipy.log(bfrac) + alpha2*scipy.log(bfrac)**2
    p1 = beta0 + beta1*scipy.log(bfrac) + beta2*scipy.log(bfrac)**2 + beta3*scipy.log(bfrac)**3
    p2 = gamma0 + gamma1*scipy.log(bfrac) + gamma2*scipy.log(bfrac)**2 + gamma3*scipy.log(bfrac)**3 + gamma4*scipy.log(bfrac)**4
    p3 = delta0 + delta1*scipy.log(bfrac) + delta2*scipy.log(bfrac)**2 + delta3*scipy.log(bfrac)**3 + delta4*scipy.log(bfrac)**4 + delta5*scipy.log(bfrac)**5

    subSurfRrs = g*(p0*u + p1*u**2 + p2*u**3 + p3*u**4)
    ## and lots more

因此，我希望有意义的变量名不会使我的记忆足迹加倍

    v = self.viewCoefs[sz][sv][sa]

    gw = v[0]
    G0 = v[1]
    G1 = v[2]
    G2 = v[3]
    alpha0 = v[4]
    alpha1 = v[5]
    alpha2 = v[6]
    beta0 = v[7]
    beta1 = v[8]
    beta2 = v[9]
    beta3 = v[10]
    gamma0 = v[11]
    gamma1 = v[12]
    gamma2 = v[12]
    gamma3 = v[12]
    gamma4 = v[13]
    delta0 = v[14]
    delta1 = v[15]
    delta2 = v[16]
    delta3 = v[17]
    delta4 = v[18]
    delta5 = v[19]
    zeta_prime_0 = v[20]
    zeta_prime_1 = v[21]
    zeta_prime_2 = v[22]
    Gamma_prime_0 = v[23]
    Gamma_prime_1 = v[24]
    Gamma_prime_2 = v[25]
    Gamma_prime_3 = v[26]

# 好吧，如果我没弄错的话，不让我的记忆加倍的解决方案是：

    v = self.viewCoefs[sz][sv][sa]

    gw = v[0]
    G0 = v[1]
    G1 = v[2]
    G2 = v[3]
    alpha0 = v[4]
    alpha1 = v[5]
    alpha2 = v[6]
    beta0 = v[7]
    beta1 = v[8]
    beta2 = v[9]
    beta3 = v[10]
    gamma0 = v[11]
    gamma1 = v[12]
    gamma2 = v[12]
    gamma3 = v[12]
    gamma4 = v[13]
    delta0 = v[14]
    delta1 = v[15]
    delta2 = v[16]
    delta3 = v[17]
    delta4 = v[18]
    delta5 = v[19]
    zeta_prime_0 = v[20]
    zeta_prime_1 = v[21]
    zeta_prime_2 = v[22]
    Gamma_prime_0 = v[23]
    Gamma_prime_1 = v[24]
    Gamma_prime_2 = v[25]
    Gamma_prime_3 = v[26]

    v = self.veiwCoefs[sz][sv][sa]

    gw = v[0:1]
    G0 = v[1:2]
    G1 = v[2:1]
    alpha0 = v[3:4]
    alpha1 = v[4:5]
    alpha2 = v[5:6]
    beta0 = v[6:7]
    beta1 = v[7:8]
    beta2 = v[8:9]
    beta3 = v[9:10]
    ## etc 

    p0 = alpha0[0] + alpha1*scipy.log(bfrac) + alpha2[0]*scipy.log(bfrac)**2
    p1 = beta0[0] + beta1[0]*scipy.log(bfrac) + beta2[0]*scipy.log(bfrac)**2 + beta3[0]*scipy.log(bfrac)**3

    ## etc

---

您几乎拥有了它，但以下是如何创建单个图元的视图：

    v = self.viewCoefs[sz][sv][sa]

    gw = v[0]
    G0 = v[1]
    G1 = v[2]
    G2 = v[3]
    alpha0 = v[4]
    alpha1 = v[5]
    alpha2 = v[6]
    beta0 = v[7]
    beta1 = v[8]
    beta2 = v[9]
    beta3 = v[10]
    gamma0 = v[11]
    gamma1 = v[12]
    gamma2 = v[12]
    gamma3 = v[12]
    gamma4 = v[13]
    delta0 = v[14]
    delta1 = v[15]
    delta2 = v[16]
    delta3 = v[17]
    delta4 = v[18]
    delta5 = v[19]
    zeta_prime_0 = v[20]
    zeta_prime_1 = v[21]
    zeta_prime_2 = v[22]
    Gamma_prime_0 = v[23]
    Gamma_prime_1 = v[24]
    Gamma_prime_2 = v[25]
    Gamma_prime_3 = v[26]

In [1]: import numpy as np

In [23]: v = np.arange(10)

In [24]: a = v[3:4]

In [25]: a[0] = 100

In [26]: v
Out[26]: array([  0,   1,   2, 100,   4,   5,   6,   7,   8,   9])

---

这里的

a

是

v

的第四个元素的视图，因此当您更改

a

时，您更改

v

视图中的相应位置非常有用，并且很好地使用它们可以帮助节省大量内存，但在您的情况下，我认为视图并不合适。虽然视图确实重用了底层数据，但我不会将其称为指针。每个视图都是唯一的ndarray对象，这意味着它有自己的属性，例如形状：

    v = self.viewCoefs[sz][sv][sa]

    gw = v[0]
    G0 = v[1]
    G1 = v[2]
    G2 = v[3]
    alpha0 = v[4]
    alpha1 = v[5]
    alpha2 = v[6]
    beta0 = v[7]
    beta1 = v[8]
    beta2 = v[9]
    beta3 = v[10]
    gamma0 = v[11]
    gamma1 = v[12]
    gamma2 = v[12]
    gamma3 = v[12]
    gamma4 = v[13]
    delta0 = v[14]
    delta1 = v[15]
    delta2 = v[16]
    delta3 = v[17]
    delta4 = v[18]
    delta5 = v[19]
    zeta_prime_0 = v[20]
    zeta_prime_1 = v[21]
    zeta_prime_2 = v[22]
    Gamma_prime_0 = v[23]
    Gamma_prime_1 = v[24]
    Gamma_prime_2 = v[25]
    Gamma_prime_3 = v[26]

In [4]: a = np.arange(7)

In [5]: b = a[1:5]

In [6]: b.shape = (2,2)

In [7]: b
Out[7]: 
array([[1, 2],
       [3, 4]])
In [8]: a.shape
Out[8]: (7,)

因此，当您执行

b=a[0:1]

时，您正在创建一个全新的ndarray对象来保存一个int/float/。。。或者别的什么。如果希望数组中的每个元素都有有有意义的名称，那么您的效率可能不会比：

    v = self.viewCoefs[sz][sv][sa]

    gw = v[0]
    G0 = v[1]
    G1 = v[2]
    G2 = v[3]
    alpha0 = v[4]
    alpha1 = v[5]
    alpha2 = v[6]
    beta0 = v[7]
    beta1 = v[8]
    beta2 = v[9]
    beta3 = v[10]
    gamma0 = v[11]
    gamma1 = v[12]
    gamma2 = v[12]
    gamma3 = v[12]
    gamma4 = v[13]
    delta0 = v[14]
    delta1 = v[15]
    delta2 = v[16]
    delta3 = v[17]
    delta4 = v[18]
    delta5 = v[19]
    zeta_prime_0 = v[20]
    zeta_prime_1 = v[21]
    zeta_prime_2 = v[22]
    Gamma_prime_0 = v[23]
    Gamma_prime_1 = v[24]
    Gamma_prime_2 = v[25]
    Gamma_prime_3 = v[26]

v = self.viewCoefs[sz][sv][sa]

gw = v[0]
G0 = v[1]
G1 = v[2]
G2 = v[3]
alpha0 = v[4]
## etc

也就是说，您应该尝试看看是否有更好的方法来矢量化您的代码，这意味着尝试将代码编写为数组上的操作，而不是数组元素上的操作。例如，您可以编写：

    v = self.viewCoefs[sz][sv][sa]

    gw = v[0]
    G0 = v[1]
    G1 = v[2]
    G2 = v[3]
    alpha0 = v[4]
    alpha1 = v[5]
    alpha2 = v[6]
    beta0 = v[7]
    beta1 = v[8]
    beta2 = v[9]
    beta3 = v[10]
    gamma0 = v[11]
    gamma1 = v[12]
    gamma2 = v[12]
    gamma3 = v[12]
    gamma4 = v[13]
    delta0 = v[14]
    delta1 = v[15]
    delta2 = v[16]
    delta3 = v[17]
    delta4 = v[18]
    delta5 = v[19]
    zeta_prime_0 = v[20]
    zeta_prime_1 = v[21]
    zeta_prime_2 = v[22]
    Gamma_prime_0 = v[23]
    Gamma_prime_1 = v[24]
    Gamma_prime_2 = v[25]
    Gamma_prime_3 = v[26]

coefs = np.zeros((5,5))
lt = np.tril_indices(5)
coefs[lt] = self.viewCoefs[sz][sv][sa]

p = (coefs * scipy.log(bfrac)**[1, 2, 3, 4, 5]).sum(-1)
subSurfRrs = g*(p*u**[1, 2, 3, 4]).sum()

---

使用numpy时，矢量化代码可以更快。在这种情况下，我们还利用了numpy的广播，我认为这是非常令人困惑的，直到我对它有了更好的了解，并意识到它是多么有用。

那么，如果我这样做，公平地说：gw=v[0]G0=v[1]G1=v[2]G2=v[3]alpha0=v[4]alpha1=v[5]alpha2=v[6]等等。我没有加倍我的内存使用？我只是在为我的向量创建更有用的句柄？@cor散-

gw=v[0]

将创建元素的副本，而

gw=v[0:1]

将创建一个视图，该视图不是副本，但更像是内存中该位置的替代标签。好的，我想我现在知道了。我需要使用gw[0]，G0[0]。。等等，用方括号括起来。谢谢在这种情况下，您真的不需要担心内存使用量“翻倍”。只有27辆车。如果216字节的内存使用对您很重要，请不要使用python。。。话虽如此，在某些情况下，numpy数组的单个元素视图是有用的，但这不是其中之一。感谢@Bago，矢量化代码是一种方法。在我确信自己所有的系数都是正确的之后。这是我习惯用Matlab做事情的方式。暂时将术语分开对于调试更有用。

    v = self.viewCoefs[sz][sv][sa]

    gw = v[0]
    G0 = v[1]
    G1 = v[2]
    G2 = v[3]
    alpha0 = v[4]
    alpha1 = v[5]
    alpha2 = v[6]
    beta0 = v[7]
    beta1 = v[8]
    beta2 = v[9]
    beta3 = v[10]
    gamma0 = v[11]
    gamma1 = v[12]
    gamma2 = v[12]
    gamma3 = v[12]
    gamma4 = v[13]
    delta0 = v[14]
    delta1 = v[15]
    delta2 = v[16]
    delta3 = v[17]
    delta4 = v[18]
    delta5 = v[19]
    zeta_prime_0 = v[20]
    zeta_prime_1 = v[21]
    zeta_prime_2 = v[22]
    Gamma_prime_0 = v[23]
    Gamma_prime_1 = v[24]
    Gamma_prime_2 = v[25]
    Gamma_prime_3 = v[26]