精华内容
下载资源
问答
  • Python NumPy学习

    2018-10-12 12:49:04
    Numpy内部解除PythonGIL(全局解释器锁),运行效率极好,是大量机器学习框架的基础库!    关于GIL请参考博客:http://www.cnblogs.com/wj-1314/p/9056555.html    NumPy的全名为Numeric Pyt...

      NumPy是Python语言的一个扩充程序库。支持高级大量的维度数组与矩阵运算,此外也针对数组运算提供大量的数学函数库。Numpy内部解除了Python的GIL(全局解释器锁),运行效率极好,是大量机器学习框架的基础库!
      
      关于GIL请参考博客:http://www.cnblogs.com/wj-1314/p/9056555.html
      
      NumPy的全名为Numeric Python,是一个开源的Python科学计算库,它包括:
      
      一个强大的N维数组对象ndrray;
      
      比较成熟的(广播)函数库;
      
      用于整合C/C++和Fortran代码的工具包;
      
      实用的线性代数、傅里叶变换和随机数生成函数
      
      1.1  NumPy的优点:
      
      对于同样的数值计算任务,使用NumPy要比直接编写Python代码便捷得多;
      
      NumPy中的数组的存储效率和输入输出性能均远远优于Python中等价的基本数据结构,且其能够提升的性能是与数组中的元素成比例的;
      
      NumPy的大部分代码都是用C语言写的,其底层算法在设计时就有着优异的性能,这使得NumPy比纯Python代码高效得多
      
      当然,NumPy也有其不足之处,由于NumPy使用内存映射文件以达到最优的数据读写性能,而内存的大小限制了其对TB级大文件的处理;此外,NumPy数组的通用性不及Python提供的list容器。因此,在科学计算之外的领域,NumPy的优势也就不那么明显。
      
      二、数组ndarray
      
      NumPy最重要的一个特点就是其N维数组对象(即ndarray),该对象是一个快速而灵活的大数据集容器,该对象由两部分组成:
      
      实际的数据;
      
      描述这些数据的元数据;
      
      Numpy中定义的最重要的对象是成为ndarray的N维数组类型。它描述相同类型的元素集合。可以使用基于零的索引访问集合中的项目。
      
      ndarray中的每个元素在内存中使用相同大小的块。ndarray中每个元素是数据类型对象的对象(称为dtype)
      
      大部分的数组操作仅仅是修改元数据部分,而不改变其底层的实际数据。数组的维数称为秩,简单来说就是如果你需要获取数组中一个特定元素所需的坐标数,如a是一个2×3×4的矩阵,你索引其中的一个元素必须给定三个坐标a[x,y,z],故它的维数就是3。而轴可以理解为一种对数组空间的分割,以数组a为例,如果我们以0为轴,那么a可以看成是一个由两个元素构成的数组,其中每个元素都是一个3×4的数组。
      
      我们可以直接将数组看作一种新的数据类型,就像list、tuple、dict一样,但数组中所有元素的类型必须是一致的,Python支持的数据类型有整型、浮点型以及复数型,但这些类型不足以满足科学计算的需求,因此NumPy中添加了许多其他的数据类型,如bool、inti、int64、float32、complex64等。同时,它也有许多其特有的属性和方法。
      
      官方解释:
      
      + View Code
      
      2.1   常用ndarray属性:
      
      dtype        描述数组元素的类型
      
      shape       以tuple表示的数组形状
      
      ndim         数组的维度
      
      size           数组中元素的个数
      
      itemsize    数组中的元素在内存所占字节数
      
      T               数组的转置
      
      flat            返回一个数组的迭代器,对flat赋值将导致整个数组的元素被覆盖
      
      real/imag  给出复数数组的实部/虚部
      
      import numpy as np
      
      # 创建简单的列表
      
      a = [1,2,3,4,5,6]
      
      # 讲列表转换为数组
      
      b = np.array(a)
      
      # Numpy查看数组属性
      
      print(b.size)
      
      #6
      
      # 数组形状
      
      print(b.shape)
      
      # (6,)
      
      # 数组维度
      
      print(b.ndim)
      
      # 1
      
      # 数组元素类型
      
      print(b.dtype)
      
      # int32
      
      import numpy as np
      
      a = np.array([1,2,3])
      
      print(a)
      
      # [1 2 3]
      
      # 多于一个维度
      
      a = np.array([[1,  2],  [3,  4]])
      
      print(a)
      
      # [[1 2]
      
      #  [3 4]]
      
      # 最小维度
      
      a = np.array([1,  2,  3,4,5], ndmin =  2)
      
      print(a)
      
      # [[1 2 3 4 5]]
      
      # dtype 参数
      
      a = np.array([1,  2,  3], dtype = complex)
      
      print(a)
      
      # [1.+0.j 2.+0.j 3.+0.j]
      
        ndarray 对象由计算机内存中的一维连续区域组成,带有将每个元素映射到内存块中某个位置的索引方案。 内存块以按行(C 风格)或按列(FORTRAN 或 MatLab 风格)的方式保存元素。
      
      2.2  常用ndarray方法:
      
      reshape(…)                                 返回一个给定shape的数组的副本
      
      resize(…)                                    返回给定shape的数组,原数组shape发生改变
      
      flatten()/ravel()                            返回展平数组,原数组不改变
      
      astype(dtype)                              返回指定元素类型的数组副本
      
      fill()                                              将数组元素全部设定为一个标量值
      
      sum/Prod()                                  计算所有数组元素的和/积
      
      mean()/var()/std()                        返回数组元素的均值/方差/标准差
      
      max()/min()/ptp()/median()          返回数组元素的最大值/最小值/取值范围/中位数
      
      argmax()/argmin()                       返回最大值/最小值的索引
      
      sort()                                           对数组进行排序,axis指定排序的轴;kind指定排序算法,默认是快速排序
      
      view()/copy()                               view创造一个新的数组对象指向同一数据;copy是深复制
      
      tolist()                                          将数组完全转为列表,注意与直接使用list(array)的区别
      
      compress()                                  返回满足条件的元素构成的数组
      
      numpy.reshape:
      
      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.flatten:
      
      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:
      
      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]'''
      
      2.3 数组的创建
      
      numpy中使用array()函数创建数组,array的首个参数一定是一个序列,可以是元组也可以是列表。
      
      2.3.1  一维数组的创建
      
      可以使用numpy中的arange()函数创建一维有序数组,它是内置函数range的扩展版。
      
      In [1]: import numpy as np
      
      In [2]: ls1 = range(www.dfgjpt.com/ 10)
      
      In [3]: list(ls1)
      
      Out[3]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
      
      In [4]: type(ls1)
      
      Out[4]: range
      
      In [5]: ls2 = np.arange(10)
      
      In [6]: list(ls2)
      
      Out[6]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
      
      In [7]: type(ls2)
      
      Out[7]: numpy.ndarray
      
        通过arange生成的序列就不是简简单单的列表类型了,而是一个一维数组。
      
      如果一维数组不是一个规律的有序元素,而是人为的输入,就需要array()函数创建了。
      
      In [8]: arr1 = np.array((1,20,13,28,22))
      
      In [9]: arr1
      
      Out[9]: array([ 1, 20, 13, 28, 22])
      
      In [10]: type(arr1)
      
      Out[10]: numpy.ndarray
      
        上面是由元组序列构成的一维数组。
      
      In [11]: arr2 = np.array([1,1,2,3,5,8,13,21])
      
      In [12]: arr2
      
      Out[12]: array([ 1,  1,  2,  3,  5,  8, 13, 21])
      
      In [13]: type(arr2)
      
      Out[13]: numpy.ndarray
      
        上面是由列表序列构成的一维数组。
      
      2.3.2  二维数组的创建
      
      二维数组的创建,其实在就是列表套列表或元组套元组。
      
      In [14]: arr3 = np.array(((1,1,2,3),(5,8,13,21),(34,55,89,144)))
      
      In [15]: arr3
      
      Out[15]:
      
      array([[  1,   1,   2,   3],
      
      [  5,   8,  13,  21],
      
      [ 34,  55,  89, 144]])
      
        上面使用元组套元组的方式。
      
      In [16]: arr4 = np.array(www.yongshiyule178.com [[1,2,3,4],[5,6,7,8],[9,10,11,12]])
      
      In [17]: arr4
      
      Out[17]:
      
      array([[ 1,  2,  3,  4],
      
      [ 5,  6,  7,  8],
      
      [ 9, 10, 11, 12]])
      
        上面使用列表套列表的方式。
      
      对于高维数组在将来的数据分析中用的比较少,这里关于高维数组的创建就不赘述了,构建方法仍然是套的方式。
      
        上面所介绍的都是人为设定的一维、二维或高维数组,numpy中也提供了几种特殊的数组,它们是:
      
      In [18]: np.ones(3)  #返回一维元素全为1的数组
      
      Out[18]: array([ 1.,  1.,  1.])
      
      In [19]: np.ones([3,4])  #返回元素全为1的3×4二维数组
      
      Out[19]:
      
      array([[ 1.,  1.,  1.,  1.],
      
      [ 1.,  1.,  1.,  1.],
      
      [ 1.,  1.,  1.,  1.]])
      
      In [20]: np.zeros(3) #返回一维元素全为0的数组
      
      Out[20]: array([ 0.,  0.,  0.])
      
      In [21]: np.zeros([3,4]) #返回元素全为0的3×4二维数组
      
      Out[21]:
      
      array([[ 0.,  0.,  0.,  0.],
      
      [ 0.,  0.,  0.,  0.],
      
      [ 0.,  0.,  0.,  0.]])
      
      In [22]: np.empty(3) #返回一维空数组
      
      Out[22]: array(www.00534.cn[ 0.,  0.,  0.])
      
      In [23]: np.empty([3,4]) #返回3×4二维空数组
      
      Out[23]:
      
      array([[ 0.,  0.,  0.,  0.],
      
      [ 0.,  0.,  0.,  0.],
      
      [ 0.,  0.,  0.,  0.]])
      
      2.3.3  ones函数
      
      返回特定大小,以1填充的新数组
      
      >>> import numpy as np
      
      >>> a=np.ones(3);a
      
      array([ 1.,  1.,  1.])
      
      >>> b=np.ones(www.06640.cn(3,2));b
      
      array([[ 1.,  1.],
      
      [ 1.,  1.],
      
      [ 1.,  1.]])
      
      2.3.4  zeros函数
      
      返回特定大小,以0填充的新数组。
      
      官方库的解释:
      
      def zeros(shape, dtype=None, order='C'): # real signature unknown; restored from __doc__
      
      """
      
      zeros(shape, dtype=float, order='C')
      
      Return a new array of given shape and type, filled with zeros.
      
      Parameters
      
      ----------
      
      shape : int or tuple of ints
      
      Shape of the new www.tianzunyule178.com array, e.g., ``(2, 3)`` or ``2``.
      
      dtype : data-type, optional
      
      The desired data-type for the array, e.g., `numpy.int8`.  Default is
      
      `numpy.float64`.
      
      order : {'C', 'F'}, optional, default: 'C'
      
      Whether to store multi-dimensional data in row-major
      
      (C-style) or column-major (Fortran-style) order in
      
      memory.
      
      Returns
      
      -------
      
      out : ndarray
      
      Array of zeros with the given shape, dtype, and order.
      
      See Also
      
      --------
      
      zeros_like : Return an array of zeros with shape and type of input.
      
      empty : Return a new uninitialized array.
      
      ones : Return a new array setting values to one.
      
      full : Return a new array of given shape filled with value.
      
      Examples
      
      --------
      
      >>> np.zeros(5)
      
      array([ 0.,  0.,  0.,  0.,  0.])
      
      >>> np.zeros((5,), dtype=int)
      
      array([0, 0, 0, 0, 0])
      
      >>> np.zeros((2, 1))
      
      array([[ 0.],
      
      [ 0.]])
      
      >>> s = (2,2)
      
      >>> np.zeros(s)
      
      array([[ 0.,  0.],
      
      [ 0.,  0.]])
      
      >>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype
      
      array([(0, 0), (0, 0)],
      
      dtype=[('x', '<i4'), ('y', '<i4')])
      
      """
      
      pass
      
      numpy.zeros(shape, dtype=float, order=’C’)
      
      参数:
      
      shape:int或ints序列
      
      新数组的形状,例如(2,3 )或2。
      
      dtype:数据类型,可选
      
      数组的所需数据类型,例如numpy.int8。默认值为 numpy.float64。
      
      order:{'C','F'},可选
      
      是否在存储器中以C或Fortran连续(按行或列方式)存储多维数据。
      
      返回:
      
      1
      
      2
      
      out:ndarray
      
      具有给定形状,数据类型和顺序的零数组。
      
      >>> c=np.zeros(3)
      
      >>> c
      
      array([ 0.,  0.,  0.])
      
      >>> d=np.zeros((2,3));d
      
      array([[ 0.,  0.,  0.],
      
      [ 0.,  0.,  0.]])
      
      #d=np.zeros(2,3)会报错,d=np.zeros(3,dtype=int)来改变默认的数据类型
      
      2.3.5  eye&identity函数
      
      >>> e=np.eye(3);e
      
      array([[ 1.,  0.,  0.],
      
      [ 0.,  1.,  0.],
      
      [ 0.,  0.,  1.]])
      
      >>> e=np.eye(3,2);e
      
      array([[ 1.,  0.],
      
      [ 0.,  1.],
      
      [ 0.,  0.]])
      
      >>> e=np.eye(3,1);e
      
      array([[ 1.],
      
      [ 0.],
      
      [ 0.]])
      
      >>> e=np.eye(3,3);e
      
      array([[ 1.,  0.,  0.],
      
      [ 0.,  1.,  0.],
      
      [ 0.,  0.,  1.]])
      
      >>> e=np.eye(3,3,1);e
      
      array([[ 0.,  1.,  0.],
      
      [ 0.,  0.,  1.],
      
      [ 0.,  0.,  0.]])
      
      e=np.eye(3,3,2);e
      
      array([[ 0.,  0.,  1.],
      
      [ 0.,  0.,  0.],
      
      [ 0.,  0.,  0.]])
      
      >>> e=np.eye(3,3,3);e
      
      array([[ 0.,  0.,  0.],
      
      [ 0.,  0.,  0.],
      
      [ 0.,  0.,  0.]])
      
      >>> e=np.eye(3,3,4);e
      
      array([[ 0.,  0.,  0.],
      
      [ 0.,  0.,  0.],
      
      [ 0.,  0.,  0.]])
      
      >>> p=np.identity(4);p
      
      array([[ 1.,  0.,  0.,  0.],
      
      [ 0.,  1.,  0.,  0.],
      
      [ 0.,  0.,  1.,  0.],
      
      [ 0.,  0.,  0.,  1.]])
      
      >>> p=np.identity(4,3);p  #会报错
      
      >>> p=np.identity((4,3));p  #会报错
      
      2.3.6 empty函数
      
      它创建指定形状和dtype的未初始化数组。它使用以下构造函数:
      
      1
      
      numpy.empty(shape, dtype = float, order = 'C')
      
        注意:数组为随机值,因为他们未初始化。
      
      import numpy as np
      
      x = np.empty([3,2], dtype =  int)
      
      print(x)
      
      # [[1762    0]
      
      #  [   0    0]
      
      #  [   0    0]]
      
      >>> a=np.empty(3);a
      
      array([  1.60091154e-163,   1.12069303e-258,   3.23790862e-318])
      
      >>> a=np.empty((3,3));a
      
      array([[  1.57741456e-284,   1.57680914e-284,   1.56735002e-163],
      
      [  1.56205068e-163,   1.62511438e-163,   1.21880041e+171],
      
      [  1.57757869e-052,   7.34292780e+223,   4.71235856e+257]])
      
      2.3.7 ones_like  zero_like   empy_like函数
      
      >>> a=np.array([[[1,2],[1,2]],[[1,2],[1,2]],[[1,2],[1,2]]])
      
      >>> a.shape
      
      (3, 2, 2)
      
      >>> b=np.ones_like(a)
      
      >>> b
      
      array([[[1, 1],
      
      [1, 1]],
      
      [[1, 1],
      
      [1, 1]],
      
      [[1, 1],
      
      [1, 1]]])
      
      >>> b=np.zeros_like(a);b
      
      array([[[0, 0],
      
      [0, 0]],
      
      [[0, 0],
      
      [0, 0]],
      
      [[0, 0],
      
      [0, 0]]])
      
      >>> a=np.array([[[1,2],[1,2]],[[1,2],[1,2]],[[1,2],[1,2]]])
      
      >>> b=np.empty_like(a);b
      
      array([[[39125057, 40012256],
      
      [81313824, 81313856]],
      
      [[       0,        0],
      
      [       0,        0]],
      
      [[       0,        0],
      
      [       0,        0]]])
      
      #注意,shape和dtype均复制
      
      三,Numpy数据类型
      
      NumPy 支持比 Python 更多种类的数值类型。 下表显示了 NumPy 中定义的不同标量数据类型。
      
      序号    数据类型及描述
      
      1.    bool_存储为一个字节的布尔值(真或假)
      
      2.    int_默认整数,相当于 C 的long,通常为int32或int64
      
      3.    intc相当于 C 的int,通常为int32或int64
      
      4.    intp用于索引的整数,相当于 C 的size_t,通常为int32或int64
      
      5.    int8字节(-128 ~ 127)
      
      6.    int1616 位整数(-32768 ~ 32767)
      
      7.    int3232 位整数(-2147483648 ~ 2147483647)
      
      8.    int6464 位整数(-9223372036854775808 ~ 9223372036854775807)
      
      9.    uint88 位无符号整数(0 ~ 255)
      
      10.    uint1616 位无符号整数(0 ~ 65535)
      
      11.    uint3232 位无符号整数(0 ~ 4294967295)
      
      12.    uint6464 位无符号整数(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等。
      
      3.1 数据类型对象(dtype)
      
      数据类型对象描述了对应于数组的固定内存块的解释,取决于以下方面:
      
      数据类型(整数、浮点或者 Python 对象)
      
      数据大小
      
      字节序(小端或大端)
      
      在结构化类型的情况下,字段的名称,每个字段的数据类型,和每个字段占用的内存块部分。
      
      如果数据类型是子序列,它的形状和数据类型。
      
      字节顺序取决于数据类型的前缀<或>。<意味着编码是小端(最小有效字节存储在最小地址中)。>意味着编码是大端(最大有效字节存储在最小地址中)。
      
      dtype语法构造:
      
      1
      
      numpy.dtype(object, align, copy)
      
      参数为:
      
      Object:被转换为数据类型的对象。
      
      Align:如果为true,则向字段添加间隔,使其类似 C 的结构体。
      
      Copy: 生成dtype对象的新副本,如果为flase,结果是内建数据类型对象的引用。
      
      示例:
      
      # 使用数组标量类型
      
      import numpy as np
      
      dt = np.dtype(np.int32)
      
      print(dt)
      
      # int32
      
      # int8,int16,int32,int64 可替换为等价的字符串 'i1','i2','i4',以及其他。
      
      dt = np.dtype('i4')
      
      print(dt)
      
      # int32
      
      # 使用端记号
      
      dt = np.dtype('>i4')
      
      print(dt)
      
      # >i4
      
      # 首先创建结构化数据类型。
      
      dt = np.dtype([('age',np.int8)])
      
      print(dt)
      
      # [('age', 'i1')]
      
      # 现在将其应用于 ndarray 对象
      
      dt = np.dtype([('age',np.int8)])
      
      a = np.array([(10,),(20,),(30,)], dtype = dt)
      
      print(a)
      
      # [(10,) (20,) (30,)]
      
      # 文件名称可用于访问 age 列的内容
      
      dt = np.dtype([('age',np.int8)])
      
      a = np.array([(10,),(20,),(30,)], dtype = dt)
      
      print(a['age'])
      
      # [10 20 30]
      
      四,Numpy 切片和索引
      
      ndarray对象的内容可以通过索引或切片来访问和修改,就像python的内置容器对象一样。
      
      nadarray 对象中的元素遵循基于零的索引,有三种可用的索引方法类型:字段访问,基础切片和高级索引。
      
      基本切片是Python中基本切片概念到n维的扩展,通过start,stop和step参数提供给内置函数的slice函数来构造一个Python slice对象,此slice对象被传递给数组来提取数组的一部分。
      
      练习:
      
      import numpy as np
      
      a = np.arange(10)
      
      print(a)
      
      # [0 1 2 3 4 5 6 7 8 9]
      
      s = slice(2,7,2)
      
      print(s)
      
      # slice(2, 7, 2)
      
      print(a[s])
      
      # [2 4 6]
      
      b = a[2:7:2]
      
      print(b)
      
      # [2 4 6]
      
      # 对单个元素进行切片
      
      b = a[5]
      
      print(b)
      
      # 5
      
      # 对始于索引的元素进行切片
      
      print(a[2:])
      
      # [2 3 4 5 6 7 8 9]
      
      # 对索引之间的元素进行切片
      
      print(a[2:5])
      
      # [2 3 4]
      
      # 二维数组
      
      # 最开始的数组
      
      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-IO
      
      ndarray对象可以保存到磁盘文件并从磁盘文件加载,可用的IO功能有:
      
      load()和save() 函数处理Numpy 二进制文件(带npy扩展名)。
      
      loadtxt() 和savetxt() 函数处理正常的文本文件。
      
      Numpy为ndarray对象引入了一个简单的文件格式,这个npy文件在磁盘文件中,存储重建ndarray所需的数据,图形,dtype和其他信息,以便正确获取数组,即使该文件在具有不同架构的一台机器上。
      
      numpy.save()
      
      此函数是讲文件输入数组存储在具有npy扩展名的磁盘文件中。
      
      1
      
      2
      
      3
      
      import numpy as np
      
      a = np.array([1,2,3,4,5])
      
      np.save('outfile',a)
      
      为了从outfile.npy重建数组,请使用load()函数。
      
      1
      
      2
      
      3
      
      4
      
      import numpy as np
      
      b = np.load('outfile.npy')
      
      print(b)
      
      # [1 2 3 4 5]
      
      save()和load()函数接受一个附加的布尔参数allow_pickles。Python中的pickle用在保存到磁盘文件或者从磁盘文件读取之前,对对象进行序列化和反序列化。
      
      savetxt()
      
      以简单文本文件格式存储和获取数组数据,通过savetxt()和loadtxt()函数来完成的。
      
      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中的ndarray与array的区别、不同
      
      答:Well, np.array is just a convenience function to create an ndarray, it is not a class itself.
      
      (嗯,np.array只是一个便捷的函数,用来创建一个ndarray,它本身不是一个类)
      
      You can also create an array using np.ndarray, but it is not the recommended way. From the docstring of np.ndarray:
      
      (你也能够用np.ndarray来创建,但这不是推荐的方式。来自np.ndarray的文档:)

    展开全文
  • Python NumPy学习总结

    2018-10-12 11:57:00
    一、NumPy简介 ...  NumPy是Python语言的一个扩充程序库。...Numpy内部解除了CPython的GIL(全局解释器锁),运行效率极好,是大量机器学习框架的基础库!  关于GIL请参考博客:http://www.cnblogs.com/wj-1314/...

    一、NumPy简介

      其官网是:http://www.numpy.org/

      NumPy是Python语言的一个扩充程序库。支持高级大量的维度数组与矩阵运算,此外也针对数组运算提供大量的数学函数库。Numpy内部解除了CPython的GIL(全局解释器锁),运行效率极好,是大量机器学习框架的基础库!

      关于GIL请参考博客:http://www.cnblogs.com/wj-1314/p/9056555.html

    NumPy的全名为Numeric Python,是一个开源的Python科学计算库,它包括:

    • 一个强大的N维数组对象ndrray;
    • 比较成熟的(广播)函数库;
    • 用于整合C/C++和Fortran代码的工具包;
    • 实用的线性代数、傅里叶变换和随机数生成函数

     NumPy的优点:

    • 对于同样的数值计算任务,使用NumPy要比直接编写Python代码便捷得多;
    • NumPy中的数组的存储效率和输入输出性能均远远优于Python中等价的基本数据结构,且其能够提升的性能是与数组中的元素成比例的;
    • NumPy的大部分代码都是用C语言写的,其底层算法在设计时就有着优异的性能,这使得NumPy比纯Python代码高效得多

             当然,NumPy也有其不足之处,由于NumPy使用内存映射文件以达到最优的数据读写性能,而内存的大小限制了其对TB级大文件的处理;此外,NumPy数组的通用性不及Python提供的list容器。因此,在科学计算之外的领域,NumPy的优势也就不那么明显。

       关于Python Numpy矩阵的用法总结请参考博文:https://www.cnblogs.com/wj-1314/p/10244807.html

    二,numpy保存二进制文件(.npy/.npz)

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

    •   load()和save() 函数处理Numpy 二进制文件(带npy扩展名)。
    •   loadtxt() 和savetxt() 函数处理正常的文本文件。

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

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

    1,numpy.save

      保存一个数组到一个二进制的文件中,保存格式是.npy

      参数介绍:

    numpy.save(file, arr, allow_pickle=True, fix_imports=True)
    
    file:文件名/文件路径
    arr:要存储的数组
    allow_pickle:布尔值,允许使用Python pickles保存对象数组(可选参数,默认即可)
    fix_imports:为了方便Pyhton2中读取Python3保存的数据(可选参数,默认即可)
    

      举例说明:

    >>> import numpy as np 
    #生成数据 
    >>> x=np.arange(10) 
    >>> x 
    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) 
     
    #数据保存 
    >>> np.save('save_x',x) 
     
    #读取保存的数据 
    >>> np.load('save_x.npy') 
    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) 
    

      

    2,numpy.savez

      这个同样是保存数组到一个二进制的文件中,但是厉害的是,它可以保存多个数组到同一个文件中,保存格式为.npz,它们其实就是多个前面np.save的保存的npy,再通过打包(未压缩)的方式把这些文件归到一个文件上,不行你再去解压npz文件就知道自己保存的是多个npy。

      参数介绍:

    numpy.savez(file, *args, **kwds)
    
    file:文件名/文件路径
    *args:要存储的数组,可以写多个,如果没有给数组指定Key,Numpy将默认从'arr_0','arr_1'的方式命名
    kwds:(可选参数,默认即可)
    

      举例说明:

    >>> import numpy as np 
    #生成数据 
    >>> x=np.arange(10) 
    >>> x 
    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) 
    >>> y=np.sin(x) 
    >>> y 
    array([ 0.        ,  0.84147098,  0.90929743,  0.14112001, -0.7568025 , 
           -0.95892427, -0.2794155 ,  0.6569866 ,  0.98935825,  0.41211849]) 
            
    #数据保存 
    >>> np.save('save_xy',x,y) 
     
    #读取保存的数据 
    >>> npzfile=np.load('save_xy.npz') 
    >>> npzfile  #是一个对象,无法读取 
    <numpy.lib.npyio.NpzFile object at 0x7f63ce4c8860> 
     
    #按照组数默认的key进行访问 
    >>> npzfile['arr_0'] 
    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) 
    >>> npzfile['arr_1'] 
    array([ 0.        ,  0.84147098,  0.90929743,  0.14112001, -0.7568025 , 
           -0.95892427, -0.2794155 ,  0.6569866 ,  0.98935825,  0.41211849]) 
    

      更加神奇的是,我们可以不适用Numpy给数组的key,而是自己给数组有意义的key,这样就可以不用去猜测自己加载数据是否是自己需要的。

    #数据保存 
    >>> np.savez('newsave_xy',x=x,y=y) 
     
    #读取保存的数据 
    >>> npzfile=np.load('newsave_xy.npz') 
     
    #按照保存时设定组数key进行访问 
    >>> npzfile['x'] 
    array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) 
    >>> npzfile['y'] 
    array([ 0.        ,  0.84147098,  0.90929743,  0.14112001, -0.7568025 , 
           -0.95892427, -0.2794155 ,  0.6569866 ,  0.98935825,  0.41211849]) 
    

      在深度学习中,我们保存了训练集,验证集,测试集,还包括它们的标签,用这个方式存储起来,要加载什么有什么,文件数量大大减少,也不会到处改文件名。

    3,savetxt()

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

    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()函数接受附加的可选参数,例如页首,页尾和分隔符。

    4,csv文件转化为npy格式

      下面有一个csv文件的数据,我想将其转化为npy格式,数据内容如下:

    cut,flute_1,flute_2,flute_3
    1,31.41635516,19.48369225,21.74806264
    2,34.8927704,23.473047,24.92595987
    3,38.10284657,27.17286849,27.89865916
    4,41.06102301,30.59930868,30.67784802
    5,43.78119133,33.76786983,33.27472071
    6,46.27671037,36.69342355,35.6999933
    7,48.56042098,39.39022937,37.96391852
    8,50.64466037,41.87195302,40.07630017
    9,52.54127629,44.15168423,42.04650728
    

      首先,数据是有索引,序列的,所以我们读取的时候要注意,转化代码如下:

    import pandas as pd
    import numpy as np
    
    file1 = 'Train_A_wear.csv'
    data1 = pd.read_csv(file1,header=0,index_col=0)
    
    np.save('train_A_wear.npy',data1.values)
    data_A_wear = np.load('trainA_wear.npy') 
    

      

    三、数组ndarray

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

      大部分的数组操作仅仅是修改元数据部分,而不改变其底层的实际数据。数组的维数称为秩,简单来说就是如果你需要获取数组中一个特定元素所需的坐标数,如a是一个2×3×4的矩阵,你索引其中的一个元素必须给定三个坐标a[x,y,z],故它的维数就是3。

      我们可以直接将数组看作一种新的数据类型,就像list、tuple、dict一样,但数组中所有元素的类型必须是一致的,Python支持的数据类型有整型、浮点型以及复数型,但这些类型不足以满足科学计算的需求,因此NumPy中添加了许多其他的数据类型,如bool、inti、int64、float32、complex64等。同时,它也有许多其特有的属性和方法。

    3.1   常用ndarray属性:

    • dtype        描述数组元素的类型
    • shape       以tuple表示的数组形状
    • ndim         数组的维度
    • size           数组中元素的个数
    • itemsize    数组中的元素在内存所占字节数
    • T               数组的转置
    • flat            返回一个数组的迭代器,对flat赋值将导致整个数组的元素被覆盖
    • real/imag  给出复数数组的实部/虚部
    • nbytes      数组占用的存储空间
    import numpy as np
    
    # 创建简单的列表
    a = [1,2,3,4,5,6]
    
    # 讲列表转换为数组
    b = np.array(a)
    
    # Numpy查看数组属性
    print(b.size)
    #6
    
    # 数组形状
    print(b.shape)
    # (6,)
    
    # 数组维度
    print(b.ndim)
    # 1
    
    # 数组元素类型
    print(b.dtype)
    # int32
    

     

    import numpy as np
    
    a = np.array([1,2,3])
    print(a)
    # [1 2 3]
    
    # 多于一个维度
    a = np.array([[1,  2],  [3,  4]])
    print(a)
    # [[1 2]
    #  [3 4]]
    
    # 最小维度
    a = np.array([1,  2,  3,4,5], ndmin =  2)
    print(a)
    # [[1 2 3 4 5]]
    
    # dtype 参数
    a = np.array([1,  2,  3], dtype = complex)
    print(a)
    # [1.+0.j 2.+0.j 3.+0.j]
    

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

    3.2  常用ndarray方法

    • reshape(…)                          返回一个给定shape的数组的副本
    • resize(…)                              返回给定shape的数组,原数组shape发生改变
    • flatten()/ravel()                      返回展平数组,原数组不改变
    • astype(dtype)                        返回指定元素类型的数组副本
    • fill()                                        将数组元素全部设定为一个标量值
    • sum/Prod()                            计算所有数组元素的和/积
    • mean()/var()/std()                  返回数组元素的均值/方差/标准差
    • max()/min()/ptp()/median()    返回数组元素的最大值/最小值/取值范围/中位数
    • argmax()/argmin()                  返回最大值/最小值的索引
    • sort()                                      对数组进行排序,axis指定排序的轴;kind指定排序算法,默认是快速排序
    • view()/copy()                          view创造一个新的数组对象指向同一数据;copy是深复制
    • tolist()                                     将数组完全转为列表,注意与直接使用list(array)的区别
    • compress()                             返回满足条件的元素构成的数组

    numpy.reshape:

    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.flatten:

    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:

    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]'''
    

     

    3.3 数组的创建

      numpy中使用array()函数创建数组,array的首个参数一定是一个序列,可以是元组也可以是列表。

    3.3.1  一维数组的创建

      可以使用numpy中的arange()函数创建一维有序数组,它是内置函数range的扩展版。

    In [1]: import numpy as np
    
    In [2]: ls1 = range(10)
    
    In [3]: list(ls1)
    
    Out[3]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    
    In [4]: type(ls1)
    
    Out[4]: range
    
    In [5]: ls2 = np.arange(10)
    
    In [6]: list(ls2)
    
    Out[6]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
    
    In [7]: type(ls2)
    
    Out[7]: numpy.ndarray
    

       通过arange生成的序列就不是简简单单的列表类型了,而是一个一维数组。

    如果一维数组不是一个规律的有序元素,而是人为的输入,就需要array()函数创建了。

    In [8]: arr1 = np.array((1,20,13,28,22))
    
    In [9]: arr1
    
    Out[9]: array([ 1, 20, 13, 28, 22])
    
    In [10]: type(arr1)
    
    Out[10]: numpy.ndarray
    

       上面是由元组序列构成的一维数组。

    In [11]: arr2 = np.array([1,1,2,3,5,8,13,21])    
    
    In [12]: arr2
    
    Out[12]: array([ 1,  1,  2,  3,  5,  8, 13, 21])
    
    In [13]: type(arr2)
    
    Out[13]: numpy.ndarray
    

       上面是由列表序列构成的一维数组。

    3.3.2  二维数组的创建

      二维数组的创建,其实在就是列表套列表或元组套元组。

    In [14]: arr3 = np.array(((1,1,2,3),(5,8,13,21),(34,55,89,144)))
    
    In [15]: arr3
    
    Out[15]:
    
    array([[  1,   1,   2,   3],
    
    [  5,   8,  13,  21],
    
    [ 34,  55,  89, 144]])
    

       上面使用元组套元组的方式。

    In [16]: arr4 = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
    
    In [17]: arr4
    
    Out[17]:
    
    array([[ 1,  2,  3,  4],
    
    [ 5,  6,  7,  8],
    
    [ 9, 10, 11, 12]])
    

       上面使用列表套列表的方式。

      对于高维数组在将来的数据分析中用的比较少,这里关于高维数组的创建就不赘述了,构建方法仍然是套的方式。

       上面所介绍的都是人为设定的一维、二维或高维数组,numpy中也提供了几种特殊的数组,它们是:

    In [18]: np.ones(3)  #返回一维元素全为1的数组
    
    Out[18]: array([ 1.,  1.,  1.])
    
    In [19]: np.ones([3,4])  #返回元素全为1的3×4二维数组
    
    Out[19]:
    
    array([[ 1.,  1.,  1.,  1.],
    
    [ 1.,  1.,  1.,  1.],
    
    [ 1.,  1.,  1.,  1.]])
    
     
    In [20]: np.zeros(3) #返回一维元素全为0的数组
    
    Out[20]: array([ 0.,  0.,  0.])
    
    In [21]: np.zeros([3,4]) #返回元素全为0的3×4二维数组
    
    Out[21]:
    
    array([[ 0.,  0.,  0.,  0.],
    
    [ 0.,  0.,  0.,  0.],
    
    [ 0.,  0.,  0.,  0.]])
    
    In [22]: np.empty(3) #返回一维空数组
    
    Out[22]: array([ 0.,  0.,  0.])
    
    In [23]: np.empty([3,4]) #返回3×4二维空数组
    
    Out[23]:
    
    array([[ 0.,  0.,  0.,  0.],
    
    [ 0.,  0.,  0.,  0.],
    
    [ 0.,  0.,  0.,  0.]])
    

    3.3.3  ones函数

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

    >>> import numpy as np
    >>> a=np.ones(3);a
    array([ 1.,  1.,  1.])
    >>> b=np.ones((3,2));b
    array([[ 1.,  1.],
           [ 1.,  1.],
           [ 1.,  1.]])
    

    3.3.4  zeros函数

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

    官方库的解释:

    def zeros(shape, dtype=None, order='C'): # real signature unknown; restored from __doc__
        """
        zeros(shape, dtype=float, order='C')
        
            Return a new array of given shape and type, filled with zeros.
        
            Parameters
            ----------
            shape : int or tuple of ints
                Shape of the new array, e.g., ``(2, 3)`` or ``2``.
            dtype : data-type, optional
                The desired data-type for the array, e.g., `numpy.int8`.  Default is
                `numpy.float64`.
            order : {'C', 'F'}, optional, default: 'C'
                Whether to store multi-dimensional data in row-major
                (C-style) or column-major (Fortran-style) order in
                memory.
        
            Returns
            -------
            out : ndarray
                Array of zeros with the given shape, dtype, and order.
        
            See Also
            --------
            zeros_like : Return an array of zeros with shape and type of input.
            empty : Return a new uninitialized array.
            ones : Return a new array setting values to one.
            full : Return a new array of given shape filled with value.
        
            Examples
            --------
            >>> np.zeros(5)
            array([ 0.,  0.,  0.,  0.,  0.])
        
            >>> np.zeros((5,), dtype=int)
            array([0, 0, 0, 0, 0])
        
            >>> np.zeros((2, 1))
            array([[ 0.],
                   [ 0.]])
        
            >>> s = (2,2)
            >>> np.zeros(s)
            array([[ 0.,  0.],
                   [ 0.,  0.]])
        
            >>> np.zeros((2,), dtype=[('x', 'i4'), ('y', 'i4')]) # custom dtype
            array([(0, 0), (0, 0)],
                  dtype=[('x', '<i4'), ('y', '<i4')])
        """
        pass
    

     

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

    参数:

    shape:int或ints序列
        新数组的形状,例如(2,3 )或2。
    dtype:数据类型,可选
        数组的所需数据类型,例如numpy.int8。默认值为 numpy.float64。
    order:{'C','F'},可选
    是否在存储器中以C或Fortran连续(按行或列方式)存储多维数据。
    

     返回:

    out:ndarray
        具有给定形状,数据类型和顺序的零数组。
    

     

    >>> c=np.zeros(3)
    >>> c
    array([ 0.,  0.,  0.])
    >>> d=np.zeros((2,3));d      
    array([[ 0.,  0.,  0.],
           [ 0.,  0.,  0.]]) 
    
    #d=np.zeros(2,3)会报错,d=np.zeros(3,dtype=int)来改变默认的数据类型
    

    3.3.5  eye&identity函数

      eye()函数用于生成指定行数的单位矩阵

    >>> e=np.eye(3);e
    array([[ 1.,  0.,  0.],
           [ 0.,  1.,  0.],
           [ 0.,  0.,  1.]])
    >>> e=np.eye(3,2);e
    array([[ 1.,  0.],
           [ 0.,  1.],
           [ 0.,  0.]])
    >>> e=np.eye(3,1);e
    array([[ 1.],
           [ 0.],
           [ 0.]])
    >>> e=np.eye(3,3);e
    array([[ 1.,  0.,  0.],
           [ 0.,  1.,  0.],
           [ 0.,  0.,  1.]])
    >>> e=np.eye(3,3,1);e
    array([[ 0.,  1.,  0.],
           [ 0.,  0.,  1.],
           [ 0.,  0.,  0.]])
    e=np.eye(3,3,2);e
    array([[ 0.,  0.,  1.],
           [ 0.,  0.,  0.],
           [ 0.,  0.,  0.]])
    >>> e=np.eye(3,3,3);e
    array([[ 0.,  0.,  0.],
           [ 0.,  0.,  0.],
           [ 0.,  0.,  0.]])
    >>> e=np.eye(3,3,4);e
    array([[ 0.,  0.,  0.],
           [ 0.,  0.,  0.],
           [ 0.,  0.,  0.]])
    >>> p=np.identity(4);p
    array([[ 1.,  0.,  0.,  0.],
           [ 0.,  1.,  0.,  0.],
           [ 0.,  0.,  1.,  0.],
           [ 0.,  0.,  0.,  1.]])
    >>> p=np.identity(4,3);p  #会报错
    >>> p=np.identity((4,3));p  #会报错
    

     3.3.6 empty函数

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

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

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

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

     

    >>> a=np.empty(3);a
    array([  1.60091154e-163,   1.12069303e-258,   3.23790862e-318])
    >>> a=np.empty((3,3));a
    array([[  1.57741456e-284,   1.57680914e-284,   1.56735002e-163],
           [  1.56205068e-163,   1.62511438e-163,   1.21880041e+171],
           [  1.57757869e-052,   7.34292780e+223,   4.71235856e+257]])
    

    3.3.7 ones_like  zero_like   empy_like函数

    >>> a=np.array([[[1,2],[1,2]],[[1,2],[1,2]],[[1,2],[1,2]]])
    >>> a.shape
    (3, 2, 2)
    >>> b=np.ones_like(a)
    >>> b
    array([[[1, 1],
            [1, 1]],
    
           [[1, 1],
            [1, 1]],
    
           [[1, 1],
            [1, 1]]])
    >>> b=np.zeros_like(a);b
    array([[[0, 0],
            [0, 0]],
    
           [[0, 0],
            [0, 0]],
    
           [[0, 0],
            [0, 0]]])
    >>> a=np.array([[[1,2],[1,2]],[[1,2],[1,2]],[[1,2],[1,2]]])
    >>> b=np.empty_like(a);b
    array([[[39125057, 40012256],
            [81313824, 81313856]],
    
           [[       0,        0],
            [       0,        0]],
    
           [[       0,        0],
            [       0,        0]]])
    #注意,shape和dtype均复制
    

     3.3.8  .T函数

      .T 作用于矩阵,用于求矩阵的转置

    >>myMat=np.mat([[1,2,3],[4,5,6]])
    >>print(myMat)
    >>matrix([[1.,2.,3.]
              [4.,5.,6.]])
    
    
    >>print(myMat.T)
    >>matrix([[1,4],
              [2,5],
              [3,6]])
    

      

    3.3.9  tolist()函数

      tolost()函数用于把一个矩阵转化为list列表

    >>x=np.mat([[1,2,3],[4,5,6]])
    >>print(x)
    >>matrix([[1,2,3],[4,,5,6]])
    >>type(x)
    >>matrix
     
     
    >>x.tolist()
    >>[[1,2,3],[4,5,6]]
    

      

    3.3.10  .I

      .I用于求矩阵的逆矩阵,逆矩阵在计算中是经常要用到的,例如一个矩阵A,求A的逆矩阵B,即存在矩阵B是AB=I(I是单位)

    In [3]: a=mat([[1,2,3],[4,5,6]])
     
    In [4]: a
    Out[4]:
    matrix([[1, 2, 3],
            [4, 5, 6]])
     
     
    In [5]: a.I
    Out[5]:
    matrix([[-0.94444444,  0.44444444],
            [-0.11111111,  0.11111111],
            [ 0.72222222, -0.22222222]])
    In [6]: s=a.I
     
    In [8]: a*s
    Out[8]:
    matrix([[  1.00000000e+00,   3.33066907e-16],
            [  0.00000000e+00,   1.00000000e+00]])
    

      

    3.3.11  .power(x1,x2)

      数组的元素分别求n次方,x2可以是数字,也可以是数组,但是x1和x2的列数要相同。

    >>> x1 = range(6)
    >>> x1
    [0, 1, 2, 3, 4, 5]
    >>> np.power(x1, 3)
    array([  0,   1,   8,  27,  64, 125])
    

      

    >>> x2 = [1.0, 2.0, 3.0, 3.0, 2.0, 1.0]
    >>> np.power(x1, x2)
    array([  0.,   1.,   8.,  27.,  16.,   5.])
    

      

    >>> x2 = np.array([[1, 2, 3, 3, 2, 1], [1, 2, 3, 3, 2, 1]])
    >>> x2
    array([[1, 2, 3, 3, 2, 1],
           [1, 2, 3, 3, 2, 1]])
    >>> np.power(x1, x2)
    array([[ 0,  1,  8, 27, 16,  5],
           [ 0,  1,  8, 27, 16,  5]])
    

      

    3.3.12  reshape() 函数

      一般用法:numpy.arrange(n).reshape(a,b)

      意思:依次生成n个自然数,并且以a行b列的数组形式显示。

    In [1]: 
    np.arange(16).reshape(2,8) #生成16个自然数,以2行8列的形式显示
    Out[1]: 
    array([[ 0,  1,  2,  3,  4,  5,  6,  7],
           [ 8,  9, 10, 11, 12, 13, 14, 15]])
    

      特殊用法:mat(or array).reshape(c,-1)

      必须是矩阵格式或者数组格式,才能使用.reshape(c,-1)函数,表示将此矩阵或者数组重组,以c行d 列的形式表示(-1的作用就在此,自动计算d:d=数组或者矩阵里面所有的元素个数(c,d必须为整数,不然会报错))

    In [2]: arr=np.arange(16).reshape(2,8)
    out[2]:
     
    In [3]: arr
    out[3]:
    array([[ 0,  1,  2,  3,  4,  5,  6,  7],
           [ 8,  9, 10, 11, 12, 13, 14, 15]])
     
    In [4]: arr.reshape(4,-1) #将arr变成4行的格式,列数自动计算的(c=4, d=16/4=4)
    out[4]:
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11],
           [12, 13, 14, 15]])
     
    In [5]: arr.reshape(8,-1) #将arr变成8行的格式,列数自动计算的(c=8, d=16/8=2)
    out[5]:
    array([[ 0,  1],
           [ 2,  3],
           [ 4,  5],
           [ 6,  7],
           [ 8,  9],
           [10, 11],
           [12, 13],
           [14, 15]])
     
    In [6]: arr.reshape(10,-1) #将arr变成10行的格式,列数自动计算的(c=10, d=16/10=1.6 != Int)
    out[6]:
    ValueError: cannot reshape array of size 16 into shape (10,newaxis)
    

     

    3.3.13 np.unique()的用法

      该函数是去除数组中的重复数字,并进行排序之后输出

    a = [2,3,4,1,21,32,32,32,2,1]
    b = [1,2,3,1,2,3]
    c = [[1,2,3],[1,2,3],[2,3,4]]
    resa = np.unique(a)
    resb = np.unique(b)
    resc = np.unique(c)
    print('unique result a is :',resa)
    print('unique result a is :',resb)
    print('unique result a is :',resc)
    '''
    unique result a is : [ 1  2  3  4 21 32]
    unique result a is : [1 2 3]
    unique result a is : [1 2 3 4]
    '''
    

      

    3.3.14  np.argsort()的用法

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

        One dimensional array:一维数组
        
        >>> x = np.array([3, 1, 2])
        >>> np.argsort(x)
        array([1, 2, 0])
        
        Two-dimensional array:二维数组
        
        >>> x = np.array([[0, 3], [2, 2]])
        >>> x
        array([[0, 3],
               [2, 2]])
        
        >>> np.argsort(x, axis=0) #按列排序
        array([[0, 1],
               [1, 0]])
        
        >>> np.argsort(x, axis=1) #按行排序
        array([[0, 1],
               [0, 1]])
    

      举个例子:

    >>> x = np.array([3, 1, 2])
    >>> np.argsort(x) #按升序排列
    array([1, 2, 0])
    >>> np.argsort(-x) #按降序排列
    array([0, 2, 1])
    
    >>> x[np.argsort(x)] #通过索引值排序后的数组
    array([1, 2, 3])
    >>> x[np.argsort(-x)]
    array([3, 2, 1])
    
    另一种方式实现按降序排序:
    
    >>> a = x[np.argsort(x)]
    >>> a
    array([1, 2, 3])
    >>> a[::-1]
    array([3, 2, 1])   
    

      

    3.3.15 np.flatnonzero()

      该函数输入一个矩阵,返回扁平化后矩阵中非零元素的位置(index)

      下面给出一个用法,输入一个矩阵,返回了其中非零元素的位置:

    >>> x = np.arange(-2, 3)
    >>> x
    array([-2, -1,  0,  1,  2])
    >>> np.flatnonzero(x)
    array([0, 1, 3, 4])
    import numpy as np
    d = np.array([1,2,3,4,4,3,5,3,6])
    haa = np.flatnonzero(d == 3)
    print (haa)
    
    [2 5 7]
    

      对向量元素的判断 d == 3,返回了一个和向量等长的由0/1组成的矩阵,然后再调用函数,返回的位置,就是对应要找的元素的位置。

    # Visualize some examples from the dataset.
    # We show a few examples of training images from each class.
    classes = ['plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck'] #类别列表
    num_classes = len(classes) #类别数目
    samples_per_class = 7 # 每个类别采样个数
    for y, cls in enumerate(classes): # 对列表的元素位置和元素进行循环,y表示元素位置(0,num_class),cls元素本身'plane'等
        idxs = np.flatnonzero(y_train == y) #找出标签中y类的位置
        idxs = np.random.choice(idxs, samples_per_class, replace=False) #从中选出我们所需的7个样本
        for i, idx in enumerate(idxs): #对所选的样本的位置和样本所对应的图片在训练集中的位置进行循环
            plt_idx = i * num_classes + y + 1 # 在子图中所占位置的计算
            plt.subplot(samples_per_class, num_classes, plt_idx) # 说明要画的子图的编号
            plt.imshow(X_train[idx].astype('uint8')) # 画图
            plt.axis('off')
            if i == 0:
                plt.title(cls) # 写上标题,也就是类别名
    plt.show() # 显示
    

      

    3.3.16  np.nonzero()

      nonzero函数是numpy中用于得到数组array中非零元素的目录(位置)的函数。

      返回值为元组,两个值分别为两个维度,包含了相应维度上非零元素的目录值。

      只有a中非零元素才会有索引值,那些零值元素没有索引值

      当使用布尔数组直接作为下标对象或者元祖下标对象中有布尔数组时,都相当于用nonzero()讲布尔数组转换成一组整数数组,然后使用整数数组进行下标运算。

      nonzeros(a)返回数组a中值不为零的元素的下标,它的返回值是一个长度为a.ndim(数组a的轴数)的元组,元组的每个元素都是一个整数数组,其值为非零元素的下标在对应轴上的值。例如对于一维布尔数组b1,nonzero(b1)所得到的是一个长度为1的元组,它表示b1[0]和b1[2]的值不为0(False)。

    b = np.array([True,False,True,False])
    b
    array([ True, False,  True, False])
    np.nonzero(b)
    (array([0, 2], dtype=int64),)
    

      对于一个二维数组c,nonzeero(c)所得到的是一个长度为2的元祖,它的第0个元素是数组a中值不为0的元素的第0轴的下标,第一个元素则为第1轴的下标,因此从下面的结果可知b2[0,0]、b[0,2]和b2[1,0]的值不为0:

    c = np.array([[True, False, True], [True, False, False]])
    c
    array([[ True, False,  True],
           [ True, False, False]])
    np.nonzero(c)
    (array([0, 0, 1], dtype=int64), array([0, 2, 0], dtype=int64))
    

     

    3.3.17  np.column_stack(tup)

      np.column_stack(tup)相当于np.concatenate((a1, a2, …), axis=1),对竖轴的数组进行横向的操作。

     官方解释(如果传递的是一个一维数组,则会先将一维数组转化为2维数组):

        Stack 1-D arrays as columns into a 2-D array.
    
        Take a sequence of 1-D arrays and stack them as columns
        to make a single 2-D array. 2-D arrays are stacked as-is,
        just like with `hstack`.  1-D arrays are turned into 2-D columns
        first.
    
        Parameters
        ----------
        tup : sequence of 1-D or 2-D arrays.
            Arrays to stack. All of them must have the same first dimension.
    
        Returns
        -------
        stacked : 2-D array
            The array formed by stacking the given arrays.
    
        See Also
        --------
        stack, hstack, vstack, concatenate
    

      举例说明:

      如果开始传入的是一维数组,首先将一维数组转化为二维数组

    import numpy as np
    
    a = np.array((1, 2, 3))
    b = np.array((2, 3, 4))
    c = np.column_stack((a, b))
    
    print(a)
    print(b)
    print(c)
    # 结果:
    [1 2 3]
    [2 3 4]
    [[1 2]
     [2 3]
     [3 4]]
    

      如果一开始传入的是多维数组,则直接进行拼接操作

    import numpy as np
    
    a = np.array(((1, 2, 3), (4, 3, 2)))
    b = np.array(((2,3,4),(2,12,2)))
    c = np.column_stack((a,b))
    print(a)
    print(b)
    print(c)
    # 结果:
    [[1 2 3]
     [4 3 2]]
    [[ 2  3  4]
     [ 2 12  2]]
    [[ 1  2  3  2  3  4]
     [ 4  3  2  2 12  2]]
    

      

    四,Numpy数据类型

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

    序号数据类型及描述
    1. bool_存储为一个字节的布尔值(真或假)
    2. int_默认整数,相当于 C 的long,通常为int32或int64
    3. intc相当于 C 的int,通常为int32或int64
    4. intp用于索引的整数,相当于 C 的size_t,通常为int32或int64
    5. int8字节(-128 ~ 127)
    6. int1616 位整数(-32768 ~ 32767)
    7. int3232 位整数(-2147483648 ~ 2147483647)
    8. int6464 位整数(-9223372036854775808 ~ 9223372036854775807)
    9. uint88 位无符号整数(0 ~ 255)
    10. uint1616 位无符号整数(0 ~ 65535)
    11. uint3232 位无符号整数(0 ~ 4294967295)
    12. uint6464 位无符号整数(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等。

    4.1 数据类型对象(dtype)

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

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

    • 数据大小

    • 字节序(小端或大端)

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

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

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

    dtype语法构造:

    numpy.dtype(object, align, copy)
    

     参数为:

    Object:被转换为数据类型的对象。 
    
    Align:如果为true,则向字段添加间隔,使其类似 C 的结构体。 
    
    Copy: 生成dtype对象的新副本,如果为flase,结果是内建数据类型对象的引用。
    

     示例:

    # 使用数组标量类型
    import numpy as np
    dt = np.dtype(np.int32)
    print(dt)
    # int32
    
    # int8,int16,int32,int64 可替换为等价的字符串 'i1','i2','i4',以及其他。
    dt = np.dtype('i4')
    print(dt)
    # int32
    
    # 使用端记号
    dt = np.dtype('>i4')
    print(dt)
    # >i4
    
    # 首先创建结构化数据类型。
    dt = np.dtype([('age',np.int8)])
    print(dt)
    # [('age', 'i1')]
    
    # 现在将其应用于 ndarray 对象
    dt = np.dtype([('age',np.int8)])
    a = np.array([(10,),(20,),(30,)], dtype = dt)
    print(a)
    # [(10,) (20,) (30,)]
    
    # 文件名称可用于访问 age 列的内容
    dt = np.dtype([('age',np.int8)])
    a = np.array([(10,),(20,),(30,)], dtype = dt)
    print(a['age'])
    # [10 20 30]
    

     

    五,Numpy 切片和索引

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

      nadarray 对象中的元素遵循基于零的索引,有三种可用的索引方法类型:字段访问,基础切片和高级索引。

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

    练习:

    import numpy as np
    
    a = np.arange(10)
    print(a)
    # [0 1 2 3 4 5 6 7 8 9]
    s = slice(2,7,2)
    print(s)
    # slice(2, 7, 2)
    print(a[s])
    # [2 4 6]
    
    b = a[2:7:2]
    print(b)
    # [2 4 6]
    
    # 对单个元素进行切片
    b = a[5]
    print(b)
    # 5
    
    # 对始于索引的元素进行切片
    print(a[2:])
    # [2 3 4 5 6 7 8 9]
    
    # 对索引之间的元素进行切片
    print(a[2:5])
    # [2 3 4]
    
    
    # 二维数组
    # 最开始的数组
    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与array的区别

      答:Well, np.array is just a convenience function to create an ndarray, it is not a class itself.
    (嗯,np.array只是一个便捷的函数,用来创建一个ndarray,它本身不是一个类)

      You can also create an array using np.ndarray, but it is not the recommended way. From the docstring of np.ndarray:
    (你也能够用np.ndarray来创建,但这不是推荐的方式。来自np.ndarray的文档:)

     numpy函数:shape用法

     

     

    转载于:https://www.cnblogs.com/wj-1314/p/9722794.html

    展开全文
  • 1)Python模块:numpy

    2019-02-25 19:30:46
    numpy是一种开源的数值计算扩展,可用来存储和处理大型矩阵。...底层使用C语言编写,内部解除GIL(全局解释器锁),其对数组的操作速度不受Python解释器的限制,效率远高于纯Python代码。 num...

    http://www.runoob.com/numpy/numpy-dtype.html

    numpy是一种开源的数值计算扩展,可用来存储和处理大型矩阵。比Python自身的嵌套列表(nested list structure)结构要高效的多。专攻数字处理。底层使用C语言编写,内部解除了GIL(全局解释器锁),其对数组的操作速度不受Python解释器的限制,效率远高于纯Python代码。

    numpy一共三块知识:ndarray ufunc   矩阵运算

    NumPy提供了一个N维数组类型ndarray,它描述了相同类型的“items”的集合。

    利用numpy创建的数组,类型都是ndarray。

    img=cv2.imread('D:\\1.jpg')   获取的img类型是ndarray

    Numpy库:

    数据类型:np.

    bool_ 
    int_  intc  intp  int 8  int16  int32  int64  uint8  uint16  uint32  uint64
    float_  float16  float32  float64  
    complex_  complex64  complex128

    数组创建

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

    数组转换

    ndarray.astype, atleast_1d, atleast_2d, atleast_3d, mat

    操作

    array_split, column_stack, concatenate, diagonal, dsplit, dstack, hsplit, hstack, ndarray.item, newaxis, ravel, repeat, reshape, resize, squeeze, swapaxes, take, transpose, vsplit, vstack

    问题

    all, any, nonzero, where

    排列

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

    运算

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

    基础统计

    cov, mean, std, var

    基本线性代数

    cross, dot, outer, linalg.svd, vdot

     

    add,sqrt

    np.around 返回四舍五入后的值,可指定精度。
    around(a, decimals=0, out=None)
    a 输入数组
    decimals 要舍入的小数位数。 默认值为0。 如果为负,整数将四舍五入到小数点左侧的位置
    np.floor  向下取整
    np.ceil 向上取整
    np.where(data > 0.5, data, 0)  满足条件返回data本身,不满足用0代替
    np.hstack((a,b))实现数组横向堆叠, np.column_stack 有点区别
    np.vstack((a,b))实现数组纵向堆叠。
    np.split(a,3)   从左到右,从上到下顺序切3个ndarray
    np.hsplit(a,4) 纵向切成4块
    np.vsplit(a,3) 横向切成3块
    a[:,newaxis]  增加维度

    ndarray的属性:

    ndarray.ndim

      ndarray.ndim表示数组的维度。

    ndarray.shape

      ndarray.shape是一个整型tuple,用来表示数组中的每个维度的大小。例如,对于一个n行和m列的矩阵,其shape为(n,m)。

    ndarray.size

      ndarray.size表示数组中元素的个数,其值等于shape中所有整数的乘积。

    ndarray.dtype

      ndarray.dtype用来描述数组中元素的类型,ndarray中的所有元素都必须是同一种类型,如果在构造数组时,传入的参数不是同一类型的,不同的类型将进行统一转化。除了标准的Python类型外,NumPy额外提供了一些自有的类型,如numpy.int32numpy.int16以及numpy.float64等。

    ndarray.itemsize

      ndarray.itemsize用于表示数组中每个元素的字节大小。

     

    ndarray.sum(axis=0\1 or none)  1 is row  ;0 is column

    ndarray.min(axis=? or none)

    ndarray.max(axis=? or none)

    ndarray.cumsum(axis=? or none)

    ndarray.reshape((m,n)) ;ndarray.reshape((m,-1)) 列自动匹配,这个很重要,一般创建阵列都需要reshape一下,确保格式(2,)表示1维

    ndarray.resize()  区别于reshape,直接更改数组,无返回值

    ndarray.T()

     

    这些完全可以用np.X(ndarray)代替

    数组创建:

    创建数组方法1:
    
    np.int8([[1,2],[3,4]])  8bits,去掉1bit符号位,7位最大127.  
    还有np.int16() .int32() .int64()
    np.float16()  .float32()  .float64()
    
    np.complex64()  .complex128()
    
    创建数组方法2:
    
    a=np.array([[1,2,3],[2,4,3]],dtype=complex)# or int \ float \ np.int8等等
    也可以不指定类型:a=np.array([1,2])
    a=np.ndarray(tuple\list\set)和b=np.array(-)返回的都是ndarray。np.array()内部用[] {} ()都行,但是一般都是用[]
    
    创建方法3:
    
    a = np.zeros((3,4))   两维
    b = np.zeros((2,2,2))  三维
    c = np.ones((3,3))   d = np.ones((3,3), dtype = np.int16)
    e = np.arange(15)   [0,14]  ;f = np.arange(15).reshape(3,5)  ;g = np.arange(0,15,3)  [0,14]步幅为3
                h = np.arange(0,3,0.3)   ;np.arange(9).reshape(3,3)
    h = np.linspace( 0, 2, 9 )  [0,2]之间,平均步幅取9个数   np.linspace( 0, 2*np.pi, 100 )
    a=np.random.randint(min,max,size [] or () or none,dtype=np.int32)   ;b=np.random.random((3,2)) #3X2 [0,1]

    等维数组可进行的运算:  + -  *   /  **     *= +=  -=  /=  ;或者比较:<  > ....a<3 ;a<b

    以上是数值对应相做算法。矩阵乘法:A.dot(B)

    当操作不同类型的数组时,最终的结果数组的类型取决于精度最宽的数组的类型。(即所谓的向上造型)

     

    处理数组:(数组的索引、切片和迭代)

    一维:

    取值兼赋值:

    单值:a[1]=N

    区间值:a[1:2]=N    [1,2)

    跨区间值:a[0:6:2]=N    [0,5]之间元素,步长为2     a[::-1]   颠倒顺序   (0可以省略)

    二、三...维:

    b[1:3:1,3:4:1]=0  中间用,隔开,每一块格式与1维相同。
    

    b[-1倒数第一行

    b[1, :第二行

    数组遍历:

    for row in b:
       
    print(row)
    for element in b.flat:其中flat属性是array中的每个元素的迭代器。
        print(element)

     

    NumPy中,数组的复制有三种方式:

    1. Python通用的地址复制:通过 b = a 复制 a 的值,b 与 a 指向同一地址,改变 b 同时也改变 a。
    2. 通过视图ndarray.view()仅复制值,当对 c 值进行改变会改变 a 的对应的值,而改变 c 的 shape 不改变 a 的 shape
    3. ndarray.copy() 进行的完整的拷贝,产生一份完全相同的独立的复制。

     

    np.hstack

    cv2.imshow("Histogram Equalization", np.hstack([image, eq]))  # np.hstack:两个图合并一个图,并排显示

     

     

    ufunc

    https://blog.csdn.net/unixtch/article/details/78531585

    ufunc是universal function的缩写,意思是这些函数能够作用于narray对象的每一个元素上,而不是针对narray对象操作,numpy提供了大量的ufunc的函数。这些函数在对narray进行运算的速度比使用循环或者列表推导式要快很多,但请注意,在对单个数值进行运算时,python提供的运算要比numpy效率高。

    逻辑运算and、or、not、xor等由于python提供,np.logical_or(a == b, a > b)

    以bitwise_开头的函数时用于位运算,如(bitwise_and、bitwise_or)等,也可以使用&、|、~和^来进行运算。 

    除了numpy提供的内置ufunc函数,用户也可以编写自定义的ufunc函数

    ## 基本形式

    u_func = np.frompyfunc(func,nin,nout)

    ret = u_func(narray_obj,param1,param2..)

    numpy.vectorize()也实现了和numpy.frompyfunc()一样的功能

    #a
    array([[ 0],
           [10],
           [20],
           [30],
           [40],
           [50]])
    #b
    array([0, 1, 2, 3, 4])
    # a+b
    array([[ 0,  1,  2,  3,  4],
           [10, 11, 12, 13, 14],
           [20, 21, 22, 23, 24],
           [30, 31, 32, 33, 34],
           [40, 41, 42, 43, 44],
           [50, 51, 52, 53, 54]])
    

    numpy提供了ogrid和mgrid来创建广播计算的数组,前者返回的是两个向量,后者返回的是进行广播运算的数组。

    ogrid[]参数是有两种形式(1):[start:end:step]即起点、终点和步长;(2):[start:end:len]即起点、终点和数组长度,这里的长度为了和步长区分,在传入时时以虚数方式传入的,例如[1,5,4j]将产生[1,2,3,4]这样的数组。 
    另外广播支持特殊的下标None,意义时在对应位置上产生1的新轴,例如a[None,:]等效于a.reshape((1,-1)),a[:,None]等效于a.reshape((-1,1)),另外,np.ix_()能将一维数组转换为能进行广播的二维数组:
    np.ix_()支持多个参数,从而支持n维空间的广播计算。

    .reduce()

    .accumulate()

    .reduceat()

     

    矩阵运算

    from numpy import *  #这样不用写np了
    b=matrix([1,2,3])  #1X3
    a1=array([1,2,3])
    a1=mat(a1)
    data1=mat(zeros((3,3))) #创建一个3*3的零矩阵,矩阵这里zeros函数的参数是一个tuple类型(3,3)
    data2=mat(ones((2,4))) #创建一个2*4的1矩阵,默认是浮点型的数据,如果需要时int类型,可以使用dtype=int
    data3=mat(random.rand(2,2)) #这里的random模块使用的是numpy中的random模块,random.rand(2,2)创建的是一个二维数组,需要将其转换成#matrix
    data4=mat(random.randint(10,size=(3,3))) #生成一个3*3的0-10之间的随机整数矩阵,如果需要指定下界则可以多加一个参数
    data5=mat(random.randint(2,8,size=(2,5))) #产生一个2-8之间的随机整数矩阵
    data6=mat(eye(2,2,dtype=int)) #产生一个2*2的对角矩阵
    a1=[1,2,3]
    a2=mat(diag(a1)) #生成一个对角线为1、2、3的对角矩阵
    
    
    a3=a1*a2 #1*2的矩阵乘以2*1的矩阵,得到1*1的矩阵
    a3=multiply(a1,a2)  点乘
    a2=a1*2  点乘
    a2=a1.I  求逆
    a2=a1.T  转置
    a1.sum(axis=0) #列和,这里得到的是1*2的矩阵
    a1.sum(axis=1) #行和,这里得到的是3*1的矩阵
    a4=sum(a1[1,:])  #计算第一行所有列的和,这里得到的是一个数值
    
    a1.max()   #计算a1矩阵中所有元素的最大值,这里得到的结果是一个数值
    a2=max(a1[:,1]) #计算第二列的最大值,这里得到的是一个1*1的矩阵
    a1[1,:].max()  #计算第二行的最大值,这里得到的是一个一个数值
    np.max(a1,0)  #计算所有列的最大值,这里使用的是numpy中的max函数
    np.max(a1,1)  #计算所有行的最大值,这里得到是一个矩阵
    np.argmax(a1,0) #计算所有列的最大值对应在该列中的索引
    np.argmax(a1[1,:])  #计算第二行中最大值对应在该行的索引
    b=a[1:,1:]  #分割出第二行以后的行和第二列以后的列的所有元素
    c=vstack((a,b))  #按列合并,即增加行数
    d=hstack((a,b))  #按行合并,即行数不变,扩展列数
    a.ndim
    m,n=a.shape
    number=a.size #元素总个数
    str=a.dtype #元素的类型
    a1=[[1,2],[3,2],[5,2]]  #列表
    a2=array(a1)  #将列表转换成二维数组
    a3=mat(a1)  #将列表转化成矩阵
    a4=array(a3)  #将矩阵转换成数组
    a41=a3.getA()  #将矩阵转换成数组
    a5=a3.tolist()  #将矩阵转换成列表
    a6=a2.tolist()  #将数组转换成列表
    当列表是一维的时候,将它转换成数组和矩阵后,再通过tolist()转换成列表是不相同的[1, 2, 3],[[1, 2, 3]]
    a7=(a4 is a5[0])
    dataMat=mat([1])
    val=dataMat[0,0]  #这个时候获取的就是矩阵的元素的数值,而不再是矩阵的类型

     

     

     

    展开全文
  • 介绍 Numpy(Numerical Python)是一个开源的Python科学计算库,用于快速处理任意维度的数组。 Numpy支持常见的数组和...(3)解除GIL限制 常用属性 属性名字 属性解释 ndarray.shape 数组维度的元组 ndarr

    介绍

    Numpy(Numerical Python)是一个开源的Python科学计算库,用于快速处理任意维度的数组。

    Numpy支持常见的数组和矩阵操作。对于同样的数值计算任务,使用Numpy比直接使用Python要简洁的多。

    Numpy使用ndarray对象来处理多维数组,该对象是一个快速而灵活的大数据容器。

    优势

    (1)内存地址连续,所有元素数据类型相同
    (2)支持并行化运算
    (3)解除了GIL限制

    常用属性

    属性名字 属性解释
    ndarray.shape 数组维度的元组
    ndarray.ndim 数组维数
    ndarray.size 数组中的元素数量
    ndarray.itemsize 一个数组元素的长度(字节)
    ndarray.dtype 数组元素的类型

    常用方法

    1、np.ones(shape, dtype):生成全1的数组
    2、np.ones_like(a, dtype):生成和a相同形状的数组
    3、np.zeros(shape, dtype):生成全0数组
    4、np.zeros_like(a, dtype):生成和a相同形状数组
    5、np.array(object, dtype):从列表生成数组
    6、np.asarray(a, dtype):如果是列表,则创建新的ndarray,如果a是ndarray,则不会创建新的空间

    等差数组

    np.linsapce(start, stop, num, endpoint)
    np.arange(start,stop, step, dtype)

    等比数组

    np.logspace(start,stop, num)

    生成随机数组

    标准正态分布:np.random.randn()
    正态分布:np.random.normal(μ,σ)
    均匀分布:np.random.rand()
    np.random.uniform()
    np.random.randint()

    形状修改

    ndarray.reshape():返回一个新的ndarray
    ndarray.resize():在自身修改
    ndarray.T:转置

    类型修改

    ndarray.astype():返回修改类型之后的数组

    数组去重

    np.unique(ndarray)

    数组运算

    ndarray > 60:返回布尔类型的数组
    ndarray[ndarray>60]:返回为True的元素
    np.all():所有都为True返回True
    np.any():有一个为Ture返回True
    np.where():三元运算符
    np.logical_and():逻辑与
    np.logical_or():逻辑或

    统计函数

    方法 说明
    min(a, axis) 返回数组的最小值或沿轴的最小值
    max(a, axis]) 返回数组的最大值或沿轴的最大值
    median(a, axis) 计算沿指定轴的中位数
    mean(a, axis, dtype) 沿指定轴计算算术平均值
    std(a, axis, dtype) 沿指定轴计算标准偏差
    var(a, axis, dtype) 沿指定轴计算标方差
    np.argmax(axis=) 最大元素对应的下标
    np.argmin(axis=) 最小元素对应的下标

    广播机制

    数组在进行矢量化运算时,要求数组的形状是相等的。当形状不相等的数组执行算术运算的时候,就会出现广播机制,该机制会对数组进行扩展,使数组的shape属性值一样,这样,就可以进行矢量化运算了。

    广播主要发生在两种情况,一种是两个数组的维数不相等,但是它们的后缘维度的轴长相符,另外一种是有一方的长度为1。

    eg:

    arr1 = np.array([[1, 2, 3, 2, 1, 4], [5, 6, 1, 2, 3, 1]])
    arr2 = np.array([[1], [3]])
    print(arr1+arr2)
    
    # 结果
    # array([[2, 3, 4, 3, 2, 5],
    #        [8, 9, 4, 5, 6, 4]])
    

    矩阵运算

    (M行, N列)*(N行, L列) = (M行, L列)

    np.matmul():矩阵乘
    np.dot:矢量运算是相同,支持矢量和标量

    展开全文
  • Numpy底层使用C语言编写,内部解除GIL(全局解释器锁),其对数组的操作速度不受Python解释器的限制,所以,其效率远高于纯Python代码 import cv2 import time import os import numpy as np def read_img_and_...
  • Python3快速入门(十二)——NumPy 一、NumPy简介 ...Numpy 是一个运行速度非常快的数学库,内部解除了CPython的GIL,运行效率极好,主要用于数组计算,是大量机器学习框架的基础库,NumPy主要包括如下...
  • Numpy 是一个运行速度非常快的数学库,内部解除了CPython的GIL(全局解释器锁),运行效率极好,主要用于数组计算,是大量机器学习框架的基础库,NumPy主要包括如下: (1)强大的N维数组对象...
  • 文章目录一、Numpy的优势:1.... ndarray的优势:4.1 内存块风格4.2 ndarray支持并行化运算(向量化运算)4.3 Numpy底层使用C语言编写,内部解除GIL(全局解释器锁),其对数组的操作速度不受Python解释器的限制,...
  • 重要的是,numpy内部解除了CPython中的全局解释器锁(GIL),运行效率非常好,是处理大量数组类结构和机器学习框架的基础库! 2、安装numpy库 直接参考下面的链接,我在此处补充点提示 参考连接:htt..
  • Android终端Termux安装NumPy、Jupyter

    万次阅读 2018-10-12 16:30:57
    Numpy内部解除PythonGIL(全局解释器锁),运算效率极好,是大量机器学习框架的基础库 安装依赖包 apt-get install clang python python-dev fftw 注:经测试fftw不用安装也可以成功 用pip安装nu...
  • Numpy内部解除PythonGIL(全局解释器锁),运算效率极好,是大量机器学习框架的基础库! 二、numpy安装 1.建议使用Anaconda安装,包含了比较全面的常用库和科学计算使用的库 这里贴上Anaconda,win下安装较为简单,...
  • 科学计算和可视化

    2019-04-24 23:55:00
     NumPy(Numeric Python)提供了一个N维的数组类型ndarray,Numpy底层使用C语言编写,内部解除GIL(全局解释器锁),其对数组的操作速度不受Python解释器的限制,效率远高于纯Python代码。  ndarray到底跟原生...
  •  NumPy(Numeric Python)提供了一个N维的数组类型ndarray,Numpy底层使用C语言编写,内部解除GIL(全局解释器锁),其对数组的操作速度不受Python解释器的限制,效率远高于纯Python代码。  ndarray到底跟原生...
  •  NumPy(Numeric Python)提供了一个N维的数组类型ndarray,Numpy底层使用C语言编写,内部解除GIL(全局解释器锁),其对数组的操作速度不受Python解释器的限制,效率远高于纯Python代码。  ndarray到底跟原生...
  •  NumPy(Numeric Python)提供了一个N维的数组类型ndarray,Numpy底层使用C语言编写,内部解除GIL(全局解释器锁),其对数组的操作速度不受Python解释器的限制,效率远高于纯Python代码。  ndarray到底跟原生...
  • 成绩雷达图

    2019-10-02 07:41:17
     NumPy(Numeric Python)提供了一个N维的数组类型ndarray,Numpy底层使用C语言编写,内部解除GIL(全局解释器锁),其对数组的操作速度不受Python解释器的限制,效率远高于纯Python代码。  ndarr...
  • jupyter numpy

    2020-04-09 13:18:46
    3.Numpy底层使用C语言编写,内部解除GIL(全局解释器锁),其对数组的操作速度不受Python解释器的限制,所以,其效率远高于纯Python代码。 ndarray (n维数组) 思考:如果拿到一个文件,该文件大小远超你电脑的内存...
  • Numpy

    2019-10-05 12:22:15
    可以并行执行-Numpy底层使用C语言编写,内部解除GIL(全局解释器锁),其对数组的操作速度不受Python解释器的限制,所以,其效率远高于纯Python代码。 numpy基于矩阵,矩阵可以分块计算,所以可以实现并行 ...
  • 科学计算与可视化

    2019-04-23 21:23:00
    科学计算与可视化 (1)numpy以及matplotlib的...Numpy内部解除了CPython的GIL(全局解释器锁),运行效率极好,是大量机器学习框架的基础库! NumPy的全名为Numeric Python,是一个开源的Python科学计算...
  • Numpy库入门与学习

    2020-04-23 14:18:34
    简介 1.numpy优势 开源科学计算库,用于快速处理多个维度的数组,使用...由C语言编写,不受python解释器的限制,解除GIL。 2.ndarry属性 名字 解释 ndarry.shape 数组维度元组 ndarry.ndim 数组维度 ...
  • Numpy使用了优化的C api,运算速度快,在深度学习需要运用numpy向量化加快运算速度,NumPy底层用C语言编写,内部解除GIL(全局解释性锁),其对数组的操作速度不受python解释器的限制,效率远高于纯python代码。...
  • nump基础

    2021-01-23 01:14:43
    numpy 底层使用C 编写,内部解除GIL 锁 创建ndarray的时候不指定类型,整数默认int64,小数默认float64 生成数组 np.linspace(0,100,10); np.arange(0,100,10) 形状修改 数组去重 np.unique(a) ...
  • Numpy学习总结

    千次阅读 2019-03-25 14:59:11
    一、NumPy简介 ...  NumPy是Python语言的一个扩充程序库。支持高级大量的维度数组与矩阵运算,此外也针对数组运算提供大量的数学...Numpy内部解除了CPython的GIL(全局解释器锁),运行效率极好,是大量机器学习框架...
  • 什么是死锁

    2019-03-19 09:15:46
    若干子线程在系统竞争时,都在等待对方对某部分资源解除占用状态,结果是谁也不愿意先解锁,互相干等着,程序无法执行下去 这就是死锁 GIL锁解释器锁 作用 :限制多线程同时执行,保证同一时间只有一个线程执行,...

空空如也

空空如也

1 2
收藏数 29
精华内容 11
关键字:

python解除gil

python 订阅