NumPy系统是Python的一种开源的数值计算扩展包,计

作者: 编程  发布:2019-11-29

这两天翻了一下机器学习实战这本书,算法是不错,只是代码不够友好,作者是个搞算法的,这点从代码上就能看出来。可是有些地方使用numpy搞数组,搞矩阵,总是感觉怪怪的,一个是需要使用三方包numpy,虽然这个包基本可以说必备了,可是对于一些新手,连pip都用不好,装的numpy也是各种问题,所以说能不用还是尽量不用,第二个就是毕竟是数据,代码样例里面写的只有几个case,可是实际应用起来,一定是要上数据库的,如果是array是不适合从数据库中读写数据的。因此综合以上两点,我就把这段代码改成list形式了,当然,也可能有人会说我对numpy很熟悉啊,而且作为专业的数学包,矩阵的运算方面也很方便,我不否定,那我这段代码恐怕对你不适合,你可以参考书上的代码,直接照打并理解就好了。

声明:本篇博文是学习《机器学习实战》一书的方式路程,系原创,若转载请标明来源。

NumPy

k-近邻算法

knn,不多说了,网上书上讲这个的一大堆,简单说就是利用新样本new_case的各维度的数值与已有old_case各维度数值的欧式距离计算

  1. K-近邻算法的一般流程:

k-近邻算法一般流程

  • 1收集数据:可以使用任何方法。
  • 2准备数据:距离计算所需要的数值,最好是结构化的数据格式。
  • 3分析数据:可以使用任何方法。
  • 4训练算法:此步骤不适用于k-近邻算法。
  • 5测试算法:计算错误率。
  • 6使用算法:首先需要输入样本数据和结构化的输入结果,然后运行k-近邻算法判定输入数据分别属于那个分类,最后应用对计算出的分类执行后续的处理。

9159.com 1

根据上图所示,有两类不同的样本数据,分别用蓝色的小正方形和红色的小三角形表示,而图正中间的那个绿色的圆所标示的数据则是待分类的数据。也就是说,现在, 我们不知道中间那个绿色的数据是从属于哪一类(蓝色小正方形or红色小三角形),下面,我们就要解决这个问题:给这个绿色的圆分类。

  • 如果K=3,绿色圆点的最近的3个邻居是2个红色小三角形和1个蓝色小正方形,少数从属于多数,基于统计的方法,判定绿色的这个待分类点属于红色的三角形一类。
  • 如果K=5,绿色圆点的最近的5个邻居是2个红色三角形和3个蓝色的正方形,还是少数从属于多数,基于统计的方法,判定绿色的这个待分类点属于蓝色的正方形一类。
    于此我们看到,当无法判定当前待分类点是从属于已知分类中的哪一类时,我们可以依据统计学的理论看它所处的位置特征,衡量它周围邻居的权重,而把它归为(或分配)到权重更大的那一类。这就是K近邻算法的核心思想。其关键还在于K值的选取,所以应当谨慎。

KNN算法中,所选择的邻居都是已经正确分类的对象。该方法在定类决策上只依据最邻近的一个或者几个样本的类别来决定待分样本所属的类别。

KNN 算法本身简单有效,它是一种 lazy-learning 算法,分类器不需要使用训练集进行训练,训练时间复杂度为0。KNN 分类的计算复杂度和训练集中的文档数目成正比,也就是说,如果训练集中文档总数为 n,那么 KNN 的分类时间复杂度为O(n)。

欧式距离这里也不说了,有兴趣可以去翻我那篇python_距离测量,里面写的很详细,并用符号展示说明,你也可以改成棋盘距离或街区距离试试,速度可能会比欧式距离快,但还是安利欧式距离。

(1)收集数据:可以使用任何方法(如爬虫)。

目录

python代码实现说明

科学计算包:numpy
运算符模块:operator

有一点没搞明白的就是,对坐标进行精度化计算这块,实测后确定使用直接计算无论是错误率还是精度,处理前都要比处理后更准确,可能原代码使用小数点的概率更高些吧,也许这个计算对于小数计算精度更有帮助

(2)准备数据:距离计算所需要的数值,最好是结构化的数据格式。

  1. 关于 numpy
  2. numpy 库
  3. numpy 基本操作
  4. numpy 复制操作
  5. numpy 计算
  6. numpy 常用函数

shape函数说明

shape函数是numpy.core.fromnumeric中的函数,它的功能是查看矩阵或者数组的维数

代码:

>>> a = array([[1,2,3],[5,6,9],[9,8,9]])
>>> a.shape
(3, 3)
>>> a.shape[0]
3

闲话一些,不多也不少,下面上代码,代码中配有伪代码,方便阅读,如果还看不太明白可以留言,我把详细注释加上

(3)分析数据:可以使用任何方法。

 

numpy.tile函数说明

函数形式:tile(A,rep)
功能:重复A的各个维度
参数类型:
A: Array类的都可以
rep:A沿着各个维度重复的次数

>>> a =array([[1,2,3],[5,6,9],[9,8,9]])
>>> tile(a,3)
array([[1, 2, 3, 1, 2, 3, 1, 2, 3],
       [5, 6, 9, 5, 6, 9, 5, 6, 9],
       [9, 8, 9, 9, 8, 9, 9, 8, 9]])
>>> tile(a,[3,2])
array([[1, 2, 3, 1, 2, 3],
       [5, 6, 9, 5, 6, 9],
       [9, 8, 9, 9, 8, 9],
       [1, 2, 3, 1, 2, 3],
       [5, 6, 9, 5, 6, 9],
       [9, 8, 9, 9, 8, 9],
       [1, 2, 3, 1, 2, 3],
       [5, 6, 9, 5, 6, 9],
       [9, 8, 9, 9, 8, 9]])
>>> tile(a,[2,2,3])
array([[[1, 2, 3, 1, 2, 3, 1, 2, 3],
        [5, 6, 9, 5, 6, 9, 5, 6, 9],
        [9, 8, 9, 9, 8, 9, 9, 8, 9],
        [1, 2, 3, 1, 2, 3, 1, 2, 3],
        [5, 6, 9, 5, 6, 9, 5, 6, 9],
        [9, 8, 9, 9, 8, 9, 9, 8, 9]],

       [[1, 2, 3, 1, 2, 3, 1, 2, 3],
        [5, 6, 9, 5, 6, 9, 5, 6, 9],
        [9, 8, 9, 9, 8, 9, 9, 8, 9],
        [1, 2, 3, 1, 2, 3, 1, 2, 3],
        [5, 6, 9, 5, 6, 9, 5, 6, 9],
        [9, 8, 9, 9, 8, 9, 9, 8, 9]]])

reps的数字从后往前分别对应A的第N个维度的重复次数。

如:

  • tile(A,3)表示A的第一个维度重复3遍。
  • tile(A,(3,2))表示A的第一个维度重复2遍,然后第二个维度重复3遍。
  • tile(A,(2,2,3))表示A的第一个维度重复3遍,第二个维度重复2遍,第三个维度重复2遍。

 

(4)测试算法:计算误差率。

1 关于numpy / About numpy

sum函数说明

函数形式:sum(axis = 0 or 1)
函数功能:没有axis参数表示全部相加,axis=0表示按列相加,axis=1表示按照行的方向相加(取‘厉害’谐音)

>>> b = tile(a,[3,2])
>>> b
array([[1, 2, 3, 1, 2, 3],
       [5, 6, 9, 5, 6, 9],
       [9, 8, 9, 9, 8, 9],
       [1, 2, 3, 1, 2, 3],
       [5, 6, 9, 5, 6, 9],
       [9, 8, 9, 9, 8, 9],
       [1, 2, 3, 1, 2, 3],
       [5, 6, 9, 5, 6, 9],
       [9, 8, 9, 9, 8, 9]])
>>> c = b.sum(axis = 0)
>>> c
array([45, 48, 63, 45, 48, 63])
>>> d = b.sum(axis = 1)
>>> d
array([12, 40, 52, 12, 40, 52, 12, 40, 52])
>>> e = b.sum()
>>> e
312
>>>

以下是代码中使用颜色,选用html的16进制RGB颜色,在应用时将其转换为10进制数字计算,old_case选取红色圈,new_case选取橙色圈

(5)使用算法:首先需要输入样本数据和结构化的输出结果,然后运行K-近邻算法判定输入数据分别属于哪个分类,最后应用对计算出的分类执行后续的处理。

NumPy系统是Python的一种开源的数值计算扩展包。这种工具可用来存储和处理大型矩阵,比Python自身的嵌套列表(nested list structure)结构要高效的多(该结构也可以用来表示矩阵(matrix))。据说NumPy将Python相当于变成一种免费的更强大的MatLab系统。参考官网解释,

argsort函数说明

函数形式:argsort(x) or x.argsort()
参数功能:argsort函数返回的是数组值从小到大的索引值

>>> x = array([3,4,2,5,1,6])
#按升序排列
>>> x.argsort()
array([4, 2, 0, 1, 3, 5])
#按升序排列
>>> argsort(-x)
array([5, 3, 1, 0, 2, 4])
>>>

紫色(茄子颜色)

  1. K-近邻算法的伪代码和Python代码

NumPy is the fundamental package for scientific computing with Python. It contains among other things:

sort函数、sorted函数说明

函数形式:sorted(iterable,cmp,key,reverse)
函数功能:排序

  • sort对列表list进行排序,而sorted可以对list或者iterator进行排序

  • sort函数对列表list进行排序时会影响列表list本身,而sorted不会

参数类型:
iterable:是可迭代类型;
cmp:用于比较的函数,比较什么由key决定;
key:用列表元素的某个属性或函数进行作为关键字,有默认值,迭代集合中的一项;
reverse:排序规则. reverse = True 降序 或者 reverse = False 升序,有默认值。
返回值:是一个经过排序的可迭代类型,与iterable一样。

>>> a = [7,3,9,4,1]
>>> sorted(a)
[1, 3, 4, 7, 9]
>>> a
[7, 3, 9, 4, 1]
>>> a.sort()
>>> a
[1, 3, 4, 7, 9]

9159.com 2

对未知类别属性的数据集中的每个点依次执行以下操作:

  • a powerful N-dimensional array object
  • sophisticated (broadcasting) functions
  • tools for integrating C/C++ and Fortran code
  • useful linear algebra, Fourier transform, and random number capabilities

operator.itemgetter函数

>>> a = [1,2,3]
>>> b = operator.itemgetter(1)//定义函数b,获取对象的第1个域的值
>>> b(a)
2
>>> b = operator.itemgetter(0,1)//定义函数b,获取对象的第1个域和第0个的值
>>> b(a)
(1, 2)

源码

绿色(黄瓜颜色)

(1)计算已知类别数据集中的点与当前点之间的距离。

Besides its obvious scientific uses, NumPy can also be used as an efficient multi-dimensional container of generic data. Arbitrary data-types can be defined. This allows NumPy to seamlessly and speedily integrate with a wide variety of databases.

9159.com 3

(2)按照距离递增次序排序。

NumPy is licensed under the BSD license, enabling reuse with few restrictions.

黄色(香蕉颜色)

(3)选取与当前点距离最小的k个点。

一个用python实现的科学计算包。包括:

9159.com 4

(4)确定前k个点所在类别的出现频率。

  1. 一个强大的N维数组对象Array;
  2. 比较成熟的(广播)函数库;
  3. 用于整合C/C++和Fortran代码的工具包;
  4. 实用的线性代数、傅里叶变换和随机数生成函数。numpy和稀疏矩阵运算包scipy配合使用更加方便。

淡绿(西葫芦颜色)

(5)返回前k个点出现频率最高的类别作为当前点的预测分类。

NumPy(Numeric Python)提供了许多高级的数值编程工具,如:矩阵数据类型、矢量处理,以及精密的运算库。专为进行严格的数字处理而产生。多为很多大型金融公司使用,以及核心的科学计算组织如:Lawrence Livermore,NASA用其处理一些本来使用C++,Fortran或Matlab等所做的任务。

9159.com 5

程序代码:

广播法则(rule)

代码见下

def classify0(inX, dataSet, labels, k):
    dataSetSize = dataSet.shape[0]  
    diffMat = tile(inX, (dataSetSize,1)) - dataSet
    sqDiffMat = diffMat**2
    sqDistances = sqDiffMat.sum(axis=1)
    distances = sqDistances**0.5
    sortedDistIndicies = distances.argsort()     
    classCount={}          
    for i in range(k):
        voteIlabel = labels[sortedDistIndicies[i]]
        classCount[voteIlabel] = classCount.get(voteIlabel,0) + 1
    sortedClassCount = sorted(classCount.iteritems(), key=operator.itemgetter(1), reverse=True)
    return sortedClassCount[0][0]

广播法则能使通用函数有意义地处理不具有相同形状的输入。

#!/usr/bin//python
# coding: utf-8

'''
1、获取key和coord_values,样例使用的是list,但是如果真正用在训练上的话list就不适合了,建议改为使用数据库进行读取
2、对坐标进行精度化计算,这个其实我没理解是为什么,可能为了防止错误匹配吧,书上是这样写的
3、指定两个参数,参数一是新加入case的坐标,参数二是需要匹配距离最近的周边点的个数n,这里赢指定单数
4、距离计算,使用欧式距离
  新加入case的坐标与每一个已有坐标计算,这里还有优化空间,以后更新
  计算好的距离与key做成新的key-value
  依据距离排序
  取前n个case
5、取得key
  对前n个case的key进行统计
  取统计量结果最多的key即是新加入case所对应的分组
6、将新加入的values与分组写成key-value加入已有的key-value列队
输入新的case坐标,返回第一步......递归
'''

import operator

def create_case_list():
  # 1代表黄瓜,2代表香蕉,3代表茄子,4代表西葫芦
  case_list = [[25,3,73732],[27.5,8,127492],[13,6,127492],[16,13,50331049],[17,4,18874516],[22,8,13762774],[14,1,30473482],[18,3,38338108]]
  case_type = [1,1,2,2,3,3,4,4]
  return case_list,case_type

def knn_fun(user_coord,case_coord_list,case_type,take_num):
  case_len = len(case_coord_list)
  coord_len = len(user_coord)
  eu_distance = []
  for coord in case_coord_list:
    coord_range = [(user_coord[i] - coord[i]) ** 2 for i in range(coord_len)]
    coord_range = sum(coord_range) ** 0.5
    eu_distance.append(coord_range)
  merage_distance_and_type = zip(eu_distance,case_type)
  merage_distance_and_type.sort()
  type_list = [merage_distance_and_type[i][1] for i in range(take_num)]
  class_count = {}
  for type_case in type_list:
    type_temp = {type_case:1}
    if class_count.get(type_case) == None:
      class_count.update(type_temp)
    else: class_count[type_case] += 1
  sorted_class_count = sorted(class_count.iteritems(), key = operator.itemgetter(1), reverse = True)
  return sorted_class_count[0][0]

def auto_norm(case_list):
  case_len = len(case_list[0])
  min_vals = [0] * case_len
  max_vals = [0] * case_len
  ranges = [0] * case_len
  for i in range(case_len):
    min_list = [case[i] for case in case_list]
    min_vals[i] = min(min_list)
    max_vals[i] = max([case[i] for case in case_list])
    ranges[i] = max_vals[i] - min_vals[i]
  norm_data_list = []
  for case in case_list:
    norm_data_list.append([(case[i] - min_vals[i])/ranges[i] for i in range(case_len)])
  return norm_data_list,ranges,min_vals

def main():
  result_list = ['黄瓜','香蕉','茄子','西葫芦']
  dimension1 = float(input('长度是: '))
  dimension2 = float(input('弯曲度是: '))
  dimension3 = float(input('颜色是: '))
  case_list,type_list = create_case_list()
  #norm_data_list,ranges,min_vals = auto_norm(case_list)
  in_coord = [dimension1,dimension2,dimension3]
  #in_coord_len = len(in_coord)
  #in_coord = [in_coord[i]/ranges[i] for i in range(in_coord_len)]
  #class_sel_result = knn_fun(in_coord,norm_data_list,type_list,3)
  class_sel_result = knn_fun(in_coord,case_list,type_list,3)
  class_sel_result = class_sel_result - 1
  return result_list[class_sel_result]

if __name__ == '__main__':
  a = main()
  print '这货是: %s' %a

代码解释:

广播第一法则是,如果所有的输入数组维度不都相同,一个“1”将被重复地添加在维度较小的数组上直至所有的数组拥有一样的维度。

测试结果,效果还不赖

(1)classify0()函数的四个输入参数:inX 用于分类的输入向量,dataSet是输入的训练样本集,labels是标签向量,最后k是用于选择最近邻的数目,其中标签向量的元素数目和矩阵dataSet的行数相同。

广播第二法则确定长度为1的数组沿着特殊的方向表现地好像它有沿着那个方向最大形状的大小。对数组来说,沿着那个维度的数组元素的值理应相同。

9159.com 6

(2)代码中测量两个对象距离的方法是欧几里得公式:

应用广播法则之后,所有数组的大小必须匹配。

                                                                                         9159.com 7

 

(3)shape函数是numpy.core.fromnumeric中的函数,它的功能是读取矩阵的长度,比如shape[0]就是读取矩阵第一维度的长度。它的输入参数可以使一个整数表示维度,也可以是一个矩阵。

2 numpy库 / numpy Library

(4)tile函数是模板numpy.lib.shape_base中的函数。函数的形式是tile(A,reps)

环境安装:

        A的类型几乎所有类型都可以:array, list, tuple, dict, matrix以及基本数据类型int, string, float以及bool类型。

pip install numpy  

        reps的类型也很多,可以是tuple,list, dict, array, int,bool.但不可以是float, string, matrix类型。行列重复copy的次数。

 

(5)sum函数中加入参数。sum(a,axis=0)或者是.sum(axis=1) ,axis=0 就是普通的相加 ;加入axis=1以后就是将一个矩阵的每一行向量相加。

2.1 常量 / Constants

(6)argsort函数返回的是数组值从小到大的索引值。

2.1.1 pi常量

 (7)   get() 函数返回字典指定键的值,如果值不在字典中返回默认值。

*常量名: pi***

(8)sorted进行排序,sorted(iterable, cmp=None, key=None, reverse=False)

*常量值:*** π 

         iterable:是可迭代类型;
         cmp:用于比较的函数,比较什么由key决定;
         key:用列表元素的某个属性或函数进行作为关键字,有默认值,迭代集合中的一项;
         reverse:排序规则. reverse = True  降序 或者 reverse = False 升序,有默认值。
         返回值:是一个经过排序的可迭代类型,与iterable一样。

 

3 示例-使用K-近邻算法改进约会网站的配对效果

2.2 函数 / Function

3.1 准备数据:从文本文件中解析数据

2.2.1 array()函数

将待处理数据的格式改变为分类器可以接收的格式。

*函数调用: ndarray = np.array(matrix_list)***

代码实现:

*函数功能:***生成一个ndarray格式的多维矩阵

 1 def file2matrix(filename):
 2     fr = open(filename)
 3     numberOfLines = len(fr.readlines())         #get the number of lines in the file
 4     returnMat = zeros((numberOfLines,3))        #prepare matrix to return
 5     classLabelVector = []                       #prepare labels return   
 6     fr = open(filename)
 7     index = 0
 8     for line in fr.readlines():
 9         line = line.strip()
10         listFromLine = line.split('t')
11         returnMat[index,:] = listFromLine[0:3]
12         classLabelVector.append(int(listFromLine[-1]))
13         index += 1
14     return returnMat,classLabelVector

*传入参数: matrix_list***

代码解释:

matrix_list: list类型,需要转换成矩阵的列表

(1)file2matrix ()函数的参数,filename接收文件名。

*返回参数: ndarray***

(2)open(路径+文件名,读写模式),读写模式:r只读,r+读写,w新建(会覆盖原有文件),a追加,b二进制文件。

ndarray: ndarray类型,numpy生成的矩阵

(3)readlines() 自动将文件内容分析成一个行的列表,该列表可以由 Python 的 for ... in ... 结构进行处理。

 

(4)len()获得列表中的元素个数。

2.2.2 arange()函数

(5)zeros(shape, dtype=float, order='C'),返回来一个给定形状和类型的用0填充的数组;

*函数调用: vector = np.arange(num)***

         参数:shape:形状

*函数功能:***生成一个1行n列的ndarray矩阵(一维向量)

                   dtype:数据类型,可选参数,默认numpy.float64

*传入参数: num***

                   dtype类型:t ,位域,如t4代表4位

num: int类型,生成向量的数据个数(从0计算)

                                     b,布尔值,true or false

*返回参数: vector***

                                     i,整数,如i8(64位)

vector: ndarray类型,numpy生成的矩阵(一维)

                                     u,无符号整数,u8(64位)

 

                                    f,浮点数,f8(64位)

2.2.3 zeros()函数

                                   c,浮点负数,

*函数调用: matrix = np.zeros(shape, dtype=)***

                                   o,对象,

*函数功能:***生成一个shape形状元素为0,数据类型为dtype的矩阵

                                   s,a,字符串,s24

*传入参数: shape, dtype***

                                   u,unicode,u24

shape: tuple类型,生成的0矩阵的形状

                order:可选参数,c代表与c语言类似,行优先;F代表列优先

dtype: obj类型,如np.float64/np.int32等,确定元素的数据类型

(6)strip() 方法用于移除字符串头尾指定的字符,默认删除空白符(包括'n', 'r',  't',  ' ')。

*返回参数: matrix***

 (7)split()就是将一个字符串分裂成多个字符串组成的列表。

matrix: ndarray类型,numpy生成的零矩阵

3.2 准备数据:归一化数值

 

不同的属性,其数值的取值范围不同,则计算距离时属性的权重就会无法掌控。因此,通常采用的方法是将数值归一化,如将取值范围处理为0到1或者-1到1之间。其通用公式:

2.2.4 ones()函数

newValue = (oldValue-min) /(max-min)

*函数调用: matrix = np.ones(shape, dtype=)***

其中min和max分别是数据集中的最小特征值和最大特征值。

*函数功能:***生成一个shape形状元素为1,数据类型为dtype的矩阵

代码实现:

*传入参数: shape, dtype***

1 def autoNorm(dataSet):
2     minVals = dataSet.min(0)
3     maxVals = dataSet.max(0)
4     ranges = maxVals - minVals
5     normDataSet = zeros(shape(dataSet))
6     m = dataSet.shape[0]
7     normDataSet = dataSet - tile(minVals, (m,1))
8     normDataSet = normDataSet/tile(ranges, (m,1))   #element wise divide
9     return normDataSet, ranges, minVals

shape: tuple类型,生成的1矩阵的形状

3.3 测试算法:作为完整程序验证分类器

dtype: obj类型,如np.float64/np.int32等,确定元素的数据类型

通常把已有的数据90%作为训练样本分类器,其余10%数据去测试分类器,检验分类器的正确率。

*返回参数: matrix***

代码实现:

matrix: ndarray类型,numpy生成的一矩阵

 1 def datingClassTest():
 2     hoRatio = 0.10      #hold out 10%
 3     datingDataMat,datingLabels = file2matrix('datingTestSet2.txt')       #load data setfrom file
 4     normMat, ranges, minVals = autoNorm(datingDataMat)
 5     m = normMat.shape[0]
 6     numTestVecs = int(m*hoRatio)
 7     errorCount = 0.0
 8     for i in range(numTestVecs):
 9         classifierResult = classify0(normMat[i,:],normMat[numTestVecs:m,:],datingLabels[numTestVecs:m],3)
10         print "the classifier came back with: %d, the real answer is: %d" % (classifierResult, datingLabels[i])
11         if (classifierResult != datingLabels[i]): errorCount += 1.0
12     print "the total error rate is: %f" % (errorCount/float(numTestVecs))
13     print errorCount

 

测试结果:

2.2.5 linspace()函数

9159.com 8

*函数调用: matrix = np.linspace(start, stop, num=50, endpoint=True)9159.com ,***

误差在5%,基本可以实现对结果的预测。

*函数功能:***生成一个等差矩阵

4.使用算法:构建完整可用系统

*传入参数: start, stop, num, endpoint***

代码实现:

start: int类型,等差矩阵的起始数

 1 def classifierPerson():
 2    resultList = [u'不喜欢',u'比较喜欢',u'很喜欢']
 3    percentTats = float(raw_input(u"玩视频游戏所耗时间百分百:"))
 4    ffmiles = float(raw_input(u"每年获得的飞行常客里程数:"))
 5    iceCream = float(raw_input(u"每周消耗的冰淇淋公升数:"))
 6    datingDataMat, datingLables = kNN.file2matrix('datingTestSet2.txt')
 7    normMat,ranges,minVals = kNN.autoNorm(datingDataMat )
 8    inArr = array([ffmiles ,percentTats ,iceCream ])
 9    classifierResult = kNN.classify0((inArr-minVals )/ranges,normMat ,datingLables ,3)
10    print u"你对这个人喜欢度: %s" % resultList [classifierResult -1]

stop: int类型,等差矩阵的终止数

运行结果:

num: int类型,生成的样本数量,默认50,必须非负

9159.com 9

endpoint: bool类型,如果为True,最后一个数包括stop,False则不包括

5 附-对数据分析的数据可视化

*返回参数: matrix***

 代码实现:

matrix: ndarray类型,numpy生成的等差矩阵

1 def show_data():
2    dataSet,lables = kNN .file2matrix('datingTestSet2.txt')
3    jieguo = kNN .classify0([2674,8.54,8.0],dataSet ,lables ,10)
4    fig= plt.figure()
5    ax = fig.add_subplot(111)
6    ax.scatter(dataSet [:, 1], dataSet [:, 2],
7               15.0*array(lables ),15.0*array(lables))
8    fig.show()
9    raw_input()

 

运行结果:

2.2.6 view()函数

9159.com 10

*函数调用: new_matrix = matrix.view()***

 

*函数功能:***创建一个新的矩阵,与原始矩阵共享原始数据(不共享其余信息,id不同)

*传入参数:无***

*返回参数: new_ matrix***

new_matrix: ndarray类型,view函数生成的新矩阵

 

2.2.7 copy()函数

*函数调用: new_matrix = matrix.copy()***

*函数功能:***创建一个新的矩阵,完全复制,且不共享任何资源,两个无关矩阵

*传入参数:无***

*返回参数: new_ matrix***

new_matrix: ndarray类型,copy函数生成的新矩阵

 

2.2.8 sin/cos()函数

*函数调用: matrix = np.sin/cos(matrix)***

*函数功能:***对矩阵的每个元素进行sin/cos操作

*传入参数: matrix***

matrix: ndarray类型,需要处理的矩阵

*返回参数: matrix***

matrix: ndarray类型,sin/cos后生成的矩阵

 

2.2.9 exp()函数

*函数调用: new_matrix = np.exp(matrix)***

*函数功能:***对矩阵元素进行以e为底的乘方运算(e^x)

*传入参数: matrix***

matrix: ndarray类型,计算矩阵

*返回参数: new_matrix***

new_matrix: ndarray类型,乘方运算后的矩阵

 

2.2.10 sqrt()函数

*函数调用: new_matrix = np.sqrt(matrix)***

*函数功能:***对矩阵元素进行以开方运算

*传入参数: matrix***

matrix: ndarray类型,计算矩阵

*返回参数: new_matrix***

new_matrix: ndarray类型,开方运算后的矩阵

 

2.2.11 dot()函数

*函数调用: matrix = np.dot(matrix_1, matrix_2) / matrix = matrix_1.dot(matrix_2)***

*函数功能:***将两个矩阵进行点乘运算

*传入参数: matrix_1, matrix_2***

matrix_1: ndarray类型,点乘矩阵1

matrix_2: ndarray类型,点乘矩阵2

*返回参数: matrix***

matrix: ndarray类型,点乘后生成的矩阵

 

2.2.12 floor/ceil()函数

*函数调用: new_matrix = np.floor/ceil(matrix)***

*函数功能:***对矩阵中的每个元素进行取整操作(floor向下,ceil向上)

*传入参数: matrix***

matrix: ndarray类型,计算矩阵

*返回参数: new_matrix***

new_matrix: ndarray类型,取整处理后的矩阵

 

2.2.13 argmax()函数

*函数调用: index = matrix.argmax(axis=None)***

*函数功能:***获取原矩阵的最大值/每行/列最大值所在索引

*传入参数: axis***

asix: bool/int类型,None则返回最大值,0/1则返回每列/行中最大值的索引

*返回参数: index***

index: int/ndarray类型,最大值或每行/列最大值索引矩阵

 

2.2.14 ravel()函数

*函数调用: new_matrix = matrix.ravel(order=‘C’)***

*函数功能:***对原矩阵进行展开(flatten)操作,变成一个单行矩阵

*传入参数: order***

order: str类型,确定取值方向

*返回参数: new_matrix***

new_matrix: ndarray类型,取整处理后的矩阵

 

2.2.15 hstack / vstack()函数

*函数调用: new_matrix = np.hstack/vstack(tup)***

*函数功能:***对原矩阵在水平/竖直方向进行堆叠(堆叠位置维度需要相同)

*传入参数: tup***

tup: tuple类型,(a, b),包括两个需要进行堆叠的矩阵a和b

*返回参数: new_matrix***

new_matrix: ndarray类型,堆叠处理后的矩阵

 

2.2.16 hsplit / vsplit()函数

*函数调用: new_matrix = np.hsplit/vsplit(matrix, indices_or_sections)***

*函数功能:***对原矩阵在水平/竖直方向进行拆分

*传入参数: matrix, indices_or_section***

matrix: ndarray类型,需要分割的原始矩阵

indices_or_section: int/tuple类型,int则表示需要切割的份数,tuple则表示需要切割的位置,如(3,4)表示切割位置在3h/v和4h/v之间

*返回参数: new_matrix***

new_matrix: list类型,切割处理后的矩阵列表,包含切割后的所有array

 

2.2.17 tile()函数

*函数调用: new_matrix = np.tile(matrix, reps)***

*函数功能:**对原矩阵进行铺展,原矩阵(c, d), reps=(a, b),则铺展成(ac, b*d)结构

*传入参数: matrix, reps***

matrix: ndarray类型,需要进行铺展的原始矩阵

reps: tuple类型,铺展形状

*返回参数: new_matrix***

new_matrix: ndarray类型,铺展处理后的矩阵

 

2.2.18 sort()函数

*函数调用: new_matrix = np.sort(matrix, axis=-1, kind=’quicksort’, order=None)***

*函数功能:***对原矩阵按行/列进行排序

*传入参数: matrix, axis, kind, order***

matrix: ndarray类型,需要进行排序的原始矩阵

axis: int/bool类型,None则将矩阵展开后排列, 0则按shape的第一维度排序,1,则按第二维度,依次类推,-1则为按最后一个维度排列

kind: str类型,确定sort的排序算法,包括{‘quicksort’, ‘mergesort’, ‘heapsort’}

order: str/list of str类型,确定排序的优先级,指定的优先排序,未指定的默认排序

*返回参数: new_matrix***

new_matrix: ndarray类型,排序处理后的矩阵

Eg.:

 1 import numpy as np
 2 
 3 x = np.array([[range(16, 12, -1), range(12, 8, -1), range(8, 4, -1)], [range(12, 8, -1), range(8, 4, -1), range(4, 0, -1)]])
 4 print(x)
 5 print(x.shape)
 6 print('----------------')
 7 print(np.sort(x, axis=None))
 8 print('----------------')
 9 print(np.sort(x, axis=0))
10 print('----------------')
11 print(np.sort(x, axis=1))
12 print('----------------')
13 print(np.sort(x, axis=-1))

输出结果

9159.com 119159.com 12

[[[16 15 14 13]
  [12 11 10  9]
  [ 8  7  6  5]]

 [[12 11 10  9]
  [ 8  7  6  5]
  [ 4  3  2  1]]]
(2, 3, 4)
----------------
[ 1  2  3  4  5  5  6  6  7  7  8  8  9  9 10 10 11 11 12 12 13 14 15 16]
----------------
[[[12 11 10  9]
  [ 8  7  6  5]
  [ 4  3  2  1]]

 [[16 15 14 13]
  [12 11 10  9]
  [ 8  7  6  5]]]
----------------
[[[ 8  7  6  5]
  [12 11 10  9]
  [16 15 14 13]]

 [[ 4  3  2  1]
  [ 8  7  6  5]
  [12 11 10  9]]]
----------------
[[[13 14 15 16]
  [ 9 10 11 12]
  [ 5  6  7  8]]

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

View Code

2.2.19 argsort()函数

*函数调用: index_matrix = np.argsort(matrix, axis=-1)***

*函数功能:***返回矩阵按行/列进行排序后的索引值列表

*传入参数: matrix, axis***

matrix: ndarray类型,需要进行排序的原始矩阵

axis: int/bool类型,None则将矩阵展开后排列, 0则按shape的第一维度排序,1,则按第二维度,依次类推,-1则为按最后一个维度排列

*返回参数: index_matrix***

index_matrix: ndarray类型,排序处理后的索引矩阵

 

2.2.20 T属性方法

*方法调用: T_matrix = matrix.T***

*方法功能:***对原矩阵进行转置操作

*传入参数:无***

*返回参数: T_matrix***

T_matrix: ndarray类型,转置处理后的矩阵

 

2.3 / Class

2.3.1 ndarray类

*类实例化:ndarray = np.array(matrix_list) / np.arange(num)***

*类的功能:***用于生成矩阵数组

*传入参数: matrix_list / num***

matrix_list: list类型,包含需要构建成ndarray矩阵的数据

num: int类型,生成ndarray的数据数量

*返回参数: ndarray***

ndarray: ndarray类型,生成的ndarray矩阵

 

2.3.1.1 dtype属性

*属性调用: fmt = ndarray.dtype***

*属性功能:*** 返回矩阵内数据的格式类型

*属性参数: fmt***

fmt: obj类型,<class ‘numpy.dtype’>

 

2.3.1.2 shape属性

*属性调用: shp = ndarray.shape / ndarray.shape = shp***

*属性功能:*** 返回矩阵各维度长度参数 / 更改矩阵各维度长度参数

*属性参数: shp***

shp: tuple类型,eg. 3维矩阵返回 (x, y, z)

 

2.3.1.3 ndim属性

*属性调用: rank = ndarray.ndim***

*属性功能:*** 返回矩阵的秩

*属性参数: rank***

rank: int类型,矩阵的秩

 

2.3.1.4 size属性

*属性调用: size = ndarray.size***

*属性功能:*** 返回矩阵的元素总数

*属性参数: size***

siez: int类型,矩阵的元素总数,等于shape中的元素乘积

 

2.3.1.5 itemsize属性

*属性调用: iSize = ndarray.itemsize***

*属性功能:*** 返回矩阵的元素总数

*属性参数: size***

siez: int类型,数组中每个元素的字节大小。例如,一个元素类型为float64的数组itemsize属性值为8(=64/8),又如,一个元素类型为complex32的数组item属性为4(=32/8)

 

2.3.1.6 data属性

*属性调用: mem = ndarray.data***

*属性功能:*** 返回包含实际数组元素的缓冲区

*属性参数: mem***

siez: obj类型,type: <class ‘memoryview’>,value: <memory at 0x00000X00X>

 

2.3.1.7 reshape方法

*函数调用: new_matrix = matrix.reshape (shape)***

*函数功能:***返回一个基于原始数据重排的矩阵

*传入参数: shape, order***

shape: tuple/int类型,用于确定新矩阵的维度参数,若一个元组某个维度为-1,则该维度由其余维度计算得出

order: str类型,‘C’表示将原始数据根据行顺序重排列,‘F’表示根据列顺序

*返回参数: new_matrix***

new_matrix: ndarray类型,重排后的矩阵

 

2.3.1.8 min/max()方法

*函数调用: value = matrix.min/max()***

*函数功能:***返回矩阵中的最小/最大值

*传入参数:无***

*返回参数: value***

value: int/str类型,矩阵中的最小/最大值

 

2.3.1.9 sum()方法

*函数调用: value = matrix.sum(axis=None)***

*函数功能:***返回矩阵的求和值

*传入参数: axis***

axis: int/None类型,None时返回矩阵所有元素之和,axis=0返回第一个维度求和值,axis=1第二个维度

*返回参数: value***

value: int/str类型,矩阵中的求和值

 

2.4 模块 / Module

2.4.1 random模块

2.4.1.1 常量

Pass

2.4.1.2 函数

2.4.1.2.1 random()函数

*函数调用: rdm = np.random.random(shape)***

*函数功能:***返回一个shape形状的随机元素矩阵

*传入参数: shape***

shape: tuple类型,随机矩阵的维度形状

*返回参数: rdm***

rdm: ndarray类型,返回的随机值矩阵

 

2.4.1.2.2 ranint()函数

*函数调用: rdi = np.random.randint(start, stop, num)***

*函数功能:***返回一个随机整数列表

*传入参数: start, stop, num***

start: int类型,随机数起始值

stop: int类型,随机数终止值

num: int类型,随机数数量

*返回参数: rdi***

rdi: list类型,返回的随机值列表

 

3 numpy基本操作

下面的代码提供了一些 numpy 基本函数的使用方法,

完整代码

9159.com 139159.com 14

 1 import numpy as np
 2 
 3 # Change type, all the elements in array should be in same type.
 4 matrix = np.array([1, 2, 3, 4])
 5 print(matrix, matrix.dtype)         # [1 2 3 4] int32
 6 matrix = np.array([1, 2, 3, 4.0])
 7 print(matrix, matrix.dtype)         # [ 1.  2.  3.  4.] float64
 8 matrix = np.array([1, 2, 3, '4'])
 9 print(matrix, matrix.dtype)         # ['1' '2' '3' '4'] <U11
10 
11 # Basic slice operation
12 matrix = np.array([[1, 2, 3, 4],
13              [5, 6, 7, 8],
14              [9, 10, 11, 12],
15              [13, 14, 15, 16]])
16 # Get number certain element(7), [row, column]
17 print(matrix[1,2])          # 7
18 # Get all row and column 3
19 print(matrix[:, 2])         # [3 7 11 15]
20 # Get certain row and column, not contains the max number
21 print(matrix[0:3, 0:2])     ''' [[ 1  2]
22                                  [ 5  6]
23                                  [ 9 10]] '''
24 
25 # Get the number by certain list
26 # (0,0),(1,1),(2,2),(3,3)
27 print(matrix[[0, 1, 2, 3], [0, 1, 2, 3]])   # [1 6 11 16]
28 # Use range method can make it too
29 print(matrix[range(4), range(4)])           # [1 6 11 16]
30 
31 # Operation to array will act to each element
32 equal_to_seven = (matrix == 7)
33 print(equal_to_seven)       ''' [[False False False False]
34                                  [False False  True False]
35                                  [False False False False]
36                                  [False False False False]] '''
37 
38 # equal_to_seven can be use as an index, True/False list also can do so
39 print(matrix[equal_to_seven])       # [7]
40 get_certain_row = [False, True, True, False]
41 print(matrix[get_certain_row])      ''' [[ 5  6  7  8]
42                                          [ 9 10 11 12]] '''
43 # Fetch row where the certain number in
44 matrix = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
45 print(matrix[matrix[:, 2] == 7])    # [[5 6 7 8]]
46 
47 vector = np.array([5, 10, 15, 20])
48 # Find the element equal to ten and five(impossible)
49 equal_to_ten_and_five = (vector == 5) & (vector == 10)
50 print(vector[equal_to_ten_and_five])                    # []
51 # Find the element equal to ten or five
52 equal_to_ten_or_five = (vector == 5) | (vector == 10)   
53 print(vector[equal_to_ten_or_five])                     # [5 10]
54 # Change equal one to other number
55 vector[equal_to_ten_or_five]=50
56 print(vector)                                           # [50 50 15 20]
57 
58 # Change the type of array
59 vector = np.array(['1', '2', '3'])
60 print(vector.dtype, vector)     # <U1 ['1' '2' '3']
61 new_vector = vector.astype(int)
62 print(new_vector.dtype, new_vector)     # int32 [1 2 3]
63 
64 # Get the min number
65 # Use print(help(np.array))
66 vector = np.array([5, 10, 15, 20])
67 print(vector.min())     # 5
68 
69 # Calculate the sum in certain dimension
70 # 1 for cal sum in row, 0 for cal sum in column
71 matrix = np.array([[1, 2, 3, 4],
72              [5, 6, 7, 8],
73              [9, 10, 11, 12],
74              [13, 14, 15, 16]])
75 print(matrix.sum(axis=1))   # [10 26 42 58]
76 print(matrix.sum(axis=0))   # [28 32 36 40]

View Code

分段解释

首先导入 numpy,

接着利用dtype属性查看元素数据类型,numpy中元素的类型必须一致,因此改变一个元素的类型,则其余元素也会被改变。

1 import numpy as np
2 
3 # Change type, all the elements in array should be in same type.
4 matrix = np.array([1, 2, 3, 4])
5 print(matrix, matrix.dtype)         # [1 2 3 4] int32
6 matrix = np.array([1, 2, 3, 4.0])
7 print(matrix, matrix.dtype)         # [ 1.  2.  3.  4.] float64
8 matrix = np.array([1, 2, 3, '4'])
9 print(matrix, matrix.dtype)         # ['1' '2' '3' '4'] <U11

 获取元素可以根据索引值进行,也可以根据类似列表切片的方法获取

 1 # Basic slice operation
 2 matrix = np.array([[1, 2, 3, 4],
 3              [5, 6, 7, 8],
 4              [9, 10, 11, 12],
 5              [13, 14, 15, 16]])
 6 # Get number certain element(7), [row, column]
 7 print(matrix[1,2])          # 7
 8 # Get all row and column 3
 9 print(matrix[:, 2])         # [3 7 11 15]
10 # Get certain row and column, not contains the max number
11 print(matrix[0:3, 0:2])     ''' [[ 1  2]
12                                  [ 5  6]
13                                  [ 9 10]] '''

使用列表的方式获取元素,两个列表分别为两个维度,两两组合获取数据

1 # Get the number by certain list
2 # (0,0),(1,1),(2,2),(3,3)
3 print(matrix[[0, 1, 2, 3], [0, 1, 2, 3]])   # [1 6 11 16]
4 # Use range method can make it too
5 print(matrix[range(4), range(4)])           # [1 6 11 16]

对于矩阵的操作将会分别作用于每一个元素上

 1 # Operation to array will act to each element
 2 equal_to_seven = (matrix == 7)
 3 print(equal_to_seven)       ''' [[False False False False]
 4                                  [False False  True False]
 5                                  [False False False False]
 6                                  [False False False False]] '''
 7 
 8 # equal_to_seven can be use as an index, True/False list also can do so
 9 print(matrix[equal_to_seven])       # [7]
10 get_certain_row = [False, True, True, False]
11 print(matrix[get_certain_row])      ''' [[ 5  6  7  8]
12                                          [ 9 10 11 12]] '''
13 # Fetch row where the certain number in
14 matrix = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
15 print(matrix[matrix[:, 2] == 7])    # [[5 6 7 8]]
16 
17 vector = np.array([5, 10, 15, 20])
18 # Find the element equal to ten and five(impossible)
19 equal_to_ten_and_five = (vector == 5) & (vector == 10)
20 print(vector[equal_to_ten_and_five])                    # []
21 # Find the element equal to ten or five
22 equal_to_ten_or_five = (vector == 5) | (vector == 10)   
23 print(vector[equal_to_ten_or_five])                     # [5 10]
24 # Change equal one to other number
25 vector[equal_to_ten_or_five]=50
26 print(vector)                                           # [50 50 15 20]

使用astype或shape=或reshape进行列表形状修改

1 # Change the type of array
2 vector = np.array(['1', '2', '3'])
3 print(vector.dtype, vector)     # <U1 ['1' '2' '3']
4 new_vector = vector.astype(int)
5 print(new_vector.dtype, new_vector)     # int32 [1 2 3]

获取最大最小值,以及求和操作

 1 # Get the min number
 2 # Use print(help(np.array))
 3 vector = np.array([5, 10, 15, 20])
 4 print(vector.min())     # 5
 5 
 6 # Calculate the sum in certain dimension
 7 # 1 for cal sum in row, 0 for cal sum in column
 8 matrix = np.array([[1, 2, 3, 4],
 9              [5, 6, 7, 8],
10              [9, 10, 11, 12],
11              [13, 14, 15, 16]])
12 print(matrix.sum(axis=1))   # [10 26 42 58]
13 print(matrix.sum(axis=0))   # [28 32 36 40]

 

4 numpy复制操作

在numpy(或者说Python)中,复制的矩阵的操作主要有三种方式,

  1. 直接通过赋值操作复制,这种复制得到的两个矩阵具有相同的id,其本质是两个指向同一内存空间的不同变量名;
  2. 通过numpy的view函数进行复制,这种复制可以得到两个id不同的矩阵,分别改变他们的形状等参数是互不影响的,但是两者共享同一原始数据,即修改其中一个的数据内容会对另外一个产生影响;
  3. 使用numpy的copy函数进行复制,这是一种完全复制,可以得到两个完全互不相关的矩阵。

代码如下

 1 import numpy as np
 2 
 3 # The simple assignments make no copy, a and b are two names for one same ndarray object
 4 a = np.arange(12)
 5 b = a 
 6 print(b is a) # True
 7 b.shape = (3, 4)
 8 print(a.shape) # (3, 4)
 9 # a and b with same id
10 print(id(a))
11 print(id(b))
12 
13 # The view method creates a new array obj that share with same source data
14 a = np.arange(12)
15 c = a.view()
16 print(c is a) # False
17 # Change the shape of c will not change the shape of a
18 c.shape = (2, 6)
19 print(a.shape) # (12, )
20 # But Change the data of c will change the data of a 
21 c[1, 2] = 1111
22 print(a)
23 # a and b with different id
24 print(id(a))
25 print(id(b))
26 
27 # The copy method makes a complete copy of array and its data
28 a = np.arange(12)
29 d = a.copy()
30 print(d is a) # False

 

5 numpy计算**

两个同维度矩阵的加减乘除、大小比较、开方、次幂、取整等操作,都将分别作用在各个元素上,点乘计算可以通过numpy.dot函数进行计算

完整代码

9159.com 159159.com 16

  1 import numpy as np
  2 
  3 a = np.array([20, 30, 40, 50])
  4 b = np.arange(4)
  5 # For (matrix - matrix) will operate for each corresponding elements
  6 # Different shape can not be subtracted unless only one element
  7 c = a - b
  8 print(c)    # [20 29 38 47]
  9 # For (matrix (-/'**'/'<') number) will operate for each elements 
 10 c -= 1
 11 print(c)    # [19 28 37 46]
 12 b = b**2 # (b*b)
 13 print(b) # [0, 1, 4, 9]
 14 print(a<35) # [True, True, False, False]
 15 
 16 # * will multiply each element in corresponding position
 17 # dot will act the dot multiply for matrix(by using matrix_1.dot(matrix_2) or np.dot(matrix_1, matrix_2))
 18 x = np.array([[1, 1],
 19               [0, 1]])
 20 y = np.array([[2, 0],
 21               [3, 4]])
 22 print(x*y)  '''[[2 0]
 23                 [0 4]] '''
 24 print('-------')
 25 print(x.dot(y))     '''[[5 4]
 26                         [3 4]] '''
 27 
 28 print('-------')
 29 print(np.dot(x, y)) '''[[5 4]
 30                         [3 4]]'''
 31 
 32 # exp function to cal e^x for x in matrix
 33 # sqrt function to cal sqrt(x) for x in matrix
 34 m = np.arange(3)
 35 print(m)    # [0 1 2]
 36 print(np.exp(m))    # [ 1.          2.71828183  7.3890561 ]
 37 print(np.sqrt(m))   # [ 0.          1.          1.41421356]
 38 
 39 # floor/ceil function to round(down/up) number of each matrix
 40 x = 10*np.random.random((3, 4))
 41 print(x)    '''[[ 6.69732597  1.18238851  4.10109987  6.40797969]
 42                 [ 6.50193132  2.58724942  5.25748965  2.58338795]
 43                 [ 0.2798712   7.89760089  6.03544519  1.5176369 ]] '''
 44 print('-------')
 45 y = np.floor(x)
 46 print(y)     '''[[ 6.  1.  4.  6.]
 47                  [ 6.  2.  5.  2.]
 48                  [ 0.  7.  6.  1.]] '''
 49 print('-------')
 50 z = np.ceil(x)
 51 print(z)    ''' [[ 7.  2.  5.  7.]
 52                  [ 7.  3.  6.  3.]
 53                  [ 1.  8.  7.  2.]] '''
 54 
 55 # ravel function can flatten a matrix into vector
 56 print(y.ravel())    # [ 6.  1.  4.  6.  6.  2.  5.  2.  0.  7.  6.  1.]
 57 # Shape value can change shape too
 58 y.shape = (6, 2)
 59 print(y)    ''' [[ 6.  1.]
 60                  [ 4.  6.]
 61                  [ 6.  2.]
 62                  [ 5.  2.]
 63                  [ 0.  7.]
 64                  [ 6.  1.]] '''
 65 print('-------')
 66 # T property function
 67 print(y.T)  ''' [[ 6.  4.  6.  5.  0.  6.]
 68                  [ 1.  6.  2.  2.  7.  1.]] '''
 69 print('-------')
 70 # If a dimension is given as -1, this dimension will be calculated automatically
 71 print(y.reshape(6, -1)) ''' [[ 6.  1.]
 72                              [ 4.  6.]
 73                              [ 6.  2.]
 74                              [ 5.  2.]
 75                              [ 0.  7.]
 76                              [ 6.  1.]] '''
 77 
 78 # hstack/vstack function can stack the matrix in h/v direction
 79 a = np.arange(6).reshape(2, 3)
 80 b = np.arange(6).reshape(2, 3)
 81 print(np.hstack((a, b))) '''[[0 1 2 0 1 2]
 82                              [3 4 5 3 4 5]] '''
 83 print(np.vstack((a, b))) '''[[0 1 2]
 84                              [3 4 5]
 85                              [0 1 2]
 86                              [3 4 5]] '''
 87 
 88 # hsplit/vsplit function can split the matrix in h/v direction
 89 x = np.arange(30).reshape(2, -1)
 90 print(x)    ''' [[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
 91                  [15 16 17 18 19 20 21 22 23 24 25 26 27 28 29]] '''
 92 # Split into 3 part (h direction, from one (2, 15) matrix to three (2, 5) matrixes)
 93 print(np.hsplit(x, 3))  '''[array([[ 0,  1,  2,  3,  4],
 94                                    [15, 16, 17, 18, 19]]),
 95                             array([[ 5,  6,  7,  8,  9],
 96                                    [20, 21, 22, 23, 24]]),
 97                             array([[10, 11, 12, 13, 14],
 98                                    [25, 26, 27, 28, 29]])] '''
 99 # Split in certain loction (split the matrix in location(after) column 3 and column 4)
100 print(np.hsplit(x, (3, 4))) '''[array([[ 0,  1,  2],
101                                        [15, 16, 17]]),
102                                 array([[ 3],
103                                        [18]]),
104                                 array([[ 4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14],
105                                        [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]])] '''
106 # Split into 3 part (v direction, from one (2, 15) matrix to two (1, 15) matrixes)
107 print(np.vsplit(x, 2))  ''' [array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14]]),
108                              array([[15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]])] '''
109 
110 # Fetch the max value position by row/column
111 data = np.random.random((5, 4))
112 print(data) ''' [[ 0.65419205  0.75953852  0.89856871  0.96162281]
113                  [ 0.76341568  0.10488636  0.06186101  0.27698986]
114                  [ 0.73737843  0.75305691  0.28705743  0.45542513]
115                  [ 0.5534984   0.54420756  0.86250921  0.596653  ]
116                  [ 0.24295898  0.28894731  0.58726507  0.39418991]] '''
117 # argmax/argmin function can get the max/min value index by row/column
118 index = data.argmax(axis=0)
119 print(index)    # [1 0 0 0]
120 # Get the max value by position
121 # data.shape[1] to get the number of column
122 print(data[index, range(data.shape[1])])    # [ 0.76341568  0.75953852  0.89856871  0.96162281]
123 
124 # Extend the matrix(like tile does)
125 x = np.arange(0, 40, 10)
126 print(x)    # [ 0 10 20 30]
127 # tile(x, (a, b)) can change origin shape(c, d) --> (a*c, b*d)
128 y = np.tile(x, (3, 5))
129 print(y)    ''' [[ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]
130                  [ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]
131                  [ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]] '''
132 print(y.shape) # (3, 20)
133 
134 # Sort the array
135 x = np.array([[4, 3, 5], [1, 2, 1]])
136 print(x)    '''[[4 3 5]
137                 [1 2 1]] '''
138 print('--------')
139 # Sort the number by row/column
140 y = np.sort(x, axis=1)
141 print(y)    '''[[3 4 5]
142                 [1 1 2]] '''
143 print('--------')
144 x.sort(axis=1)
145 print(x)    '''[[3 4 5]
146                 [1 1 2]] '''
147 print('--------')
148 # argsort can return the sorted index list
149 x = np.array([4, 3, 1, 2])
150 y = np.argsort(x)
151 print(y) # [2, 3, 1, 0] min is 1, index=2, then num 2, index is 3, num 3,index is 1, max is 4, index=0
152 # Use the sorted index list to fetch value
153 print('--------')
154 print(x[y]) # [1, 2, 3, 4]

View Code

分段解释

两个同维度矩阵的加减乘除、大小比较、开方、次幂、取整等操作,都将分别作用在各个元素上,点乘计算可以通过numpy.dot函数进行计算

 1 import numpy as np
 2 
 3 a = np.array([20, 30, 40, 50])
 4 b = np.arange(4)
 5 # For (matrix - matrix) will operate for each corresponding elements
 6 # Different shape can not be subtracted unless only one element
 7 c = a - b
 8 print(c)    # [20 29 38 47]
 9 # For (matrix (-/'**'/'<') number) will operate for each elements 
10 c -= 1
11 print(c)    # [19 28 37 46]
12 b = b**2 # (b*b)
13 print(b) # [0, 1, 4, 9]
14 print(a<35) # [True, True, False, False]
15 
16 # * will multiply each element in corresponding position
17 # dot will act the dot multiply for matrix(by using matrix_1.dot(matrix_2) or np.dot(matrix_1, matrix_2))
18 x = np.array([[1, 1],
19               [0, 1]])
20 y = np.array([[2, 0],
21               [3, 4]])
22 print(x*y)  '''[[2 0]
23                 [0 4]] '''
24 print('-------')
25 print(x.dot(y))     '''[[5 4]
26                         [3 4]] '''
27 
28 print('-------')
29 print(np.dot(x, y)) '''[[5 4]
30                         [3 4]]'''
31 
32 # exp function to cal e^x for x in matrix
33 # sqrt function to cal sqrt(x) for x in matrix
34 m = np.arange(3)
35 print(m)    # [0 1 2]
36 print(np.exp(m))    # [ 1.          2.71828183  7.3890561 ]
37 print(np.sqrt(m))   # [ 0.          1.          1.41421356]

random模块可以生成随机元素的矩阵

 1 # floor/ceil function to round(down/up) number of each matrix
 2 x = 10*np.random.random((3, 4))
 3 print(x)    '''[[ 6.69732597  1.18238851  4.10109987  6.40797969]
 4                 [ 6.50193132  2.58724942  5.25748965  2.58338795]
 5                 [ 0.2798712   7.89760089  6.03544519  1.5176369 ]] '''
 6 print('-------')
 7 y = np.floor(x)
 8 print(y)     '''[[ 6.  1.  4.  6.]
 9                  [ 6.  2.  5.  2.]
10                  [ 0.  7.  6.  1.]] '''
11 print('-------')
12 z = np.ceil(x)
13 print(z)    ''' [[ 7.  2.  5.  7.]
14                  [ 7.  3.  6.  3.]
15                  [ 1.  8.  7.  2.]] '''

ravel函数可以将矩阵展开成一维,T属性方法可以得到转置矩阵

 1 # ravel function can flatten a matrix into vector
 2 print(y.ravel())    # [ 6.  1.  4.  6.  6.  2.  5.  2.  0.  7.  6.  1.]
 3 # Shape value can change shape too
 4 y.shape = (6, 2)
 5 print(y)    ''' [[ 6.  1.]
 6                  [ 4.  6.]
 7                  [ 6.  2.]
 8                  [ 5.  2.]
 9                  [ 0.  7.]
10                  [ 6.  1.]] '''
11 print('-------')
12 # T property function
13 print(y.T)  ''' [[ 6.  4.  6.  5.  0.  6.]
14                  [ 1.  6.  2.  2.  7.  1.]] '''
15 print('-------')

reshape函数若其中一个参数为-1则该维度由其他维度计算得到

1 # If a dimension is given as -1, this dimension will be calculated automatically
2 print(y.reshape(6, -1)) ''' [[ 6.  1.]
3                              [ 4.  6.]
4                              [ 6.  2.]
5                              [ 5.  2.]
6                              [ 0.  7.]
7                              [ 6.  1.]] '''

random模块可以生成随机元素的矩阵。

1 # hstack/vstack function can stack the matrix in h/v direction
2 a = np.arange(6).reshape(2, 3)
3 b = np.arange(6).reshape(2, 3)
4 print(np.hstack((a, b))) '''[[0 1 2 0 1 2]
5                              [3 4 5 3 4 5]] '''
6 print(np.vstack((a, b))) '''[[0 1 2]
7                              [3 4 5]
8                              [0 1 2]
9                              [3 4 5]] '''

堆叠以及切割操作

 1 # hsplit/vsplit function can split the matrix in h/v direction
 2 x = np.arange(30).reshape(2, -1)
 3 print(x)    ''' [[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
 4                  [15 16 17 18 19 20 21 22 23 24 25 26 27 28 29]] '''
 5 # Split into 3 part (h direction, from one (2, 15) matrix to three (2, 5) matrixes)
 6 print(np.hsplit(x, 3))  '''[array([[ 0,  1,  2,  3,  4],
 7                                    [15, 16, 17, 18, 19]]),
 8                             array([[ 5,  6,  7,  8,  9],
 9                                    [20, 21, 22, 23, 24]]),
10                             array([[10, 11, 12, 13, 14],
11                                    [25, 26, 27, 28, 29]])] '''
12 # Split in certain loction (split the matrix in location(after) column 3 and column 4)
13 print(np.hsplit(x, (3, 4))) '''[array([[ 0,  1,  2],
14                                        [15, 16, 17]]),
15                                 array([[ 3],
16                                        [18]]),
17                                 array([[ 4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14],
18                                        [19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]])] '''
19 # Split into 3 part (v direction, from one (2, 15) matrix to two (1, 15) matrixes)
20 print(np.vsplit(x, 2))  ''' [array([[ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14]]),
21                              array([[15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]])] '''

获取最大值索引

 1 # Fetch the max value position by row/column
 2 data = np.random.random((5, 4))
 3 print(data) ''' [[ 0.65419205  0.75953852  0.89856871  0.96162281]
 4                  [ 0.76341568  0.10488636  0.06186101  0.27698986]
 5                  [ 0.73737843  0.75305691  0.28705743  0.45542513]
 6                  [ 0.5534984   0.54420756  0.86250921  0.596653  ]
 7                  [ 0.24295898  0.28894731  0.58726507  0.39418991]] '''
 8 # argmax/argmin function can get the max/min value index by row/column
 9 index = data.argmax(axis=0)
10 print(index)    # [1 0 0 0]
11 # Get the max value by position
12 # data.shape[1] to get the number of column
13 print(data[index, range(data.shape[1])])    # [ 0.76341568  0.75953852  0.89856871  0.96162281]

将矩阵进行铺展操作

1 # Extend the matrix(like tile does)
2 x = np.arange(0, 40, 10)
3 print(x)    # [ 0 10 20 30]
4 # tile(x, (a, b)) can change origin shape(c, d) --> (a*c, b*d)
5 y = np.tile(x, (3, 5))
6 print(y)    ''' [[ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]
7                  [ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]
8                  [ 0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30  0 10 20 30]] '''
9 print(y.shape) # (3, 20)

矩阵的排序及排序索引

 1 # Sort the array
 2 x = np.array([[4, 3, 5], [1, 2, 1]])
 3 print(x)    '''[[4 3 5]
 4                 [1 2 1]] '''
 5 print('--------')
 6 # Sort the number by row/column
 7 y = np.sort(x, axis=1)
 8 print(y)    '''[[3 4 5]
 9                 [1 1 2]] '''
10 print('--------')
11 x.sort(axis=1)
12 print(x)    '''[[3 4 5]
13                 [1 1 2]] '''
14 print('--------')
15 # argsort can return the sorted index list
16 x = np.array([4, 3, 1, 2])
17 y = np.argsort(x)
18 print(y) # [2, 3, 1, 0] min is 1, index=2, then num 2, index is 3, num 3,index is 1, max is 4, index=0
19 # Use the sorted index list to fetch value
20 print('--------')
21 print(x[y]) # [1, 2, 3, 4]

 

6 numpy常用函数

完整代码

9159.com 179159.com 18

 1 import numpy as np
 2 
 3 # Build a matrix, shape is (2, 4, 2)
 4 matrix = np.array([[[1,2], [2,3], [3,4], [4,5]], 
 5                     [[1,2], [2,3], [3,4], [4,5]]])
 6 
 7 # arange function to quickly create an array(vector)
 8 # Note: the shape is (x, ), one dimension array
 9 vector = np.arange(15)
10 print(vector)   # [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
11 # reshape function to reshape an array
12 matrix = vector.reshape(3, 5)
13 print(matrix)   ''' [[ 0  1  2  3  4]
14                      [ 5  6  7  8  9]
15                      [10 11 12 13 14]] '''
16 # shape is the row&column of matrix(array) - (3, 5)
17 # ndim is the number of dimensions(axes) of matrix - 2
18 # dtype is a numpy class, dtype.name is the type name of matrix - int32
19 # size is the total number of elements of matrix - 15
20 print(matrix.shape, matrix.ndim, matrix.dtype.name, matrix.size) # (3, 5) 2 int32 15
21 # arrange(from, to, step)
22 vector = np.arange(10, 30, 5)
23 print(vector)   # [10 15 20 25]
24 vector = np.arange(1, 3, 0.5)
25 print(vector)   # [ 1.   1.5  2.   2.5]
26 
27 # Init a matrix with all elements 0, default type is float64
28 matrix = np.zeros((3, 4), dtype=np.float64)
29 print(matrix)   ''' [[ 0.  0.  0.  0.]
30                      [ 0.  0.  0.  0.]
31                      [ 0.  0.  0.  0.]] '''
32 # Init a matrix with all elements 1
33 matrix = np.ones((2, 3, 4), dtype=np.int32)
34 print(matrix)   ''' [[[1 1 1 1]
35                       [1 1 1 1]
36                       [1 1 1 1]]
37                       
38                      [[1 1 1 1]
39                       [1 1 1 1]
40                       [1 1 1 1]]]'''
41 
42 # random function will return a matrix with random number(between 0 to 1)
43 # random((row, column))
44 rd = np.random.random((2, 3))
45 print(rd)   ''' [[ 0.45595053  0.69816822  0.30391984]
46                  [ 0.22757757  0.725762    0.84856338]] '''
47 
48 # Get the matrix with some same step numbers,
49 # 得到相应数量的等差数列
50 # linspace(from, to, number)
51 # Notice whether the num should be plus one
52 matrix = np.linspace(0, 2, 11)
53 print(matrix)   # [ 0.   0.2  0.4  0.6  0.8  1.   1.2  1.4  1.6  1.8  2. ]
54 
55 # sin/cos function can calculate the sin/cos of each elements
56 from numpy import pi
57 matrix = np.linspace(0, 2*pi, 9)
58 print(matrix)   # [ 0.          0.78539816  1.57079633  2.35619449  3.14159265  3.92699082  4.71238898  5.49778714  6.28318531]
59 matrix = np.sin(matrix)
60 print(matrix)   # [  0.00000000e+00   7.07106781e-01   1.00000000e+00   7.07106781e-01   1.22464680e-16  -7.07106781e-01  -1.00000000e+00  -7.07106781e-01  -2.44929360e-16]

View Code

分段解释

建立一个矩阵,可以通过array或arange函数生成,对于一位矩阵,其shape值为(x, )

 

 1 import numpy as np
 2 
 3 # Build a matrix, shape is (2, 4, 2)
 4 matrix = np.array([[[1,2], [2,3], [3,4], [4,5]], 
 5                     [[1,2], [2,3], [3,4], [4,5]]])
 6 
 7 # arange function to quickly create an array(vector)
 8 # Note: the shape is (x, ), one dimension array
 9 vector = np.arange(15)
10 print(vector)   # [ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]
11 # reshape function to reshape an array
12 matrix = vector.reshape(3, 5)
13 print(matrix)   ''' [[ 0  1  2  3  4]
14                      [ 5  6  7  8  9]
15                      [10 11 12 13 14]] '''
16 # shape is the row&column of matrix(array) - (3, 5)
17 # ndim is the number of dimensions(axes) of matrix - 2
18 # dtype is a numpy class, dtype.name is the type name of matrix - int32
19 # size is the total number of elements of matrix - 15
20 print(matrix.shape, matrix.ndim, matrix.dtype.name, matrix.size) # (3, 5) 2 int32 15
21 # arrange(from, to, step)
22 vector = np.arange(10, 30, 5)
23 print(vector)   # [10 15 20 25]
24 vector = np.arange(1, 3, 0.5)
25 print(vector)   # [ 1.   1.5  2.   2.5]

生成一个全零/一矩阵

 1 # Init a matrix with all elements 0, default type is float64
 2 matrix = np.zeros((3, 4), dtype=np.float64)
 3 print(matrix)   ''' [[ 0.  0.  0.  0.]
 4                      [ 0.  0.  0.  0.]
 5                      [ 0.  0.  0.  0.]] '''
 6 # Init a matrix with all elements 1
 7 matrix = np.ones((2, 3, 4), dtype=np.int32)
 8 print(matrix)   ''' [[[1 1 1 1]
 9                       [1 1 1 1]
10                       [1 1 1 1]]
11                       
12                      [[1 1 1 1]
13                       [1 1 1 1]
14                       [1 1 1 1]]]'''

随机矩阵及等差矩阵等

 1 # random function will return a matrix with random number(between 0 to 1)
 2 # random((row, column))
 3 rd = np.random.random((2, 3))
 4 print(rd)   ''' [[ 0.45595053  0.69816822  0.30391984]
 5                  [ 0.22757757  0.725762    0.84856338]] '''
 6 
 7 # Get the matrix with some same step numbers,
 8 # 得到相应数量的等差数列
 9 # linspace(from, to, number)
10 # Notice whether the num should be plus one
11 matrix = np.linspace(0, 2, 11)
12 print(matrix)   # [ 0.   0.2  0.4  0.6  0.8  1.   1.2  1.4  1.6  1.8  2. ]
13 
14 # sin/cos function can calculate the sin/cos of each elements
15 from numpy import pi
16 matrix = np.linspace(0, 2*pi, 9)
17 print(matrix)   # [ 0.          0.78539816  1.57079633  2.35619449  3.14159265  3.92699082  4.71238898  5.49778714  6.28318531]
18 matrix = np.sin(matrix)
19 print(matrix)   # [  0.00000000e+00   7.07106781e-01   1.00000000e+00   7.07106781e-01   1.22464680e-16  -7.07106781e-01  -1.00000000e+00  -7.07106781e-01  -2.44929360e-16]

 

参考链接


本文由9159.com发布于编程,转载请注明出处:NumPy系统是Python的一种开源的数值计算扩展包,计

关键词: