# 导入模块 import numpy as np # 数组声明 arr = np.arange(0,11) # 打印阵列 print(arr)
输出结果
[ 0 1 2 3 4 5 6 7 8 9 10]
现在，要获取Numpy数组中元素的索引，例如，它与从列表中检索索引的方式非常相似（注意：在python中，索引从0开始）。
# 导入模块
import numpy as np
# 数组声明
arr = np.arange(0,11)
# 打印阵列
print("arr:", arr)
# 基于索引的打印元素
# 从给定索引返回元素
print("arr[8]:", arr[8])
# 返回开始，结束之间的元素
print("arr[1:5]:", arr[1:5])
# 返回开始，结束之间的元素
print("arr[0:5]:", arr[0:5])
#返回元素直到结束
print("arr[:6]:", arr[:6])
# 从开始返回元素
print("arr[2:]:", arr[2:])输出结果
arr: [ 0 1 2 3 4 5 6 7 8 9 10] arr[8]: 8 arr[1:5]: [1 2 3 4] arr[0:5]: [0 1 2 3 4] arr[:6]: [0 1 2 3 4 5] arr[2:]: [ 2 3 4 5 6 7 8 9 10]
考虑以下示例，
# 导入模块 import numpy as np # 二维阵列 arr_2d = np.array([[10,15,20],[25,30,35],[40,45,50]]) # 打印阵列 print(arr_2d)
输出结果
[[10 15 20] [25 30 35] [40 45 50]]
在二维数组中有两种访问索引的方法-双括号和单括号表示法。但是，最优选的方法是使用单括号表示法。以下是使用双括号和单括号表示法的示例。
1）双括号符号
# 导入模块 import numpy as np # 二维阵列 arr_2d = np.array([[10,15,20],[25,30,35],[40,45,50]]) # 返回第二行第一列 print(arr_2d[1][0]) # 返回第一行第三列 print(arr_2d[0][2])
输出结果
25 20
2）单括号条件
# 导入模块 import numpy as np # 二维阵列 arr_2d = np.array([[10,15,20],[25,30,35],[40,45,50]]) # 使用切片符号返回所需的值 print(arr_2d[:2,1:]) # 返回第一行第三列 print(arr_2d[0,2])
输出结果
[[15 20] [30 35]] 20
假设我们有一个NumPy数组，
import numpy as np arr = np.arange(1,11) print(arr) # 输出：[1 2 3 4 5 6 7 8 9 10]
在上面创建的数组上应用>运算符
bool_arr = arr>4
比较运算符将应用于数组中的每个元素，并且返回的布尔Numpy Array中的元素数量将与原始Numpy Array相同。但是对于每个满足条件的元素，在数组中将为True，在返回的数组中为Other。数组的内容将是
import numpy as np arr = np.arange(1,11) bool_arr = arr>4 print(bool_arr) print(arr)
输出结果
[False False False False True True True True True True] [ 1 2 3 4 5 6 7 8 9 10]
现在，要获得条件结果，请将bool_arr传递给arr对象，然后仅返回值为true的那些元素，
print(arr[bool_arr]) # 输出：[5 6 7 8 9 10]
一步实现以上内容，
import numpy as np
arr = np.arange(1,11)
print("arr...")
print(arr)
new_arr = arr[arr>6]
print("new_arr...")
print(new_arr)输出结果
arr... [ 1 2 3 4 5 6 7 8 9 10] new_arr... [ 7 8 9 10]
广播是NumPy用于允许在具有不同形状和大小的数组之间进行算术运算的方法。广播通过实际上复制较小的阵列以及不匹配的尺寸来解决不同形状的阵列之间的算术问题。
NumPy不复制较小的数组。取而代之的是，它对内存中的现有结构进行了存储，并在计算上有效地使用了实际上可实现相同结果的结构。
广播示例
import numpy as np
arr = np.arange(1,11)
# 打印阵列 before broadcasting
print("arr before broadcasting...")
print(arr)
arr[0:5] = 123
# 打印阵列 before broadcasting
print("arr before broadcasting...")
print(arr)输出结果
arr before broadcasting... [ 1 2 3 4 5 6 7 8 9 10] arr before broadcasting... [123 123 123 123 123 6 7 8 9 10]
下例说明了广播的重要行为，
import numpy as np arr = np.arange(0,11) # 切片数组 sliced_arr = arr[0:5] print(sliced_arr) # 将指定的数字广播到99 sliced_arr[:] = 99 print(sliced_arr) # 广播也会更改父数组 print(arr)
输出结果
[0 1 2 3 4] [99 99 99 99 99] [99 99 99 99 99 5 6 7 8 9 10]
NumPy进行上述操作的原因是为了避免在处理大型数组时出现内存问题。为了保留原始值，有一个选项可以复制下面示例中说明的数组，
import numpy as np arr = np.arange(0,11) print(arr) arr_copy = arr.copy() print(arr_copy) arr_copy[:] = 1 print(arr_copy) # 父数组未修改 print(arr)
输出结果
[ 0 1 2 3 4 5 6 7 8 9 10] [ 0 1 2 3 4 5 6 7 8 9 10] [1 1 1 1 1 1 1 1 1 1 1] [ 0 1 2 3 4 5 6 7 8 9 10]
一般广播规则
在两个数组上进行操作时，NumPy逐元素比较其形状。它从尾随尺寸开始，一直向前发展。当，
它们相等，或者
其中之一是1
如果不满足这些条件，则将引发ValueError：操作数不能一起广播的异常，这表明数组的形状不兼容。所得数组的大小是沿输入数组每个维度的最大大小。