NumPy 从数值范围创建数组、切片和索引

NumPy 从数值范围创建数组

numpy.arange

numpy 包中的使用 arange 函数创建数值范围并返回 ndarray 对象，函数格式如下：

numpy.arange(start, stop, step, dtype)
根据 start 与 stop 指定的范围以及 step 设定的步长，生成一个 ndarray。

参数说明：

import numpy as np
 
x = np.arange(5)  
print (x)
# [0  1  2  3  4]

import numpy as np
 
# 设置了 dtype
x = np.arange(5, dtype =  float)  
print (x)
# [0.  1.  2.  3.  4.]


# 设置了起始值、终止值及步长：
import numpy as np
x = np.arange(10,20,2)  
print (x)
# [10  12  14  16  18]

numpy.linspace

numpy.linspace 函数用于创建一个一维数组，数组是一个等差数列构成的，格式如下：

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

参数说明：

#用到三个参数，设置起始点为 1 ，终止点为 10，数列个数为 10。
import numpy as np
a = np.linspace(1,1,10)
print(a)
# [ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]



# 将 endpoint 设为 false，不包含终止值：
import numpy as np
 
a = np.linspace(10, 20,  5, endpoint =  False)  
print(a)
[10. 12. 14. 16. 18.]

a=np.linspace(10,20,5,endpoint=True)
print(a)
#[10.  12.5 15.  17.5 20. ]

设置间距。

import numpy as np
a =np.linspace(1,10,10,retstep= True)
 
print(a)
# (array([ 1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.]), 1.0)

# 拓展例子
b =np.linspace(1,10,10).reshape([10,1])
print(b)
#[[ 1.]
# [ 2.]
# [ 3.]
# [ 4.]
# [ 5.]
# [ 6.]
# [ 7.]
# [ 8.]
# [ 9.]
# [10.]]

numpy.logspace
numpy.logspace 函数用于创建一个于等比数列。格式如下：

np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
base 参数意思是取对数的时候 log 的下标。

import numpy as np
# 默认底数是 10
a = np.logspace(1.0,  2.0, num =  10)  
print (a)
#[ 10.           12.91549665     16.68100537      21.5443469  27.82559402      
#  35.93813664   46.41588834     59.94842503      77.42636827    100.    ]



# 将对数的底数设置为 2 :
import numpy as np
a = np.logspace(0,9,10,base=2)
print (a)

#[  1.   2.   4.   8.  16.  32.  64. 128. 256. 512.]

切片和索引

ndarray对象的内容可以通过索引或切片来访问和修改，与 Python 中 list 的切片操作一样。

ndarray 数组可以基于 0 - n 的下标进行索引，切片对象可以通过内置的slice 函数，并设置 start, stop 及 step 参数进行，从原数组中切割出一个新数组。

import numpy as np
 
a = np.arange(10)
s = slice(2,7,2)   # 从索引 2 开始到索引 7 停止，间隔为2
print (a[s])
# [2  4  6]

也可以通过冒号分隔切片参数 start:stop:step 来进行切片操作：

import numpy as np
 
a = np.arange(10)  
b = a[2:7:2]   # 从索引 2 开始到索引 7 停止，间隔为 2
print(b)
# [2  4  6]

冒号 : 的解释：如果只放置一个参数，如 [2]，将返回与该索引相对应的单个元素。如果为 [2:]，表示从该索引开始以后的所有项都将被提取。如果使用了两个参数，如 [2:7]，那么则提取两个索引(不包括停止索引)之间的项。

import numpy as np
 
a = np.arange(10)  # [0 1 2 3 4 5 6 7 8 9]
b = a[5] 
print(b) # 5

import numpy as np
 
a = np.arange(10)
print(a[2:])   #[2  3  4  5  6  7  8  9]

import numpy as np
 
a = np.arange(10)  # [0 1 2 3 4 5 6 7 8 9]
print(a[2:5])  # [2  3  4]

多维数组同样适用上述索引提取方法：

import numpy as np
 
a = np.array([[1,2,3],[3,4,5],[4,5,6]])
print(a)
# 从某个索引处开始切割
print('从数组索引 a[1:] 处开始切割')
print(a[1:])
输出：
[[1 2 3]
 [3 4 5]
 [4 5 6]]
从数组索引 a[1:] 处开始切割
[[3 4 5]
 [4 5 6]]

切片还可以包括省略号 …，来使选择元组的长度与数组的维度相同。 如果在行位置使用省略号，它将返回包含行中元素的 ndarray。

import numpy as np
 
a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
print (a[...,1])   # 第2列元素
print (a[1,...])   # 第2行元素
print (a[...,1:])  # 第2列及剩下的所有元素

输出：
[2 4 5]
[3 4 5]
[[2 3]
 [4 5]
 [5 6]]

在多维数组的切片中，使用, 区分维数。

import numpy as np
  
a=np.arange(0,12)
a.shape=(3,4)
print(a)
print(a[0:2,1:3])

输出：
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[1 2]
 [5 6]]

NumPy 高级索引

NumPy 比一般的 Python 序列提供更多的索引方式。除了之前看到的用整数和切片的索引外，数组可以由整数数组索引、布尔索引及花式索引。

import numpy as np
 
b = np.array([[1,2,3],[4,5,6],[7,8,9],[10,11,12]],dtype=int)
 
c = b[0,1]  #1行 第二个单元元素
# 输出： 2
 
d = b[:,1]  #所有行 第二个单元元素
# 输出： [ 2  5  8 11]
 
e = b[1,:]  #2行 所有单元元素
# 输出： [4 5 6]
 
f = b[1,1:]  #2行 第2个单元开始以后所有元素
# 输出： [5 6]
 
g = b[1,:2]  #2行 第1个单元开始到索引为2以前的所有元素
# 输出： [4 5]

索引多维数组

 例1：产生一个5X7的数组，选择0,2,4行，0,1,2列的数

>>> y = np.arange(35).reshape(5,7)
>>> y[np.array([0,2,4]), np.array([0,1,2])]
array([ 0, 15, 30])
例2：选取第0,2,4行，第1列的值

>>> y[np.array([0,2,4]), 1]
array([ 1, 15, 29])
例3：选取第0,2,4行的值

>>> y[np.array([0,2,4])]
array([[ 0,  1,  2,  3,  4,  5,  6],
       [14, 15, 16, 17, 18, 19, 20],
       [28, 29, 30, 31, 32, 33, 34]])

整数数组索引

以下实例获取数组中(0,0)，(1,1)和(2,0)位置处的元素。

import numpy as np 
 
x = np.array([[1,  2],  [3,  4],  [5,  6]]) 

#[0,1,2]为行号索引数组，[0,1,0]为列号索引数组
y = x[[0,1,2],  [0,1,0]]  
print (y)
# [1 4 5]

以下实例获取了 4X3 数组中的四个角的元素。 行索引是 [0,0] 和 [3,3]，而列索引是 [0,2] 和 [0,2]。

import numpy as np 
 
x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
print ('我们的数组是：' )
print (x)
print ('\n')
rows = np.array([[0,0],[3,3]]) 
cols = np.array([[0,2],[0,2]]) 
y = x[rows,cols]  
print  ('这个数组的四个角元素是：')
print (y)

我们的数组是：
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]


这个数组的四个角元素是：
[[ 0  2]
 [ 9 11]]

等价于
x = np.array([[0, 1, 2], [3, 4, 5], [6, 7, 8], [9, 10, 11]])
m=np.array(x[[0,0,3,3],[0,2,0,2]]).reshape(2,2)
print(m)
[[ 0  2]
 [ 9 11]]

布尔索引

我们可以通过一个布尔数组来索引目标数组。

布尔索引通过布尔运算（如：比较运算符）来获取符合指定条件的元素的数组。

以下实例获取大于 5 的元素：

import numpy as np 
 
x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
print ('我们的数组是：')
print (x)
print ('\n')
# 现在我们会打印出大于 5 的元素  
print  ('大于 5 的元素是：')
print (x[x >  5])


我们的数组是：
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]


大于 5 的元素是：
[ 6  7  8  9 10 11]

NumPy 广播(Broadcast)

广播(Broadcast)是 numpy 对不同形状(shape)的数组进行数值计算的方式， 对数组的算术运算通常在相应的元素上进行。
如果两个数组 a 和 b 形状相同，即满足 a.shape == b.shape，那么 a*b 的结果就是 a 与 b 数组对应位相乘。这要求维数相同，且各维度的长度相同。

import numpy as np 
 
a = np.array([1,2,3,4]) 
b = np.array([10,20,30,40]) 
c = a * b 
print (c)

# [ 10  40  90 160]

当运算中的 2 个数组的形状不同时，numpy 将自动触发广播机制。如：

import numpy as np 
 
a = np.array([[ 0, 0, 0],
           [10,10,10],
           [20,20,20],
           [30,30,30]])
b = np.array([1,2,3])
print(a + b)


输出：
[[ 1  2  3]
 [11 12 13]
 [21 22 23]
 [31 32 33]]

import numpy as np 
 
a = np.array([[ 0, 0, 0],
           [10,10,10],
           [20,20,20],
           [30,30,30]])
b = np.array([1,2,3])
bb = np.tile(b, (4, 1))
print(a + bb)

输出：
[[ 1  2  3]
 [11 12 13]
 [21 22 23]
 [31 32 33]]

广播的规则:

• 让所有输入数组都向其中形状最长的数组看齐，形状中不足的部分都通过在前面加 1 补齐。

• 输出数组的形状是输入数组形状的各个维度上的最大值。

• 如果输入数组的某个维度和输出数组的对应维度的长度相同或者其长度为 1 时，这个数组能够用来计算，否则出错。

• 当输入数组的某个维度的长度为 1 时，沿着此维度运算时都用此维度上的第一组值。
  简单理解：对两个数组，分别比较他们的每一个维度（若其中一个数组没有当前维度则忽略），满足：

• 数组拥有相同形状。

• 当前维度的值相等。

• 当前维度的值有一个是 1。
  若条件不满足，抛出 “ValueError: frames are not aligned” 异常。