NumPy-快速处理数据

2 NumPy-快速处理数据¶ 标准 excel标准偏差excel标准偏差函数exl标准差函数国标检验抽样标准表免费下载红头文件格式标准下载 安装的 Python 中用列表(list)保存一组值，可以用来当作数组使用，不过由 于列表的元素可以是任何对象，因此列表中所保存的是对象的指针。这样为了保 存一个简单的[1,2,3]，需要有 3 个指针和三个整数对象。对于数值运算来说这种 结构显然比较浪费内存和 CPU 计算时间。 此外Python 还提供了一个 array模块，array对象和列表不同，它直接保存数值， 和 C 语言的一维数组比较类似。但是由于它不支持多维，也没有各种运算函数， 因此也不适合做数值运算。 NumPy 的诞生弥补了这些不足，NumPy 提供了两种基本的对象：ndarray （N-dimensional array object）和 ufunc（universal function object）。ndarray(下 文统一称之为数组)是存储单一数据类型的多维数组，而 ufunc 则是能够对数组 进行处理的函数。 2.1 ndarray 对象¶ 函数库的导入 本书的示例程序假设用以下推荐的方式导入 NumPy 函数库: import numpy as np 2.1.1 创建¶ 首先需要创建数组才能对其进行其它操作。 我们可以通过给 array 函数传递 Python 的序列对象创建数组，如果传递的是多 层嵌套的序列，将创建多维数组(下例中的变量 c): >>> a = np.array([1, 2, 3, 4]) >>> b = np.array((5, 6, 7, 8)) >>> c = np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]]) >>> b array([5, 6, 7, 8]) >>> c array([[1, 2, 3, 4], [4, 5, 6, 7], [7, 8, 9, 10]]) >>> c.dtype dtype('int32') 数组的大小可以通过其 shape 属性获得： >>> a.shape (4,) >>> c.shape (3, 4) 数组 a 的 shape 只有一个元素，因此它是一维数组。而数组 c 的 shape 有两个 元素，因此它是二维数组，其中第 0 轴的长度为 3，第 1 轴的长度为 4。还可以 通过修改数组的 shape 属性，在保持数组元素个数不变的情况下，改变数组每 个轴的长度。下面的例子将数组 c 的 shape 改为(4,3)，注意从(3,4)改为(4,3)并 不是对数组进行转置，而只是改变每个轴的大小，数组元素在内存中的位置并没 有改变： >>> c.shape = 4,3 >>> c array([[ 1, 2, 3], [ 4, 4, 5], [ 6, 7, 7], [ 8, 9, 10]]) 当某个轴的元素为-1 时，将根据数组元素的个数自动计算此轴的长度，因此下 面的程序将数组 c 的 shape 改为了(2,6)： >>> c.shape = 2,-1 >>> c array([[ 1, 2, 3, 4, 4, 5], [ 6, 7, 7, 8, 9, 10]]) 使用数组的 reshape 方法，可以创建一个改变了尺寸的新数组，原数组的 shape 保持不变： >>> d = a.reshape((2,2)) >>> d array([[1, 2], [3, 4]]) >>> a array([1, 2, 3, 4]) 数组 a 和 d 其实共享数据存储内存区域，因此修改其中任意一个数组的元素都 会同时修改另外一个数组的 内容 财务内部控制制度的内容财务内部控制制度的内容人员招聘与配置的内容项目成本控制的内容消防安全演练内容 ： >>> a[1] = 100 # 将数组 a的第一个元素改为 100 >>> d # 注意数组 d中的 2也被改变了 array([[ 1, 100], [ 3, 4]]) 数组的元素类型可以通过 dtype 属性获得。上面例子中的参数序列的元素都是整 数，因此所创建的数组的元素类型也是整数，并且是 32bit 的长整型。可以通过 dtype 参数在创建时指定元素类型: >>> np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]], dtype=np.float) array([[ 1., 2., 3., 4.], [ 4., 5., 6., 7.], [ 7., 8., 9., 10.]]) >>> np.array([[1, 2, 3, 4],[4, 5, 6, 7], [7, 8, 9, 10]], dtype=np.complex) array([[ 1.+0.j, 2.+0.j, 3.+0.j, 4.+0.j], [ 4.+0.j, 5.+0.j, 6.+0.j, 7.+0.j], [ 7.+0.j, 8.+0.j, 9.+0.j, 10.+0.j]]) 上面的例子都是先创建一个Python序列，然后通过 array函数将其转换为数组， 这样做显然效率不高。因此 NumPy 提供了很多专门用来创建数组的函数。下面 的每个函数都有一些关键字参数，具体用法请查看函数 说明 关于失联党员情况说明岗位说明总经理岗位说明书会计岗位说明书行政主管岗位说明书 。  arange 函数类似于 python 的 range 函数，通过指定开始值、 终值和步长来创建一维数组， 注意数组不包括终值:  >>> np.arange(0,1,0.1)  array([ 0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])  linspace 函数通过指定开始值、 终值和元素个数来创建一维 数组，可以通过 endpoint 关键 字指定是否包括终值，缺省设 置是包括终值:  >>> np.linspace(0, 1, 12)  array([ 0. , 0.09090909, 0.18181818, 0.27272727, 0.36363636,  0.45454545, 0.54545455, 0.63636364, 0.72727273, 0.81818182,  0.90909091, 1. ])  logspace 函数和 linspace 类 似，不过它创建等比数列，下 面 的 例 子 产 生 1(10^0) 到 100(10^2)、有 20 个元素的等 比数列:  >>> np.logspace(0, 2, 20)  array([ 1. , 1.27427499, 1.62377674, 2.06913808,  2.6366509 , 3.35981829, 4.2813324 , 5.45559478,  6.95192796, 8.8586679 , 11.28837892, 14.38449888,  18.32980711, 23.35721469, 29.76351442, 37.92690191,  48.32930239, 61.58482111, 78.47599704, 100. ]) 此外，使用 frombuffer, fromstring, fromfile 等函数可以从字节序列创建数组，下 面以 fromstring 为例: >>> s = "abcdefgh" Python 的字符串实际上是字节序列，每个字符占一个字节，因此如果从字符串 s 创建一个 8bit 的整数数组的话，所得到的数组正好就是字符串中每个字符的 ASCII 编码: >>> np.fromstring(s, dtype=np.int8) array([ 97, 98, 99, 100, 101, 102, 103, 104], dtype=int8) 如果从字符串 s 创建 16bit 的整数数组，那么两个相邻的字节就表示一个整数， 把字节 98 和字节 97 当作一个 16 位的整数，它的值就是 98*256+97 = 25185。 可以看出内存中是以 little endian(低位字节在前)方式保存数据的。 >>> np.fromstring(s, dtype=np.int16) array([25185, 25699, 26213, 26727], dtype=int16) >>> 98*256+97 25185 如果把整个字符串转换为一个 64 位的双精度浮点数数组，那么它的值是: >>> np.fromstring(s, dtype=np.float) array([ 8.54088322e+194]) 显然这个例子没有什么意义，但是可以想象如果我们用 C 语言的二进制方式写 了一组 double 类型的数值到某个文件中，那们可以从此文件读取相应的数据， 并通过 fromstring 函数将其转换为 float64 类型的数组。 我们可以写一个 Python 的函数，它将数组下标转换为数组中对应的值，然后使 用此函数创建数组： >>> def func(i): ... return i%4+1 ... >>> np.fromfunction(func, (10,)) array([ 1., 2., 3., 4., 1., 2., 3., 4., 1., 2.]) fromfunction 函数的第一个参数为计算每个数组元素的函数，第二个参数为数组 的大小(shape)，因为它支持多维数组，所以第二个参数必须是一个序列，本例 中用(10,)创建一个 10 元素的一维数组。 下面的例子创建一个二维数组表示九九乘法表，输出的数组 a 中的每个元素 a[i, j]都等于 func2(i, j)： >>> def func2(i, j): ... return (i+1) * (j+1) ... >>> a = np.fromfunction(func2, (9,9)) >>> a array([[ 1., 2., 3., 4., 5., 6., 7., 8., 9.], [ 2., 4., 6., 8., 10., 12., 14., 16., 18.], [ 3., 6., 9., 12., 15., 18., 21., 24., 27.], [ 4., 8., 12., 16., 20., 24., 28., 32., 36.], [ 5., 10., 15., 20., 25., 30., 35., 40., 45.], [ 6., 12., 18., 24., 30., 36., 42., 48., 54.], [ 7., 14., 21., 28., 35., 42., 49., 56., 63.], [ 8., 16., 24., 32., 40., 48., 56., 64., 72.], [ 9., 18., 27., 36., 45., 54., 63., 72., 81.]]) 2.1.2 存取元素¶ 数组元素的存取方法和 Python 的标准方法相同： >>> a = np.arange(10) >>> a[5] # 用整数作为下标可以获取数组中的某个元素 5 >>> a[3:5] # 用范围作为下标获取数组的一个切片，包括 a[3]不包括 a[5] array([3, 4]) >>> a[:5] # 省略开始下标，表示从 a[0]开始 array([0, 1, 2, 3, 4]) >>> a[:-1] # 下标可以使用负数，表示从数组后往前数 array([0, 1, 2, 3, 4, 5, 6, 7, 8]) >>> a[2:4] = 100,101 # 下标还可以用来修改元素的值 >>> a array([ 0, 1, 100, 101, 4, 5, 6, 7, 8, 9]) >>> a[1:-1:2] # 范围中的第三个参数表示步长，2表示隔一个元素取一个元 素 array([ 1, 101, 5, 7]) >>> a[::-1] # 省略范围的开始下标和结束下标，步长为-1，整个数组头尾颠倒 array([ 9, 8, 7, 6, 5, 4, 101, 100, 1, 0]) >>> a[5:1:-2] # 步长为负数时，开始下标必须大于结束下标 array([ 5, 101]) 和 Python 的列表序列不同，通过下标范围获取的新的数组是原始数组的一个视 图。它与原始数组共享同一块数据空间： >>> b = a[3:7] # 通过下标范围产生一个新的数组 b，b和 a共享同一块数据空 间 >>> b array([101, 4, 5, 6]) >>> b[2] = -10 # 将 b的第 2个元素修改为-10 >>> b array([101, 4, -10, 6]) >>> a # a的第 5个元素也被修改为 10 array([ 0, 1, 100, 101, 4, -10, 6, 7, 8, 9]) 除了使用下标范围存取元素之外，NumPy 还提供了两种存取元素的高级方法。 使用整数序列 当使用整数序列对数组元素进行存取时，将使用整数序列中的每个元素作为下标， 整数序列可以是列表或者数组。使用整数序列作为下标获得的数组不和原始数组 共享数据空间。 >>> x = np.arange(10,1,-1) >>> x array([10, 9, 8, 7, 6, 5, 4, 3, 2]) >>> x[[3, 3, 1, 8]] # 获取 x中的下标为 3, 3, 1, 8的 4个元素，组成一个 新的数组 array([7, 7, 9, 2]) >>> b = x[np.array([3,3,-3,8])] #下标可以是负数 >>> b[2] = 100 >>> b array([7, 7, 100, 2]) >>> x # 由于 b和 x不共享数据空间，因此 x中的值并没有改变 array([10, 9, 8, 7, 6, 5, 4, 3, 2]) >>> x[[3,5,1]] = -1, -2, -3 # 整数序列下标也可以用来修改元素的值 >>> x array([10, -3, 8, -1, 6, -2, 4, 3, 2]) 使用布尔数组 当使用布尔数组 b 作为下标存取数组 x 中的元素时，将收集数组 x 中所有在数组 b 中对应下标为 True 的元素。使用布尔数组作为下标获得的数组不和原始数组 共享数据空间，注意这种方式只对应于布尔数组，不能使用布尔列表。 >>> x = np.arange(5,0,-1) >>> x array([5, 4, 3, 2, 1]) >>> x[np.array([True, False, True, False, False])] >>> # 布尔数组中下标为 0，2的元素为 True，因此获取 x中下标为 0,2 的元素 array([5, 3]) >>> x[[True, False, True, False, False]] >>> # 如果是布尔列表，则把 True当作 1, False当作 0，按照整数序列方式获 取 x中的元素 array([4, 5, 4, 5, 5]) >>> x[np.array([True, False, True, True])] >>> # 布尔数组的长度不够时，不够的部分都当作 False array([5, 3, 2]) >>> x[np.array([True, False, True, True])] = -1, -2, -3 >>> # 布尔数组下标也可以用来修改元素 >>> x array([-1, 4, -2, -3, 1]) 布尔数组一般不是手工产生，而是使用布尔运算的 ufunc 函数产生，关于 ufunc 函数请参照 ufunc 运算 一节。 >>> x = np.random.rand(10) # 产生一个长度为 10，元素值为 0-1的随机数的 数组 >>> x array([ 0.72223939, 0.921226 , 0.7770805 , 0.2055047 , 0.17567449, 0.95799412, 0.12015178, 0.7627083 , 0.43260184, 0.91379859]) >>> x>0.5 >>> # 数组 x中的每个元素和 0.5进行大小比较，得到一个布尔数组，True 表 示 x中对应的值大于 0.5 array([ True, True, True, False, False, True, False, True, False, True], dtype=bool) >>> x[x>0.5] >>> # 使用 x>0.5返回的布尔数组收集 x中的元素，因此得到的结果是 x 中所有 大于 0.5的元素的数组 array([ 0.72223939, 0.921226 , 0.7770805 , 0.95799412, 0.7627083 , 0.91379859]) 2.1.3 多维数组¶ 多维数组的存取和一维数组类似，因为多维数组有多个轴，因此它的下标需要用 多个值来表示，NumPy 采用组元(tuple)作为数组的下标。如图 2.1 所示，a 为一 个 6x6 的数组，图中用颜色区分了各个下标以及其对应的选择区域。 组元不需要圆括号 虽然我们经常在 Python 中用圆括号将组元括起来，但是其实组元的语法定义只 需要用逗号隔开即可，例如 x,y=y,x 就是用组元交换变量值的一个例子。 图 2.1 使用数组切片语法访问多维数组中的元素 如何创建这个数组 你也许会对如何创建 a 这样的数组感到好奇，数组 a 实际上是一个加法表，纵 轴的值为 0, 10, 20, 30, 40, 50；横轴的值为 0, 1, 2, 3, 4, 5。纵轴的每个元素都 和横轴的每个元素求和，就得到图中所示的数组 a。你可以用下面的语句创建它， 至于其原理我们将在后面的章节进行讨论： >>> np.arange(0, 60, 10).reshape(-1, 1) + np.arange(0, 6) array([[ 0, 1, 2, 3, 4, 5], [10, 11, 12, 13, 14, 15], [20, 21, 22, 23, 24, 25], [30, 31, 32, 33, 34, 35], [40, 41, 42, 43, 44, 45], [50, 51, 52, 53, 54, 55]]) 多维数组同样也可以使用整数序列和布尔数组进行存取。 图 2.2 使用整数序列和布尔数组访问多维数组中的元素  a[(0,1,2,3,4),(1,2,3,4,5)] : 用 于存取数组的下标和仍然是 一个有两个元素的组元，组元 中的每个元素都是整数序列， 分别对应数组的第 0 轴和第 1 轴。从两个序列的对应位置取 出两个整数组成下标： a[0,1], a[1,2], ..., a[4,5]。  a[3:, [0, 2, 5]] : 下标中的第 0 轴是一个范围，它选取第 3 行 之后的所有行；第 1 轴是整数 序列，它选取第 0, 2, 5 三列。  a[mask, 2] : 下标的第 0 轴是 一个布尔数组，它选取第 0， 2，5 行；第 1 轴是一个整数， 选取第 2 列。 2.1.4 结构数组¶ 在 C 语言中我们可以通过 struct 关键字定义结构类型，结构中的字段占据连续 的内存空间，每个结构体占用的内存大小都相同，因此可以很容易地定义结构数 组。和C语言一样，在NumPy中也很容易对这种结构数组进行操作。只要NumPy 中的结构定义和 C 语言中的定义相同，NumPy 就可以很方便地读取 C 语言的结 构数组的二进制数据，转换为 NumPy 的结构数组。 假设我们需要定义一个结构数组，它的每个元素都有name, age和weight字段。 在 NumPy 中可以如下定义： import numpy as np persontype = np.dtype({ 'names':['name', 'age', 'weight'], 'formats':['S32','i', 'f']}) a = np.array([("Zhang",32,75.5),("Wang",24,65.2)], dtype=persontype) 我们先创建一个 dtype 对象 persontype，通过其字典参数描述结构类型的各个 字段。字典有两个关键字：names，formats。每个关键字对应的值都是一个列 表。names 定义结构中的每个字段名，而 formats 则定义每个字段的类型：  S32 : 32个字节的字符串类型， 由于结构中的每个元素的大 小必须固定，因此需要指定字 符串的长度  i : 32bit 的整数类型，相当于 np.int32  f : 32bit 的单精度浮点数类型， 相当于 np.float32 然后我们调用 array 函数创建数组，通过关键字参数 dtype=persontype， 指定 所创建的数组的元素类型为结构 persontype。运行上面程序之后，我们可以在 IPython 中执行如下的语句查看数组 a 的元素类型 >>> a.dtype dtype([('name', '|S32'), ('age', ' : 高位字节在前 结构数组的存取方式和一般数组相同，通过下标能够取得其中的元素，注意元素 的值看上去像是组元，实际上它是一个结构： >>> a[0] ('Zhang', 32, 75.5) >>> a[0].dtype dtype([('name', '|S32'), ('age', '>> c = a[1] >>> c["name"] = "Li" >>> a[1]["name"] "Li" 结构像字典一样可以通过字符串下标获取其对应的字段值： >>> a[0]["name"] 'Zhang' 我们不但可以获得结构元素的某个字段，还可以直接获得结构数组的字段，它返 回的是原始数组的视图，因此可以通过修改 b[0]改变 a[0]["age"]： >>> b=a[:]["age"] # 或者 a["age"] >>> b array([32, 24]) >>> b[0] = 40 >>> a[0]["age"] 40 通过调用 a.tostring 或者 a.tofile 方法，可以直接输出数组 a 的二进制形式： >>> a.tofile("test.bin") 利用下面的 C 语言程序可以将 test.bin 文件中的数据读取出来。 内存对齐 C 语言的结构体为了内存寻址方便，会自动的添加一些填充用的字节，这叫做内 存对齐。例如如果把下面的 name[32]改为 name[30]的话，由于内存对齐问题， 在 name 和 age 中间会填补两个字节，最终的结构体大小不会改变。因此如果 numpy 中的所配置的内存大小不符合 C 语言的对齐 规范 编程规范下载gsp规范下载钢格栅规范下载警徽规范下载建设厅规范下载 的话，将会出现数据错 位。为了解决这个问题，在创建 dtype 对象时，可以传递参数 align=True，这样 numpy 的结构数组的内存对齐和 C 语言的结构体就一致了。 #include struct person { char name[32]; int age; float weight; }; struct person p[2]; void main () { FILE *fp; int i; fp=fopen("test.bin","rb"); fread(p, sizeof(struct person), 2, fp); fclose(fp); for(i=0;i<2;i++) printf("%s %d %f\n", p[i].name, p[i].age, p[i].weight); getchar(); } 结构类型中可以包括其它的结构类型，下面的语句创建一个有一个字段 f1 的结 构，f1 的值是另外一个结构，它有字段 f2，其类型为 16bit 整数。 >>> np.dtype([('f1', [('f2', np.int16)])]) dtype([('f1', [('f2', '>> np.dtype([('f0', 'i4'), ('f1', 'f8', (2, 3))]) dtype([('f0', '>> np.dtype({'surname':('S25',0),'age':(np.uint8,25)}) dtype([('surname', '|S25'), ('age', '|u1')]) 2.1.5 内存结构¶ 下面让我们来看看 ndarray 数组对象是如何在内存中储存的。如图 2.3 所示，关 于数组的描述信息保存在一个数据结构中，这个结构引用两个对象：一块用于保 存数据的存储区域和一个用于描述元素类型的 dtype 对象。 图 2.3 ndarray 数组对象在内存中的储存方式 数据存储区域保存着数组中所有元素的二进制数据，dtype 对象则知道如何将元 素的二进制数据转换为可用的值。数组的维数、大小等信息都保存在 ndarray 数 组对象的数据结构中。图中显示的是如下数组的内存结构： >>> a = np.array([[0,1,2],[3,4,5],[6,7,8]], dtype=np.float32) strides 中保存的是当每个轴的下标增加 1 时，数据存储区中的指针所增加的字 节数。例如图中的 strides 为 12,4，即第 0 轴的下标增加 1 时，数据的地址增加 12 个字节：即 a[1,0]的地址比 a[0,0]的地址要高 12 个字节，正好是 3 个单精度 浮点数的总字节数；第 1 轴下标增加 1 时，数据的地址增加 4 个字节，正好是 单精度浮点数的字节数。 如果 strides 中的数值正好和对应轴所占据的字节数相同的话，那么数据在内存 中是连续存储的。然而数据并不一定都是连续储存的，前面介绍过通过下标范围 得到新的数组是原始数组的视图，即它和原始视图共享数据存储区域： >>> b = a[::2,::2] >>> b array([[ 0., 2.], [ 6., 8.]], dtype=float32) >>> b.strides (24, 8) 由于数组 b 和数组 a 共享数据存储区，而 b 中的第 0 轴和第 1 轴都是数组 a 中 隔一个元素取一个，因此数组 b 的 strides 变成了 24,8，正好都是数组 a 的两倍。 对照前面的图很容易看出数据 0 和 2 的地址相差 8 个字节，而 0 和 6 的地址相 差 24 个字节。 元素在数据存储区中的排列格式有两种：C 语言格式和 Fortan 语言格式。在 C 语言中，多维数组的第 0 轴是最上位的，即第 0 轴的下标增加 1 时，元素的地 址增加的字节数最多；而 Fortan 语言的多维数组的第 0 轴是最下位的，即第 0 轴的下标增加 1 时，地址只增加一个元素的字节数。在 NumPy 中，元素在内存 中的排列缺省是以 C 语言格式存储的，如果你希望改为 Fortan 格式的话，只需 要给数组传递 order="F"参数： >>> c = np.array([[0,1,2],[3,4,5],[6,7,8]], dtype=np.float32, order="F") >>> c.strides (4, 12) 2.2 ufunc 运算¶ ufunc 是 universal function 的缩写，它是一种能对数组的每个元素进行操作的函 数。NumPy 内置的许多 ufunc 函数都是在 C 语言级别实现的，因此它们的计算 速度非常快。让我们来看一个例子： >>> x = np.linspace(0, 2*np.pi, 10) # 对数组 x中的每个元素进行正弦计算，返回一个同样大小的新数组 >>> y = np.sin(x) >>> y array([ 0.00000000e+00, 6.42787610e-01, 9.84807753e-01, 8.66025404e-01, 3.42020143e-01, -3.42020143e-01, -8.66025404e-01, -9.84807753e-01, -6.42787610e-01, -2.44921271e-16]) 先用 linspace 产生一个从 0 到 2*PI 的等距离的 10 个数，然后将其传递给 sin 函 数，由于 np.sin 是一个 ufunc 函数，因此它对 x 中的每个元素求正弦值，然后 将结果返回，并且赋值给 y。计算之后 x 中的值并没有改变，而是新创建了一个 数组保存结果。如果我们希望将 sin 函数所计算的结果直接覆盖到数组 x 上去的 话，可以将要被覆盖的数组作为第二个参数传递给 ufunc 函数。例如：: >>> t = np.sin(x,x) >>> x array([ 0.00000000e+00, 6.42787610e-01, 9.84807753e-01, 8.66025404e-01, 3.42020143e-01, -3.42020143e-01, -8.66025404e-01, -9.84807753e-01, -6.42787610e-01, -2.44921271e-16]) >>> id(t) == id(x) True sin 函数的第二个参数也是 x，那么它所做的事情就是对 x 中的每给值求正弦值， 并且把结果保存到 x 中的对应的位置中。此时函数的返回值仍然是整个计算的结 果，只不过它就是 x，因此两个变量的 id 是相同的(变量 t 和变量 x 指向同一块 内存区域)。 我用下面这个小程序，比较了一下 numpy.math 和 Python 标准库的 math.sin 的 计算速度：: import time import math import numpy as np x = [i * 0.001 for i in xrange(1000000)] start = time.clock() for i, t in enumerate(x): x[i] = math.sin(t) print "math.sin:", time.clock() - start x = [i * 0.001 for i in xrange(1000000)] x = np.array(x) start = time.clock() np.sin(x,x) print "numpy.sin:", time.clock() - start # 输出 # math.sin: 1.15426932753 # numpy.sin: 0.0882399858083 在我的电脑上计算 100 万次正弦值，numpy.sin 比 math.sin 快 10 倍多。这得利 于 numpy.sin 在 C 语言级别的循环计算。numpy.sin 同样也支持对单个数值求正 弦，例如：numpy.sin(0.5)。不过值得注意的是，对单个数的计算 math.sin 则比 numpy.sin 快得多了，让我们看下面这个测试程序： x = [i * 0.001 for i in xrange(1000000)] start = time.clock() for i, t in enumerate(x): x[i] = np.sin(t) print "numpy.sin loop:", time.clock() - start # 输出 # numpy.sin loop: 5.72166965355 请注意 numpy.sin 的计算速度只有 math.sin 的 1/5。这是因为 numpy.sin 为了同 时支持数组和单个值的计算，其 C 语言的内部实现要比 math.sin 复杂很多，如 果我们同样在 Python 级别进行循环的话，就会看出其中的差别了。此外， numpy.sin 返回的数的类型和 math.sin 返回的类型有所不同，math.sin 返回的 是 Python 的标准 float 类型，而 numpy.sin 则返回一个 numpy.float64 类型： >>> type(math.sin(0.5)) >>> type(np.sin(0.5)) 通过上面的例子我们了解了如何最有效率地使用 math 库和 numpy 库中的数学 函数。因为它们各有长短，因此在导入时不建议使用*号全部载入，而是应该使 用 import numpy as np 的方式载入，这样我们可以根据需要选择合适的函数调 用。 NumPy 中有众多的 ufunc 函数为我们提供各式各样的计算。除了 sin 这种单输 入函数之外，还有许多多个输入的函数，add 函数就是一个最常用的例子。先来 看一个例子: >>> a = np.arange(0,4) >>> a array([0, 1, 2, 3]) >>> b = np.arange(1,5) >>> b array([1, 2, 3, 4]) >>> np.add(a,b) array([1, 3, 5, 7]) >>> np.add(a,b,a) array([1, 3, 5, 7]) >>> a array([1, 3, 5, 7]) add 函数返回一个新的数组，此数组的每个元素都为两个参数数组的对应元素之 和。它接受第 3 个参数指定计算结果所要写入的数组，如果指定的话，add 函数 就不再产生新的数组。 由于 Python 的操作符重载功能，计算两个数组相加可以简单地写为 a+b，而 np.add(a,b,a)则可以用 a+=b 来表示。下面是数组的运算符和其对应的 ufunc 函 数的一个列表，注意除号"/"的意义根据是否激活__future__.division 有所不同。 y = x1 + x2: add(x1, x2 [, y]) y = x1 - x2: subtract(x1, x2 [, y]) y = x1 * x2: multiply (x1, x2 [, y]) y = x1 / x2: divide (x1, x2 [, y]), 如果两个数组的元素为整数，那么用整数除法 y = x1 / x2: true divide (x1, x2 [, y]), 总是返回精确的商 y = x1 // x2: floor divide (x1, x2 [, y]), 总是对返回值取整 y = -x: negative(x [,y]) y = x1**x2: power(x1, x2 [, y]) y = x1 % x2: remainder(x1, x2 [, y]), mod(x1, x2, [, y]) 数组对象支持这些操作符，极大地简化了算式的编写，不过要注意如果你的算式 很复杂，并且要运算的数组很大的话，会因为产生大量的中间结果而降低程序的 运算效率。例如：假设 a b c 三个数组采用算式 x=a*b+c 计算，那么它相当于: t = a * b x = t + c del t 也就是说需要产生一个数组 t 保存乘法的计算结果，然后再产生最后的结果数组 x。我们可以通过手工将一个算式分解为 x = a*b; x += c，以减少一次内存分配。 通过组合标准的 ufunc 函数的调用，可以实现各种算式的数组计算。不过有些时 候这种算式不易编写，而针对每个元素的计算函数却很容易用 Python 实现，这 时可以用 frompyfunc 函数将一个计算单个元素的函数转换成 ufunc 函数。这样 就可以方便地用所产生的 ufunc 函数对数组进行计算了。让我们来看一个例子。 我们想用一个分段函数描述三角波，三角波的样子如图 2.4 所示： 图 2.4 三角波可以用分段函数进行计算 我们很容易根据上图所示写出如下的计算三角波某点 y 坐标的函数: def triangle_wave(x, c, c0, hc): x = x - int(x) # 三角波的周期为 1，因此只取 x坐标的小数部分进行计 算 if x >= c: r = 0.0 elif x < c0: r = x / c0 * hc else: r = (c-x) / (c-c0) * hc return r 显然 triangle_wave 函数只能计算单个数值，不能对数组直接进行处理。我们可 以用下面的方法先使用列表包容(List comprehension)，计算出一个 list，然后用 array 函数将列表转换为数组： x = np.linspace(0, 2, 1000) y = np.array([triangle_wave(t, 0.6, 0.4, 1.0) for t in x]) 这种做法每次都需要使用列表包容语法调用函数，对于多维数组是很麻烦的。让 我们来看看如何用 frompyfunc 函数来解决这个问题： triangle_ufunc = np.frompyfunc( lambda x: triangle_wave(x, 0.6, 0.4, 1.0), 1, 1) y2 = triangle_ufunc(x) frompyfunc 的调用格式为 frompyfunc(func, nin, nout)，其中 func 是计算单个元 素的函数，nin 是此函数的输入参数的个数，nout 是此函数的返回值的个数。虽 然 triangle_wave 函数有 4 个参数，但是由于后三个 c, c0, hc 在整个计算中值都 是固定的，因此所产生的 ufunc 函数其实只有一个参数。为了满足这个条件，我 们用一个 lambda 函数对 triangle_wave 的参数进行一次包装。这样传入 frompyfunc 的函数就只有一个参数了。这样子做，效率并不是太高，另外还有 一种方法： def triangle_func(c, c0, hc): def trifunc(x): x = x - int(x) # 三角波的周期为 1，因此只取 x坐标的小数部分进 行计算 if x >= c: r = 0.0 elif x < c0: r = x / c0 * hc else: r = (c-x) / (c-c0) * hc return r # 用 trifunc函数创建一个 ufunc函数，可以直接对数组进行计算, 不过通 过此函数 # 计算得到的是一个 Object数组，需要进行类型转换 return np.frompyfunc(trifunc, 1, 1) y2 = triangle_func(0.6, 0.4, 1.0)(x) 我们通过函数 triangle_func 包装三角波的三个参数，在其内部定义一个计算三 角波的函数 trifunc，trifunc 函数在调用时会采用 triangle_func 的参数进行计算。 最后 triangle_func 返回用 frompyfunc 转换结果。 值得注意的是用 frompyfunc 得到的函数计算出的数组元素的类型为 object，因 为 frompyfunc 函数无法保证 Python 函数返回的数据类型都完全一致。因此还需 要再次 y2.astype(np.float64)将其转换为双精度浮点数组。 2.2.1 广播¶ 当我们使用 ufunc 函数对两个数组进行计算时，ufunc 函数会对这两个数组的对 应元素进行计算，因此它要求这两个数组有相同的大小(shape 相同)。如果两个 数组的 shape 不同的话，会进行如下的广播(broadcasting)处理： 1. 让所有输入数组都向其中 shape 最长的数组看齐， shape中不足的部分都通过在 前面加 1 补齐 2. 输出数组的 shape 是输入数 组 shape 的各个轴上的最大 值 3. 如果输入数组的某个轴和输 出数组的对应轴的长度相同 或者其长度为 1 时，这个数组 能够用来计算，否则出错 4. 当输入数组的某个轴的长度 为 1 时，沿着此轴运算时都用 此轴上的第一组值 上述 4 条 规则 编码规则下载淘宝规则下载天猫规则下载麻将竞赛规则pdf麻将竞赛规则pdf 理解起来可能比较费劲，让我们来看一个实际的例子。 先创建一个二维数组 a，其 shape 为(6,1)： >>> a = np.arange(0, 60, 10).reshape(-1, 1) >>> a array([[ 0], [10], [20], [30], [40], [50]]) >>> a.shape (6, 1) 再创建一维数组 b，其 shape 为(5,)： >>> b = np.arange(0, 5) >>> b array([0, 1, 2, 3, 4]) >>> b.shape (5,) 计算 a 和 b 的和，得到一个加法表，它相当于计算 a,b 中所有元素组的和，得到 一个 shape 为(6,5)的数组： >>> c = a + b >>> c array([[ 0, 1, 2, 3, 4], [10, 11, 12, 13, 14], [20, 21, 22, 23, 24], [30, 31, 32, 33, 34], [40, 41, 42, 43, 44], [50, 51, 52, 53, 54]]) >>> c.shape (6, 5) 由于 a和 b的 shape长度(也就是 ndim属性)不同，根据规则 1，需要让 b的 shape 向 a 对齐，于是将 b 的 shape 前面加 1，补齐为(1,5)。相当于做了如下计算： >>> b.shape=1,5 >>> b array([[0, 1, 2, 3,