python数据分析:Numpy(1)

120 阅读6分钟

本文已参与「新人创作礼」活动,一起开启掘金创作之路。

一,什么是Numpy?

高级的数值编程工具

  • 强大的N维数组对象:ndarray
  • 对数组结构数据进行运算(不用遍历循环,矩阵运算)
  • 随机数,线性代数,傅里叶变换等功能
二,np的数据类型:数组

方法结果描述
ar.ndim2查看数组的轴(维度)
ar.shape(2, 6)查看数组的维度,对于n行m列的数据,其shape为(n, m)
ar.size12数组的元素总数,对于n行m列的数组,元素总数为n*m
ar.dtypeint32数组中元素的类型,类似type()(注意了,type()是函数,.dtype是方法)
  • 输入:

    import numpy as np
    ar = np.array([[1, 2, 3, 4, 5, 6], [5, 2, 6, 8, 9, 6]])
    1print("列表", [1, 2, 3, 4, 5, 6])
    2print("数组", ar, type(ar))
    3print(ar.ndim)           # 查看数组的轴(维度)
    4print(ar.shape)          # 查看数组的形状,对于n行m列的数据,其shape为(n, m)
    5print(ar.size)           # 数组的元素总数,对于n行m列的数组,元素总数为n*m
    6print(type(ar), ar.dtype)# 数组中元素的类型,类似type()
    7,ar					   # 交互式输出
    
  • 输出

    输出:
    1,列表 [1, 2, 3, 4, 5, 6]
    2,数组 [[1 2 3 4 5 6]
     		[5 2 6 8 9 6]] <class 'numpy.ndarray'>
    32										# 二维数组,两行六列(多个二维组成三维)
    4,(2, 6)									# 两行六列
    512										# 这个数组里一共有12个元素
    6,<class 'numpy.ndarray'> int32
    7,array([[1, 2, 3, 4, 5, 6],
           		[5, 2, 6, 8, 9, 6]])
    
    # 数组的基本属性
    # ① 数组的维数称为秩(rank),一维数组的秩为1,二维数组的秩为2,以此类推
    # ② 在NumPy中,每一个线性的数组称为是一个轴(axes),秩其实是描述轴的数量:
    # 比如说,二维数组相当于是两个一维数组,其中第一个一维数组中每个元素又是一个一维数组
    # 所以一维数组就是NumPy中的轴(axes),第一个轴相当于是底层数组,第二个轴是底层数组里的数组。
    # 而轴的数量——秩,就是数组的维数。 
    
三,如何创建np数组

创建数组:array(),括号内可以是列表、元祖、数组、生成器等

  1. 通过生成器range()创建

    ar1 = np.array(range(10))
    print(ar1)
    --------------------------
    [0 1 2 3 4 5 6 7 8 9]
    
  2. 直接通过np内置的类似range()功能的arange()创建

    print(np.arange(10))
    --------------------------
    [0 1 2 3 4 5 6 7 8 9]
    
    # 创建数组:arange(),类似range(),在给定间隔内返回均匀间隔的值。
    print(np.arange(10))    		# 返回0-9,整型
    print(np.arange(1., 10., 0.5))  # 返回0.0-9.0,浮点型
    print(np.arange(5,12))  		# 返回5-11
    print(np.arange(5.0,12,2))  	# 返回5.0-12.0,步长为2
    print(np.arange(10000))  		# 如果数组太大而无法打印,NumPy会自动跳过数组的心
    --------------------------		# 部分,并只打印边角
    [0 1 2 3 4 5 6 7 8 9]
    [1.  1.5 2.  2.5 3.  3.5 4.  4.5 5.  5.5 6.  6.5 7.  7.5 8.  8.5 9.  9.5]
    [ 5  6  7  8  9 10 11]
    [  5.   7.   9.  11.]
    [   0    1    2 ..., 9997 9998 9999]
    
  3. 直接用[]创建

    print(np.array([1, 2, 3, 4, 5, 6, 789]))
    --------------------------
    [0 1 2 3 4 5 6 7 8 9]
    
  4. 使用嵌套列表创建多维列表

    print(np.array([[1, 2, 3, 4], [5, 6, 7, 8]]))
    --------------------------
    [[1 2 3 4]
     [5 6 7 8]]
    
    print(np.array([[1, 2, 3, 4], ["a", "b", "c", "d"]]))
    --------------------------		# 如果创建的时候元素不是数字,那么会给你全部转换类型
    [['1' '2' '3' '4']
     ['a' 'b' 'c' 'd']]
    
    print(np.array([[1, 2, 3, 4, 5], [1, 2, 3, 4, 5, 6, 7]]))
    --------------------------		# 如果元素数量不相同会变成一维数组
    [list([1, 2, 3, 4, 5]) list([1, 2, 3, 4, 5, 6, 7])]
    
  5. 使用linspace()创建(返回一个范围内以num平分个数的数组。)

    # 创建数组:linspace():返回在间隔[开始,停止]上计算的num个均匀间隔的样本。
    ar1 = np.linspace(2.0, 3.0, num=5)
    ar2 = np.linspace(2.0, 3.0, num=5, endpoint=False)
    ar3 = np.linspace(2.0, 3.0, num=5, retstep=True)
    print(ar1,type(ar1))
    print(ar2)
    print(ar3,type(ar3))
    # numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
    # start:起始值,stop:结束值
    # num:生成样本数,默认为50
    # endpoint:True,右闭。False,右开。默认值为True。
    # retstep:True,返回一个元组,元组里第一个元素为数组array,第二个为步长
    ----------------------------------------
    [ 2.    2.25  2.5   2.75  3.  ] <class 'numpy.ndarray'>
    [ 2.   2.2  2.4  2.6  2.8]
    (array([ 2.  ,  2.25,  2.5 ,  2.75,  3.  ]), 0.25) <class 'tuple'>
    
  6. 使用zeros()/zeros_like()/ones()/ones_like()创建数组

    输入:

    # 创建数组:zeros()/zeros_like()/ones()/ones_like()
    
    ar1 = np.zeros(5)  
    ar2 = np.zeros((2,2), dtype = np.int)
    print(ar1,ar1.dtype)
    print(ar2,ar2.dtype)
    print('-------------------')
    # numpy.zeros(shape, dtype=float, order='C'):返回给定形状和类型的新数组,用零填充。
    # shape:数组纬度,二维以上需要用(),且输入参数为整数
    # dtype:数据类型,默认numpy.float64
    # order:是否在存储器中以C或Fortran连续(按行或列方式)存储多维数据。
    
    ar3 = np.array([list(range(5)),list(range(5,10))])
    ar4 = np.zeros_like(ar3)
    print(ar3)
    print(ar4)
    print('-------------------')
    # 返回具有与给定数组相同的形状和类型的零数组,ar4会根据ar3的形状和dtype创建一个全0的数组
    
    ar5 = np.ones(9)
    ar6 = np.ones((2,3,4))
    ar7 = np.ones_like(ar3)
    print(ar5)
    print(ar6)
    print(ar7)
    # ones()/ones_like()和zeros()/zeros_like()一样,只是填充为1
    

    输出:

    [ 0.  0.  0.  0.  0.] float64
    [[0 0]
     [0 0]] int32
    -------------------
    [[0 1 2 3 4]
     [5 6 7 8 9]]
    [[0 0 0 0 0]
     [0 0 0 0 0]]
    -------------------
    [ 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 1 1]
     [1 1 1 1 1]]
    
  7. 使用eye创建单位矩阵

    # 创建数组:eye()
    
    print(np.eye(5))
    # 创建一个正方的N*N的单位矩阵,对角线值为1,其余为0
    --------------------------------------------
    [[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.]]
    
四,ndarray数据类型

'''
    ndarray的数据类型

    bool 用一个字节存储的布尔类型(True或False)

    inti 由所在平台决定其大小的整数(一般为int32或int64)

    int8 一个字节大小,-128 至 127

    int16 整数,-32768 至 32767

    int32 整数,-2 ** 31 至 2 ** 32 -1

    int64 整数,-2 ** 63 至 2 ** 63 - 1

    uint8 无符号整数,0 至 255

    uint16 无符号整数,0 至 65535

    uint32 无符号整数,0 至 2 ** 32 - 1

    uint64 无符号整数,0 至 2 ** 64 - 1

    float16 半精度浮点数:16位,正负号1位,指数5位,精度10位

    float32 单精度浮点数:32位,正负号1位,指数8位,精度23位

    float64或float 双精度浮点数:64位,正负号1位,指数11位,精度52位

    complex64 复数,分别用两个32位浮点数表示实部和虚部

    complex128或complex 复数,分别用两个64位浮点数表示实部和虚部

'''