精华内容
参与话题
问答
  • NumPy使用

    2017-07-09 17:14:53
    NumPy数组的创建 1、 NumPy数组属性 1、NumPy数组下标是从0开始,而且数组中所有元素的类型必须相同。 2、NumPy数组的维数称为秩(rank),一维数组的秩为1,二维数组的秩为2。 3、NumPy数组中重要的属性: (1)...

    NumPy数组的创建

    1、创建数组:array

    2、制定数组类型:dtype

    3、创建特殊数组:

    (1)元素全为0:zeros

    (2)元素全为1:ones

    (3)指定元素范围:arange

    (4)线段性元素:linspace


    NumPy数组属性

    1、NumPy数组下标是从0开始,而且数组中所有元素的类型必须相同。

    2、NumPy数组的维数称为秩(rank),一维数组的秩为1,二维数组的秩为2。

    3、NumPy数组中重要的属性:

    (1)ndim:数组的维数,也就是秩;

    (2)shape:数组的形状;

    (3)size:数组中元素个数;

    (4)dtype:数组中元素的类型。

    4、改变数组的形状:reshape


    Numpy基本运算

    1、加减乘除

    2、矩阵相乘dot

    3、特殊运算:

    (1)sum:求和

    (2)min:最小值

    (3)max:最大值

    (4)mean/average:均值

    (5)sort:排序

    ps:对行或者列进行操作,需要使用axis,当axis=1时,为行;axis=0时,为列

    (6)T/transpose:转秩

    (7)clip:制定元素转换为最大值,最小值

    (8)flatten():将多维矩阵展开为数列


    NumPy索引操作

    (1)取元素

    (2)切片


    NumPy数组合并与分割

    1、合并

    (1)vstack:上下合并

    (2)hstack:左右合并

    (3)concatenate:合并多个矩阵

    2、分割

    (1)split:axis=1纵向等量分割,axis=0横向等量分割

    (2)array_split:不等量分割

    (3)vsplit/hsplit:与split对应


    # -*- coding: utf-8 -*-
    """
    Created on Sun Jul  9 11:10:32 2017
    
    @author: tfygg
    """
    
    import numpy as np
    
    print("数组的创建与属性")
    a = np.array([[1,2], [2,3]])
    print(a)
    print(a.ndim)
    print(a.shape)
    print(a.size)
    print(a.dtype)
    
    b = np.ones((2,4))
    print(b)
    print(b.ndim)
    print(b.shape)
    print(b.size)
    print(b.dtype)
     
    c = np.arange(1,10,1) # 1-10 的数据,步长为1
    print(c)
    
    d = np.linspace(1,20,20) # 开始端1,结束端20,且分割成20个数据,生成线段
    print(d)
    print(d.shape)
    
    e = d.reshape(2,10)
    print(e)
    print(e.shape)
    
    
    print("数组的基本运算")
    a = np.arange(0,20,2).reshape(2,5)
    b = np.linspace(1, 10, 10).reshape(2,5)
    print('a =', a)
    print('b =', b)
    print(a-b)
    print(a+b)
    print(a*b)
    print(a*2)
    print(a/2)
    print(a**2)
    print(np.sum(a))
    print(np.max(a))
    print(np.min(a))
    print(np.sum(a,axis=1))#行
    print(np.max(a,axis=0))#列
    print(np.mean(a,axis=1))
    print(a.T)
    print(np.clip(a,4,13))
    print(np.sort(a))
    print(a.flatten())
    
    print("索引操作")
    a = np.random.rand(3,4)
    print(a)
    print(a[1][1])
    print(a[1,1])
    print(a[1,1:3])
    print(a[:,1:3])
    print(a[:,1])
    
    
    print("矩阵合并与分割")
    a = np.random.rand(2,4)
    b = np.random.rand(1,4)
    c = np.random.rand(2,1)
    print(a)
    print(b)
    print(c)
    print(np.vstack((a,b)))
    print(np.hstack((a,c)))
    d = np.concatenate((a,b,b),axis=0)
    print(d)
    
    print(np.split(a,2,axis=1))
    print(np.split(a,2,axis=0))
    print(np.vsplit(a,2))


    展开全文
  • numpy使用

    千次阅读 2018-01-25 13:58:35
    来源:http://blog.csdn.net/lsjseu/article/details/20359201 用Python做科学计算:基础篇、手册篇、... 先决条件 在阅读这个教程之前,你多少需要知道点Python。如果你想从新回忆下,请看看Python Tutorial

    来源:http://blog.csdn.net/lsjseu/article/details/20359201

    用Python做科学计算:基础篇、手册篇、实战篇:http://old.sebug.net/paper/books/scipydoc/index.html


    先决条件

    在阅读这个教程之前,你多少需要知道点Python。如果你想从新回忆下,请看看Python Tutorial.

    如果你想要运行教程中的示例,你至少需要在你的电脑上安装了以下一些软件:

    这些是可能对你有帮助的:

    • ipython是一个净强化的交互Python Shell,对探索NumPy的特性非常方便。
    • matplotlib将允许你绘图
    • Scipy在NumPy的基础上提供了很多科学模块

    基础篇

    NumPy的主要对象是同种元素的多维数组。这是一个所有的元素都是一种类型、通过一个正整数元组索引的元素表格(通常是元素是数字)。在NumPy中维度(dimensions)叫做轴(axes),轴的个数叫做秩(rank)。

    例如,在3D空间一个点的坐标[1, 2, 3]是一个秩为1的数组,因为它只有一个轴。那个轴长度为3.又例如,在以下例子中,数组的秩为2(它有两个维度).第一个维度长度为2,第二个维度长度为3.

    [[ 1., 0., 0.],
     [ 0., 1., 2.]]

    NumPy的数组类被称作ndarray。通常被称作数组。注意numpy.array和标准Python库类array.array并不相同,后者只处理一维数组和提供少量功能。更多重要ndarray对象属性有:

    • ndarray.ndim

      数组轴的个数,在python的世界中,轴的个数被称作秩

    • ndarray.shape

      数组的维度。这是一个指示数组在每个维度上大小的整数元组。例如一个n排m列的矩阵,它的shape属性将是(2,3),这个元组的长度显然是秩,即维度或者ndim属性

    • ndarray.size

      数组元素的总个数,等于shape属性中元组元素的乘积。

    • ndarray.dtype

      一个用来描述数组中元素类型的对象,可以通过创造或指定dtype使用标准Python类型。另外NumPy提供它自己的数据类型。

    • ndarray.itemsize

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

    • ndarray.data

      包含实际数组元素的缓冲区,通常我们不需要使用这个属性,因为我们总是通过索引来使用数组中的元素。

    一个例子1

    >>> from numpy  import *
    >>> a = arange(15).reshape(3, 5)
    >>> a
    array([[ 0,  1,  2,  3,  4],
           [ 5,  6,  7,  8,  9],
           [10, 11, 12, 13, 14]])
    >>> a.shape
    (3, 5)
    >>> a.ndim
    2
    >>> a.dtype.name
    'int32'
    >>> a.itemsize
    4
    >>> a.size
    15
    >>> type(a)
    numpy.ndarray
    >>> b = array([6, 7, 8])
    >>> b
    array([6, 7, 8])
    >>> type(b)
    numpy.ndarray

    创建数组

    有好几种创建数组的方法。

    例如,你可以使用array函数从常规的Python列表和元组创造数组。所创建的数组类型由原序列中的元素类型推导而来。

    >>> from numpy  import *
    >>> a = array( [2,3,4] )
    >>> a
    array([2, 3, 4])
    >>> a.dtype
    dtype('int32')
    >>> b = array([1.2, 3.5, 5.1])
    >>> b.dtype
    dtype('float64')  一个常见的错误包括用多个数值参数调用`array`而不是提供一个由数值组成的列表作为一个参数。
    
    >>> a = array(1,2,3,4)    # WRONG
    
    >>> a = array([1,2,3,4])  # RIGHT

    数组将序列包含序列转化成二维的数组,序列包含序列包含序列转化成三维数组等等。

    >>> b = array( [ (1.5,2,3), (4,5,6) ] )
    >>> b
    array([[ 1.5,  2. ,  3. ],
           [ 4. ,  5. ,  6. ]])

    数组类型可以在创建时显示指定

    >>> c = array( [ [1,2], [3,4] ], dtype=complex )
    >>> c
    array([[ 1.+0.j,  2.+0.j],
           [ 3.+0.j,  4.+0.j]])

    通常,数组的元素开始都是未知的,但是它的大小已知。因此,NumPy提供了一些使用占位符创建数组的函数。这最小化了扩展数组的需要和高昂的运算代价。

    函数function创建一个全是0的数组,函数ones创建一个全1的数组,函数empty创建一个内容随机并且依赖与内存状态的数组。默认创建的数组类型(dtype)都是float64。

    >>> zeros( (3,4) )
    array([[0.,  0.,  0.,  0.],
           [0.,  0.,  0.,  0.],
           [0.,  0.,  0.,  0.]])
    >>> ones( (2,3,4), dtype=int16 )                # dtype can also be specified
    array([[[ 1, 1, 1, 1],
            [ 1, 1, 1, 1],
            [ 1, 1, 1, 1]],
           [[ 1, 1, 1, 1],
            [ 1, 1, 1, 1],
            [ 1, 1, 1, 1]]], dtype=int16)
    >>> empty( (2,3) )
    array([[  3.73603959e-262,   6.02658058e-154,   6.55490914e-260],
           [  5.30498948e-313,   3.14673309e-307,   1.00000000e+000]])

    为了创建一个数列,NumPy提供一个类似arange的函数返回数组而不是列表:

    >>> arange( 10, 30, 5 )
    array([10, 15, 20, 25])
    >>> arange( 0, 2, 0.3 )                 # it accepts float arguments
    array([ 0. ,  0.3,  0.6,  0.9,  1.2,  1.5,  1.8])

    arange使用浮点数参数时,由于有限的浮点数精度,通常无法预测获得的元素个数。因此,最好使用函数linspace去接收我们想要的元素个数来代替用range来指定步长。

    其它函数array, zeros, zeros_like, ones, ones_like, empty, empty_like, arange, linspace, rand, randn, fromfunction, fromfile参考:NumPy示例

    打印数组

    当你打印一个数组,NumPy以类似嵌套列表的形式显示它,但是呈以下布局:

    • 最后的轴从左到右打印
    • 次后的轴从顶向下打印
    • 剩下的轴从顶向下打印,每个切片通过一个空行与下一个隔开

    一维数组被打印成行,二维数组成矩阵,三维数组成矩阵列表。

    >>> a = arange(6)                         # 1d array
    >>> print a
    [0 1 2 3 4 5]
    >>>
    >>> b = arange(12).reshape(4,3)           # 2d array
    >>> print b
    [[ 0  1  2]
     [ 3  4  5]
     [ 6  7  8]
     [ 9 10 11]]
    >>>
    >>> c = arange(24).reshape(2,3,4)         # 3d array
    >>> print c
    [[[ 0  1  2  3]
      [ 4  5  6  7]
      [ 8  9 10 11]]
    
     [[12 13 14 15]
      [16 17 18 19]
      [20 21 22 23]]]

    查看形状操作一节获得有关reshape的更多细节

    如果一个数组用来打印太大了,NumPy自动省略中间部分而只打印角落

    >>> print arange(10000)
    [   0    1    2 ..., 9997 9998 9999]
    >>>
    >>> print arange(10000).reshape(100,100)
    [[   0    1    2 ...,   97   98   99]
     [ 100  101  102 ...,  197  198  199]
     [ 200  201  202 ...,  297  298  299]
     ...,
     [9700 9701 9702 ..., 9797 9798 9799]
     [9800 9801 9802 ..., 9897 9898 9899]
     [9900 9901 9902 ..., 9997 9998 9999]]

    禁用NumPy的这种行为并强制打印整个数组,你可以设置printoptions参数来更改打印选项。

    >>> set_printoptions(threshold='nan')

    基本运算

    数组的算术运算是按元素的。新的数组被创建并且被结果填充。

    >>> a = array( [20,30,40,50] )
    >>> b = arange( 4 )
    >>> b
    array([0, 1, 2, 3])
    >>> c = a-b
    >>> c
    array([20, 29, 38, 47])
    >>> b**2
    array([0, 1, 4, 9])
    >>> 10*sin(a)
    array([ 9.12945251, -9.88031624,  7.4511316 , -2.62374854])
    >>> a<35
    array([True, True, False, False], dtype=bool)

    不像许多矩阵语言,NumPy中的乘法运算符*指示按元素计算,矩阵乘法可以使用dot函数或创建矩阵对象实现(参见教程中的矩阵章节)

    >>> A = array( [[1,1],
    ...             [0,1]] )
    >>> B = array( [[2,0],
    ...             [3,4]] )
    >>> A*B                         # elementwise product
    array([[2, 0],
           [0, 4]])
    >>> dot(A,B)                    # matrix product
    array([[5, 4],
           [3, 4]])

    有些操作符像+=*=被用来更改已存在数组而不创建一个新的数组。

    >>> a = ones((2,3), dtype=int)
    >>> b = random.random((2,3))
    >>> a *= 3
    >>> a
    array([[3, 3, 3],
           [3, 3, 3]])
    >>> b += a
    >>> b
    array([[ 3.69092703,  3.8324276 ,  3.0114541 ],
           [ 3.18679111,  3.3039349 ,  3.37600289]])
    >>> a += b                                  # b is converted to integer type
    >>> a
    array([[6, 6, 6],
           [6, 6, 6]])

    当运算的是不同类型的数组时,结果数组和更普遍和精确的已知(这种行为叫做upcast)。

    >>> a = ones(3, dtype=int32)
    >>> b = linspace(0,pi,3)
    >>> b.dtype.name
    'float64'
    >>> c = a+b
    >>> c
    array([ 1.        ,  2.57079633,  4.14159265])
    >>> c.dtype.name
    'float64'
    >>> d = exp(c*1j)
    >>> d
    array([ 0.54030231+0.84147098j, -0.84147098+0.54030231j,
           -0.54030231-0.84147098j])
    >>> d.dtype.name
    'complex128' 许多非数组运算,如计算数组所有元素之和,被作为ndarray类的方法实现
    
    >>> a = random.random((2,3))
    >>> a
    array([[ 0.6903007 ,  0.39168346,  0.16524769],
           [ 0.48819875,  0.77188505,  0.94792155]])
    >>> a.sum()
    3.4552372100521485
    >>> a.min()
    0.16524768654743593
    >>> a.max()
    0.9479215542670073

    这些运算默认应用到数组好像它就是一个数字组成的列表,无关数组的形状。然而,指定axis参数你可以吧运算应用到数组指定的轴上:

    >>> b = arange(12).reshape(3,4)
    >>> b
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11]])
    >>>
    >>> b.sum(axis=0)                            # sum of each column
    array([12, 15, 18, 21])
    >>>
    >>> b.min(axis=1)                            # min of each row
    array([0, 4, 8])
    >>>
    >>> b.cumsum(axis=1)                         # cumulative sum along each row
    array([[ 0,  1,  3,  6],
           [ 4,  9, 15, 22],
           [ 8, 17, 27, 38]])

    通用函数(ufunc)

    NumPy提供常见的数学函数如sin,cosexp。在NumPy中,这些叫作“通用函数”(ufunc)。在NumPy里这些函数作用按数组的元素运算,产生一个数组作为输出。

    >>> B = arange(3)
    >>> B
    array([0, 1, 2])
    >>> exp(B)
    array([ 1.        ,  2.71828183,  7.3890561 ])
    >>> sqrt(B)
    array([ 0.        ,  1.        ,  1.41421356])
    >>> C = array([2., -1., 4.])
    >>> add(B, C)
    array([ 2.,  0.,  6.])

    更多函数all, alltrue, any, apply along axis, argmax, argmin, argsort, average, bincount, ceil, clip, conj, conjugate, corrcoef, cov, cross, cumprod, cumsum, diff, dot, floor, inner, inv, lexsort, max, maximum, mean, median, min, minimum, nonzero, outer, prod, re, round, sometrue, sort, std, sum, trace, transpose, var, vdot, vectorize, where 参见:NumPy示例

    索引,切片和迭代

    一维数组可以被索引、切片和迭代,就像列表和其它Python序列。

    >>> a = arange(10)**3
    >>> a
    array([  0,   1,   8,  27,  64, 125, 216, 343, 512, 729])
    >>> a[2]
    8
    >>> a[2:5]
    array([ 8, 27, 64])
    >>> a[:6:2] = -1000    # equivalent to a[0:6:2] = -1000; from start to position 6, exclusive, set every 2nd element to -1000
    >>> a
    array([-1000,     1, -1000,    27, -1000,   125,   216,   343,   512,   729])
    >>> a[ : :-1]                                 # reversed a
    array([  729,   512,   343,   216,   125, -1000,    27, -1000,     1, -1000])
    >>> for i in a:
    ...         print i**(1/3.),
    ...
    nan 1.0 nan 3.0 nan 5.0 6.0 7.0 8.0 9.0

    多维数组可以每个轴有一个索引。这些索引由一个逗号分割的元组给出。

    >>> def f(x,y):
    ...         return 10*x+y
    ...
    >>> b = fromfunction(f,(5,4),dtype=int)
    >>> b
    array([[ 0,  1,  2,  3],
           [10, 11, 12, 13],
           [20, 21, 22, 23],
           [30, 31, 32, 33],
           [40, 41, 42, 43]])
    >>> b[2,3]
    23
    >>> b[0:5, 1]                       # each row in the second column of b
    array([ 1, 11, 21, 31, 41])
    >>> b[ : ,1]                        # equivalent to the previous example
    array([ 1, 11, 21, 31, 41])
    >>> b[1:3, : ]                      # each column in the second and third row of b
    array([[10, 11, 12, 13],
           [20, 21, 22, 23]])

    当少于轴数的索引被提供时,确失的索引被认为是整个切片:

    >>> b[-1]                                  # the last row. Equivalent to b[-1,:]
    array([40, 41, 42, 43])

    b[i]中括号中的表达式被当作i和一系列:,来代表剩下的轴。NumPy也允许你使用“点”像b[i,...]

    (…)代表许多产生一个完整的索引元组必要的分号。如果x是秩为5的数组(即它有5个轴),那么:

    • x[1,2,…] 等同于 x[1,2,:,:,:],
    • x[…,3] 等同于 x[:,:,:,:,3]
    • x[4,…,5,:] 等同 x[4,:,:,5,:].
    >>> c = array( [ [[  0,  1,  2],      # a 3D array (two stacked 2D arrays) ...               [ 10, 12, 13]], ... ...              [[100,101,102], ...               [110,112,113]] ] ) >>> c.shape (2, 2, 3) >>> c[1,...]                          # same as c[1,:,:] or c[1] array([[100, 101, 102],        [110, 112, 113]]) >>> c[...,2]                          # same as c[:,:,2] array([[  2,  13],        [102, 113]]) 

    迭代多维数组是就第一个轴而言的:2

    >>> for row in b:
    ...         print row
    ...
    [0 1 2 3]
    [10 11 12 13]
    [20 21 22 23]
    [30 31 32 33]
    [40 41 42 43]

    然而,如果一个人想对每个数组中元素进行运算,我们可以使用flat属性,该属性是数组元素的一个迭代器:

    >>> for element in b.flat:
    ...         print element,
    ...
    0 1 2 3 10 11 12 13 20 21 22 23 30 31 32 33 40 41 42 43

    更多[], …, newaxis, ndenumerate, indices, index exp 参考NumPy示例

    形状操作

    更改数组的形状

    一个数组的形状由它每个轴上的元素个数给出:

    >>> a = floor(10*random.random((3,4)))
    >>> a
    array([[ 7.,  5.,  9.,  3.],
           [ 7.,  2.,  7.,  8.],
           [ 6.,  8.,  3.,  2.]])
    >>> a.shape
    (3, 4)

    一个数组的形状可以被多种命令修改:

    >>> a.ravel() # flatten the array
    array([ 7.,  5.,  9.,  3.,  7.,  2.,  7.,  8.,  6.,  8.,  3.,  2.])
    >>> a.shape = (6, 2)
    >>> a.transpose()
    array([[ 7.,  9.,  7.,  7.,  6.,  3.],
           [ 5.,  3.,  2.,  8.,  8.,  2.]])

    ravel()展平的数组元素的顺序通常是“C风格”的,就是说,最右边的索引变化得最快,所以元素a[0,0]之后是a[0,1]。如果数组被改变形状(reshape)成其它形状,数组仍然是“C风格”的。NumPy通常创建一个以这个顺序保存数据的数组,所以ravel()将总是不需要复制它的参数3。但是如果数组是通过切片其它数组或有不同寻常的选项时,它可能需要被复制。函数reshape()ravel()还可以被同过一些可选参数构建成FORTRAN风格的数组,即最左边的索引变化最快。

    reshape函数改变参数形状并返回它,而resize函数改变数组自身。

    >>> a
    array([[ 7.,  5.],
           [ 9.,  3.],
           [ 7.,  2.],
           [ 7.,  8.],
           [ 6.,  8.],
           [ 3.,  2.]])
    >>> a.resize((2,6))
    >>> a
    array([[ 7.,  5.,  9.,  3.,  7.,  2.],
           [ 7.,  8.,  6.,  8.,  3.,  2.]])

    如果在改变形状操作中一个维度被给做-1,其维度将自动被计算

    更多 shape, reshape, resize, ravel 参考NumPy示例

    组合(stack)不同的数组

    几种方法可以沿不同轴将数组堆叠在一起:

    >>> a = floor(10*random.random((2,2)))
    >>> a
    array([[ 1.,  1.],
           [ 5.,  8.]])
    >>> b = floor(10*random.random((2,2)))
    >>> b
    array([[ 3.,  3.],
           [ 6.,  0.]])
    >>> vstack((a,b))
    array([[ 1.,  1.],
           [ 5.,  8.],
           [ 3.,  3.],
           [ 6.,  0.]])
    >>> hstack((a,b))
    array([[ 1.,  1.,  3.,  3.],
           [ 5.,  8.,  6.,  0.]])

    函数column_stack以列将一维数组合成二维数组,它等同与vstack对一维数组。

    >>> column_stack((a,b))   # With 2D arrays
    array([[ 1.,  1.,  3.,  3.],
           [ 5.,  8.,  6.,  0.]])
    >>> a=array([4.,2.])
    >>> b=array([2.,8.])
    >>> a[:,newaxis]  # This allows to have a 2D columns vector
    array([[ 4.],
           [ 2.]])
    >>> column_stack((a[:,newaxis],b[:,newaxis]))
    array([[ 4.,  2.],
           [ 2.,  8.]])
    >>> vstack((a[:,newaxis],b[:,newaxis])) # The behavior of vstack is different
    array([[ 4.],
           [ 2.],
           [ 2.],
           [ 8.]])

    row_stack函数,另一方面,将一维数组以行组合成二维数组。

    对那些维度比二维更高的数组,hstack沿着第二个轴组合,vstack沿着第一个轴组合,concatenate允许可选参数给出组合时沿着的轴。

    Note

    在复杂情况下,r_[]c_[]对创建沿着一个方向组合的数很有用,它们允许范围符号(“:”):

    >>> r_[1:4,0,4]
    array([1, 2, 3, 0, 4])

    当使用数组作为参数时,r_c_的默认行为和vstackhstack很像,但是允许可选的参数给出组合所沿着的轴的代号。

    更多函数hstack , vstack, column_stack , row_stack , concatenate , c_ , r_ 参见NumPy示例.

    将一个数组分割(split)成几个小数组

    使用hsplit你能将数组沿着它的水平轴分割,或者指定返回相同形状数组的个数,或者指定在哪些列后发生分割:

    >>> a = floor(10*random.random((2,12)))
    >>> a
    array([[ 8.,  8.,  3.,  9.,  0.,  4.,  3.,  0.,  0.,  6.,  4.,  4.],
           [ 0.,  3.,  2.,  9.,  6.,  0.,  4.,  5.,  7.,  5.,  1.,  4.]])
    >>> hsplit(a,3)   # Split a into 3
    [array([[ 8.,  8.,  3.,  9.],
           [ 0.,  3.,  2.,  9.]]), array([[ 0.,  4.,  3.,  0.],
           [ 6.,  0.,  4.,  5.]]), array([[ 0.,  6.,  4.,  4.],
           [ 7.,  5.,  1.,  4.]])]
    >>> hsplit(a,(3,4))   # Split a after the third and the fourth column
    [array([[ 8.,  8.,  3.],
           [ 0.,  3.,  2.]]), array([[ 9.],
           [ 9.]]), array([[ 0.,  4.,  3.,  0.,  0.,  6.,  4.,  4.],
           [ 6.,  0.,  4.,  5.,  7.,  5.,  1.,  4.]])]

    vsplit沿着纵向的轴分割,array split允许指定沿哪个轴分割。

    复制和视图

    当运算和处理数组时,它们的数据有时被拷贝到新的数组有时不是。这通常是新手的困惑之源。这有三种情况:

    完全不拷贝

    简单的赋值不拷贝数组对象或它们的数据。

    >>> a = arange(12)
    >>> b = a            # no new object is created
    >>> b is a           # a and b are two names for the same ndarray object
    True
    >>> b.shape = 3,4    # changes the shape of a
    >>> a.shape
    (3, 4)

    Python 传递不定对象作为参考4,所以函数调用不拷贝数组。

    >>> def f(x):
    ...     print id(x)
    ...
    >>> id(a)                           # id is a unique identifier of an object
    148293216
    >>> f(a)
    148293216

    视图(view)和浅复制

    不同的数组对象分享同一个数据。视图方法创造一个新的数组对象指向同一数据。

    >>> c = a.view()
    >>> c is a
    False
    >>> c.base is a                        # c is a view of the data owned by a
    True
    >>> c.flags.owndata
    False
    >>>
    >>> c.shape = 2,6                      # a's shape doesn't change
    >>> a.shape
    (3, 4)
    >>> c[0,4] = 1234                      # a's data changes
    >>> a
    array([[   0,    1,    2,    3],
           [1234,    5,    6,    7],
           [   8,    9,   10,   11]])

    切片数组返回它的一个视图:

    >>> s = a[ : , 1:3]     # spaces added for clarity; could also be written "s = a[:,1:3]"
    >>> s[:] = 10           # s[:] is a view of s. Note the difference between s=10 and s[:]=10
    >>> a
    array([[   0,   10,   10,    3],
           [1234,   10,   10,    7],
           [   8,   10,   10,   11]])

    深复制

    这个复制方法完全复制数组和它的数据。

    >>> d = a.copy()                          # a new array object with new data is created
    >>> d is a
    False
    >>> d.base is a                           # d doesn't share anything with a
    False
    >>> d[0,0] = 9999
    >>> a
    array([[   0,   10,   10,    3],
           [1234,   10,   10,    7],
           [   8,   10,   10,   11]])

    函数和方法(method)总览

    这是个NumPy函数和方法分类排列目录。这些名字链接到NumPy示例,你可以看到这些函数起作用。[^5]

    创建数组

    arange, array, copy, empty, empty_like, eye, fromfile, fromfunction, identity, linspace, logspace, mgrid, ogrid, ones, ones_like, r , zeros, zeros_like 

    转化

    astype, atleast 1d, atleast 2d, atleast 3d, mat 

    操作

    array split, column stack, concatenate, diagonal, dsplit, dstack, hsplit, hstack, item, newaxis, ravel, repeat, reshape, resize, squeeze, swapaxes, take, transpose, vsplit, vstack 

    询问

    all, any, nonzero, where 

    排序

    argmax, argmin, argsort, max, min, ptp, searchsorted, sort 

    运算

    choose, compress, cumprod, cumsum, inner, fill, imag, prod, put, putmask, real, sum 

    基本统计

    cov, mean, std, var 

    基本线性代数

    cross, dot, outer, svd, vdot

    进阶

    广播法则(rule)

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

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

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

    应用广播法则之后,所有数组的大小必须匹配。更多细节可以从这个文档找到。

    花哨的索引和索引技巧

    NumPy比普通Python序列提供更多的索引功能。除了索引整数和切片,正如我们之前看到的,数组可以被整数数组和布尔数组索引。

    通过数组索引

    >>> a = arange(12)**2                          # the first 12 square numbers
    >>> i = array( [ 1,1,3,8,5 ] )                 # an array of indices
    >>> a[i]                                       # the elements of a at the positions i
    array([ 1,  1,  9, 64, 25])
    >>>
    >>> j = array( [ [ 3, 4], [ 9, 7 ] ] )         # a bidimensional array of indices
    >>> a[j]                                       # the same shape as j
    array([[ 9, 16],
           [81, 49]])

    当被索引数组a是多维的时,每一个唯一的索引数列指向a的第一维5。以下示例通过将图片标签用调色版转换成色彩图像展示了这种行为。

    >>> palette = array( [ [0,0,0],                # black
    ...                    [255,0,0],              # red
    ...                    [0,255,0],              # green
    ...                    [0,0,255],              # blue
    ...                    [255,255,255] ] )       # white
    >>> image = array( [ [ 0, 1, 2, 0 ],           # each value corresponds to a color in the palette
    ...                  [ 0, 3, 4, 0 ]  ] )
    >>> palette[image]                            # the (2,4,3) color image
    array([[[  0,   0,   0],
            [255,   0,   0],
            [  0, 255,   0],
            [  0,   0,   0]],
           [[  0,   0,   0],
            [  0,   0, 255],
            [255, 255, 255],
            [  0,   0,   0]]])

    我们也可以给出不不止一维的索引,每一维的索引数组必须有相同的形状。

    >>> a = arange(12).reshape(3,4)
    >>> a
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11]])
    >>> i = array( [ [0,1],                        # indices for the first dim of a
    ...              [1,2] ] )
    >>> j = array( [ [2,1],                        # indices for the second dim
    ...              [3,3] ] )
    >>>
    >>> a[i,j]                                     # i and j must have equal shape
    array([[ 2,  5],
           [ 7, 11]])
    >>>
    >>> a[i,2]
    array([[ 2,  6],
           [ 6, 10]])
    >>>
    >>> a[:,j]                                     # i.e., a[ : , j]
    array([[[ 2,  1],
            [ 3,  3]],
           [[ 6,  5],
            [ 7,  7]],
           [[10,  9],
            [11, 11]]])

    自然,我们可以把i和j放到序列中(比如说列表)然后通过list索引。

    >>> l = [i,j]
    >>> a[l]                                       # equivalent to a[i,j]
    array([[ 2,  5],
           [ 7, 11]])

    然而,我们不能把i和j放在一个数组中,因为这个数组将被解释成索引a的第一维。

    >>> s = array( [i,j] )
    
    
    
    
    

    >>> a[s] # not what we want --------------------------------------------------------------------------- IndexError Traceback (most recent call last) <ipython-input-100-b912f631cc75> in <module>() ----> 1 a[s] IndexError: index (3) out of range (0<=index<2) in dimension 0 >>> >>> a[tuple(s)] # same as a[i,j] array([[ 2, 5], [ 7, 11]])

    另一个常用的数组索引用法是搜索时间序列最大值6

    >>> time = linspace(20, 145, 5)                 # time scale
    >>> data = sin(arange(20)).reshape(5,4)         # 4 time-dependent series
    >>> time
    array([  20.  ,   51.25,   82.5 ,  113.75,  145.  ])
    >>> data
    array([[ 0.        ,  0.84147098,  0.90929743,  0.14112001],
           [-0.7568025 , -0.95892427, -0.2794155 ,  0.6569866 ],
           [ 0.98935825,  0.41211849, -0.54402111, -0.99999021],
           [-0.53657292,  0.42016704,  0.99060736,  0.65028784],
           [-0.28790332, -0.96139749, -0.75098725,  0.14987721]])
    >>>
    >>> ind = data.argmax(axis=0)                   # index of the maxima for each series
    >>> ind
    array([2, 0, 3, 1])
    >>>
    >>> time_max = time[ ind]                       # times corresponding to the maxima
    >>>
    >>> data_max = data[ind, xrange(data.shape[1])] # => data[ind[0],0], data[ind[1],1]...
    >>>
    >>> time_max
    array([  82.5 ,   20.  ,  113.75,   51.25])
    >>> data_max
    array([ 0.98935825,  0.84147098,  0.99060736,  0.6569866 ])
    >>>
    >>> all(data_max == data.max(axis=0))
    True

    你也可以使用数组索引作为目标来赋值:

    >>> a = arange(5)
    >>> a
    array([0, 1, 2, 3, 4])
    >>> a[[1,3,4]] = 0
    >>> a
    array([0, 0, 2, 0, 0])

    然而,当一个索引列表包含重复时,赋值被多次完成,保留最后的值:

    >>> a = arange(5)
    >>> a[[0,0,2]]=[1,2,3]
    >>> a
    array([2, 1, 3, 3, 4])

    这足够合理,但是小心如果你想用Python的+=结构,可能结果并非你所期望:

    >>> a = arange(5)
    >>> a[[0,0,2]]+=1
    >>> a
    array([1, 1, 3, 3, 4])

    即使0在索引列表中出现两次,索引为0的元素仅仅增加一次。这是因为Python要求a+=1a=a+1等同。

    通过布尔数组索引

    当我们使用整数数组索引数组时,我们提供一个索引列表去选择。通过布尔数组索引的方法是不同的我们显式地选择数组中我们想要和不想要的元素。

    我们能想到的使用布尔数组的索引最自然方式就是使用和原数组一样形状的布尔数组。

    >>> a = arange(12).reshape(3,4)
    >>> b = a > 4
    >>> b                                          # b is a boolean with a's shape
    array([[False, False, False, False],
           [False, True, True, True],
           [True, True, True, True]], dtype=bool)
    >>> a[b]                                       # 1d array with the selected elements
    array([ 5,  6,  7,  8,  9, 10, 11])

    这个属性在赋值时非常有用:

    >>> a[b] = 0                                   # All elements of 'a' higher than 4 become 0
    >>> a
    array([[0, 1, 2, 3],
           [4, 0, 0, 0],
           [0, 0, 0, 0]])

    你可以参考曼德博集合示例看看如何使用布尔索引来生成曼德博集合的图像。

    第二种通过布尔来索引的方法更近似于整数索引;对数组的每个维度我们给一个一维布尔数组来选择我们想要的切片。

    >>> a = arange(12).reshape(3,4)
    >>> b1 = array([False,True,True])             # first dim selection
    >>> b2 = array([True,False,True,False])       # second dim selection
    >>>
    >>> a[b1,:]                                   # selecting rows
    array([[ 4,  5,  6,  7],
           [ 8,  9, 10, 11]])
    >>>
    >>> a[b1]                                     # same thing
    array([[ 4,  5,  6,  7],
           [ 8,  9, 10, 11]])
    >>>
    >>> a[:,b2]                                   # selecting columns
    array([[ 0,  2],
           [ 4,  6],
           [ 8, 10]])
    >>>
    >>> a[b1,b2]                                  # a weird thing to do
    array([ 4, 10])

    注意一维数组的长度必须和你想要切片的维度或轴的长度一致,在之前的例子中,b1是一个秩为1长度为三的数组(a的行数),b2(长度为4)与a的第二秩(列)相一致。7

    ix_()函数

    ix_函数可以为了获得多元组的结果而用来结合不同向量。例如,如果你想要用所有向量a、b和c元素组成的三元组来计算a+b*c

    >>> a = array([2,3,4,5])
    >>> b = array([8,5,4])
    >>> c = array([5,4,6,8,3])
    >>> ax,bx,cx = ix_(a,b,c)
    >>> ax
    array([[[2]],
    
           [[3]],
    
           [[4]],
    
           [[5]]])
    >>> bx
    array([[[8],
            [5],
            [4]]])
    >>> cx
    array([[[5, 4, 6, 8, 3]]])
    >>> ax.shape, bx.shape, cx.shape
    ((4, 1, 1), (1, 3, 1), (1, 1, 5))
    >>> result = ax+bx*cx
    >>> result
    array([[[42, 34, 50, 66, 26],
            [27, 22, 32, 42, 17],
            [22, 18, 26, 34, 14]],
           [[43, 35, 51, 67, 27],
            [28, 23, 33, 43, 18],
            [23, 19, 27, 35, 15]],
           [[44, 36, 52, 68, 28],
            [29, 24, 34, 44, 19],
            [24, 20, 28, 36, 16]],
           [[45, 37, 53, 69, 29],
            [30, 25, 35, 45, 20],
            [25, 21, 29, 37, 17]]])
    >>> result[3,2,4]
    17
    >>> a[3]+b[2]*c[4]
    17

    你也可以实行如下简化:

    def ufunc_reduce(ufct, *vectors):
        vs = ix_(*vectors)
        r = ufct.identity
        for v in vs:
            r = ufct(r,v)
        return r

    然后这样使用它:

    >>> ufunc_reduce(add,a,b,c)
    array([[[15, 14, 16, 18, 13],
            [12, 11, 13, 15, 10],
            [11, 10, 12, 14,  9]],
           [[16, 15, 17, 19, 14],
            [13, 12, 14, 16, 11],
            [12, 11, 13, 15, 10]],
           [[17, 16, 18, 20, 15],
            [14, 13, 15, 17, 12],
            [13, 12, 14, 16, 11]],
           [[18, 17, 19, 21, 16],
            [15, 14, 16, 18, 13],
            [14, 13, 15, 17, 12]]])

    这个reduce与ufunc.reduce(比如说add.reduce)相比的优势在于它利用了广播法则,避免了创建一个输出大小乘以向量个数的参数数组。8

    用字符串索引

    参见RecordArray

    线性代数

    继续前进,基本线性代数包含在这里。

    简单数组运算

    参考numpy文件夹中的linalg.py获得更多信息

    >>> from numpy import *
    >>> from numpy.linalg import *
    
    >>> a = array([[1.0, 2.0], [3.0, 4.0]])
    >>> print a
    [[ 1.  2.]
     [ 3.  4.]]
    
    >>> a.transpose()
    array([[ 1.,  3.],
           [ 2.,  4.]])
    
    >>> inv(a)
    array([[-2. ,  1. ],
           [ 1.5, -0.5]])
    
    >>> u = eye(2) # unit 2x2 matrix; "eye" represents "I"
    >>> u
    array([[ 1.,  0.],
           [ 0.,  1.]])
    >>> j = array([[0.0, -1.0], [1.0, 0.0]])
    
    >>> dot (j, j) # matrix product
    array([[-1.,  0.],
           [ 0., -1.]])
    
    >>> trace(u)  # trace
     2.0
    
    >>> y = array([[5.], [7.]])
    >>> solve(a, y)
    array([[-3.],
           [ 4.]])
    
    >>> eig(j)
    (array([ 0.+1.j,  0.-1.j]),
    array([[ 0.70710678+0.j,  0.70710678+0.j],
           [ 0.00000000-0.70710678j,  0.00000000+0.70710678j]]))
    Parameters:
        square matrix
    
    Returns
        The eigenvalues, each repeated according to its multiplicity.
    
        The normalized (unit "length") eigenvectors, such that the
        column ``v[:,i]`` is the eigenvector corresponding to the
        eigenvalue ``w[i]`` .

    矩阵类

    这是一个关于矩阵类的简短介绍。

    >>> A = matrix('1.0 2.0; 3.0 4.0')
    >>> A
    [[ 1.  2.]
     [ 3.  4.]]
    >>> type(A)  # file where class is defined
    <class 'numpy.matrixlib.defmatrix.matrix'>
    
    >>> A.T  # transpose
    [[ 1.  3.]
     [ 2.  4.]]
    
    >>> X = matrix('5.0 7.0')
    >>> Y = X.T
    >>> Y
    [[5.]
     [7.]]
    
    >>> print A*Y  # matrix multiplication
    [[19.]
     [43.]]
    
    >>> print A.I  # inverse
    [[-2.   1. ]
     [ 1.5 -0.5]]
    
    >>> solve(A, Y)  # solving linear equation
    matrix([[-3.],
            [ 4.]])

    索引:比较矩阵和二维数组

    注意NumPy中数组和矩阵有些重要的区别。NumPy提供了两个基本的对象:一个N维数组对象和一个通用函数对象。其它对象都是建构在它们之上 的。特别的,矩阵是继承自NumPy数组对象的二维数组对象。对数组和矩阵,索引都必须包含合适的一个或多个这些组合:整数标量、省略号 (ellipses)、整数列表;布尔值,整数或布尔值构成的元组,和一个一维整数或布尔值数组。矩阵可以被用作矩阵的索引,但是通常需要数组、列表或者 其它形式来完成这个任务。

    像平常在Python中一样,索引是从0开始的。传统上我们用矩形的行和列表示一个二维数组或矩阵,其中沿着0轴的方向被穿过的称作行,沿着1轴的方向被穿过的是列。9

    让我们创建数组和矩阵用来切片:

    >>> A = arange(12)
    >>> A
    array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
    >>> A.shape = (3,4)
    >>> M = mat(A.copy())
    >>> print type(A),"  ",type(M)
    <type 'numpy.ndarray'>    <class 'numpy.core.defmatrix.matrix'>
    >>> print A
    [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]]
    >>> print M
    [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]]

    现在,让我们简单的切几片。基本的切片使用切片对象或整数。例如,A[:]M[:]的求值将表现得和Python索引很相似。然而要注意很重要的一点就是NumPy切片数组创建数据的副本;切片提供统一数据的视图。

    >>> print A[:]; print A[:].shape
    [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]]
    (3, 4)
    >>> print M[:]; print M[:].shape
    [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]]
    (3, 4)

    现在有些和Python索引不同的了:你可以同时使用逗号分割索引来沿着多个轴索引。

    >>> print A[:,1]; print A[:,1].shape
    [1 5 9]
    (3,)
    >>> print M[:,1]; print M[:,1].shape
    [[1]
     [5]
     [9]]
    (3, 1)

    注意最后两个结果的不同。对二维数组使用一个冒号产生一个一维数组,然而矩阵产生了一个二维矩阵。10例如,一个M[2,:]切片产生了一个形状为(1,4)的矩阵,相比之下,一个数组的切片总是产生一个最低可能维度11的数组。例如,如果C是一个三维数组,C[...,1]产生一个二维的数组而C[1,:,1]产生一个一维数组。从这时开始,如果相应的矩阵切片结果是相同的话,我们将只展示数组切片的结果。

    假如我们想要一个数组的第一列和第三列,一种方法是使用列表切片:

    >>> A[:,[1,3]]
    array([[ 1,  3],
           [ 5,  7],
           [ 9, 11]])

    稍微复杂点的方法是使用take()方法(method):

    >>> A[:,].take([1,3],axis=1)
    array([[ 1,  3],
           [ 5,  7],
           [ 9, 11]])

    如果我们想跳过第一行,我们可以这样:

    >>> A[1:,].take([1,3],axis=1)
    array([[ 5,  7],
           [ 9, 11]])

    或者我们仅仅使用A[1:,[1,3]]。还有一种方法是通过矩阵向量积(叉积)。

    >>> A[ix_((1,2),(1,3))]
    array([[ 5,  7],
           [ 9, 11]])

    为了读者的方便,在次写下之前的矩阵:

    >>> A[ix_((1,2),(1,3))]
    array([[ 5,  7],
           [ 9, 11]])

    现在让我们做些更复杂的。比如说我们想要保留第一行大于1的列。一种方法是创建布尔索引:

    >>> A[0,:]>1
    array([False, False, True, True], dtype=bool)
    >>> A[:,A[0,:]>1]
    array([[ 2,  3],
           [ 6,  7],
           [10, 11]])

    就是我们想要的!但是索引矩阵没这么方便。

    >>> M[0,:]>1
    matrix([[False, False, True, True]], dtype=bool)
    >>> M[:,M[0,:]>1]
    matrix([[2, 3]])

    这个过程的问题是用“矩阵切片”来切片产生一个矩阵12,但是矩阵有个方便的A属性,它的值是数组呈现的。所以我们仅仅做以下替代:

    >>> M[:,M.A[0,:]>1]
    matrix([[ 2,  3],
            [ 6,  7],
            [10, 11]])

    如果我们想要在矩阵两个方向有条件地切片,我们必须稍微调整策略,代之以:

    >>> A[A[:,0]>2,A[0,:]>1]
    array([ 6, 11])
    >>> M[M.A[:,0]>2,M.A[0,:]>1]
    matrix([[ 6, 11]])

    我们需要使用向量积ix_:

    >>> A[ix_(A[:,0]>2,A[0,:]>1)]
    array([[ 6,  7],
           [10, 11]])
    >>> M[ix_(M.A[:,0]>2,M.A[0,:]>1)]
    matrix([[ 6,  7],
            [10, 11]])

    技巧和提示

    下面我们给出简短和有用的提示。

    “自动”改变形状

    更改数组的维度,你可以省略一个尺寸,它将被自动推导出来。

    >>> a = arange(30)
    >>> a.shape = 2,-1,3  # -1 means "whatever is needed"
    >>> a.shape
    (2, 5, 3)
    >>> a
    array([[[ 0,  1,  2],
            [ 3,  4,  5],
            [ 6,  7,  8],
            [ 9, 10, 11],
            [12, 13, 14]],
           [[15, 16, 17],
            [18, 19, 20],
            [21, 22, 23],
            [24, 25, 26],
            [27, 28, 29]]])

    向量组合(stacking)

    我们如何用两个相同尺寸的行向量列表构建一个二维数组?在MATLAB中这非常简单:如果x和y是两个相同长度的向量,你仅仅需要做m=[x;y]。在NumPy中这个过程通过函数column_stackdstackhstackvstack来完成,取决于你想要在那个维度上组合。例如:

    x = arange(0,10,2)                     # x=([0,2,4,6,8])
    y = arange(5)                          # y=([0,1,2,3,4])
    m = vstack([x,y])                      # m=([[0,2,4,6,8],
                                           #     [0,1,2,3,4]])
    xy = hstack([x,y])                     # xy =([0,2,4,6,8,0,1,2,3,4])

    二维以上这些函数背后的逻辑会很奇怪。

    参考写个Matlab用户的NumPy指南并且在这里添加你的新发现: )

    直方图(histogram)

    NumPy中histogram函数应用到一个数组返回一对变量:直方图数组和箱式向量。注意:matplotlib也有一个用来建立直方图的函数(叫作hist,正如matlab中一样)与NumPy中的不同。主要的差别是pylab.hist自动绘制直方图,而numpy.histogram仅仅产生数据。

    import numpy
    import pylab
    
    
    
    
    
    # Build a vector of 10000 normal deviates with variance 0.5^2 and mean 2 mu, sigma = 2, 0.5 v = numpy.random.normal(mu,sigma,10000) # Plot a normalized histogram with 50 bins pylab.hist(v, bins=50, normed=1) # matplotlib version (plot) pylab.show() # Compute the histogram with numpy and then plot it (n, bins) = numpy.histogram(v, bins=50, normed=True) # NumPy version (no plot) pylab.plot(.5*(bins[1:]+bins[:-1]), n) pylab.show()


    2 NumPy-快速处理数据

    标准安装的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 就是用组元交换变量值的一个例子。

    _images/numpy_intro_02.png

    图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]])
    


    多维数组同样也可以使用整数序列和布尔数组进行存取。

    _images/numpy_intro_03.png

    图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', '<i4'), ('weight', '<f4')])
    

    这里我们看到了另外一种描述结构类型的方法: 一个包含多个组元的列表,其中形如 (字段名, 类型描述) 的组元描述了结构中的每个字段。类型描述前面为我们添加了 ‘|’, ‘<’ 等字符,这些字符用来描述字段值的字节顺序:

    • | : 忽视字节顺序
    • < : 低位字节在前
    • > : 高位字节在前

    结构数组的存取方式和一般数组相同,通过下标能够取得其中的元素,注意元素的值看上去像是组元,实际上它是一个结构:

    >>> a[0]
    ('Zhang', 32, 75.5)
    >>> a[0].dtype
    dtype([('name', '|S32'), ('age', '<i4'), ('weight', '<f4')])
    

    a[0]是一个结构元素,它和数组a共享内存数据,因此可以通过修改它的字段,改变原始数组中的对应字段:

    >>> 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语言的对齐规范的话,将会出现数据错位。为了解决这个问题,在创建dtype对象时,可以传递参数align=True,这样numpy的结构数组的内存对齐和C语言的结构体就一致了。

    #include <stdio.h>
    
    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', '<i2')])])
    

    当某个字段类型为数组时,用组元的第三个参数表示,下面描述的f1字段是一个shape为(2,3)的双精度浮点数组:

    >>> np.dtype([('f0', 'i4'), ('f1', 'f8', (2, 3))])
    dtype([('f0', '<i4'), ('f1', '<f8', (2, 3))])
    

    用下面的字典参数也可以定义结构类型,字典的关键字为结构中字段名,值为字段的类型描述,但是由于字典的关键字是没有顺序的,因此字段的顺序需要在类型描述中给出,类型描述是一个组元,它的第二个值给出字段的字节为单位的偏移量,例如age字段的偏移量为25个字节:

    >>> np.dtype({'surname':('S25',0),'age':(np.uint8,25)})
    dtype([('surname', '|S25'), ('age', '|u1')])
    


    2.1.5 内存结构

    下面让我们来看看ndarray数组对象是如何在内存中储存的。如图2.3所示,关于数组的描述信息保存在一个数据结构中,这个结构引用两个对象:一块用于保存数据的存储区域和一个用于描述元素类型的dtype对象。

    _images/numpy_memory_struct.png

    图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 'float'>
    >>> type(np.sin(0.5))
    <type 'numpy.float64'>
    

    通过上面的例子我们了解了如何最有效率地使用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所示:

    _images/numpy_intro_01.png

    图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条规则理解起来可能比较费劲,让我们来看一个实际的例子。

    先创建一个二维数组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, 4]])
    

    这样加法运算的两个输入数组的shape分别为(6,1)和(1,5),根据规则2,输出数组的各个轴的长度为输入数组各个轴上的长度的最大值,可知输出数组的shape为(6,5)。

    由于b的第0轴上的长度为1,而a的第0轴上的长度为6,因此为了让它们在第0轴上能够相加,需要将b在第0轴上的长度扩展为6,这相当于:

    >>> b = b.repeat(6,axis=0)
    >>> b
    array([[0, 1, 2, 3, 4],
           [0, 1, 2, 3, 4],
           [0, 1, 2, 3, 4],
           [0, 1, 2, 3, 4],
           [0, 1, 2, 3, 4],
           [0, 1, 2, 3, 4]])
    

    由于a的第1轴的长度为1,而b的第一轴长度为5,因此为了让它们在第1轴上能够相加,需要将a在第1轴上的长度扩展为5,这相当于:

    >>> a = a.repeat(5, axis=1)
    >>> a
    array([[ 0,  0,  0,  0,  0],
           [10, 10, 10, 10, 10],
           [20, 20, 20, 20, 20],
           [30, 30, 30, 30, 30],
           [40, 40, 40, 40, 40],
           [50, 50, 50, 50, 50]])
    

    经过上述处理之后,a和b就可以按对应元素进行相加运算了。

    当然,numpy在执行a+b运算时,其内部并不会真正将长度为1的轴用repeat函数进行扩展,如果这样做的话就太浪费空间了。

    由于这种广播计算很常用,因此numpy提供了一个快速产生如上面a,b数组的方法: ogrid对象:

    >>> x,y = np.ogrid[0:5,0:5]
    >>> x
    array([[0],
           [1],
           [2],
           [3],
           [4]])
    >>> y
    array([[0, 1, 2, 3, 4]])
    

    ogrid是一个很有趣的对象,它像一个多维数组一样,用切片组元作为下标进行存取,返回的是一组可以用来广播计算的数组。其切片下标有两种形式:

    • 开始值:结束值:步长,和np.arange(开始值, 结束值, 步长)类似

    • 开始值:结束值:长度j,当第三个参数为虚数时,它表示返回的数组的长度,和np.linspace(开始值, 结束值, 长度)类似:

      >>> x, y = np.ogrid[0:1:4j, 0:1:3j]
      >>> x
      array([[ 0.        ],
             [ 0.33333333],
             [ 0.66666667],
             [ 1.        ]])
      >>> y
      array([[ 0. ,  0.5,  1. ]])
      

    ogrid为什么不是函数

    根据Python的语法,只有在中括号中才能使用用冒号隔开的切片语法,如果ogrid是函数的话,那么这些切片必须使用slice函数创建,这显然会增加代码的长度。

    利用ogrid的返回值,我能很容易计算x, y网格面上各点的值,或者x, y, z网格体上各点的值。下面是绘制三维曲面 x * exp(x**2 - y**2) 的程序:

    import numpy as np
    from enthought.mayavi import mlab
    
    x, y = np.ogrid[-2:2:20j, -2:2:20j]
    z = x * np.exp( - x**2 - y**2)
    
    pl = mlab.surf(x, y, z, warp_scale="auto")
    mlab.axes(xlabel='x', ylabel='y', zlabel='z')
    mlab.outline(pl)
    

    此程序使用mayavi的mlab库快速绘制如图2.5所示的3D曲面,关于mlab的相关内容将在今后的章节进行介绍。

    _images/numpy_intro_04.png

    图2.5 使用ogrid创建的三维曲面

    2.2.2 ufunc的方法

    ufunc函数本身还有些方法,这些方法只对两个输入一个输出的ufunc函数有效,其它的ufunc对象调用这些方法时会抛出ValueError异常。

    reduce 方法和Python的reduce函数类似,它沿着axis轴对array进行操作,相当于将<op>运算符插入到沿axis轴的所有子数组或者元素当中。

    <op>.reduce (array=, axis=0, dtype=None)

    例如:

    >>> np.add.reduce([1,2,3]) # 1 + 2 + 3
    6
    >>> np.add.reduce([[1,2,3],[4,5,6]], axis=1) # 1,4 + 2,5 + 3,6
    array([ 6, 15])
    

    accumulate 方法和reduce方法类似,只是它返回的数组和输入的数组的shape相同,保存所有的中间计算结果:

    >>> np.add.accumulate([1,2,3])
    array([1, 3, 6])
    >>> np.add.accumulate([[1,2,3],[4,5,6]], axis=1)
    array([[ 1,  3,  6],
           [ 4,  9, 15]])
    

    reduceat 方法计算多组reduce的结果,通过indices参数指定一系列reduce的起始和终了位置。reduceat的计算有些特别,让我们通过一个例子来解释一下:

    >>> a = np.array([1,2,3,4])
    >>> result = np.add.reduceat(a,indices=[0,1,0,2,0,3,0])
    >>> result
    array([ 1,  2,  3,  3,  6,  4, 10])
    

    对于indices中的每个元素都会调用reduce函数计算出一个值来,因此最终计算结果的长度和indices的长度相同。结果result数组中除最后一个元素之外,都按照如下计算得出:

    if indices[i] < indices[i+1]:
        result[i] = np.reduce(a[indices[i]:indices[i+1]])
    else:
        result[i] = a[indices[i]

    而最后一个元素如下计算:

    np.reduce(a[indices[-1]:])
    

    因此上面例子中,结果的每个元素如下计算而得:

    1 : a[0] = 1
    2 : a[1] = 2
    3 : a[0] + a[1] = 1 + 2
    3 : a[2] = 3
    6 : a[0] + a[1] + a[2] =  1 + 2 + 3 = 6
    4 : a[3] = 4
    10: a[0] + a[1] + a[2] + a[4] = 1+2+3+4 = 10

    可以看出result[::2]和a相等,而result[1::2]和np.add.accumulate(a)相等。

    outer 方法,<op>.outer(a,b)方法的计算等同于如下程序:

    >>> a.shape += (1,)*b.ndim
    >>> <op>(a,b)
    >>> a = a.squeeze()
    

    其中squeeze的功能是剔除数组a中长度为1的轴。如果你看不太明白这个等同程序的话,让我们来看一个例子:

    >>> np.multiply.outer([1,2,3,4,5],[2,3,4])
    array([[ 2,  3,  4],
           [ 4,  6,  8],
           [ 6,  9, 12],
           [ 8, 12, 16],
           [10, 15, 20]])
    

    可以看出通过outer方法计算的结果是如下的乘法表:

    #    2, 3, 4
    # 1
    # 2
    # 3
    # 4
    # 5
    

    如果将这两个数组按照等同程序一步一步的计算的话,就会发现乘法表最终是通过广播的方式计算出来的。


    2.3 矩阵运算

    NumPy和Matlab不一样,对于多维数组的运算,缺省情况下并不使用矩阵运算,如果你希望对数组进行矩阵运算的话,可以调用相应的函数。

    matrix对象

    numpy库提供了matrix类,使用matrix类创建的是矩阵对象,它们的加减乘除运算缺省采用矩阵方式计算,因此用法和matlab十分类似。但是由于NumPy中同时存在ndarray和matrix对象,因此用户很容易将两者弄混。这有违Python的“显式优于隐式”的原则,因此并不推荐在较复杂的程序中使用matrix。下面是使用matrix的一个例子:

    >>> a = np.matrix([[1,2,3],[5,5,6],[7,9,9]])
    >>> a*a**-1
    matrix([[  1.00000000e+00,   1.66533454e-16,  -8.32667268e-17],
            [ -2.77555756e-16,   1.00000000e+00,  -2.77555756e-17],
            [  1.66533454e-16,   5.55111512e-17,   1.00000000e+00]])
    

    因为a是用matrix创建的矩阵对象,因此乘法和幂运算符都变成了矩阵运算,于是上面计算的是矩阵a和其逆矩阵的乘积,结果是一个单位矩阵。

    矩阵的乘积可以使用dot函数进行计算。对于二维数组,它计算的是矩阵乘积,对于一维数组,它计算的是其点积。当需要将一维数组当作列矢量或者行矢量进行矩阵运算时,推荐先使用reshape函数将一维数组转换为二维数组:

    >>> a = array([1, 2, 3])
    >>> a.reshape((-1,1))
    array([[1],
           [2],
           [3]])
    >>> a.reshape((1,-1))
    array([[1, 2, 3]])
    

    除了dot计算乘积之外,NumPy还提供了inner和outer等多种计算乘积的函数。这些函数计算乘积的方式不同,尤其是当对于多维数组的时候,更容易搞混。

    • dot : 对于两个一维的数组,计算的是这两个数组对应下标元素的乘积和(数学上称之为内积);对于二维数组,计算的是两个数组的矩阵乘积;对于多维数组,它的通用计算公式如下,即结果数组中的每个元素都是:数组a的最后一维上的所有元素与数组b的倒数第二位上的所有元素的乘积和:

      dot(a, b)[i,j,k,m] = sum(a[i,j,:] * b[k,:,m])
      

      下面以两个3为数组的乘积演示一下dot乘积的计算结果:

      首先创建两个3维数组,这两个数组的最后两维满足矩阵乘积的条件:

      >>> a = np.arange(12).reshape(2,3,2)
      >>> b = np.arange(12,24).reshape(2,2,3)
      >>> c = np.dot(a,b)
      

      dot乘积的结果c可以看作是数组a,b的多个子矩阵的乘积:

      >>> np.alltrue( c[0,:,0,:] == np.dot(a[0],b[0]) )
      True
      >>> np.alltrue( c[1,:,0,:] == np.dot(a[1],b[0]) )
      True
      >>> np.alltrue( c[0,:,1,:] == np.dot(a[0],b[1]) )
      True
      >>> np.alltrue( c[1,:,1,:] == np.dot(a[1],b[1]) )
      True
      
    • inner : 和dot乘积一样,对于两个一维数组,计算的是这两个数组对应下标元素的乘积和;对于多维数组,它计算的结果数组中的每个元素都是:数组a和b的最后一维的内积,因此数组a和b的最后一维的长度必须相同:

      inner(a, b)[i,j,k,m] = sum(a[i,j,:]*b[k,m,:])
      

      下面是inner乘积的演示:

      >>> a = np.arange(12).reshape(2,3,2)
      >>> b = np.arange(12,24).reshape(2,3,2)
      >>> c = np.inner(a,b)
      >>> c.shape
      (2, 3, 2, 3)
      >>> c[0,0,0,0] == np.inner(a[0,0],b[0,0])
      True
      >>> c[0,1,1,0] == np.inner(a[0,1],b[1,0])
      True
      >>> c[1,2,1,2] == np.inner(a[1,2],b[1,2])
      True
      
    • outer : 只按照一维数组进行计算,如果传入参数是多维数组,则先将此数组展平为一维数组之后再进行运算。outer乘积计算的列向量和行向量的矩阵乘积:

      >>> np.outer([1,2,3],[4,5,6,7])
      array([[ 4,  5,  6,  7],
             [ 8, 10, 12, 14],
             [12, 15, 18, 21]])
      

    矩阵中更高级的一些运算可以在NumPy的线性代数子库linalg中找到。例如inv函数计算逆矩阵,solve函数可以求解多元一次方程组。下面是solve函数的一个例子:

    >>> a = np.random.rand(10,10)
    >>> b = np.random.rand(10)
    >>> x = np.linalg.solve(a,b)
    >>> np.sum(np.abs(np.dot(a,x) - b))
    3.1433189384699745e-15
    

    solve函数有两个参数a和b。a是一个N*N的二维数组,而b是一个长度为N的一维数组,solve函数找到一个长度为N的一维数组x,使得a和x的矩阵乘积正好等于b,数组x就是多元一次方程组的解。

    有关线性代数方面的内容将在今后的章节中详细介绍。

    2.4 文件存取

    NumPy提供了多种文件操作函数方便我们存取数组内容。文件存取的格式分为两类:二进制和文本。而二进制格式的文件又分为NumPy专用的格式化二进制类型和无格式类型。

    使用数组的方法函数tofile可以方便地将数组中数据以二进制的格式写进文件。tofile输出的数据没有格式,因此用numpy.fromfile读回来的时候需要自己格式化数据:

    >>> a = np.arange(0,12)
    >>> a.shape = 3,4
    >>> a
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11]])
    >>> a.tofile("a.bin")
    >>> b = np.fromfile("a.bin", dtype=np.float) # 按照float类型读入数据
    >>> b # 读入的数据是错误的
    array([  2.12199579e-314,   6.36598737e-314,   1.06099790e-313,
             1.48539705e-313,   1.90979621e-313,   2.33419537e-313])
    >>> a.dtype # 查看a的dtype
    dtype('int32')
    >>> b = np.fromfile("a.bin", dtype=np.int32) # 按照int32类型读入数据
    >>> b # 数据是一维的
    array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
    >>> b.shape = 3, 4 # 按照a的shape修改b的shape
    >>> b # 这次终于正确了
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11]])
    

    从上面的例子可以看出,需要在读入的时候设置正确的dtype和shape才能保证数据一致。并且tofile函数不管数组的排列顺序是C语言格式的还是Fortran语言格式的,统一使用C语言格式输出。

    此外如果fromfile和tofile函数调用时指定了sep关键字参数的话,数组将以文本格式输入输出。

    numpy.load和numpy.save函数以NumPy专用的二进制类型保存数据,这两个函数会自动处理元素类型和shape等信息,使用它们读写数组就方便多了,但是numpy.save输出的文件很难和其它语言编写的程序读入:

    >>> np.save("a.npy", a)
    >>> c = np.load( "a.npy" )
    >>> c
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11]])
    

    如果你想将多个数组保存到一个文件中的话,可以使用numpy.savez函数。savez函数的第一个参数是文件名,其后的参数都是需要保存的数组,也可以使用关键字参数为数组起一个名字,非关键字参数传递的数组会自动起名为arr_0, arr_1, …。savez函数输出的是一个压缩文件(扩展名为npz),其中每个文件都是一个save函数保存的npy文件,文件名对应于数组名。load函数自动识别npz文件,并且返回一个类似于字典的对象,可以通过数组名作为关键字获取数组的内容:

    >>> a = np.array([[1,2,3],[4,5,6]])
    >>> b = np.arange(0, 1.0, 0.1)
    >>> c = np.sin(b)
    >>> np.savez("result.npz", a, b, sin_array = c)
    >>> r = np.load("result.npz")
    >>> r["arr_0"] # 数组a
    array([[1, 2, 3],
           [4, 5, 6]])
    >>> r["arr_1"] # 数组b
    array([ 0. ,  0.1,  0.2,  0.3,  0.4,  0.5,  0.6,  0.7,  0.8,  0.9])
    >>> r["sin_array"] # 数组c
    array([ 0.        ,  0.09983342,  0.19866933,  0.29552021,  0.38941834,
            0.47942554,  0.56464247,  0.64421769,  0.71735609,  0.78332691])
    

    如果你用解压软件打开result.npz文件的话,会发现其中有三个文件:arr_0.npy, arr_1.npy, sin_array.npy,其中分别保存着数组a, b, c的内容。

    使用numpy.savetxt和numpy.loadtxt可以读写1维和2维的数组:

    >>> a = np.arange(0,12,0.5).reshape(4,-1)
    >>> np.savetxt("a.txt", a) # 缺省按照'%.18e'格式保存数据,以空格分隔
    >>> np.loadtxt("a.txt")
    array([[  0. ,   0.5,   1. ,   1.5,   2. ,   2.5],
           [  3. ,   3.5,   4. ,   4.5,   5. ,   5.5],
           [  6. ,   6.5,   7. ,   7.5,   8. ,   8.5],
           [  9. ,   9.5,  10. ,  10.5,  11. ,  11.5]])
    >>> np.savetxt("a.txt", a, fmt="%d", delimiter=",") #改为保存为整数,以逗号分隔
    >>> np.loadtxt("a.txt",delimiter=",") # 读入的时候也需要指定逗号分隔
    array([[  0.,   0.,   1.,   1.,   2.,   2.],
           [  3.,   3.,   4.,   4.,   5.,   5.],
           [  6.,   6.,   7.,   7.,   8.,   8.],
           [  9.,   9.,  10.,  10.,  11.,  11.]])
    

    文件名和文件对象

    本节介绍所举的例子都是传递的文件名,也可以传递已经打开的文件对象,例如对于load和save函数来说,如果使用文件对象的话,可以将多个数组储存到一个npy文件中:

    >>> a = np.arange(8)
    >>> b = np.add.accumulate(a)
    >>> c = a + b
    >>> f = file("result.npy", "wb")
    >>> np.save(f, a) # 顺序将a,b,c保存进文件对象f
    >>> np.save(f, b)
    >>> np.save(f, c)
    >>> f.close()
    >>> f = file("result.npy", "rb")
    >>> np.load(f) # 顺序从文件对象f中读取内容
    array([0, 1, 2, 3, 4, 5, 6, 7])
    >>> np.load(f)
    array([ 0,  1,  3,  6, 10, 15, 21, 28])
    >>> np.load(f)
    array([ 0,  2,  5,  9, 14, 20, 27, 35])





    展开全文
  • Numpy 使用教程--Numpy 数学函数及代数运算 Numpy 使用教程–Numpy 数学函数及代数运算 一、实验介绍 1.1 实验内容 如果你使用 Python 语言进行科学计算,那么一定会接触到 NumpyNumpy 是支持 Python 语言的...

    Numpy 使用教程--Numpy 数学函数及代数运算

    Numpy 使用教程–Numpy 数学函数及代数运算

    一、实验介绍

    1.1 实验内容

    如果你使用 Python 语言进行科学计算,那么一定会接触到 Numpy。Numpy 是支持 Python 语言的数值计算扩充库,其拥有强大的高维度数组处理与矩阵运算能力。除此之外,Numpy 还内建了大量的函数,方便你快速构建数学模型。

    1.2 实验知识点

    Numpy 数学函数 
    Numpy 代数运算 


    1.3 实验环境

    python2.7 
    Xfce 终端 
    ipython 终端 
    1.4 适合人群

    本课程难度为一般,属于初级级别课程,适合具有 Python 基础,并对使用 Numpy 进行科学计算感兴趣的用户。

    二、数学函数

    使用 python 自带的运算符,你可以完成数学中的加减乘除,以及取余、取整,幂次计算等。导入自带的 math 模块之后,里面又包含绝对值、阶乘、开平方等一些常用的数学函数。不过,这些函数仍然相对基础。如果要完成更加复杂一些的数学计算,就会显得捉襟见肘了。

    numpy 为我们提供了更多的数学函数,以帮助我们更好地完成一些数值计算。下面就依次来看一看。

    2.1 三角函数

    首先, 看一看 numpy 提供的三角函数功能。这些方法有:

    1. numpy.sin(x):三角正弦。 
    2. numpy.cos(x):三角余弦。 
    3. numpy.tan(x):三角正切。 
    4. numpy.arcsin(x):三角反正弦。 
    5. numpy.arccos(x):三角反余弦。 
    6. numpy.arctan(x):三角反正切。 
    7. numpy.hypot(x1,x2):直角三角形求斜边。 
    8. numpy.degrees(x):弧度转换为度。 
    9. numpy.radians(x):度转换为弧度。 
    10. numpy.deg2rad(x):度转换为弧度。 
    11. numpy.rad2deg(x):弧度转换为度。 

    比如,我们可以用上面提到的 numpy.rad2deg(x) 将弧度转换为度。

    import numpy as np
    
    np.rad2deg(np.pi) 

    这些函数非常简单,就不再一一举例了。

    2.2 双曲函数

    在数学中,双曲函数是一类与常见的三角函数类似的函数。双曲函数经常出现于某些重要的线性微分方程的解中,使用 numpy 计算它们的方法为:

    1. numpy.sinh(x):双曲正弦。 
    2. numpy.cosh(x):双曲余弦。 
    3. numpy.tanh(x):双曲正切。 
    4. numpy.arcsinh(x):反双曲正弦。 
    5. numpy.arccosh(x):反双曲余弦。 
    6. numpy.arctanh(x):反双曲正切。 


    2.3 数值修约

    数值修约, 又称数字修约, 是指在进行具体的数字运算前, 按照一定的规则确定一致的位数, 然后舍去某些数字后面多余的尾数的过程[via. 维基百科]。比如, 我们常听到的「4 舍 5 入」就属于数值修约中的一种。

    1. numpy.around(a):平均到给定的小数位数。 
    2. numpy.round_(a):将数组舍入到给定的小数位数。 
    3. numpy.rint(x):修约到最接近的整数。 
    4. numpy.fix(x, y):向 0 舍入到最接近的整数。 
    5. numpy.floor(x):返回输入的底部(标量 x 的底部是最大的整数 i)。 
    6. numpy.ceil(x):返回输入的上限(标量 x 的底部是最小的整数 i). 
    7. numpy.trunc(x):返回输入的截断值。

    随机选择几个浮点数,看一看上面方法的区别。

    import numpy as np
    
    a = np.array([1.21, 2.53, 3.86]) 
    a 
    array([ 1.21, 2.53, 3.86])
    
    np.around(a) 
    array([ 1., 3., 4.])
    
    np.round_(a) 
    array([ 1., 3., 4.])
    
    np.rint(a) 
    array([ 1., 3., 4.])
    
    np.fix(a) 
    array([ 1., 2., 3.])
    
    np.floor(a) 
    array([ 1., 2., 3.])
    
    np.ceil(a) 
    array([ 2., 3., 4.])
    
    np.trunc(a) 
    array([ 1., 2., 3.]) 


    2.4 求和、求积、差分

    下面这些方法用于数组内元素或数组间进行求和、求积以及进行差分。

    1. numpy.prod(a, axis, dtype, keepdims):返回指定轴上的数组元素的乘积。 
    2. numpy.sum(a, axis, dtype, keepdims):返回指定轴上的数组元素的总和。 
    3. numpy.nanprod(a, axis, dtype, keepdims):返回指定轴上的数组元素的乘积, 将 NaN 视作 1。 
    4. numpy.nansum(a, axis, dtype, keepdims):返回指定轴上的数组元素的总和, 将 NaN 视作 0。 
    5. numpy.cumprod(a, axis, dtype):返回沿给定轴的元素的累积乘积。 
    6. numpy.cumsum(a, axis, dtype):返回沿给定轴的元素的累积总和。 
    7. numpy.nancumprod(a, axis, dtype):返回沿给定轴的元素的累积乘积, 将 NaN 视作 1。 
    8. numpy.nancumsum(a, axis, dtype):返回沿给定轴的元素的累积总和, 将 NaN 视作 0。 
    9. numpy.diff(a, n, axis):计算沿指定轴的第 n 个离散差分。 
    10. numpy.ediff1d(ary, to_end, to_begin):数组的连续元素之间的差异。 
    11. numpy.gradient(f):返回 N 维数组的梯度。 
    12. numpy.cross(a, b, axisa, axisb, axisc, axis):返回两个(数组)向量的叉积。 
    13. numpy.trapz(y, x, dx, axis):使用复合梯形规则沿给定轴积分。 


    下面,我们选取几个举例测试一下:

    import numpy as np 
    a=np.arange(5) 
    a 
    array([0, 1, 2, 3, 4])
    
    np.prod(a) # 所有元素乘积 
    0
    
    np.sum(a) # 所有元素和 
    10
    
    np.nanprod(a) # 默认轴上所有元素乘积 
    0
    
    np.nansum(a) # 默认轴上所有元素和 
    10
    
    np.cumprod(a) # 默认轴上元素的累积乘积。 
    array([0, 0, 0, 0, 0])
    
    np.diff(a) # 默认轴上元素差分。 
    array([1, 1, 1, 1]) 


    2.5 指数和对数

    如果你需要进行指数或者对数求解,可以用到以下这些方法。

    1. numpy.exp(x):计算输入数组中所有元素的指数。 
    2. numpy.expm1(x):对数组中的所有元素计算 exp(x) - 1. 
    3. numpy.exp2(x):对于输入数组中的所有 p, 计算 2 ** p。 
    4. numpy.log(x):计算自然对数。 
    5. numpy.log10(x):计算常用对数。 
    6. numpy.log2(x):计算二进制对数。 
    7. numpy.log1p(x):log(1 + x)。 
    8. numpy.logaddexp(x1, x2):log2(2**x1 + 2**x2)。 
    9. numpy.logaddexp2(x1, x2):log(exp(x1) + exp(x2))。 

    2.6 算术运算

    当然,numpy 也提供了一些用于算术运算的方法,使用起来会比 python 提供的运算符灵活一些,主要是可以直接针对数组。

    1. numpy.add(x1, x2):对应元素相加。 
    2. numpy.reciprocal(x):求倒数 1/x。 
    3. numpy.negative(x):求对应负数。 
    4. numpy.multiply(x1, x2):求解乘法。 
    5. numpy.divide(x1, x2):相除 x1/x2。 
    6. numpy.power(x1, x2):类似于 x1^x2。 
    7. numpy.subtract(x1, x2):减法。 
    8. numpy.fmod(x1, x2):返回除法的元素余项。 
    9. numpy.mod(x1, x2):返回余项。 
    10. numpy.modf(x1):返回数组的小数和整数部分。 
    11. numpy.remainder(x1, x2):返回除法余数。
    import numpy as np
    
    a1 = np.random.randint(0, 10, 5) 
    a2 = np.random.randint(0, 10, 5)
    
    a1 
    array([3, 7, 8, 0, 0])
    
    a2 
    array([1, 8, 6, 4, 4])
    
    np.add(a1, a2) 
    array([ 4, 15, 14, 4, 4])
    
    np.reciprocal(a1) 
    array([0, 0, 0, , ])
    
    np.negative(a1) 
    array([-3, -7, -8, 0, 0])
    
    np.multiply(a1, a2) 
    array([ 3, 56, 48, 0, 0])
    
    np.divide(a1, a2) 
    array([3, 0, 1, 0, 0])
    
    np.power(a1, a2) 
    array([3,5764801,262144,0,0])
    
    np.subtract(a1, a2) 
    array([ 2, -1, 2, -4, -4])
    
    np.fmod(a1, a2) 
    array([0, 7, 2, 0, 0])
    
    np.mod(a1, a2) 
    array([0, 7, 2, 0, 0])
    
    np.modf(a1) 
    (array([ 0., 0., 0., 0., 0.]), array([ 3., 7., 8., 0., 0.]))
    
    np.remainder(a1, a2) 
    array([0, 7, 2, 0, 0])

    2.7 矩阵和向量积

    求解向量、矩阵、张量的点积等同样是 numpy 非常强大的地方。

    1. numpy.dot(a,b):求解两个数组的点积。 
    2. numpy.vdot(a,b):求解两个向量的点积。 
    3. numpy.inner(a,b):求解两个数组的内积。 
    4. numpy.outer(a,b):求解两个向量的外积。 
    5. numpy.matmul(a,b):求解两个数组的矩阵乘积。 
    6. numpy.tensordot(a,b):求解张量点积。 
    7. numpy.kron(a,b):计算 Kronecker 乘积。 

    2.8 其他

    除了上面这些归好类别的方法,numpy 中还有一些用于数学运算的方法,归纳如下:

    1. numpy.angle(z, deg):返回复参数的角度。 
    2. numpy.real(val):返回数组元素的实部。 
    3. numpy.imag(val):返回数组元素的虚部。 
    4. numpy.conj(x):按元素方式返回共轭复数。 
    5. numpy.convolve(a, v, mode):返回线性卷积。 
    6. numpy.sqrt(x):平方根。 
    7. numpy.cbrt(x):立方根。 
    8. numpy.square(x):平方。 
    9. numpy.absolute(x):绝对值, 可求解复数。 
    10. numpy.fabs(x):绝对值。 
    11. numpy.sign(x):符号函数。 
    12. numpy.maximum(x1, x2):最大值。 
    13. numpy.minimum(x1, x2):最小值。 
    14. numpy.nan_to_num(x):用 0 替换 NaN。 
    15. numpy.interp(x, xp, fp, left, right, period):线性插值。 


    三、代数运算

    上面,我们分为 8 个类别,介绍了 numpy 中常用到的数学函数。这些方法让复杂的计算过程表达更为简单。除此之外,numpy 中还包含一些代数运算的方法,尤其是涉及到矩阵的计算方法,求解特征值、特征向量、逆矩阵等,非常方便。

    1. numpy.linalg.cholesky(a):Cholesky 分解。 
    2. numpy.linalg.qr(a ,mode):计算矩阵的 QR 因式分解。 
    3. numpy.linalg.svd(a ,full_matrices,compute_uv):奇异值分解。 
    4. numpy.linalg.eig(a):计算正方形数组的特征值和右特征向量。 
    5. numpy.linalg.eigh(a, UPLO):返回 Hermitian 或对称矩阵的特征值和特征向量。 
    6. numpy.linalg.eigvals(a):计算矩阵的特征值。 
    7. numpy.linalg.eigvalsh(a, UPLO):计算 Hermitian 或真实对称矩阵的特征值。 
    8. numpy.linalg.norm(x ,ord,axis,keepdims):计算矩阵或向量范数。 
    9. numpy.linalg.cond(x ,p):计算矩阵的条件数。 
    10. numpy.linalg.det(a):计算数组的行列式。 
    11. numpy.linalg.matrix_rank(M ,tol):使用奇异值分解方法返回秩。 
    12. numpy.linalg.slogdet(a):计算数组的行列式的符号和自然对数。 
    13. numpy.trace(a ,offset,axis1,axis2,dtype,out):沿数组的对角线返回总和。 
    14. numpy.linalg.solve(a,b):求解线性矩阵方程或线性标量方程组。 
    15. numpy.linalg.tensorsolve(a,b ,axes):为 x 解出张量方程a x = b 
    16. numpy.linalg.lstsq(a,b ,rcond):将最小二乘解返回到线性矩阵方程。 
    17. numpy.linalg.inv(a):计算逆矩阵。 
    18. numpy.linalg.pinv(a ,rcond):计算矩阵的(Moore-Penrose)伪逆。 
    19. numpy.linalg.tensorinv(a ,ind):计算N维数组的逆。
    20.  

    四、实验总结

    数学函数和代数运算方法是使用 numpy 进行数值计算中的利器,numpy 针对矩阵的高效率处理,往往可以达到事半功倍的效果。
     

    展开全文
  • Numpy 使用教程 4

    千次阅读 2017-09-18 23:58:32
    Numpy 使用教程--Numpy 数学函数及代数运算 一、实验介绍 1.1 实验内容 如果你使用 Python 语言进行科学计算,那么一定会接触到 NumpyNumpy 是支持 Python 语言的数值计算扩充库,其拥有强大的高维度数组处理与...

    Numpy 使用教程--Numpy 数学函数及代数运算

    一、实验介绍

    1.1 实验内容

    如果你使用 Python 语言进行科学计算,那么一定会接触到 Numpy。Numpy 是支持 Python 语言的数值计算扩充库,其拥有强大的高维度数组处理与矩阵运算能力。除此之外,Numpy 还内建了大量的函数,方便你快速构建数学模型。

    1.2 实验知识点

    • Numpy 数学函数
    • Numpy 代数运算

    1.3 实验环境

    • python2.7
    • Xfce 终端
    • ipython 终端

    1.4 适合人群

    本课程难度为一般,属于初级级别课程,适合具有 Python 基础,并对使用 Numpy 进行科学计算感兴趣的用户。

    二、数学函数

    使用 python 自带的运算符,你可以完成数学中的加减乘除,以及取余、取整,幂次计算等。导入自带的 math 模块之后,里面又包含绝对值、阶乘、开平方等一些常用的数学函数。不过,这些函数仍然相对基础。如果要完成更加复杂一些的数学计算,就会显得捉襟见肘了。

    numpy 为我们提供了更多的数学函数,以帮助我们更好地完成一些数值计算。下面就依次来看一看。

    2.1 三角函数

    首先, 看一看 numpy 提供的三角函数功能。这些方法有:

    1. numpy.sin(x):三角正弦。
    2. numpy.cos(x):三角余弦。
    3. numpy.tan(x):三角正切。
    4. numpy.arcsin(x):三角反正弦。
    5. numpy.arccos(x):三角反余弦。
    6. numpy.arctan(x):三角反正切。
    7. numpy.hypot(x1,x2):直角三角形求斜边。
    8. numpy.degrees(x):弧度转换为度。
    9. numpy.radians(x):度转换为弧度。
    10. numpy.deg2rad(x):度转换为弧度。
    11. numpy.rad2deg(x):弧度转换为度。

    比如,我们可以用上面提到的 numpy.rad2deg(x) 将弧度转换为度。

    import numpy as np
    
    np.rad2deg(np.pi)
    

    此处输入图片的描述

    这些函数非常简单,就不再一一举例了。

    2.2 双曲函数

    在数学中,双曲函数是一类与常见的三角函数类似的函数。双曲函数经常出现于某些重要的线性微分方程的解中,使用 numpy 计算它们的方法为:

    1. numpy.sinh(x):双曲正弦。
    2. numpy.cosh(x):双曲余弦。
    3. numpy.tanh(x):双曲正切。
    4. numpy.arcsinh(x):反双曲正弦。
    5. numpy.arccosh(x):反双曲余弦。
    6. numpy.arctanh(x):反双曲正切。

    2.3 数值修约

    数值修约, 又称数字修约, 是指在进行具体的数字运算前, 按照一定的规则确定一致的位数, 然后舍去某些数字后面多余的尾数的过程[via. 维基百科]。比如, 我们常听到的「4 舍 5 入」就属于数值修约中的一种。

    1. numpy.around(a):平均到给定的小数位数。
    2. numpy.round_(a):将数组舍入到给定的小数位数。
    3. numpy.rint(x):修约到最接近的整数。
    4. numpy.fix(x, y):向 0 舍入到最接近的整数。
    5. numpy.floor(x):返回输入的底部(标量 x 的底部是最大的整数 i)。
    6. numpy.ceil(x):返回输入的上限(标量 x 的底部是最小的整数 i).
    7. numpy.trunc(x):返回输入的截断值。

    随机选择几个浮点数,看一看上面方法的区别。

    >>> import numpy as np
    
    >>> a = np.array([1.21, 2.53, 3.86])
    >>> a
    array([ 1.21,  2.53,  3.86])
    
    >>> np.around(a)
    array([ 1.,  3.,  4.])
    
    >>> np.round_(a)
    array([ 1.,  3.,  4.])
    
    >>> np.rint(a)
    array([ 1.,  3.,  4.])
    
    >>> np.fix(a)
    array([ 1.,  2.,  3.])
    
    >>> np.floor(a)
    array([ 1.,  2.,  3.])
    
    >>> np.ceil(a)
    array([ 2.,  3.,  4.])
    
    >>> np.trunc(a)
    array([ 1.,  2.,  3.])
    

    2.4 求和、求积、差分

    下面这些方法用于数组内元素或数组间进行求和、求积以及进行差分。

    1. numpy.prod(a, axis, dtype, keepdims):返回指定轴上的数组元素的乘积。
    2. numpy.sum(a, axis, dtype, keepdims):返回指定轴上的数组元素的总和。
    3. numpy.nanprod(a, axis, dtype, keepdims):返回指定轴上的数组元素的乘积, 将 NaN 视作 1。
    4. numpy.nansum(a, axis, dtype, keepdims):返回指定轴上的数组元素的总和, 将 NaN 视作 0。
    5. numpy.cumprod(a, axis, dtype):返回沿给定轴的元素的累积乘积。
    6. numpy.cumsum(a, axis, dtype):返回沿给定轴的元素的累积总和。
    7. numpy.nancumprod(a, axis, dtype):返回沿给定轴的元素的累积乘积, 将 NaN 视作 1。
    8. numpy.nancumsum(a, axis, dtype):返回沿给定轴的元素的累积总和, 将 NaN 视作 0。
    9. numpy.diff(a, n, axis):计算沿指定轴的第 n 个离散差分。
    10. numpy.ediff1d(ary, to_end, to_begin):数组的连续元素之间的差异。
    11. numpy.gradient(f):返回 N 维数组的梯度。
    12. numpy.cross(a, b, axisa, axisb, axisc, axis):返回两个(数组)向量的叉积。
    13. numpy.trapz(y, x, dx, axis):使用复合梯形规则沿给定轴积分。

    下面,我们选取几个举例测试一下:

    >>> import numpy as np
    >>> a=np.arange(5)
    >>> a
    array([0, 1, 2, 3, 4])
    
    >>> np.prod(a) # 所有元素乘积
    0
    
    >>> np.sum(a) # 所有元素和
    10
    
    >>> np.nanprod(a) # 默认轴上所有元素乘积
    0
    
    >>> np.nansum(a) # 默认轴上所有元素和
    10
    
    >>> np.cumprod(a) # 默认轴上元素的累积乘积。
    array([0, 0, 0, 0, 0])
    
    >>> np.diff(a) # 默认轴上元素差分。
    array([1, 1, 1, 1])
    

    2.5 指数和对数

    如果你需要进行指数或者对数求解,可以用到以下这些方法。

    1. numpy.exp(x):计算输入数组中所有元素的指数。
    2. numpy.expm1(x):对数组中的所有元素计算 exp(x) - 1.
    3. numpy.exp2(x):对于输入数组中的所有 p, 计算 2 ** p。
    4. numpy.log(x):计算自然对数。
    5. numpy.log10(x):计算常用对数。
    6. numpy.log2(x):计算二进制对数。
    7. numpy.log1p(x)log(1 + x)
    8. numpy.logaddexp(x1, x2)log2(2**x1 + 2**x2)
    9. numpy.logaddexp2(x1, x2)log(exp(x1) + exp(x2))

    2.6 算术运算

    当然,numpy 也提供了一些用于算术运算的方法,使用起来会比 python 提供的运算符灵活一些,主要是可以直接针对数组。

    1. numpy.add(x1, x2):对应元素相加。
    2. numpy.reciprocal(x):求倒数 1/x。
    3. numpy.negative(x):求对应负数。
    4. numpy.multiply(x1, x2):求解乘法。
    5. numpy.divide(x1, x2):相除 x1/x2。
    6. numpy.power(x1, x2):类似于 x1^x2。
    7. numpy.subtract(x1, x2):减法。
    8. numpy.fmod(x1, x2):返回除法的元素余项。
    9. numpy.mod(x1, x2):返回余项。
    10. numpy.modf(x1):返回数组的小数和整数部分。
    11. numpy.remainder(x1, x2):返回除法余数。
    >>> import numpy as np
    
    >>> a1 = np.random.randint(0, 10, 5)
    >>> a2 = np.random.randint(0, 10, 5)
    
    >>> a1
    array([3, 7, 8, 0, 0])
    
    >>> a2
    array([1, 8, 6, 4, 4])
    
    >>> np.add(a1, a2)
    array([ 4, 15, 14,  4,  4])
    
    >>> np.reciprocal(a1)
    array([0, 0, 0, , ])
    
    >>> np.negative(a1)
    array([-3, -7, -8,  0,  0])
    
    >>> np.multiply(a1, a2)
    array([ 3, 56, 48,  0,  0])
    
    >>> np.divide(a1, a2)
    array([3, 0, 1, 0, 0])
    
    >>> np.power(a1, a2)
    array([3,5764801,262144,0,0])
    
    >>> np.subtract(a1, a2)
    array([ 2, -1,  2, -4, -4])
    
    >>> np.fmod(a1, a2)
    array([0, 7, 2, 0, 0])
    
    >>> np.mod(a1, a2)
    array([0, 7, 2, 0, 0])
    
    >>> np.modf(a1)
    (array([ 0.,  0.,  0.,  0.,  0.]), array([ 3.,  7.,  8.,  0.,  0.]))
    
    >>> np.remainder(a1, a2)
    array([0, 7, 2, 0, 0])
    >>>
    

    2.7 矩阵和向量积

    求解向量、矩阵、张量的点积等同样是 numpy 非常强大的地方。

    1. numpy.dot(a,b):求解两个数组的点积。
    2. numpy.vdot(a,b):求解两个向量的点积。
    3. numpy.inner(a,b):求解两个数组的内积。
    4. numpy.outer(a,b):求解两个向量的外积。
    5. numpy.matmul(a,b):求解两个数组的矩阵乘积。
    6. numpy.tensordot(a,b):求解张量点积。
    7. numpy.kron(a,b):计算 Kronecker 乘积。

    2.8 其他

    除了上面这些归好类别的方法,numpy 中还有一些用于数学运算的方法,归纳如下:

    1. numpy.angle(z, deg):返回复参数的角度。
    2. numpy.real(val):返回数组元素的实部。
    3. numpy.imag(val):返回数组元素的虚部。
    4. numpy.conj(x):按元素方式返回共轭复数。
    5. numpy.convolve(a, v, mode):返回线性卷积。
    6. numpy.sqrt(x):平方根。
    7. numpy.cbrt(x):立方根。
    8. numpy.square(x):平方。
    9. numpy.absolute(x):绝对值, 可求解复数。
    10. numpy.fabs(x):绝对值。
    11. numpy.sign(x):符号函数。
    12. numpy.maximum(x1, x2):最大值。
    13. numpy.minimum(x1, x2):最小值。
    14. numpy.nan_to_num(x):用 0 替换 NaN。
    15. numpy.interp(x, xp, fp, left, right, period):线性插值。

    三、代数运算

    上面,我们分为 8 个类别,介绍了 numpy 中常用到的数学函数。这些方法让复杂的计算过程表达更为简单。除此之外,numpy 中还包含一些代数运算的方法,尤其是涉及到矩阵的计算方法,求解特征值、特征向量、逆矩阵等,非常方便。

    1. numpy.linalg.cholesky(a):Cholesky 分解。
    2. numpy.linalg.qr(a ,mode):计算矩阵的 QR 因式分解。
    3. numpy.linalg.svd(a ,full_matrices,compute_uv):奇异值分解。
    4. numpy.linalg.eig(a):计算正方形数组的特征值和右特征向量。
    5. numpy.linalg.eigh(a, UPLO):返回 Hermitian 或对称矩阵的特征值和特征向量。
    6. numpy.linalg.eigvals(a):计算矩阵的特征值。
    7. numpy.linalg.eigvalsh(a, UPLO):计算 Hermitian 或真实对称矩阵的特征值。
    8. numpy.linalg.norm(x ,ord,axis,keepdims):计算矩阵或向量范数。
    9. numpy.linalg.cond(x ,p):计算矩阵的条件数。
    10. numpy.linalg.det(a):计算数组的行列式。
    11. numpy.linalg.matrix_rank(M ,tol):使用奇异值分解方法返回秩。
    12. numpy.linalg.slogdet(a):计算数组的行列式的符号和自然对数。
    13. numpy.trace(a ,offset,axis1,axis2,dtype,out):沿数组的对角线返回总和。
    14. numpy.linalg.solve(a,b):求解线性矩阵方程或线性标量方程组。
    15. numpy.linalg.tensorsolve(a,b ,axes):为 x 解出张量方程a x = b
    16. numpy.linalg.lstsq(a,b ,rcond):将最小二乘解返回到线性矩阵方程。
    17. numpy.linalg.inv(a):计算逆矩阵。
    18. numpy.linalg.pinv(a ,rcond):计算矩阵的(Moore-Penrose)伪逆。
    19. numpy.linalg.tensorinv(a ,ind):计算N维数组的逆。

    四、实验总结

    数学函数和代数运算方法是使用 numpy 进行数值计算中的利器,numpy 针对矩阵的高效率处理,往往可以达到事半功倍的效果。

    展开全文
  • Numpy 使用教程 1

    2017-09-18 23:54:45
    Numpy 使用教程--Numpy 安装及数值类型介绍 一、实验介绍 1.1 实验内容 如果你使用 Python 语言进行科学计算,那么一定会接触到 NumpyNumpy 是支持 Python 语言的数值计算扩充库,其拥有强大的多维数组处理与...
  • Numpy 使用教程 5

    2017-09-18 23:59:32
    Numpy 使用教程--Numpy 数组索引及其他用法 一、实验介绍 1.1 实验内容 如果你使用 Python 语言进行科学计算,那么一定会接触到 NumpyNumpy 是支持 Python 语言的数值计算扩充库,其拥有强大的高维度数组处理与...
  • NumPy使用手记

    千次阅读 2015-02-01 20:31:39
    这个系列开始,我记录在使用NumPy使用中的一些具体的技巧和注意事项。 1) 巧用 where函数  where函数是numpy的内置,也是一个非常有用的函数,提供了快速并且灵活的计算功能。 def f_norm_1(data, ...
  • Numpy 使用教程 3

    千次阅读 2017-09-18 23:56:58
    Numpy 使用教程--Numpy 数组操作及随机抽样 一、实验介绍 1.1 实验内容 如果你使用 Python 语言进行科学计算,那么一定会接触到 NumpyNumpy 是支持 Python 语言的数值计算扩充库,其拥有强大的高维度数组处理与...
  • Numpy 使用教程 2

    2017-09-18 23:55:50
    Numpy 使用教程--Numpy 多维数组创建及属性 一、实验介绍 1.1 实验内容 如果你使用 Python 语言进行科学计算,那么一定会接触到 NumpyNumpy 是支持 Python 语言的数值计算扩充库,其拥有强大的高维度数组处理与...
  • python numpy使用

    千次阅读 2015-12-08 14:26:59
    python numpy使用 1.建立矩阵 a1=np.array([1,2,3],dtype=int) #建立一个一维数组,数据类型是int。也可以不指定数据类型,使用默认。几乎所有的数组建立函数都可以指定数据类型,即dtype的取值。 a2=np.array...
  • numpy使用说明

    2020-07-30 08:49:27
    numpy用户指南 numpy中文网
  • numpy使用GPU

    千次阅读 2019-05-07 14:09:18
    pip install mxnet-cu92mkl pip install minpy 安装完毕后 import mipy.numpy as np
  • 参考自numpy帮助文档 numpy.dot 原型: numpy.dot(a, b, out=None) 两个numpy数组的点乘 (1).... 如果两个参数a,ba,ba,b都是222维的,该运算做矩阵乘法,但是使用matmul或者a@b更好 np.dot([...
  • Numpy 使用详解

    2017-09-17 13:46:55
    Numpy 概述: 是基于向量化的运算 进行数值运算时Numpy数组比list效率高 用于读写硬盘上基于数组的数据集的工具 线性代数运算、傅里叶变换,以及随机数生成 用于将C、C++、Fortran代码集成到Python的工具 除了为...
  • numpy使用教程

    千次阅读 2018-10-01 13:22:36
    目录 基础知识 数组创建 打印数组 基本操作 索引,切片和迭代 ...NumPy的主要对象是同构多维数组。它是一个元素表(通常是数字),都是相同的类型,由正整数元组索引。在NumPy维度中称为轴。 例...
  • Numpy使用小记

    千次阅读 2019-01-31 20:36:59
    import numpy as np a = np.array([[1,2,3,4],[5,6,7,8]]) # 返回ndarray对象 print(a.shape[0]) # 矩阵行数与列数 # 矩阵按行列截取 print(a[0,:]) # 获取第一行 任意列,返回的也是一个ndarray对象 # 矩阵按条件...
  • numpy 使用技巧

    千次阅读 2018-01-10 22:27:16
    numpy.argmax 返回一个array的最大值所在行,列 ;返回第一个值 numpy.argmax(x,axis=,out=) >>> a = np.arange(6).reshape(2,3) >>> a array([[0, 1, 2], [3, 4, 5]]) >>> np.argmax(a) 5 >>> np.argmax(a, ...
  • Numpy使用2

    2016-03-08 10:09:37
    这一篇就讲讲numpy的常用功能以及与其它python库的结合使用。假设你已经成功执行下列语句:import numpy as np初始化(1)直接创建## 创建一维数组 In [8]: test_list = [1,3,5,6,7]In [9]: array_numpy = np.array...
  • Numpy使用4

    2016-03-11 10:22:09
    上篇博客写到了numpy的索引与切片,这篇博客介绍numpy的一些数学统计上的使用和如何结合numpy实现对结构化文本的处理通用函数所谓的通用函数(ufunc)就是指元素级别的数组函数,你可以将其看做简单函数其接受一个或者...
  • Numpy使用1

    2016-03-07 17:48:22
    Numpy介绍NumPy is the fundamental package for scientific computing with Python. It contains among other things: a powerful N-dimensional array object sophisticated (broadcasting) functions tools for ...
  • numpy使用GPU加速

    万次阅读 2018-12-22 23:55:38
    在跑完mnist的KNN分类后,跑的挺慢,突然想有没有GPU的numpy的呢,上网查了查,才知道原生的numpy没有实现(不应该啊。。。),结构查到了minpy,花了10分钟左右配好了环境,写个日志记录一下。 安装minpy: 我的机器...
  • 1.numpy.where() 的用法详解 官方文档:https://docs.scipy.org/doc/numpy/reference/generated/numpy.where.html np.where(condition,x,y) 满足条件输出x,不满足条件输出y。 np.where(condition) 如果只有条件...
  • Numpy使用教程2

    2018-05-27 21:16:05
    其中,numpy.reshape() 等效于 ndarray.reshape() 方法:numpy.reshape(a,newshape) 其中,a 表示原数组,newshape 用于指定新的形状(整数或者元组)。 示例代码:import numpy as np ...
  • NumPy是一个用于科学计算的基础库,常和pandas配合使用,实现复杂计算。Orca的底层实现基于DolphinDB,如果用NumPy函数直接处理Orca对象,会直接将Orca对象下载到本地计算,造成不必要的性能损失,甚至可能导致异常...

空空如也

1 2 3 4 5 ... 20
收藏数 33,664
精华内容 13,465
关键字:

numpy使用