Numpy使用总结

目录

Ndarray的创建

Ndarray属性

Ndarray 切片，索引与修改

索引

切片

修改

运算

连接与分割

Numpy中的nan与inf

Numpy读取本地数据

---

Ndarray的创建

1.类似正常创建数组：

a=np.array([1,2,3,])
b=np.array(range(5))
c=np.arange(3,18,3)

结果如下

[1 2 3]
[0 1 2 3 4]
[3 6 9 12 15]

2.numpy.zeros

返回特定大小，以 0 填充的新数组。

numpy.zeros(shape, dtype = float, order = 'C')

参数	含义
Shape	空数组的形状，整数或整数元组
Dtype	所需的输出数组类型，可选
Order	'C'为按行的 C 风格数组，'F'为按列的 Fortran 风格数组

3.numpy.ones

返回特定大小，以 1 填充的新数组。

numpy.zeros(shape, dtype = float, order = 'C')

参数含义与zeros相同

 

Ndarray属性

ndarray.shape

返回一个包含数组维度的元组

如

a=np.array([1,2,3])
print(a.shape)
b=np.array([[1,2,3],[4,5,6]])
print(b.shape)

输出：
(3,)
(2, 3)

可以使用reshape函数调整数组大小，同时可以使用flatten展开：

print(b)
c=b.reshape(1,6)
print(c)
c=b.reshape(6,1)
print(c)
c=b.reshape((6,))
print(c)
c=b.flatten()
print(c)

结果：
[[1 2 3]
 [4 5 6]]
[[1 2 3 4 5 6]]
[[1]
 [2]
 [3]
 [4]
 [5]
 [6]]
[1 2 3 4 5 6]
[1 2 3 4 5 6]

数组内数据类型：dtype，可以使用astype修改：

d=np.arange(3,18,3,dtype=float)
print(d)
print(d.dtype)
e=d.astype("int32")
print(e)
print(e.dtype)

结果:
[ 3.  6.  9. 12. 15.]
float64
[ 3  6  9 12 15]
int32

Ndarray 切片，索引与修改

索引

ndarray对象的内容可以通过索引或切片来访问和修改

索引类似于array，维度之间使用，分隔开来：

c=np.arange(0,24).reshape(4,6)
print(c)
d=c[3,4]
print(d)

结果：
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
22

切片

切片也类似于array，维度之间使用，分隔开来。用：表示切片范围，而如果要取不连续的切片，使用[index1,index2,index3]来取：

c=np.arange(0,24).reshape(4,6)
print(c)
d=c[1,:]
print(d)
d=c[2:,:]
print(d)
d=c[:,0]
print(d)
d=c[:,1:4]
print(d)
d=c[:,[1,3,4]]
print(d)
d=c[[0,3,1],[1,2,5]]
print(d)

结果：
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
[ 6  7  8  9 10 11]
[[12 13 14 15 16 17]
 [18 19 20 21 22 23]]
[ 0  6 12 18]
[[ 1  2  3]
 [ 7  8  9]
 [13 14 15]
 [19 20 21]]
[[ 1  3  4]
 [ 7  9 10]
 [13 15 16]
 [19 21 22]]
[ 1 20 11]

修改

而对于ndarray内容进行修改，最简单的方法即直接访问并且修改。

对于交换行或者列，直接用索引即可：

c=np.arange(0,24).reshape(4,6).astype(float)
print(c)
c[[1,2],:]=c[[2,1],:]
print(c)
c[:,[2,4]]=c[:,[4,2]]
print(c)

结果：
[[ 0.  1.  2.  3.  4.  5.]
 [ 6.  7.  8.  9. 10. 11.]
 [12. 13. 14. 15. 16. 17.]
 [18. 19. 20. 21. 22. 23.]]
[[ 0.  1.  2.  3.  4.  5.]
 [12. 13. 14. 15. 16. 17.]
 [ 6.  7.  8.  9. 10. 11.]
 [18. 19. 20. 21. 22. 23.]]
[[ 0.  1.  4.  3.  2.  5.]
 [12. 13. 16. 15. 14. 17.]
 [ 6.  7. 10.  9.  8. 11.]
 [18. 19. 22. 21. 20. 23.]]

另外numpy还提供各种修改和运算方法：

round方法可以修改小数位：

x=np.array([random.random() for i in range(5)])
print(x)
x=np.round(x,2)
print(x)

结果：
[0.31145458 0.51175965 0.27928466 0.76468556 0.47759405]
[0.31 0.51 0.28 0.76 0.48]

转置可以使用transpose， .T  以及swapaxes 实现：

c=np.arange(0,6).reshape(2,3)
print(c)
d=c.transpose()
print(d)
d=c.T
print(d)
d=c.swapaxes(1,0)
print(d)

结果：
[[0 1 2]
 [3 4 5]]
[[0 3]
 [1 4]
 [2 5]]
[[0 3]
 [1 4]
 [2 5]]
[[0 3]
 [1 4]
 [2 5]]

对于修改数组内满足条件的元素，也可以直接使用索引判断做到，另外也可以使用np.where。对于双边限制，可以使用np.clip修改:

c=np.arange(0,24).reshape(4,6)
print(c)
c[c<10]=8
print(c)
c=np.arange(0,24).reshape(4,6)
print(c)
c=np.where(c<10,0,10)
print(c)
c=np.arange(0,24).reshape(4,6)
print(c)
c=c.clip(8,12)
print(c)

结果：
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
[[ 8  8  8  8  8  8]
 [ 8  8  8  8 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
[[ 0  0  0  0  0  0]
 [ 0  0  0  0 10 10]
 [10 10 10 10 10 10]
 [10 10 10 10 10 10]]
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [12 13 14 15 16 17]
 [18 19 20 21 22 23]]
[[ 8  8  8  8  8  8]
 [ 8  8  8  9 10 11]
 [12 12 12 12 12 12]
 [12 12 12 12 12 12]]

运算

对于ndarray的运算，numpy提供的经典的算术运算方法。而ndarray的算术运算采用广播原则，术语广播是指 NumPy 在算术运算期间处理不同形状的数组的能力。 对数组的算术运算通常在相应的元素上进行。 如果两个阵列具有完全相同的形状，则这些操作被无缝执行。

如果两个数组的维数不相同，则元素到元素的操作是不可能的。 然而，在 NumPy 中仍然可以对形状不相似的数组进行操作，因为它拥有广播功能。 较小的数组会广播到较大数组的大小，以便使它们的形状可兼容。

如果满足以下规则，可以进行广播：

• ndim较小的数组会在前面追加一个长度为 1 的维度。

• 输出数组的每个维度的大小是输入数组该维度大小的最大值。

• 如果输入在每个维度中的大小与输出大小匹配，或其值正好为 1，则在计算中可它。

• 如果输入的某个维度大小为 1，则该维度中的第一个数据元素将用于该维度的所有计算。

如果上述规则产生有效结果，并且满足以下条件之一，那么数组被称为可广播的。

• 数组拥有相同形状。

• 数组拥有相同的维数，每个维度拥有相同长度，或者长度为 1。

• 数组拥有极少的维度，可以在其前面追加长度为 1 的维度，使上述条件成立。

b=np.arange(1,7).reshape(2,3)
print(b)
c=b+2
print(c)
c=b*2
print(c)
c=b/2
print(c)

结果：
[[1 2 3]
 [4 5 6]]
[[3 4 5]
 [6 7 8]]
[[ 2  4  6]
 [ 8 10 12]]
[[0.5 1.  1.5]
 [2.  2.5 3. ]]


c=np.arange(0,6).reshape(2,3)
print(b)
print(c)
d=b+c
print(d)

结果：
[[1 2 3]
 [4 5 6]]
[[0 1 2]
 [3 4 5]]
[[ 1  3  5]
 [ 7  9 11]]


c=np.arange(0,3)
print(b)
print(c)
d=b+c
print(d)

结果：
[[1 2 3]
 [4 5 6]]
[0 1 2]
[[1 3 5]
 [4 6 8]]


c=np.arange(0,2).reshape(2,1)
print(b)
print(c)
d=b+c
print(d)

结果：
[[1 2 3]
 [4 5 6]]
[[0]
 [1]]
[[1 2 3]
 [5 6 7]]

连接与分割

np.hstack 水平堆叠序列中的数组（列方向）

np.vstack 竖直堆叠序列中的数组（行方向）

np.hsplit 将一个数组水平分割为多个子数组（按列）

np.vsplit 将一个数组竖直分割为多个子数组（按行）

c=np.arange(0,24).reshape(4,6).astype(float)
d=np.arange(0,24).reshape(4,6).astype(float)
print(c)
print(d)
print(np.vstack((c,d)))
print(np.hstack((c,d)))

结果：
[[ 0.  1.  2.  3.  4.  5.]
 [ 6.  7.  8.  9. 10. 11.]
 [12. 13. 14. 15. 16. 17.]
 [18. 19. 20. 21. 22. 23.]]
[[ 0.  1.  2.  3.  4.  5.]
 [ 6.  7.  8.  9. 10. 11.]
 [12. 13. 14. 15. 16. 17.]
 [18. 19. 20. 21. 22. 23.]]
[[ 0.  1.  2.  3.  4.  5.]
 [ 6.  7.  8.  9. 10. 11.]
 [12. 13. 14. 15. 16. 17.]
 [18. 19. 20. 21. 22. 23.]
 [ 0.  1.  2.  3.  4.  5.]
 [ 6.  7.  8.  9. 10. 11.]
 [12. 13. 14. 15. 16. 17.]
 [18. 19. 20. 21. 22. 23.]]
[[ 0.  1.  2.  3.  4.  5.  0.  1.  2.  3.  4.  5.]
 [ 6.  7.  8.  9. 10. 11.  6.  7.  8.  9. 10. 11.]
 [12. 13. 14. 15. 16. 17. 12. 13. 14. 15. 16. 17.]
 [18. 19. 20. 21. 22. 23. 18. 19. 20. 21. 22. 23.]]


a = np.arange(16).reshape(4,4)
b = np.hsplit(a,2) 
print (b[0])
print (b[1])

结果：
[[ 0,  1],                                                             
 [ 4,  5],                                                              
 [ 8,  9],                                                              
 [12, 13]]
[[ 2,  3],                                           
 [ 6,  7],                                                              
 [10, 11],                                                              
 [14, 15]]

Numpy中的nan与inf

nan(NAN,Nan):not a number

表示不是一个数字

什么时候numpy中会出现nan： 当我们读取本地的文件为float的时候，如果有缺失，就会出现nan       当做了一个不合适的计算的时候(比如无穷大(inf)减去无穷大)

inf(-inf,inf):infinity,inf

表示正无穷，-inf表示负无穷

什么时候回出现inf(包括(-inf，+inf)): 比如一个数字除以0,(python中直接会报错,numpy中是一个inf或者-inf）

nan特性：两个nan不相等，可利用此特性判断nan个数：

c=np.arange(0,24).reshape(4,6).astype(float)
c[[0,3,1],[1,2,5]]=np.nan
print(c)
print(np.count_nonzero(c))
print(np.count_nonzero(c!=c))
print(np.count_nonzero(np.isnan(c)))
print(np.sum(c))
print(np.sum(c,axis=0))

结果：
[[ 0. nan  2.  3.  4.  5.]
 [ 6.  7.  8.  9. 10. nan]
 [12. 13. 14. 15. 16. 17.]
 [18. 19. nan 21. 22. 23.]]
23
3
3
nan
[36. nan nan 48. 52. nan]

如何处理nan：

在一组数据中单纯的把nan替换为0，不合适。

比如，全部替换为0后，替换之前的平均值如果大于0，替换之后的均值肯定会变小，所以更一般的方式是把缺失的数值替换为均值（中值）或者是直接删除有缺失值的一行：

c=np.arange(0,24).reshape(4,6).astype(float)
c[[0,3,1],[1,2,5]]=np.nan
print(c)
for i in range(c.shape[1]):
    temp_col=c[:,i]
    num_nan=np.count_nonzero(temp_col!=temp_col)
    if num_nan!=0:
        not_nan=temp_col[temp_col==temp_col]
        temp_col[temp_col!=temp_col]=not_nan.mean()
print(c)
        
结果：
[[ 0. nan  2.  3.  4.  5.]
 [ 6.  7.  8.  9. 10. nan]
 [12. 13. 14. 15. 16. 17.]
 [18. 19. nan 21. 22. 23.]]
[[ 0. 13.  2.  3.  4.  5.]
 [ 6.  7.  8.  9. 10. 15.]
 [12. 13. 14. 15. 16. 17.]
 [18. 19.  8. 21. 22. 23.]]

Numpy读取本地数据

一般使用np.loadtxt()。可以读取txt以及csv文件

numpy.loadtxt(fname, dtype=, comments='#', delimiter=None, converters=None, skiprows=0, usecols=None, unpack=False

 

相关代码：https://github.com/rexyang97/Data_science_library/blob/main/numpy.ipynb