附上参考链接
https://www.runoob.com/numpy/numpy-tutorial.html
https://www.cnblogs.com/TensorSense/p/6795995.html
https://docs.scipy.org/doc/numpy/
大数据挖掘常用的Python包
Numpy：科学计算包
Scipy：科学计算包
Pandas：数据分析处理包
Matplotlib：数据可视化库
Scikit-learn：机器学习库
这里只介绍numpy包
一、Numpy简介
NumPy是一个开源的Python科学计算基础库，提供了大量的数值编程工具，可以方便地处理向量、矩阵等运算。它包含：
- 一个强大的N维数组对象 ndarray
- 广播功能函数
- 线性代数、傅里叶变换、随机数生成等功能
NumPy是SciPy、Pandas等数据处理或科学计算库的基础
二、Numpy的基本操作
0. 导入Numpy
import numpy as np
1. 创建数组
- （1）从Python中的列表、元组等类型创建nd-array数组
利用
① 从列表创建数组
import numpy as np
li = [1,5,6,8]
x = np.array(li)
print(x)
print(type(x))
结果:
[1 5 6 8]
<class 'numpy.ndarray'>
② 从元组创建数组
import numpy as np
tup = (5,4,8,6)
x = np.array(tup)
print(x)
print(type(x))
结果:
[5 4 8 6]
<class 'numpy.ndarray'>
③ 从列表和元组混合创建数组
import numpy as np
li = [1,5,6,8]
tup = (5,4,8,6)
x = np.array([li,tup]) #实际上这里依旧是列表创建数组
print(x)
print(type(x))
结果:
[[1 5 6 8]
[5 4 8 6]]
<class 'numpy.ndarray'>
-
（2）使用Numpy函数创建数组
import numpy as np
x1 = np.arange(10)
x2 = np.arange(5)
x3 = np.arange(1,11,2)
print(x1)
print(x2)
print(x3)
结果:
[0 1 2 3 4 5 6 7 8 9]
[0, 1, 2, 3, 4]
[1, 3, 5, 7, 9]
arange()有三个主要参数，start，stop，step，即起始、终止和步长。
② ones(shape)
参数shape指的是列表或者元组，数字个数指数组的维度，可以通过shape属性查看数组的形状。参数dtype是元素的类型有int，默认为float。
import numpy as np
x1 = np.ones(3) #一维数组
x2 = np.ones((2,3)) #二维数组
x3 = np.ones([2,3,4]) #三维数组
print(x1)
print()
print(x2)
print()
print(x3)
print(x1.shape)
print(x2.shape)
print(x3.shape)
结果:
[1. 1. 1.]
[[1. 1. 1.]
[1. 1. 1.]]
[[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]
[[1. 1. 1. 1.]
[1. 1. 1. 1.]
[1. 1. 1. 1.]]]
(3,)
(2, 3)
(2, 3, 4)
③ zeros(shape)
zeros与ones相似，只不过生成的元素是0.
import numpy as np
x1 = np.zeros(3) #一维数组
x2 = np.zeros((2,3)) #二维数组
x3 = np.zeros([2,3,4]) #三维数组
print(x1)
print()
print(x2)
print()
print(x3)
结果:
[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.]
[0. 0. 0. 0.]
[0. 0. 0. 0.]]]
④ full(shape,val)
用val填充一个shape形状的数组
import numpy as np
x = np.full((2,3),2) #用2填充2*3的二维数组
print(x)
结果:
[[2 2 2]
[2 2 2]]
⑤ eye(n)
生成一个n*n维的单位矩阵
import numpy as np
x = np.eye(3)
print(x)
结果:
[[1. 0. 0.]
[0. 1. 0.]
[0. 0. 1.]]
-
（3）利用其它函数创建nd-array数组
① linspace(start,stop,num,endpoint)
import numpy as np
x1 = np.linspace(1,10,3,dtype=int) # endpoint默认为True
print(x1)
x2 = np.linspace(1,10,3,dtype=int,endpoint=False)
print(x2)
结果:
[1 5 10]
[1 4 7]
② concatenate((a1,a2,...,an),aixs=0)
(a1,a2,...)是要连接的序列，aixs是行或者列，0是按列连接、1是按行连接，默认为0。
将两个或多个数组合并成一个数组
import numpy as np
a = np.array([[4,1],[3,2]])
b = np.array([[5,2],[8,9]])
c1 = np.concatenate([a,b])
c2 = np.concatenate((a,b),1)
print(a)
print()
print(b)
print()
print(c1)
print()
print(c2)
结果:
[[4 1]
[3 2]]
[[5 2]
[8 9]]
[[4 1]
[3 2]
[5 2]
[8 9]]
[[4 1 5 2]
[3 2 8 9]]
③ hstack(tup)和vstack(tup)
tup是元组
import numpy as np
a = np.array([[5,4],[8,6],[8,7]])
b = np.array([[1,2],[4,5],[2,2]])
c1 = np.hstack((a,b))
c2 = np.vstack((a,b))
print(a)
print()
print(b)
print()
print(c1)
print()
print(c2)
结果:
[[5 4]
[8 6]
[8 7]]
[[1 2]
[4 5]
[2 2]]
[[5 4 1 2]
[8 6 4 5]
[8 7 2 2]]
[[5 4]
[8 6]
[8 7]
[1 2]
[4 5]
[2 2]]
2. 获取数组属性
数组属性
import numpy as np
a = np.array([[2,1,3],[1,4,5],[8,5,5]])
print(a)
print("a.ndim:",a.ndim)
print("a.shape:",a.shape)
print("a.size:",a.size)
print('a.dtype:',a.dtype)
print('itemsize:',a.itemsize)
结果:
[[2 1 3]
[1 4 5]
[8 5 5]]
a.ndim: 2
a.shape: (3, 3)
a.size: 9
a.dtype: int32
itemsize: 4
3. 随机生成、复制、排序、调整、转置数组
有np.random.rand()，np.random.randn()两种方式，区别在于rand()只生成正数。
import numpy as np
x1 = np.random.randn(2,3) #生成一个2x3的二维数组
x2 = np.random.randn(3,4) #生成一个3x4的二维数组
x3 = np.random.randn(2,2,3) #生成一个2x2x3的三维数组
print(x1)
print()
print(x2)
print()
print(x3)
结果:
[[ 0.6919357 0.39917593 -0.0896835 ]
[ 0.61647791 0.85612186 -0.93986079]]
[[-0.1696892 -1.66241796 -1.24078019 1.02316869]
[ 1.05928049 -0.42552907 0.40492102 -0.78794536]
[ 0.78318229 0.75858729 -0.44156901 -1.58432534]]
[[[ 0.85747856 1.61558974 -0.46686676]
[ 1.22798477 1.26865842 -0.18074301]]
[[-1.99597649 0.40527899 1.86830874]
[-0.5422555 0.83269358 -0.33257266]]]
② 复制数组
np.copy(arr)
import numpy as np
a = np.array([[1,2,4],[2,5,6]])
a_copy = np.copy(a)
print(a)
print()
print('复制',a_copy)
结果:
[[1 2 4]
[2 5 6]]
复制 [[1 2 4]
[2 5 6]]
③ 排序数组
np.sort(a,axis=1)
axis=0 按列排序，axis=1按行排序
import numpy as np
a = np.array([[1,5,3],[8,7,2]])
b = np.sort(a)
c = np.sort(a,axis=0)
print(a)
print()
print(b)
print()
print(c)
结果:
[[1 5 3]
[8 7 2]]
[[1 3 5]
[2 7 8]]
[[1 5 2]
[8 7 3]]
④ 调整数组
reshape(arr,newshape)，调整数组的形状
import numpy as np
a = np.array([[1,5,3],[8,7,2]]) #这是一个2x3的二维数组
b = np.reshape(a,(3,2)) #调整为3x2的数组，但不能调整为2x4,4x2这样子的
print(a)
print()
print(b)
resize(a,newshape)，调整数组的大小，可以调整为更大的数组，如果新数组大小大于原始大小，则包含原始数组中的元素的副本。
import numpy as np
a = np.array([[1,5,3],[8,7,2]]) #这是一个2x3的二维数组
b = np.resize(a,(3,4)) #调整为一个3x4的二维数组
print(a)
print()
print(b)
结果:
[[1 5 3]
[8 7 2]]
[[1 5 3 8]
[7 2 1 5]
[3 8 7 2]]
⑤ 转置数组
arr.T
import numpy as np
a = np.array([[1,5,3],[8,7,2]]) #这是一个2x3的二维数组
aT = a.T
print(a)
print()
print(aT)
结果:
[[1 5 3]
[8 7 2]]
[[1 8]
[5 7]
[3 2]]
4. 增加、删除元素
① 添加元素
1）从结尾增加元素，append(arr,values)
import numpy as np
a = np.array([[1,5,3],[8,7,2]])
print("添加元素之前：")
print(a)
a = np.append(a,10)
print("添加元素之后，变成了一维数组：")
print(a)
结果:
添加元素之前：
[[1 5 3]
[8 7 2]]
添加元素之后，变成了一维数组：
[ 1 5 3 8 7 2 10]
沿0轴添加元素
import numpy as np
a = np.array([[1,5,3],[8,7,2]])
print("添加之前")
print(a)
a = np.append(a,[[2,5,6]],axis=0)
print("沿0轴添加元素")
print(a)
结果:
添加之前
[[1 5 3]
[8 7 2]]
沿0轴添加元素
[[1 5 3]
[8 7 2]
[2 5 6]]
沿1轴添加元素
import numpy as np
a = np.array([[1,5,3],[8,7,2]])
print("添加之前")
print(a)
#a = np.append(a,[[2,5,6]],axis=1)按1轴，必须两个维度都要增加
a = np.append(a,[[2,5,6],[1,5,5]],axis=1)
print("沿1轴添加元素")
print(a)
结果:
添加之前
[[1 5 3]
[8 7 2]]
沿1轴添加元素
[[1 5 3 2 5 6]
[8 7 2 1 5 5]]
2）从指定位置增加元素，insert(arr,index,values)
普通插入
import numpy as np
a = np.arange(12).reshape(4,3)
print("添加之前")
print(a)
a = np.insert(a,2,[1,5,7])
print("在索引为2的元素之前插入，变为一维数组:")
print(a)
结果:
添加之前
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
在索引为2的元素之前插入，变为一维数组:
[ 0 1 1 5 7 2 3 4 5 6 7 8 9 10 11]
按行(0轴)索引插入
import numpy as np
a = np.arange(12).reshape(4,3)
print("添加之前")
print(a)
a = np.insert(a,2,[1,5,7],0)
print("按行索引插入，在行索引为2的行之前插入:")
print(a)
结果:
添加之前
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
按行索引插入，在行索引为2的行之前插入:
[[ 0 1 2]
[ 3 4 5]
[ 1 5 7]
[ 6 7 8]
[ 9 10 11]]
按列(1轴)索引插入
import numpy as np
a = np.arange(12).reshape(4,3)
print("添加之前")
print(a)
#a = np.insert(a,2,[1,5,7],1) 注意，按列来的话，有四个元素
a = np.insert(a,2,[1,5,7,4],1)
print("按列索引插入，在列索引为2的列之前插入:")
print(a)
结果:
添加之前
[[ 0 1 2]
[ 3 4 5]
[ 6 7 8]
[ 9 10 11]]
按列索引插入，在列索引为2的列之前插入:
[[ 0 1 1 2]
[ 3 4 5 5]
[ 6 7 7 8]
[ 9 10 4 11]]
② 删除元素
普通删除，返回一维数组
import numpy as np
a = np.arange(10).reshape(5,2)
print("删除之前:")
print(a)
a = np.delete(a,2)
print("删除之后:")
print(a)
结果:
删除之前:
[[0 1]
[2 3]
[4 5]
[6 7]
[8 9]]
删除之后:
[0 1 3 4 5 6 7 8 9]
np.delete(arr,index,axis=0):删除数组arr第index+1行所有的元素，返回ndarray对象
import numpy as np
a = np.arange(10).reshape(5,2)
print("删除之前:")
print(a)
a = np.delete(a,2,axis=0)
print("删除之后:")
print(a)
结果:
删除之前:
[[0 1]
[2 3]
[4 5]
[6 7]
[8 9]]
删除之后:
[[0 1]
[2 3]
[6 7]
[8 9]]
np.delete(arr,index,axis=1):删除数组arr第index+1列所有的元素，返回ndarray对象
import numpy as np
a = np.arange(10).reshape(2,5)
print("删除之前:")
print(a)
a = np.delete(a,2,axis=1)
print("删除之后:")
print(a)
结果:
删除之前:
[[0 1 2 3 4]
[5 6 7 8 9]]
删除之后:
[[0 1 3 4]
[5 6 8 9]]
5. 数组的索引、切片、子集
① 索引：获取数组中特定位置元素的过程
一维数组的索引，与序列相似
import numpy as np
a = np.array([4,2,6,1,7])
print(a)
print("查找索引为3的元素:")
print(a[3])
结果:
[4 2 6 1 7]
查找索引为3的元素:
1
多维数组的索引每个维度一个索引值，逗号分割
import numpy as np
a = np.arange(24).reshape(2,3,4) #生成一个2x3x4的三维数组
print(a)
print("查找第一维度索引为1的数组")
print("a[1]:")
print(a[1])
print("查找第一维度索引为1、第二维度索引为2的数组")
print("a[1,2]:")
print(a[1,2])
print("查找第一维度索引为1、第二维度索引为2、第三维度索引为3的元素:")
print("a[1,2,3]:")
print(a[1,2,3])
结果:
[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
查找第一维度索引为1的数组
a[1]:
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]
查找第一维度索引为1、第二维度索引为2的数组
a[1,2]:
[20 21 22 23]
查找第一维度索引为1、第二维度索引为2、第三维度索引为3的元素:
a[1,2,3]:
23
② 切片：获取数组元素子集的过程
一维数组的切片，与序列相似，有start、stop、step
import numpy as np
a = np.array([4,2,6,1,7,19,12])
print(a)
print("切出从索引0到索引4的元素：")
print("a[:5]:")
print(a[:5])
print("切出从索引1到索引5的元素：")
print("a[1:6]:")
print(a[1:6])
print("以间隔为2，切出元素：")
print("a[::2]:")
print(a[::2])
结果:
[ 4 2 6 1 7 19 12]
切出从索引0到索引4的元素：
a[:5]:
[4 2 6 1 7]
切出从索引1到索引5的元素：
a[1:6]:
[ 2 6 1 7 19]
以间隔为2，切出元素：
a[::2]:
[ 4 6 7 12]
多维数组的切片选取一个维度用: 每个维度切片方法与一维数组相同。
a[第一个维度,第二个维度,第三个维度]
import numpy as np
a = np.arange(24).reshape((2,3,4))
print(a)
print("第一维度不切片、第二维度切索引为1到2的、第三维度切0到3的片段")
print("操作:a[:,1:3,:4]")
print(a[:,1:3,:4])
print("第一维度不切片、第二维度切索引为1到2的、第三维度以步长为2切片")
print("操作:a[:,1:3,::2]")
print(a[:,1:3,::2])
print("第一维度得到最后一片、第二维度切索引为1到2的、第三维度以步长为2切片")
print("操作:a[1,1:3,::2]")
print(a[1,1:3,::2])
结果:
[[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[12 13 14 15]
[16 17 18 19]
[20 21 22 23]]]
第一维度不切片、第二维度切索引为1到2的、第三维度切0到3的片段
操作:a[:,1:3,:4]
[[[ 4 5 6 7]
[ 8 9 10 11]]
[[16 17 18 19]
[20 21 22 23]]]
第一维度不切片、第二维度切索引为1到2的、第三维度以步长为2切片
操作:a[:,1:3,::2]
[[[ 4 6]
[ 8 10]]
[[16 18]
[20 22]]]
第一维度得到最后一片、第二维度切索引为1到2的、第三维度以步长为2切片
操作:a[1,1:3,::2]
[[16 18]
[20 22]]
6. 标量运算
标量运算
① add(arr,num)
import numpy as np
a = np.array([[2,1],[3,2]])
print(a)
print("加法:")
print("np.add(a,2)")
print(np.add(a,2))
结果:
[[2 1]
[3 2]]
加法:
np.add(a,2)
[[4 3]
[5 4]]
② subtract(arr,num)
import numpy as np
a = np.array([[2,1],[3,2]])
print(a)
print("减法:")
print("np.subtract(a,2)")
print(np.subtract(a,2))
结果:
[[2 1]
[3 2]]
减法:
np.subtract(a,2)
[[ 0 -1]
[ 1 0]]
③ multiply(arr,num)
import numpy as np
a = np.array([[2,1],[3,2]])
print(a)
print("乘法:")
print("np.multiply(a,2)")
print(np.multiply(a,2))
结果:
[[2 1]
[3 2]]
乘法:
np.multiply(a,2)
[[4 2]
[6 4]]
④ divide(arr,num)
import numpy as np
a = np.array([[2,1],[3,2]])
print(a)
print("除法:")
print("np.divide(a,2)")
print(np.divide(a,2))
结果:
[[2 1]
[3 2]]
除法:
np.divide(a,2)
[[1. 0.5]
[1.5 1. ]]
⑤ power(arr,num)
import numpy as np
a = np.array([[2,1],[3,2]])
print(a)
print("幂运算:")
print("np.power(a,2)")
print(np.power(a,2))
结果:
[[2 1]
[3 2]]
幂运算:
np.power(a,2)
[[4 1]
[9 4]]
7. 向量运算
① np.add(arr1,arr2)：两个数组对应元素相加
import numpy as np
a = np.array([1,2,5,6]).reshape(2,2)
b = np.array([6,5,2,1]).reshape(2,2)
c = np.add(a,b)
print('这是a数组')
print(a)
print('这是b数组')
print(b)
print('np.add(a,b)，a，b两个数组对应元素相加')
print(c)
结果:
这是a数组
[[1 2]
[5 6]]
这是b数组
[[6 5]
[2 1]]
np.add(a,b)，a，b两个数组对应元素相加
[[7 7]
[7 7]]
② np.subtract(arr1,arr2)：两个数组对应元素相减
import numpy as np
a = np.array([1,2,5,6]).reshape(2,2)
b = np.array([6,5,2,1]).reshape(2,2)
c = np.subtract(a,b)
print('这是a数组')
print(a)
print('这是b数组')
print(b)
print('np.subtract(a,b)，a，b两个数组对应元素相减')
print(c)
结果:
这是a数组
[[1 2]
[5 6]]
这是b数组
[[6 5]
[2 1]]
np.subtract(a,b)，a，b两个数组对应元素相减
[[-5 -3]
[ 3 5]]
③ np.multiply(arr1,arr2)：两个数组对应元素相乘，而不是矩阵相乘的法则。
import numpy as np
a = np.array([1,2,5,6]).reshape(2,2)
b = np.array([6,5,2,1]).reshape(2,2)
c = np.multiply(a,b)
print('这是a数组')
print(a)
print('这是b数组')
print(b)
print('np.multiply(a,b)，a，b两个数组对应元素相乘')
print(c)
结果:
这是a数组
[[1 2]
[5 6]]
这是b数组
[[6 5]
[2 1]]
np.multiply(a,b)，a，b两个数组对应元素相乘
[[ 6 10]
[10 6]]
④ np.divide(arr1,arr2)：两个数组对应元素相除
import numpy as np
a = np.array([12,10,1,6]).reshape(2,2)
b = np.array([6,5,2,1]).reshape(2,2)
c = np.divide(a,b)
print('这是a数组')
print(a)
print('这是b数组')
print(b)
print('np.divide(a,b)，a，b两个数组对应元素相除')
print(c)
结果:
这是a数组
[[12 10]
[ 1 6]]
这是b数组
[[6 5]
[2 1]]
np.divide(a,b)，a，b两个数组对应元素相除
[[2. 2. ]
[0.5 6. ]]
⑤ np.power(arr1,arr2)：将数组arr2中的元素作为数组arr1的对应元素的指数
import numpy as np
a = np.array([1,2,5,6]).reshape(2,2)
b = np.array([6,5,2,2]).reshape(2,2)
c = np.power(a,b)
print('这是a数组')
print(a)
print('这是b数组')
print(b)
print('np.power(a,b)，将b的元素作为a对应元素的指数')
print(c)
结果:
这是a数组
[[1 2]
[5 6]]
这是b数组
[[6 5]
[2 2]]
np.power(a,b)，将b的元素作为a对应元素的指数
[[ 1 32]
[25 36]]
⑥ np.abs(x) np.fabs(x)：计算数组各元素的绝对值
import numpy as np
a = np.array([-1,-2,5,6]).reshape(2,2)
b = np.array([-6,-5,2,1]).reshape(2,2)
c = np.abs(a)
d = np.fabs(b)
print('这是a数组')
print(a)
print('这是b数组')
print(b)
print('np.abs(a)')
print(c)
print('np.fabs(b)，元素变为浮点型')
print(d)
结果:
这是a数组
[[-1 -2]
[ 5 6]]
这是b数组
[[-6 -5]
[ 2 1]]
np.abs(a)
[[1 2]
[5 6]]
np.fabs(b)，元素变为浮点型
[[6. 5.]
[2. 1.]]
⑦ np.sqrt(x)：计算数组各元素的平方根
import numpy as np
a = np.array([1,4,16,36]).reshape(2,2)
c = np.sqrt(a)
print('这是a数组')
print(a)
print('np.sqrt(a)，计算数组a各元素的平方根')
print(c)
结果:
这是a数组
[[ 1 4]
[16 36]]
np.sqrt(a)，计算数组a各元素的平方根
[[1. 2.]
[4. 6.]]
⑧ np.square(x)：计算数组各元素的平方
import numpy as np
a = np.array([1,2,5,6]).reshape(2,2)
c = np.square(a)
print('这是a数组')
print(a)
print('np.square(a)，计算数组a各元素的平方')
print(c)
结果:
这是a数组
[[1 2]
[5 6]]
np.square(a)，计算数组a各元素的平方
[[ 1 4]
[25 36]]
⑨ np.log(x)、np.log10(x)、np.log2(x)
np.log(x)：计算数组各元素的自然对数
import numpy as np
a = np.array([np.e,2,10,6]).reshape(2,2)
c = np.log(a)
print('这是a数组')
print(a)
print('np.log(a)，计算数组a各元素的自然对数')
print(c)
结果:
这是a数组
[[ 2.71828183 2. ]
[10. 6. ]]
np.log(a)，计算数组a各元素的自然对数
[[1. 0.69314718]
[2.30258509 1.79175947]]
np.log10(x)：计算数组各元素的10底对数
import numpy as np
a = np.array([10,100,1000,2]).reshape(2,2)
c = np.log10(a)
print('这是a数组')
print(a)
print('np.log10(a)，计算数组a各元素的10底对数')
print(c)
结果:
这是a数组
[[ 10 100]
[1000 2]]
np.log10(a)，计算数组a各元素的10底对数
[[1. 2. ]
[3. 0.30103]]
np.log2(x)：计算数组各元素的2底对数
import numpy as np
a = np.array([2,16,32,4]).reshape(2,2)
c = np.log2(a)
print('这是a数组')
print(a)
print('np.log2(a)，计算数组a各元素的2底对数')
print(c)
结果:
这是a数组
[[ 2 16]
[32 4]]
np.log2(a)，计算数组a各元素的2底对数
[[1. 4.]
[5. 2.]]
⑩ np.ceil(x)、np.floor(x)
np.ceil(x)：数组各元素向上取整
import numpy as np
a = np.random.randn(2,2)
c = np.ceil(a)
print('这是a数组')
print(a)
print('np.ceil(a)，数组a各元素向上取整')
print(c)
结果:
这是a数组
[[ 0.35828912 1.21284634]
[-0.78966178 0.01141592]]
np.ceil(a)，数组a各元素向上取整
[[ 1. 2.]
[-0. 1.]]
np.floor(x)：数组各元素向下取整
import numpy as np
a = np.random.randn(2,2)
c = np.floor(a)
print('这是a数组')
print(a)
print('np.floor(a)，数组a各元素向下取整')
print(c)
结果:
这是a数组
[[-0.92498697 -0.24792889]
[-0.7291078 1.64891259]]
np.floor(a)，数组a各元素向下取整
[[-1. -1.]
[-1. 1.]]
8. 统计函数
① mean(arr,axis)：计算数组中的均值，axis是指定轴的均值，0是求每列的均值，1是求每行的均值
import numpy as np
a = np.array([[2,1],[5,2]])
print(a)
print("求a的均值，np.mean(a)")
print(np.mean(a))
print("求a每列的均值，np.mean(a,axis=0)")
print(np.mean(a,axis=0))
print("求a每行的均值，np.mean(a,axis=1)")
print(np.mean(a,axis=1))
结果:
[[2 1]
[5 2]]
求a的均值，np.mean(a)
2.5
求a每列的均值，np.mean(a,axis=0)
[3.5 1.5]
求a每行的均值，np.mean(a,axis=1)
[1.5 3.5]
② var()：返回数组arr中所有元素的方差
import numpy as np
a = np.array([[2,1],[5,2]])
print(a)
print("求a的方差，np.var(a)")
a_var = np.var(a)
print(a_var)
结果:
[[2 1]
[5 2]]
求a的方差，np.var(a)
2.25
③ std()：返回数组arr中所有元素的标准差
import numpy as np
a = np.array([[2,1],[5,2]])
print(a)
print("求a的标准差，np.std(a)")
a_std = np.std(a)
print(a_std)
结果:
[[2 1]
[5 2]]
求a的方差，np.std(a)
1.5
④ corrcoef()：返回数组arr中所有元素的相关系数
import numpy as np
a = np.array([[2,1],[5,2]])
print(a)
print("求a的相关系数，np.corrcoef(a)")
a_corrcoef = np.corrcoef(a)
print(a_corrcoef)
结果:
[[2 1]
[5 2]]
求a的相关系数，np.corrcoef(a)
[[1. 1.]
[1. 1.]]
⑤ sum()：返回数组arr所有元素之和
import numpy as np
a = np.array([[2,1],[5,2]])
print(a)
print("求a的和，np.sum(a)")
a_sum = np.sum(a)
print(a_sum)
结果:
[[2 1]
[5 2]]
求a的和，np.sum(a)
10
⑥ min()：返回数组arr中最小元素
import numpy as np
a = np.array([[2,1],[5,2]])
print(a)
print("求a的最小元素，np.min(a)")
a_min = np.min(a)
print(a_min)
结果:
[[2 1]
[5 2]]
求a的最小元素，np.min(a)
1
⑦ max()：返回数组arr中最大元素
import numpy as np
a = np.array([[2,1],[5,2]])
print(a)
print("求a的最大元素，np.max(a)")
a_max = np.max(a)
print(a_max)
结果:
[[2 1]
[5 2]]
求a的最大元素，np.max(a)
5
9. 矩阵的操作
科学计算中大量使用到矩阵运算，NumPy提供了矩阵对象。矩阵对象和数组对象主要有两点差别：
矩阵是二维的，而数组可以是任意正整数维
矩阵的*操作符进行的是矩阵乘法，乘号左侧的矩阵列和乘号右侧的矩阵行大小要相等，而数组的*操作符是对应元素两两相乘，乘号两侧的数组每一维大小都需要一致。
① 矩阵的生成
1）np.asmatrix(arr)
import numpy as np
a = np.arange(15).reshape(3,5)
print('这是数组a')
print(a)
print('a的类型')
print(type(a))
m = np.asmatrix(a)
print('将数组a转为矩阵m，np.asmatrix(a),得矩阵m')
print(m)
print('m的类型')
print(type(m))
结果:
这是数组a
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]
a的类型
<class 'numpy.ndarray'>
将数组a转为矩阵m，np.asmatrix(a),得矩阵m
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]
m的类型
<class 'numpy.matrix'>
2）np.matrix(arr)
import numpy as np
m = np.matrix('1,2,8;6,5,3;4,9,7')
#使用该函数时，内部需为字符串，每行用分号隔开
print("矩阵m")
print(m)
print("查看类型type(m)")
print(type(m))
结果:
矩阵m
[[1 2 8]
[6 5 3]
[4 9 7]]
查看类型type(m)
<class 'numpy.matrix'>
3）np.mat(arr)
import numpy as np
a = np.arange(2,45,3).reshape(5,3)
print('这是数组a')
print(a)
print('a的类型')
print(type(a))
m = np.mat(a)
print('将数组a转为矩阵m，np.mat(a),得矩阵m')
print(m)
print('m的类型')
print(type(m))
结果:
这是数组a
[[ 2 5 8]
[11 14 17]
[20 23 26]
[29 32 35]
[38 41 44]]
a的类型
<class 'numpy.ndarray'>
将数组a转为矩阵m，np.mat(a),得矩阵m
[[ 2 5 8]
[11 14 17]
[20 23 26]
[29 32 35]
[38 41 44]]
m的类型
<class 'numpy.matrix'>
② 矩阵的乘法
直接按照矩阵的乘法来计算，用*来进行矩阵相乘，左矩阵的列数要等于右矩阵的行数
import numpy as np
left_m = np.mat(np.arange(1,5).reshape(2,2))
right_m = np.mat(np.arange(1,8,2).reshape(2,2))
print('左矩阵left_m')
print(left_m)
print('右矩阵right_m')
print(right_m)
print('两个矩阵相乘')
print(left_m * right_m)
结果:
左矩阵left_m
[[1 2]
[3 4]]
右矩阵right_m
[[1 3]
[5 7]]
两个矩阵相乘
[[11 17]
[23 37]]
③ 矩阵的转置
1）matrix.T
import numpy as np
m = np.mat(np.arange(9).reshape(3,3))
print("矩阵m")
print(m,'\n')
print("m的转置T，矩阵矩阵m.T")
print(m.T)
结果:
矩阵m
[[0 1 2]
[3 4 5]
[6 7 8]]
m的转置T，矩阵矩阵m.T
[[0 3 6]
[1 4 7]
[2 5 8]]
2）np.transope(matrix)
import numpy as np
m = np.mat(np.arange(9).reshape(3,3))
print("矩阵m")
print(m,'\n')
print("m的转置T，矩阵矩阵np.transope(m)")
print(np.transpose(m))
结果:
矩阵m
[[0 1 2]
[3 4 5]
[6 7 8]]
m的转置T，矩阵矩阵np.transope(m)
[[0 3 6]
[1 4 7]
[2 5 8]]
④ 求逆矩阵
linalg是numpy中用于线性代数计算的模块，是linear algebra的简写
导入linalg
inv()函数求逆矩阵
import numpy as np
import numpy.linalg as nlg
m = np.mat(np.array([[4,9],[3,10]]))
inverse_m = nlg.inv(m)
print("矩阵m")
print(m,'\n')
print('m的逆矩阵,nlg.inv(m)')
print(inverse_m,'\n')
print('检验,inverse_m * m == 单位矩阵?')
print(inverse_m * m)
结果:
矩阵m
[[ 4 9]
[ 3 10]]
m的逆矩阵,nlg.inv(m)
[[ 0.76923077 -0.69230769]
[-0.23076923 0.30769231]]
检验,inverse_m * m == 单位矩阵?
[[1. 0.]
[0. 1.]]
10. 缺失值
缺失值在量化分析中也是一种信息，NumPy提供了nan作为缺失值的记录，通过isnan函数判定是否为缺失值。nan_to_num函数可以将nan替换成0。
np.nan可以得到缺失值，能将浮点数转为缺失值
import numpy as np
a = np.array([[1,2],[3,4]],dtype=float)
print(a)
a[0,1] = np.nan
print("a[0,1]修改成缺失值之后")
print(a)
结果:
[[1. 2.]
[3. 4.]]
a[0,1]修改成缺失值之后
[[ 1. nan]
[ 3. 4.]]
isnan函数可以判断是否有缺失值
import numpy as np
a = np.array([[1,2],[3,4]],dtype=float)
print(a)
a[0,1] = np.nan
print("a[0,1]修改成缺失值之后")
print(a)
print("isnan(a):")
print(np.isnan(a))
结果:
[[1. 2.]
[3. 4.]]
a[0,1]修改成缺失值之后
[[ 1. nan]
[ 3. 4.]]
isnan(a):
[[False True]
[False False]]
nan_to_num函数可以将nan值替换为0
import numpy as np
a = np.array([[1,2],[3,4]],dtype=float)
print(a)
a[0,1] = np.nan
print("a[0,1]修改成缺失值之后")
print(a)
a = np.nan_to_num(a)
print("将缺失值变为0，nan_to_num()")
print(a)
结果:
[[1. 2.]
[3. 4.]]
a[0,1]修改成缺失值之后
[[ 1. nan]
[ 3. 4.]]
将缺失值变为0，nan_to_num()
[[1. 0.]
[3. 4.]]
