numpy_numpy安装 - CSDN
numpy 订阅
NumPy(Numerical Python)是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵,比Python自身的嵌套列表(nested list structure)结构要高效的多(该结构也可以用来表示矩阵(matrix)),支持大量的维度数组与矩阵运算,此外也针对数组运算提供大量的数学函数库 [1]  。 展开全文
NumPy(Numerical Python)是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵,比Python自身的嵌套列表(nested list structure)结构要高效的多(该结构也可以用来表示矩阵(matrix)),支持大量的维度数组与矩阵运算,此外也针对数组运算提供大量的数学函数库 [1]  。
信息
外文名
numpy
内    容
提供和处理N维数组对象Array
含    义
Python的一种开源的科学计算库
用    途
科学计算,数据分析
numpyNumpy介绍
一个用python实现的科学计算,包括:1、一个强大的N维数组对象Array;2、比较成熟的(广播)函数库;3、用于整合C/C++和Fortran代码的工具包;4、实用的线性代数、傅里叶变换和随机数生成函数。numpy和稀疏矩阵运算包scipy配合使用更加方便。NumPy(Numeric Python)提供了许多高级的数值编程工具,如:矩阵数据类型、矢量处理,以及精密的运算库。专为进行严格的数字处理而产生。多为很多大型金融公司使用,以及核心的科学计算组织如:Lawrence Livermore,NASA用其处理一些本来使用C++,Fortran或Matlab等所做的任务。NumPy 的前身为 Numeric ,最早由 Jim Hugunin 与其它协作者共同开发,2005 年,Travis Oliphant 在 Numeric 中结合了另一个同性质的程序库 Numarray 的特色,并加入了其它扩展而开发了 NumPy。NumPy 为开放源代码并且由许多协作者共同维护开发。 [1] 
收起全文
精华内容
参与话题
  • NumPy数据分析

    万人学习 2019-12-18 15:12:53
    本课程是NumPy数据分析课程,课程从NumPy环境搭建讲起,到最后股票分析项目结束,全程实战讲解了NumPy数据分析的方方面面,内容涵盖:NumPy数组创建、NumPy数组操作、NumPy广播、NumPy字符串、NumPy统计函数、排序、...
  • numpy——基础篇

    千次阅读 多人点赞 2020-09-29 13:16:48
    NumPy是Python中科学计算的基础包。它是一个Python库,提供多维数组对象,各种派生对象(如掩码数组和矩阵),以及用于数组快速操作的各种API,有包括数学、逻辑、形状操作、排序、选择、输入输出、离散傅立叶变换、...

    相关文章

    numpy——进阶篇



    简介

    NumPy是Python中科学计算的基础包。它是一个Python库,提供多维数组对象,各种派生对象(如掩码数组和矩阵),以及用于数组快速操作的各种API,有包括数学、逻辑、形状操作、排序、选择、输入输出、离散傅立叶变换、基本线性代数,基本统计运算和随机模拟等等。


    使用

    我们仅需要简单的通过import numpy as np就可以使用numpy了。

    import numpy as np
    np.eye(4)
    #output
    array([[1., 0., 0., 0.],
           [0., 1., 0., 0.],
           [0., 0., 1., 0.],
           [0., 0., 0., 1.]])
    

    为什么要用numpy?

    如果我们希望两个列表对应项相加,则我们需要这样做,使用Python列表这样的代码是冗余的,而使用numpy则大大减少了代码的冗余。

    #使用Python列表
    a = [1,2,3,4]
    b = [4,5,6,7,8]
    out = []
    for i,j in zip(a,b):
        out.append(i+j)
    print(out)
    #output
    [ 5,  7,  9, 11]
    
    #使用numpy
    import numpy as np
    a = np.array([1,2,3,4])
    b = np.array([4,5,6,7])
    print(a+b)
    #output
    array([ 5,  7,  9, 11])
    

    而且Python自带的list在使用中也更加耗时。不难看出使用numpy将大大提高代码的运行速度。

    #使用Python自带的数据类型
    a = list(range(1000000))
    %timeit sum(a)
    #output
    72.3 ms ± 2.54 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)
    
    #使用numpy
    import numpy as np
    a = list(range(1000000))
    a_array = np.array(a)
    %timeit np.sum(a_array)
    #output
    1.06 ms ± 33.6 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)
    

    为什么numpy运行速度会很快?

    在Python list中,list存放的是每一项数据的索引,通过这个索引找到相应的内存地址,才能知道这个数值是多少。这就像是你想开一个party,但是你手里只有给个人的地址,你需要进入他们的房间。但numpy不同的是把所有的元素都组织到一个屋子,也就是一个数据结构中,同一个缓存中。所以这些元素在内存中是相邻的。他们都有相同的类型,numpy就能对这些数字进行非常快速的计算。因为不用做类型检查,它不需要申请获取这些元素拥有所有对象。


    Beware of type coercion(提防强制数据类型)

    numpy对传入的数据类型是有强管制的。这样做的好处就是numpy的行为比较可预测。缺点就是不灵活。因此如果你发现数据被改变时,不要惊讶

    # 传入浮点,整型,字符串
     arr = np.array([1.9,2,'asd','a'])
     # output
     array(['1.9', '2', 'asd', 'a'], dtype='<U32')
    
    # 传入浮点,整型
     arr = np.array([1,2.2,3,4.9])
    # output
     array([1. , 2.2, 3. , 4.9])
    
    # 传入整数、浮点、负数
    arr = np.array([1,2.2,3,4.5+5j])
    # output
    array([1. +0.j, 2.2+0.j, 3. +0.j, 4.5+5.j])
    


    基础操作

    现在让我们一起探讨一下numpy的基础操作,为了简便,一下代码涉及的一些数值,现已给出。

    import numpy as np
    a = np.array(['a','s','d','f'])
    b = np.array([1,2,3,4])
    c = np.array([4,5,6,7])
    d = np.eye(4)
    

    读取、修改

    # 读取一维数组指定值
     a[1]
    # output
     's'
    
    #读取二维数组指定值
     d[1,1]
    # output
     1.0
    
    # 读取一行
     d[1]
    #output
     array([0., 1., 0., 0.])
    
    # 读取一列(之所以不用d[,2]是因为numpy是按行存储的)
     d[:,2]
    #output
     array([0., 0., 1., 0.])
    
    #修改二维数组
     d[2,3] = 5
    # output
     array([[1., 0., 0., 0.],
            [0., 1., 0., 0.],
            [0., 0., 1., 5.],
            [0., 0., 0., 1.]])
    

    加、减、乘、除、

    b + c
    #output
    array([ 5,  7,  9, 11])
    
    b - c
    #output
    array([-3, -3, -3, -3])
    
    b * c
    #output
    array([ 4, 10, 18, 28])
    
    b / c
    #output
    array([0.25      , 0.4       , 0.5       , 0.57142857])
    
    b ** c
    #output
    array([    1,    32,   729, 16384], dtype=int32)
    


    逻辑运算

    In [4]: A
    Out[4]: array([False,  True,  True,  True, False,  True, False])
    
    In [5]: B
    Out[5]: array([ True,  True, False,  True, False, False, False])
    
    # 与
    In [6]: np.logical_and(A,B)
    Out[6]: array([False,  True, False,  True, False, False, False])
    # 或
    In [7]: np.logical_or(A,B)
    Out[7]: array([ True,  True,  True,  True, False,  True, False])
    # 非
    In [8]: np.logical_not(A)
    Out[8]: array([ True, False, False, False,  True, False,  True])
    # 异或
    In [9]: np.logical_xor(A,B)
    Out[9]: array([ True, False,  True, False, False,  True, False])
    
    

    shape(各维度长度)

    shape返回一个元组,列出每个维度的数组长度。

    a.shape
    #output
    (1,)
    
    d.shape
    #output
    (4, 4)
    

    ndim(维度)

    a.ndim
    #output
    1
    
    d.ndim
    #output
    2
    

    dtype(类型)

    我们可以通过dtype来查看numpy数组元素的数据类型。

    a.dtype
    #output
    dtype('<U2')
    
    d.dtype
    #output
    dtype('int32')
    

    指定数据类型

    由于numpy会强制数据类型,因此,如果想指定数据类型的话可以这样操作。

     arr = np.array([1, 2.2, 3, 4.9],dtype = 'int32')
    # output
     array([1, 2, 3, 4])
    
    # 如果遇到无法转换,则会报错
     arr = np.array([1. , 2.2, 3. , 'a'],dtype = 'int32')
     ValueError: invalid literal for int() with base 10: 'a'
    

    修改数据类型

    numpy数据类型转换需要调用方法astype(),不能直接修改dtype。调用astype返回数据类型修改后的数据,但是源数据的类型不会变。

     arr = np.array([1 , 2.2, 3, 4.9])
     a = arr.astype(int)
    # output
     array([1, 2, 3, 4])
     
     a = arr.astype(np.int64)
    # output
     array([1, 2, 3, 4], dtype=int64)
     
     a = arr.astype(np.str)
    # output
     array(['1.0', '2.2', '3.0', '4.9'], dtype='<U32')
    

    如果直接修改dtype则不会转换,而是直接切分,因此会导致数据出错。

    arr = np.array([1 , 2.2, 3, 4.9])
    arr.dtype 
    #oupput 
    dtype('float64')
    
    #将原来每个64bits的浮点数 硬生生切成32bits的整型
    arr.dtype = np.int32
    #output
    array([          0,  1072693248, -1717986918,  1073846681,           0,
            1074266112, -1717986918,  1075026329])
    

    itemsize(最大元素的字节数)

    a.itemsize
    #output
    4
    
    b.itemsize
    #output
    4
    

    nbytes(总元素字节数)

     a.nbytes
    # output
     16
     b.nbytes
    # output
     16
    

    fill(填充)

    以指定的元素填充数组。

    a.fill('a')
    #output
    array(['a', 'a', 'a', 'a'], dtype='<U1')
    

    reshape(重塑)

    在不改变原数据的情况下,重新按指定形状生成数组

    >>> a = np.arange(1,26)
    >>> a
    array([ 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])
    # 元素不匹配时,则会报错
    >>> a.reshape(5,6)
    ValueError: cannot reshape array of size 25 into shape (5,6)
    >>> a.reshape(5,5)
    array([[ 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]])
    

    如果只是单纯的想要n列,对于行数并无要求,或者只是单纯的对行数有要求,对列并无要求,则可以使用负数来进行替代。这里的复数numpy理解为未指定的。

    In [17]: a.reshape(-1,2)
    Out[17]:
    array([[ 0, 10],
           [20, 30],
           [40, 50]])
    
    In [18]: a.reshape(-2,2)
    Out[18]:
    array([[ 0, 10],
           [20, 30],
           [40, 50]])
    
    In [19]: a.reshape(-2,1)
    Out[19]:
    array([[ 0],
           [10],
           [20],
           [30],
           [40],
           [50]])
    


    sum

    sxis

    对于sum中有一个axis的参数,假设默认为None,现设a是一个形状为(2,3,2)的数组。则

    • axis=0(-3)时,则将a在第0维(倒数第3维)上求和,得到一个(3,2)的数组
    • axis=1(-2)时,则将a在第1维(倒数第2维)上求和,得到一个(2,2)的数组
    • axis=2(-1)时,则将a在第2维(倒数第1维)上求和,得到一个(2,3)的数组
     a = np.arange(12).reshape(2,3,2)
    # output
     array([[[ 0,  1],
            [ 2,  3],
            [ 4,  5]],
    
           [[ 6,  7],
            [ 8,  9],
            [10, 11]]])
     a_0 = a.sum(axis = 0)
     a_1 = a.sum(axis = 1)
     a_2 = a.sum(axis = 2)
    # output 分别为a_0, a_1, a_2
     array([[ 6,  8],
           [10, 12],
           [14, 16]])
     array([[ 6,  9],
           [24, 27]])
     array([[ 1,  5,  9],
           [13, 17, 21]])
    


    keepdims

    sum函数中,参数keepdims默认是<<no value>>的。如果想让求和后的纬度保持不变,则可以通过设置keeodimsTrue来实现。

     b = a.sum(axis = 2,keepdims = True)
    # output
     array([[[ 1],
            [ 5],
            [ 9]],
    
           [[13],
            [17],
            [21]]])
     b.shape
    # output
     (2, 3, 1)
    


    initinal

    通过initial可以设置初始值。

     a.sum()
    # output
     66
    
    a.sum(initial = 10)
    # output
     76
    

    其他相似函数

    函数名 含义
    prod 返回数组的或给定轴上数组元素的乘积。(空数组的乘积为1)
    min/max 返回数组的最小(大)值或给定轴的最小(大)值。
    argmin/argmin 返回沿轴的最小(大)值的索引。(无initial和keepdims)
    max 返回数组的最大值或给定轴的最大值。
    ptp 沿轴的值范围(max-min, 无initial)
    mean 返回数组的均值或给定轴的均值。
    std/var 计算沿指定轴的标准偏差(方差)。(其中自由度ddof=0为总体标准差(总体方差),ddof=1为样本标准差(样本方差)。无initial)
    any/all any是元组元素只要有一个为真才为真,all是所有元素为真才为真。(无initial)


    flags(返回内存信息)

    flags返回ndarray对象的内存信息,包含以下属性:

    属性 描述
    C_CONTIGUOUS 数据在一个单一的C风格的连续字段中
    F_CONTIGUOUS 数据在一个单一的Fortran风格的连续字段中
    OWNDATA 数据拥有它所使用的内存(True)或从另一个对象中借用它(False)
    WRITEABLE 数据区域可以被写入(True),设置为False时为只读。
    ALIGNED 数据和所有元素都适当对其到硬件上(True为对齐)
    WRITEBACKIFCOPY UPDATEIFCOPY 已弃用,由 WRITEBACKIFCOPY 取代;
    UPDATEIFCOPY 这个数组是其它数组的一个副本,当这个数组被释放时,原数组的内容将被更新

    C_CONTIGUOUS和F_CONTIGUOUS

    C_CONTIGUOUSF_CONTIGUOUS分别表示C风格和Fortran风格。这是两种不同的编程语言,在C语言中数组的存储风格是按行存储,而在Fortran语言中则是按列存储。==numpy数组是按行存储。==既然如此那为什么又设计到了两种不同风格的判别呢?

    • 一维数组,
      对于一维数组,不管按行存储还是按列存储内存中的顺序都是不变的,因此既符合C_CONTIGUOUS又符合F_CONTIGUOUS
      数组a的存储方式如下图所示:
      一维数组

     a = np.array([1,2,3,4])
     a.flags
    # output
      C_CONTIGUOUS : True
      F_CONTIGUOUS : True
    ···
    
    • 二维数组
      当然,对于二维数组就不一样了,我们可以看到数组b在内存中是按C风格(行优先)存储的。所以符合C_CONTIGUOUS不符合F_CONTIGUOUS。内存中的存储方式如下图左,现在我们将b转置赋给c。如果为c单独开辟一段内存是不划算的,numpy做的是给你一个相同内存缓冲区的一个视图,尽量不创建一个副本。对于c来说,c的C风格相当于是b的Fortran风格。因此只需要在b上创建一个视图,并标为Fortran风格。便可作为c
      二维数组
     b = np.array([[1,2,3,4],[2,5,1,4]])
    # output 
     C_CONTIGUOUS : True
     F_CONTIGUOUS : False
    ···
     c = b.T
    # output
     In [7]: c.flags
    Out[7]:
     C_CONTIGUOUS : False
     F_CONTIGUOUS : True
    

    OWNDATA

    因为b是直接创建的,因此b上的数据拥有所属的内存,而c相当于是b上的一个视图,因此数据没有所属的内存

     b.flags
    # outpit
    ···
     OWNDATA :  True
    ···
     c.flags
    # output
     OWNDATA : False
    


    类x数组

    函数 解释
    empty_like 返回形状和类型与给定数组相同的新数组。(值为内存中的原垃圾值)
    ones_like 返回形状与类型与给定数组相同的数组。(1填充)
    zeros_like 返回形状与类型与给定数组相同的数组。(0填充)
    a = np.range(36).reshape(6,6)
    np.empty_like(a)
    np.ones_like(a)
    np.zeros_like(a)
    # output
    array([[ 0,  0,  0,  0,  0,  0],
           [ 0,  0,  0,  0,  0,  0],
           [ 0,  0,  0,  0,  0,  0],
           [ 0,  0,  0,  0,  0,  0],
           [ 0,  0,  0,  0,  0,  0],
           [-2,  0, -2, -1,  0,  0]])
    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],
           [1, 1, 1, 1, 1, 1],
           [1, 1, 1, 1, 1, 1]])
    array([[0, 0, 0, 0, 0, 0],
           [0, 0, 0, 0, 0, 0],
           [0, 0, 0, 0, 0, 0],
           [0, 0, 0, 0, 0, 0],
           [0, 0, 0, 0, 0, 0],
           [0, 0, 0, 0, 0, 0]])
    


    where

    where(条件,[x,y])
    返回根据条件从x或y中选择的元素。
    

    举例

     a = np.array([[1,2],[3,4]])
     b = np.array([[9,8],[7,6]])
     mask = np.array([[1,0],[0,1]],dtype = bool)
     np.where(mask,a,b)
    # output
     array([[1, 8],
           [7, 4]])
    


    索引

    现给出两个数组,下面所有操作均在其上。

    >>> import numpy as np
    >>>#负索引         -6 -5 -4 -3 -2 -1
    ···#正索引          0, 1, 2, 3, 4, 5
    ··· a = np.array([10, 5, 7, 9, 8, 4])
    >>> b = np.array([[ 1, 2, 9, 4, 3],
    				  [ 0, 5, 3, 5, 1],
    				  [ 8, 3, 2, 4, 7]])
    

    切片

    每当做切片时,numpy做的是给你一个相同内存缓冲区的一个试图。所以numpy大多数情况下尽量不创建一个副本,它不赋值数据,只是指向内存中的同一个位置,所以这意味着对一个巨大数组做切片操作很廉价。除了一些关于形状和维度数量的元数据外。

    一维切片

    numpy数组切片和python基本上是一样的。

    # 正索引从零开始,len(a)-1结束
    # 负索引从-len(a)开始,-1结束
    >>> a
    array([10,  5,  7,  9,  8,  4])
    >>> a[1:3]
    array([5, 7])
    >>> a[:3]
    array([10,  5,  7])
    >>> a[-4:]
    array([7, 9, 8, 4])
    >>> a[:-3]
    array([10,  5,  7])
    
    # 只能正向索引,否则返回为空
    # 无法从倒数第4个到正数第2个
    >>> a[-4:2]
    array([], dtype=int32)
    # 可以从正数第2个到倒数第1个
    >>> a[2:-1]
    array([7, 9, 8])
    
    #每n间隔n-1个取一个
    >>> a[::3]
    array([10,  9])
    >>> a[::2]
    array([10,  7,  8])
    # 间隔反取
    >>> a[::-2]
    array([4, 9, 5])
    
    # 区间跳转 (开始:结束:间隔)
    >>> b = np.arange(10)
    >>> b
    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    >>> b[1:7:2]
    array([1, 3, 5])
    >>> b[7:1:-2]
    array([7, 5, 3])
    

    多维切片

    以二维数组为例,先在行切片,找到指定行后再列切片。你可以简单理解为在不同维度切片后重叠区域。
    切片

    # 灰色区域
    >>> b[1,3:5]
    array([5, 1])
    
    # 橙色区域
    >>> b[0:2,0:2]
    array([[1, 2],
           [0, 5]])
    
    # 蓝色区域
    >>> b[:,2]
    array([9, 3, 2])
    
    # 间隔选取
    >>> b[::2,1::2]
    array([[2, 4],
           [3, 4]])
    


    花式索引

    虽然切片已经能够满足大多数的情况,但如果让你不定长去索引numpy中的几个数组呢?你会怎么做?这里将介绍花式索引。


    通过位置索引

    在numpy的数组可以通过列表批量传入索引值来进行索引。

     a = np.arange(8)
     indices = [1,2,-2]
     b = a[indices]
    # output
     array([1, 2, 6])
    
    # 也可以直接传入行和列(对应位置组成点)
    a = np.arange(36).reshape([6,6])
    # putout
    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],
           [30, 31, 32, 33, 34, 35]])
     b = a[[0,1,2,3,4],[1,2,3,4,5]]
     # output
      array([ 1,  8, 15, 22, 29])
    

    布尔索引

    我们也可以通过布尔的真假值来进行索引。

     a = np.arange(10)
     b = a < 5
    # output 返回的是一个bool数组
     array([True, True, True, True, True, False, False, False, False, False])
    
     a[a < 5] = 0
     print(a)
    # output
     array([0, 0, 0, 0, 0, 5, 6, 7, 8, 9])
     
    # 注意这里的bool个数应该和a对等
     c = np.array([0,1,0,0,0,1,0,1,0,1],dtype = bool)
     a[c]
    # output
     array([1, 5, 7, 9])
    
    # 值得注意的是,只有0才为False
    In [1]: c = np.array([1,2,3,4,0,0,-5],dtype = bool)
    Out[2]: array([ True,  True,  True,  True, False, False,  True])
    

    • 想一下能不能用a > 3 and a < 5来找出数组a中小于5大于3的元素呢?我可以看一下
     a > 3 and a < 5
    # output
    ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()
    

    具有多个元素的数组的真值是不明确的。oh,原来数组a元素中判断的结果有真有假,而and左右两边只能是确定的,要么是真要么是假,当两边都为真的时候才为真。那么错误提示中的建议使用any()all()又是什么呢?

    # any()意思是只要有一个为真,这个数组就为真
     (a < 5).any() 
    # output
    True
    
    #all()意思是所有为真才为真
    (a < 9).all()
    (a < 10).all()
    #output
    False True
    

    嗯哼,好像并没有解决问题。这里我们引入一个几种位操作。

    操作符 含义
    & and
    or
    ~ not
    ^ xor

    因此我们可以通过&来实现对数组实现按位运算,这就像numpy中的“+”,“-”一样。

    # 之所以使用括号是因为位运算符优先级高于比较运算符
     (a > 3) & (a < 5)
    # output
     array([False, False, False, False, True, False, False, False, False, False])
    
    # 因此这样我们就可以进行bool索引
     a[(a > 3) & (a < 5)]
    # output
     array([4])
    

    • 如何得到满足条件的索引值?
     a = np.array([[1,2,3,4],[2,5,9,7],[5,2,3,4]])
     np.nonzero(a < 3)
    # output 既分别是(0,0),(0,1),(1,0),(2,1)四个点
    (array([0, 0, 1, 2], dtype=int64), array([0, 1, 0, 1], dtype=int64))
    
    #上面的输出方式如果看不习惯我们可以反转一下就比较清楚了
     np.transpose(np.nonzero(a < 3))
    # output
    array([[0, 0],
           [0, 1],
           [1, 0],
           [2, 1]], dtype=int64)
    


    • 下面我们通过一个联系来进一步熟悉花式索引。

    【1.】输出下列表格中各颜色区域的元素。

    图示

     a = np.arange(36).reshape([6,6])
     
     # 黄色区域
     y = a[[0,1,2,3,4],[1,2,3,4,5]]
    # 红色区域
     mask = np.array([1,0,1,0,0,1],dtype = bool)
     r = a[mask,2]
    # 蓝色区域
     b = a[3:,[0,2,5]]
    

    【2.】输出上表中能被3整除的数
    这里需要说明的是,在通过以对应位置输出时,由于引入Nan(表空缺,浮点型),所以原始数据不可避免的被强制改变成浮点型。

    # 以一维数组形式输出
     mask = a % 3 ==0
     a[mask]
    # output
     array([ 0,  3,  6,  9, 12, 15, 18, 21, 24, 27, 30, 33])
    
    # 以对应位置输出
    # 方法一,使用emoty_like函数
    b = np.empty_like(a,dtype = np.float)
    b.fill(np.nan)
    b[mask] = a[mask]
    #output
    array([[ 0., nan, nan,  3., nan, nan],
           [ 6., nan, nan,  9., nan, nan],
           [12., nan, nan, 15., nan, nan],
           [18., nan, nan, 21., nan, nan],
           [24., nan, nan, 27., nan, nan],
           [30., nan, nan, 33., nan, nan]])
    
    # 方法二,使用where函数
     mask = a % 3 == 0
     np.where(mask,a,np.nan)
    # output
    array([[ 0., nan, nan,  3., nan, nan],
           [ 6., nan, nan,  9., nan, nan],
           [12., nan, nan, 15., nan, nan],
           [18., nan, nan, 21., nan, nan],
           [24., nan, nan, 27., nan, nan],
           [30., nan, nan, 33., nan, nan]])
    


    切片与花式索引

    值得注意的是花式索引给出的是一个 副本 而切片给出的是一个 视图

     a = np.arange(10)
     num1 = a[(a > 2) & (a < 8)]
     num2 = a[3,8]
    # output num1和num2均为
     array([3, 4, 5, 6, 7])
    
    # 修改num1
     num1[2] = 9
    # output num1改变,a未改变
     array([3, 4, 9, 6, 7])
     array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
    
    # 修改num2
     num2[2] = 9
    # output num2和a均改变
     array([3, 4, 9, 6, 7])
     array([0, 1, 2, 3, 4, 9, 6, 7, 8, 9])
    


    计算规则

    • Rule 1:首先检查多维数组之间的操作是否正确匹配形状。
    • Rule 2:数学运算符将元素逐个应用于值(+,-,*,/log,exp…)。
    • Rule 3:归约运算适用于整个数组,除非指定了坐标轴(mean,std,skew,sum…)。
    • Rule 4:除非明确忽略,否则缺失值会传播(nanmean,nansum,…)。

    这里我们主要详细讲一下规则一

    每次你在数组之间进行操作时,numpy做的第一件事就是检查它们的形状是否匹配,这称为“广播规则”。广播的初衷就是要节约时间和不必要的空间,没有必要分配更多的内存,只需要重复相同的数据。
    这里举几个被认为是匹配形状的例子。

    形状完全一致
    在最简单的情况下,如下两个形状(3,2)的数组,假设我们把它们加在一起,形状显然匹配,因为它们是相同的形状。得到的结果是数组元素对应位置逐个相加。
    形状一致时
    形状不一致
    另一种是兼容的数组,对于左边a形状为(3,2),右边b形状(2,)的数组,则numpy会认为从 右侧对齐。然后广播数组b依次与a的每一行的元素进行操作。此时numpy并不需要额外的内存来复制b将他们达到完全相同的形状。

    形状不一致

    # (3,2)、 (2,) 右侧对齐为(2) 广播3次
    a = np.arange(1,7).reshape(3,2)
    b = np.array([5,6])
    # output a+b
    array([[ 6,  8],
           [ 8, 10],
           [10, 12]])
    
    # (2,3,2,2)、 (2,2) 右侧对齐为(2,2) 广播2*3次
     a = np.arange(24).reshape(2,3,2,2)
     b = np.array([[1,1],[1,1]])
    # output a+b
    array([[[[ 1,  2],
             [ 3,  4]],
            [[ 5,  6],
             [ 7,  8]],
            [[ 9, 10],
             [11, 12]]],
             
           [[[13, 14],
             [15, 16]],
            [[17, 18],
             [19, 20]],
            [[21, 22],
             [23, 24]]]])
    
    展开全文
  • Python之Numpy详细教程

    万次阅读 多人点赞 2019-01-28 23:11:15
    NumPy - 简介 NumPy 是一个 Python 包。 它代表 “Numeric Python”。 它是一个由多维数组对象和用于处理数组的例程集合组成的库。 Numeric,即 NumPy 的前身,是由 Jim Hugunin 开发的。 也开发了另一个包 ...

    NumPy - 简介

    NumPy 是一个 Python 包。 它代表 “Numeric Python”。 它是一个由多维数组对象和用于处理数组的例程集合组成的库。

    Numeric,即 NumPy 的前身,是由 Jim Hugunin 开发的。 也开发了另一个包 Numarray ,它拥有一些额外的功能。 2005年,Travis Oliphant 通过将 Numarray 的功能集成到 Numeric 包中来创建 NumPy 包。 这个开源项目有很多贡献者。

    NumPy 操作

    使用NumPy,开发人员可以执行以下操作:

    • 数组的算数和逻辑运算。

    • 傅立叶变换和用于图形操作的例程。

    • 与线性代数有关的操作。 NumPy 拥有线性代数和随机数生成的内置函数。

    NumPy – MatLab 的替代之一

    NumPy 通常与 SciPy(Scientific Python)和 Matplotlib(绘图库)一起使用。 这种组合广泛用于替代 MatLab,是一个流行的技术计算平台。 但是,Python 作为 MatLab 的替代方案,现在被视为一种更加现代和完整的编程语言。

    NumPy 是开源的,这是它的一个额外的优势。

     

    NumPy - Ndarray 对象

    NumPy 中定义的最重要的对象是称为 ndarray 的 N 维数组类型。 它描述相同类型的元素集合。 可以使用基于零的索引访问集合中的项目。

    ndarray中的每个元素在内存中使用相同大小的块。 ndarray中的每个元素是数据类型对象的对象(称为 dtype)。

    ndarray对象提取的任何元素(通过切片)由一个数组标量类型的 Python 对象表示。 下图显示了ndarray,数据类型对象(dtype)和数组标量类型之间的关系。

    Ndarray

    Ndarray

    ndarray类的实例可以通过本教程后面描述的不同的数组创建例程来构造。 基本的ndarray是使用 NumPy 中的数组函数创建的,如下所示:

    
    numpy.array 
    
    

    它从任何暴露数组接口的对象,或从返回数组的任何方法创建一个ndarray。

    
    numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
    
    

    上面的构造器接受以下参数:

    序号 参数及描述
    1. object 任何暴露数组接口方法的对象都会返回一个数组或任何(嵌套)序列。
    2. dtype 数组的所需数据类型,可选。
    3. copy 可选,默认为true,对象是否被复制。
    4. order C(按行)、F(按列)或A(任意,默认)。
    5. subok 默认情况下,返回的数组被强制为基类数组。 如果为true,则返回子类。
    6. ndmin 指定返回数组的最小维数。

    看看下面的例子来更好地理解。

    示例 1

    
    import numpy as np 
    a = np.array([1,2,3])  
    print a
    

    输出如下:

    [1, 2, 3]
    
    

    示例 2

    
    # 多于一个维度  
    import numpy as np 
    a = np.array([[1,  2],  [3,  4]])  
    print a
    

    输出如下:

    [[1, 2] 
     [3, 4]]
    
    

    示例 3

    
    # 最小维度  
    import numpy as np 
    a = np.array([1,  2,  3,4,5], ndmin =  2)  
    print a
    

    输出如下:

    [[1, 2, 3, 4, 5]]
    
    

    示例 4

    
    # dtype 参数  
    import numpy as np 
    a = np.array([1,  2,  3], dtype = complex)  
    print a
    

    输出如下:

    [ 1.+0.j,  2.+0.j,  3.+0.j]
    
    

    **ndarray ** 对象由计算机内存中的一维连续区域组成,带有将每个元素映射到内存块中某个位置的索引方案。 内存块以按行(C 风格)或按列(FORTRAN 或 MatLab 风格)的方式保存元素。

    NumPy - 数据类型

    NumPy 支持比 Python 更多种类的数值类型。 下表显示了 NumPy 中定义的不同标量数据类型。

    序号 数据类型及描述
    1. bool_ 存储为一个字节的布尔值(真或假)
    2. int_ 默认整数,相当于 C 的long,通常为int32int64
    3. intc 相当于 C 的int,通常为int32int64
    4. intp 用于索引的整数,相当于 C 的size_t,通常为int32int64
    5. int8 字节(-128 ~ 127)
    6. int16 16 位整数(-32768 ~ 32767)
    7. int32 32 位整数(-2147483648 ~ 2147483647)
    8. int64 64 位整数(-9223372036854775808 ~ 9223372036854775807)
    9. uint8 8 位无符号整数(0 ~ 255)
    10. uint16 16 位无符号整数(0 ~ 65535)
    11. uint32 32 位无符号整数(0 ~ 4294967295)
    12. uint64 64 位无符号整数(0 ~ 18446744073709551615)
    13. float_ float64的简写
    14. float16 半精度浮点:符号位,5 位指数,10 位尾数
    15. float32 单精度浮点:符号位,8 位指数,23 位尾数
    16. float64 双精度浮点:符号位,11 位指数,52 位尾数
    17. complex_ complex128的简写
    18. complex64 复数,由两个 32 位浮点表示(实部和虚部)
    19. complex128 复数,由两个 64 位浮点表示(实部和虚部)

    NumPy 数字类型是dtype(数据类型)对象的实例,每个对象具有唯一的特征。 这些类型可以是np.bool_np.float32等。

    数据类型对象 (dtype)

    数据类型对象描述了对应于数组的固定内存块的解释,取决于以下方面:

    • 数据类型(整数、浮点或者 Python 对象)

    • 数据大小

    • 字节序(小端或大端)

    • 在结构化类型的情况下,字段的名称,每个字段的数据类型,和每个字段占用的内存块部分。

    • 如果数据类型是子序列,它的形状和数据类型。

    字节顺序取决于数据类型的前缀<><意味着编码是小端(最小有效字节存储在最小地址中)。 >意味着编码是大端(最大有效字节存储在最小地址中)。

    dtype可由一下语法构造:

    numpy.dtype(object, align, copy)
    
    

    参数为:

    • Object:被转换为数据类型的对象。

    • Align:如果为true,则向字段添加间隔,使其类似 C 的结构体。

    • Copy ? 生成dtype对象的新副本,如果为flase,结果是内建数据类型对象的引用。

    示例 1

    
    # 使用数组标量类型  
    import numpy as np 
    dt = np.dtype(np.int32)  
    print dt
    

    输出如下:

    int32
    
    

    示例 2

    
    #int8,int16,int32,int64 可替换为等价的字符串 'i1','i2','i4',以及其他。  
    import numpy as np 
    
    dt = np.dtype('i4')  
    print dt 
    

    输出如下:

    int32
    
    

    示例 3

    
    # 使用端记号  
    import numpy as np 
    dt = np.dtype('>i4')  
    print dt
    

    输出如下:

    >i4
    
    

    下面的例子展示了结构化数据类型的使用。 这里声明了字段名称和相应的标量数据类型。

    示例 4

    
    # 首先创建结构化数据类型。  
    import numpy as np 
    dt = np.dtype([('age',np.int8)])  
    print dt 
    

    输出如下:

    [('age', 'i1')] 
    
    

    示例 5

    
    # 现在将其应用于 ndarray 对象  
    import numpy as np 
    
    dt = np.dtype([('age',np.int8)]) 
    a = np.array([(10,),(20,),(30,)], dtype = dt)  
    print a
    

    输出如下:

    [(10,) (20,) (30,)]
    
    

    示例 6

    
    # 文件名称可用于访问 age 列的内容  
    import numpy as np 
    
    dt = np.dtype([('age',np.int8)]) 
    a = np.array([(10,),(20,),(30,)], dtype = dt)  
    print a['age']
    

    输出如下:

    [10 20 30]
    
    

    示例 7

    以下示例定义名为 student 的结构化数据类型,其中包含字符串字段name整数字段age浮点字段marks。 此dtype应用于ndarray对象。

    
    import numpy as np 
    student = np.dtype([('name','S20'),  ('age',  'i1'),  ('marks',  'f4')])  
    print student
    

    输出如下:

    [('name', 'S20'), ('age', 'i1'), ('marks', '<f4')])
    
    

    示例 8

    
    import numpy as np 
    
    student = np.dtype([('name','S20'),  ('age',  'i1'),  ('marks',  'f4')]) 
    a = np.array([('abc',  21,  50),('xyz',  18,  75)], dtype = student)  
    print a
    

    输出如下:

    [('abc', 21, 50.0), ('xyz', 18, 75.0)]
    
    

    每个内建类型都有一个唯一定义它的字符代码:

    • 'b':布尔值

    • 'i':符号整数

    • 'u':无符号整数

    • 'f':浮点

    • 'c':复数浮点

    • 'm':时间间隔

    • 'M':日期时间

    • 'O':Python 对象

    • 'S', 'a':字节串

    • 'U':Unicode

    • 'V':原始数据(void

    NumPy - 数组属性

    这一章中,我们会讨论 NumPy 的多种数组属性。

    ndarray.shape

    这一数组属性返回一个包含数组维度的元组,它也可以用于调整数组大小。

    示例 1

    
    import numpy as np 
    a = np.array([[1,2,3],[4,5,6]])  
    print a.shape
    

    输出如下:

    (2, 3)
    
    

    示例 2

    
    # 这会调整数组大小  
    import numpy as np 
    
    a = np.array([[1,2,3],[4,5,6]]) a.shape =  (3,2)  
    print a 
    

    输出如下:

    [[1, 2] 
     [3, 4] 
     [5, 6]]
    
    

    示例 3

    NumPy 也提供了reshape函数来调整数组大小。

    
    import numpy as np 
    a = np.array([[1,2,3],[4,5,6]]) 
    b = a.reshape(3,2)  
    print b
    

    输出如下:

    [[1, 2] 
     [3, 4] 
     [5, 6]]
    
    

    ndarray.ndim

    这一数组属性返回数组的维数。

    示例 1

    
    # 等间隔数字的数组  
    import numpy as np 
    a = np.arange(24)  print a
    

    输出如下:

    [0 1  2  3  4  5  6  7  8  9  10  11  12  13  14  15  16 17 18 19 20 21 22 23] 
    
    

    示例 2

    
    # 一维数组  
    import numpy as np 
    a = np.arange(24) a.ndim 
    # 现在调整其大小
    b = a.reshape(2,4,3)  
    print b 
    # b 现在拥有三个维度
    

    输出如下:

    [[[ 0,  1,  2] 
      [ 3,  4,  5] 
      [ 6,  7,  8] 
      [ 9, 10, 11]]  
      [[12, 13, 14] 
       [15, 16, 17]
       [18, 19, 20] 
       [21, 22, 23]]] 
    
    

    numpy.itemsize

    这一数组属性返回数组中每个元素的字节单位长度。

    示例 1

    
    # 数组的 dtype 为 int8(一个字节)  
    import numpy as np 
    x = np.array([1,2,3,4,5], dtype = np.int8)  
    print x.itemsize
    

    输出如下:

    1
    
    

    示例 2

    
    # 数组的 dtype 现在为 float32(四个字节)  
    import numpy as np 
    x = np.array([1,2,3,4,5], dtype = np.float32)  
    print x.itemsize
    

    输出如下:

    4
    
    

    numpy.flags

    ndarray对象拥有以下属性。这个函数返回了它们的当前值。

    序号 属性及描述
    1. C_CONTIGUOUS (C) 数组位于单一的、C 风格的连续区段内
    2. F_CONTIGUOUS (F) 数组位于单一的、Fortran 风格的连续区段内
    3. OWNDATA (O) 数组的内存从其它对象处借用
    4. WRITEABLE (W) 数据区域可写入。 将它设置为flase会锁定数据,使其只读
    5. ALIGNED (A) 数据和任何元素会为硬件适当对齐
    6. UPDATEIFCOPY (U) 这个数组是另一数组的副本。当这个数组释放时,源数组会由这个数组中的元素更新

    示例

    下面的例子展示当前的标志。

    
    import numpy as np 
    x = np.array([1,2,3,4,5])  
    print x.flags
    

    输出如下:

    
    C_CONTIGUOUS : True 
    F_CONTIGUOUS : True 
    OWNDATA : True 
    WRITEABLE : True 
    ALIGNED : True 
    UPDATEIFCOPY : False
    
    

    NumPy - 数组创建例程

    新的ndarray对象可以通过任何下列数组创建例程或使用低级ndarray构造函数构造。

    numpy.empty

    它创建指定形状和dtype的未初始化数组。 它使用以下构造函数:

    numpy.empty(shape, dtype = float, order = 'C')
    
    

    构造器接受下列参数:

    序号 参数及描述
    1. Shape 空数组的形状,整数或整数元组
    2. Dtype 所需的输出数组类型,可选
    3. Order 'C'为按行的 C 风格数组,'F'为按列的 Fortran 风格数组

    示例

    下面的代码展示空数组的例子:

    
    import numpy as np 
    x = np.empty([3,2], dtype =  int)  
    print x
    

    输出如下:

    [[22649312    1701344351] 
     [1818321759  1885959276] 
     [16779776    156368896]]
    
    

    注意:数组元素为随机值,因为它们未初始化。

    numpy.zeros

    返回特定大小,以 0 填充的新数组。

    numpy.zeros(shape, dtype = float, order = 'C')
    
    

    构造器接受下列参数:

    序号 参数及描述
    1. Shape 空数组的形状,整数或整数元组
    2. Dtype 所需的输出数组类型,可选
    3. Order 'C'为按行的 C 风格数组,'F'为按列的 Fortran 风格数组

    示例 1

    
    # 含有 5 个 0 的数组,默认类型为 float  
    import numpy as np 
    x = np.zeros(5)  
    print x
    

    输出如下:

    [ 0.  0.  0.  0.  0.]
    
    

    示例 2

    
    import numpy as np 
    x = np.zeros((5,), dtype = np.int)  
    print x
    

    输出如下:

    [0  0  0  0  0]
    
    

    示例 3

    
    # 自定义类型 
    import numpy as np 
    x = np.zeros((2,2), dtype =  [('x',  'i4'),  ('y',  'i4')])  
    print x
    

    输出如下:

    [[(0,0)(0,0)]
     [(0,0)(0,0)]]         
    
    

    numpy.ones

    返回特定大小,以 1 填充的新数组。

    
    numpy.ones(shape, dtype = None, order = 'C')
    
    

    构造器接受下列参数:

    序号 参数及描述
    1. Shape 空数组的形状,整数或整数元组
    2. Dtype 所需的输出数组类型,可选
    3. Order 'C'为按行的 C 风格数组,'F'为按列的 Fortran 风格数组

    示例 1

    
    # 含有 5 个 1 的数组,默认类型为 float  
    import numpy as np 
    x = np.ones(5)  print x
    

    输出如下:

    [ 1.  1.  1.  1.  1.]
    
    

    示例 2

    
    import numpy as np 
    x = np.ones([2,2], dtype =  int)  
    print x
    

    输出如下:

    [[1  1] 
     [1  1]]
    
    

    NumPy - 来自现有数据的数组

    这一章中,我们会讨论如何从现有数据创建数组。

    numpy.asarray

    此函数类似于numpy.array,除了它有较少的参数。 这个例程对于将 Python 序列转换为ndarray非常有用。

    
    numpy.asarray(a, dtype = None, order = None)
    
    

    构造器接受下列参数:

    序号 参数及描述
    1. a 任意形式的输入参数,比如列表、列表的元组、元组、元组的元组、元组的列表
    2. dtype 通常,输入数据的类型会应用到返回的ndarray
    3. order 'C'为按行的 C 风格数组,'F'为按列的 Fortran 风格数组

    下面的例子展示了如何使用asarray函数:

    示例 1

    
    # 将列表转换为 ndarray 
    import numpy as np 
    
    x =  [1,2,3] 
    a = np.asarray(x)  
    print a
    

    输出如下:

    [1  2  3] 
    
    

    示例 2

    
    # 设置了 dtype  
    import numpy as np 
    
    x =  [1,2,3] 
    a = np.asarray(x, dtype =  float)  
    print a
    

    输出如下:

    [ 1.  2.  3.] 
    
    

    示例 3

    
    # 来自元组的 ndarray  
    import numpy as np 
    
    x =  (1,2,3) 
    a = np.asarray(x)  
    print a
    

    输出如下:

    [1  2  3]
    
    

    示例 4

    
    # 来自元组列表的 ndarray
    import numpy as np 
    
    x =  [(1,2,3),(4,5)] 
    a = np.asarray(x)  
    print a
    

    输出如下:

    [(1, 2, 3) (4, 5)]
    
    

    numpy.frombuffer

    此函数将缓冲区解释为一维数组。 暴露缓冲区接口的任何对象都用作参数来返回ndarray

    numpy.frombuffer(buffer, dtype = float, count = -1, offset = 0)
    
    

    构造器接受下列参数:

    序号 参数及描述
    1. buffer 任何暴露缓冲区借口的对象
    2. dtype 返回数组的数据类型,默认为float
    3. count 需要读取的数据数量,默认为-1,读取所有数据
    4. offset 需要读取的起始位置,默认为0

    示例

    下面的例子展示了frombuffer函数的用法。

    
    import numpy as np 
    s =  'Hello World' 
    a = np.frombuffer(s, dtype =  'S1')  
    print a
    

    输出如下:

    ['H'  'e'  'l'  'l'  'o'  ' '  'W'  'o'  'r'  'l'  'd']
    
    

    numpy.fromiter

    此函数从任何可迭代对象构建一个ndarray对象,返回一个新的一维数组。

    numpy.fromiter(iterable, dtype, count = -1)
    
    

    构造器接受下列参数:

    序号 参数及描述
    1. iterable 任何可迭代对象
    2. dtype 返回数组的数据类型
    3. count 需要读取的数据数量,默认为-1,读取所有数据

    以下示例展示了如何使用内置的range()函数返回列表对象。 此列表的迭代器用于形成ndarray对象。

    示例 1

    
    # 使用 range 函数创建列表对象  
    import numpy as np 
    list = range(5)  
    print list
    

    输出如下:

    [0,  1,  2,  3,  4]
    
    

    示例 2

    
    # 从列表中获得迭代器  
    import numpy as np 
    list = range(5) 
    it = iter(list)  
    # 使用迭代器创建 ndarray 
    x = np.fromiter(it, dtype =  float)  
    print x
    

    输出如下:

    [0.   1.   2.   3.   4.]
    
    

    NumPy - 来自数值范围的数组

    这一章中,我们会学到如何从数值范围创建数组。

    numpy.arange

    这个函数返回ndarray对象,包含给定范围内的等间隔值。

    
    numpy.arange(start, stop, step, dtype)
    
    

    构造器接受下列参数:

    序号 参数及描述
    1. start 范围的起始值,默认为0
    2. stop 范围的终止值(不包含)
    3. step 两个值的间隔,默认为1
    4. dtype 返回ndarray的数据类型,如果没有提供,则会使用输入数据的类型。

    下面的例子展示了如何使用该函数:

    示例 1

    
    import numpy as np
    x = np.arange(5)  
    print x
    

    输出如下:

    [0  1  2  3  4]
    
    

    示例 2

    
    import numpy as np
    # 设置了 dtype
    x = np.arange(5, dtype =  float)  
    print x
    

    输出如下:

    [0.  1.  2.  3.  4.]
    
    

    示例 3

    
    # 设置了起始值和终止值参数  
    import numpy as np
    x = np.arange(10,20,2)  
    print x
    

    输出如下:

    [10  12  14  16  18]
    
    

    numpy.linspace

    此函数类似于arange()函数。 在此函数中,指定了范围之间的均匀间隔数量,而不是步长。 此函数的用法如下。

    
    numpy.linspace(start, stop, num, endpoint, retstep, dtype)
    
    

    构造器接受下列参数:

    序号 参数及描述
    1. start 序列的起始值
    2. stop 序列的终止值,如果endpointtrue,该值包含于序列中
    3. num 要生成的等间隔样例数量,默认为50
    4. endpoint 序列中是否包含stop值,默认为ture
    5. retstep 如果为true,返回样例,以及连续数字之间的步长
    6. dtype 输出ndarray的数据类型

    下面的例子展示了linspace函数的用法。

    示例 1

    
    import numpy as np
    x = np.linspace(10,20,5)  
    print x
    

    输出如下:

    [10.   12.5   15.   17.5  20.]
    
    

    示例 2

    
    # 将 endpoint 设为 false
    import numpy as np
    x = np.linspace(10,20,  5, endpoint =  False)  
    print x
    

    输出如下:

    [10.   12.   14.   16.   18.]
    
    

    示例 3

    
    # 输出 retstep 值  
    import numpy as np
    
    x = np.linspace(1,2,5, retstep =  True)  
    print x
    # 这里的 retstep 为 0.25
    

    输出如下:

    
    (array([ 1.  ,  1.25,  1.5 ,  1.75,  2.  ]), 0.25)
    
    

    numpy.logspace

    此函数返回一个ndarray对象,其中包含在对数刻度上均匀分布的数字。 刻度的开始和结束端点是某个底数的幂,通常为 10。

    
    numpy.logscale(start, stop, num, endpoint, base, dtype)
    
    

    logspace函数的输出由以下参数决定:

    序号 参数及描述
    1. start 起始值是base ** start
    2. stop 终止值是base ** stop
    3. num 范围内的数值数量,默认为50
    4. endpoint 如果为true,终止值包含在输出数组当中
    5. base 对数空间的底数,默认为10
    6. dtype 输出数组的数据类型,如果没有提供,则取决于其它参数

    下面的例子展示了logspace函数的用法。

    示例 1

    
    import numpy as np
    # 默认底数是 10
    a = np.logspace(1.0,  2.0, num =  10)  
    print a
    

    输出如下:

    [ 10.           12.91549665     16.68100537      21.5443469  27.82559402      
      35.93813664   46.41588834     59.94842503      77.42636827    100.    ]
    
    

    示例 2

    
    # 将对数空间的底数设置为 2  
    import numpy as np
    a = np.logspace(1,10,num =  10,  base  =  2)  
    print a
    

    输出如下:

    [ 2.     4.     8.    16.    32.    64.   128.   256.    512.   1024.]
    
    

    NumPy - 切片和索引

    ndarray对象的内容可以通过索引或切片来访问和修改,就像 Python 的内置容器对象一样。

    如前所述,ndarray对象中的元素遵循基于零的索引。 有三种可用的索引方法类型: 字段访问,基本切片高级索引

    基本切片是 Python 中基本切片概念到 n 维的扩展。 通过将startstopstep参数提供给内置的slice函数来构造一个 Python slice对象。 此slice对象被传递给数组来提取数组的一部分。

    示例 1

    
    import numpy as np
    a = np.arange(10)
    s = slice(2,7,2)  
    print a[s]
    

    输出如下:

    [2  4  6]
    
    

    在上面的例子中,ndarray对象由arange()函数创建。 然后,分别用起始,终止和步长值272定义切片对象。 当这个切片对象传递给ndarray时,会对它的一部分进行切片,从索引27,步长为2

    通过将由冒号分隔的切片参数(start:stop:step)直接提供给ndarray对象,也可以获得相同的结果。

    示例 2

    
    import numpy as np
    a = np.arange(10)
    b = a[2:7:2]  
    print b
    

    输出如下:

    [2  4  6]
    
    

    如果只输入一个参数,则将返回与索引对应的单个项目。 如果使用a:,则从该索引向后的所有项目将被提取。 如果使用两个参数(以:分隔),则对两个索引(不包括停止索引)之间的元素以默认步骤进行切片。

    示例 3

    
    # 对单个元素进行切片  
    import numpy as np
    
    a = np.arange(10)
    b = a[5]  
    print b
    

    输出如下:

    5
    
    

    示例 4

    
    # 对始于索引的元素进行切片  
    import numpy as np
    a = np.arange(10)  
    print a[2:]
    

    输出如下:

    [2  3  4  5  6  7  8  9]
    
    

    示例 5

    
    # 对索引之间的元素进行切片  
    import numpy as np
    a = np.arange(10)  
    print a[2:5]
    

    输出如下:

    [2  3  4]
    
    

    上面的描述也可用于多维ndarray

    示例 6

    
    import numpy as np
    a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
    print a
    # 对始于索引的元素进行切片  
    print  '现在我们从索引 a[1:] 开始对数组切片'  
    print a[1:]
    

    输出如下:

    
    [[1 2 3]
     [3 4 5]
     [4 5 6]]
    
    现在我们从索引 a[1:] 开始对数组切片
    [[3 4 5]
     [4 5 6]]
    
    

    切片还可以包括省略号(...),来使选择元组的长度与数组的维度相同。 如果在行位置使用省略号,它将返回包含行中元素的ndarray

    示例 7

    
    # 最开始的数组  
    import numpy as np
    a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
    print  '我们的数组是:'  
    print a
    print  '\n'  
    # 这会返回第二列元素的数组:  
    print  '第二列的元素是:'  
    print a[...,1]  
    print  '\n'  
    # 现在我们从第二行切片所有元素:  
    print  '第二行的元素是:'  
    print a[1,...]  
    print  '\n'  
    # 现在我们从第二列向后切片所有元素:
    print  '第二列及其剩余元素是:'  
    print a[...,1:]
    

    输出如下:

    
    我们的数组是:
    [[1 2 3]
     [3 4 5]
     [4 5 6]]
    
    第二列的元素是:
    [2 4 5]
    
    第二行的元素是:
    [3 4 5]
    
    第二列及其剩余元素是:
    [[2 3]
     [4 5]
     [5 6]]
    
    

    NumPy - 高级索引

    如果一个ndarray是非元组序列,数据类型为整数或布尔值的ndarray,或者至少一个元素为序列对象的元组,我们就能够用它来索引ndarray。高级索引始终返回数据的副本。 与此相反,切片只提供了一个视图。

    有两种类型的高级索引:整数和布尔值。

    整数索引

    这种机制有助于基于 N 维索引来获取数组中任意元素。 每个整数数组表示该维度的下标值。 当索引的元素个数就是目标ndarray的维度时,会变得相当直接。

    以下示例获取了ndarray对象中每一行指定列的一个元素。 因此,行索引包含所有行号,列索引指定要选择的元素。

    示例 1

    
    import numpy as np 
    
    x = np.array([[1,  2],  [3,  4],  [5,  6]]) 
    y = x[[0,1,2],  [0,1,0]]  
    print y
    

    输出如下:

    [1  4  5]
    
    

    该结果包括数组中(0,0)(1,1)(2,0)位置处的元素。

    下面的示例获取了 4X3 数组中的每个角处的元素。 行索引是[0,0][3,3],而列索引是[0,2][0,2]

    示例 2

    
    import numpy as np 
    x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
    print  '我们的数组是:'  
    print x 
    print  '\n' 
    rows = np.array([[0,0],[3,3]]) 
    cols = np.array([[0,2],[0,2]]) 
    y = x[rows,cols]  
    print  '这个数组的每个角处的元素是:'  
    print y
    

    输出如下:

    
    我们的数组是:                                                                 
    [[ 0  1  2]                                                                   
     [ 3  4  5]                                                                   
     [ 6  7  8]                                                                   
     [ 9 10 11]]
    
    这个数组的每个角处的元素是:                                      
    [[ 0  2]                                                                      
     [ 9 11]] 
    
    

    返回的结果是包含每个角元素的ndarray对象。

    高级和基本索引可以通过使用切片:或省略号...与索引数组组合。 以下示例使用slice作为列索引和高级索引。 当切片用于两者时,结果是相同的。 但高级索引会导致复制,并且可能有不同的内存布局。

    示例 3

    
    import numpy as np 
    x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
    print  '我们的数组是:'  
    print x 
    print  '\n'  
    # 切片
    z = x[1:4,1:3]  
    print  '切片之后,我们的数组变为:'  
    print z 
    print  '\n'  
    # 对列使用高级索引 
    y = x[1:4,[1,2]] 
    print  '对列使用高级索引来切片:'  
    print y
    

    输出如下:

    
    我们的数组是:
    [[ 0  1  2] 
     [ 3  4  5] 
     [ 6  7  8]
     [ 9 10 11]]
    
    切片之后,我们的数组变为:
    [[ 4  5]
     [ 7  8]
     [10 11]]
    
    对列使用高级索引来切片:
    [[ 4  5]
     [ 7  8]
     [10 11]] 
    
    

    布尔索引

    当结果对象是布尔运算(例如比较运算符)的结果时,将使用此类型的高级索引。

    示例 1

    这个例子中,大于 5 的元素会作为布尔索引的结果返回。

    
    import numpy as np 
    x = np.array([[  0,  1,  2],[  3,  4,  5],[  6,  7,  8],[  9,  10,  11]])  
    print  '我们的数组是:'  
    print x 
    print  '\n'  
    # 现在我们会打印出大于 5 的元素  
    print  '大于 5 的元素是:'  
    print x[x >  5]
    

    输出如下:

    
    我们的数组是:
    [[ 0  1  2] 
     [ 3  4  5] 
     [ 6  7  8] 
     [ 9 10 11]] 
    
    大于 5 的元素是:
    [ 6  7  8  9 10 11] 
    
    

    示例 2

    这个例子使用了~(取补运算符)来过滤NaN

    
    import numpy as np 
    a = np.array([np.nan,  1,2,np.nan,3,4,5])  
    print a[~np.isnan(a)]
    

    输出如下:

    [ 1.   2.   3.   4.   5.] 
    
    

    示例 3

    以下示例显示如何从数组中过滤掉非复数元素。

    
    import numpy as np 
    a = np.array([1,  2+6j,  5,  3.5+5j])  
    print a[np.iscomplex(a)]
    

    输出如下:

    [2.0+6.j  3.5+5.j] 
    
    

    NumPy - 广播

    术语广播是指 NumPy 在算术运算期间处理不同形状的数组的能力。 对数组的算术运算通常在相应的元素上进行。 如果两个阵列具有完全相同的形状,则这些操作被无缝执行。

    示例 1

    
    import numpy as np 
    
    a = np.array([1,2,3,4]) 
    b = np.array([10,20,30,40]) 
    c = a * b 
    print c
    

    输出如下:

    [10   40   90   160]
    
    

    如果两个数组的维数不相同,则元素到元素的操作是不可能的。 然而,在 NumPy 中仍然可以对形状不相似的数组进行操作,因为它拥有广播功能。 较小的数组会广播到较大数组的大小,以便使它们的形状可兼容。

    如果满足以下规则,可以进行广播:

    • ndim较小的数组会在前面追加一个长度为 1 的维度。

    • 输出数组的每个维度的大小是输入数组该维度大小的最大值。

    • 如果输入在每个维度中的大小与输出大小匹配,或其值正好为 1,则在计算中可它。

    • 如果输入的某个维度大小为 1,则该维度中的第一个数据元素将用于该维度的所有计算。

    如果上述规则产生有效结果,并且满足以下条件之一,那么数组被称为可广播的

    • 数组拥有相同形状。

    • 数组拥有相同的维数,每个维度拥有相同长度,或者长度为 1。

    • 数组拥有极少的维度,可以在其前面追加长度为 1 的维度,使上述条件成立。

    下面的例称展示了广播的示例。

    示例 2

    
    import numpy as np 
    a = np.array([[0.0,0.0,0.0],[10.0,10.0,10.0],[20.0,20.0,20.0],[30.0,30.0,30.0]]) 
    b = np.array([1.0,2.0,3.0])  
    print  '第一个数组:'  
    print a 
    print  '\n'  
    print  '第二个数组:'  
    print b 
    print  '\n'  
    print  '第一个数组加第二个数组:'  
    print a + b
    

    输出如下:

    
    第一个数组:
    [[ 0. 0. 0.]
     [ 10. 10. 10.]
     [ 20. 20. 20.]
     [ 30. 30. 30.]]
    
    第二个数组:
    [ 1. 2. 3.]
    
    第一个数组加第二个数组:
    [[ 1. 2. 3.]
     [ 11. 12. 13.]
     [ 21. 22. 23.]
     [ 31. 32. 33.]]
    
    

    下面的图片展示了数组b如何通过广播来与数组a兼容。

    array

    array

    NumPy - 数组上的迭代

    NumPy 包包含一个迭代器对象numpy.nditer。 它是一个有效的多维迭代器对象,可以用于在数组上进行迭代。 数组的每个元素可使用 Python 的标准Iterator接口来访问。

    让我们使用arange()函数创建一个 3X4 数组,并使用nditer对它进行迭代。

    示例 1

    
    import numpy as np
    a = np.arange(0,60,5) 
    a = a.reshape(3,4)  
    print  '原始数组是:'  
    print a print  '\n'  
    print  '修改后的数组是:'  
    for x in np.nditer(a):  
        print x,
    

    输出如下:

    
    原始数组是:
    [[ 0 5 10 15]
     [20 25 30 35]
     [40 45 50 55]]
    
    修改后的数组是:
    0 5 10 15 20 25 30 35 40 45 50 55
    
    

    示例 2

    迭代的顺序匹配数组的内容布局,而不考虑特定的排序。 这可以通过迭代上述数组的转置来看到。

    
    import numpy as np 
    a = np.arange(0,60,5) 
    a = a.reshape(3,4)  
    print  '原始数组是:'  
    print a 
    print  '\n'  
    print  '原始数组的转置是:' 
    b = a.T 
    print b 
    print  '\n'  
    print  '修改后的数组是:'  
    for x in np.nditer(b):  
        print x,
    

    输出如下:

    
    原始数组是:
    [[ 0 5 10 15]
     [20 25 30 35]
     [40 45 50 55]]
    
    原始数组的转置是:
    [[ 0 20 40]
     [ 5 25 45]
     [10 30 50]
     [15 35 55]]
    
    修改后的数组是:
    0 5 10 15 20 25 30 35 40 45 50 55
    
    

    迭代顺序

    如果相同元素使用 F 风格顺序存储,则迭代器选择以更有效的方式对数组进行迭代。

    示例 1

    
    import numpy as np
    a = np.arange(0,60,5) 
    a = a.reshape(3,4)  
    print  '原始数组是:'  
    print a print  '\n'  
    print  '原始数组的转置是:' 
    b = a.T 
    print b 
    print  '\n'  
    print  '以 C 风格顺序排序:' 
    c = b.copy(order='C')  
    print c for x in np.nditer(c):  
        print x,  
    print  '\n'  
    print  '以 F 风格顺序排序:' 
    c = b.copy(order='F')  
    print c 
    for x in np.nditer(c):  
        print x,
    

    输出如下:

    
    原始数组是:
    [[ 0 5 10 15]
     [20 25 30 35]
     [40 45 50 55]]
    
    原始数组的转置是:
    [[ 0 20 40]
     [ 5 25 45]
     [10 30 50]
     [15 35 55]]
    
    以 C 风格顺序排序:
    [[ 0 20 40]
     [ 5 25 45]
     [10 30 50]
     [15 35 55]]
    0 20 40 5 25 45 10 30 50 15 35 55
    
    以 F 风格顺序排序:
    [[ 0 20 40]
     [ 5 25 45]
     [10 30 50]
     [15 35 55]]
    0 5 10 15 20 25 30 35 40 45 50 55
    
    

    示例 2

    可以通过显式提醒,来强制nditer对象使用某种顺序:

    
    import numpy as np 
    a = np.arange(0,60,5) 
    a = a.reshape(3,4)  
    print  '原始数组是:'  
    print a 
    print  '\n'  
    print  '以 C 风格顺序排序:'  
    for x in np.nditer(a, order =  'C'):  
        print x,  
    print  '\n'  
    print  '以 F 风格顺序排序:'  
    for x in np.nditer(a, order =  'F'):  
        print x,
    

    输出如下:

    
    原始数组是:
    [[ 0 5 10 15]
     [20 25 30 35]
     [40 45 50 55]]
    
    以 C 风格顺序排序:
    0 5 10 15 20 25 30 35 40 45 50 55
    
    以 F 风格顺序排序:
    0 20 40 5 25 45 10 30 50 15 35 55
    
    

    修改数组的值

    nditer对象有另一个可选参数op_flags。 其默认值为只读,但可以设置为读写或只写模式。 这将允许使用此迭代器修改数组元素。

    示例

    
    import numpy as np
    a = np.arange(0,60,5) 
    a = a.reshape(3,4)  
    print  '原始数组是:'  
    print a 
    print  '\n'  
    for x in np.nditer(a, op_flags=['readwrite']): 
        x[...]=2*x 
    print  '修改后的数组是:'  
    print a
    

    输出如下:

    
    原始数组是:
    [[ 0 5 10 15]
     [20 25 30 35]
     [40 45 50 55]]
    
    修改后的数组是:
    [[ 0 10 20 30]
     [ 40 50 60 70]
     [ 80 90 100 110]]
    
    

    外部循环

    nditer类的构造器拥有flags参数,它可以接受下列值:

    序号 参数及描述
    1. c_index 可以跟踪 C 顺序的索引
    2. f_index 可以跟踪 Fortran 顺序的索引
    3. multi-index 每次迭代可以跟踪一种索引类型
    4. external_loop 给出的值是具有多个值的一维数组,而不是零维数组

    示例

    在下面的示例中,迭代器遍历对应于每列的一维数组。

    
    import numpy as np 
    a = np.arange(0,60,5) 
    a = a.reshape(3,4)  
    print  '原始数组是:'  
    print a 
    print  '\n'  
    print  '修改后的数组是:'  
    for x in np.nditer(a, flags =  ['external_loop'], order =  'F'):  
        print x,
    

    输出如下:

    
    原始数组是:
    [[ 0 5 10 15]
     [20 25 30 35]
     [40 45 50 55]]
    
    修改后的数组是:
    [ 0 20 40] [ 5 25 45] [10 30 50] [15 35 55]
    
    

    广播迭代

    如果两个数组是可广播的nditer组合对象能够同时迭代它们。 假设数组a具有维度 3X4,并且存在维度为 1X4 的另一个数组b,则使用以下类型的迭代器(数组b被广播到a的大小)。

    示例

    
    import numpy as np 
    a = np.arange(0,60,5) 
    a = a.reshape(3,4)  
    print  '第一个数组:'  
    print a 
    print  '\n'  
    print  '第二个数组:' 
    b = np.array([1,  2,  3,  4], dtype =  int)  
    print b 
    print  '\n'  
    print  '修改后的数组是:'  
    for x,y in np.nditer([a,b]):  
        print  "%d:%d"  %  (x,y),
    

    输出如下:

    
    第一个数组:
    [[ 0 5 10 15]
     [20 25 30 35]
     [40 45 50 55]]
    
    第二个数组:
    [1 2 3 4]
    
    修改后的数组是:
    0:1 5:2 10:3 15:4 20:1 25:2 30:3 35:4 40:1 45:2 50:3 55:4
    
    

    NumPy - 数组操作

    NumPy包中有几个例程用于处理ndarray对象中的元素。 它们可以分为以下类型:

    修改形状

    序号 形状及描述
    1. reshape 不改变数据的条件下修改形状
    2. flat 数组上的一维迭代器
    3. flatten 返回折叠为一维的数组副本
    4. ravel 返回连续的展开数组

    numpy.reshape

    这个函数在不改变数据的条件下修改形状,它接受如下参数:

    numpy.reshape(arr, newshape, order')
    

    其中:

    • arr:要修改形状的数组
    • newshape:整数或者整数数组,新的形状应当兼容原有形状
    • order'C'为 C 风格顺序,'F'为 F 风格顺序,'A'为保留原顺序。

    例子

    
    import numpy as np
    a = np.arange(8)
    print '原始数组:'
    print a
    print '\n'
    
    b = a.reshape(4,2)
    print '修改后的数组:'
    print b
    

    输出如下:

    
    原始数组:
    [0 1 2 3 4 5 6 7]
    
    修改后的数组:
    [[0 1]
     [2 3]
     [4 5]
     [6 7]]
    

    numpy.ndarray.flat

    该函数返回数组上的一维迭代器,行为类似 Python 内建的迭代器。

    例子

    
    import numpy as np 
    a = np.arange(8).reshape(2,4) 
    print '原始数组:' 
    print a 
    print '\n' 
    
    print '调用 flat 函数之后:' 
    # 返回展开数组中的下标的对应元素 
    print a.flat[5]
    

    输出如下:

    
    原始数组:
    [[0 1 2 3]
     [4 5 6 7]]
    
    调用 flat 函数之后:
    5
    

    numpy.ndarray.flatten

    该函数返回折叠为一维的数组副本,函数接受下列参数:

    
    ndarray.flatten(order)
    

    其中:

    • order'C' -- 按行,'F' -- 按列,'A' -- 原顺序,'k' -- 元素在内存中的出现顺序。

    例子

    
    import numpy as np 
    a = np.arange(8).reshape(2,4) 
    
    print '原数组:' 
    print a 
    print '\n'  
    # default is column-major 
    
    print '展开的数组:' 
    print a.flatten() 
    print '\n'  
    
    print '以 F 风格顺序展开的数组:' 
    print a.flatten(order = 'F')
    

    输出如下:

    
    原数组:
    [[0 1 2 3]
     [4 5 6 7]]
    
    展开的数组:
    [0 1 2 3 4 5 6 7]
    
    以 F 风格顺序展开的数组:
    [0 4 1 5 2 6 3 7]
    

    numpy.ravel

    这个函数返回展开的一维数组,并且按需生成副本。返回的数组和输入数组拥有相同数据类型。这个函数接受两个参数。

    
    numpy.ravel(a, order)
    

    构造器接受下列参数:

    • order'C' -- 按行,'F' -- 按列,'A' -- 原顺序,'k' -- 元素在内存中的出现顺序。

    例子

    
    import numpy as np 
    a = np.arange(8).reshape(2,4) 
    
    print '原数组:' 
    print a 
    print '\n'  
    
    print '调用 ravel 函数之后:' 
    print a.ravel()  
    print '\n' 
    
    print '以 F 风格顺序调用 ravel 函数之后:' 
    print a.ravel(order = 'F')
    
    
    原数组:
    [[0 1 2 3]
     [4 5 6 7]]
    
    调用 ravel 函数之后:
    [0 1 2 3 4 5 6 7]
    
    以 F 风格顺序调用 ravel 函数之后:
    [0 4 1 5 2 6 3 7]
    

    翻转操作

    序号 操作及描述
    1. transpose 翻转数组的维度
    2. ndarray.Tself.transpose()相同
    3. rollaxis 向后滚动指定的轴
    4. swapaxes 互换数组的两个轴

    numpy.transpose

    这个函数翻转给定数组的维度。如果可能的话它会返回一个视图。函数接受下列参数:

    
    numpy.transpose(arr, axes)
    

    其中:

    • arr:要转置的数组
    • axes:整数的列表,对应维度,通常所有维度都会翻转。

    例子

    
    import numpy as np 
    a = np.arange(12).reshape(3,4) 
    
    print '原数组:' 
    print a  
    print '\n' 
    
    print '转置数组:' 
    print np.transpose(a)
    

    输出如下:

    
    原数组:
    [[ 0 1 2 3]
     [ 4 5 6 7]
     [ 8 9 10 11]]
    
    转置数组:
    [[ 0 4 8]
     [ 1 5 9]
     [ 2 6 10]
     [ 3 7 11]]
    

    numpy.ndarray.T

    该函数属于ndarray类,行为类似于numpy.transpose

    例子

    
    import numpy as np 
    a = np.arange(12).reshape(3,4) 
    
    print '原数组:' 
    print a 
    print '\n'  
    
    print '转置数组:' 
    print a.T
    

    输出如下:

    
    原数组:
    [[ 0 1 2 3]
     [ 4 5 6 7]
     [ 8 9 10 11]]
    
    转置数组:
    [[ 0 4 8]
     [ 1 5 9]
     [ 2 6 10]
     [ 3 7 11]]
    

    numpy.rollaxis

    该函数向后滚动特定的轴,直到一个特定位置。这个函数接受三个参数:

    
    numpy.rollaxis(arr, axis, start)
    

    其中:

    • arr:输入数组
    • axis:要向后滚动的轴,其它轴的相对位置不会改变
    • start:默认为零,表示完整的滚动。会滚动到特定位置。

    例子

    
    # 创建了三维的 ndarray 
    import numpy as np 
    a = np.arange(8).reshape(2,2,2) 
    
    print '原数组:' 
    print a 
    print '\n'
    # 将轴 2 滚动到轴 0(宽度到深度)
    
    print '调用 rollaxis 函数:' 
    print np.rollaxis(a,2)  
    # 将轴 0 滚动到轴 1:(宽度到高度)
    print '\n' 
    
    print '调用 rollaxis 函数:' 
    print np.rollaxis(a,2,1)
    

    输出如下:

    
    原数组:
    [[[0 1]
     [2 3]]
     [[4 5]
     [6 7]]]
    
    调用 rollaxis 函数:
    [[[0 2]
     [4 6]]
     [[1 3]
     [5 7]]]
    
    调用 rollaxis 函数:
    [[[0 2]
     [1 3]]
     [[4 6]
     [5 7]]]
    

    numpy.swapaxes

    该函数交换数组的两个轴。对于 1.10 之前的 NumPy 版本,会返回交换后数组的试图。这个函数接受下列参数:

    
    numpy.swapaxes(arr, axis1, axis2)
    
    • arr:要交换其轴的输入数组
    • axis1:对应第一个轴的整数
    • axis2:对应第二个轴的整数
    
    # 创建了三维的 ndarray 
    import numpy as np 
    a = np.arange(8).reshape(2,2,2) 
    
    print '原数组:'
    print a 
    print '\n'  
    # 现在交换轴 0(深度方向)到轴 2(宽度方向)
    
    print '调用 swapaxes 函数后的数组:' 
    print np.swapaxes(a, 2, 0)
    

    输出如下:

    
    原数组:
    [[[0 1]
     [2 3]]
    
     [[4 5]
      [6 7]]]
    
    调用 swapaxes 函数后的数组:
    [[[0 4]
     [2 6]]
     
     [[1 5]
      [3 7]]]
    

    修改维度

    序号 维度和描述
    1. broadcast 产生模仿广播的对象
    2. broadcast_to 将数组广播到新形状
    3. expand_dims 扩展数组的形状
    4. squeeze 从数组的形状中删除单维条目

    broadcast

    如前所述,NumPy 已经内置了对广播的支持。 此功能模仿广播机制。 它返回一个对象,该对象封装了将一个数组广播到另一个数组的结果。

    该函数使用两个数组作为输入参数。 下面的例子说明了它的用法。

    
    import numpy as np 
    x = np.array([[1], [2], [3]]) 
    y = np.array([4, 5, 6])  
       
    # 对 y 广播 x
    b = np.broadcast(x,y)  
    # 它拥有 iterator 属性,基于自身组件的迭代器元组 
    
    print '对 y 广播 x:' 
    r,c = b.iters 
    print r.next(), c.next() 
    print r.next(), c.next() 
    print '\n'  
    # shape 属性返回广播对象的形状
    
    print '广播对象的形状:' 
    print b.shape 
    print '\n'  
    # 手动使用 broadcast 将 x 与 y 相加
    b = np.broadcast(x,y) 
    c = np.empty(b.shape) 
    
    print '手动使用 broadcast 将 x 与 y 相加:' 
    print c.shape 
    print '\n'  
    c.flat = [u + v for (u,v) in b] 
    
    print '调用 flat 函数:' 
    print c 
    print '\n'  
    # 获得了和 NumPy 内建的广播支持相同的结果
    
    print 'x 与 y 的和:' 
    print x + y
    

    输出如下:

    
    对 y 广播 x:
    1 4
    1 5
    
    广播对象的形状:
    (3, 3)
    
    手动使用 broadcast 将 x 与 y 相加:
    (3, 3)
    
    调用 flat 函数:
    [[ 5. 6. 7.]
     [ 6. 7. 8.]
     [ 7. 8. 9.]]
    
    x 与 y 的和:
    [[5 6 7]
     [6 7 8]
     [7 8 9]]
    

    numpy.broadcast_to

    此函数将数组广播到新形状。 它在原始数组上返回只读视图。 它通常不连续。 如果新形状不符合 NumPy 的广播规则,该函数可能会抛出ValueError

    注意 - 此功能可用于 1.10.0 及以后的版本。

    该函数接受以下参数。

    
    numpy.broadcast_to(array, shape, subok)
    

    例子

    
    import numpy as np 
    a = np.arange(4).reshape(1,4) 
    
    print '原数组:' 
    print a 
    print '\n'  
    
    print '调用 broadcast_to 函数之后:' 
    print np.broadcast_to(a,(4,4))
    

    输出如下:

    [[0  1  2  3] 
     [0  1  2  3] 
     [0  1  2  3] 
     [0  1  2  3]]
    

    numpy.expand_dims

    函数通过在指定位置插入新的轴来扩展数组形状。该函数需要两个参数:

    
    numpy.expand_dims(arr, axis)
    

    其中:

    • arr:输入数组
    • axis:新轴插入的位置

    例子

    
    import numpy as np 
    x = np.array(([1,2],[3,4])) 
    
    print '数组 x:' 
    print x 
    print '\n'  
    y = np.expand_dims(x, axis = 0) 
    
    print '数组 y:' 
    print y 
    print '\n'
    
    print '数组 x 和 y 的形状:' 
    print x.shape, y.shape 
    print '\n'  
    # 在位置 1 插入轴
    y = np.expand_dims(x, axis = 1) 
    
    print '在位置 1 插入轴之后的数组 y:' 
    print y 
    print '\n'  
    
    print 'x.ndim 和 y.ndim:' 
    print x.ndim,y.ndim 
    print '\n'  
    
    print 'x.shape 和 y.shape:' 
    print x.shape, y.shape
    

    输出如下:

    
    数组 x:
    [[1 2]
     [3 4]]
    
    数组 y:
    [[[1 2]
     [3 4]]]
    
    数组 x 和 y 的形状:
    (2, 2) (1, 2, 2)
    
    在位置 1 插入轴之后的数组 y:
    [[[1 2]]
     [[3 4]]]
    
    x.shape 和 y.shape:
    2 3
    
    x.shape and y.shape:
    (2, 2) (2, 1, 2)
    

    numpy.squeeze

    函数从给定数组的形状中删除一维条目。 此函数需要两个参数。

    
    numpy.squeeze(arr, axis)
    

    其中:

    • arr:输入数组
    • axis:整数或整数元组,用于选择形状中单一维度条目的子集

    例子

    
    import numpy as np  
    x = np.arange(9).reshape(1,3,3) 
    
    print '数组 x:' 
    print x 
    print '\n'  
    y = np.squeeze(x) 
    
    print '数组 y:' 
    print y 
    print '\n'  
    
    print '数组 x 和 y 的形状:' 
    print x.shape, y.shape
    

    输出如下:

    
    数组 x:
    [[[0 1 2]
     [3 4 5]
     [6 7 8]]]
    
    数组 y:
    [[0 1 2]
     [3 4 5]
     [6 7 8]]
    
    数组 x 和 y 的形状:
    (1, 3, 3) (3, 3)
    

    数组的连接

    序号 数组及描述
    1. concatenate 沿着现存的轴连接数据序列
    2. stack 沿着新轴连接数组序列
    3. hstack 水平堆叠序列中的数组(列方向)
    4. vstack 竖直堆叠序列中的数组(行方向)

    numpy.concatenate

    数组的连接是指连接。 此函数用于沿指定轴连接相同形状的两个或多个数组。 该函数接受以下参数。

    
    numpy.concatenate((a1, a2, ...), axis)
    

    其中:

    • a1, a2, ...:相同类型的数组序列
    • axis:沿着它连接数组的轴,默认为 0

    例子

    
    import numpy as np 
    a = np.array([[1,2],[3,4]]) 
    
    print '第一个数组:' 
    print a 
    print '\n'  
    b = np.array([[5,6],[7,8]]) 
    
    print '第二个数组:' 
    print b 
    print '\n'  
    # 两个数组的维度相同 
    
    print '沿轴 0 连接两个数组:' 
    print np.concatenate((a,b)) 
    print '\n'  
    
    print '沿轴 1 连接两个数组:' 
    print np.concatenate((a,b),axis = 1)
    

    输出如下:

    
    第一个数组:
    [[1 2]
     [3 4]]
    
    第二个数组:
    [[5 6]
     [7 8]]
    
    沿轴 0 连接两个数组:
    [[1 2]
     [3 4]
     [5 6]
     [7 8]]
    
    沿轴 1 连接两个数组:
    [[1 2 5 6]
     [3 4 7 8]]
    

    numpy.stack

    此函数沿新轴连接数组序列。 此功能添加自 NumPy 版本 1.10.0。 需要提供以下参数。

    
    numpy.stack(arrays, axis)
    

    其中:

    • arrays:相同形状的数组序列
    • axis:返回数组中的轴,输入数组沿着它来堆叠
    
    import numpy as np 
    a = np.array([[1,2],[3,4]]) 
    
    print '第一个数组:' 
    print a 
    print '\n'
    b = np.array([[5,6],[7,8]]) 
    
    print '第二个数组:' 
    print b 
    print '\n'  
    
    print '沿轴 0 堆叠两个数组:' 
    print np.stack((a,b),0) 
    print '\n'  
    
    print '沿轴 1 堆叠两个数组:' 
    print np.stack((a,b),1)
    

    输出如下:

    
    第一个数组:
    [[1 2]
     [3 4]]
    
    第二个数组:
    [[5 6]
     [7 8]]
    
    沿轴 0 堆叠两个数组:
    [[[1 2]
     [3 4]]
     [[5 6]
     [7 8]]]
    
    沿轴 1 堆叠两个数组:
    [[[1 2]
     [5 6]]
     [[3 4]
     [7 8]]]
    

    numpy.hstack

    numpy.stack函数的变体,通过堆叠来生成水平的单个数组。

    例子

    
    import numpy as np 
    a = np.array([[1,2],[3,4]]) 
    
    print '第一个数组:' 
    print a 
    print '\n'  
    b = np.array([[5,6],[7,8]]) 
    
    print '第二个数组:' 
    print b 
    print '\n'  
    
    print '水平堆叠:' 
    c = np.hstack((a,b)) 
    print c 
    print '\n'
    

    输出如下:

    
    第一个数组:
    [[1 2]
     [3 4]]
    
    第二个数组:
    [[5 6]
     [7 8]]
    
    水平堆叠:
    [[1 2 5 6]
     [3 4 7 8]]
    

    numpy.vstack

    numpy.stack函数的变体,通过堆叠来生成竖直的单个数组。

    
    import numpy as np 
    a = np.array([[1,2],[3,4]]) 
    
    print '第一个数组:' 
    print a 
    print '\n'  
    b = np.array([[5,6],[7,8]]) 
    
    print '第二个数组:' 
    print b 
    print '\n'
    
    print '竖直堆叠:' 
    c = np.vstack((a,b)) 
    print c
    

    输出如下:

    
    第一个数组:
    [[1 2]
     [3 4]]
    
    第二个数组:
    [[5 6]
     [7 8]]
    
    竖直堆叠:
    [[1 2]
     [3 4]
     [5 6]
     [7 8]]
    

    数组分割

    序号 数组及操作
    1. split 将一个数组分割为多个子数组
    2. hsplit 将一个数组水平分割为多个子数组(按列)
    3. vsplit 将一个数组竖直分割为多个子数组(按行)

    numpy.split

    该函数沿特定的轴将数组分割为子数组。函数接受三个参数:

    
    numpy.split(ary, indices_or_sections, axis)
    

    其中:

    • ary:被分割的输入数组
    • indices_or_sections:可以是整数,表明要从输入数组创建的,等大小的子数组的数量。 如果此参数是一维数组,则其元素表明要创建新子数组的点。
    • axis:默认为 0

    例子

    
    import numpy as np 
    a = np.arange(9) 
    
    print '第一个数组:' 
    print a 
    print '\n'  
    
    print '将数组分为三个大小相等的子数组:' 
    b = np.split(a,3) 
    print b 
    print '\n'  
    
    print '将数组在一维数组中表明的位置分割:' 
    b = np.split(a,[4,7])
    print b 
    

    输出如下:

    
    第一个数组:
    [0 1 2 3 4 5 6 7 8]
    
    将数组分为三个大小相等的子数组:
    [array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8])]
    
    将数组在一维数组中表明的位置分割:
    [array([0, 1, 2, 3]), array([4, 5, 6]), array([7, 8])]
    

    numpy.hsplit

    numpy.hsplitsplit()函数的特例,其中轴为 1 表示水平分割,无论输入数组的维度是什么。

    
    import numpy as np 
    a = np.arange(16).reshape(4,4) 
    
    print '第一个数组:' 
    print a 
    print '\n'  
    
    print '水平分割:' 
    b = np.hsplit(a,2) 
    print b 
    print '\n'
    

    输出:

    
    第一个数组:
    [[ 0 1 2 3]
     [ 4 5 6 7]
     [ 8 9 10 11]
     [12 13 14 15]]
    
    水平分割:                                                         
    [array([[ 0,  1],                                                             
           [ 4,  5],                                                              
           [ 8,  9],                                                              
           [12, 13]]), array([[ 2,  3],                                           
           [ 6,  7],                                                              
           [10, 11],                                                              
           [14, 15]])] 
    

    numpy.vsplit

    numpy.vsplitsplit()函数的特例,其中轴为 0 表示竖直分割,无论输入数组的维度是什么。下面的例子使之更清楚。

    
    import numpy as np 
    a = np.arange(16).reshape(4,4) 
    
    print '第一个数组:' 
    print a 
    print '\n'
    
    print '竖直分割:' 
    b = np.vsplit(a,2) 
    print b
    

    输出如下:

    
    第一个数组:
    [[ 0 1 2 3]
     [ 4 5 6 7]
     [ 8 9 10 11]
     [12 13 14 15]]
    
    竖直分割:                                                           
    [array([[0, 1, 2, 3],                                                         
           [4, 5, 6, 7]]), array([[ 8,  9, 10, 11],                               
           [12, 13, 14, 15]])] 
    

    添加/删除元素

    序号 元素及描述
    1. resize 返回指定形状的新数组
    2. append 将值添加到数组末尾
    3. insert 沿指定轴将值插入到指定下标之前
    4. delete 返回删掉某个轴的子数组的新数组
    5. unique 寻找数组内的唯一元素

    numpy.resize

    此函数返回指定大小的新数组。 如果新大小大于原始大小,则包含原始数组中的元素的重复副本。 该函数接受以下参数。

    
    numpy.resize(arr, shape)
    

    其中:

    • arr:要修改大小的输入数组
    • shape:返回数组的新形状

    例子

    
    import numpy as np 
    a = np.array([[1,2,3],[4,5,6]]) 
    
    print '第一个数组:' 
    print a 
    print '\n'
    
    print '第一个数组的形状:' 
    print a.shape 
    print '\n'  
    b = np.resize(a, (3,2)) 
    
    print '第二个数组:' 
    print b 
    print '\n'  
    
    print '第二个数组的形状:' 
    print b.shape 
    print '\n'  
    # 要注意 a 的第一行在 b 中重复出现,因为尺寸变大了 
    
    print '修改第二个数组的大小:' 
    b = np.resize(a,(3,3)) 
    print b
    

    输出如下:

    
    第一个数组:
    [[1 2 3]
     [4 5 6]]
    
    第一个数组的形状:
    (2, 3)
    
    第二个数组:
    [[1 2]
     [3 4]
     [5 6]]
    
    第二个数组的形状:
    (3, 2)
    
    修改第二个数组的大小:
    [[1 2 3]
     [4 5 6]
     [1 2 3]]
    

    numpy.append

    此函数在输入数组的末尾添加值。 附加操作不是原地的,而是分配新的数组。 此外,输入数组的维度必须匹配否则将生成ValueError

    函数接受下列函数:

    
    numpy.append(arr, values, axis)
    

    其中:

    • arr:输入数组
    • values:要向arr添加的值,比如和arr形状相同(除了要添加的轴)
    • axis:沿着它完成操作的轴。如果没有提供,两个参数都会被展开。

    例子

    
    import numpy as np 
    a = np.array([[1,2,3],[4,5,6]]) 
    
    print '第一个数组:' 
    print a 
    print '\n'  
    
    print '向数组添加元素:' 
    print np.append(a, [7,8,9]) 
    print '\n'  
    
    print '沿轴 0 添加元素:' 
    print np.append(a, [[7,8,9]],axis = 0) 
    print '\n'  
    
    print '沿轴 1 添加元素:' 
    print np.append(a, [[5,5,5],[7,8,9]],axis = 1)
    

    输出如下:

    
    第一个数组:
    [[1 2 3]
     [4 5 6]]
    
    向数组添加元素:
    [1 2 3 4 5 6 7 8 9]
    
    沿轴 0 添加元素:
    [[1 2 3]
     [4 5 6]
     [7 8 9]]
    
    沿轴 1 添加元素:
    [[1 2 3 5 5 5]
     [4 5 6 7 8 9]]
    

    numpy.insert

    此函数在给定索引之前,沿给定轴在输入数组中插入值。 如果值的类型转换为要插入,则它与输入数组不同。 插入没有原地的,函数会返回一个新数组。 此外,如果未提供轴,则输入数组会被展开。

    insert()函数接受以下参数:

    
    numpy.insert(arr, obj, values, axis)
    

    其中:

    • arr:输入数组
    • obj:在其之前插入值的索引
    • values:要插入的值
    • axis:沿着它插入的轴,如果未提供,则输入数组会被展开

    例子

    
    import numpy as np 
    a = np.array([[1,2],[3,4],[5,6]]) 
    
    print '第一个数组:' 
    print a 
    print '\n'  
    
    print '未传递 Axis 参数。 在插入之前输入数组会被展开。' 
    print np.insert(a,3,[11,12]) 
    print '\n'  
    print '传递了 Axis 参数。 会广播值数组来配输入数组。' 
    
    print '沿轴 0 广播:' 
    print np.insert(a,1,[11],axis = 0) 
    print '\n'  
    
    print '沿轴 1 广播:' 
    print np.insert(a,1,11,axis = 1)
    

    numpy.delete

    此函数返回从输入数组中删除指定子数组的新数组。 与insert()函数的情况一样,如果未提供轴参数,则输入数组将展开。 该函数接受以下参数:

    
    Numpy.delete(arr, obj, axis)
    

    其中:

    • arr:输入数组
    • obj:可以被切片,整数或者整数数组,表明要从输入数组删除的子数组
    • axis:沿着它删除给定子数组的轴,如果未提供,则输入数组会被展开

    例子

    
    import numpy as np 
    a = np.arange(12).reshape(3,4) 
    
    print '第一个数组:' 
    print a 
    print '\n'  
    
    print '未传递 Axis 参数。 在插入之前输入数组会被展开。' 
    print np.delete(a,5) 
    print '\n'  
    
    print '删除第二列:'  
    print np.delete(a,1,axis = 1) 
    print '\n'  
    
    print '包含从数组中删除的替代值的切片:' 
    a = np.array([1,2,3,4,5,6,7,8,9,10]) 
    print np.delete(a, np.s_[::2])
    

    输出如下:

    
    第一个数组:
    [[ 0 1 2 3]
     [ 4 5 6 7]
     [ 8 9 10 11]]
    
    未传递 Axis 参数。 在插入之前输入数组会被展开。
    [ 0 1 2 3 4 6 7 8 9 10 11]
    
    删除第二列:
    [[ 0 2 3]
     [ 4 6 7]
     [ 8 10 11]]
    
    包含从数组中删除的替代值的切片:
    [ 2 4 6 8 10]
    

    numpy.unique

    此函数返回输入数组中的去重元素数组。 该函数能够返回一个元组,包含去重数组和相关索引的数组。 索引的性质取决于函数调用中返回参数的类型。

    
    numpy.unique(arr, return_index, return_inverse, return_counts)
    

    其中:

    • arr:输入数组,如果不是一维数组则会展开
    • return_index:如果为true,返回输入数组中的元素下标
    • return_inverse:如果为true,返回去重数组的下标,它可以用于重构输入数组
    • return_counts:如果为true,返回去重数组中的元素在原数组中的出现次数

    例子

    
    import numpy as np 
    a = np.array([5,2,6,2,7,5,6,8,2,9]) 
    
    print '第一个数组:' 
    print a 
    print '\n'  
    
    print '第一个数组的去重值:' 
    u = np.unique(a) 
    print u 
    print '\n'  
    
    print '去重数组的索引数组:' 
    u,indices = np.unique(a, return_index = True) 
    print indices 
    print '\n'  
    
    print '我们可以看到每个和原数组下标对应的数值:' 
    print a 
    print '\n'  
    
    print '去重数组的下标:' 
    u,indices = np.unique(a,return_inverse = True) 
    print u 
    print '\n' 
    
    print '下标为:' 
    print indices 
    print '\n'  
    
    print '使用下标重构原数组:' 
    print u[indices] 
    print '\n'  
    
    print '返回去重元素的重复数量:' 
    u,indices = np.unique(a,return_counts = True) 
    print u 
    print indices
    

    输出如下:

    
    第一个数组:
    [5 2 6 2 7 5 6 8 2 9]
    
    第一个数组的去重值:
    [2 5 6 7 8 9]
    
    去重数组的索引数组:
    [1 0 2 4 7 9]
    
    我们可以看到每个和原数组下标对应的数值:
    [5 2 6 2 7 5 6 8 2 9]
    
    去重数组的下标:
    [2 5 6 7 8 9]
    
    下标为:
    [1 0 2 0 3 1 2 4 0 5]
    
    使用下标重构原数组:
    [5 2 6 2 7 5 6 8 2 9]
    
    返回唯一元素的重复数量:
    [2 5 6 7 8 9]
     [3 2 2 1 1 1]
    

    NumPy - 位操作

    下面是 NumPy 包中可用的位操作函数。

    序号 操作及描述
    1. bitwise_and 对数组元素执行位与操作
    2. bitwise_or 对数组元素执行位或操作
    3. invert 计算位非
    4. left_shift 向左移动二进制表示的位
    5. right_shift 向右移动二进制表示的位

    bitwise_and

    通过np.bitwise_and()函数对输入数组中的整数的二进制表示的相应位执行位与运算。

    例子

    
    import numpy as np 
    print '13 和 17 的二进制形式:' 
    a,b = 13,17 
    print bin(a), bin(b) 
    print '\n'  
    
    print '13 和 17 的位与:' 
    print np.bitwise_and(13, 17)
    

    输出如下:

    13 和 17 的二进制形式:
    0b1101 0b10001
    
    13 和 17 的位与:
    1
    

    你可以使用下表验证此输出。 考虑下面的位与真值表。

    A B AND
    1 1 1
    1 0 0
    0 1 0
    0 0 0

    | | | 1 | 1 | 0 | 1 |
    | --- | --- |
    | AND |
    | | 1 | 0 | 0 | 0 | 1 |
    | result | 0 | 0 | 0 | 0 | 1 |

    bitwise_or

    通过np.bitwise_or()函数对输入数组中的整数的二进制表示的相应位执行位或运算。

    例子

    
    import numpy as np 
    a,b = 13,17 
    print '13 和 17 的二进制形式:' 
    print bin(a), bin(b)  
    
    print '13 和 17 的位或:' 
    print np.bitwise_or(13, 17)
    

    输出如下:

    13 和 17 的二进制形式:
    0b1101 0b10001
    
    13 和 17 的位或:
    29
    

    你可以使用下表验证此输出。 考虑下面的位或真值表。

    A B OR
    1 1 1
    1 0 1
    0 1 1
    0 0 0

    | | | 1 | 1 | 0 | 1 |
    | --- | --- |
    | OR |
    | | 1 | 0 | 0 | 0 | 1 |
    | result | 1 | 1 | 1 | 0 | 1 |

    invert

    此函数计算输入数组中整数的位非结果。 对于有符号整数,返回补码。

    例子

    
    import numpy as np 
    
    print '13 的位反转,其中 ndarray 的 dtype 是 uint8:' 
    print np.invert(np.array([13], dtype = np.uint8)) 
    print '\n'  
    # 比较 13 和 242 的二进制表示,我们发现了位的反转
    
    print '13 的二进制表示:' 
    print np.binary_repr(13, width = 8) 
    print '\n'  
    
    print '242 的二进制表示:' 
    print np.binary_repr(242, width = 8)
    

    输出如下:

    
    13 的位反转,其中 ndarray 的 dtype 是 uint8:
    [242]
    
    13 的二进制表示:
    00001101
    
    242 的二进制表示:
    11110010
    

    请注意,np.binary_repr()函数返回给定宽度中十进制数的二进制表示。

    left_shift

    numpy.left shift()函数将数组元素的二进制表示中的位向左移动到指定位置,右侧附加相等数量的 0。

    例如,

    
    import numpy as np 
    
    print '将 10 左移两位:' 
    print np.left_shift(10,2) 
    print '\n'  
    
    print '10 的二进制表示:' 
    print np.binary_repr(10, width = 8) 
    print '\n'  
    
    print '40 的二进制表示:' 
    print np.binary_repr(40, width = 8)  
    #  '00001010' 中的两位移动到了左边,并在右边添加了两个 0。
    

    输出如下:

    将 10 左移两位:
    40
    
    10 的二进制表示:
    00001010
    
    40 的二进制表示:
    00101000
    

    right_shift

    numpy.right_shift()函数将数组元素的二进制表示中的位向右移动到指定位置,左侧附加相等数量的 0。

    
    import numpy as np 
    
    print '将 40 右移两位:' 
    print np.right_shift(40,2) 
    print '\n'  
    
    print '40 的二进制表示:' 
    print np.binary_repr(40, width = 8) 
    print '\n'  
    
    print '10 的二进制表示:' 
    print np.binary_repr(10, width = 8)  
    #  '00001010' 中的两位移动到了右边,并在左边添加了两个 0。
    

    输出如下:

    将 40 右移两位:
    10
    
    40 的二进制表示:
    00101000
    
    10 的二进制表示:
    00001010
    

    NumPy - 字符串函数

    以下函数用于对dtypenumpy.string_numpy.unicode_的数组执行向量化字符串操作。 它们基于 Python 内置库中的标准字符串函数。

    序号 函数及描述
    1. add() 返回两个strUnicode数组的逐个字符串连接
    2. multiply() 返回按元素多重连接后的字符串
    3. center() 返回给定字符串的副本,其中元素位于特定字符串的中央
    4. capitalize() 返回给定字符串的副本,其中只有第一个字符串大写
    5. title() 返回字符串或 Unicode 的按元素标题转换版本
    6. lower() 返回一个数组,其元素转换为小写
    7. upper() 返回一个数组,其元素转换为大写
    8. split() 返回字符串中的单词列表,并使用分隔符来分割
    9. splitlines() 返回元素中的行列表,以换行符分割
    10. strip() 返回数组副本,其中元素移除了开头或者结尾处的特定字符
    11. join() 返回一个字符串,它是序列中字符串的连接
    12. replace() 返回字符串的副本,其中所有子字符串的出现位置都被新字符串取代
    13. decode() 按元素调用str.decode
    14. encode() 按元素调用str.encode

    这些函数在字符数组类(numpy.char)中定义。 较旧的 Numarray 包包含chararray类。 numpy.char类中的上述函数在执行向量化字符串操作时非常有用。

    numpy.char.add()

    函数执行按元素的字符串连接。

    
    import numpy as np 
    print '连接两个字符串:' 
    print np.char.add(['hello'],[' xyz']) 
    print '\n'
    
    print '连接示例:' 
    print np.char.add(['hello', 'hi'],[' abc', ' xyz'])
    

    输出如下:

    连接两个字符串:
    ['hello xyz']
    
    连接示例:
    ['hello abc' 'hi xyz']
    

    numpy.char.multiply()

    这个函数执行多重连接。

    
    import numpy as np 
    print np.char.multiply('Hello ',3)
    

    输出如下:

    Hello Hello Hello 
    

    numpy.char.center()

    此函数返回所需宽度的数组,以便输入字符串位于中心,并使用fillchar在左侧和右侧进行填充。

    
    import numpy as np 
    # np.char.center(arr, width,fillchar) 
    print np.char.center('hello', 20,fillchar = '*')
    

    输出如下:

    *******hello********
    

    numpy.char.capitalize()

    函数返回字符串的副本,其中第一个字母大写

    
    import numpy as np 
    print np.char.capitalize('hello world')
    

    输出如下:

    Hello world 
    

    numpy.char.title()

    返回输入字符串的按元素标题转换版本,其中每个单词的首字母都大写。

    
    import numpy as np 
    print np.char.title('hello how are you?')
    

    输出如下:

    Hello How Are You?
    

    numpy.char.lower()

    函数返回一个数组,其元素转换为小写。它对每个元素调用str.lower

    
    import numpy as np 
    print np.char.lower(['HELLO','WORLD']) 
    print np.char.lower('HELLO')
    

    输出如下:

    ['hello' 'world']
    hello
    

    numpy.char.upper()

    函数返回一个数组,其元素转换为大写。它对每个元素调用str.upper

    
    import numpy as np 
    print np.char.upper('hello') 
    print np.char.upper(['hello','world'])
    

    输出如下:

    HELLO
    ['HELLO' 'WORLD']
    

    numpy.char.split()

    此函数返回输入字符串中的单词列表。 默认情况下,空格用作分隔符。 否则,指定的分隔符字符用于分割字符串。

    
    import numpy as np 
    print np.char.split ('hello how are you?') 
    print np.char.split ('TutorialsPoint,Hyderabad,Telangana', sep = ',')
    

    输出如下:

    ['hello', 'how', 'are', 'you?']
    ['TutorialsPoint', 'Hyderabad', 'Telangana']
    

    numpy.char.splitlines()

    函数返回数组中元素的单词列表,以换行符分割。

    
    import numpy as np 
    print np.char.splitlines('hello\nhow are you?') 
    print np.char.splitlines('hello\rhow are you?')
    

    输出如下:

    ['hello', 'how are you?']
    ['hello', 'how are you?']
    

    '\n''\r''\r\n'都会用作换行符。

    numpy.char.strip()

    函数返回数组的副本,其中元素移除了开头或结尾处的特定字符。

    
    import numpy as np 
    print np.char.strip('ashok arora','a') 
    print np.char.strip(['arora','admin','java'],'a')
    

    输出如下:

    shok aror
    ['ror' 'dmin' 'jav']
    

    numpy.char.join()

    这个函数返回一个字符串,其中单个字符由特定的分隔符连接。

    
    import numpy as np 
    print np.char.join(':','dmy') 
    print np.char.join([':','-'],['dmy','ymd'])
    

    输出如下:

    
    d:m:y
    ['d:m:y' 'y-m-d']
    

    numpy.char.replace()

    这个函数返回字符串副本,其中所有字符序列的出现位置都被另一个给定的字符序列取代。

    
    import numpy as np 
    print np.char.replace ('He is a good boy', 'is', 'was')
    

    输出如下:

    He was a good boy
    

    numpy.char.decode()

    这个函数在给定的字符串中使用特定编码调用str.decode()

    
    import numpy as np 
    
    a = np.char.encode('hello', 'cp500') 
    print a 
    print np.char.decode(a,'cp500')
    

    输出如下:

    \x88\x85\x93\x93\x96
    hello
    

    numpy.char.encode()

    此函数对数组中的每个元素调用str.encode函数。 默认编码是utf_8,可以使用标准 Python 库中的编解码器。

    
    import numpy as np 
    a = np.char.encode('hello', 'cp500') 
    print a
    

    输出如下:

    \x88\x85\x93\x93\x96
    

    NumPy - 算数函数

    很容易理解的是,NumPy 包含大量的各种数学运算功能。 NumPy 提供标准的三角函数,算术运算的函数,复数处理函数等。

    三角函数

    NumPy 拥有标准的三角函数,它为弧度制单位的给定角度返回三角函数比值。

    示例

    
    import numpy as np
    a = np.array([0,30,45,60,90])  
    print  '不同角度的正弦值:'  
    # 通过乘 pi/180 转化为弧度  
    print np.sin(a*np.pi/180)  
    print  '\n'  
    print  '数组中角度的余弦值:'  
    print np.cos(a*np.pi/180)  
    print  '\n'  
    print  '数组中角度的正切值:'  
    print np.tan(a*np.pi/180)  
    

    输出如下:

    不同角度的正弦值:                                                   
    [ 0.          0.5         0.70710678  0.8660254   1.        ]                 
    
    数组中角度的余弦值:                                         
    [  1.00000000e+00   8.66025404e-01   7.07106781e-01   5.00000000e-01          
       6.12323400e-17]                                                            
    
    数组中角度的正切值:                                            
    [  0.00000000e+00   5.77350269e-01   1.00000000e+00   1.73205081e+00          
       1.63312394e+16]
    
    

    arcsinarccos,和arctan函数返回给定角度的sincostan的反三角函数。 这些函数的结果可以通过numpy.degrees()函数通过将弧度制转换为角度制来验证。

    示例

    
    import numpy as np
    a = np.array([0,30,45,60,90])  
    print  '含有正弦值的数组:'
    sin = np.sin(a*np.pi/180)  
    print sin
    print  '\n'  
    print  '计算角度的反正弦,返回值以弧度为单位:'
    inv = np.arcsin(sin)  
    print inv
    print  '\n'  
    print  '通过转化为角度制来检查结果:'  
    print np.degrees(inv)  
    print  '\n'  
    print  'arccos 和 arctan 函数行为类似:'
    cos = np.cos(a*np.pi/180)  
    print cos
    print  '\n'  
    print  '反余弦:'
    inv = np.arccos(cos)  
    print inv
    print  '\n'  
    print  '角度制单位:'  
    print np.degrees(inv)  
    print  '\n'  
    print  'tan 函数:'
    tan = np.tan(a*np.pi/180)  
    print tan
    print  '\n'  
    print  '反正切:'
    inv = np.arctan(tan)  
    print inv
    print  '\n'  
    print  '角度制单位:'  
    print np.degrees(inv)  
    

    输出如下:

    
    含有正弦值的数组:
    [ 0.          0.5         0.70710678  0.8660254   1.        ]
    
    计算角度的反正弦,返回值以弧度制为单位:
    [ 0.          0.52359878  0.78539816  1.04719755  1.57079633]
    
    通过转化为角度制来检查结果:
    [  0.  30.  45.  60.  90.]
    
    arccos 和 arctan 函数行为类似:
    [  1.00000000e+00   8.66025404e-01   7.07106781e-01   5.00000000e-01          
       6.12323400e-17]
    
    反余弦:
    [ 0.          0.52359878  0.78539816  1.04719755  1.57079633]
    
    角度制单位:
    [  0.  30.  45.  60.  90.]
    
    tan 函数:
    [  0.00000000e+00   5.77350269e-01   1.00000000e+00   1.73205081e+00          
       1.63312394e+16]
    
    反正切:
    [ 0.          0.52359878  0.78539816  1.04719755  1.57079633]
    
    角度制单位:
    [  0.  30.  45.  60.  90.]
    
    

    舍入函数

    numpy.around()

    这个函数返回四舍五入到所需精度的值。 该函数接受以下参数。

    
    numpy.around(a,decimals)
    
    

    其中:

    序号 参数及描述
    1. a 输入数组
    2. decimals 要舍入的小数位数。 默认值为0。 如果为负,整数将四舍五入到小数点左侧的位置

    示例

    
    import numpy as np
    a = np.array([1.0,5.55,  123,  0.567,  25.532])  
    print  '原数组:'  
    print a
    print  '\n'  
    print  '舍入后:'  
    print np.around(a)  
    print np.around(a, decimals =  1)  
    print np.around(a, decimals =  -1)
    

    输出如下:

    
    原数组:                                                          
    [   1.       5.55   123.       0.567   25.532]
    
    舍入后:                                                         
    [   1.    6.   123.    1.   26. ]                                               
    [   1.    5.6  123.    0.6  25.5]                                          
    [   0.    10.  120.    0.   30. ]
    
    

    numpy.floor()

    此函数返回不大于输入参数的最大整数。 即标量x 的下限是最大的整数i ,使得i <= x。 注意在Python中,向下取整总是从 0 舍入。

    示例

    
    import numpy as np
    a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])  
    print  '提供的数组:'  
    print a
    print  '\n'  
    print  '修改后的数组:'  
    print np.floor(a)
    

    输出如下:

    
    提供的数组:                                                            
    [ -1.7   1.5  -0.2   0.6  10. ]
    
    修改后的数组:                                                         
    [ -2.   1.  -1.   0.  10.]
    
    

    numpy.ceil()

    ceil()函数返回输入值的上限,即,标量x的上限是最小的整数i ,使得i> = x

    示例

    
    import numpy as np
    a = np.array([-1.7,  1.5,  -0.2,  0.6,  10])  
    print  '提供的数组:'  
    print a
    print  '\n'  
    print  '修改后的数组:'  
    print np.ceil(a)
    

    输出如下:

    
    提供的数组:
    [ -1.7   1.5  -0.2   0.6  10. ]
    
    修改后的数组:
    [ -1.   2.  -0.   1.  10.]
    
    

    NumPy - 算数运算

    用于执行算术运算(如add()subtract()multiply()divide())的输入数组必须具有相同的形状或符合数组广播规则。

    示例

    
    import numpy as np 
    a = np.arange(9, dtype = np.float_).reshape(3,3)  
    print  '第一个数组:'  
    print a 
    print  '\n'  
    print  '第二个数组:' 
    b = np.array([10,10,10])  
    print b 
    print  '\n'  
    print  '两个数组相加:'  
    print np.add(a,b)  
    print  '\n'  
    print  '两个数组相减:'  
    print np.subtract(a,b)  
    print  '\n'  
    print  '两个数组相乘:'  
    print np.multiply(a,b)  
    print  '\n'  
    print  '两个数组相除:'  
    print np.divide(a,b)
    

    输出如下:

    
    第一个数组:
    [[ 0. 1. 2.]
     [ 3. 4. 5.]
     [ 6. 7. 8.]]
    
    第二个数组:
    [10 10 10]
    
    两个数组相加:
    [[ 10. 11. 12.]
     [ 13. 14. 15.]
     [ 16. 17. 18.]]
    
    两个数组相减:
    [[-10. -9. -8.]
     [ -7. -6. -5.]
     [ -4. -3. -2.]]
    
    两个数组相乘:
    [[ 0. 10. 20.]
     [ 30. 40. 50.]
     [ 60. 70. 80.]]
    
    两个数组相除:
    [[ 0. 0.1 0.2]
     [ 0.3 0.4 0.5]
     [ 0.6 0.7 0.8]]
    
    

    让我们现在来讨论 NumPy 中提供的一些其他重要的算术函数。

    numpy.reciprocal()

    此函数返回参数逐元素的倒数,。 由于 Python 处理整数除法的方式,对于绝对值大于 1 的整数元素,结果始终为 0, 对于整数 0,则发出溢出警告。

    示例

    
    import numpy as np 
    a = np.array([0.25,  1.33,  1,  0,  100])  
    print  '我们的数组是:'  
    print a 
    print  '\n'  
    print  '调用 reciprocal 函数:'  
    print np.reciprocal(a)  
    print  '\n' 
    b = np.array([100], dtype =  int)  
    print  '第二个数组:'  
    print b 
    print  '\n'  
    print  '调用 reciprocal 函数:'  
    print np.reciprocal(b)  
    

    输出如下:

    
    我们的数组是:                                                               
    [   0.25    1.33    1.      0.    100.  ]                                     
    
    调用 reciprocal 函数:                                         
    main.py:9: RuntimeWarning: divide by zero encountered in reciprocal           
      print np.reciprocal(a)                                                      
    [ 4.         0.7518797  1.               inf  0.01     ]                      
    
    第二个数组:                                                      
    [100]                                                                         
    
    调用 reciprocal 函数:                                        
    [0]                         
    
    

    numpy.power()

    此函数将第一个输入数组中的元素作为底数,计算它与第二个输入数组中相应元素的幂。

    
    import numpy as np 
    a = np.array([10,100,1000])  
    print  '我们的数组是;'  
    print a 
    print  '\n'  
    print  '调用 power 函数:'  
    print np.power(a,2)  
    print  '\n'  
    print  '第二个数组:' 
    b = np.array([1,2,3])  
    print b 
    print  '\n'  
    print  '再次调用 power 函数:'  
    print np.power(a,b)
    

    输出如下:

    
    我们的数组是;                                                              
    [  10  100 1000]                                                              
    
    调用 power 函数:                                                    
    [    100   10000 1000000]                                                     
    
    第二个数组:                                                              
    [1 2 3]                                                                       
    
    再次调用 power 函数:                                              
    [        10      10000 1000000000] 
    
    

    numpy.mod()

    此函数返回输入数组中相应元素的除法余数。 函数numpy.remainder()也产生相同的结果。

    
    import numpy as np 
    a = np.array([10,20,30]) 
    b = np.array([3,5,7])  
    print  '第一个数组:'  
    print a 
    print  '\n'  
    print  '第二个数组:'  
    print b 
    print  '\n' 
    print  '调用 mod() 函数:'  
    print np.mod(a,b)  
    print  '\n'  
    print  '调用 remainder() 函数:'  
    print np.remainder(a,b)  
    

    输出如下:

    
    第一个数组:
    [10 20 30]
    
    第二个数组:
    [3 5 7]
    
    调用 mod() 函数:                                                     
    [1 0 2]
    
    调用 remainder() 函数:                                              
    [1 0 2]
    
    

    以下函数用于对含有复数的数组执行操作。

    • numpy.real() 返回复数类型参数的实部。

    • numpy.imag() 返回复数类型参数的虚部。

    • numpy.conj() 返回通过改变虚部的符号而获得的共轭复数。

    • numpy.angle() 返回复数参数的角度。 函数的参数是degree。 如果为true,返回的角度以角度制来表示,否则为以弧度制来表示。

    
    import numpy as np 
    a = np.array([-5.6j,  0.2j,  11.  ,  1+1j])  
    print  '我们的数组是:'  
    print a 
    print  '\n'  
    print  '调用 real() 函数:'  
    print np.real(a)  
    print  '\n'  
    print  '调用 imag() 函数:'  
    print np.imag(a)  
    print  '\n'  
    print  '调用 conj() 函数:'  
    print np.conj(a)  
    print  '\n'  
    print  '调用 angle() 函数:'  
    print np.angle(a)  
    print  '\n'  
    print  '再次调用 angle() 函数(以角度制返回):'  
    print np.angle(a, deg =  True)
    

    输出如下:

    
    我们的数组是:
    [ 0.-5.6j 0.+0.2j 11.+0.j 1.+1.j ]
    
    调用 real() 函数:
    [ 0. 0. 11. 1.]
    
    调用 imag() 函数:
    [-5.6 0.2 0. 1. ]
    
    调用 conj() 函数:
    [ 0.+5.6j 0.-0.2j 11.-0.j 1.-1.j ]
    
    调用 angle() 函数:
    [-1.57079633 1.57079633 0. 0.78539816]
    
    再次调用 angle() 函数(以角度制返回):
    [-90. 90. 0. 45.]
    
    

    NumPy - 统计函数

    NumPy 有很多有用的统计函数,用于从数组中给定的元素中查找最小,最大,百分标准差和方差等。 函数说明如下:

    numpy.amin()numpy.amax()

    这些函数从给定数组中的元素沿指定轴返回最小值和最大值。

    示例

    
    import numpy as np 
    a = np.array([[3,7,5],[8,4,3],[2,4,9]])  
    print  '我们的数组是:'  
    print a 
    print  '\n'  
    print  '调用 amin() 函数:'  
    print np.amin(a,1)  
    print  '\n'  
    print  '再次调用 amin() 函数:'  
    print np.amin(a,0)  
    print  '\n'  
    print  '调用 amax() 函数:'  
    print np.amax(a)  
    print  '\n'  
    print  '再次调用 amax() 函数:'  
    print np.amax(a, axis =  0)
    

    输出如下:

    
    我们的数组是:
    [[3 7 5]
    [8 4 3]
    [2 4 9]]
    
    调用 amin() 函数:
    [3 3 2]
    
    再次调用 amin() 函数:
    [2 4 3]
    
    调用 amax() 函数:
    9
    
    再次调用 amax() 函数:
    [8 7 9]
    
    

    numpy.ptp()

    numpy.ptp()函数返回沿轴的值的范围(最大值 - 最小值)。

    
    import numpy as np 
    a = np.array([[3,7,5],[8,4,3],[2,4,9]])  
    print  '我们的数组是:'  
    print a 
    print  '\n'  
    print  '调用 ptp() 函数:'  
    print np.ptp(a)  
    print  '\n'  
    print  '沿轴 1 调用 ptp() 函数:'  
    print np.ptp(a, axis =  1)  
    print  '\n'  
    print  '沿轴 0 调用 ptp() 函数:'  
    print np.ptp(a, axis =  0)  
    

    输出如下:

    
    我们的数组是:
    [[3 7 5]
    [8 4 3]
    [2 4 9]]
    
    调用 ptp() 函数:
    7
    
    沿轴 1 调用 ptp() 函数:
    [4 5 7]
    
    沿轴 0 调用 ptp() 函数:
    [6 3 6]
    
    

    numpy.percentile()

    百分位数是统计中使用的度量,表示小于这个值得观察值占某个百分比。 函数numpy.percentile()接受以下参数。

    
    numpy.percentile(a, q, axis)
    
    

    其中:

    序号 参数及描述
    1. a 输入数组
    2. q 要计算的百分位数,在 0 ~ 100 之间
    3. axis 沿着它计算百分位数的轴

    示例

    
    import numpy as np 
    a = np.array([[30,40,70],[80,20,10],[50,90,60]])  
    print  '我们的数组是:'  
    print a 
    print  '\n'  
    print  '调用 percentile() 函数:'  
    print np.percentile(a,50)  
    print  '\n'  
    print  '沿轴 1 调用 percentile() 函数:'  
    print np.percentile(a,50, axis =  1)  
    print  '\n'  
    print  '沿轴 0 调用 percentile() 函数:'  
    print np.percentile(a,50, axis =  0)
    

    输出如下:

    
    我们的数组是:
    [[30 40 70]
     [80 20 10]
     [50 90 60]]
    
    调用 percentile() 函数:
    50.0
    
    沿轴 1 调用 percentile() 函数:
    [ 40. 20. 60.]
    
    沿轴 0 调用 percentile() 函数:
    [ 50. 40. 60.]
    
    

    numpy.median()

    中值定义为将数据样本的上半部分与下半部分分开的值。 numpy.median()函数的用法如下面的程序所示。

    示例

    
    import numpy as np 
    a = np.array([[30,65,70],[80,95,10],[50,90,60]])  
    print  '我们的数组是:'  
    print a 
    print  '\n'  
    print  '调用 median() 函数:'  
    print np.median(a)  
    print  '\n'  
    print  '沿轴 0 调用 median() 函数:'  
    print np.median(a, axis =  0)  
    print  '\n'  
    print  '沿轴 1 调用 median() 函数:'  
    print np.median(a, axis =  1)
    

    输出如下:

    
    我们的数组是:
    [[30 65 70]
     [80 95 10]
     [50 90 60]]
    
    调用 median() 函数:
    65.0
    
    沿轴 0 调用 median() 函数:
    [ 50. 90. 60.]
    
    沿轴 1 调用 median() 函数:
    [ 65. 80. 60.]
    
    

    numpy.mean()

    算术平均值是沿轴的元素的总和除以元素的数量。 numpy.mean()函数返回数组中元素的算术平均值。 如果提供了轴,则沿其计算。

    示例

    
    import numpy as np 
    a = np.array([[1,2,3],[3,4,5],[4,5,6]])  
    print  '我们的数组是:'  
    print a 
    print  '\n'  
    print  '调用 mean() 函数:'  
    print np.mean(a)  
    print  '\n'  
    print  '沿轴 0 调用 mean() 函数:'  
    print np.mean(a, axis =  0)  
    print  '\n'  
    print  '沿轴 1 调用 mean() 函数:'  
    print np.mean(a, axis =  1)
    

    输出如下:

    
    我们的数组是:
    [[1 2 3]
     [3 4 5]
     [4 5 6]]
    
    调用 mean() 函数:
    3.66666666667
    
    沿轴 0 调用 mean() 函数:
    [ 2.66666667 3.66666667 4.66666667]
    
    沿轴 1 调用 mean() 函数:
    [ 2. 4. 5.]
    
    

    numpy.average()

    加权平均值是由每个分量乘以反映其重要性的因子得到的平均值。 numpy.average()函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。 该函数可以接受一个轴参数。 如果没有指定轴,则数组会被展开。

    考虑数组[1,2,3,4]和相应的权重[4,3,2,1],通过将相应元素的乘积相加,并将和除以权重的和,来计算加权平均值。

    加权平均值 = (1*4+2*3+3*2+4*1)/(4+3+2+1)
    

    示例

    
    import numpy as np 
    a = np.array([1,2,3,4])  
    print  '我们的数组是:'  
    print a 
    print  '\n'  
    print  '调用 average() 函数:'  
    print np.average(a)  
    print  '\n'  
    # 不指定权重时相当于 mean 函数
    wts = np.array([4,3,2,1])  
    print  '再次调用 average() 函数:'  
    print np.average(a,weights = wts)  
    print  '\n'  
    # 如果 returned 参数设为 true,则返回权重的和  
    print  '权重的和:'  
    print np.average([1,2,3,  4],weights =  [4,3,2,1], returned =  True)
    

    输出如下:

    
    我们的数组是:
    [1 2 3 4]
    
    调用 average() 函数:
    2.5
    
    再次调用 average() 函数:
    2.0
    
    权重的和:
    (2.0, 10.0)
    
    

    在多维数组中,可以指定用于计算的轴。

    示例

    
    import numpy as np 
    a = np.arange(6).reshape(3,2)  
    print  '我们的数组是:'  
    print a 
    print  '\n'  
    print  '修改后的数组:' 
    wt = np.array([3,5])  
    print np.average(a, axis =  1, weights = wt)  
    print  '\n'  
    print  '修改后的数组:'  
    print np.average(a, axis =  1, weights = wt, returned =  True)
    

    输出如下:

    
    我们的数组是:
    [[0 1]
     [2 3]
     [4 5]]
    
    修改后的数组:
    [ 0.625 2.625 4.625]
    
    修改后的数组:
    (array([ 0.625, 2.625, 4.625]), array([ 8., 8., 8.]))
    
    

    标准差

    标准差是与均值的偏差的平方的平均值的平方根。 标准差公式如下:

    
    std = sqrt(mean((x - x.mean())**2))
    
    

    如果数组是[1,2,3,4],则其平均值为2.5。 因此,差的平方是[2.25,0.25,0.25,2.25],并且其平均值的平方根除以4,即sqrt(5/4)1.1180339887498949

    示例

    
    import numpy as np 
    print np.std([1,2,3,4])
    

    输出如下:

    
    1.1180339887498949 
    
    

    方差

    方差是偏差的平方的平均值,即mean((x - x.mean())** 2)。 换句话说,标准差是方差的平方根。

    示例

    
    import numpy as np 
    print np.var([1,2,3,4])
    

    输出如下:

    
    1.25
    
    

    NumPy - 排序、搜索和计数函数

    NumPy中提供了各种排序相关功能。 这些排序函数实现不同的排序算法,每个排序算法的特征在于执行速度,最坏情况性能,所需的工作空间和算法的稳定性。 下表显示了三种排序算法的比较。

    种类 速度 最坏情况 工作空间 稳定性
    'quicksort'(快速排序) 1 O(n^2) 0
    'mergesort'(归并排序) 2 O(n*log(n)) ~n/2
    'heapsort'(堆排序) 3 O(n*log(n)) 0

    numpy.sort()

    sort()函数返回输入数组的排序副本。 它有以下参数:

    
    numpy.sort(a, axis, kind, order)
    
    

    其中:

    序号 参数及描述
    1. a 要排序的数组
    2. axis 沿着它排序数组的轴,如果没有数组会被展开,沿着最后的轴排序
    3. kind 默认为'quicksort'(快速排序)
    4. order 如果数组包含字段,则是要排序的字段

    示例

    
    import numpy as np  
    a = np.array([[3,7],[9,1]])  
    print  '我们的数组是:'  
    print a 
    print  '\n'  
    print  '调用 sort() 函数:'  
    print np.sort(a)  
    print  '\n'  
    print  '沿轴 0 排序:'  
    print np.sort(a, axis =  0)  
    print  '\n'  
    # 在 sort 函数中排序字段 
    dt = np.dtype([('name',  'S10'),('age',  int)]) 
    a = np.array([("raju",21),("anil",25),("ravi",  17),  ("amar",27)], dtype = dt)  
    print  '我们的数组是:'  
    print a 
    print  '\n'  
    print  '按 name 排序:'  
    print np.sort(a, order =  'name')
    

    输出如下:

    我们的数组是:
    [[3 7]
     [9 1]]
    
    调用 sort() 函数:
    [[3 7]
     [1 9]]
    
    沿轴 0 排序:
    [[3 1]
     [9 7]]
    
    我们的数组是:
    [('raju', 21) ('anil', 25) ('ravi', 17) ('amar', 27)]
    
    按 name 排序:
    [('amar', 27) ('anil', 25) ('raju', 21) ('ravi', 17)]
    
    

    numpy.argsort()

    numpy.argsort()函数对输入数组沿给定轴执行间接排序,并使用指定排序类型返回数据的索引数组。 这个索引数组用于构造排序后的数组。

    示例

    
    import numpy as np 
    x = np.array([3,  1,  2])  
    print  '我们的数组是:'  
    print x 
    print  '\n'  
    print  '对 x 调用 argsort() 函数:' 
    y = np.argsort(x)  
    print y 
    print  '\n'  
    print  '以排序后的顺序重构原数组:'  
    print x[y]  
    print  '\n'  
    print  '使用循环重构原数组:'  
    for i in y:  
        print x[i],
    

    输出如下:

    
    我们的数组是:
    [3 1 2]
    
    对 x 调用 argsort() 函数:
    [1 2 0]
    
    以排序后的顺序重构原数组:
    [1 2 3]
    
    使用循环重构原数组:
    1 2 3
    
    

    numpy.lexsort()

    函数使用键序列执行间接排序。 键可以看作是电子表格中的一列。 该函数返回一个索引数组,使用它可以获得排序数据。 注意,最后一个键恰好是 sort 的主键。

    示例

    
    import numpy as np 
    
    nm =  ('raju','anil','ravi','amar') 
    dv =  ('f.y.',  's.y.',  's.y.',  'f.y.') 
    ind = np.lexsort((dv,nm))  
    print  '调用 lexsort() 函数:'  
    print ind 
    print  '\n'  
    print  '使用这个索引来获取排序后的数据:'  
    print  [nm[i]  +  ", "  + dv[i]  for i in ind]  
    

    输出如下:

    调用 lexsort() 函数:
    [3 1 0 2]
    
    使用这个索引来获取排序后的数据:
    ['amar, f.y.', 'anil, s.y.', 'raju, f.y.', 'ravi, s.y.']
    
    

    NumPy 模块有一些用于在数组内搜索的函数。 提供了用于找到最大值,最小值以及满足给定条件的元素的函数。

    numpy.argmax()numpy.argmin()

    这两个函数分别沿给定轴返回最大和最小元素的索引。

    示例

    
    import numpy as np 
    a = np.array([[30,40,70],[80,20,10],[50,90,60]])  
    print  '我们的数组是:'  
    print a 
    print  '\n'  
    print  '调用 argmax() 函数:'  
    print np.argmax(a)  
    print  '\n'  
    print  '展开数组:'  
    print a.flatten()  
    print  '\n'  
    print  '沿轴 0 的最大值索引:' 
    maxindex = np.argmax(a, axis =  0)  
    print maxindex 
    print  '\n'  
    print  '沿轴 1 的最大值索引:' 
    maxindex = np.argmax(a, axis =  1)  
    print maxindex 
    print  '\n'  
    print  '调用 argmin() 函数:' 
    minindex = np.argmin(a)  
    print minindex 
    print  '\n'  
    print  '展开数组中的最小值:'  
    print a.flatten()[minindex]  
    print  '\n'  
    print  '沿轴 0 的最小值索引:' 
    minindex = np.argmin(a, axis =  0)  
    print minindex 
    print  '\n'  
    print  '沿轴 1 的最小值索引:' 
    minindex = np.argmin(a, axis =  1)  
    print minindex
    

    输出如下:

    
    我们的数组是:
    [[30 40 70]
     [80 20 10]
     [50 90 60]]
    
    调用 argmax() 函数:
    7
    
    展开数组:
    [30 40 70 80 20 10 50 90 60]
    
    沿轴 0 的最大值索引:
    [1 2 0]
    
    沿轴 1 的最大值索引:
    [2 0 1]
    
    调用 argmin() 函数:
    5
    
    展开数组中的最小值:
    10
    
    沿轴 0 的最小值索引:
    [0 1 1]
    
    沿轴 1 的最小值索引:
    [0 2 0]
    
    

    numpy.nonzero()

    numpy.nonzero()函数返回输入数组中非零元素的索引。

    示例

    
    import numpy as np 
    a = np.array([[30,40,0],[0,20,10],[50,0,60]])  
    print  '我们的数组是:'  
    print a 
    print  '\n'  
    print  '调用 nonzero() 函数:'  
    print np.nonzero (a)
    

    输出如下:

    
    我们的数组是:
    [[30 40 0]
     [ 0 20 10]
     [50 0 60]]
    
    调用 nonzero() 函数:
    (array([0, 0, 1, 1, 2, 2]), array([0, 1, 1, 2, 0, 2]))
    
    

    numpy.where()

    where()函数返回输入数组中满足给定条件的元素的索引。

    示例

    
    import numpy as np 
    x = np.arange(9.).reshape(3,  3)  
    print  '我们的数组是:'  
    print x 
    print  '大于 3 的元素的索引:' 
    y = np.where(x >  3)  
    print y 
    print  '使用这些索引来获取满足条件的元素:'  
    print x[y]
    

    输出如下:

    
    我们的数组是:
    [[ 0. 1. 2.]
     [ 3. 4. 5.]
     [ 6. 7. 8.]]
    
    大于 3 的元素的索引:
    (array([1, 1, 2, 2, 2]), array([1, 2, 0, 1, 2]))
    
    使用这些索引来获取满足条件的元素:
    [ 4. 5. 6. 7. 8.]
    
    

    numpy.extract()

    extract()函数返回满足任何条件的元素。

    
    import numpy as np 
    x = np.arange(9.).reshape(3,  3)  
    print  '我们的数组是:'  
    print x 
    # 定义条件 
    condition = np.mod(x,2)  ==  0  
    print  '按元素的条件值:'  
    print condition 
    print  '使用条件提取元素:'  
    print np.extract(condition, x)
    

    输出如下:

    
    我们的数组是:
    [[ 0. 1. 2.]
     [ 3. 4. 5.]
     [ 6. 7. 8.]]
    
    按元素的条件值:
    [[ True False True]
     [False True False]
     [ True False True]]
    
    使用条件提取元素:
    [ 0. 2. 4. 6. 8.]
    
    

    NumPy - 字节交换

    我们已经看到,存储在计算机内存中的数据取决于 CPU 使用的架构。 它可以是小端(最小有效位存储在最小地址中)或大端(最小有效字节存储在最大地址中)。

    numpy.ndarray.byteswap()

    numpy.ndarray.byteswap()函数在两个表示:大端和小端之间切换。

    
    import numpy as np 
    a = np.array([1,  256,  8755], dtype = np.int16)  
    print  '我们的数组是:'  
    print a 
    print  '以十六进制表示内存中的数据:'  
    print map(hex,a)  
    # byteswap() 函数通过传入 true 来原地交换 
    print  '调用 byteswap() 函数:'  
    print a.byteswap(True)  
    print  '十六进制形式:'  
    print map(hex,a)  
    # 我们可以看到字节已经交换了
    

    输出如下:

    我们的数组是:
    [1 256 8755]
    
    以十六进制表示内存中的数据:
    ['0x1', '0x100', '0x2233']
    
    调用 byteswap() 函数:
    [256 1 13090]
    
    十六进制形式:
    ['0x100', '0x1', '0x3322']
    
    

    NumPy - 副本和视图

    在执行函数时,其中一些返回输入数组的副本,而另一些返回视图。 当内容物理存储在另一个位置时,称为副本。 另一方面,如果提供了相同内存内容的不同视图,我们将其称为视图

    无复制

    简单的赋值不会创建数组对象的副本。 相反,它使用原始数组的相同id()来访问它。 id()返回 Python 对象的通用标识符,类似于 C 中的指针。

    此外,一个数组的任何变化都反映在另一个数组上。 例如,一个数组的形状改变也会改变另一个数组的形状。

    示例

    
    import numpy as np 
    a = np.arange(6)  
    print  '我们的数组是:'  
    print a 
    print  '调用 id() 函数:'  
    print id(a)  
    print  'a 赋值给 b:' 
    b = a 
    print b 
    print  'b 拥有相同 id():'  
    print id(b)  
    print  '修改 b 的形状:' 
    b.shape =  3,2  
    print b 
    print  'a 的形状也修改了:'  
    print a
    

    输出如下:

    
    我们的数组是:
    [0 1 2 3 4 5]
    
    调用 id() 函数:
    139747815479536
    
    a 赋值给 b:
    [0 1 2 3 4 5]
    b 拥有相同 id():
    139747815479536
    
    修改 b 的形状:
    [[0 1]
     [2 3]
     [4 5]]
    
    a 的形状也修改了:
    [[0 1]
     [2 3]
     [4 5]]
    
    

    视图或浅复制

    NumPy 拥有ndarray.view()方法,它是一个新的数组对象,并可查看原始数组的相同数据。 与前一种情况不同,新数组的维数更改不会更改原始数据的维数。

    示例

    
    import numpy as np 
    # 最开始 a 是个 3X2 的数组
    a = np.arange(6).reshape(3,2)  
    print  '数组 a:'  
    print a 
    print  '创建 a 的视图:' 
    b = a.view()  
    print b 
    print  '两个数组的 id() 不同:'  
    print  'a 的 id():'  
    print id(a)  
    print  'b 的 id():'  
    print id(b)  
    # 修改 b 的形状,并不会修改 a
    b.shape =  2,3  
    print  'b 的形状:'  
    print b 
    print  'a 的形状:'  
    print a
    

    输出如下:

    
    数组 a:
    [[0 1]
     [2 3]
     [4 5]]
    
    创建 a 的视图:
    [[0 1]
     [2 3]
     [4 5]]
    
    两个数组的 id() 不同:
    a 的 id():
    140424307227264
    b 的 id():
    140424151696288
    
    b 的形状:
    [[0 1 2]
     [3 4 5]]
    
    a 的形状:
    [[0 1]
     [2 3]
     [4 5]]
    
    

    数组的切片也会创建视图:

    示例

    
    import numpy as np 
    a = np.array([[10,10],  [2,3],  [4,5]])  
    print  '我们的数组:'  
    print a 
    print  '创建切片:' 
    s = a[:,  :2]  
    print s 
    

    输出如下:

    
    我们的数组:
    [[10 10]
     [ 2 3]
     [ 4 5]]
    
    创建切片:
    [[10 10]
     [ 2 3]
     [ 4 5]]
    
    

    深复制

    ndarray.copy()函数创建一个深层副本。 它是数组及其数据的完整副本,不与原始数组共享。

    示例

    
    import numpy as np 
    a = np.array([[10,10],  [2,3],  [4,5]])  
    print  '数组 a:'  
    print a 
    print  '创建 a 的深层副本:' 
    b = a.copy()  
    print  '数组 b:'  
    print b 
    # b 与 a 不共享任何内容  
    print  '我们能够写入 b 来写入 a 吗?'  
    print b is a 
    print  '修改 b 的内容:' 
    b[0,0]  =  100  
    print  '修改后的数组 b:'  
    print b 
    print  'a 保持不变:'  
    print a
    

    输出如下:

    
    数组 a:
    [[10 10]
     [ 2 3]
     [ 4 5]]
    
    创建 a 的深层副本:
    数组 b:
    [[10 10]
     [ 2 3]
     [ 4 5]]
    我们能够写入 b 来写入 a 吗?
    False
    
    修改 b 的内容:
    修改后的数组 b:
    [[100 10]
     [ 2 3]
     [ 4 5]]
    
    a 保持不变:
    [[10 10]
     [ 2 3]
     [ 4 5]]
    
    

    NumPy - 矩阵库

    NumPy 包包含一个 Matrix库numpy.matlib。此模块的函数返回矩阵而不是返回ndarray对象。

    matlib.empty()

    matlib.empty()函数返回一个新的矩阵,而不初始化元素。 该函数接受以下参数。

    
    numpy.matlib.empty(shape, dtype, order)
    
    

    其中:

    序号 参数及描述
    1. shape 定义新矩阵形状的整数或整数元组
    2. Dtype 可选,输出的数据类型
    3. order C 或者 F

    示例

    
    import numpy.matlib 
    import numpy as np 
    print np.matlib.empty((2,2))  
    # 填充为随机数据
    

    输出如下:

    [[ 2.12199579e-314,   4.24399158e-314] 
     [ 4.24399158e-314,   2.12199579e-314]] 
    
    

    numpy.matlib.zeros()

    此函数返回以零填充的矩阵。

    
    import numpy.matlib 
    import numpy as np 
    print np.matlib.zeros((2,2))  
    

    输出如下:

    
    [[ 0.  0.] 
     [ 0.  0.]]) 
    
    

    numpy.matlib.ones()

    此函数返回以一填充的矩阵。

    
    import numpy.matlib 
    import numpy as np 
    print np.matlib.ones((2,2))
    

    输出如下:

    [[ 1.  1.] 
     [ 1.  1.]] 
    
    

    numpy.matlib.eye()

    这个函数返回一个矩阵,对角线元素为 1,其他位置为零。 该函数接受以下参数。

    
    numpy.matlib.eye(n, M,k, dtype)
    
    

    其中:

    序号 参数及描述
    1. n 返回矩阵的行数
    2. M 返回矩阵的列数,默认为n
    3. k 对角线的索引
    4. dtype 输出的数据类型

    示例

    
    import numpy.matlib 
    import numpy as np 
    print np.matlib.eye(n =  3, M =  4, k =  0, dtype =  float)
    

    输出如下:

    
    [[ 1.  0.  0.  0.] 
     [ 0.  1.  0.  0.] 
     [ 0.  0.  1.  0.]]) 
    
    

    numpy.matlib.identity()

    numpy.matlib.identity()函数返回给定大小的单位矩阵。单位矩阵是主对角线元素都为 1 的方阵。

    
    import numpy.matlib 
    import numpy as np 
    print np.matlib.identity(5, dtype =  float)
    

    输出如下:

    [[ 1.  0.  0.  0.  0.] 
     [ 0.  1.  0.  0.  0.] 
     [ 0.  0.  1.  0.  0.] 
     [ 0.  0.  0.  1.  0.] 
     [ 0.  0.  0.  0.  1.]] 
    
    

    numpy.matlib.rand()

    ·numpy.matlib.rand()`函数返回给定大小的填充随机值的矩阵。

    示例

    
    import numpy.matlib 
    import numpy as np 
    print np.matlib.rand(3,3)
    

    输出如下:

    [[ 0.82674464  0.57206837  0.15497519] 
     [ 0.33857374  0.35742401  0.90895076] 
     [ 0.03968467  0.13962089  0.39665201]]
    
    

    注意,矩阵总是二维的,而ndarray是一个 n 维数组。 两个对象都是可互换的。

    示例

    
    import numpy.matlib 
    import numpy as np  
    
    i = np.matrix('1,2;3,4')  
    print i 
    

    输出如下:

    [[1  2] 
     [3  4]]
    
    

    示例

    
    import numpy.matlib 
    import numpy as np  
    
    j = np.asarray(i)  
    print j 
    

    输出如下:

    [[1  2] 
     [3  4]] 
    
    

    示例

    
    import numpy.matlib 
    import numpy as np  
    
    k = np.asmatrix (j)  
    print k
    

    输出如下:

    [[1  2] 
     [3  4]]
    
    

    NumPy - 线性代数

    NumPy 包包含numpy.linalg模块,提供线性代数所需的所有功能。 此模块中的一些重要功能如下表所述。

    序号 函数及描述
    1. dot 两个数组的点积
    2. vdot 两个向量的点积
    3. inner 两个数组的内积
    4. matmul 两个数组的矩阵积
    5. determinant 数组的行列式
    6. solve 求解线性矩阵方程
    7. inv 寻找矩阵的乘法逆矩阵

    numpy.dot()

    此函数返回两个数组的点积。 对于二维向量,其等效于矩阵乘法。 对于一维数组,它是向量的内积。 对于 N 维数组,它是a的最后一个轴上的和与b的倒数第二个轴的乘积。

    
    import numpy.matlib 
    import numpy as np 
    
    a = np.array([[1,2],[3,4]]) 
    b = np.array([[11,12],[13,14]]) 
    np.dot(a,b)
    

    输出如下:

    [[37  40] 
     [85  92]] 
    

    要注意点积计算为:

    [[1*11+2*13, 1*12+2*14],[3*11+4*13, 3*12+4*14]]
    

    numpy.vdot()

    此函数返回两个向量的点积。 如果第一个参数是复数,那么它的共轭复数会用于计算。 如果参数id是多维数组,它会被展开。

    例子

    
    import numpy as np 
    a = np.array([[1,2],[3,4]]) 
    b = np.array([[11,12],[13,14]]) 
    print np.vdot(a,b)
    

    输出如下:

    130
    

    注意:1*11 + 2*12 + 3*13 + 4*14 = 130

    numpy.inner()

    此函数返回一维数组的向量内积。 对于更高的维度,它返回最后一个轴上的和的乘积。

    例子

    
    import numpy as np 
    print np.inner(np.array([1,2,3]),np.array([0,1,0])) 
    # 等价于 1*0+2*1+3*0
    

    输出如下:

    2
    

    例子

    
    # 多维数组示例 
    import numpy as np 
    a = np.array([[1,2], [3,4]]) 
    
    print '数组 a:' 
    print a 
    b = np.array([[11, 12], [13, 14]]) 
    
    print '数组 b:' 
    print b 
    
    print '内积:' 
    print np.inner(a,b)
    

    输出如下:

    
    数组 a:
    [[1 2]
    [3 4]]
    
    数组 b:
    [[11 12]
    [13 14]]
    
    内积:
    [[35 41]
    [81 95]]
    

    上面的例子中,内积计算如下:

    1*11+2*12, 1*13+2*14 
    3*11+4*12, 3*13+4*14 
    

    numpy.matmul

    numpy.matmul()函数返回两个数组的矩阵乘积。 虽然它返回二维数组的正常乘积,但如果任一参数的维数大于2,则将其视为存在于最后两个索引的矩阵的栈,并进行相应广播。

    另一方面,如果任一参数是一维数组,则通过在其维度上附加 1 来将其提升为矩阵,并在乘法之后被去除。

    例子

    
    # 对于二维数组,它就是矩阵乘法
    import numpy.matlib 
    import numpy as np 
    
    a = [[1,0],[0,1]] 
    b = [[4,1],[2,2]] 
    print np.matmul(a,b)
    

    输出如下:

    [[4  1] 
     [2  2]] 
    

    例子

    
    # 二维和一维运算
    import numpy.matlib 
    import numpy as np 
    
    a = [[1,0],[0,1]] 
    b = [1,2] 
    print np.matmul(a,b) 
    print np.matmul(b,a)
    

    输出如下:

    [1  2] 
    [1  2] 
    

    例子

    
    # 维度大于二的数组 
    import numpy.matlib 
    import numpy as np 
    
    a = np.arange(8).reshape(2,2,2) 
    b = np.arange(4).reshape(2,2) 
    print np.matmul(a,b)
    

    输出如下:

    [[[2   3] 
       [6   11]] 
      [[10  19] 
       [14  27]]]
    

    numpy.linalg.det()

    行列式在线性代数中是非常有用的值。 它从方阵的对角元素计算。 对于 2×2 矩阵,它是左上和右下元素的乘积与其他两个的乘积的差。

    换句话说,对于矩阵[[a,b],[c,d]],行列式计算为ad-bc。 较大的方阵被认为是 2×2 矩阵的组合。

    numpy.linalg.det()函数计算输入矩阵的行列式。

    例子

    
    import numpy as np
    a = np.array([[1,2], [3,4]]) 
    print np.linalg.det(a)
    

    输出如下:

    
    -2.0
    

    例子

    
    b = np.array([[6,1,1], [4, -2, 5], [2,8,7]]) 
    print b 
    print np.linalg.det(b) 
    print 6*(-2*7 - 5*8) - 1*(4*7 - 5*2) + 1*(4*8 - -2*2)
    

    输出如下:

    [[ 6 1 1]
     [ 4 -2 5]
     [ 2 8 7]]
    
    -306.0
    
    -306
    

    numpy.linalg.solve()

    numpy.linalg.solve()函数给出了矩阵形式的线性方程的解。

    考虑以下线性方程:

    x + y + z = 6
    
    2y + 5z = -4
    
    2x + 5y - z = 27
    

    可以使用矩阵表示为:

    如果矩阵成为AXB,方程变为:

    AX = B  
    

    X = A^(-1)B 
    

    numpy.linalg.inv()

    我们使用numpy.linalg.inv()函数来计算矩阵的逆。 矩阵的逆是这样的,如果它乘以原始矩阵,则得到单位矩阵。

    例子

    
    import numpy as np 
    
    x = np.array([[1,2],[3,4]]) 
    y = np.linalg.inv(x) 
    print x 
    print y 
    print np.dot(x,y)
    

    输出如下:

    [[1 2]                                                                        
     [3 4]]                                                                       
    [[-2.   1. ]                                                                  
     [ 1.5 -0.5]]                                                                 
    [[  1.00000000e+00   1.11022302e-16]                                          
     [  0.00000000e+00   1.00000000e+00]]
    

    例子

    现在让我们在示例中创建一个矩阵A的逆。

    
    import numpy as np 
    a = np.array([[1,1,1],[0,2,5],[2,5,-1]]) 
    
    print '数组 a:'
    print a 
    ainv = np.linalg.inv(a) 
    
    print 'a 的逆:' 
    print ainv  
    
    print '矩阵 b:' 
    b = np.array([[6],[-4],[27]]) 
    print b 
    
    print '计算:A^(-1)B:' 
    x = np.linalg.solve(a,b) 
    print x  
    # 这就是线性方向 x = 5, y = 3, z = -2 的解
    

    输出如下:

    
    数组 a:
    [[ 1 1 1]
     [ 0 2 5]
     [ 2 5 -1]]
    
    a 的逆:
    [[ 1.28571429 -0.28571429 -0.14285714]
     [-0.47619048 0.14285714 0.23809524]
     [ 0.19047619 0.14285714 -0.0952381 ]]
    
    矩阵 b:
    [[ 6]
     [-4]
     [27]]
    
    计算:A^(-1)B:
    [[ 5.]
     [ 3.]
     [-2.]]
    

    结果也可以使用下列函数获取

    x = np.dot(ainv,b)
    

    NumPy - Matplotlib

    Matplotlib 是 Python 的绘图库。 它可与 NumPy 一起使用,提供了一种有效的 MatLab 开源替代方案。 它也可以和图形工具包一起使用,如 PyQt 和 wxPython。

    Matplotlib 模块最初是由 John D. Hunter 编写的。 自 2012 年以来,Michael Droettboom 是主要开发者。 目前,Matplotlib 1.5.1 是可用的稳定版本。 该软件包可以二进制分发,其源代码形式在 www.matplotlib.org 上提供。

    通常,通过添加以下语句将包导入到 Python 脚本中:

    
    from matplotlib import pyplot as plt
    
    

    这里pyplot()是 matplotlib 库中最重要的函数,用于绘制 2D 数据。 以下脚本绘制方程y = 2x + 5

    示例

    
    import numpy as np 
    from matplotlib import pyplot as plt 
    
    x = np.arange(1,11) 
    y =  2  * x +  5 
    plt.title("Matplotlib demo") 
    plt.xlabel("x axis caption") 
    plt.ylabel("y axis caption") 
    plt.plot(x,y) plt.show()
    

    ndarray对象xnp.arange()函数创建为x轴上的值。y轴上的对应值存储在另一个数组对象y中。 这些值使用matplotlib软件包的pyplot子模块的plot()函数绘制。

    图形由show()函数展示。

    上面的代码应该产生以下输出:

    Matplotlib Demo

    Matplotlib Demo

    作为线性图的替代,可以通过向plot()函数添加格式字符串来显示离散值。 可以使用以下格式化字符。

    字符 描述
    '-' 实线样式
    '--' 短横线样式
    '-.' 点划线样式
    ':' 虚线样式
    '.' 点标记
    ',' 像素标记
    'o' 圆标记
    'v' 倒三角标记
    '^' 正三角标记
    '<' 左三角标记
    '>' 右三角标记
    '1' 下箭头标记
    '2' 上箭头标记
    '3' 左箭头标记
    '4' 右箭头标记
    's' 正方形标记
    'p' 五边形标记
    '*' 星形标记
    'h' 六边形标记 1
    'H' 六边形标记 2
    '+' 加号标记
    'x' X 标记
    'D' 菱形标记
    'd' 窄菱形标记
    `' '` 竖直线标记
    '_' 水平线标记

    还定义了以下颜色缩写。

    字符 颜色
    'b' 蓝色
    'g' 绿色
    'r' 红色
    'c' 青色
    'm' 品红色
    'y' 黄色
    'k' 黑色
    'w' 白色

    要显示圆来代表点,而不是上面示例中的线,请使用ob作为plot()函数中的格式字符串。

    示例

    
    import numpy as np 
    from matplotlib import pyplot as plt 
    
    x = np.arange(1,11) 
    y =  2  * x +  5 
    plt.title("Matplotlib demo") 
    plt.xlabel("x axis caption") 
    plt.ylabel("y axis caption") 
    plt.plot(x,y,"ob") 
    plt.show()  
    

    上面的代码应该产生以下输出:

    Color Abbreviation

    Color Abbreviation

    绘制正弦波

    以下脚本使用 matplotlib 生成正弦波图

    示例

    
    import numpy as np 
    import matplotlib.pyplot as plt 
    # 计算正弦曲线上点的 x 和 y 坐标
    x = np.arange(0,  3  * np.pi,  0.1) 
    y = np.sin(x)
    plt.title("sine wave form")  
    # 使用 matplotlib 来绘制点
    plt.plot(x, y) 
    plt.show()  
    

    Sine Wave

    Sine Wave

    subplot()

    subplot()函数允许你在同一图中绘制不同的东西。 在下面的脚本中,绘制正弦余弦值。

    示例

    
    import numpy as np 
    import matplotlib.pyplot as plt 
    # 计算正弦和余弦曲线上的点的 x 和 y 坐标 
    x = np.arange(0,  3  * np.pi,  0.1) 
    y_sin = np.sin(x) 
    y_cos = np.cos(x)  
    # 建立 subplot 网格,高为 2,宽为 1  
    # 激活第一个 subplot
    plt.subplot(2,  1,  1)  
    # 绘制第一个图像 
    plt.plot(x, y_sin) 
    plt.title('Sine')  
    # 将第二个 subplot 激活,并绘制第二个图像
    plt.subplot(2,  1,  2) 
    plt.plot(x, y_cos) 
    plt.title('Cosine')  
    # 展示图像
    plt.show()
    

    上面的代码应该产生以下输出:

    Sub Plot

    Sub Plot

    bar()

    pyplot子模块提供bar()函数来生成条形图。 以下示例生成两组xy数组的条形图。

    示例

    
    from matplotlib import pyplot as plt 
    x =  [5,8,10] 
    y =  [12,16,6] 
    x2 =  [6,9,11] 
    y2 =  [6,15,7] 
    plt.bar(x, y, align =  'center') 
    plt.bar(x2, y2, color =  'g', align =  'center') 
    plt.title('Bar graph') 
    plt.ylabel('Y axis') 
    plt.xlabel('X axis') 
    plt.show()
    

    NumPy - 使用 Matplotlib 绘制直方图

    NumPy 有一个numpy.histogram()函数,它是数据的频率分布的图形表示。 水平尺寸相等的矩形对应于类间隔,称为bin,变量height对应于频率。

    numpy.histogram()

    numpy.histogram()函数将输入数组和bin作为两个参数。 bin数组中的连续元素用作每个bin的边界。

    
    import numpy as np 
    
    a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27]) ]
    np.histogram(a,bins =  [0,20,40,60,80,100]) 
    hist,bins = np.histogram(a,bins =  [0,20,40,60,80,100])  
    print hist 
    print bins 
    

    输出如下:

    [3 4 5 2 1]
    [0 20 40 60 80 100]
    
    

    plt()

    Matplotlib 可以将直方图的数字表示转换为图形。 pyplot子模块的plt()函数将包含数据和bin数组的数组作为参数,并转换为直方图。

    
    from matplotlib import pyplot as plt 
    import numpy as np  
    
    a = np.array([22,87,5,43,56,73,55,54,11,20,51,5,79,31,27]) 
    plt.hist(a, bins =  [0,20,40,60,80,100]) 
    plt.title("histogram") 
    plt.show()
    

    输出如下:

    Histogram Plot

    Histogram Plot

    NumPy - IO

    ndarray对象可以保存到磁盘文件并从磁盘文件加载。 可用的 IO 功能有:

    • load()save()函数处理 numPy 二进制文件(带npy扩展名)

    • loadtxt()savetxt()函数处理正常的文本文件

    NumPy 为ndarray对象引入了一个简单的文件格式。 这个npy文件在磁盘文件中,存储重建ndarray所需的数据、图形、dtype和其他信息,以便正确获取数组,即使该文件在具有不同架构的另一台机器上。

    numpy.save()

    numpy.save()文件将输入数组存储在具有npy扩展名的磁盘文件中。

    
    import numpy as np 
    a = np.array([1,2,3,4,5]) 
    np.save('outfile',a)
    

    为了从outfile.npy重建数组,请使用load()函数。

    
    import numpy as np 
    b = np.load('outfile.npy')  
    print b 
    

    输出如下:

    
    array([1, 2, 3, 4, 5])
    
    

    save()load()函数接受一个附加的布尔参数allow_pickles。 Python 中的pickle用于在保存到磁盘文件或从磁盘文件读取之前,对对象进行序列化和反序列化。

    savetxt()

    以简单文本文件格式存储和获取数组数据,是通过savetxt()loadtx()函数完成的。

    示例

    
    import numpy as np 
    
    a = np.array([1,2,3,4,5]) 
    np.savetxt('out.txt',a) 
    b = np.loadtxt('out.txt')  
    print b 
    

    输出如下:

    [ 1.  2.  3.  4.  5.] 
    
    

    savetxt()loadtxt()数接受附加的可选参数,例如页首,页尾和分隔符。

    NumPy - 实用资源

    以下资源包含有关 NumPy 的其他信息。 请使用它们获得更多的深入知识。


    转载链接:https://www.jianshu.com/p/57e3c0a92f3a

    展开全文
  • NumPy — 从零到入门

    千次阅读 多人点赞 2020-05-05 14:23:32
    numpy一.常见库函数1.empty2. full 一.常见库函数 1.empty empty(shape, dtype=float, order=‘C’) shape, int或int元组 dtype, 数组中元素的格式 C或F, 代表行优先或列优先 np.empty(shape=3) 2. ...

    前言

    Numpy是一个用于科学计算的包,虽然大多数数据分析工作不需要深入理解NumpPy包,但是精通面向数组的编程和思维方式是成为Python科学计算牛人的一大关键步骤。

    一. NumPy库的介绍

    1. 简介

    NumPy(Numerical Python)是高性能科学计算和数据分析的基础包

    它利用不同维度的数组进行数学计算操作。因此该库提供了大量的便于直接使用的库函数,可以很灵活与便捷的帮助研究人员进行数值计算。

    目前,它已经在数据分析和机器学习被广泛使用,并拥有以下几个特点:

    1. 对整组数据进行快速运算的标准数学函数库,无需编写循环,即内置并行运算功能,当系统进行某种计算时,并且有多个核心时,NumPy会自动做并行计算。
    2. NumPy底层用C语言编写,内部解除了GIL(全局解释性锁),其对数组的操作速度不受python解释器的限制,效率远高于纯python代码。
    3. 拥有一个类似于列表的、强大的N维数组对象ndarray,它描述了相同类型的元素的集合。并且它还是一个具有矢量运算和复杂广播能力的快速且节省空间的多维数组
    4. 具有实用的线性代数、傅里叶变换和随机生成函数的功能。

    总之,它是一个处理数值型运算效率非常高的包。

    2. 安装

    安装有两种办法,取其一即可,当然安装两者都行,不过要将python环境和anaconda的环境进行区分,否则很容易发生冲突与混淆。

    (1). 安装python “大礼包软件” - anaconda

    说到数据分析,很多人会想到安装anaconda,这是一个已经自带集成了很多python数据分析的常用库的软件,它对新手比较友好,不用去自己下载整理各种繁杂的库,当然,除了自带的库,它也支持搜索下载新库,以及改变已下载库的版本,删除库,查询库等等。除了操作库之外,它还拥有很多新功能,它内置自带各种软件如:jupyter notebook、spyder等等,功能很多很全面。

    (2). 直接通过python内置库pip进行安装

    当然,对于已经很熟悉数据分析的人来说,环境的配置可以变得简洁,直接通过:

    pip install numpy
    pip install XXX...
    ...
    

    即把几个常用的库给安装下来了,如果下载爆红遇到Https连接超时time out问题,这里有几种办法:

    1. 如果你的时间比较充裕,或者观察下载耗费时间不会很长,每次超时爆红,再继续pip运行一遍,你会发现,每次进度条都会比上一次跑的多才断开,重复多次直到下载完成。
    2. pip安装时加上镜像源,即加上[ -m 镜像源 ] ,具体镜像源,参考我前面一篇博客:镜像源。这种方法有个弊端,就是有些库的版本可能会很陈旧,可能会出现问题。比如:我以前做Django项目时,创建虚拟环境,安装virtualenv,无法进入创建出来的虚拟环境中去。然而卸载掉后,安装官方版本后,没有出现任何问题。
    3. 对于有条件的人,可以选择买个VPN,挂着梯子下载库,因为服务器本身就在国外,然后你就会发现,几十分钟的库,几分钟甚至几十秒就下载完成了。

    3. 性能对比

    numpy中的数组对象为:ndarray。n是n个、多个的意思;d是dimension,表示维度;array则为数组的意思。

    跟它比较类似为python中的list,我们先来看看ndarray和list的结构:

    list_test = [1,2,3,4]
    array_test = np.array([1,2,3,4])
    
    display(list_test, array_test)
    display(type(list_test), type(array_test))
    

    结果:
    在这里插入图片描述

    数组array和列表list外形很相似,但是数据分析为什么要用到array,而不是直接使用list呢?

    我们来进行下性能测试:

    import numpy as np
    import time
    
    # 列表计算花费时间
    t1_list = time.time()
    con_list = []
    for i in range(100000):
        con_list.append(i**2)
    t2_list = time.time()
    
    t_spend_list = t2_list - t1_list
    
    # array计算花费时间
    t1_numpy = time.time()
    con_array = np.arange(100000) ** 2
    t2_numpy = time.time()
    
    t_spend_numpy = t2_numpy - t1_numpy
    
    display(t_spend_list, t_spend_numpy)
    

    测试结果:
    在这里插入图片描述

    4. 内存中的存储形式

    列表包含三个属性:列表的类型:列表类;列表的长度:元素个数;列表中的元素地址:指向元素对象的存储位置。每个元素对象包含:类型:该元素的类型;元素:该元素的值。

    列表可以存储多个数据类型。
    在这里插入图片描述
    数组包含四个属性:类型:表示元素的属性,即,每个元素应为同一数据类型;数据:按顺序排列着每个元素的值,便于广播;维度和步幅。
    在这里插入图片描述
    综上可以看出,数组的存储结构使其性能大大提高,优于使用列表。

    二、创建ndarray对象

    在创建对象时,若不指定内部元素的类型,那么函数会自动为这个数组推断出一个较为合适的数据类型。数据类型保存在一个特殊的dtype属性对象中。所以,一般情况下,在偏差不大时,我们也可以不去指定元素数据类型。

    1. array()函数 - 自由创建

    它接收一切序列型的对象,比如:列表、元组、可迭代对象等等,当然也包括它自己

    用法:

    np.array(序列型对象)
    

    例子:

    import numpy as np
    
    n1 = np.array([1, 2, 3]) # 列表
    n2 = np.array((4,5,6))  # 元组
    n3 = np.array(range(7,10)) # 可迭代对象
    
    # 输出:
    array([1, 2, 3])
    array([4, 5, 6])
    array([7, 8, 9])
    

    2. arange()函数 - 范围创建

    在Python中,range()函数,只能接受整型参数。
    在Numpy中,arange()函数可以接受数值型等等参数。

    用法:

    np.arange(start, end, step)
    
    start - 起始,不存在时,默认从0开始
    end - 结束,不包括,实质上取到end-1
    step - 步长
    

    例子:

    import numpy as np
    
    # 数值型
    np.arange(10, 13, 1) # 整型
    np.arange(3.0) # 浮点型
    np.arange(True) # 布尔型
    np.arange(4+4j) # 复数型
     
    # 输出:
    array([10, 11, 12])
    array([0., 1., 2.])
    array([0])
    array([0.+0.j, 1.+0.j, 2.+0.j, 3.+0.j])
    

    3. random模块 - 随机创建

    使用NumPy包中的random模块,它包含很多函数可以创建基于随机的数组。
    具体函数可以参考:np.random模块的使用

    用法:

    np.random.randint(start, end, size)
    
    start - 随机范围的下边界
    end - 随机范围的上边界
    size - 随机结果的形态
    

    例子:

    n1 = np.random.randint(5, 15, size=(4, 4))
    
    # 输出:
    array([[12, 11, 14,  6],
           [ 5,  6, 13, 13],
           [ 8, 14, 13, 12],
           [ 8, 11, 10,  6]])
    

    4. repeat()函数 - 复制创建

    将输入值的整体某部分,在原来的基础上,进行指定次数的复制,从而创建新的输出值。

    用法:

    np.repeat(a, repeats, axis=None)
    
    a - array-like
    repeats - 重复次数
    axis - 执行方向
    

    例子:

    x = np.array([[1,2],[3,4]])
    np.repeat(x, [1, 2], axis=0)
    
    # 结果
    array([[1, 2],
           [3, 4],
           [3, 4]])
    

    5. full()函数 - 填充创建

    指定输出的形状,再指定一个数填充入该结构中,输出该结果。

    用法:

    np.full(shape, fill_value, dtype=None, order='C')
    
    shape - 列表或元祖表现的多维数组
    fill_value - 填充值,只能为数值型
    dtype - 指定填充值的数据类型
    order - C或者F,是否将多维数组以C或者Fortrain的形式存在内存中。默认为C
    

    例子:

    np.full((2, 2), np.inf)
    
    # 结果
    array([[ inf,  inf],
           [ inf,  inf]])
    

    6. ones()、zeros() - 自动填充创建

    指定形状,函数会直接自动填充内部值。

    用法:

    np.ones(shape, dtype=None, order='C')
    np.zeros(shape, dtype=None, order='C')
    # ones_like(a, dtype=None, order='K', subok=True)
    # zeros_like(a, dtype=None, order='K', subok=True)
    
    shape - 列表或元祖表现的多维数组
    dtype - 指定填充值的数据类型
    order - C或者F,是否将多维数组以C或者Fortrain的形式存在内存中。默认为C
    

    例子:

    a = np.ones((3, 3))
    b = np.zeros((2,2))
    print(a)
    print(b)
    
    # 打印
    [[1. 1. 1.]
     [1. 1. 1.]
     [1. 1. 1.]]
     
    [[0. 0.]
     [0. 0.]]
    

    7. empty() - 内存创建

    该函数值分配数组大小内存,而不产生实际值。具有相同效果的还有有empty_like()函数。

    用法:

    np.empty(shape, dtype=None, order='C')
    # np.empty_like(prototype, dtype=None, order=None, subok=None)
    
    shape - 列表或元祖表现的多维数组
    dtype - 指定填充值的数据类型
    order - C或者F,是否将多维数组以C或者Fortrain的形式存在内存中。默认为C
    

    例子:

    a = np.empty((3,3))
    print(a)
    print(a[0]) # 值为0
    
    # 打印
    [[0.00000000e+000 0.00000000e+000 0.00000000e+000]
     [0.00000000e+000 0.00000000e+000 2.41104035e-321]
     [1.37962320e-306 1.29060870e-306 2.22518251e-306]]
    [0. 0. 0.]
    

    认为empty()和empty_like()结果的值为0是不正确的,因为很多情况下,它返回的是未初始化的垃圾值。

    8. eyes() - 对角创建

    创建一个类单位矩阵,即对角线上为1,其余为0的数组。指定形状即可创建。

    用法:

    np.eye(N, M=None, k=0, dtype=float, order='C')
    
    N - 输出的行数
    M - 输出的列数。如果为空,默认大小等于N
    k - 设定对角线索引位置。默认为主对角线,即0。正值,是上对角线;负值是下对角线。
    dtype - 指定填充值的数据类型
    order - 在内存中存储是否以行为主的C风格或者以列为主的Fortran风格
    

    例子:

    a = np.eye(5, k=-2)
    b = np.eye(5, k=2)
    print(a) # 右移两格
    print(b) # 左移两格
    
    # 打印
    [[0. 0. 0. 0. 0.]
     [0. 0. 0. 0. 0.]
     [1. 0. 0. 0. 0.]
     [0. 1. 0. 0. 0.]
     [0. 0. 1. 0. 0.]]
     
    [[0. 0. 1. 0. 0.]
     [0. 0. 0. 1. 0.]
     [0. 0. 0. 0. 1.]
     [0. 0. 0. 0. 0.]
     [0. 0. 0. 0. 0.]]
    

    三、ndarray的属性

    属性为该对象的变量,而不是函数,无需加括号

    1. dtype

    (1). 查看数组类型

    import numpy as np
    
    n1 = np.array([1, 3, 5])
    n1.dtype
    
    # 结果
    dtype('int32')
    # window系统默认int32
    

    (2). 修改数组类型

    该属性可以进行修改,方法如下:

    第一种:通过函数内置参数去修改,比如array函数中的dtype

    import numpy as np
    
    n1 = np.array([1, 3, 5], dtype=np.int64)
    n1.dtype
    
    # 结果
    dtype('int64')
    

    第二种:通过自身属性去修改

    import numpy as np
    
    n1 = np.array([1, 3, 5], dtype=np.int64)
    
    n1.dtype
    # 结果 dtype('int64')
    
    # 第二种
    n2 = n1.astype(np.int32)
    # 有返回值,不改变原数组类型
    # 无论如何都会拷贝一份新数组
    
    # 第三种
    # a.dtype = 'int32' 或 np.int32
    # 无返回值,直接修改原数组类型
    
    
    n2.dtype
    # 结果 
    dtype('int32')
    

    (3). 数组的常用数据类型:

    类型 类型代码 说明
    int8, uint8 i1, u1 有符号和无符号的8位(1个字节)整型
    int16, uint16 i2, u2 有符号和无符号的16位(2个字节)整型
    int32, uint32 i4, u4 有符号和无符号的32位(4个字节)整型
    int64, uint64 i8, u8 有符号和无符号的64位(8个字节)整型
    float16 f2 半精度浮点数
    float32 f4 或 f 标准的单精度浮点数。与C的float兼容
    float64 f8 或 d 标准的双精度浮点数。与C语言的double和python的float对象兼容
    float128 f16 或 g 扩展精度浮点数
    complex64, complex128, complex256 c8, c16, c32 分别用两个32位,64位,128位浮点数表示的复数
    bool ? 存储True和False值的布尔类型
    object O python对象类型
    string_ S 固定长度的字符串类型(每个字符一个字节)。例如:要创建一个长度为10的字符串,应使用S10
    unicode_ U 固定长度的Unicode类型(字节数由平台决定)跟字符串的定义方式一样

    NumPy比Python内置的数据类型多得多,这是为了能够高效处理海量数据而设计的。例如:int8数据类型比默认int64数据类型更节省内存空间。

    注意: 浮点数(如float32和flost64)只能表示近似的分数值。在复杂计算中,可能会积累一些浮点错误,因此比较操作只能在一定小数位以内有效。

    2. size

    获取数组中元素总数

    import numpy as np
    
    n1 = np.array([[1, 3, 5], [2, 4, 6]])
    
    n1
    # 结果
    array([[1, 3, 5],
          [2, 4, 6]])
    
    n1.size
    # 结果 6
    

    3. ndim

    获取数组的维度

    import numpy as np
    
    n1 = np.array([[[1, 3, 5], [2, 4, 6]]])
    
    n1
    # 结果
    array([[[1, 3, 5],
            [2, 4, 6]]])
    
    n1.ndim
    # 结果 
    3
    

    4. shape

    获取数组的形状

    import numpy as np
    
    n1 = np.array([[[1, 3, 5], [2, 4, 6]]])
    
    n1.shape
    # 结果,返回一个元祖。一块,每块2行3列
    (1, 2, 3)
    

    对于形状改变的操作,可见下面第五章。

    5. itemsize

    数组中每个元素所占的字节大小

    import numpy as np
    
    n1 = np.array([[[1, 3, 5], [2, 4, 6]]])
    
    n1.itemsize
    # 结果。默认元素类型int32,一个字节8位,则占32/8=4个字节
    4
    

    四、 数组对象的操作

    1. 基本操作

    1.1 运算

    数组不用编写循环,即可对数据执行批量操作。这通常就叫做矢量化(vectorization)。数组之间的任何算术运算,都会将运算运用到元素级。

    (1). 相等形状数组间,加减乘除四则运算

    arr1 = np.array([1, 2, 3, 4])
    arr2 = np.array([2, 2, 5, 5])
    print(arr1+arr2)
    print(arr1-arr2)
    print(arr1*arr2)
    print(arr1/arr2)
    
    # 打印
    [3, 4, 8, 9]
    [-1, 0, -2, -1]
    [ 2,4, 15, 20]
    [0.5, 1., 0.6, 0.8]
    

    (2). 大小不等的数组间的运算
    数组大小不等之间的运算叫做:广播(broadcasting),可以参考链接详细了解。

    arr1 = np.array([1, 2, 3, 4])
    arr3 = np.array([4])
    print(arr1+arr3)
    print(arr1-arr3)
    print(arr1*arr3)
    print(arr1/arr3)
    
    [5, 6, 7, 8]
    [-3, -2, -1,  0]
    [ 4,  8, 12, 16]
    [0.25, 0.5,  0.75, 1.  ]
    

    1.2 删除

    用法:

    np.delete(arr, obj, axis=None)
    arr    - 待操作的数组
    obj    - 待删除的元素的索引
    axis   - 方向。如果“axis”为空,则将“obj”应用于扁平数组。
    

    例子:

    arr = np.array([[1,2,3,4], [5,6,7,8], [9,10,11,12]])
    # 打印
    array([[ 1,  2,  3,  4],
           [ 5,  6,  7,  8],
           [ 9, 10, 11, 12]])
    # 删除操作
    np.delete(arr, [1,3,5], None)
    # 结果
    array([ 1,  3,  5,  7,  8,  9, 10, 11, 12])
    

    1.3 插入

    用法1:指定位置插入

    np.insert(arr, obj, values, axis=None)
    arr    - 待操作的数组
    obj    - 待插入的索引位置
    values - 待插入的值
    axis   - 方向。如果“axis”为空,则将“obj”应用于扁平数组。
    

    例子1:

    a = np.array([[1, 1], [2, 2], [3, 3]])
    # print
    array([[1, 1],
           [2, 2],
           [3, 3]])
    # 插入
    np.insert(a, 1, 5, axis=1)
    # 结果
    array([[1, 5, 1],
           [2, 5, 2],
           [3, 5, 3]])
    

    用法2:向后插入

    np.append(arr, values, axis=None)
    arr    - 待操作的数组
    values - 待插入的值
    axis   - 方向。如果“axis”为空,则将“obj”应用于扁平数组。
    

    例子2:

    np.append([1, 2, 3], [[4, 5, 6], [7, 8, 9]])
    # 结果
    array([1, 2, 3, 4, 5, 6, 7, 8, 9])
    

    当轴指定时,values值的形状shape属性必须匹配前面的数组arr

    ### 1.
    # 形状匹配时
    np.append([[1, 2, 3], [4, 5, 6]], [[7, 8, 9]], axis=0)
    # 结果正确
    array([[1, 2, 3],
           [4, 5, 6],
           [7, 8, 9]])
           
    ### 2.        
    # 形状不匹配时
    np.append([[1, 2, 3], [4, 5, 6]], [7, 8, 9], axis=0)
    # 结果,报错
    Traceback (most recent call last):
    ...
    

    1.4 转换

    要想矩阵转列表,可以使用tolist方法:

    n1.tolist()
    
    # 输出
    [1, 2, 3]
    

    2. 数组对象的索引

    2.1. 普通索引

    (1) 取单个索引

    用法1: n1[行][列](看成2个一维数组法)

    注意:这个n[ ][ ]的用法不是严格的表示n[行][列],只是便于记忆。因为我们可以拆开来看:一个二维数组,n[1]表示第二行,此时结果已经是一维数组了,并没有行与列之分,再来个[2],则单纯的指一维数组的索引。

    import numpy as np
    
    n1 = np.random.randint(2, 10, size=(4, 4))
    
    n1
    # 结果
    array([[8, 2, 3, 4],
           [3, 5, 3, 9],
           [3, 9, 9, 9],
           [3, 2, 5, 5]])
    
    n1[1]
    # 结果
    array([3, 5, 3, 9])
    
    n1[1][2]
    # 结果
    3
    

    用法2:n1[行, 列](坐标点法)
    注意:这个n[ , ]按照坐标点来理解,以点为基准,即行与列一一匹配对应,如(行,列),这样理解后面的列表和切片比较方便。

    import numpy as np
    
    n1 = np.random.randint(2, 10, size=(4, 4))
    
    n1
    # 结果
    array([[8, 2, 3, 4],
           [3, 5, 3, 9],
           [3, 9, 9, 9],
           [3, 2, 5, 5]])
    
    n1[1, 2]
    # 结果
    3
    

    (2) 取多行索引

    import numpy as np
    
    n1 = np.random.randint(2, 10, size=(4, 4))
    
    n1
    # 结果
    array([[8, 2, 3, 4],
           [3, 5, 3, 9],
           [3, 9, 9, 9],
           [3, 2, 5, 5]])
    

    n1[ [行索引列表] ]:通过索引列表获取几行:

    n1[[1,3]]
    # 结果 取n1[1], n1[3]
    array([[3, 5, 3, 9],
           [3, 2, 5, 5]])
    

    n1[ [行索引列表], [列索引列表] ]:每个行与列一一对应
    [ , ]内,元素为列表即:多个不同的、无序的(行,列),…(行,列),[ , ]内为切片即:从(行,列)递增到(行,列)。

    n1[[1, 3],[0, 2]]
    # 结果 取n1[1][0], n1[3][2],等同于坐标点(1, 0)和(0, 2)
    array([3, 5])
    

    2.2 布尔索引(条件索引)

    定义数组:

    import numpy as np
    
    n1 = np.random.randint(2, 10, size=(4, 4))
    
    n1
    # 结果
    array([[8, 2, 3, 4],
           [3, 5, 3, 9],
           [3, 9, 9, 9],
           [3, 2, 5, 5]])
    

    建立条件:

    condition = n1<5
    condition
    # 结果 小于5为True,否则为False
    array([[False,  True,  True,  True],
           [ True, False,  True, False],
           [ True, False, False, False],
           [ True,  True, False, False]])
    

    条件筛选:

    n1[condition]
    # 结果 对应索引为True的保留,为False的去除(原n1不变)
    array([2, 3, 4, 3, 3, 3, 3, 2])
    # 打印
    [2 3 4 3 3 3 3 2]
    

    反向条件筛选:

    # 使用 ~ 符号表示取反,或者逻辑非 np.logical_not
    n1[~condition]
    或者
    n1[np.logical_not(condition)]
    # 结果 对应索引为True的保留,为False的去除(原n1不变)
    array([2, 3, 4, 3, 3, 3, 3, 2])
    # 打印
    [8 5 9 9 9 9 5 5]
    

    其他条件符号:
    其中的条件运算可以有:==, !=, >, <, >=, <=, &(与) 和 |(或),同时也有在np模块中,对应的逻辑函数。

    n1[(n1>3) & (n1<7)]
    # 结果
    array([4, 5, 5, 5])
    

    注意:关键字and和or在布尔型数组中无效

    2.3 花式索引

    选出方形索引区域,使用ix_()函数

    例子:

    np.ix_([索引1],[索引2],[索引3])
    
    索引的数量与维度对应,并且,每个索引列表内都是一维的。
    

    例子:

    arr1 = np.array([[8, 2, 3, 4],
           [3, 5, 3, 9],
           [3, 9, 9, 9],
           [3, 2, 5, 5]])
    
    print(arr1[np.ix_([0,2],[1,3])])
    
    # 打印
    [[2 4]
     [9 9]]
    

    3. 数组对象的切片

    切片只能针对用法二:n1[行, 列]

    import numpy as np
    
    n1 = np.random.randint(2, 10, size=(4, 4))
    n1
    # 结果
    array([[7, 4, 3, 6],
           [8, 3, 3, 5],
           [2, 5, 4, 7],
           [6, 8, 4, 8]])
    
    n1[0:2, 1:3]
    # 结果,取第1,2行的第2,3列。注意与n1[[0,1],[1,2]]行列映射的区别
    array([[4, 3],
           [3, 3]])
    

    取一列:

    n1[:, 1]
    # 结果 取第一列
    array([4, 3, 5, 8])
    

    为什么切片对方法一得不到结果?:
    结果会不同,因为前面讲过,[][]这不是真正意义上的[行][列],只是人们便于记忆而错误习惯这样理解,而是应该分开来看,使用连续的中括号 - [][]指定一个值时,应该是n[行][索引];指定多行时,应该是[行][行],而不是[行][列]。

    n1 = np.random.randint(2, 10, size=(4, 4))
    n1
    
    # n1结果
    array([[5, 9, 2, 6],
           [9, 6, 3, 2],
           [8, 3, 5, 7],
           [6, 9, 7, 8]])
    

    切片:

    n1[1:3][1:3]
    

    结果:

    array([[8, 3, 5, 7]])
    

    如何理解呢?
    就像我前面讲的,分开来看,并且结果指多行,对应上面的原理,应该是[行][行],理解如下:

    第一步:

    n2 = n1[1:3]
    n2
    
    # 结果,取出1,2行 (从0行开始)
    array([[9, 6, 3, 2],
           [8, 3, 5, 7]])
    

    第二步:

    n2[1:3]
    
    # 结果,取出1,2行,但是2行没有,则只取出第1行 (从0行开始)
    array([[8, 3, 5, 7]])
    

    4. where条件逻辑函数

    前面使用过条件逻辑表达式,但是还有一种,在处理复杂度高的条件时,更为简便的方法。

    import numpy as np
    
    n1 = np.random.randint(2, 10, size=(4, 4))
    n1
    # 结果
    array([[7, 4, 3, 6],
           [8, 3, 3, 5],
           [2, 5, 4, 7],
           [6, 8, 4, 8]])
    
    

    (1). 使用条件表达式替换值(改变原数组)

    n1[n1>5] = 0
    n1
    # 结果
    array([[0, 4, 3, 0],
           [0, 3, 3, 5],
           [2, 5, 4, 0],
           [0, 0, 4, 0]])
    

    (2). 使用where函数来替换值(不改变原数组)

    np.where(condition, x, y)
    condition  - 判断条件,或者布尔掩码(布尔索引)
    x          - 替换成为的值
    y          - 待替换的数组
    

    若无x和y,则直接返回条件判断结果的索引

    np.where([[True, False], [True, True]],
              [[1, 2], [3, 4]],
              [[9, 8], [7, 6]])
    # 结果
    array([[1, 8],
           [3, 4]])
    

    5. 去掉缺失值

    在函数前使用波浪号~,表示"反义"

    arr = np.array([1,2,3,np.nan,4,5,6,np.nan,9])
    arr
    # 打印arr
    array([ 1.,  2.,  3., nan,  4.,  5.,  6., nan,  9.])
    
    arr[~np.isnan(arr)]
    # 结果
    array([1., 2., 3., 4., 5., 6., 9.])
    

    6. 去除重复值

    对重复的值,删减保留唯一一项

    有对应函数,可以直接删除多余项

    np.random.seed(3)
    n1 = np.random.randint(0,15,size=6)
    n1
    # 打印
    array([10,  8,  9,  3,  8,  8])
    
    rs = np.unique(n1)
    rs
    # 打印
    array([ 3,  8,  9, 10])
    

    7. 去除所有重复值

    对重复的值,全部删除

    无对应函数,需要手动实现

    np.random.seed(45)
    n1 = np.random.randint(0,15,size=(4,4))
    n1
    # 打印 n1
    array([[11, 14,  3, 12],
           [ 0, 13,  5,  3],
           [ 4,  9,  8,  1],
           [14,  5,  9,  6]])
    # un表示所有值的数量
    un = np.unique(n1, return_counts=True)
    # 去除所有重复值,方法1
    un[0][un[1]==1]
    
    # 去除所有重复值,方法2
    np.array(set(n1.flatten().tolist()))
    

    五、 数组形状的操作

    1. reshape方法和resize方法

    import numpy as np
    
    n1 = np.arange(12)
    n1
    # 结果
    array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
    

    (1). reshape方法
    reshape的参数值之积等于一维参数值,例如下面的3*4 = 12

    # 或n1.reshape(3, -1),-1代表贪婪填充,可取的最大值
    n1.reshape(3, 4)
    # 结果 
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11]])
    

    再次打印n1时, n1不改变:

    n1
    array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])
    

    reshape有返回值,不改变n1的原值
    (2). resize方法

    n1.resize(3, 4)
    # 结果

    再次打印n1,n1改变:

    n1
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11]])
    

    resize无返回值,直接改变n1原值

    2. flatten方法和ravel方法

    import numpy as np
    
    n1 = np.random.randint(10,size=(4,4))
    n1
    # 结果
    array([[8, 6, 0, 6],
           [5, 1, 2, 4],
           [9, 5, 9, 2],
           [9, 5, 4, 1]])
    

    (1). flatten方法

    n1.flatten()
    # 结果
    array([8, 6, 0, 6, 5, 1, 2, 4, 9, 5, 9, 2, 9, 5, 4, 1])
    

    再次打印n1:

    n1
    array([[8, 6, 0, 6],
           [5, 1, 2, 4],
           [9, 5, 9, 2],
           [9, 5, 4, 1]])
    

    (2). ravel属性

    n1.ravel()
    # 结果 同上
    array([8, 6, 0, 6, 5, 1, 2, 4, 9, 5, 9, 2, 9, 5, 4, 1])
    

    再次打印n1,同上:

    n1
    array([[8, 6, 0, 6],
           [5, 1, 2, 4],
           [9, 5, 9, 2],
           [9, 5, 4, 1]])
    

    区别:

    n1.flatten()[0] = 100
    n1
    # 不改变原数组的值,重新拷贝一份
    array([[8, 6, 0, 6],
           [5, 1, 2, 4],
           [9, 5, 9, 2],
           [9, 5, 4, 1]])
    
    n1.ravel()[0] = 100
    n1
    # 改变原数组的值,浅拷贝
    array([[100, 6, 0, 6],
           [5, 1, 2, 4],
           [9, 5, 9, 2],
           [9, 5, 4, 1]])
    

    flatten和ravel都有返回值,ravel是浅拷贝,它的地址还是指向原来的数组,改变任意一方,都会受影响;flatten是深拷贝,它已经被分配了新的地址,所以改变自身的值,原值不受影响。

    3. 数组的拼接

    (1). vstack:垂直堆叠
    v是vertical的英文单词缩写,是垂直的意思,所以是进行上下垂直方向上的堆叠,即:垂直堆叠。按照轴的标准看,则是axis=0,即按行拼接,将每一个水平行都堆叠在一起。那么列数必须相等。(注意理解,这并不矛盾)

    import numpy as np
    
    n1 = np.random.randint(10, size=(4, 4))
    n2 = np.random.randint(10, size=(1, 4))
    display(n1, n2)
    
    # 结果
    array([[5, 4, 7, 2],
           [7, 6, 4, 3],
           [7, 2, 5, 7],
           [0, 6, 9, 3]])
    array([[0, 8, 4, 1]])
    
    np.vstack([n1, n2])
    # 结果
    array([[5, 4, 7, 2],
           [7, 6, 4, 3],
           [7, 2, 5, 7],
           [0, 6, 9, 3],
           [0, 8, 4, 1]])
    

    (2). hstack:水平堆叠
    h是horizontal的英文缩写,表示垂直的意思,所以是进行水平方向上的堆叠:即水平堆叠。按照轴的标准看,则是axis=1,即按列拼接,将每一个垂直列都堆叠在一起。那么
    行数必须相等。

    import numpy as np
    
    n1 = np.random.randint(10, size=(4, 4))
    n2 = np.random.randint(10, size=(4, 1))
    display(n1, n2)
    # 结果
    array([[1, 4, 7, 8],
           [2, 6, 7, 3],
           [9, 0, 1, 4],
           [1, 3, 3, 7]])
    array([[4],
           [4],
           [6],
           [4]])
    
    np.hstack([n1, n2])
    # 结果
    array([[1, 4, 7, 8, 4],
           [2, 6, 7, 3, 4],
           [9, 0, 1, 4, 6],
           [1, 3, 3, 7, 4]])
    

    (3). concatenate([], axis)

    import numpy as np
    
    n1 = np.random.randint(10, size=(4, 4))
    n2 = np.random.randint(10, size=(4, 4))
    display(n1, n2)
    # 结果
    array([[3, 5, 4, 6],
           [8, 4, 1, 5],
           [8, 7, 6, 9],
           [5, 3, 7, 6]])
    array([[6, 7, 9, 1],
           [4, 1, 9, 7],
           [6, 4, 0, 6],
           [9, 9, 7, 9]])
    
    np.concatenate([n1, n2])
    # 结果 默认axis=0, 从第一层内容对应开始拼接(np.concatenate([n1, n2], axis=0))
    array([[3, 5, 4, 6],
           [8, 4, 1, 5],
           [8, 7, 6, 9],
           [5, 3, 7, 6],
           [6, 7, 9, 1],
           [4, 1, 9, 7],
           [6, 4, 0, 6],
           [9, 9, 7, 9]])
    
    np.concatenate([n1, n2], axis=1)
    # 结果 从第二层内容对应开始拼接
    array([[3, 5, 4, 6, 6, 7, 9, 1],
           [8, 4, 1, 5, 4, 1, 9, 7],
           [8, 7, 6, 9, 6, 4, 0, 6],
           [5, 3, 7, 6, 9, 9, 7, 9]])
    

    (4). np.c_[a ,b]

    a = np.arange(10).reshape(2, -1)
    b = np.repeat(1, 10).reshape(2, -1)
    # 打印a,b
    array([[0, 1, 2, 3, 4],
           [5, 6, 7, 8, 9]])
    array([[1, 1, 1, 1, 1],
           [1, 1, 1, 1, 1]])
    
    np.c_[a,b]
    # 结果
    array([[0, 1, 2, 3, 4, 1, 1, 1, 1, 1],
           [5, 6, 7, 8, 9, 1, 1, 1, 1, 1]])
    

    4. 数组的分割

    创建一个 6 * 6 的二维数组:

    import numpy as np
    
    n1 = np.random.randint(10, size=(6, 6))
    n1
    # 结果
    array([[9, 1, 9, 5, 7, 9],
           [8, 9, 0, 6, 8, 1],
           [5, 1, 5, 6, 4, 9],
           [3, 2, 1, 9, 8, 8],
           [3, 1, 5, 2, 2, 0],
           [0, 3, 1, 4, 0, 3]])
    

    (1). hsplit:水平方向分成多个水平子数组

    注意:split理解为分离的意思,而不是切割的意思,否则,后面的结果会理解相反。

    要想实现水平方向分离,则需要从列方向进行切割。

    • hsplit(ndarray, x), x指定:均匀分成几部分,不可均分则报错
    np.hsplit(n1, 2)
    # 输出
    [array([[9, 1, 9],
            [8, 9, 0],
            [5, 1, 5],
            [3, 2, 1],
            [3, 1, 5],
            [0, 3, 1]]), array([[5, 7, 9],
            [6, 8, 1],
            [6, 4, 9],
            [9, 8, 8],
            [2, 2, 0],
            [4, 0, 3]])]
    
    • hsplit(ndarray, [x, y]), 用列表代表分割的索引,不一定要均分
    np.hsplit(n1, [2, 4])
    # 结果
    [array([[9, 1],
            [8, 9],
            [5, 1],
            [3, 2],
            [3, 1],
            [0, 3]]), array([[9, 5],
            [0, 6],
            [5, 6],
            [1, 9],
            [5, 2],
            [1, 4]]), array([[7, 9],
            [8, 1],
            [4, 9],
            [8, 8],
            [2, 0],
            [0, 3]])]
    

    (2). vsplit:分成多个垂直子数组

    • vsplit(ndarray, x), x指定:均匀分成几部分,不可均分则报错
    np.vsplit(n1, 2)
    # 输出
    [array([[9, 1, 9, 5, 7, 9],
            [8, 9, 0, 6, 8, 1],
            [5, 1, 5, 6, 4, 9]]), array([[3, 2, 1, 9, 8, 8],
            [3, 1, 5, 2, 2, 0],
            [0, 3, 1, 4, 0, 3]])]
    
    • vsplit(ndarray, [x, y]), 用列表代表分割的索引
    np.vsplit(n1, [2, 4])
    # 结果
    [array([[9, 1, 9, 5, 7, 9],
            [8, 9, 0, 6, 8, 1]]), array([[5, 1, 5, 6, 4, 9],
            [3, 2, 1, 9, 8, 8]]), array([[3, 1, 5, 2, 2, 0],
            [0, 3, 1, 4, 0, 3]])]
    

    (3). split / array_split(array, indicate_or_sections, axis)
    axis指定按照哪一层进行切割,默认从axis=0、第0层为标准进行切割, 即vsplit方法,将垂直方向分成多个垂直子数组

    np.array_split(n1, [1, 4])
    # 结果  9, (8, 5, 3), (3, 0)   或(np.arrat_split(n1, [1, 4], axis=0))
    [array([[9, 1, 9, 5, 7, 9]]), array([[8, 9, 0, 6, 8, 1],
            [5, 1, 5, 6, 4, 9],
            [3, 2, 1, 9, 8, 8]]), array([[3, 1, 5, 2, 2, 0],
            [0, 3, 1, 4, 0, 3]])]
    
    np.arrat_split(n1, [1, 4], axis=1)
    # 结果 9, (1,9,5), (7, 9)
    [array([[9],
            [8],
            [5],
            [3],
            [3],
            [0]]), array([[1, 9, 5],
            [9, 0, 6],
            [1, 5, 6],
            [2, 1, 9],
            [1, 5, 2],
            [3, 1, 4]]), array([[7, 9],
            [8, 1],
            [4, 9],
            [8, 8],
            [2, 0],
            [0, 3]])]
    

    5. 数组的转置

    转置(transpose)是重塑的一种特殊形式。

    import numpy as np
    n1 = np.random.randint(10, size=(3, 6))
    n1
    
    # 结果
    array([[0, 0, 0, 4, 6, 1],
           [1, 3, 1, 7, 8, 1],
           [6, 7, 2, 8, 2, 0]])
    

    (1). ndarray的 T 属性

    n1.T
    # 结果
    array([[0, 1, 6],
           [0, 3, 7],
           [0, 1, 2],
           [4, 7, 8],
           [6, 8, 2],
           [1, 1, 0]])
    

    矩阵相乘,内积(线性代数-列行对应,不可直接 *-元素对应 ):

    n1.dot(n1.T)
    # 结果
    array([[ 53,  77,  44],
           [ 77, 125, 101],
           [ 44, 101, 157]])
    

    (2). transpose方法

    用法:

    array.transpose()
    或
    np.transpose(array)
    

    例子:

    n1.transpose() # 或 np.transpose(n1)
    # 结果
    array([[0, 1, 6],
           [0, 3, 7],
           [0, 1, 2],
           [4, 7, 8],
           [6, 8, 2],
           [1, 1, 0]])
    

    注意: 两个方法类似,不改变原来的数组形状
    进行矩阵转置的目的:便于求标准矩阵

    (3). swapaxes()方法

    接收轴编号,对应轴进行交换

    用法:

    array.swapaxes(axis1, axis2, axis3)
    或
    np.swapaxes(array, axis1, axis2, axis3)
    

    例子:

    arr1 = np.array([[8, 2, 3, 4],
           [3, 5, 3, 9],
           [3, 9, 9, 9],
           [3, 2, 5, 5]])
           
    arr1.swapaxes(0, 1) # 横轴与纵轴进行交换
    # 或者 np.swapaxes(arr1, 0, 1)
    
    # 打印
    [[8 3 3 3]
     [2 5 9 2]
     [3 3 9 5]
     [4 9 9 5]]
    

    六、 通用函数

    通用函数,即ufunc(unusual function),是一种对ndarray对象中的数据执行元素级运算的函数。可以将其看做简单函数的矢量化包装器。许多ufunc都是简单的元素级变体,如sqrt和exp。

    1. 一元函数(unary ufunc)

    函数 描述
    np.abs()、fabs() 绝对值,非复数值可以使用更快的fabs()
    np.sqrt() 开根
    np.square 开方
    np.exp() 计算e^x
    np.log(), np.log10(), np.log20(), np.log1p() 求以自然常数e, 10, 20, (1+x)为底的对数
    np.sign() 将数组中的值标签化,大于0变1,等于0为0,小于0为-1
    np.ceil() 朝着无穷大的方向取整,如3.14变4
    np.floor() 朝着无穷小的方向取整,如3.14变3
    np.rint(), np.round() 返回四舍五入后的值
    np.modf() 将整数和小数分隔开来, 形成两个数组
    np.isnan() 判断是否为nan
    np.isinf() 判断是否是无穷
    np.isfinite() 判断是否是有穷
    cos, cosh, sin, sinh, tan, tanh 普通型和双曲型三角函数
    arccos, arccosh, arcsin, arcsinh, arctan, arctanh 反三角函数和双曲型反三角函数
    np.logical_not() 计算元素not x的真值,同~

    2. 二元函数(binary ufunc)

    函数 描述
    np.add() 相加
    np.subtract() 相减
    np.mutiply() 相乘 (一一对应乘)
    np.dot() 矩阵内积 (按公式乘)
    np.divide() 相除
    np.floor_divide() 向下圆整除法(丢弃余数)
    np.mod() 取余
    np.power(arr,B) 次方,arr内每个元素的B次方
    np.greater(), np.greater_equal(), np.less(), np.less_equal(), np.equal(), np.not_equal() >, >=, <, <=, =, !=
    np.logical_and() & 的函数表达式
    np.logical_or() | 的函数表达式
    np.logical_xor() ^ 的函数表达式
    np.copysign() 将后一个参数符号赋给前一个参数
    np.ix_() 生成一个索引器,用于Fancy indexing(花式索引)

    3. 聚合函数 - 数学与统计方法

    通过数组上一组数学函数,对整个数组或者某个轴向数据进行统计计算。

    下列聚合函数的聚合计算(aggregation,通常叫做约简(reduction))。

    既可以当做数组的实例方法调用(如:arr1.sum()),也可以当做顶级Numpy函数使用(如:np.sum(arr1))。并且在使用的时候可以指定具体哪个轴(axis),计算轴方向上的统计结果。

    函数 NAN安全版本 描述
    np.sum(arr1) np.nansum() 计算元素的和
    np.prod(arr1) np.nanprod() 计算元素的积
    np.mean(arr1) np.nanmean() 计算元素平均值
    np.std(arr1) np.nanstd() 计算元素的标准差
    np.var(arr1) np.nanvar() 计算元素的方差
    np.min(arr1) np.nanmin() 获得元素的最小值
    np.max(arr1) np.nanmax() 获得数组中元素的最大值
    np.argmin(arr1) np.nanargmin() 获得数组中最小值的索引
    np.argmax(arr1) np.nanargmax() 获得最大值的索引
    np.median(arr1) np.nanmedian() 获得元素的中位数
    np.minimum(arr1, arr2) np.fmin() 获得多个数组中元素最小值
    np.maximun(arr1, arr2) np.fmax() 获得多个数组中元素最大值
    np.cumsum() 元素的逐渐累计和数组
    np.cumprod() 元素的逐渐累计积数组

    numpy的sum函数比python内置sum函数效率要高,例如:

    nums = np.random.rand(1000000)
    %timeit sum(nums)
    %timeit np.sum(nums)
    

    sum(nums):
    在这里插入图片描述
    np.sum(nums):
    在这里插入图片描述

    4. 布尔函数- any()和all()

    产生布尔数组的函数。

    np.all(self, axis=None, out=None, keepdims=False)
    np.any(self, axis=None, out=None, keepdims=False)
    

    注意: 有self就代表,不仅可以以Numpy函数调用,也可以以数组实例方法调用。

    不指定轴axis,则默认为操作所有元素,即变成一维来进行操作。

    函数 描述
    np.any() 是否有一个元素为True
    np.all() 是否所有元素为True

    例子:查看所有数组是否都为0。

    np.all(array==0)
    or
    (array==0).all()
    

    5. 生成函数

    部分前面零零散散介绍过了,用法相同。

    函数 描述
    np.array(x) 将输入转化为一个矩阵
    np.arange(start,end,step) 循环创建矩阵
    np.ones(n) 生成n长度的一维全1矩阵
    np.ones_like() 形状与参数相同的一维全1矩阵
    np.zeros(n) 生成n长度的一维全0矩阵
    np.zeros_like(n) 形状与参数相同的一维全1矩阵
    np.empty(n) 生成n长度的一维未初始化的矩阵
    np.eye(n) 创建一个n * n的单位矩阵
    np.mershgrid(ndarray, ndarray,…) 生成一个ndarray * ndarray * …的多维数组
    np.where(cond,ndarray1,ndarray2) 根据条件选取ndarray1或ndarray2
    np.in1d(ndarray,[x,y,…]) 检查ndarray中的元素是否等于[x,y,…]中的一个,返回bool数组

    6. 矩阵函数

    函数 说明
    np.diag(array) 以一维数组的形式返回方阵的对角线(或非对角线)元素
    np.diag([x,y,…]) 将一维数组转化为方阵(非对角线元素为0)
    np.dot(ndarray, ndarray) 矩阵相乘
    np.trace(ndarray) 计算矩阵对角线元素的和
    np.mat / matrix 创建矩阵
    np.bmat(array) 数组变矩阵
    matrix.H 求共轭转置,实部不变,虚部相反
    matrix.I 求逆矩阵(不能是奇异矩阵,即不可逆矩阵)
    matrix.T 求矩阵的转置

    7. 排序函数

    跟Python内置列表类型一样,Numpy数组也可以通过sort方法排序。

    函数 说明
    np.sort(ndarray) 排序,返回副本,默认升序
    np.sort(-ndarray) 降序排序
    np.argsort(ndarray) 返回排序后的下标值

    sort()函数用法:

    np.sort(self, axis=-1, kind='quicksort', order=None)
    
    axis - 沿着那个轴排序。默认为-1,意味着,默认以最内层或最大轴序号为标准排序。
    kind - 排序算法,有'quicksort', 'mergesort', 'heapsort', 'stable'。默认为快速排序。
    # order - 字符串或字符串列表。制定指定排序顺序列表。
    

    例子:

    arr1 = np.random.randint(1, 20, size=12)
    print(arr1) # 排序前
    arr1.sort()
    print(arr1) # 排序后
    print(arr1[int(0.05*len(arr1))]) # 5%分位数
    
    # 打印
    [19 12 15  7 15  9  9 14  7 19 11 14]
    [ 7  7  9  9 11 12 14 14 15 15 19 19]
    7
    

    8. 唯一化和集合逻辑

    arr1 = np.array([3, 9, 7, 3, 1, 5, 8, 1])
    print(np.unique(arr1))  # 唯一值,并排序
    print(np.in1d(arr1, [3, 9, 1]))  # 包含值,则返回对应布尔值
    
    # 打印
    [1 3 5 7 8 9]
    [ True  True False  True  True False False  True]
    
    函数 说明
    np.unique(x) 排除重复元素,并返回有序结果
    np.interset1d(x, y) 返回二者的交集、公共元素,并返回有序结果
    np.union1d(x, y) 返回二者的并集,并返回有序结果
    np.in1d(x, y) 得到一个"x中的元素是否包含y"的布尔型数组
    np.setdiff1d(x, y) 返回二者的差,即在x中而不再y中
    np.setxor1d(x, y) 返回二者的对称差,存在与一个数组中,但是不同时存在于两个数组中,简单说就是异或

    8. 其他补充函数

    函数 说明
    np.linspace(x, y, n) 将制定的[x, y]平均分成n份,即等差数列
    np.take(a, indexs) 从a中根据下标index提取元素
    np.apply_along_axis(func1d, axis,arr) 沿着某个轴执行指定函数(文档有详细例子)
    np.unique(ar, return_index=False, return_inverse=False, return_counts=False, axis=None) 去除数组中的重复元素

    七、 数组文件

    Numpy能够读写磁盘上的文本数据或二进制数据。

    1. 二进制格式保存

    默认情况下,数组是以未压缩的原始二进制格式保存在扩展名为.npy的文件中。

    读写磁盘数组数据的三个主要函数:
    用法:

    # 单文件存储,文件结尾:.npy
    np.save(file, array, allow_pickle=True, fix_imports=True)
    # 多文件压缩存储,文件结尾:.npz
    np.savez(file, *args, **kwds)
    
    # 读取
    np.load(file, mmap_mode=None, allow_pickle=False, fix_imports=True,
             encoding='ASCII')
    

    若文件路径末尾没有主动加上扩展名.npy,则该扩展名会被自动加上。然后就可以通过np.load()读取磁盘上的数组。

    例子:

    (1). 单文件:

    存储:

    arr1 = np.array([3, 9, 7, 3, 1, 5, 8, 1])
    np.save("my_array", arr1)
    

    在这里插入图片描述
    读取:

    print(np.load('my_array.npy'))
    # [3 9 7 3 1 5 8 1]
    

    (2). 多文件:
    存储:

    arr1 = np.array([3, 9, 7, 3, 1, 5, 8, 1])
    arr2 = np.array([1, 2, 3, 4, 5, 6])
    np.savez("my_zip", a=arr1, b=arr2)
    result = np.load('my_zip.npz')
    

    在这里插入图片描述
    读取:

    print(result['b'])
    
    [1 2 3 4 5 6]
    

    2. 文本格式保存

    用法:

    # 存储
    np.savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\n', header='',
                footer='', comments='# ', encoding=None)
    # np.genfromtxt与np.savetxt类似,只不过是面向结构化数组和缺失数据处理
    np.loadtxt(fname, dtype=float, comments='#', delimiter=None,
                converters=None, skiprows=0, usecols=None, unpack=False,
                ndmin=0, encoding='bytes', max_rows=None)
    # savetxt
    fname  -  取的文件名
    X      -  数组对象名
    fmt    - 字符串或者字符串序列,如:(%10.5f),其他复杂格式可参考底层代码。
    delimiter - 列分隔符,一般为','逗号分隔
    newline   - 行分隔符
    header    - 头注,写在文件开头
    footer    - 角注,写在文件结尾
    comments - 标注符号,写在header和footer前面,默认为'#',也可写成'numpy.loadtxt'等。
    encoding - 编码输出文件
    
    # loadtxt
    dtype - 输出文件数据类型,默认为float
    converters - 一个字典,映射列序号给一个函数,该函数可以解析字符串为目标值
    skiprows - 整型。跳过的行,默认为0行
    usecols - 整型或者元组序列。主动选择要读取的列。
    unpack -  返回被转化过的数组。默认False
    ndim -  整型,返回至少该维度的数组
    maxrows - 返回'skiprows'行后,读取'maxrows'行后的内容。默认读取所有行。
    

    例子:

    arr1 = np.array([3, 9, 7, 3, 1, 5, 8, 1])
    np.savetxt("my_txt", arr1)
    

    在这里插入图片描述

    np.loadtxt('my_txt')
    
    # [3. 9. 7. 3. 1. 5. 8. 1.]
    

    以上参数可以自行尝试,深入了解可以结合官方文档。

    八、线性代数

    线性代数(如:矩阵乘法、矩阵分解、行列式以及其他方阵数学等)是任何数组库的重要组成部分。不像某些语言(如:MATLAB),通过*对两个二维数组相乘得到的是一个元素级的积,而不是矩阵点积。因此NumPy提供了一个用于矩阵乘法的dot()函数。

    例子1:
    m行k列的数组 点乘 k行n列的数组 得到一个m行n列的数组。(k必须对应相等)

    x = np.array([[1, 2, 3], [4, 5, 6]])
    y = np.array([[6, 23], [-1, 7], [8, 9]])
    
    print(x.dot(y))
    # np.dot(x, y)
    
    [[ 28  64]
     [ 67 181]]
    

    例子2:
    多维数组乘以一维数组,结果得到一维数组

    np.dot(x, np.ones(3))
    # [6., 5.]
    

    NumPy中有一组标准的矩阵分解运算以及诸如求:逆、行列式等。他们跟MATLAB和R等语言所使用的是相同的行业标准级Fortran库,如:BLAS、LAPACK、Inter MKL等等,它也取决于你的Numpy版本。

    from numpy.linalg import inv, qr
    import numpy as np
    
    X = np.random.randn(5, 5)
    mat = X.T.dot(X)
    print(inv(mat))
    # 逆矩阵
    [[ 2.38676625  0.0383446   1.22607032 -1.22301455  1.0457165 ]
     [ 0.0383446   0.89091613 -0.85883745 -0.98421099  1.40459633]
     [ 1.22607032 -0.85883745  2.17537261  0.88836567 -1.83227867]
     [-1.22301455 -0.98421099  0.88836567  2.70466106 -3.56901905]
     [ 1.0457165   1.40459633 -1.83227867 -3.56901905  5.19884975]]
     
    result = mat.dot(inv(mat))
    print(result)
    # 结果为单位矩阵(矩阵 点乘 它的逆矩阵)
    [[ 1.00000000e+00 -1.35244046e-16 -4.33027096e-16 -9.40317599e-16
       6.35775695e-17]
     [-9.61938278e-17  1.00000000e+00  1.45119917e-16  4.27620132e-16
       1.34304975e-15]
     [-1.96936202e-15 -1.45718601e-15  1.00000000e+00  3.04388831e-15
      -1.89553893e-15]
     [-7.19491779e-17 -3.02262390e-16  8.72327184e-16  1.00000000e+00
      -6.47110058e-16]
     [ 1.21385063e-16 -1.67329489e-16 -4.21602789e-16 -2.27367980e-16
       1.00000000e+00]]
    
    q, r = qr(mat)
    print(r)
    # 上三角矩阵
    [[-3.61408516  0.84443702  3.54093823 -3.47532695 -0.63147377]
     [ 0.         -3.6491614  -2.81565423 -7.12586627 -4.94495531]
     [ 0.          0.         -1.76235213 -5.81463287 -4.72452019]
     [ 0.          0.          0.         -1.50171095 -1.05653428]
     [ 0.          0.          0.          0.          0.14713904]]
    
    print(q)
    # 标准正交列矩阵
    [[-0.85043878 -0.01382966 -0.41096514  0.16368423  0.28439014]
     [-0.05424249 -0.77067525  0.12413786 -0.54821699  0.29523778]
     [ 0.4553698  -0.30573961 -0.80115779  0.23297692  0.05504161]
     [ 0.09014986  0.53724225 -0.35238216 -0.73203806  0.20782411]
     [ 0.24150151  0.15415076  0.22286869  0.28724144  0.88641777]]
    

    常用的np.linalg()函数

    函数 说明
    diag 以一维数组的形式返回方阵的对角线(或非对角线)元素,或将一维数组转换为方阵(非对角线元素为0)
    dot 矩阵乘法
    trace 计算对角线元素和
    det 计算矩阵行列式
    eig 计算方阵的本征值和本征向量
    inv 计算方阵的逆
    pinv 计算方阵的Moore-Penrose伪逆
    qr 计算QR分解
    svd 计算奇异值分解(SVD)
    solve 解线性方程组Ax=b,其中A为一个方阵
    lstsq 计算Ax=b的最小二乘解

    九、随机生成数

    numpy.random模块对Python内置的random模块进行了补充,增加了一些用于高效生成多种概率分布的样本值的函数。

    例子1:
    得到一个符合标准正态分布的4*4样本

    samples = np.random.normal(size=(4,4))
    # 打印
    [[-1.24461343 -0.59702205  0.24199145 -1.91128939]
     [ 0.72805342  0.46096565  0.17278008  0.92695652]
     [-0.24785401  1.82771813 -0.42215406  0.27845425]
     [-0.25153488 -1.71629335  0.50279265 -1.05585743]]
    

    例子2:
    比较Python内置random与NumPy模块的random运行速度

    from random import normalvariate
    N = 1000000
    %timeit samples = [normalvariate(0, 1) for _ in xrange(N)]
    # 1 loops, best of 3:1.33s per loop
    %timeit np.random.normal(size=N)
    # 10 loops, best of 3: 57.7ms per loop
    

    部分numpy.random函数:

    函数 说明
    seed 确定随机数生成器的种子
    permutation 返回一个序列的随机排列
    shuffle 对一个序列就地随机排列
    rand 产生均匀分布的样本值
    randint 给定的上下限范围内随机选取整数
    randn 产生正态分布(平均值为0,标准差为1)的样本值,类似于MATLAB接口
    binomial 产生二项分布的样本值
    normal 产生正态(高斯)分布的样本值
    beta 产生Beta分布的样本值
    chisquare 产生卡方分布的样本值
    gamma 产生Gamma分布的样本值
    uniform 产生在[0, 1)中均匀分布的样本值

    更多具体函数可参考:np.random模块的使用

    参考资料与文档

    参考:
    数据分析三大神器之一:Numpy

    文档:
    NumPy官网
    Numpy中文官网

    修改时间

    第一次修改:2020/5/4

    展开全文
  • Numpy精炼操作大全

    2020-06-17 22:29:00
    Numpy 简介 ​ numpy是进行科学计算的python标准库,尤其在数据分析时,可以说它是大量python数学和科学计算包的基础。 安装 conda install numpy //Anaconda环境 ndarray属性 ​ ndarray表示N维数组对象,数组的...

    Numpy

    简介

    ​ numpy是进行科学计算的python标准库,尤其在数据分析时,可以说它是大量python数学和科学计算包的基础。

    安装

    conda install numpy     //Anaconda环境
    

    ndarray属性

    ndarray表示N维数组对象,数组的维数和每一维数组元素的个数由shape决定,数组的维数称为轴(axes),轴的数量称为秩(rank)。

    numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)
    

    shape :表示数组每个轴元素数量的元组

    a = np.array([1,2,3,4])
    c = np.array([[1,2,3,4],
                  [5,6,7,8],
                  [9,10,11,12]])
    a.shape
    (4,)
    c.shape
    (3,4) 
    

    rank:轴的个数/维度数量

    c.ndim
    2
    

    reshape:改变shape,并不会返回,但注意他们共享内存空间,因此修改任何一个也对另一个产生影响,因此注意新数组的元素个数必须与原数组一样。

    c.shape=2,3,2  //c.reshape(2,3,2)  //  c.reshape((2,3,2))
    array([[[ 1,  2],
            [ 3,  4],
            [ 5,  6]],
    
           [[ 7,  8],
            [ 9, 10],
            [11, 12]]])
    c.reshape(-1,12)
    array([[ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12]])
    

    dtype:数组元素数据类型的对象

    c.dtype
    dtype('int32')
    c.dtype
    
    

    size:元素总个数

    c.size
    12
    

    itemsize:每个元素长度所占字节数

    c.itemsize
    4
    

    data:包含数组实际元素的缓冲区

    a.data
    <memory at 0x000002293742CB88>
    

    创建数组

    numpy.empty(shape, dtype = float, order = 'C')
    #order 有"C"和"F"  分别代表行优先和列优先
    

    普通python序列转换

    ndarr = np.array([1,2,3])  #直接创建
    list = [1,2,3,4]     #list 创建
    tuplt = (1,2,3,4)   #tuple 创建
    ndarr1 = np.array(list)
    ndarr2 = np.array(tuple)
    

    zeros

    np.zeros((3,4))
    array([[0., 0., 0., 0.],
           [0., 0., 0., 0.],
           [0., 0., 0., 0.]])
    

    ones

    np.ones((4,6))
    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.]])
    

    empty

    np.empty((2,3))
    array([[4.24399158e-314, 8.48798317e-314, 1.27319747e-313],
           [1.69759663e-313, 2.12199579e-313, 2.54639495e-313]])
    

    arange

    np.arange(0,12,3)
    array([0, 3, 6, 9])
    

    linspace

    np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
    np.linspace(0,1,10)
    array([0.        , 0.11111111, 0.22222222, 0.33333333, 0.44444444,
           0.55555556, 0.66666667, 0.77777778, 0.88888889, 1.        ])
    

    logspace

    np.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
    np.logspace(0,3,4,base=2)
    array([1., 2., 4., 8.])
    

    在0~1均匀分布的随机数组成的数组

    np.random.random((2,3))
    array([[0.00751748, 0.81284807, 0.86476196],
           [0.51759227, 0.78719195, 0.26068424]])
    

    在整数均匀分布的随机数组成的数组

    np.random.randint(0, 5, (3, 2))
    array([[2, 0],
           [1, 1],
           [0, 0]])
    

    单位矩阵

    np.eye(3)
    array([[1., 0., 0.],
           [0., 1., 0.],
           [0., 0., 1.]])
    

    随机小数数组

    np.random.randn(3,2,3)
    array([[[-0.4760226 , -0.54090915,  1.1947473 ],
            [-1.51931029, -0.61272605,  0.94740362]],
    
           [[-0.2962579 ,  0.26290447,  0.38847889],
            [ 0.22281148,  0.0900214 ,  0.69396055]],
    
           [[ 0.80654318, -1.32299948, -0.39186606],
            [-0.24411807,  0.93703774,  1.14458252]]])
    

    根据已有数组创建

    x = c     #将c的地址传给x  x,c改变元素会相互影响
    x = c.copy() 
    arr = np.arange(12)
    a=arr[3:]
    b=arr[3:-1]
    a[1]=123
    b[2]=234
    print(arr)
    print(id(a),id(b),id(arr[3:]))
    [  0   1   2   3 123 234   6   7   8   9  10  11]
    4545878416 4545878496 4545878576 #虽然地址不一样 但是修改值得话会相互影响 split()一样
    

    形状变化

    拼接

    a = np.array([1,2,3,4])
    b = np.array([5,6,7,8])
    np.concatenate([a,b],axis=0)  #axis代表轴数
    array([1, 2, 3, 4, 5, 6, 7, 8])
    np.vstack((a,b))
    array([[1, 2, 3, 4],
           [5, 6, 7, 8]])
    np.hstack((a,b))
    array([1, 2, 3, 4, 5, 6, 7, 8])
    np.dstack((a,b)) 	
    array([[[1, 5],
            [2, 6],
            [3, 7],
            [4, 8]]])
    

    分裂、切片

    np.split(arr,[])  #按axis切分  注意一定要是[]
    np.hsplit(arr,[])
    np.vsplit(arr,[])
    np.dsplit(arr,[])
    

    一维数组

    x=np.array([[9, 5, 9],
           [9, 9, 8],
           [6, 4, 2]])
    x.ravel()
    array([9, 5, 9, 9, 9, 8, 6, 4, 2])
    

    排序

    x = np.array([3,  1,  2]) 
    np.sort(x,axis=0)
    array([1, 2, 3])
    np.argsort(x,axis=0)
    array([1, 2, 0], dtype=int64)
    

    转置

    A.T
    A.transpose()
    

    广播

    在这里插入图片描述

    索引

    布尔索引

    在这里插入图片描述

    特殊函数

    np.where()

    arr = np.array([[1,2,np.NaN,4],
                    [3,np.NaN,5,6]])
    arr
    array([[ 1.,  2., nan,  4.],
           [ 3., nan,  5.,  6.]])
    np.isnan(arr)
    np.where(np.isnan(arr),0,arr)
    array([[1., 2., 0., 4.],
           [3., 0., 5., 6.]])
    

    np.unique()

    strarr = np.array(['图书','数码','没事','小吃','女装','没事','小吃','没事','女子','女装'])
    np.unique(strarr)
    array(['图书', '女子', '女装', '小吃', '数码', '没事'], dtype='<U2')
    

    运算

    元素运算

    在这里插入图片描述
    在这里插入图片描述

    绝对值

    x = np.array([-2, -1, 0, 1, 2])
    np.absolute(x)
    np.abs(x)
    abs(x)
    array([2, 1, 0, 1, 2])
    

    聚合函数

    np.sum(0)  #求和  0代表第一个轴
    np.min(0)  #最小
    np.max(0)    #最大
    np.cumsum()
    np.cumprod() 
    np.mean(0)  #  
    

    在这里插入图片描述

    矩阵运算

    dot() 数组积运算
    vdot() 向量点积
    inner() 返回一维数组内积
    matmul() 数组矩阵积
    np.dot(A,B) = np.matmul(A,B)  #A B为矩阵
    np.dot(a,b)=np.vdot(a,b)=np.inner(a,b) # a b都为为一维
    

    布尔运算

    a = np.arange(6)
    a<3
    array([ True,  True,  True, False, False, False])
    a[a<3]
    array([0, 1, 2])
    np.count_nonzero(a<3)
    3
    np.sum(a<3)
    3
    np.all(a>5)
    False
    np.any(a>4)
    True
    

    在这里插入图片描述

    运算符 对应函数
    & np.bitwise_and
    | np.bitwise_or
    ^ np.bitwise_xor
    ~ np.bitwise_not
    np.sum((inches>0.5)&(inches<1))
    

    IO文件

    存放

    import numpy as np
    data = np.random.randint(0,8,(3,4)) 
    np.save('data',data)
    np.load('data.npy')
    np.savez('data',data)
    np.load('data.npz')
    np.savetxt('data.csv',data,fmt="%d",delimiter=",")
    np.savetxt("out.txt",data,fmt="%d",delimiter=",") # 改为保存为整数,以逗号分隔
    

    读取

    import numpy as np
    data = np.loadtxt('filename',delimiter=',')  
    data = np.genfromtxt('filename',delimiter=',',encoding='gbk')  //字符变量为nan
    
    展开全文
  • SciPy.org — SciPy.org https://www.scipy.org,网站Documentation——pandas——searchimport numpy as np import pandas as pd import matplotlib as mpl from matplotlib import pyplot as plt————————...
  • import numpy as np 数据可视化 Pandas 的数据可视化使用 matplotlib 为基础组件。更基础的信息可参阅 matplotlib 相关内容。本节主要介绍 Pandas 里提供的比 matplotlib 更便捷的数据可视化操作。 线型图 ...
  • 大家都知道,Matplotlib 是众多 Python 可视化包的鼻祖,也是Python最常用的标准可视化库,其功能非常强大,同时也非常复杂,想要搞明白并非易事。但自从Python进入3.0时代以后,pandas的使用变得更加普及,它的身影...
  • import numpy as np import pandas as pd from matplotlib import pyplot as plt ts=pd.Series(np.random.randn(1000),index=pd.date_range('20000101',periods=1000)) ats=ts.cumsum() ats.describe() O...
  • python之numpy的基本使用

    万次阅读 多人点赞 2017-01-26 14:51:27
    一、numpy概述numpy模块提供了python对N维数组对象的支持:ndarray,ndarray数组中的元素须为同一数据类型,这一点与python的列表是不一样的。numpy支持高级大量的维度数组与矩阵运算,此外也针对数组运算提供大量的...
  • Numpy

    万次阅读 多人点赞 2018-07-26 17:35:56
    Numpy(Numerical Python)是一个开源的、高性能的Python数值计算库为提高运算效率,ndarray数组值的类型默认相同,创建时自动指定默认数据类型(内存占用最大的值类型) 默认浮点类型(float)导包:import numpy as np//...
  •        “实践是检验真理的唯一标准”。...NumPy(Numerical Python) 是 Python 语言的一个扩展程序库。其中提供了许多向量和矩阵操作,能让用户轻松完成最优化、线性代数、积分、
  • numpy.zeros(shape, dtype=float, order='c') 创建指定大小的数组,数组元素以 0 来填充 numpy.random.permutation(x) x为序列或整数,当x为整数时,返回随机排列range(x);当x为序列时,返回x随机排列的序列 ...
  • 使用pip命令安装numpy模块

    万次阅读 2019-07-10 09:12:07
    首先打开cmd后输入:pip install numpy;
  • Anaconda安装numpy

    万次阅读 2019-04-13 11:05:22
    如果Anaconda不安装numpy,程序开始使用import Tensorflow会报错。 解决办法,安装numpy。输入命令提示符,如下, 安装完成即可。
  • pycharm 安装numpy失败的解决办法

    万次阅读 2018-09-26 22:00:00
          pycharm安装numpy失败,问题是 解决办法: 配置系统变量 path 新加 然后在cmd 命令行里添加 之后pycharm里面就有了 numpy
  • Windows下安装numpy

    万次阅读 2018-05-08 22:23:40
    1.安装Python。2.在https://pypi.org/project/numpy/#files下载numpy,要和Python版本对应。比如我的Python是3.4,那么下载的就是:numpy-1.14.3-cp34-none-win_amd64.whl3.放到Python安装目录下的script中:4.执行...
  • NumPy函数库是Python开发环境的一个独立模块,而且大多数Python发行版没有默认安装NumPy数据库,因此在安装Python之后必须单独安装NumPy数据库。 进入Python shell开发环境后输入 from numpy import* 如果出现No ...
  • 解决安装numpy仍然报No module named numpy背景解决 背景 在用到numpy的时候,已经pip install numpy无数遍,可就是报错,no module named numpy 解决 举Clion例,在Clion中需要找到settings-Python Interpreter。...
  • python中Numpy包的安装及使用

    万次阅读 2016-12-17 11:13:51
    以上准备工作准备完毕之后,进行Numpy安装,先进入whl安装包的存放目录。比如在C盘:cd C:\再使用命令行安装:pip install numpy文件名.whl至此,Numpy的安装完成。Numpy使用举例import numpy a
1 2 3 4 5 ... 20
收藏数 63,389
精华内容 25,355
关键字:

numpy