Python数据分析-Numpy

Numpy特点

Numpy作为使用Python进行科学计算的常用库,有着如下特点:

  • 提供了N维数组(矩阵),快速高效,矢量数学运算;
  • 高效的Index,不需要循环,因为底层实现采用了C语言开发。

常见的数组和矩阵的方法

数组和矩阵的创建与维度信息
  • numpy.array()

    ## 数组的创建
    vector = numpy.array([1,2,3,4])
    
    ## 矩阵的创建
    matrix = numpy.array([
        [1,2,3],
        [4,5,6],
        [7,8,9]
    ])
  • shape
    ## 打印数组的维度信息
    vector.shape() ——》(4,) # 数组中存在4个元素
    
    ## 打印矩阵的维度信息
    matrix.shape()——》(3,3) #三行三列
  • reshape
    eg:
    a = np.arange(15).reshape(3, 5) #随机创建3行5列的矩阵
    Out:
       [[ 0  1  2  3  4]
       [ 5  6  7  8  9]
       [10 11 12 13 14]]
    a.ndim # 返回其维数 即 2

    注意:

    • reshape可以创建一个改变了尺寸的新数组,但是原始数组的shape是不会发生变化的。
    • reshape(-1):数组新的shape属性应该要与原来的配套,如果等于-1的话,那么Numpy会根据剩下的维度计算出数组的另外一个shape属性值。
      eg:
      z = np.array([[1, 2, 3, 4],
                [5, 6, 7, 8],
                [9, 10, 11, 12],
                [13, 14, 15, 16]])
      z.shape
        Out:(4, 4)
      z.reshape(-1)
        Out:array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16])
    • reshape(-1,1):在不知道有多少行的情况下,转变成一列数据
      eg:
      z.reshape(-1,1)
      Out:array([[ 1],
              [ 2],
              [ 3],
              [ 4],
              [ 5],
              [ 6],
              [ 7],
              [ 8],
              [ 9],
              [10],
              [11],
              [12],
              [13],
              [14],
              [15],
              [16]])
      
    • reshape(-1,2):在不知道有多少行的情况下,转变成2列数据
      eg:
      z.reshape(-1, 2)
      Out:array([[ 1,  2],
              [ 3,  4],
              [ 5,  6],
              [ 7,  8],
              [ 9, 10],
              [11, 12],
              [13, 14],
              [15, 16]])
  • linspace
    • 一般情况下,先创建python序列,通过array函数转换城数组,这样的效率不高,但是可以直接通过arange函数,指定开始值、终值和步长来创建一维数组(数组不包括终止值)。
    • linspace函数通过指定开始值、终值和元素的个数来创建一维数组。但是可以通过endpoint关键字来指定是否包括终值,缺省值默认为包括终止值。
      eg:
      np.linspace(0, 1, 10) # 步长为1/9
      Out:——》array([ 0. , 0.11111111, 0.22222222, 0.33333333, 0.44444444,0.55555556, 0.66666667, 0.77777778, 0.88888889, 1. ])
      
      
  • logspace

    logspace函数和linspace类似,不过它创建等比数列

    eg:
    np.logspace(0, 2, 20) # 产生1(10^0)到100(10^2)、有20个元素的等比数列
    
    array([ 1. ,    1.27427499,   1.62377674,    2.06913808,
    2.6366509 ,   3.35981829,   4.2813324 ,    5.45559478,
    6.95192796,  8.8586679 ,    11.28837892, 14.38449888,
    18.32980711, 23.35721469, 29.76351442, 37.92690191,
    48.32930239, 61.58482111, 78.47599704, 100. ])
  • zeros()、ones()、empty()可以创建指定形状和类型的数组

    zeros_like()、ones_like()、empty_like()等函数可创建与参数数组的形状及类型相同的数组。因此,“zeros_like(a)”和“zeros(a.shape,
    a.dtype)”的效果相同

    1.zeros(,dtype) == zeros_like() ——零矩阵
    eg:
    np.zeros(4, np.float) #元素类型默认为np.float,因此这里可以省略
    array([ 0., 0., 0., 0.])
    
    2.ones()——元素全部为1的矩阵
    eg:
    numpy.ones((3,4),numpy.int) # 3行4列,元素类型为int且全部为1的矩阵
    array([[1, 1, 1, 1],
           [1, 1, 1, 1],
           [1, 1, 1, 1]])
    
    3.empty()——空矩阵
    eg:
    np.empty((2,3),np.int) #只分配内存,不对其进行初始化
    array([[ 32571594, 32635312, 505219724],
              [ 45001384, 1852386928, 665972]])
    
访问和获取元素
  • 切片(按照行列获取)
    注意:切片操作的时候,表示的是一个从第一个想要索引开始到第i个你不想要的索引结束,其中第三个参数表示的是截取的步长

    ## 数组获取元素
    vector[0:3]  #表示的是从第一个元素开始截取,获取三个元素,返回[1,2,3]
    
    ## 矩阵获取元素
    matrix[1:,0:2] # 从二列开始,获取第一列和第二列,返回([
        [4,5],
        [7,8]
    ])
  • 按照条件获取
    eg:
    a = vector[vector > 3] # 截取数组中所有元素大于3的,返回[4]
    a = vector[vector == 4] # 截取数组中元素等于4的数组,如果不存在的话,返回一个空数组
    
    b = matrix[matrix > 5] # 截取矩阵中所有元素大于5,返回结果是一个一维数组,即[6,7,8,9]
    b = matrix[matrix == 9] # 返回的是一个boolean矩阵,结果[
        [False,False,False],
        [False,False,False],
        [Fasle,False,True]
    ]
    • 混淆项

      1. 数组比较和按照条件截取数组内容的返回结果是不相同的
      eg:
      print(vector == 3) # 返回的是将数组的元素逐一比较,返回的是一个boolean数组
      
      print(vector[vector==3]) # 返回的是截取数组中满足条件的数组
      
      2. 矩阵比较和按照条件截取矩阵内容的返回结果是不相同的
      eg:
      print(matrix == 3) # 返回的是将矩阵的元素逐一比较,返回的是一个boolean矩阵
      
      print(matrix[matrix==3]) # 返回的是截取矩阵中满足条件的数组
      
  • 按照整数序列存取元素

    当使用整数序列对数组元素进行存取时,将使用整数序列中的每个元素作为下标,整数序列可以是列表或者数组。使用整数序列作为下标获得的数组不和原始数组共享数据空间。也就是说,获取的新数组如果发生改变,原数组是不会发生改变的。相对前两者而言,这种存取方式是高效的。

    eg:
    a = numpy.linspace(0,1,10,endpoint=False)
    a
    >> array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9])
    
    # 按照整数序列,选取第4个、第6个、第8个、第10个元素进行组成新的数组
    b = a[[3,5,7,9]]
    b
    >> array([0.3, 0.5, 0.7, 0.9])
    
    # 按照序列修改对应位置的值
    b[[0,1,2]]= -1,-2,-3
    b
    >> array([-1. , -2. , -3. ,  0.9])
  • 使用布尔数组

    当使用布尔数组b作为下标存取数组x中的元素时,将收集数组x中所有在数组b中对应下标为True的元素。使用布尔数组作为下标获得的数组不和原始数组共享数据空间,注意这种方式只对应于布尔数组,不能使用布尔列表。

  • 注意:
    • 和Python的列表序列不同,通过下标范围获取的新的数组是原始数组的一个视图。它与原始数组共享同一块数据空间,也就是说,新数组元素发生变化,原数组也会同时发生变化的
常见的运算
  • sum

    eg:
     # 数组求和
    
     # 矩阵求和
     # The axis dictates which dimension we perform the operation on
     #1 means that we want to perform the operation on each row, and 0 means on each column
     matrix = numpy.array([
                     [5, 10, 15],
                     [20, 25, 30],
                     [35, 40, 45]
                  ])
     matrix.sum(axis=1) # axis=1表示按照每一行进行求和,axis=0表示按照每一列进行求和
  • 乘积
    eg:
    #The matrix product can be performed using the dot function or method
    A = numpy.array([
        [1,2],
        [3,4]
    ])
    B = numpy.array([
        [1,1],
        [4,6]
    ])
    
    # 普通的乘积
    multi = A * B
    print(multi)
    》》[[ 1  2]
        [12 24]]
    
    ## 点积运算
    resultdot = numpy.dot(A,B)
    print(resultdot)
    》》[[ 9 13]
        [19 27]]
    
    # flatten the array 铺平
    print(A.ravel())
    》》[1 2 3 4]
    
    # 横向拼接/纵向拼接
    print(numpy.vstack((A,B)))/numpy.hstack((A,B))
    》》[[1 2]
        [3 4]
        [1 1]
        [4 6]]
    
  • 均值、方差
    • mean()用于求数组的平均值,也可以通过axis参数指定求平均值的轴,通过out参数指定输出数组。和sum()不同的是,对于整数数组,它使用双精度浮点数进行计算,而对于其他类型的数组,则使用和数组元素类型相同的累加变量进行计算。
    • average()也可以对数组进行平均计算。它没有out和dtype参数,但有一个指定每个元素权值的weights参数。
    • std()var()分别计算数组的标准差和方差,有axisout及dtype等参数。
      eg:
      f = numpy.array([[ 0,  1,  2,  3,  4,  5],
             [10, 11, 12, 13, 14, 15],
             [20, 21, 22, 23, 24, 25],
             [30, 31, 32, 33, 34, 35],
             [40, 41, 42, 43, 44, 45],
             [50, 51, 52, 53, 54, 55]])
       ## 均值
      f.mean(f,axis=1) #整数数组使用双精度浮点数进行计算
      >> array([ 2.5, 12.5, 22.5, 32.5, 42.5, 52.5])
      
      ## 方差
      numpy.var(f,axis=1)
      》》array([2.91666667, 2.91666667, 2.91666667, 2.91666667, 2.91666667,
             2.91666667])
      
      ## 标准差
      numpy.std(f,axis=1)
      》》array([1.70782513, 1.70782513, 1.70782513, 1.70782513, 1.70782513,
             1.70782513])
  • 三种转置运算T、transpose、swapaxes
    • T是一种普通的转置
    • transpose属于一种轴变换
    • swapaxes其实就是把矩阵中某两个轴对换一下,属于轴对称
    arr = numpy.arange(24).reshape((2, 3, 4))
    arr
    》》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]]])
    ## 转置
    arr.T
    》》
    array([[[ 0, 12],
            [ 4, 16],
            [ 8, 20]],
    
           [[ 1, 13],
            [ 5, 17],
            [ 9, 21]],
    
           [[ 2, 14],
            [ 6, 18],
            [10, 22]],
    
           [[ 3, 15],
            [ 7, 19],
            [11, 23]]])
    
    ## 将轴1和轴0互换,轴2不变,原始是(0,1,2)
    arr.transpose(1,0,2)
    》》array([[[ 0,  1,  2,  3],
            [12, 13, 14, 15]],
    
           [[ 4,  5,  6,  7],
            [16, 17, 18, 19]],
    
           [[ 8,  9, 10, 11],
            [20, 21, 22, 23]]])
    
    ## 将轴1和轴0互换,原始是(0,1)
    arr.swapaxes(1, 0)
    》》array([[[ 0,  1,  2,  3],
            [12, 13, 14, 15]],
    
           [[ 4,  5,  6,  7],
            [16, 17, 18, 19]],
    
           [[ 8,  9, 10, 11],
            [20, 21, 22, 23]]])
  • 最值和排序
    • max()、min()求最大最小值
    • ptp()计算最大值和最小值之间的差
    • 用argmax()和argmin()可以求最大值和最小值的下标。如果不指定axis参数,就返回平坦化之后的数组下标
    • 数组的sort()方法用于对数组进行排序,它将改变数组的内容。而sort()函数则返回一个新数组,不改变原始数组。它们的axis参数默认值都为-1,即沿着数组的最后一个轴进行排序。
      sort()函数的axis参数可以设置为None,此时它将得到平坦化之后进行排序的新数组。
    • argsort()返冋数组的排序下标,axis参数的默认值为-1
    • median()可以获得数组的中值,即对数组进行排序之后,位于数组中间位置的值,当长度是偶数时,得到正中间两个数的平均值。它也可以指定axis和out参数
    • eg:
      a2 = floor(10*random.random((2,2)))
      >>> a2
      array([[ 1., 1.],
             [ 5., 8.]])
      >>>np.min(a2) # 最小值
      1.0
      >>>np.max(a2) # 最大值
      9.0
      >>>np.ptp(a2) # 最大最小值的差值
      8.0
      >>> np.argmax(a) #找到数组a中最大值的下标,有多个最值时得到第一个最值的下标
      2
      >>> idx = np.argmax(a, axis=1)
      >>> idx
      array([2, 3, 0, 0])
      ## 使用xrange()选择出每行的最大值
      >>> a[xrange(a.shape[0]),idx]
      array([9, 8, 9, 9])
      
      >>> np.sort(a, axis=0) #对每列的数据进行排序 array([[5,1,1, 4, 0],
                [7, 1, 3, 6, 0],
                [9, 5, 9, 7, 2],
                [9, 8, 9'8, 3]])
  • 按照某个轴的方向进行复制——tile
    eg:
    a = numpy.arange(0, 40, 10)
    a
    》》array([ 0, 10, 20, 30])
    
    ## 将数组作为元素复制成3行5列的矩阵
    b = numpy.tile(a, (3, 5))
    b
    》》array([[ 0, 10, 20, 30,  0, 10, 20, 30,  0, 10, 20, 30,  0, 10, 20, 30,
             0, 10, 20, 30],
           [ 0, 10, 20, 30,  0, 10, 20, 30,  0, 10, 20, 30,  0, 10, 20, 30,
             0, 10, 20, 30],
           [ 0, 10, 20, 30,  0, 10, 20, 30,  0, 10, 20, 30,  0, 10, 20, 30,
             0, 10, 20, 30]])
函数模块
  • numpy.linalg模块包含线性代数的函数。使用这个模块,可以计算逆矩阵、求特征值、解线性方程组以及求解行列式等
    • 对矩阵求逆

      使用numpy.linalg模块中的inv函数计算了逆矩阵,并检查了原矩阵与求得的逆矩阵相乘的结果确为单位矩阵。

      eg:
      A = np.mat("0 1 2;1 0 3;4 -3 8") #使用mat函数创建矩阵
      ## 求逆
      inverse = np.linalg.inv(A)
    • numpy.linalg中的函数solve可以求解形如 Ax= b 的线性方程组,其中 A为矩阵,b为一维或二维的数组,x是未知变量
      eg:
      A = np.mat("0 1 2;1 0 3;4 -3 8") #使用mat函数创建矩阵
      b = np.array([0, 8, -9])
      ## 求解
      x = np.linalg.solve(A, b)
    • 特征值和特征向量——eigvals函数

      特征值(eigenvalue)即方程 Ax= ax 的根,是一个标量。其中,A 是一个二维矩阵,x 是一个一维向量。特征向量(eigenvector)是关于特征值的向量。在numpy.linalg模块中,eigvals函数可以计算矩阵的特征值,而eig函数可以返回一个包含特征值和对应的特征向量的元组。

    • 奇异值分解
      在numpy.linalg模块中的svd函数可以对矩阵进行奇异值分解。该函数返回3个矩阵——U、Sigma和V,其中U和V是正交矩阵,Sigma包含输入矩阵的奇异值。
小结
  • 特征信息

    X.flags????#数组的存储情况信息。
    
    X.shape????#结果是一个tuple,返回本数组的行数、列数、……
    
    X.ndim???#数组的维数,结果是一个数。
    
    X.size????#数组中元素的数量
    
    X.itemsize????#数组中的数据项的所占内存空间大小
    
    X.dtype????#数据类型
    
    X.T???#如果X是矩阵,发挥的是X的转置矩阵
    
    X.trace()????#计算X的迹
    
    np.linalg.det(a)???#返回的是矩阵a的行列式
    
    np.linalg.norm(a,ord=None)????#计算矩阵a的范数
    
    np.linalg.eig(a)????#矩阵a的特征值和特征向量
    
    np.linalg.cond(a,p=None)????#矩阵a的条件数
    
    np.linalg.inv(a)????#矩阵a的逆矩阵
  • 索引
    x=np.arange(10)
    
    print x[2]????#单个元素,从前往后正向索引。注意下标是从0开始的。
    
    print x[-2]????#从后往前索引。最后一个元素的下标是-1
    
    print x[2:5]????#多个元素,左闭右开,默认步长值是1
    
    print x[:-7]????#多个元素,从后向前,制定了结束的位置,使用默认步长值
    
    print x[1:7:2]???#指定步长值
    
    x.shape=(2,5)????#x的shape属性被重新赋值,要求就是元素个数不变。2*5=10
    
    print x[1,3]????#二维数组索引单个元素,第2行第4列的那个元素
    
    print x[0]???#第一行所有的元素
    
    y=np.arange(35).reshape(5,7)????#reshape()函数用于改变数组的维度
    
    print y[1:5:2,::2]????#选择二维数组中的某些符合条件的元素
    

原文地址:https://www.cnblogs.com/cecilia-2019/p/11368223.html

时间: 2024-10-10 01:55:00

Python数据分析-Numpy的相关文章

python数据分析Numpy(二)

Numpy (Numerical Python) 高性能科学计算和数据分析的基础包: ndarray,多维数组(矩阵),具有矢量运算能力,快速.节省空间: 矩阵运算,无需循环,可以完成类似Matlab中的矢量运算: 线性代数.随机送生成: ndarray ,N维数组对象(矩阵) 所有元素必须是相同类型 ndim属性,维度个数 shape属性,各维度大小 dtype属性,数据类型 代码示例: import numpy # 生成指定维度的随机多维数据(两行三列) data = numpy.rando

Python数据分析-Numpy数值计算

Numpy介绍: NumPy是高性能科学计算和数据分析的基础包.它是pandas等其他各种工具的基础. NumPy的主要功能: 1)ndarray,一个多维数组结构,高效且节省空间 2)无需循环对整组数据进行快速运算的数学函数 3)读写磁盘数据的工具以及用于操作内存映射文件的工具 4)线性代数.随机数生成和傅里叶变换功能 5)用于集成C.C++等代码的工具 pyhton里面安装.引入方式: 安装方法:pip install numpy 引用方式:import numpy as np 创建数组:

python数据分析NumPy入门

numpy库入门 维度:一组数据的组织形式 一维数据:由对等关系的有序或无序数列构成,采用线性方式组织 (列表,集合) (数组) 列表和数组 都是一组数据的有序结构 不同点 列表:数据类型可以不同 数组:数据类型相同 二维数据:由多个一维数据构成,是一维数据的组合形式 (表格)(列表) 多维数据:由一维或二维数据在新维度上扩展形成(多维列表) 高维数据仅利用最基本的二元关系展示数据间的复杂结构 (字典) Numpy Numpy 是一个开源的python科学计算基础库 一个强大的N维数组对象 nd

python 数据分析 Numpy(Numerical Python Basic)

# 导入numpy 模块 1 import numpy as np 10 a = np.random.random((2,4)) 11 a 12 Out[5]: 13 array([[0.20974732, 0.73822026, 0.82760722, 0.050551 ], 14 [0.77337155, 0.06521922, 0.55524187, 0.59209907]]) # 求矩阵所有数据的和,最小值,最大值 22 np.sum(a) 23 Out[7]: 3.8120575132

python数据分析numpy库学习

import numpy as np def asum(a_list,b_list,n1=2,n2=3): a = np.array(a_list) b = np.array(b_list) c = pow(a,n1) + pow(b,n2) return c a_lst = [1,2,3,4] b_lst = [2,3,4,5] print(asum(a_lst,b_lst)) #np.array()生成数据对象ndarray a = np.array([[1,2,3,4],[1,2,3,4]

分享《Python数据分析基础教程:NumPy学习指南(第2版)》高清中文PDF+英文PDF+源代码

下载:https://pan.baidu.com/s/1YSD97Gd3gmmPmNkvuG0eew更多资料分享:http://blog.51cto.com/3215120 <Python数据分析基础教程:NumPy学习指南(第2版)>高清中文PDF+高清英文PDF+源代码 高清中文版PDF,249页,带目录和书签,文字能够复制粘贴:高清英文版PDF,310页,带目录和书签,文字能够复制粘贴:中英文两版可以对比学习.配套源代码:经典书籍,讲解详细:其中高清中文版如图: 原文地址:http://

Python——数据分析,Numpy,Pandas,matplotlib

由于图片内容太多,请拖动至新标签页再查看 Python--数据分析,Numpy,Pandas,matplotlib 原文地址:https://www.cnblogs.com/Jery-9527/p/10804069.html

Python数据分析与展示(1)-数据分析之表示(1)-NumPy数据存取与函数

NumPy数据存取与函数 数据的CSV文件存取 CSV文件 CSV(Comma-Separated Value,逗号分隔值) CSV是一种常见的文件格式,用来存储批量数据. 将数据写入CSV文件 np.savetxt(frame, array, fmt='%.18e', delimiter=None) -frame: 文件.字符串或产生器,可以是.gz或.bz2的压缩文件 -array: 存入文件的数组 -fmt: 写入文件的格式,例如:%d %.2f %.18e -delimiter:分割字符

Numpy学习:《Python数据分析基础教程NumPy学习指南第2版》中文PDF+英文PDF+代码

NumPy是一个优秀的科学计算库,提供了很多实用的数学函数.强大的多维数组对象和优异的计算性能,不仅可以取代Matlab和Mathematica的许多功能,而且业已成为Python科学计算生态系统的重要组成部分.但与这些商业产品不同,它是免费的开源软件. 推荐学习<Python数据分析基础教程NumPy学习指南第2版>,通过书中丰富的示例,学会Matplotlib绘图,并结合使用其他Python科学计算库(如SciPy和Scikits),让工作更有成效,让代码更加简洁而高效. 学习参考: &l