【Data Mining】机器学习三剑客之Numpy常用用法总结

作者：陈老师 个人公众号：接地气学堂

陈老师新课：商业分析全攻略 https://edu.hellobi.com/course/308 用数据分析方法解决商业问题，目前已经100+学员加入！5星好评。分析思维双剑合璧，四大板块：概念篇、行业篇、思维篇、套路篇 

一、前言

  玩数据分析、数据挖掘、AI的都知道这个python库用的是很多的，里面包含各种操作，在实际的dataset的处理当中是非常常用的，这里我做一个总结，方便自己看，也方便大家看，我准备做一个非常细致的分类，每个分类有对应的numpy常用用法，以后见到或者用到再一个个慢慢加进来，如果我还用csdn我就会移植update下去。

二、下载、安装、导入

  用anaconda安装是十分方便的，如果你已经安装了tf,keras之类的，其实已经直接把numpy安装了，一般来说安装就是pip命令。

1pip install numpy#py2

2pip3 install numpy#py3

用法则是

1importnumpyasnp# 一般as为np来操作

三、常用用法总结

１．array基本信息以及生成各种常见array基本操作

生成array，得到对应的基本信息

1importnumpyasnp

2

3array = np.array([[1,2,3],

4[2,3,4]])

5

6printarray#numpy生成的array

7printarray.dtype# 每个元素的类型

8print"number of dim", array.ndim# array的维度

9print'shape:', array.shape#形状，　两行三列。

10print'size:', array.size#array的大小＝array中所有元素的个数

11"""

12[[1 2 3]

13[2 3 4]]

14int64

15number of dim 2

16shape: (2, 3)

17size: 6

18"""

array的生成就是np.array(list)，本质上是把定义的list转换成array，因为array可以进行更加方便地计算和操作，比如矩阵的转置和相乘。

array的dtype设置

1importnumpyasnp

2

3a = np.array([2,23,4], dtype=np.float32)

4print"a's dtype", a.dtype

5aa = np.array([2,23,4], dtype=np.int)

6print"aa's dtype", aa.dtype

7aaa = np.array([2,23,4])

8print"aaa's dtype", aaa.dtype

9aaaa = np.array([2.2,23.2,4.2])

10print"aaaa's dtype", aaaa.dtype

11aaaaa = np.array([2,23,4], dtype=np.int64)

12print"aaaaa's dtype:", aaaaa.dtype

13

14"""

15a's dtype float32

16aa's dtype int64

17aaa's dtype int64

18aaaa's dtype float64

19aaaaa's dtype: int64

20"""

由可以得到一个结论就是如果定义的array里面的list的元素本身为整数的话，不设置type，则默认为int64,如果设置为int类型而没有设置字节大小则还是默认为int64,如果元素本身为小数，则默认为float64。

所以如果用int64，则如果元素都为整数则不需要设置默认即可，设置其他类型需要设置，float类似。

生成常见array格式

1a1 = np.zeros((2,3), dtype=np.int)# 生成shape=(2, 3)的全为0的array

2

3printa1

4"""

5[[0 0 0]

6[0 0 0]]

7"""

8

9a2 = np.ones((3,4), dtype=np.int16)# 生成shape=(3, 4)的全为1的array

10

11printa2

12"""

13[[1 1 1 1]

14[1 1 1 1]

15[1 1 1 1]]

16"""

这里注意shape=(a,b)，在填入shape的参数的时候一定要加括号，以下雷同。

1a3 = np.empty((3,4))#  生成shape=(3, 4)的全为接近空的array

2printa3

3"""

4[[6.92259773e-310 4.67497449e-310 6.92259751e-310 6.92259750e-310]

5[2.37151510e-322 3.16202013e-322 0.00000000e+000 6.92257087e-310]

6[6.92259748e-310 6.92257087e-310 6.92257063e-310 6.92257063e-310]]

7"""

8a4 = np.arange(10,20,2)# 生成array　10到20　每隔2的一增加，for循环中主要使用

9printa4

10"""

11[10 12 14 16 18]

12"""

13

14a5 = np.arange(12)# 生成array　０到12-1=11　每一个增加，for循环中非常常用

15printa5

16"""

17[ 0  1  2  3  4  5  6  7  8  9 10 11]

18"""

19

20a6 = np.arange(12).reshape((3,4))# 这里主要展示reshape的功能，能够重新定义矩阵的形状

21printa6

22"""

23[[ 0  1  2  3]

24[ 4  5  6  7]

25[ 8  9 10 11]]

26"""

27# 1和10之间４个元素越过，这个主要应用在插值运算或者matplotlib画光滑曲线的时候计算用到。

28a7 = np.linspace(1,10,4).reshape((2,2))

29

30printa7

31"""

32[[ 1.  4.]

33[ 7. 10.]]

34

35"""

２．array之间的计算

加减法

相同维度:

1importnumpyasnp

2

3a = np.array([10,20,30,40])

4b = np.arange(4)

5print"a:", a

6print"b:", b

7c = a+b

8print"c:", c

9c1 = a-b

10print"c1:", c1

11"""

12a: [10 20 30 40]

13b: [0 1 2 3]

14c: [10 21 32 43]

15c1: [10 19 28 37]

16"""

不同维度:

1aa = np.array([[1,2,3,4],

2[11,22,33,44]])

3

4bb = np.arange(4)

5

6print"aa:", aa

7print"bb:", bb

8print"a+b:", aa+bb

9

10"""

11aa:   [[ 1  2  3  4]

12[11 22 33 44]]

13bb:    [0 1 2 3]

14a+b:   [[ 1  3  5  7]

15[11 23 35 47]]

16"""

如果是不同维度的array进行加减法的话，程序就是把维度低的array自动复制扩展到大维度的array,进行相加 当然前提条件是两个不同维度的array进行相加的时候，低维度的array的shape也要和高维度的array其中一个shape相同，例如上面代码所示，(2,4) (1,4) 都有个shape为４

乘除法

1d = np.array([[1,2],

2[3,4]])

3e = np.arange(1,8,2).reshape((2,2))

4print"d:", d

5print"e:", e

6

7print"d*e:", d*e#对应元素相乘

8print"d/e", d/e#对应元素相除，因为是int64类型所以类似于2/3=0

9"""

10d: [[1 2]

11[3 4]]

12e: [[1 3]

13[5 7]]

14d*e: [[ 1  6]

15[15 28]]

16d/e [[1 0]

17[0 0]]

18"""

不同纬度的乘除法和上面加减法解析情况一样，可对比来看。

平方，三角函数，比较元素大小

1a = np.array([10,20,30,40])

2b = np.arange(4)

3c2 = b**2# 平方

4print"c2:", c2

5

6c3 =10*np.sin(a)#　sin函数

7print"c3:", c3

8"""

9c2: [0 1 4 9]

10c3: [-5.44021111  9.12945251 -9.88031624  7.4511316 ]

11"""

12print"b:", b

13print"b:", b <3#　b中小于３的都为TRUE

14print"b:", b ==3# b中等于３的为TRUE

15"""

16b: [0 1 2 3]

17b: [ True  True  True False]

18b: [False False False  True]

19

20"""

矩阵相乘

1d = np.array([[1,2],

2[3,4]])

3e = np.arange(1,8,2).reshape((2,2))

4print"d:", d

5print"e:", e

6printnp.dot(d, e)

7printd.dot(e)

8"""

9d: [[1 2]

10[3 4]]

11e: [[1 3]

12[5 7]]

13[[11 17]     #例如１１　为1*1+2*5=11

14[23 37]]

15[[11 17]

16[23 37]]

17

18"""

np.dot(d, e) 与d.dot(e)一样，都为d和e进行矩阵相乘

随机数和max,min,sum

1f = np.random.random((2,4))#随机产生shape为（２，４）的一个array，每个元素都为0-1之间随机生成

2printf

3print"=------="

4printnp.sum(f)

5printnp.min(f)

6printnp.max(f)

7"""

8[[0.11027523 0.84841991 0.59866992 0.92557867]

9[0.99917522 0.2771565  0.25578198 0.06671013]]

10=------=

114.081767552987877

120.06671012832269874

130.9991752153886827

14"""

15print"============="

16printnp.sum(f, axis=0)

17printnp.min(f, axis=1)

18printnp.max(f, axis=0)

19"""

20[1.10945044 1.12557641 0.8544519  0.9922888 ]

21[0.11027523 0.06671013]

22[0.99917522 0.84841991 0.59866992 0.92557867]

23"""

顾名思义，sum为总，min为最小，max为最大，如果不设置axis维度参数的话，则都为整个array的元素来说，但一般我们运用都只是算某个维度的sum,max,min，在二维数据中，axis=0代表行，第一个维度，axis=1，代表列为第二个维度，其实这么记并不是很好很有可能记错，我一般都是这么记得：axis=0为行，那意思就是每一行都要算呗？算完那不就是一列的每一行算个数被，axis=1类推，多维数据类推即可

矩阵转置和排序，以及元素比较大小重置元素方法

1c = np.arange(14,2,-1).reshape((3,4))

2

3printc

4print"sort:", np.sort(c)# 每一行进行重新大小排序当然也有axis参数配置，根据我的axis参数说明来操作

5

6printnp.transpose(c)#转置　同下面操作

7printc.T#　转置　同上面操作

8

9print"clip:",np.clip(c,5,9)#c矩阵中的元素小于５的等于５，大于９的等于９

10"""

11[[14 13 12 11]

12[10  9  8  7]

13[ 6  5  4  3]]

14sort: [[11 12 13 14]

15[ 7  8  9 10]

16[ 3  4  5  6]]

17[[14 10  6]

18[13  9  5]

19[12  8  4]

20[11  7  3]]

21[[14 10  6]

22[13  9  5]

23[12  8  4]

24[11  7  3]]

25clip: [[9 9 9 9]

26[9 9 8 7]

27[6 5 5 5]]

28"""

平均值、中值，累加，后减前

1a = np.arange(2,14).reshape((3,4))

2print"a:", a

3print"average:", np.average(a)#平均值

4print"median:", np.median(a)#中值

5

6print"cumsum:", np.cumsum(a)#每个元素变成当前元素＋前面所有元素的和

7print"diff:", np.diff(a)#当前元素减去前面元素的差

8"""

9a: [[ 2  3  4  5]

10[ 6  7  8  9]

11[10 11 12 13]]

12average: 7.5

13median: 7.5

14cumsum: [ 2  5  9 14 20 27 35 44 54 65 77 90]

15diff: [[1 1 1]

16[1 1 1]

17[1 1 1]]

18"""

３．索引

最大值最小值索引，非零索引

1a = np.array([[2,6,0,4],

2[4,8,9,1],

3[10,2,3,11]])

4print"argmin:", np.argmin(a)

5print"axis0:", np.argmin(a, axis=0)

6print"axis1:", np.argmin(a, axis=1)

7print"argmax:", np.argmax(a)

8print"zero:", np.nonzero(a)

9

10"""

11argmin: 2

12axis0: [0 2 0 1]

13axis1: [2 3 1]

14argmax: 11

15zero: (array([0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2]), array([0, 1, 3, 0, 1, 2, 3, 0, 1, 2, 3]))

16"""

argmin/argmax都是返回最小值/最大值的索引的函数。

这里的axis和上面的分析是完全一致的，例如argmin(a)就是最小的索引，虽小的毋庸置疑是０，所以总体来讲从第一行第一个元素到最后一行最后一个元素，总体来算索引，那就是第二个为０，所以返回２，如果axis=0说明一列中的每一行来比较，那第一列比较出来最小的为２，即索引为０，因为每一列的每一行来比较所以最后的维度为列数，在这里即为４，以此列推。

 非零索引的意思为非零的数返回索引，如上例为返回两个array，前面array对应行索引，后面对应列索引，一前一后加一起的shape才对应一个非零索引

取值，取列或行

1importnumpyasnp

2

3a = np.arange(3,15).reshape((3,4))

4

5printa

6printa[1]#索引为1的行，同下

7printa[:][1]#索引为1的行，同上

8print"=========-------==========="

9printa[2][1]#和数组一样的表示 

10printa[2,1]#同上，这才是比较标准的array的索引表示，前面是行后面是列的索引

11print"=========---------============"

12printa[:,1]#索引为１的列,生成为行向量

13printa[:,1:2]#索引为１的列，生成为列向量

14printa[:,1:3]

15

16printa[1,1:3]#为上面a[:, 1:3]的索引为１的行向量

17"""

18[[ 3  4  5  6]

19[ 7  8  9 10]

20[11 12 13 14]]

21[ 7  8  9 10]

22[ 7  8  9 10]

23=========-------===========

2412

2512

26=========---------============

27[ 4  8 12]

28[[ 4]

29[ 8]

30[12]]

31[[ 4  5]

32[ 8  9]

33[12 13]]

34[8 9]

35"""

着重讲一下　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]　#索引为１的列，生成为列向量

因为两种取值的思想不一样，最终造成的结果也不一样，一个是直接取，所以维度减少了一个，另一个是在原本维度上截取，最终还是原来的维度。

迭代元素和降维

1a = np.arange(3,15).reshape((3,4))# 数据都是下取上差一个取到。

2printa

3print"row"

4forrowina:#取每一行迭代

5printrow

6print"column"

7forcolumnina.T:#每一列迭代

8printcolumn

9print"====================="

10printa.flatten()# 所有元素变成一维

11b = np.array([[1,2,3]])

12printb

13printb.flatten()#降维

14

15foritemina.flat:#每个元素打印

16printitem

17

18"""

19[[ 3  4  5  6]

20[ 7  8  9 10]

21[11 12 13 14]]

22row

23[3 4 5 6]

24[ 7  8  9 10]

25[11 12 13 14]

26column

27[ 3  7 11]

28[ 4  8 12]

29[ 5  9 13]

30[ 6 10 14]

31=====================

32[ 3  4  5  6  7  8  9 10 11 12 13 14]

33[[1 2 3]]

34[1 2 3]

353

364

375

386

397

408

419

4210

4311

4412

4513

4614

47"""

行迭代，就是可以理解为最外层的维度进行迭代，列迭代就是利用转置来完成。

flatten()函数的意思为把array的内层的维度进行降一维，将内层的维度弄掉，则二维数据就成为一维数据了

４．合并与分开

两个合并、多个合并（行向量转换成列向量）

1# -*- coding: utf-8 -*-

2importnumpyasnp

3

4a = np.array([1,1,2])

5b = np.array([2,3,4])

6

7c = np.vstack((a, b))#vertical

8

9print"a:", a

10print"b:", b

11print"c:", c

12print"a,c shape:", a.shape, c.shape

13

14d = np.hstack((a, b))#horizontal

15print"d:", d

16printd.shape

17"""

18a: [1 1 2]

19b: [2 3 4]

20c: [[1 1 2]

21[2 3 4]]

22a,c shape: (3,) (2, 3)

23d: [1 1 2 2 3 4]

24(6,)

25"""

26printa.T# not transponse　行向量无法直接用转置来变成列向量

27# 行向量变成列向量

28printa[np.newaxis, :].shape

29printa[:, np.newaxis].shape

30printa[:, np.newaxis]#转换方法

31"""

32[1 1 2]

33(1, 3)

34(3, 1)

35[[1]

36[1]

37[2]]

38"""

39a = np.array([1,1,2])[:, np.newaxis]

40b = np.array([2,3,4])[:, np.newaxis]

41

42c = np.concatenate((a, b, b), axis=0)#多向量融合 

43

44printc

45

46c = np.concatenate((a, b, b), axis=1)#多向量融合

47

48printc

49

50"""

51[[1]

52[1]

53[2]

54[2]

55[3]

56[4]

57[2]

58[3]

59[4]]

60[[1 2 2]

61[1 3 3]

62[2 4 4]]

63"""

分开

1# -*- coding: utf-8 -*-

2importnumpyasnp

3

4a = np.arange(12).reshape((3,4))

5

6printa

7print"平等分开"

8print"vertical:", np.split(a,2, axis=1)#

9

10print"horizontal:", np.split(a,3, axis=0)#

11"""

12[[ 0  1  2  3]

13[ 4  5  6  7]

14[ 8  9 10 11]]

15平等分开

16vertical: [array([[0, 1],

17[4, 5],

18[8, 9]]), array([[ 2,  3],

19[ 6,  7],

20[10, 11]])]

21horizontal: [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]

22"""

23print"不平等分开"

24printnp.array_split(a,3, axis=1)

25

26print"代替需要axis参数"

27print"vertical_a:", np.vsplit(a,3)

28

29print"horizontal_a:", np.hsplit(a,2)

30"""

31不平等分开

32[array([[0, 1],

33[4, 5],

34[8, 9]]), array([[ 2],

35[ 6],

36[10]]), array([[ 3],

37[ 7],

38[11]])]

39代替需要axis参数

40vertical_a: [array([[0, 1, 2, 3]]), array([[4, 5, 6, 7]]), array([[ 8,  9, 10, 11]])]

41horizontal_a: [array([[0, 1],

42[4, 5],

43[8, 9]]), array([[ 2,  3],

44[ 6,  7],

45[10, 11]])]

46"""

５．元素传递和copy

1b = np.arange(4)

2

3printb

4c = b

5e = c

6d = e

7b[0] =11

8printb

9

10printcisb

11printdisb

12printb[0]

13

14d[1:3] = [22,22]

15printb

16printc

17

18c = b.copy()

19

20b[3] =44

21

22printb

23printc

24printe

25"""

26[0 1 2 3]

27[11  1  2  3]

28True

29True

3011

31[11 22 22  3]

32[11 22 22  3]

33[11 22 22 44]

34[11 22 22  3]

35[11 22 22 44]

36"""

array这个元素传递有点意思的，就是如果直接a=b，其实从内存角度来考虑就相当于a和b指向了一样的元素内存空间，所以改变一个元素的值，另一个一样改变，如果想各是各的，并且还想传递另一个元素的值那就用a=b.copy()，所以这个还是需要注意的

6.补充部分

array.min/max/ptp

1importnumpyasnp

2

3a = [[2,4,8,9], [1,7,4,5], [5,7,1,4]]

4a = np.array(a)

5print(a)

6print(a.min(0))

7print(a.min(1))

8print(a.ptp(0))

9"""

10[[2 4 8 9]

11[1 7 4 5]

12[5 7 1 4]]

13axis=0 为每列的最小值返回

14[1 4 1 4]

15axis=1 为每行的最小值返回

16[2 1 1]

17ptp为最大值减最小值的range

18[4 3 7 5]

19"""

np.random.choice

1importnumpyasnp

2

3a = np.random.choice(a=100, size=20)

4print(a)

5"""

60-99之间选size为20的随机数的list

7[78 82 91 96  5 60 28 79 24 56  5 34 58 48 96 57 77 23 80 69]

8"""