Python学习之Numpy练习

1.创建ndarray数组

import numpy as np

#创建一维数组
a = [1.1,2.2,3.3,4.4]
arr = np.array(a)
print('a:{}'.format(a))
print('arr:{}'.format(arr))

a:[1.1, 2.2, 3.3, 4.4]
arr:[ 1.1  2.2  3.3  4.4]

#创建多维数组
b = [[1,2,3,4],[5,6,7,8]]
arr1 = np.array(b)
print('arr1:{}'.format(arr1))

arr1:[[1 2 3 4]
 [5 6 7 8]]

#shape函数的使用
print('arr.shape:{}'.format(arr.shape))
print('arr1.shape:{}'.format(arr1.shape))

arr.shape:(4,)
arr1.shape:(2, 4)

shape函数的使用
如果数组是一维数组，shape函数返回值为(n, )，n记录数组的长度，也是元素的个数，逗号后为空，表明返回值为元组类型；如果是二维数组，则返回两个值（n1,n2），第一个值n1表示行数，逗号后的第二个值n2表示列数，返回值同样是元组对象。

#reshape函数的使用
arr1_reshape = arr1.reshape(4,2)
print('arr1_reshape:{}'.format(arr1_reshape))
print('arr1:{}'.format(arr1))

arr1_reshape:[[1 2]
 [3 4]
 [5 6]
 [7 8]]
arr1:[[1 2 3 4]
 [5 6 7 8]]

reshape函数的使用
reshape函数可以更改数组的结构，原数组的shape仍然保持不变。

#更改数组共享内存区域
arr1[0,0] = 10   #arr1中的第一个元素
print('arr1:{}'.format(arr1))
print('arr1_reshape:{}'.format(arr1_reshape))

arr1:[[10  2  3  4]
 [ 5  6  7  8]]
arr1_reshape:[[10  2]
 [ 3  4]
 [ 5  6]
 [ 7  8]]

对于arr1的修改直接带来了arr1_reshape中相应元素的改变。

#创建特殊数组
# 创建0数组 1数组 空数组 单位数组
print('zero_array1: {}'.format(np.zeros(5)))
print('zero_array2: {}'.format(np.zeros((3,6))))
print('one_array: {}'.format(np.ones((2,3))))
print('empty_array: {}'.format(np.empty((2,2,4))))
print('arange_array: {}'.format(np.arange(10)))
print('eye_array: {}'.format(np.eye(3,3)))

zero_array1: [ 0.  0.  0.  0.  0.]
zero_array2: [[ 0.  0.  0.  0.  0.  0.]
 [ 0.  0.  0.  0.  0.  0.]
 [ 0.  0.  0.  0.  0.  0.]]
one_array: [[ 1.  1.  1.]
 [ 1.  1.  1.]]
empty_array: [[[  6.23042070e-307   7.56587584e-307   1.37961302e-306   6.23053614e-307]
  [  6.23053954e-307   9.34609790e-307   8.45593934e-307   9.34600963e-307]]

 [[  1.86921143e-306   6.23061763e-307   9.34608432e-307   9.79101082e-307]
  [  1.60218491e-306   7.56602523e-307   2.22522596e-306   8.34424766e-308]]]
arange_array: [0 1 2 3 4 5 6 7 8 9]
eye_array: [[ 1.  0.  0.]
 [ 0.  1.  0.]
 [ 0.  0.  1.]]

2.数组的数据类型

#查看数组对象的数据类型
print('arr_dtype:{}'.format(arr.dtype))
print('arr1_dtype:{}'.format(arr1.dtype))

arr_dtype:float64
arr1_dtype:int32

arr数组中的各元素以浮点数类型储存，arr1中的元素都为整型数值。

#创建数组指定数据类型
arr2 = np.array([1,2,3,4,5], dtype=np.int32)
arr3 = np.array([1,2,3,4,5], dtype=np.float64)
print('arr2: {},  arr2 dtype: {} '.format(arr2,arr2.dtype))
print('arr3: {},  arr3 dtype: {} '.format(arr3,arr3.dtype))

arr2: [1 2 3 4 5],  arr2 dtype: int32 
arr3: [ 1.  2.  3.  4.  5.],  arr3 dtype: float64 

#整数数值转化为浮点数值
arr2_float = arr2.astype(np.float32)
print('arr2_float: {},  arr2_float dtype: {} '.format(arr2_float,arr2_float.dtype))

arr2_float: [ 1.  2.  3.  4.  5.],  arr2_float dtype: float32 

#浮点数类型转化为整数值
arr3_int = arr3.astype(np.int32)
print('arr3_int: {},  arr3_int dtype: {} '.format(arr3_int,arr3_int.dtype))

arr3_int: [1 2 3 4 5],  arr3_int dtype: int32 

#字符串转化为数值型
arr4_string = np.array(['1.1','2.2','3.3','4.4'],dtype=np.string_)
arr4_float = arr4_string.astype(np.float64)
print('arr4_float: {}, arr4_float dtype: {} '.format(arr4_float, arr4_float.dtype))

arr4_float: [ 1.1  2.2  3.3  4.4], arr4_float dtype: float64 

3.数组的索引与切片

#对一维数组切片
arr5 = np.arange(15)
print('arr5: {}'.format(arr5))
print('arr5[8]: {}'.format(arr5[8]))
print('arr5[8:12]: {}'.format(arr5[8:12]))    

arr5: [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
arr5[8]: 8
arr5[8:12]: [ 8  9 10 11]

#对numpy数组进行修改
arr5[8:12] = 21
print('arr5:{}'.format(arr5))

arr5:[ 0  1  2  3  4  5  6  7 21 21 21 21 12 13 14]

#修改数组并保留原数据
arr5 = np.arange(15)
arr5_origin = arr5.copy()
arr5[8:12] = 59
print('arr5: {}'.format(arr5))
print('arr5_origin: {}'.format(arr5_origin))

arr5: [ 0  1  2  3  4  5  6  7 59 59 59 59 12 13 14]
arr5_origin: [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]

#二维数组索引
arr_2d = np.array([[1,1,1],[2,2,2],[3,3,3]])
print('arr_2d[1]:{}'.format(arr_2d[1]))

arr_2d[1]:[2 2 2]

#访问二维数组的元素
print('arr_2d[2,1]: {}'.format(arr_2d[2,1]))
print('arr_2d[2][1]: {}'.format(arr_2d[2][1]))

arr_2d[2,1]: 3
arr_2d[2][1]: 3

#多维数组索引
arr_3d = np.arange(16).reshape((2,2,4))
print('arr_3d:{}'.format(arr_3d))

arr_3d:[[[ 0  1  2  3]
  [ 4  5  6  7]]

 [[ 8  9 10 11]
  [12 13 14 15]]]

print('arr_3d[0]:{}'.format(arr_3d[0]))
print('arr_3d[1]:{}'.format(arr_3d[1]))

arr_3d[0]:[[0 1 2 3]
 [4 5 6 7]]
arr_3d[1]:[[ 8  9 10 11]
 [12 13 14 15]]

print('arr_3d[0]:{}'.format(arr_3d[0,1]))

arr_3d[0]:[4 5 6 7]

#多维数组元素修改
arr_3d_origin = arr_3d[0].copy()
arr_3d[0] = 50
print('arr_3d: {}'.format(arr_3d))
arr_3d[0] = arr_3d_origin
print('arr_3d: {}'.format(arr_3d))

arr_3d: [[[50 50 50 50]
  [50 50 50 50]]

 [[ 8  9 10 11]
  [12 13 14 15]]]
arr_3d: [[[ 0  1  2  3]
  [ 4  5  6  7]]

 [[ 8  9 10 11]
  [12 13 14 15]]]

#多维数组切片索引
arr6 = np.arange(25).reshape(5,5)
print('arr6: {}'.format(arr6))
print('arr6[1,2:4]: {}'.format(arr6[1,2:4]))
print('arr6[1:3,2:4]: {}'.format(arr6[1:3,2:4]))
print('arr6[:,2:]: {}'.format(arr6[:,2:]))
print('arr6[::2,2:]: {}'.format(arr6[::2,2:]))

arr6: [[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]
 [15 16 17 18 19]
 [20 21 22 23 24]]
arr6[1,2:4]: [7 8]
arr6[1:3,2:4]: [[ 7  8]
 [12 13]]
arr6[:,2:]: [[ 2  3  4]
 [ 7  8  9]
 [12 13 14]
 [17 18 19]
 [22 23 24]]
arr6[::2,2:]: [[ 2  3  4]
 [12 13 14]
 [22 23 24]]

#使用布尔型索引选取5×5数组arr6数据
x = np.array([0,1,2,3,1])
print(x==1)
print('arr6[x==1]: {}'.format(arr6[x==1]))
print('arr6[x==1, 3:]: {}'.format(arr6[x==1, 3:]))

[False  True False False  True]
arr6[x==1]: [[ 5  6  7  8  9]
 [20 21 22 23 24]]
arr6[x==1, 3:]: [[ 8  9]
 [23 24]]

#布尔型反向索引
print('arr6[x!=1]:{}'.format(arr6[x!=1]))
print('arr6[~(x==1)]: {}'.format(arr6[~(x==1)]))
print('arr6[np.logical_not(x==1)]: {}'.format(arr6[np.logical_not(x==1)]))

arr6[x!=1]:[[ 0  1  2  3  4]
 [10 11 12 13 14]
 [15 16 17 18 19]]
arr6[~(x==1)]: [[ 0  1  2  3  4]
 [10 11 12 13 14]
 [15 16 17 18 19]]
arr6[np.logical_not(x==1)]: [[ 0  1  2  3  4]
 [10 11 12 13 14]
 [15 16 17 18 19]]

！=表示不等于。
～表示对于条件的否定。
logical_not函数用于设置反向条件。

#布尔型与或索引
print('arr6[(x==1) | (x==0)]: {}'.format(arr6[(x==1) | (x==0)]))

arr6[(x==1) | (x==0)]: [[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [20 21 22 23 24]]

#布尔型筛选索引
arr6[arr6>10] = 10
print('arr6:{}'.format(arr6))

arr6:[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 10 10 10 10]
 [10 10 10 10 10]
 [10 10 10 10 10]]

4 数学与统计函数调用

#Numpy统计运算
arr6 = np.arange(25).reshape(5,5)
print('arr6.sum(): {}'.format(arr6.sum()))
print('arr6.mean(): {}'.format(arr6.mean()))
print('arr6.std(): {}'.format(arr6.std()))
print('arr6.var(): {}'.format(arr6.var()))
print('arr6.max(): {}'.format(arr6.max()))
print('arr6.min(): {}'.format(arr6.min()))
print('arr6.cumsum(): {}'.format(arr6.cumsum()))
print('arr6.cumprod(): {}'.format(arr6.cumprod()))
print('arr6.argmin(): {}'.format(arr6.argmin()))
print('arr6.argmax(): {}'.format(arr6.argmax()))

arr6.sum(): 300
arr6.mean(): 12.0
arr6.std(): 7.211102550927978
arr6.var(): 52.0
arr6.max(): 24
arr6.min(): 0
arr6.cumsum(): [  0   1   3   6  10  15  21  28  36  45  55  66  78  91 105 120 136 153
 171 190 210 231 253 276 300]
arr6.cumprod(): [0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0]
arr6.argmin(): 0
arr6.argmax(): 24

求和公式（sum）、求平均值（mean）、方差（var）、标准差（std）、最大值（max）、最小值（min）、累计和（cumsum）与积（cumprod）、最大最小元素的索引（argmax、argmin）等。

#矩阵的转置
arr7 = np.array([[1,2,3],[4,5,6],[7,8,9]])
print('arr7: {}'.format(arr7))
print('arr7.T: {}'.format(arr7.T))

arr7: [[1 2 3]
 [4 5 6]
 [7 8 9]]
arr7.T: [[1 4 7]
 [2 5 8]
 [3 6 9]]

#矩阵的逆
print('arr7: {}'.format(np.linalg.inv(arr7)))

arr7: [[ -4.50359963e+15   9.00719925e+15  -4.50359963e+15]
 [  9.00719925e+15  -1.80143985e+16   9.00719925e+15]
 [ -4.50359963e+15   9.00719925e+15  -4.50359963e+15]]

#矩阵的加减法
arr8 = np.array([[4,5,6],[7,8,9],[1,2,4]])
print('arr7+arr8: {}'.format(arr7+arr8))
print('arr7-arr8: {}'.format(arr7-arr8))

arr7+arr8: [[ 5  7  9]
 [11 13 15]
 [ 8 10 13]]
arr7-arr8: [[-3 -3 -3]
 [-3 -3 -3]
 [ 6  6  5]]

#矩阵的点乘
print('矩阵arr7的点乘: {}'.format(arr7*arr8))
# 矩阵的乘法
print('arr7乘arr8: {}'.format(arr7.dot(arr8.T)))
# 矩阵的迹
print('arr7的迹: {}'.format(np.trace(arr7)))

矩阵arr7的点乘: [[ 4 10 18]
 [28 40 54]
 [ 7 16 36]]
arr7乘arr8: [[ 32  50  17]
 [ 77 122  38]
 [122 194  59]]
arr7的迹: 15

#矩阵的特征值和特征向量
eigvalue,eigvector = np.linalg.eig(arr7)
print('特征值为： {}，'.format(eigvalue))
print('特征向量为： {}'.format(eigvector))

特征值为： [  1.61168440e+01  -1.11684397e+00  -1.30367773e-15]，
特征向量为： [[-0.23197069 -0.78583024  0.40824829]
 [-0.52532209 -0.08675134 -0.81649658]
 [-0.8186735   0.61232756  0.40824829]]

#矩阵的排序
arr9 = np.array([[2,4,3],[5,4,2],[9,0,3]])
arr9.sort(axis=1)
print('arr9: {}'.format(arr9))
print('按行排序后的矩阵：{}'.format(arr9))
arr10 = np.array([[2,4,3],[5,4,2],[9,0,3]])
np.sort(arr10,axis=0)
print('按列排序后得矩阵：{}'.format(arr10))

arr9: [[2 3 4]
 [2 4 5]
 [0 3 9]]
按行排序后的矩阵：[[2 3 4]
 [2 4 5]
 [0 3 9]]
按列排序后得矩阵：[[2 4 3]
 [5 4 2]
 [9 0 3]]

np.sort函数返回的是已排序的副本，对原数组已做修改。

#矩阵的元素去重
arr11 = np.array([3,2,1,4,3,1,2,4,2,3])
print('去重后的元素：{}'.format(np.unique(arr11)))

去重后的元素：[1 2 3 4]

5 文件的读入和读出

#写入文件操作
arr12 = np.arange(9).reshape(3,3)
np.savetxt('arr12.txt',arr12)

#读取数据文件
a = np.loadtxt('arr12.txt',delimiter=' ')
print('文件内容: {}'.format(a))

文件内容: [[ 0.  1.  2.]
 [ 3.  4.  5.]
 [ 6.  7.  8.]]

如果数据文件是以逗号分隔的csv文件，则在loadtxt函数中，设置参数delimiter=‘,’即可。

参考书籍：
Python 3 快速入门与实战