python学习——numpy学习

numpy库介绍

Python虽然支持的数据类型有整形、浮点型以及复数型，但是这些类型不足以满足科学计算的需求。采用numpy能够方便我们去做数据分析。

利用列表创建矩阵

包含创建一维矩阵，创建二维矩阵，创建复数矩阵，输出numpy矩阵数据的类型

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import numpy as np
# 第一种用法
a = np.array([2,3,4]) # 生成一个一维的矩阵
b = np.array([2.0,3.0,4.0])
c = np.array([[1.0,2.0],[3.0,4.0]]) # 建立二维矩阵
d = np.array([[1,2],[3,4]],dtype=complex) # 指定复数数据类型
print(a, a.dtype)
print(b, b.dtype)
print(c, c.dtype)
print(d, d.dtype)

输出结果：

[2 3 4] int32
[ 2. 3. 4.] float64
[[ 1. 2.]
 [ 3. 4.]] float64
[[ 1.+0.j 2.+0.j]
 [ 3.+0.j 4.+0.j]] complex128

创建矩阵的常用函数

array 函数使用、全为0或1的矩阵生成、按照步长或差值生成、随机矩阵、矩阵重组

print("000000000000000000")
print(np.arange(0,7,1,dtype=np.int16)) # 0为起点，间隔为1时可缺省(引起歧义下不可缺省)

print(np.ones((2,3,4),dtype=np.int16) )# 2页，3行，4列，全1，指定数据类型

print("111111111111111111")
print(np.zeros((2,3,4))) # 2页，3行，4列，全0

print("222222222222222222")
print(np.empty((2,3))) #什么都没有，生成的是一个接近于0的数
print(np.arange(0,10,2) )# 起点为0，不超过10，步长为2

print(np.linspace(-1,2,5)) # 起点为-1，终点为2，取5个点（相当于分成了4段）

print(np.random.randint(0,3,(2,3))) #大于等于0，小于3，2行3列的随机整数
print("3333333333333333333")
b = np.arange(6).reshape((2,-1)) # 2行3列  将矩阵重新重组
print(b)

结果输出

000000000000000000
[0 1 2 3 4 5 6]
[[[1 1 1 1]
  [1 1 1 1]
  [1 1 1 1]]

 [[1 1 1 1]
  [1 1 1 1]
  [1 1 1 1]]]
111111111111111111
[[[0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]]

 [[0. 0. 0. 0.]
  [0. 0. 0. 0.]
  [0. 0. 0. 0.]]]
222222222222222222
[[1.39069238e-309 1.39069238e-309 1.39069238e-309]
 [1.39069238e-309 1.39069238e-309 1.39069238e-309]]
[0 2 4 6 8]
[-1.   -0.25  0.5   1.25  2.  ]
[[1 2 0]
 [0 2 0]]
3333333333333333333
[[0 1 2]
 [3 4 5]]

矩阵基本运算

矩阵减法、平方、三角函数

import numpy as np
a = np.array([1,5,10,15])
b = np.arange(4) #结果 [0, 1, 2, 3]
c = np.array([[1,2],[3,4]])

print(a-b) # 矩阵相减 [1 4 8 12] = [1,5,10,15] - [0, 1, 2, 3]
print(a**2)
print(c**2)
print(b.reshape(2,2)) #矩阵变形 
# [0 1 2 3] =>  [[0 1]
#                [2 3]]

d = np.sin(np.pi/2) #按照弧度制计算三角函数 结果1.0

print(b<2) # 判断b中那些数是<2的，如果是对应位置为true 输出[True True False False]

输出结果

[ 1  4  8 12]
[  1  25 100 225]
[[ 1  4]
 [ 9 16]]
[[0 1]
 [2 3]]
[ True  True False False]

矩阵乘法、求和、最大、最小值

# 矩阵乘法
print("===============")
e_1 = np.array([[1,2],[3,4]])
e_2 = np.array([[1,1],[2,2]])
print(e_1)
print(e_2)
e = np.dot(e_1, e_2)
e = e_1.dot(e_2)
print(e)
# [[1 2]      *   # [[1 1]   =  # [[ 5  5]
#  [3 4]]         #  [2 2]]     #  [11 11]]

# 求和 np.sum()
print("===============")
a = np.array([[1,5],[10,15]])
print(a) # [[ 1  5] [10 15]] 两行两列的矩阵
print(np.sum(a,axis=1)) # axis=0 列数求和[11 20]   axis=1 行数求和 [6 25] 缺省：计算整体

# 求最小值 np.min()
print(np.min(a,axis=0)) # axis=0 列数最小值[1 5]   axis=1 行数求和[1 10]  缺省：计算整体

# 求最大值 np.max()
print(np.max(a,axis=1)) # axis=0 列数最小值[10 15]   axis=1 行数求和[5 15]  缺省：计算整体

输出结果

===============
[[1 2]
 [3 4]]
[[1 1]
 [2 2]]
[[ 5  5]
 [11 11]]
===============
[[ 1  5]
 [10 15]]
[ 6 25]
[1 5]
[ 5 15]

最大小值索引、求平均值、累加、累差、非零索引

# 最小值的索引
import numpy as np
A = np.arange(1,13).reshape(3,4)
# A =[[ 1  2  3  4]
#     [ 5  6  7  8]
#     [ 9 10 11 12]]

print(np.argmin(A))  # 最小值的索引
print(np.argmax(A))  # 最大值的索引
print(np.average(A,axis = 0)) # 计算整体的平均值 axis = 0/1 行/列平均值 缺省：整体平均值
# 这里也可以使用 print(np.mean(A,axis = 0))

print(np.cumsum(A)) # 累加 [1  3  6 10 15 21 28 36 45 55 66 78]
print(np.diff(A)) # 累差 [[1 1 1] [1 1 1] [1 1 1]] 每一行后一个数减去前一个数 变成3*3矩阵

print(np.nonzero(A)) # 输出索引位置 前一个array：行  后一个：列
# (array([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2]), array([0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]))

输出结果

0
11
[5. 6. 7. 8.] #列平均值 如果求行采用 print(np.average(A,axis = 1))
[ 1  3  6 10 15 21 28 36 45 55 66 78]
[[1 1 1]
 [1 1 1]
 [1 1 1]]
(array([0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2]), array([0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]))

排序转置

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import numpy as np
A = np.array([[1,4,3],[5,2,8]])
print(A)
print(np.sort(A,axis=0))  
# a: 要排序的数组
# axis: 沿着它排序数组的轴，如果没有数组会被展开，沿着最后的轴排序， axis=0 按列排序，axis=1 按行排序
# kind: 默认为'quicksort'（快速排序）
# order: 如果数组包含字段，则是要排序的字段

print(np.transpose(A))  # 矩阵转置 也可以这样写：print(A.T)

输出结果

[[1 4 3]
 [5 2 8]]
[[1 2 3]
 [5 4 8]]
[[1 5]
 [4 2]
 [3 8]]

clip

Numpy 中clip函数的使用

numpy.clip(a, a_min, a_max, out=None)[source]

其中a是一个数组，后面两个参数分别表示最小和最大值
如果比a_min小，变成a_min，如果比a_max大，变成a_max

import numpy as np
x=np.array([1,2,3,5,6,7,8,9])
print(np.clip(x,3,8)) #[3 3 3 5 6 7 8 8]

输出结果

[3 3 3 5 6 7 8 8]

将矩阵a中小于a_min，变成a_min，大于a_max，变成a_max

索引

在numpy 中从第0行第0列开始索引

# 索引 注释里面是按照数学里面的矩阵行列来说明的
A = np.array([[1,4,3],[5,2,8]])

print(A[1][1]) # 输出第2行第2个元素 2 (索引某一值) print(A[1,1]) 

print(A[1]) # 输出第2行（索引某一行）print(A[1,:])
print(A[0:2,:])  # 输出第1-2行（索引某一行）print(A[1,:])

print(A[:,1]) # 输出第2列
print(A[:,0:2]) #输出第1-2列

输出矩阵

2
[5 2 8]
[[1 4 3]
 [5 2 8]]
[4 2]
[[1 4]
 [5 2]]

合并

将两个向量合并成矩阵
将行向量变成列向量

# 合并
A = np.array([1,1,1]) #这个可以理解成向量，没有行列的明确区分
B = np.array([2,2,2]) 

print(np.vstack((A,B)))  # 上下合并成两行 注意np.vstack((A,B)) 有两层括号[[1 1 1] [2 2 2]]
print(np.hstack((A,B)))  # 左右合并成一行 注意np.hstack((A,B)) 有两层括号 [1 1 1 2 2 2]

# 添加维度
print(A[:, np.newaxis]) # [[1] [1] [1]]  变成列

输出结果

[[1 1 1]
 [2 2 2]]
[1 1 1 2 2 2]
[[1]
 [1]
 [1]]