关于python机器学习基础之numpy的基础用法的总结

写在前面：以下代码为python代码，笔者使用的是python3.7版本，需要用到的模块有numpy，如果需要实践请自行下载此模块。

一、文章背景

       由于近几年人工智能的发展，python这门解释性编程语言非常火爆，对于人工智能初步的学习总是由矩阵说起，当然对于矩阵的处理也不单单是用作人工智能，因此矩阵的处理非常有必要学习，笔者当然知道matlab可以用来做矩阵的处理，那既然有matlab，我们何必用python呢？我不否认读者用matlab去处理矩阵，但是，matlab软件众所周知是：1. 需要付费，而且不是很便宜；2.非常的大，安装包足足有20G左右；3. 对电脑配置要求较高。针对以上三点，为了解决这些问题，我们选择使用python中numpy这个模块进行矩阵处理，希望读者可以理解。此博客和之前的两篇博客不同的是，此博客并不是设计类，而实numpy基础知识的学习。
 

二、生成矩阵的常规操作

       在一切都开始之前我们得先导入模块，python中导入模块用使用import即可

	import numpy

 
方法一：直接输入法

	v1 = numpy.array([5, 10, 15, 20])
	v2 = numpy.array([[5, 1, 0, 2], [2, 3, 4, 1]])

结果

	v1：
		[5 10 15 20]
	v2：
		[[5 1 0 2]
 		 [2 3 4 1]]

方法二：使用arange函数

	ary1 = numpy.arange(15)
	ary2 = ary1.reshape(3, 5)
	ary3 = numpy.arange(0, 21, 5)

       看到这些东西，大家可能并不知道是用来干什么的，现在笔者按照自己的理解给大家一一解释一下，首先第一句话我们就是应用了numpy里面的arange，括号里面是15意思就是产生了一个1 * 15的一行数，分别是从0 - 14，大家接触程序也已经很久了肯定是知道在编程语言中基本都是从0开始计数，第二行reshape是什么意思呢？这一个英语单词即使我们不认识，我们应该也可以猜出来，这句话在这里的意思是将ary1由1 * 15变化为3 * 5的一个矩阵，废话不多说，第三行的意思是从0开始到21结束，中间间隔为5的所有数的集合，那么如果你理解了，就看下面的结果，看看和你自己算出来的一样吗？

	ary1:
		[0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
	ary2:
		[[ 0  1  2  3  4]
 		 [ 5  6  7  8  9]
 		 [10 11 12 13 14]]
 	ary3:
 		[0  5 10 15 20]

方法三：使用linspace去创建

	l1 = numpy.linspace(0, 5*numpy.pi, 100)
	l2 = l1.reshape(20, 5)

       对于reshape就不多加说明了，这里说一下linspace里面的三个数，简单来说就是前两个数规定了上下限，第三个数表示一共在这两个数内等间距的取多少个数，numpy.pi就是圆周率的意思，由于100个数太多了，结果只显示 l2 的，理解上述所说之后请看如下结果。

	l2:
        [[ 0.          0.1586663   0.31733259  0.47599889  0.63466518]
         [ 0.79333148  0.95199777  1.11066407  1.26933037  1.42799666]
         [ 1.58666296  1.74532925  1.90399555  2.06266184  2.22132814]
         [ 2.37999443  2.53866073  2.69732703  2.85599332  3.01465962]
         [ 3.17332591  3.33199221  3.4906585   3.6493248   3.8079911 ]
         [ 3.96665739  4.12532369  4.28398998  4.44265628  4.60132257]
         [ 4.75998887  4.91865516  5.07732146  5.23598776  5.39465405]
         [ 5.55332035  5.71198664  5.87065294  6.02931923  6.18798553]
         [ 6.34665183  6.50531812  6.66398442  6.82265071  6.98131701]
         [ 7.1399833   7.2986496   7.45731589  7.61598219  7.77464849]
         [ 7.93331478  8.09198108  8.25064737  8.40931367  8.56797996]
         [ 8.72664626  8.88531256  9.04397885  9.20264515  9.36131144]
         [ 9.51997774  9.67864403  9.83731033  9.99597663 10.15464292]
         [10.31330922 10.47197551 10.63064181 10.7893081  10.9479744 ]
         [11.10664069 11.26530699 11.42397329 11.58263958 11.74130588]
         [11.89997217 12.05863847 12.21730476 12.37597106 12.53463736]
         [12.69330365 12.85196995 13.01063624 13.16930254 13.32796883]
         [13.48663513 13.64530142 13.80396772 13.96263402 14.12130031]
         [14.27996661 14.4386329  14.5972992  14.75596549 14.91463179]
         [15.07329809 15.23196438 15.39063068 15.54929697 15.70796327]]

方法四：应用random去创建

	r1 = numpy.random.random(6)
	r2 = r1.reshape(2, 3)
	r3 = numpy.random.random((2, 3))

       接下来将解释一下random具体含义，从单词意思上去看就是创建随机数的意思，这里需要说明的是使用random创建的随机数均在0和1之间，如上述代码 r1 和 r2 两个步骤，相当于 r3 这一个步骤，由于是随机的，所以这里显示的结果无参考价值。

r1:
	[0.65426524 0.74149256 0.85758724 0.04061725 0.42513048 0.34153109]
r2:
	[[0.65426524 0.74149256 0.85758724]
 	 [0.04061725 0.42513048 0.34153109]]
r3:
	[[0.95320346 0.23472479 0.12991534]
 	 [0.43021892 0.12763831 0.89084107]]

方法五：创建全0矩阵和全1矩阵

    z1 = numpy.zeros(15)
    z2 = z1.reshape(3, 5)
    z3 = numpy.zeros((3, 5))
    o1 = numpy.ones((3, 5)
    o2 = numpy.ones((3, 5), dtype = numpy.int32)
    o3 = numpy.ones((3, 4, 5), dtype = numpy.int32)

       和random类似的写法0就是zero，1就是one，这里大家可能不理解的地方有dtype和o3里第一个括号，我一个一个说，首先，声明一点是zeros和ones生成的都是float类型的变量，如果我们需要改一下数据类型，我们在括号里声明就行，接下来解决第二个问题，其实o3和o2本质是一样的，o2中是（3，5）o3中是（3，4，5）可以理解为维度不同o2是一个二维的o3是一个三维的，理解以上之后请看结果。

	z1:
    	[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
    z2:
        [[0. 0. 0. 0. 0.]
         [0. 0. 0. 0. 0.]
         [0. 0. 0. 0. 0.]]
    z3
        [[0. 0. 0. 0. 0.]
         [0. 0. 0. 0. 0.]
         [0. 0. 0. 0. 0.]]
    o1:
        [[1. 1. 1. 1. 1.]
         [1. 1. 1. 1. 1.]
         [1. 1. 1. 1. 1.]]
    o2:
        [[1 1 1 1 1]
         [1 1 1 1 1]
         [1 1 1 1 1]]
    o3:
        [[[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 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]]]

三、矩阵的运算

       我们知道矩阵可以进行加运算，减运算，也可以进行点乘，也可以进行叉乘，矩阵的加减运算此处就不多说了，相应位置相加相减就行，可是矩阵的乘法运算是有两种形式的，那么我们在python中是如何表示的呢？一些解释性的语言在这里，可能解释之后也不太好理解，我们直接应用之前所掌握的创建矩阵去做一个实践然后去看结果，在这个过程中理解，实践代码如下：

	import numpy
    A1 = numpy.linspace(0, 5, 4)
    A1 = A1.reshape(2, 2)
    B1 = numpy.random.random((2, 2))
    print(A1)
    print(B1)
    # 向量的点乘
    print(A1 * B1)
    # 向量的叉乘第一种写法
    print(numpy.dot(A1, B1))
    # 向量的叉乘第二种写法
    print(A1.dot(B1))

结果

    [[0.         1.66666667]
     [3.33333333 5.        ]]
    [[0.30484861 0.64493797]
     [0.47079376 0.88976236]]
    [[0.         1.07489661]
     [1.56931254 4.44881179]]
    [[0.78465627 1.48293726]
     [3.37013084 6.59860501]]
    [[0.78465627 1.48293726]
     [3.37013084 6.59860501]]

       通过代码注释以及结果的分析相信你已经掌握了这片文章所讲的知识点了，熟能生巧，笔者还是希望读者可以多加练习这些基础知识。
 

四、最后的话

       本篇文章讲述的知识相对来说比较基础，也相对比较好懂，希望读者可以很好的掌握这些基础知识，发现错误的读者也可以加笔者QQ：2428425170，进行及时反馈，笔者是一个十分和蔼的人哦！