NumPy入门指南(一) | Day1

太过爱你忘了你带给我的痛 2023-02-12 11:26 2阅读 0赞

同学们好！

今天我们开始数据分析第二期的课程啦~~~

今明两天我们主要学习NumPy，NumPy是用Python做数据分析时不可或缺的一个库，想知道它怎么使用吗？快往下看吧！（ps:课程内容较多，大家坚持住哦！）

NumPy介绍

NumPy(Numerical Python)是Python中一个非常重要的第三方库，**用于快速处理任意维度的数组**。NumPy支持常见的数组和矩阵操作。对于同样的数值计算任务，使用Numpy比直接使用Python内置的方法要快速，方便。

NumPy中的数组的存储效率和输入输出性能均远远优于Python中等价的基本数据结构，且其能够提升的性能是与数组中的元素成比例的。

NumPy的大部分代码用C语言编写，其底层算法在设计时就有着优异的性能，这使得NumPy比纯Python代码高效得多。

下面我们来看一个案例：通过记录时间差，对比Python列表数据结构和Numpy数组ndarray计算数组求和来对比两者的效率

import random 
    import time 
    import numpy as np 
    # 创建列表a来存放（100000000）个随机数
    a = []
    for i in range(100000000):
      a.append(random.random()) # append是将()中的元素添加到列表的末尾
      
    # 记录Python对列表a求和的时间差
    t1 = time.time() # time.time() 获得当前时间
    sum1=sum(a) #
    t2=time.time()
    
    # 记录使用Numpy中的array数据结构，对数组a求和的时间差
    b=np.array(a)
    t3=time.time()
    sum2=np.sum(b)
    t4=time.time()
    print(t2-t1, t4-t3)

# 运行结果：
    3.891148090362549 0.19675397872924805
    “”“
    运行后需要等待几秒钟可以看到计算结果；
    Python列表中元素求和的运行时间将近4s，
    而Numpy中的array数据结构只需要0.2s。
    ”“”

### NumPy中的数组ndarray ###

ndarray(N-dimensional array object)是NumPy中的多维数组，它是一系列同类型数据的集合，而在Python的列表数据结构中，里面的元素可以是不同类型的数据；此外，ndarray中元素在数组\[ \]中显示时，元素间没有逗号。

### 创建一维数组 ###

一般不能直接创建ndarray，通过读取列表来创建数组，可以采用三种方法：

1.  转换list到array  
2.  使用python的函数range生成序列
3.  使用numpy自带的函数arange,用法与range相同

import numpy as np
    list_a = [1,2,3,4]
    onedArray = np.array(list_a) # 将列表转换为NumPy数组
    
    # 查看数据类型
    print(type(onedArray)) # type函数可以查看数据类型
    print(onedArray)
    
    """
    运行结果：
    <class 'numpy.ndarray'>
    [1 2 3 4]
    数据类型是numpy中的ndarray,[]中元素间没有逗号
    """
    
    # 创建数组的其他形式
    
    ## 1.直接传入列表的方式
    t1 = np.array([1,2,3])
    print(t1)
    print(type(t1))
    '''
    运行结果：
    [1 2 3]
    <class 'numpy.ndarray'>
    '''
    
    ## 2. 传入range生成序列
    t2 = np.array(range(10))
    print(t2)
    print(type(t2))
    '''
    运行结果：
    [0 1 2 3 4 5 6 7 8 9]
    <class 'numpy.ndarray'>
    '''
    
    ## 3. 使用numpy自带的np.arange()生成数组
    t3 = np.arange(0,10,2)
    print(t3)
    print(type(t3))
    
    '''
    运行结果：
    [0 2 4 6 8]
    <class 'numpy.ndarray'>
    '''

### 创建二维数组 ###

取出数组中的元素，方法与取出列表中的元素相同：指定元素的下标序号，第一个元素的下标是0。取出二维数组中的元素的方法，与一维数组相同，先指定第几个一维数组，再从取得的一维元素中指定元素的下标。

import numpy as np
    list2 = [[1,2],[3,4],[5,6]]
    twodArray = np.array(list2)
    print(twodArray)
    '''
    运行结果：
    [[1 2]
     [3 4]
     [5 6]]
     二维数组对应的类似excel中的行和列，可以和sql交互
    '''
    
    # 二维列表可以看做列表里面放列表
    # 取出二维列表list2中的第一个元素
    print(list2[0])
    """
    运行结果：
    [1,2]
    """
    
    # 如何取出二维列表list2中第一个一维列表中的第一个元素？
    print(list2[0][0])
    """
    运行结果：
    '1'
    """

### 常用属性 ###

通过查询ndim属性可以得知数组的维度，shape属性得知形状；如果是二维数组，shape用几行几列来描述；size属性表示数组中有几个元素。

import numpy as np
    list2 = [[1,2],[3,4],[5,6]]
    twodArray = np.array(list2)
    
    # ndim: 获取数组的维度
    print(twodArray.ndim)
    '''2'''
    
    # shape:形状(行，列)
    print(twodArray.shape)
    '''(3, 2)'''
    
    # size数组中有多少个元素
    print(twodArray.size)
    '''6'''

### 调整数组的形状 ###

调整数组的形状就是改变数组的行数和列数，类似于我们在大学数学中学习的矩阵。通过建立数组可以保存excel和数据库中的数据。那么如何调整行和列，也就是修改形状呢？

这里提供两个方法，一是给shape的属性赋值，二是使用reshape()函数。

import numpy as np
    twodArray = np.array([[1,2,3],[4,5,6]])
    
    # 修改数组形状：
    # 方法1：给属性shape赋值
    one = twodArray
    one.shape=(3,2)
    print(one)
    '''
    [[1 2]
     [3 4]
     [5 6]]
    '''
    # 方法2：函数reshape()，返回一个新的数组
    two = twodArray.reshape(2,3)
    print(two)
    '''
    [[1 2 3]
     [4 5 6]]
    '''
    
    # 将多维数组变成一维数组
    three = twodArray.reshape((6,),order='F')
    # order参数中,'C'是默认,以行展开，'F'(Fortran风格)以列展开；
    print(three)
    '''
    [1 3 5 2 4 6]
    '''
    four = twodArray.reshape((6,),order='C')
    print(four)
    '''
    [1 2 3 4 5 6]
    '''

### 数组形状拓展： ###

我们继续使用reshape()函数，将一个一维数组，转化为二维和三维数组。

二维数组可以存放x和y轴(行和列)两个维度的信息，三维数组还可以增加一个z轴。

import numpy as np
    t = np.arange(24)
    
    print(t)
    print(t.shape) # 一行24列
    '''
    [ 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,)
    '''
    
    # 转换成二维
    t1 = t.reshape((4,6)) #四行六列
    print(t1)
    print(t1.shape)
    '''
    [[ 0  1  2  3  4  5]
     [ 6  7  8  9 10 11]
     [12 13 14 15 16 17]
     [18 19 20 21 22 23]]
    (4, 6)
    '''
    
    # 转换成三维
    t2 = t.reshape((2,3,4)) # （2，3，4）三维数组里有两组元素，每个元素有三行，四列
    print(t2)
    print(t2.shape)
    '''
    [[[ 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, 3, 4)
    '''

### 将数组转成列表: ###

函数tolist()可以将ndarray数组转换成Python列表

import numpy as np
    a = np.array([9, 12, 88, 14, 25])
    list_a = a.tolist()
    print(list_a)
    print(type(list_a))
    '''
    [9, 12, 88, 14, 25]
    <class 'list'>
    '''

### NumPy的数据类型 ###

NumPy数组由于提升了计算的性能，数组中的元素直接存储数据，默认是int，但是计算时如果数据是浮点型，一定要说明数据类型是浮点型。而python中的列表存储元素的方式是在列表中存放一个指针，指针指向数据，因而计算速度也降低了。

Numpy最主要的功能就是科学计算，计算时，numpy的数组支持的数据类型有：![format_png][]举例来说，int16是整数16位，可以存放的数字大小从-32768 至 32767，占 2个字节，一个字节是8位，两个字节16位，不同的精度对内存空间的占用大小不同。

通过指定或者修改nupmy数组中的dtype属性来设置数组的数据类型。

import numpy as np 
    f = np.array([1,2,3,4,5], dtype = np.int16)
    # 输出数组中每个元素的字节单位长度
    print(f.itemsize)    
    # 获取数据类型
    print(f.dtype)      
    
    # 调整数据类型
    f1 = f.astype(np.int32)
    print(f1.dtype)
    
    #----- 随机生成小数 -----
    # 使用Python语法，保留2位
    import random # random生成0-1内的小数，如果随机数需要扩大十分位，后面乘以100
    print(round(random.random(),2)) #round：约分保留2位小数
    ## 使用numpy语法
    f2 = np.array([random.random() for i in range(10)])
    # [random.random() for i in range(10)]是一个列表表达式，for i in range(10)循环在这里是多次循环的功能，循环十次，产生一个含有10个随机数的列表
    print(np.round(f2,2))
    
    
    # 运行结果：
    '''
    2
    int16
    int32
    0.3
    [0.64 0.52 0.4  0.22 0.3  0.08 0.8  0.62 0.83 0.51]
    '''

数组的计算

Numpy的主要功能是对数值型的数据进行计算,学习如何对数组进行计算是后续数据分析的基础。

Pandas可以对其他类型的数据进行操作，Numpy和Pandas之间的关系类似matplotlib和seaborn的关系。

### 数组和数的计算 ###

numpy的**广播机制**存在运算过程中，加减乘除的值被广播到所有的元素上面。举例来说，对数组进行加减乘除，相当于对数组中的每一个元素进行加减乘除。

import numpy as np
    t1 = np.arange(24).reshape((6,4))
    print(t1)
    print(t1+2)
    print(t1*2)
    print(t1/2)
    
    # 运行结果：
    '''
    [[ 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  3  4  5]
     [ 6  7  8  9]
     [10 11 12 13]
     [14 15 16 17]
     [18 19 20 21]
     [22 23 24 25]]
    
    [[ 0  2  4  6]
     [ 8 10 12 14]
     [16 18 20 22]
     [24 26 28 30]
     [32 34 36 38]
     [40 42 44 46]]
    
    [[ 0.   0.5  1.   1.5]
     [ 2.   2.5  3.   3.5]
     [ 4.   4.5  5.   5.5]
     [ 6.   6.5  7.   7.5]
     [ 8.   8.5  9.   9.5]
     [10.  10.5 11.  11.5]]
    '''

### 数组和数组之间的操作 ###

数组和数组存在形状的差异，不同形状的数组如何计算呢？

#### 同种形状的数组：对应位置进行计算操作 ####

import numpy as np
    t1 = np.arange(24).reshape((6,4))
    t2 = np.arange(100,124).reshape((6,4))
    print(t1)
    print(t2)
    print(t1+t2)
    print(t1*t2)
    
    # 运行结果：
    '''
    [[ 0  1  2  3]
     [ 4  5  6  7]
     [ 8  9 10 11]
     [12 13 14 15]
     [16 17 18 19]
     [20 21 22 23]]
    
    [[100 101 102 103]
     [104 105 106 107]
     [108 109 110 111]
     [112 113 114 115]
     [116 117 118 119]
     [120 121 122 123]]
    
    [[100 102 104 106]
     [108 110 112 114]
     [116 118 120 122]
     [124 126 128 130]
     [132 134 136 138]
     [140 142 144 146]]
    
    [[   0  101  204  309]
     [ 416  525  636  749]
     [ 864  981 1100 1221]
     [1344 1469 1596 1725]
     [1856 1989 2124 2261]
     [2400 2541 2684 2829]]
    '''

#### 不种形状的多维数组:不能计算 ####

import numpy as np
    t1 = np.arange(24).reshape((4,6))
    t2 = np.arange(18).reshape((3,6))
    print(t1)
    print(t2)
    print(t1-t2)
    
    # 运行结果：
    '''
    ValueError: operands could not be broadcast together with shapes (4,6) (3,6)
    '''

#### 行数或者列数与多维数组相同的一维数组可以进行计算: ####

1.行形状相同(会与每一行数组的对应位相操作)

2.列形状相同(会与每一个相同维度的数组的对应位相操作)

import numpy as np
    # 行形状相同 （列数相同）
    t1 = np.arange(24).reshape((4,6))
    t2 = np.arange(0,6)
    print(t1)
    print(t2)
    print(t1-t2)
    
    # 运行结果：
    '''
    [[ 0  1  2  3  4  5]
     [ 6  7  8  9 10 11]
     [12 13 14 15 16 17]
     [18 19 20 21 22 23]]
    
    [0 1 2 3 4 5]
    
    [[ 0  0  0  0  0  0]
     [ 6  6  6  6  6  6]
     [12 12 12 12 12 12]
     [18 18 18 18 18 18]]
    '''
    
    # 列形状相同 （行数相同）
    t3 = np.arange(24).reshape((4,6))
    t4 = np.arange(4).reshape((4,1))
    print(t3)
    print(t4)
    print(t3-t4)
    
    # 运行结果
    '''
    [[ 0  1  2  3  4  5]
     [ 6  7  8  9 10 11]
     [12 13 14 15 16 17]
     [18 19 20 21 22 23]]
    
    [[0]
     [1]
     [2]
     [3]]
    
    [[ 0  1  2  3  4  5]
     [ 5  6  7  8  9 10]
     [10 11 12 13 14 15]
     [15 16 17 18 19 20]]
    '''

### 数组中的轴 ###

1.什么是轴: 在numpy中可以理解为方向，使用0，1，2数字表示，对于一个一维数组，只有一个0轴，对于2维数组(shape(2，2))有0轴和1轴，对于3维数组(shape(2，2，3))有0，1，2轴。

2.为什么要学习轴(axis): 有了轴的概念后，我们计算会更加方便，比如计算一个2维数组的平均值，必须指定是计算哪个轴方向上数值的平均值。

![format_png 1][]

当axis=0时，为跨行计算，方向可以记忆为右，相当于x轴正数的方向，但计算的是x轴方向上的列值；例如：sum求和, 那么三列分别相加，跨行计算，结果是\[5 7 9\]。

同理，axis=1时为跨列计算，方向为下，y轴的负数方向，计算的是y轴行的值；sum求和时，两行内的三列分别相加，结果是\[6 15\]。

![format_png 2][]

三维数组中，0轴 axis = 0 时，计算时，从同位置的元素的方向计算，相当于”穿透“。例如求和时，是把二维数组中相同位置的元素在0轴方向上相加，那么计算出的结果第一个位置的元素的和等于 1 + 7 + 14 = 22。同理，1轴和2轴的计算就是二维数组中0轴和1轴的计算方法。

import numpy as np
    a = np.array([[1,2,3],[4,5,6]]) # 2行3列的数组
    print(np.sum(a,axis=0)) # 0轴方向上的求和，[5 7 9]
    print(np.sum(a,axis=1)) # 1轴方向上的求和，[ 6 15]
    print(np.sum(a)) # 计算所有的值的和 21
    
    #三维的数据
    a = np.arange(27).reshape((3,3,3))
    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]
      [24 25 26]]]
    '''
    
    b = np.sum(a, axis=0)
    print(b)
    '''
    [[27 30 33]
     [36 39 42]
     [45 48 51]]
    '''
    c = np.sum(a, axis=1)
    print(c)
    '''
    [[ 9 12 15]
     [36 39 42]
     [63 66 69]]
    '''
    
    c = np.sum(a, axis=2)
    print(c)
    '''
    [[ 3 12 21]
     [30 39 48]
     [57 66 75]]
    '''

**小作业：**

练习数组形状修改

练习矩阵相乘

![format_png 3][]

[![format_png 4][]][format_png 4 1]

**写在后面：**

学完今天的课程，是不是对NumPy不再陌生？

完成今天的学习，评论区留言打卡~

记得在群里分享你的完成情况哦~

![format_png 5][]

好文章，我在看❤

[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X2pwZy9xaWFTbDNSVDFSYzA2VlI0ZHdSMmhFaWNrOXBSOFVscjFvQzN6UDhEdHQzSnBqV3lRMEtRdVJtNDBhclVIbnZodlZpYU1NUTVhYTU4SGlheU1kUDN3aWI3TEtRLzY0MA?x-oss-process=image/format,png
[format_png 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9xaWFTbDNSVDFSYzA2VlI0ZHdSMmhFaWNrOXBSOFVscjFvb3l3bjlhNXI3MU9KV2ZTZTU3amx1TnVDTXdRM2RsQ1NZYmlhbGh6NXJRMlBXaWFoSW5iNlpZdEEvNjQw?x-oss-process=image/format,png
[format_png 2]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9xaWFTbDNSVDFSYzA2VlI0ZHdSMmhFaWNrOXBSOFVscjFvVFVNNmpjNXJmV0I1Y2N5VTA3dnd5eWlidHdYb2lhc0NlUzBIaFNWYno3cURjZDB2NGNTMmQzcFEvNjQw?x-oss-process=image/format,png
[format_png 3]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X2dpZi9iOTZDaWJDdDcwaWFaVldMcUtXWXFUb0JCb0xUZU5jMk5tbHk0REJnbmoyb21Vcm5XdWtHZm1DQ1F0VmlhTGlhaktIcDRjQ1VNOUZXZzhzMTRVT1JoY2NVQmcvNjQw?x-oss-process=image/format,png
[format_png 4]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X3BuZy9xaWFTbDNSVDFSYzFZRmMyckF4ZVFFcFZxcmVpY2liV0dJaFZjcDBzZnFtclFac3hEalVtaFQzUEdaMnpOeVFsSjM0d0VJaWNjTEVnRGhJUnJwU2xkMEhYTHcvNjQw?x-oss-process=image/format,png
[format_png 4 1]: https://mp.weixin.qq.com/mp/appmsgalbum?__biz=MzIwMTMxMTQxNQ%3D%3D&action=getalbum&album_id=1339196544410796033#wechat_redirect
[format_png 5]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9tbWJpei5xcGljLmNuL21tYml6X2pwZy9xaWFTbDNSVDFSYzFlTFVkYjVjenlFcU5kckttRE9pYmxFd2U3OVdOc1ZmNFVpY05LTEJ4TGZpYWFqaEdoNzZEWkV2OWxxdDUySkt4Vm5mUDJZTGliRWliRnJiUS82NDA?x-oss-process=image/format,png