python数据处理之numpy和pandas(上)

python数据处理之numpy和pandas(上)

前言:

学习python的基本语法已经半月了,对基本的语句操作也有所熟悉,在学习中主要参考的是廖雪峰老师的python教程,感觉受益很多,文章下面各方前辈的评论也是很好的学习教程,能让我知道错误的原因和解决方法。网址为:https://www.liaoxuefeng.com/wiki/0014316089557264a6b348958f449949df42a6d3a2e542c000。最近也一直在看前百度人工智能首席专家吴恩达老师在网易云课堂上免费开放的《神经网络和机器学习》课程,地址为:http://study.163.com/my#/smarts目前已经进行三周,对两层神经网络以及正反向传播都有些了解了,磨刀不误砍柴工,考过研的都明白一句话,基础不牢,地动山摇!所以我还是想着跟着一个老师或者前辈将python中一些常用的库学习一下。
偶然间在知乎上看到莫烦老师的网站主打python,又恰逢今年毕业的师兄所入职的南京烽火,校招网址:http://njau.91job.gov.cn/campus/view/id/674916对TensorFlow和caffe等有所要求,以及神经网络KNN和CNN方面也有要求,我也在知乎上和其他地方询问一些前辈,烽火公司还是很符合我的预期,所以自己也朝着这方面自学,以求毕业的时候能够达到烽火的招聘标准吧。哈哈,说了这么多,现在就开始吧!

numpy:

数据处理方面,python简直是最好用的语言工具,numpy和pandas是其数据处理最好用的“臂膀”。在开始之前,Windows和Linux用户建议您安装anaconda3,免去了后续一些基本包的安装,也减少了出错几率。神经网络最最基本的运算时来自于矩阵运算。第一步我们开始进行一个矩阵的赋值,显示和规格参数描述,在此之前,我默然您也跟我一样有过其他的语言的基础,也有python的基础。

1.矩阵赋值和规格参数显示


  
  
  1. import numpy as np
  2. A = np.array([[ 1, 2, 3],
  3. [ 2, 3, 4]])
  4. print(A)
导入 numpy 库简写为 np, 利用 np.array() 来进行赋值,注意,一个 2 行 3 列的矩阵应该是 [[1,1,1],[1,1,1]], 最外面是有一对方括号的。那么输出结果自 然为:

  
  
  1. [[ 1 2 3]
  2. [ 2 3 4]]
接着我们需要探查一下矩阵的维度,类型和元素个数:

  
  
  1. print( 'number of dim:',A.ndim)
  2. print( 'shape:',A.shape)
  3. print( 'size:',A.size)
则结果相对应的为:

  
  
  1. number of dim: 2
  2. shape: ( 2, 3)
  3. size: 6

接下来是创建矩阵,注意啊,创建矩阵是通过函数赋值,而上面赋值矩阵是咱们自己赋值给矩阵空间的。


  
  
  1. import numpy as np
  2. A = np.array([[ 2, 2.3, 4],
  3. [ 2, 3.2, 4]])
  4. A0 = np.zeros(( 3, 4))
  5. A1 = np.ones(( 2, 3),dtype=np.int16)
  6. Amin = np.empty(( 3, 4))
  7. Arange = np.arange( 12).reshape(( 3, 4))
  8. Aline = np.linspace( 1, 10, 6).reshape(( 2, 3))
  9. print(A)
  10. print(A0)
  11. print(A1)
  12. print(Amin)
  13. print(Arange)
  14. print(Aline)

下面来解释这段numpy的使用。A是赋值矩阵,也就是前面提到的,A0就是将矩阵的每个元素都设为0,后面的(3,4)即3行4列,完全可以根据自身需要去设置一个全零的任意行任意列的矩阵。A1是设置矩阵元素为全1,(2,3)与之同理,注意后面的dtype,这是设置矩阵的元素的数据类型,可以为整型int,64位,32位和16位等,也可以是浮点型float长度同前,这个根据自身处理数据的需要来进行设定。Amin是建立一个近似于0的最小数的矩阵,可以快速的进行内存空间的分配。Arange是创建一个(3,4)的矩阵,数值为0-11共12个数,也可以设置为一个区间,但数量必须和reshape的矩阵元素个数相同。Aline是进行线段化一段数据,如上1-10之间分六段,这六段的结构为(2,3)的矩阵。这就是矩阵创建的相关知识。运行结果如下所示:


  
  
  1. [[ 2. 2.3 4. ]
  2. [ 2. 3.2 4. ]]
  3. [[ 0. 0. 0. 0.]
  4. [ 0. 0. 0. 0.]
  5. [ 0. 0. 0. 0.]]
  6. [[ 1 1 1]
  7. [ 1 1 1]]
  8. [[ 0. 0. 0. 0.]
  9. [ 0. 0. 0. 0.]
  10. [ 0. 0. 0. 0.]]
  11. [[ 0 1 2 3]
  12. [ 4 5 6 7]
  13. [ 8 9 10 11]]
  14. [[ 1. 2.8 4.6]
  15. [ 6.4 8.2 10. ]]

2.numpy基础运算



矩阵运算时数据运算的基础,下面来进行一些简单的矩阵数据运算:

  
  
  1. import numpy as np
  2. a = np.array([ 10, 20, 30, 40])
  3. b = np.arange( 4)
  4. print(a,b)
  5. print(a> 20,b< 3)
  6. c = a-b
  7. d = a+b
  8. e = a*b
  9. f = b** 2
  10. g = 10*np.sin(a) #cos tan等
  11. print(c)
  12. print(d)
  13. print(e)
  14. print(f)
  15. print(g)
在一个矩阵中,如果想设定阈值找到哪几个元素是大小某值,小于某值或者等于某值的时候,可以直接写成(print(a>T)或者(print(a<T))或(print(a==T))),这样就会返回与a相同维数的矩阵,里面的值是布尔类型,即满足条件为True,否则为False。两个矩阵相加减与int类型数据相加同样,这里两个矩阵相乘并不是线性代数中矩阵相乘,而是各个元素之间分别相乘,若是矩阵相乘,则需要使用no.dot(),下一例中有所涉及。求一个矩阵中所有元素的平方为f =b**2,三次方为b**3,求某个数值的三角函数直接用np.sin(),np.cos()等等。
运算结果为:

  
  
  1. [ 10 20 30 40] [ 0 1 2 3]
  2. [ False False True True] [ True True True False]
  3. [ 10 19 28 37]
  4. [ 10 21 32 43]
  5. [ 0 20 60 120]
  6. [ 0 1 4 9]
  7. [ -5.44021111 9.12945251 -9.88031624 7.4511316 ]
线性代数中矩阵的运算:

  
  
  1. import numpy as np
  2. a = np.array([[ 1, 1],
  3. [ 0, 1]])
  4. b = np.arange( 4).reshape( 2, 2)
  5. print(a)
  6. print(b)
  7. c = a*b
  8. c_dot = np.dot(a,b)
  9. c_dot_1 = a.dot(b)
  10. print(c)
  11. print(c_dot)
  12. print(c_dot_1)

这里两个矩阵进行线性代数中的乘法运算,有两种方式,第一种是np.dot(a,b),第二种为a.dot(b),运算结果如下:

  
  
  1. [[ 1 1]
  2. [ 0 1]]
  3. [[ 0 1]
  4. [ 2 3]]
  5. [[ 0 1]
  6. [ 0 3]]
  7. [[ 2 4]
  8. [ 2 3]]
  9. [[ 2 4]
  10. [ 2 3]]
求矩阵中某一行某一列中数值已经某行某列求和:

  
  
  1. import numpy as np
  2. a = np.random.random(( 2, 4))
  3. print(a)
  4. print(np.sum(a))
  5. print(np.max(a))
  6. print(np.min(a))
  7. print(np.sum(a,axis= 1))
  8. print(np.min(a,axis= 0))
  9. print(np.min(a,axis= 1))
这里面,根据函数的名字就能直观了解功能,需要强调的是,axis的赋值问题,axis=0就是关注的某一列的问题,axis=1就是关注的某一行的问题。经过编译输出结果为:

  
  
  1. [[ 0.2706944 0.48027564 0.00835308 0.83170055]
  2. [ 0.31429675 0.54158937 0.87013878 0.25754769]]
  3. 3.57459626981
  4. 0.870138784946
  5. 0.00835308363163
  6. [ 1.59102368 1.98357259]
  7. [ 0.2706944 0.48027564 0.00835308 0.25754769]
  8. [ 0.00835308 0.25754769]

3.numpy中的一些内置函数


以下介绍一些numpy本身自带的数据处理函数:


  
  
  1. import numpy as np
  2. a = np.arange( 2, 14).reshape(( 3, 4))
  3. print(a)
  4. print(np.argmin(a)) #最小索引值
  5. print(np.argmax(a))
  6. print(np.mean(a)) #与下一行代码相同
  7. print(a.mean())
  8. print(np.mean(a,axis= 0))
  9. print(np.median(a)) #中位数
  10. print(np.cumsum(a)) #第i个数是前i个数相加
  11. print(np.diff(a)) #累差,i=i+1-i
  12. #print(np.nonzero(a))
  13. print(np.transpose(a)) #矩阵的转置,行变列,同下
  14. print(a.T)
  15. print(np.clip(a, 5, 9)) #阈值控制,大于某值就为某值,小于类似
以上函数中,np.argmin和np.argmax为索引函数,即找到最小最大值得位置在哪,返回int型位置数,求均值可以用np.mean()与a.mean()类似,其中要想求出每一行或者每一列的均值只需要对axis进行赋值0,1即可。np.median求中间数,虽然在此程序中与mean函数得到的结果是一样的,但意义不同,median求得是矩阵最中间的数值而不是平均值。np.cumsum是累加求和函数,即第i个数是前i个数相加得来的结果,而np.diff是累差,第i和数是后面一个数减去i自身得来的新的数。np.transpose是矩阵转置函数,即行变列,列变行,其结果和(a,T)一样,np.clip是阈值函数,即大于某值的数统统等于那个值,小于某值的数统统等于此值。函数功能介绍完毕,下面展示运行结果:


  
  
  1. [[ 2 3 4 5]
  2. [ 6 7 8 9]
  3. [ 10 11 12 13]]
  4. 0
  5. 11
  6. 7.5
  7. 7.5
  8. [ 6. 7. 8. 9.]
  9. 7.5
  10. [ 2 5 9 14 20 27 35 44 54 65 77 90]
  11. [[ 1 1 1]
  12. [ 1 1 1]
  13. [ 1 1 1]]
  14. [[ 2 6 10]
  15. [ 3 7 11]
  16. [ 4 8 12]
  17. [ 5 9 13]]
  18. [[ 2 6 10]
  19. [ 3 7 11]
  20. [ 4 8 12]
  21. [ 5 9 13]]
  22. [[ 5 5 5 5]
  23. [ 6 7 8 9]
  24. [ 9 9 9 9]]









评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值