2.numpy矩阵简单使用

àì夳堔傛蜴生んèń 2022-12-27 08:48 192阅读 0赞

# 2.numpy矩阵 #

### numpy创建数组(矩阵) ###

1.  创建数组

# 创建数组
    a = np.array([i for i in range(1, 6)])
    b = np.array(range(1, 6))
    c = np.arange(1, 6)
    # a = b = c
    # arange([start,] stop[, step,], dtype=None)
    print(a, b, c)
    # 数组的类名
    print(type(a))
    # 数组的类型
    print(a.dtype)

1.  数据类型的操作

# 数据类型的操作
    # 指定创建数组类型
    a=np.array([0,1,0,1], dtype=np.bool)
    print(a)
    # 修改数组类型
    b = a.astype("int")
    print(b)
    
    a=np.array([0,1,0,1], dtype=int)
    b = a.astype("float")
    print(a)
    print(b)
    # 修改浮点型的小数位数
    a = np.array([i/123 for i in range(1, 10)], dtype=np.float)
    print(a)
    b = np.round(a, 2)
    print(b)

1.  数组的形状

a = np.array([[i for i in range(1, 6)], [i for i in range(6, 11)]], dtype=np.int)
    print(a)
    # 查看数组的形状
    print(a.shape)
    # (2, 5)
    # 修改数组的形状
    b = a.reshape(5, 2)
    print(b)
    # 把数组转换为一维数据
    c = b.reshape(1, 10)
    print(c)
    print(list(b.flatten()))
    print([*b.flat])
    print(b.ravel())

1.  数组和数的计算

# 数组和数的计算
    a = np.array([[i for i in range(3, 9)], [i for i in range(4, 10)]], dtype=np.int)
    # 加减
    print(a)
    print(a+1)
    # 乘除
    print(a*3)
    # numpy 广播机制造成的，在运算过程中，加减乘除的值被广播到所有元素上面
    print(a[0]*3)

1.  数组和数组的计算

import numpy as np
    
    # 数组和数组的计算
    a = np.array([[i for i in range(3, 9)], [i for i in range(4, 10)]], dtype=np.int)
    
    b = np.array([[i for i in range(13, 19)], [i for i in range(14, 20)]], dtype=np.int)
    # 多行与多行，行数相同，多列与多列，列数相同
    # 加减
    print(a+b)
    # 乘除
    print(a*b)
    
    # 多行与多行，行数相同，多列与多列，列数不同
    # c = np.array([[i for i in range(13, 18)], [i for i in range(14, 19)]], dtype=np.int)
    # print(a*c)
    
    # 单行与多行，行数不同，多列与多列，列数相同
    d = np.array([i for i in range(1, 7)])
    print(a-d)
    print(a*d)
    
    # 多行与多行，行数相同，单列与多列，列数不同
    e = np.array([[i for i in range(1, 2)], [i for i in range(2, 3)]])
    print(a+e)
    print(a*e)

1.  广播原则> 如果两个数组的**后缘维度(从末尾开始算起的维度)的轴长度相符**或**其中一方的长度为1**，则认为它们是广播兼容的。广播会在**缺失维度**和(或)**轴长度为1的维度**上进行。

怎么理解呢?  
可以把维度指的是shape所对应的数字个数  
那么问题来了:  
shape为(3,3,3)的数组能够和(3,2)的数组进行计算么?  
shape为(3,3,2)的数组能够和(3,2)的数组进行计算么?  
有什么好处呢?  
举个例子:每列的数据减去列的平均值的结果  
7. 轴（axis）> 在numpy中可以理解为方向,使用0,1,2…数字表示,对于一个一维数组,只有一个0轴,对于2维数组(shape(2,2)),有0轴和1轴,对于三维数组(shape(2,2, 3)),有0,1,2轴

> 有了轴的概念之后,我们计算会更加方便,比如计算一个2维数组的平均值,必须指定是计算哪个方向上面的数字的平均值  
> 那么问题来了:  
> 在前面的知识,轴在哪里?  
> 回顾np.arange(0,10).reshape((2,5)),reshpe中2表示0轴长度(包含数据的条数)为2,1轴长度为5,2X5一共10个数据

二维数组的轴  
!\[image.png\](https://img-blog.csdnimg.cn/img\_convert/38525552048b55beeb5a8bcb83371c4d.png\#align=left&display=inline&height=402&margin=\[object Object\]&name=image.png&originHeight=402&originWidth=504&size=115247&status=done&style=none&width=504)  
三维数组的轴  
!\[image.png\](https://img-blog.csdnimg.cn/img\_convert/5acc441bcaa5322a72468c8d166f3e81.png\#align=left&display=inline&height=457&margin=\[object Object\]&name=image.png&originHeight=457&originWidth=750&size=166739&status=done&style=none&width=750)

### numpy 读取数据 ###

> CSV:Comma-Separated Value,逗号分隔值文件  
> 显示：表格状态  
> 源文件：换行和逗号分隔行列的格式化文本,每一行的数据表示一条记录  
> 由于csv便于展示,读取和写入,所以很多地方也是用csv的格式存储和传输中小型的数据,为了方便教学,我们会经常操作csv格式的文件,但是操作数据库中的数据也是很容易的实现的

np.loadtxt(frame,dtype=np.float,delimiter=None,skiprows=0,usecols=None,unpack=False)

!\[image.png\](https://img-blog.csdnimg.cn/img\_convert/ca74f2b5babddb824e53b17169ac0b51.png\#align=left&display=inline&height=326&margin=\[object Object\]&name=image.png&originHeight=326&originWidth=684&size=62702&status=done&style=none&width=684)

!\[image.png\](https://img-blog.csdnimg.cn/img\_convert/3426cbd9145e11193bb6a894199b2352.png\#align=left&display=inline&height=310&margin=\[object Object\]&name=image.png&originHeight=310&originWidth=760&size=115091&status=done&style=none&width=760)

> 假设现在我们有一组从2006年到2016年1000部最流行的电影数据，我们想知道这些电影数据中评分的平均分，导演的人数等信息，我们应该怎么获取？  
> 数据来源：[https://www.kaggle.com/damianpanek/sunday-eda/data][https_www.kaggle.com_damianpanek_sunday-eda_data]

#### 1. numpy中的转置 ####

> 转置是一种变换,对于numpy中的数组来说,就是在对角线方向交换数据,目的也是为了更方便的去处理数据

In [7]: t = np.array([i for i in range(18)]).reshape(3, 6)
    
    In [8]: t
    Out[8]:
    array([[ 0,  1,  2,  3,  4,  5],
           [ 6,  7,  8,  9, 10, 11],
           [12, 13, 14, 15, 16, 17]])
    
    In [9]: t.transpose()
    Out[9]:
    array([[ 0,  6, 12],
           [ 1,  7, 13],
           [ 2,  8, 14],
           [ 3,  9, 15],
           [ 4, 10, 16],
           [ 5, 11, 17]])
           
    In [11]: t.swapaxes(1, 0)
    Out[11]:
    array([[ 0,  6, 12],
           [ 1,  7, 13],
           [ 2,  8, 14],
           [ 3,  9, 15],
           [ 4, 10, 16],
           [ 5, 11, 17]])
    
    In [12]: t.T
    Out[12]:
    array([[ 0,  6, 12],
           [ 1,  7, 13],
           [ 2,  8, 14],
           [ 3,  9, 15],
           [ 4, 10, 16],
           [ 5, 11, 17]])

### numpy 索引和切片 ###

In [16]: t
    Out[16]:
    array([[ 0,  1,  2,  3,  4,  5],
           [ 6,  7,  8,  9, 10, 11],
           [12, 13, 14, 15, 16, 17]])
    
    In [17]: t[1] # 取一行
    Out[17]: array([ 6,  7,  8,  9, 10, 11])
    
    In [18]: t[:,2] # 取一列
    Out[18]: array([ 2,  8, 14])
    
    In [19]: t[1:3] # 取多行
    Out[19]:
    array([[ 6,  7,  8,  9, 10, 11],
           [12, 13, 14, 15, 16, 17]])
    
    In [20]: t[:, 1:3] # 取多列
    Out[20]:
    array([[ 1,  2],
           [ 7,  8],
           [13, 14]])
           
    In [21]: t[:, [1,3]] 取特定的多列
    Out[21]:
    array([[ 1,  3],
           [ 7,  9],
           [13, 15]])
    
    In [22]: t[[1,2]]  # 取特定的多行
    Out[22]:
    array([[ 6,  7,  8,  9, 10, 11],
           [12, 13, 14, 15, 16, 17]])

### numpy中数值的修改 ###

In [23]: t
    Out[23]:
    array([[ 0,  1,  2,  3,  4,  5],
           [ 6,  7,  8,  9, 10, 11],
           [12, 13, 14, 15, 16, 17]])
    
    In [24]: t[:, 2:4] = 0
    
    In [25]: t
    Out[25]:
    array([[ 0,  1,  0,  0,  4,  5],
           [ 6,  7,  0,  0, 10, 11],
           [12, 13,  0,  0, 16, 17]])
    
    
    # 布尔索引
    In [26]: t=np.arange(24).reshape((4,6))
    
    In [27]: t
    Out[27]:
    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]])
    
    In [28]: t<10
    Out[28]:
    array([[ True,  True,  True,  True,  True,  True],
           [ True,  True,  True,  True, False, False],
           [False, False, False, False, False, False],
           [False, False, False, False, False, False]])
    
    In [29]: t[t<10]=0
    
    In [30]: t
    Out[30]:
    array([[ 0,  0,  0,  0,  0,  0],
           [ 0,  0,  0,  0, 10, 11],
           [12, 13, 14, 15, 16, 17],
           [18, 19, 20, 21, 22, 23]])
    # numpy中三元运算符
    In [32]: t=np.arange(24).reshape((4,6))
    
    In [33]: t
    Out[33]:
    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]])
    
    In [34]: np.where(t<10, 0, 10)
    Out[34]:
    array([[ 0,  0,  0,  0,  0,  0],
           [ 0,  0,  0,  0, 10, 10],
           [10, 10, 10, 10, 10, 10],
           [10, 10, 10, 10, 10, 10]])
    In [57]: t=np.arange(24).reshape((4,6))
    # numpy中的clip(裁剪)
    In [58]: t.clip(10, 18)
    Out[58]:
    array([[10, 10, 10, 10, 10, 10],
           [10, 10, 10, 10, 10, 11],
           [12, 13, 14, 15, 16, 17],
           [18, 18, 18, 18, 18, 18]])
    
    In [59]:

### numpy中的nan和inf ###

> nan(NAN,Nan):not a number表示不是一个数字  
> 什么时候numpy中会出现nan：  
> 当我们读取本地的文件为float的时候，如果有缺失，就会出现nan  
> 当做了一个不合适的计算的时候(比如无穷大(inf)减去无穷大)  
> inf(-inf,inf):infinity,inf表示正无穷，-inf表示负无穷  
> 什么时候回出现inf包括（-inf，+inf）  
> 比如一个数字除以0，（python中直接会报错，numpy中是一个inf或者-inf）

#### 1. numpy中的nan的注意点 ####

1.  两个nan不相等

In [1]: import numpy as np
    
    In [2]: np.nan==nap.nan
    ---------------------------------------------------------------------------
    NameError                                 Traceback (most recent call last)
    <ipython-input-2-2b42aa695106> in <module>
    ----> 1 np.nan==nap.nan
    
    NameError: name 'nap' is not defined
    In [7]: np.nan!=np.nan
    Out[7]: True

1.  判断nan的个数\`\`\`  
    In \[13\]: t=np.array(\[1, 2, np.nan\])

In \[14\]: np.count\_nonzero(t!=t)

3. 判断nan```
    In [12]: t=np.array([1, 2, np.nan])
    
    In [15]: t[np.isnan(t)]=0
    
    In [16]: t
    Out[16]: array([1., 2., 0.])

1.  nan和任何值计算都为nan  
    nan 填充均值

# t中存在nan值，如何操作把其中的nan填充为每一列的均值
    
    import numpy as np
    t = np.array([[  0.,   1.,   2.,   3.,   4.,   5.],
           [  6.,   7.,  np.nan,   9.,  10.,  11.],
           [ 12.,  13.,  np.nan,  np.nan,  np.nan,  17.],
           [ 18.,  19.,  20.,  21.,  22.,  23.]])
    
    # print(t.shape)
    def fill_nan_by_column_mean(t):
        for i in range(t.shape[1]):
            nan_num = np.count_nonzero(t[:, i][t[:, i] != t[:, i]])  # 计算非nan的个数
            if nan_num > 0:
                now_col = t[:, i]
                now_col_not_nan = now_col[np.isnan(now_col)==False].sum()
                now_col_mean = now_col_not_nan/(t.shape[0]-nan_num)
                now_col[np.isnan(now_col)] = now_col_mean
                t[:, i] = now_col
        print(t)
    fill_nan_by_column_mean(t)

### numpy中常用统计函数 ###

求和：t.sum(axis=None)
    
    均值：t.mean(a,axis=None) 受离群点的影响较大
    
    中值：np.median(t,axis=None)
    
    最大值：t.max(axis=None)
    
    最小值：t.min(axis=None)
    
    极值：np.ptp(t,axis=None) 即最大值和最小值只差
    
    标准差：t.std(axis=None)   ==样本标准差

> 标准差是一组数据平均值分散程度的一种度量。一个较大的标准差，代表大部分数值和其平均值之间差异较大；一个较小的标准差，代表这些数值较接近平均值  
> 反映出数据的波动稳定情况，越大表示波动越大，约不稳定

> ##### 默认返回多维数组的全部的统计结果,如果指定axis则返回一个当前轴上的结果 #####

### 数据组的拼接 ###

In [30]: t1 = np.arange(0, 12).reshape((2, 6))
    
    In [31]: t2 = np.arange(12, 24).reshape((2, 6))
    
    In [32]: t1
    Out[32]:
    array([[ 0,  1,  2,  3,  4,  5],
           [ 6,  7,  8,  9, 10, 11]])
    
    In [33]: t2
    Out[33]:
    array([[12, 13, 14, 15, 16, 17],
           [18, 19, 20, 21, 22, 23]])
    
    In [34]: np.vstack((t1, t2))        # 垂直拼接 行拼接
    Out[34]:
    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]])
    
    In [35]: np.hstack((t1, t2))   # 水平拼接 列拼接
    Out[35]:
    array([[ 0,  1,  2,  3,  4,  5, 12, 13, 14, 15, 16, 17],
           [ 6,  7,  8,  9, 10, 11, 18, 19, 20, 21, 22, 23]])
    
    In [36]:

### 数组的行列交换 ###

In [50]: t2 = np.arange(12, 24).reshape((3, 4))
    
    In [51]: t2
    Out[51]:
    array([[12, 13, 14, 15],
           [16, 17, 18, 19],
           [20, 21, 22, 23]])
    
    In [52]: t2[[1,2], :] = t2[[2,1], :]
    
    In [53]: t2
    Out[53]:
    array([[12, 13, 14, 15],
           [20, 21, 22, 23],
           [16, 17, 18, 19]])
    
    In [55]: t2[:, [0,2]]=t2[:,[2,0]]
    
    In [56]: t2
    Out[56]:
    array([[14, 13, 12, 15],
           [22, 21, 20, 23],
           [18, 17, 16, 19]])

### numpy更多好用的方法 ###

1.  获取最大值最小值的位置
    
    1.  np.argmax(t,axis=0)获取每一列的最大值得位置
    2.  np.argmin(t,axis=1)
2.  创建一个全0的数组: np.zeros((3,4))
3.  创建一个全1的数组:np.ones((3,4))
4.  创建一个对角线为1的正方形数组(方阵)：np.eye(3)

### numpy生成随机数 ###

!\[image.png\](https://img-blog.csdnimg.cn/img\_convert/4c57e78a473f2d7e3061743d12a86acc.png\#align=left&display=inline&height=612&margin=\[object Object\]&name=image.png&originHeight=612&originWidth=1206&size=200855&status=done&style=none&width=1206)

### numpy的注意点copy和view ###

1.  a=b 完全不复制，a和b相互影响
2.  a = b\[:\],视图的操作，一种切片，会创建新的对象a，但是a的数据完全由b保管，他们两个的数据变化是一致的，
3.  a = b.copy(),复制，a和b互不影响

[https_www.kaggle.com_damianpanek_sunday-eda_data]: https://www.kaggle.com/damianpanek/sunday-eda/data