一、前言
玩数据分析、数据挖掘、AI的都知道这个python库用的是很多的，里面包含各种操作，在实际的dataset的处理当中是非常常用的，这里我做一个总结，方便自己看，也方便大家看，我准备做一个非常细致的分类，每个分类有对应的numpy常用用法，以后见到或者用到再一个个慢慢加进来，如果我还用csdn我就会移植update下去。
二、下载、安装、导入
用anaconda安装是十分方便的，如果你已经安装了tf,keras之类的，其实已经直接把numpy安装了，一般来说安装就是pip命令。
代码语言：javascript复制pip install numpy #py2
pip3 install numpy #py3
用法则是
代码语言：javascript复制import numpy as np # 一般as为np来操作
三、常用用法总结
１．array基本信息以及生成各种常见array基本操作
生成array，得到对应的基本信息
代码语言：javascript复制import numpy as np
array = np.array([[1, 2, 3],
[2, 3, 4]])
print array #numpy生成的array
print array.dtype # 每个元素的类型
print "number of dim", array.ndim # array的维度
print 'shape:', array.shape #形状， 两行三列。
print 'size:', array.size #array的大小＝array中所有元素的个数
"""
[[1 2 3]
[2 3 4]]
int64
number of dim 2
shape: (2, 3)
size: 6
"""
array的生成就是np.array(list)，本质上是把定义的list转换成array，因为array可以进行更加方便地计算和操作，比如矩阵的转置和相乘。
array的dtype设置
代码语言：javascript复制import numpy as np
a = np.array([2, 23, 4], dtype=np.float32)
print "a's dtype", a.dtype
aa = np.array([2, 23, 4], dtype=np.int)
print "aa's dtype", aa.dtype
aaa = np.array([2, 23, 4])
print "aaa's dtype", aaa.dtype
aaaa = np.array([2.2, 23.2, 4.2])
print "aaaa's dtype", aaaa.dtype
aaaaa = np.array([2, 23, 4], dtype=np.int64)
print "aaaaa's dtype:", aaaaa.dtype
"""
a's dtype float32
aa's dtype int64
aaa's dtype int64
aaaa's dtype float64
aaaaa's dtype: int64
"""
由可以得到一个结论就是如果定义的array里面的list的元素本身为整数的话，不设置type，则默认为int64,如果设置为int类型而没有设置字节大小则还是默认为int64,如果元素本身为小数，则默认为float64。 所以如果用int64，则如果元素都为整数则不需要设置默认即可，设置其他类型需要设置，float类似。
生成常见array格式
代码语言：javascript复制a1 = np.zeros((2, 3), dtype=np.int) # 生成shape=(2, 3)的全为0的array
print a1
"""
[[0 0 0]
[0 0 0]]
"""
a2 = np.ones((3, 4), dtype=np.int16) # 生成shape=(3, 4)的全为1的array
print a2
"""
[[1 1 1 1]
[1 1 1 1]
[1 1 1 1]]
"""
这里注意shape=(a,b)，在填入shape的参数的时候一定要加括号，以下雷同。
a3 = np.empty((3, 4)) # 生成shape=(3, 4)的全为接近空的array
print a3
"""
[[6.92259773e-310 4.67497449e-310 6.92259751e-310 6.92259750e-310]
[2.37151510e-322 3.16202013e-322 0.00000000e 000 6.92257087e-310]
[6.92259748e-310 6.92257087e-310 6.92257063e-310 6.92257063e-310]]
"""
a4 = np.arange(10, 20, 2) # 生成array 10到20 每隔2的一增加，for循环中主要使用
print a4
"""
[10 12 14 16 18]
"""
a5 = np.arange(12) # 生成array ０到12-1=11 每一个增加，for循环中非常常用
print a5
"""
[ 0 1 2 3 4 5 6 7 8 9 10 11]
"""
a6 = np.arange(12).reshape((3,4)) # 这里主要展示reshape的功能，能够重新定义矩阵的形状
print a6
"""
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
"""
27 # 1和10之间４个元素越过，这个主要应用在插值运算或者matplotlib画光滑曲线的时候计算用到。
a7 = np.linspace(1, 10, 4).reshape((2, 2))
print a7
"""
[[ 1. 4.]
[ 7. 10.]]
"""
２．array之间的计算
加减法
相同维度:
代码语言：javascript复制import numpy as np
a = np.array([10, 20, 30, 40])
b = np.arange(4)
print "a:", a
print "b:", b
c = a b
print "c:", c
c1 = a-b
print "c1:", c1
"""
a: [10 20 30 40]
b: [0 1 2 3]
c: [10 21 32 43]
c1: [10 19 28 37]
"""
不同维度:
代码语言：javascript复制aa = np.array([[1, 2, 3, 4],
[11, 22, 33, 44]])
bb = np.arange(4)
print "aa:", aa
print "bb:", bb
print "a b:", aa bb
"""
aa: [[ 1 2 3 4]
[11 22 33 44]]
bb: [0 1 2 3]
a b: [[ 1 3 5 7]
[11 23 35 47]]
"""
如果是不同维度的array进行加减法的话，程序就是把维度低的array自动复制扩展到大维度的array,进行相加 当然前提条件是两个不同维度的array进行相加的时候，低维度的array的shape也要和高维度的array其中一个shape相同，例如上面代码所示，(2,4) (1,4) 都有个shape为４
乘除法
代码语言：javascript复制d = np.array([[1, 2],
[3, 4]])
e = np.arange(1, 8, 2).reshape((2, 2))
print "d:", d
print "e:", e
print "d*e:", d*e #对应元素相乘
print "d/e", d/e #对应元素相除，因为是int64类型所以类似于2/3=0
"""
d: [[1 2]
[3 4]]
e: [[1 3]
[5 7]]
d*e: [[ 1 6]
[15 28]]
d/e [[1 0]
[0 0]]
"""
不同纬度的乘除法和上面加减法解析情况一样，可对比来看。
平方，三角函数，比较元素大小
代码语言：javascript复制a = np.array([10, 20, 30, 40])
b = np.arange(4)
c2 = b**2 # 平方
print "c2:", c2
c3 = 10*np.sin(a) # sin函数
print "c3:", c3
"""
c2: [0 1 4 9]
c3: [-5.44021111 9.12945251 -9.88031624 7.4511316 ]
"""
print "b:", b
print "b:", b < 3 # b中小于３的都为TRUE
print "b:", b == 3 # b中等于３的为TRUE
"""
b: [0 1 2 3]
b: [ True True True False]
b: [False False False True]
"""
矩阵相乘
代码语言：javascript复制d = np.array([[1, 2],
[3, 4]])
e = np.arange(1, 8, 2).reshape((2, 2))
print "d:", d
print "e:", e
print np.dot(d, e)
print d.dot(e)
"""
d: [[1 2]
[3 4]]
e: [[1 3]
[5 7]]
[[11 17] #例如１１ 为1*1 2*5=11
[23 37]]
[[11 17]
[23 37]]
"""
np.dot(d, e) 与d.dot(e)一样，都为d和e进行矩阵相乘
随机数和max,min,sum
代码语言：javascript复制f = np.random.random((2, 4)) #随机产生shape为（２，４）的一个array，每个元素都为0-1之间随机生成
print f
print "=------="
print np.sum(f)
print np.min(f)
print np.max(f)
"""
[[0.11027523 0.84841991 0.59866992 0.92557867]
[0.99917522 0.2771565 0.25578198 0.06671013]]
=------=
4.081767552987877
0.06671012832269874
0.9991752153886827
"""
print "============="
print np.sum(f, axis=0)
print np.min(f, axis=1)
print np.max(f, axis=0)
"""
[1.10945044 1.12557641 0.8544519 0.9922888 ]
[0.11027523 0.06671013]
[0.99917522 0.84841991 0.59866992 0.92557867]
"""
顾名思义，sum为总，min为最小，max为最大，如果不设置axis维度参数的话，则都为整个array的元素来说，但一般我们运用都只是算某个维度的sum,max,min，在二维数据中，axis=0代表行，第一个维度，axis=1，代表列为第二个维度，其实这么记并不是很好很有可能记错，我一般都是这么记得：axis=0为行，那意思就是每一行都要算呗？算完那不就是一列的每一行算个数被，axis=1类推，多维数据类推即可
矩阵转置和排序，以及元素比较大小重置元素方法
代码语言：javascript复制c = np.arange(14, 2, -1).reshape((3, 4))
print c
print "sort:", np.sort(c)# 每一行进行重新大小排序当然也有axis参数配置，根据我的axis参数说明来操作
print np.transpose(c) #转置 同下面操作
print c.T # 转置 同上面操作
print "clip:",np.clip(c, 5, 9)#c矩阵中的元素小于５的等于５，大于９的等于９
"""
[[14 13 12 11]
[10 9 8 7]
[ 6 5 4 3]]
sort: [[11 12 13 14]
[ 7 8 9 10]
[ 3 4 5 6]]
[[14 10 6]
[13 9 5]
[12 8 4]
[11 7 3]]
[[14 10 6]
[13 9 5]
[12 8 4]
[11 7 3]]
clip: [[9 9 9 9]
[9 9 8 7]
[6 5 5 5]]
"""
平均值、中值，累加，后减前
代码语言：javascript复制a = np.arange(2, 14).reshape((3, 4))
print "a:", a
print "average:", np.average(a) #平均值
print "median:", np.median(a) #中值
print "cumsum:", np.cumsum(a) #每个元素变成当前元素＋前面所有元素的和
print "diff:", np.diff(a) #当前元素减去前面元素的差
"""
a: [[ 2 3 4 5]
[ 6 7 8 9]
[10 11 12 13]]
average: 7.5
median: 7.5
cumsum: [ 2 5 9 14 20 27 35 44 54 65 77 90]
diff: [[1 1 1]
[1 1 1]
[1 1 1]]
"""
３．索引
最大值最小值索引，非零索引
代码语言：javascript复制a = np.array([[2, 6, 0, 4],
[4, 8, 9, 1],
[10, 2, 3, 11]])
print "argmin:", np.argmin(a)
print "axis0:", np.argmin(a, axis=0)
print "axis1:", np.argmin(a, axis=1)
print "argmax:", np.argmax(a)
print "zero:", np.nonzero(a)
"""
argmin: 2
axis0: [0 2 0 1]
axis1: [2 3 1]
argmax: 11
zero: (array([0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2]), array([0, 1, 3, 0, 1, 2, 3, 0, 1, 2, 3]))
"""
argmin/argmax都是返回最小值/最大值的索引的函数。
这里的axis和上面的分析是完全一致的，例如argmin(a)就是最小的索引，虽小的毋庸置疑是０，所以总体来讲从第一行第一个元素到最后一行最后一个元素，总体来算索引，那就是第二个为０，所以返回２，如果axis=0说明一列中的每一行来比较，那第一列比较出来最小的为２，即索引为０，因为每一列的每一行来比较所以最后的维度为列数，在这里即为４，以此列推。
非零索引的意思为非零的数返回索引，如上例为返回两个array，前面array对应行索引，后面对应列索引，一前一后加一起的shape才对应一个非零索引
取值，取列或行
代码语言：javascript复制import numpy as np
a = np.arange(3, 15).reshape((3, 4))
print a
print a[1] #索引为1的行，同下
print a[:][1] #索引为1的行，同上
print "=========-------==========="
print a[2][1] #和数组一样的表示
print a[2, 1] #同上，这才是比较标准的array的索引表示，前面是行后面是列的索引
print "=========---------============"
print a[:, 1] #索引为１的列,生成为行向量
print a[:, 1:2] #索引为１的列，生成为列向量
print a[:, 1:3]
print a[1, 1:3] #为上面a[:, 1:3]的索引为１的行向量
"""
[[ 3 4 5 6]
[ 7 8 9 10]
[11 12 13 14]]
[ 7 8 9 10]
[ 7 8 9 10]
=========-------===========
12
12
=========---------============
[ 4 8 12]
[[ 4]
[ 8]
[12]]
[[ 4 5]
[ 8 9]
[12 13]]
[8 9]
"""
着重讲一下 a[:, 1:2] a[:, 1:3] a[1, 1:3]
a[:, 1:2]：:代表行所有也就是一列要的话，这一列的每一行都要，1:2对应的从索引为１的列来算移植相当于取到索引为（2-1）的列，2为取的最高索引大一个。所以总体来讲就是首先取每一行，之后在行里取索引１->１的列元素，所以为最终的结果列向量。
a[:, 1:3]：按照上面的分析则每一行都要，列要索引为1和(3-1)的元素，那就是索引为1和2的所有元素，也就是第二列和第三列的元素。
a[1, 1:3]：为a[:, 1:3]的索引为１的所有元素。 这里需要注意的是
a[:, 1] #索引为１的列,生成为行向量，
a[:, 1:2] #索引为１的列，生成为列向量
因为两种取值的思想不一样，最终造成的结果也不一样，一个是直接取，所以维度减少了一个，另一个是在原本维度上截取，最终还是原来的维度。
迭代元素和降维
代码语言：javascript复制a = np.arange(3, 15).reshape((3, 4))# 数据都是下取上差一个取到。
print a
print "row"
for row in a: #取每一行迭代
print row
print "column"
for column in a.T: #每一列迭代
print column
print "====================="
print a.flatten() # 所有元素变成一维
b = np.array([[1, 2, 3]])
print b
print b.flatten() #降维
for item in a.flat: #每个元素打印
print item
"""
[[ 3 4 5 6]
[ 7 8 9 10]
[11 12 13 14]]
row
[3 4 5 6]
[ 7 8 9 10]
[11 12 13 14]
column
[ 3 7 11]
[ 4 8 12]
[ 5 9 13]
[ 6 10 14]
=====================
[ 3 4 5 6 7 8 9 10 11 12 13 14]
[[1 2 3]]
[1 2 3]
3
4
5
6
7
8
9
10
11
12
13
14
"""
行迭代，就是可以理解为最外层的维度进行迭代，列迭代就是利用转置来完成。
flatten()函数的意思为把array的内层的维度进行降一维，将内层的维度弄掉，则二维数据就成为一维数据了
４．合并与分开
两个合并、多个合并（行向量转换成列向量）
代码语言：javascript复制# -*- coding: utf-8 -*-
import numpy as np
a = np.array([1, 1, 2])
b = np.array([2, 3, 4])
c = np.vstack((a, b)) #vertical
print "a:", a
print "b:", b
print "c:", c
print "a,c shape:", a.shape, c.shape
d = np.hstack((a, b)) #horizontal
print "d:", d
print d.shape
"""
a: [1 1 2]
b: [2 3 4]
c: [[1 1 2]
[2 3 4]]
a,c shape: (3,) (2, 3)
d: [1 1 2 2 3 4]
(6,)
"""
print a.T # not transponse 行向量无法直接用转置来变成列向量
# 行向量变成列向量
print a[np.newaxis, :].shape
print a[:, np.newaxis].shape
print a[:, np.newaxis] #转换方法
"""
[1 1 2]
(1, 3)
(3, 1)
[[1]
[1]
[2]]
"""
a = np.array([1, 1, 2])[:, np.newaxis]
b = np.array([2, 3, 4])[:, np.newaxis]
c = np.concatenate((a, b, b), axis=0) #多向量融合
print c
c = np.concatenate((a, b, b), axis=1) #多向量融合
print c
"""
[[1]
[1]
[2]
[2]
[3]
[4]
[2]
[3]
[4]]
[[1 2 2]
[1 3 3]
[2 4 4]]
"""
分开
代码语言：javascript复制# -*- coding: utf-8 -*-
import numpy as np
a = np.arange(12).reshape((3, 4))
print a
print "平等分开"
print "vertical:", np.split(a, 2, axis=1) #
print "horizontal:", np.split(a, 3, axis=0) #
"""
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
平等分开
vertical: [array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2, 3],
[ 6, 7],
[10, 11]])]
horizontal: [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
"""
print "不平等分开"
print np.array_split(a, 3, axis=1)
print "代替需要axis参数"
print "vertical_a:", np.vsplit(a, 3)
print "horizontal_a:", np.hsplit(a, 2)
"""
不平等分开
[array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2],
[ 6],
[10]]), array([[ 3],
[ 7],
[11]])]
代替需要axis参数
vertical_a: [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8, 9, 10, 11]])]
horizontal_a: [array([[0, 1],
[4, 5],
[8, 9]]), array([[ 2, 3],
[ 6, 7],
[10, 11]])]
"""
５．元素传递和copy
代码语言：javascript复制b = np.arange(4)
print b
c = b
e = c
d = e
b[0] = 11
print b
print c is b
print d is b
print b[0]
d[1: 3] = [22, 22]
print b
print c
c = b.copy()
b[3] = 44
print b
print c
print e
"""
[0 1 2 3]
[11 1 2 3]
True
True
11
[11 22 22 3]
[11 22 22 3]
[11 22 22 44]
[11 22 22 3]
[11 22 22 44]
"""
array这个元素传递有点意思的，就是如果直接a=b，其实从内存角度来考虑就相当于a和b指向了一样的元素内存空间，所以改变一个元素的值，另一个一样改变，如果想各是各的，并且还想传递另一个元素的值那就用a=b.copy()，所以这个还是需要注意的
6.补充部分
array.min/max/ptp
代码语言：javascript复制import numpy as np
a = [[2, 4, 8, 9], [1, 7, 4, 5], [5, 7, 1, 4]]
a = np.array(a)
print(a)
print(a.min(0))
print(a.min(1))
print(a.ptp(0))
"""
[[2 4 8 9]
[1 7 4 5]
[5 7 1 4]]
axis=0 为每列的最小值返回
[1 4 1 4]
axis=1 为每行的最小值返回
[2 1 1]
ptp为最大值减最小值的range
[4 3 7 5]
"""
np.random.choice
代码语言：javascript复制import numpy as np
a = np.random.choice(a=100, size=20)
print(a)
"""
0-99之间选size为20的随机数的list
[78 82 91 96 5 60 28 79 24 56 5 34 58 48 96 57 77 23 80 69]
"""
