NumPy是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵，比Python自身的嵌套列表（nested list structure）结构要高效的多。
NumPy（Numeric Python）提供了许多高级的数值编程工具。Numpy的一个重要特征是它的数组计算，是我们做数据分析必不可少的一个包。
导入Python库使用关键字import，后面可以自定义库的简称，但是一般都将NumPy命名为np，pandas命名为pd。
使用前一定要先导入Numpy包，导入的方法有以下几种：
import numpy
import numpy as np
from numpy import * ##不用加前缀，但和其他包函数重名容易报错
import numpy as np
1Numpy对象及其索引
数组上的数学操作
假如我们想将列表中的每个元素增加1，但列表不支持这样的操作：
a=[1,2,3,4]
[i+1 for i in a]
[2, 3, 4, 5]
与另一个数相加，得到对应元素相加的结果：
a=[1,2,3,4]
b=[2,3,4,5]
[x+y for (x,y) in zip(a,b)]
[3, 5, 7, 9]
zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。
这样的操作比较麻烦，而且在数据量特别大的时候会非常耗时间。
如果我们使用Numpy，就会变得特别简单
a=np.array([1,2,3,4])
b=np.array([2,3,4,5])
a+1
array([2, 3, 4, 5])
a+b
array([3, 5, 7, 9])
产生数组 array
1.从列表产生数据
list=[0,1,2,3]
a=np.array(list)
a
array([0, 1, 2, 3])
2.从列表传入
a=np.array([1,2,3,4])
a
array([1, 2, 3, 4])
3.生成全0数组
a=np.zeros(5)
a
array([0., 0., 0., 0., 0.])
4.生成全1数组
a=np.ones(5,dtype='bool') ##dtype定义需要的数据类型 这里定义成布尔
a
array([ True, True, True, True, True])
5.使用fill方法将数组设定为指定值
与列表不同，数组中要求所有元素的dtype是一样的，如果传入参数的类型与数组类型不一样，需要按照已有的类型进行转换。
a=np.array([1,2,3,4])
a.fill(2)
a
array([2, 2, 2, 2])
a.fill(2.5) ##传入的参数类型会按照原数组类型进行转换 浮点型转整型
a
array([2, 2, 2, 2])
##使用fill方法将原数组类型改变
a=np.array([1,2,3,4])
a=a.astype('float')
a.fill(2.5)
a
array([2.5, 2.5, 2.5, 2.5])
使用特定的方法生成特殊的数组
1.生成整数序列 arange
a=np.arange(1,10)
a
array([1, 2, 3, 4, 5, 6, 7, 8, 9])
a=np.arange(1,10,2) ##arange(起点,终点,步长)
a
array([1, 3, 5, 7, 9])
2.生成等差数列 linspace
a=np.linspace(1,19,10) ##linspace(起点,终点,个数)，此处从1开始到19结束，生成10个元素
a
array([ 1., 3., 5., 7., 9., 11., 13., 15., 17., 19.])
3.生成随机数 random.rand/randn
a=np.random.rand(10) ##生成0-1的10个随机数 浮点数
a
array([0.06818817, 0.33335218, 0.64765711, 0.4336125 , 0.46251429,
0.78930739, 0.47116701, 0.60252559, 0.77941471, 0.57273979])
b=np.random.randn(10) ##生成0-1的10个随机数,随机数服从标准正太分布
b
array([ 0.5770561 , -1.36047333, -0.41379915, -0.4660371 , -0.24865449,
0.99519499, -1.27109413, -1.18072939, -0.75014523, 0.17017929])
c=np.random.randint(1,10,10) ##生成1-10的10个随机整数 randint(起点,终点,个数)
c
array([6, 2, 4, 3, 9, 6, 3, 9, 7, 4])
数组属性
a
array([0.06818817, 0.33335218, 0.64765711, 0.4336125 , 0.46251429,
0.78930739, 0.47116701, 0.60252559, 0.77941471, 0.57273979])
1.查看类型
a=np.array([1,2,3,4])
type(a)
numpy.ndarray
numpy的n维数组
2.查看数组中的数据类型
a.dtype
dtype('int32')
3.查看形状，会返回一个元组，每个元素代表这一堆的元素数目
a.shape
(4,)
查看数组里面元素的数目
a.size
4
查看数组的维度
a.ndim
1
索引与切片
索引第一个元素
a=np.array([1,2,3,4])
a[0]
1
修改第一个元素的值
a[0]=10
a
array([10, 2, 3, 4])
切片，支持负索引
a=np.array([11,12,13,14,15])
a[1:3]
array([12, 13])
a[1:-2] # 第一个元素 到 倒数第二个元素的前一个元素
array([12, 13])
省略参数
a=np.array([11,12,13,14,15])
a[-2:]
array([14, 15])
a[::2]
array([11, 13, 15])
错位相减
假设我们记录一部电影的累计票房：
ob=np.array([21000,21800,22100,23400,25000])
ob
array([21000, 21800, 22100, 23400, 25000])
可以这样计算每天的票房
ob2=ob[1:]-ob[:-1]
ob2
array([ 800, 300, 1300, 1600])
多维数组
多维数组及其属性
将以列表为元素的列表传入，最终得到的额就是一个二维数组
a=np.array([[1,2,3,4],[5,6,7,8]])
a
array([[1, 2, 3, 4],
[5, 6, 7, 8]])
查看形状
a.shape #两行四列 2*4
(2, 4)
查看总的元素个数
a.size
8
查看维数
a.ndim
2
多维数组索引
对于二维数组，可以传入两个数字来索引
a=np.array([[1,2,3,4],[5,6,7,8]])
a
array([[1, 2, 3, 4],
[5, 6, 7, 8]])
a[1,3]
8
索引赋值
a[1,3]=9
a
array([[1, 2, 3, 4],
[5, 6, 7, 9]])
索引一整行内容
a[1]
array([5, 6, 7, 8])
Python会将这单个元组当成对第一堆的索引，然后返回对应的内容
行索引在逗号前，列索引在逗号后
a[:,1] ##返回的是第二列。
array([2, 6])
多维数组切片
a=np.array([[0,1,2,3,4,5],[10,11,12,13,14,15],[20,21,22,23,24,25],[30,31,32,33,34,35],[40,41,42,43,44,45],[50,51,52,53,54,55]])
a
array([[ 0, 1, 2, 3, 4, 5],
[10, 11, 12, 13, 14, 15],
[20, 21, 22, 23, 24, 25],
[30, 31, 32, 33, 34, 35],
[40, 41, 42, 43, 44, 45],
[50, 51, 52, 53, 54, 55]])
取到第一行的第4和第5两个元素
:左闭右开的区间
a[0,3:5]
array([3, 4])
得到最后两行的最后两列
a[-2:,-2:]
array([[44, 45],
[54, 55]])
得到第3列
a[:,2]
array([ 2, 12, 22, 32, 42, 52])
每一堆都支持切片的规则，包括负索引，省略
[起点:终点:步长]左闭右开
#例如：取出3，5行的奇数列
a[2:5:2,::2]
array([[20, 22, 24],
[40, 42, 44]])
切片是引用
切片在内存中使用的是引用机制。
引用机制意味着，Python并没有为b分配新的空间来存储它的值，而实让b指向了a所分配的内存空间，因此，改变b会改变a的值。
a=np.array([0,1,2,3,4])
b=a[2:4]
b
array([2, 3])
b[0]=10
a
array([ 0, 1, 10, 3, 4])
而这种现象在列表中并不会出现
list=[1,2,3,4,5]
list1=list[2:4]
list1
[3, 4]
list1[0]=10
list
[1, 2, 3, 4, 5]
这样的好处在于，对于很大的数据，不用大量复制多余的值，节约了空间
缺点在于，可能出现改变一个值而改变另一个值的情况。
一个解决方法是使用copy()方法产生一个复制，这个复制中会申请新的内存。
a=np.array([0,1,2,3,4])
b=a[2:4].copy()
b[0]=10
a
array([0, 1, 2, 3, 4])
花式索引
切片只能支撑连续或者等间隔的切片操作，要想实现任意位置的操作，需要使用花式索引 fancy slicing
一维花式索引
与range函数类似，我们可以使用arange函数来产生等差数组
a=np.arange(0,100,10)
a
array([ 0, 10, 20, 30, 40, 50, 60, 70, 80, 90])
花式索引需要指定索引位置
index=[1,2,-3]
y=a[index]
y
array([10, 20, 70])
还可以使用布尔数组来花式索引
mask=np.array([0,2,2,0,0,1,0,0,1,0],dtype=bool)
mask
array([False, True, True, False, False, True, False, False, True,
False])
y=a[mask]
y
array([10, 20, 50, 80])
mask必须是布尔数组，长度必须和数组长度相等
二维花式索引
对于二维花式索引，我们需要给定行和列的值
a=np.array([[0,1,2,3,4,5],[10,11,12,13,14,15],[20,21,22,23,24,25],[30,31,32,33,34,35],[40,41,42,43,44,45],[50,51,52,53,54,55]])
a
array([[ 0, 1, 2, 3, 4, 5],
[10, 11, 12, 13, 14, 15],
[20, 21, 22, 23, 24, 25],
[30, 31, 32, 33, 34, 35],
[40, 41, 42, 43, 44, 45],
[50, 51, 52, 53, 54, 55]])
返回的是一条次对角线上的5个值(此处取1，12，23，34，45)
a[(0,1,2,3,4),(1,2,3,4,5)] ##两个括号相对位置的数分别为行标和列标
array([ 1, 12, 23, 34, 45])
返回最后三行的1，3，5列
a[-3:,0:6:2]
array([[30, 32, 34],
[40, 42, 44],
[50, 52, 54]])
a[-3:,[0,2,4]]
array([[30, 32, 34],
[40, 42, 44],
[50, 52, 54]])
使用布尔数组进行索引
mask=np.array([1,0,1,0,1,0],dtype=bool)
a[-3:,mask]
array([[30, 32, 34],
[40, 42, 44],
[50, 52, 54]])
与切片不同，花式索引返回的是对象的一个复制而不是引用
“不完全”索引
只给定行索引的时候，返回整行
a=np.array([[0,1,2,3,4,5],[10,11,12,13,14,15],[20,21,22,23,24,25],[30,31,32,33,34,35],[40,41,42,43,44,45],[50,51,52,53,54,55]])
y=a[:3]
y
array([[ 0, 1, 2, 3, 4, 5],
[10, 11, 12, 13, 14, 15],
[20, 21, 22, 23, 24, 25]])
这时候也可以使用花式索引取出2，3，5行
con=np.array([0,1,1,0,1,0],dtype=bool)
a[con]
array([[10, 11, 12, 13, 14, 15],
[20, 21, 22, 23, 24, 25],
[40, 41, 42, 43, 44, 45]])
where语句
where(array)
where函数会返回所有非零元素的索引
满足条件的位置的元组
a=np.random.randint(1,10,10)
a
array([2, 1, 8, 9, 2, 3, 7, 7, 4, 3])
np.where(a>5)
(array([2, 3, 6, 7], dtype=int64),)
np.where(a>5,1,0)
array([0, 0, 1, 1, 0, 0, 1, 1, 0, 0])
np.where(condition[,x,y])
三个参数满足条件condition时输出x，不满足时输出y
这里元素大于5 满足输出1 否则输出0
一维数组
a=np.array([0,12,5,20])
判断句数组中的元素是不是大于10
a>10
array([False, True, False, True])
数组中所有大于10的元素的索引位置
np.where(a>10)
(array([1, 3], dtype=int64),)
注意到where的返回值是一个元组，返回的是索引位置
也可以直接用数组操作
a[a>10]
array([12, 20])
a[np.where(a>10)]
array([12, 20])
2数组类型
数组类型
布尔型：bool：占一个字节
整型：int8/16/32/64/128，int：和C语言的long一样大
无符号整型：uint8/16/32/64/128，uint：和C语言中的unsigned long一样大
浮点数：float16/32/64，float，longfloat：默认为双精度float64，longfloat精度大小与系统有关
复数：complex64/128，complex，longconplex：默认为complex128，即实部虚部都为双精度
字符串：string，unicode：可以使用表示一个4字节字符串的数组
对象：object：数组中可以使用任意值
时间：datetime64，timedelta64
类型转换
a=np.array([1.5,-3],dtype=int)
a
array([ 1, -3])
asarray函数
numpy.asarray(a, dtype=None, order=None)
将输入转换为数组。
a=np.array([1,2,3])
np.asarray(a,dtype=float)
array([1., 2., 3.])
astype函数
a=np.array([1,2,3])
a.astype(float)
array([1., 2., 3.])
##astype方法返回一个新数组 而不是引用
a=np.array([1,2,3])
b=a.astype(float)
b[0]=0.5
b
array([0.5, 2. , 3. ])
a
array([1, 2, 3])
astype引用不会对原数组产生影响
3 数组操作
以豆瓣10部高分电影为例
##电影名称
mv_name=['肖申克的救赎','控方证人','美丽人生','阿甘正传','霸王别姬','泰坦尼克号','辛德勒的名单','这个杀手不太冷','疯狂动物成','海豚湾']
##评分人数
mv_num=np.array([692795,42995,327855,580897,478523,157074,306904,662552,284652,159302])
##评分
mv_score=np.array([9.6,9.5,9.5,9.4,9.4,9.4,9.4,9.3,9.3,9.3])
##电影时长
mv_length=np.array([142,116,116,142,171,194,195,133,109,92])
数组排序
sort函数
##对评分人数排序
np.sort(mv_num)
array([ 42995, 157074, 159302, 284652, 306904, 327855, 478523, 580897,
662552, 692795])
mv_num ##sort函数不改变原数组
array([692795, 42995, 327855, 580897, 478523, 157074, 306904, 662552,
284652, 159302])
argsort返回从小到大的排列在数组中的索引位置
argsort函数
order=np.argsort(mv_num)
order
array([1, 5, 9, 8, 6, 2, 4, 3, 7, 0], dtype=int64)
##看评分人数最少
order[0]
1
##通过order获得索引，然后查看对应索引的其他数组信息
mv_name[1]
'控方证人'
数学操作
求和
np.sum(mv_num)
3693549
mv_num.sum()
3693549
最大值
mv_length.max()
195
np.max(mv_length)
195
最小值 min
均值 mean
标准差 std
方差 var
相关系数矩阵 cov
np.cov(mv_score,mv_length)
array([[9.88888889e-03, 4.55555556e-01],
[4.55555556e-01, 1.26288889e+03]])
多维数组操作
数组形状 shape
a=np.arange(6)
a
array([0, 1, 2, 3, 4, 5])
##修改原数组成2行3列
a.shape=2,3
a
array([[0, 1, 2],
[3, 4, 5]])
a.shape
(2, 3)
与之对应的方法是reshape，但它不会改变原来数组的值，而是返回一个新的数组
a=np.arange(6)
a
array([0, 1, 2, 3, 4, 5])
a.reshape(2,3)
array([[0, 1, 2],
[3, 4, 5]])
a
array([0, 1, 2, 3, 4, 5])
转置 T/transpose
a=a.reshape(2,3)
a
array([[0, 1, 2],
[3, 4, 5]])
a.T
array([[0, 3],
[1, 4],
[2, 5]])
a.transpose()
array([[0, 3],
[1, 4],
[2, 5]])
4数组连接
concatenate((a0,a1,...,an),axis=0)
axis=0代表往跨行（down)，而axis=1代表跨列（across)
使用0值表示沿着每一列或行标签索引值向下执行方法
使用1值表示沿着每一行或者列标签模向执行对应的方法
注意：这些数组要用（）包括到一个元组中去。
除了给定的轴外，这些数组其他轴的长度必须是一样的。
x=np.array([[0,1,2],[10,11,12]])
y=np.array([[50,51,51],[60,61,62]])
print(x.shape,y.shape)
(2, 3) (2, 3)
默认沿着第一维进行连接
z=np.concatenate((x,y),axis=0)
z
array([[ 0, 1, 2],
[10, 11, 12],
[50, 51, 51],
[60, 61, 62]])
沿着第二维进行连接
z=np.concatenate((x,y),axis=1)
z
array([[ 0, 1, 2, 50, 51, 51],
[10, 11, 12, 60, 61, 62]])
注意到这里x和y的形状是一样的，还可以将它们连接成三维的数组，但是concatenate不提供这样的功能，可以这样操作：
z=np.array((x,y))
z
array([[[ 0, 1, 2],
[10, 11, 12]],
[[50, 51, 51],
[60, 61, 62]]])
事实上，NumPy提供了分别对应这三种情况的函数
vstack
np.vstack((x,y))
array([[ 0, 1, 2],
[10, 11, 12],
[50, 51, 51],
[60, 61, 62]])
hstack
np.hstack((x,y))
array([[ 0, 1, 2, 50, 51, 51],
[10, 11, 12, 60, 61, 62]])
dstack
np.dstack((x,y))
array([[[ 0, 50],
[ 1, 51],
[ 2, 51]],
[[10, 60],
[11, 61],
[12, 62]]])
5 NumPy内置函数
https://blog.csdn.net/nihaoxiaocui/article/details/51992860
a=np.array([-1,2,3,-2])
##绝对值
np.abs(a)
array([1, 2, 3, 2])
##指数
np.exp(a)
array([ 0.36787944, 7.3890561 , 20.08553692, 0.13533528])
##中值
np.median(a)
0.5
##累计和(从前到后依次累加)
np.cumsum(a)
array([-1, 1, 4, 2], dtype=int32)