Python 如何将引用的numpy数组更改为其自身的一部分？

考虑应用于两个numpy阵列的以下操作和切片：

In [1]: import numpy as np                                                                               

In [2]: a = np.array([1,2,3,4])                                                                          

In [3]: b = np.array([5,6,7,8])                                                                          

In [4]: a[2:] = 0                                                                                       

In [5]: a = a[::2]                                                                                       

In [6]: b[2:] = 0                                                                                       

In [7]: b = b[::2]                                                                                       

In [8]: a                                                                                                
Out[8]: array([1, 0])

In [9]: b                                                                                                
Out[9]: array([5, 0])

例如，我不想重复切片代码，而不是上面的第[4]-[7]行，我希望使用

In [4]: for data in [a,b] : 
   ...:     data[2:] = 0
   ...:     data = data[::2] 

我知道它不起作用，因为

data=data[：：2]

的作用是使

data

指向一个新对象，而不是更改原始对象。因此，

a

和

b

的值不分片：

In [5]: a                                                                                                
Out[5]: array([1, 2, 0, 0])

In [6]: b                                                                                                
Out[6]: array([5, 6, 0, 0])

我的问题是:

如何切片变量引用的numpy数组

---

在我的实际应用程序中，我需要在每个数组中执行几个操作，并希望它们都位于

for

的

内的同一块中。您可以使用
映射
映射所有变量上的切片

将numpy导入为np
a=np.数组（[1,2,3,4]）
b=np.数组（[5,6,7,8]）
def func（x）：
x[2:]=0
x=x[：：2]
返回x
[a，b]=列表（映射（func[a，b]））
印刷品（a、b）

输出：

[1 0] [5 0]

您可以使用
map
映射所有变量上的切片

将numpy导入为np
a=np.数组（[1,2,3,4]）
b=np.数组（[5,6,7,8]）
def func（x）：
x[2:]=0
x=x[：：2]
返回x
[a，b]=列表（映射（func[a，b]））
印刷品（a、b）

输出：

[1 0] [5 0]

听起来你想要一本字典：

import numpy as np

arrs = {'a': np.array([1,2,3,4]), 'b': np.array([5,6,7,8])}
arrs = {k: v[::2] for k, v in arrs.items()}
print(arrs)

输出：

{'a': array([1, 3]), 'b': array([5, 7])}

听起来你想要一本字典：

import numpy as np

arrs = {'a': np.array([1,2,3,4]), 'b': np.array([5,6,7,8])}
arrs = {k: v[::2] for k, v in arrs.items()}
print(arrs)

输出：

{'a': array([1, 3]), 'b': array([5, 7])}

您可以使用列表：

a,b = [arr[::2] for arr in [a,b]]

您可以使用列表：

a,b = [arr[::2] for arr in [a,b]]

在创建数组对象和赋值时可能会有一些混淆

让我举例说明：

定义两个数组：

In [5]: a=np.arange(1,5); b=np.arange(5,10)                                     

In [6]: alist = [a,b]                                                           

列出这两个阵列：

In [5]: a=np.arange(1,5); b=np.arange(5,10)                                     

In [6]: alist = [a,b]                                                           

以及一个返回新数组的通用函数（它是视图这一事实并不重要）：

该函数可应用于
a
引用的数组：

In [8]: foo(a)                                                                  
Out[8]: array([3, 4])

或到
alist
引用的每个数组：

In [9]: [foo(i) for i in alist]                                                 
Out[9]: [array([3, 4]), array([7, 8, 9])]

In [14]: alist                                                                  
Out[14]: [array([1, 2, 3, 4]), array([5, 6, 7, 8, 9])]

这些数组可以解压为变量（新名称或旧名称）：

原始数组仍存在于
alist
中。
a
具有新值的事实不会改变
alist
：

In [9]: [foo(i) for i in alist]                                                 
Out[9]: [array([3, 4]), array([7, 8, 9])]

In [14]: alist                                                                  
Out[14]: [array([1, 2, 3, 4]), array([5, 6, 7, 8, 9])]

通过
map
解包的作业也会执行相同的操作：

In [15]: d,e = map(foo, alist)                                                  
In [16]: d,e                                                                    
Out[16]: (array([3, 4]), array([7, 8, 9]))

制作切片数组的字典也很有用：

In [17]: {key: foo(value) for key, value in zip(['e','d'],alist)}               
Out[17]: {'e': array([3, 4]), 'd': array([7, 8, 9])}

在创建数组对象和赋值时可能会有一些混淆

让我举例说明：

定义两个数组：

In [5]: a=np.arange(1,5); b=np.arange(5,10)                                     

In [6]: alist = [a,b]                                                           

列出这两个阵列：

In [5]: a=np.arange(1,5); b=np.arange(5,10)                                     

In [6]: alist = [a,b]                                                           

以及一个返回新数组的通用函数（它是视图这一事实并不重要）：

该函数可应用于
a
引用的数组：

In [8]: foo(a)                                                                  
Out[8]: array([3, 4])

或到
alist
引用的每个数组：

In [9]: [foo(i) for i in alist]                                                 
Out[9]: [array([3, 4]), array([7, 8, 9])]

In [14]: alist                                                                  
Out[14]: [array([1, 2, 3, 4]), array([5, 6, 7, 8, 9])]

这些数组可以解压为变量（新名称或旧名称）：

原始数组仍存在于
alist
中。
a
具有新值的事实不会改变
alist
：

In [9]: [foo(i) for i in alist]                                                 
Out[9]: [array([3, 4]), array([7, 8, 9])]

In [14]: alist                                                                  
Out[14]: [array([1, 2, 3, 4]), array([5, 6, 7, 8, 9])]

通过
map
解包的作业也会执行相同的操作：

In [15]: d,e = map(foo, alist)                                                  
In [16]: d,e                                                                    
Out[16]: (array([3, 4]), array([7, 8, 9]))

制作切片数组的字典也很有用：

In [17]: {key: foo(value) for key, value in zip(['e','d'],alist)}               
Out[17]: {'e': array([3, 4]), 'd': array([7, 8, 9])}

谢谢，但是没有。我应该提到我在阵列中执行其他操作。我将更正问题以使其更清楚。然后用包含所有要应用的操作的函数替换
lambda
函数。我可能错了，但我认为lambda函数可以描述数组中所有可能的操作。例如，它如何对我的问题中描述的操作进行编码？我已经删除了
lambda
，并使用了一个通用函数。如果需要，您可以在其中添加更多操作。我曾想到过类似的解决方案
[a，b]=[a，b]]]
，但我不喜欢在两个位置重复相同的数组列表。谢谢，但不。我应该提到我在数组中执行其他操作。我将更正问题以使其更清楚。然后用包含所有要应用的操作的函数替换
lambda
函数。我可能错了，但我认为lambda函数可以描述数组中所有可能的操作。例如，它如何对我的问题中描述的操作进行编码？我已经删除了
lambda
，并使用了一个通用函数。如果需要，您可以在其中添加更多操作。我曾想过类似的解决方案
[a，b]=[a，b]]]
中的[func（x）for x，但我不喜欢在两个位置重复相同的数组列表。我也更新了我的答案。看看有没有用。a和b的尺寸一样吗？只有两个吗？@yatu，它们不一定是同一个大小，可能有几个。我也更新了我的答案。看看有没有用。a和b的尺寸一样吗？只是其中的两个吗？@yatu，它们的大小不一定相同，可能有好几个。