Python可视化：数据可视化之 NumPy——ndarray (详细集全）（1）

桃扇骨 2022-12-16 11:59 247阅读 0赞

### Numpy基础 ###

*   *  1.1 NumPy数组对象ndarray
     *   *  1.1.1 创建NumPy 数组、查看数组的属性
         *   *  1.1.1.1 np.array()函数
             *  1.1.1.2 其它内置函数创建数组
             *  1.1.2.3 numpy.random模块：创建随机数数组
         *  1.1.2 ndarry对象的数据类型
         *   *  1.1.2.1 创建数据类型:
             *  1.1.2.2 转换数据类型
         *  1.1.3 数组的切片与索引
         *  1.1.4 展开函数
         *   *  1.1.4.1 数组的拼接和分裂

## 1.1 NumPy数组对象ndarray ##

**NumPy**：Numerical Python，是一个开源的Python科学计算库，它是一个由多维数组对象和用于处理数组的例程集合组成的库。

**NumPy的基本功能如下：**

*  提供了一个具有矢量算术运算和复杂广播功能的快速且节省空间的多维数组对象ndarray。
 *  用于对数组执行元素级计算以及直接对数组执行数学运算的函数。
 *  用于读写硬盘上基于数组的数据集的工具，以及用于操作内存映射文件的工具。
 *  提供了线性代数、随机数生成以及傅立叶变换功能。

**NumPy提供了两种基本对象：** ndarray（N-dimensional Array Object）和 ufunc（Universal Function Object）。  
**ndarray：** 多维数组对象。ndarray一般是同质的（但特殊的数组类型可以是异质的），即数组中所有元素的数据类型必须一致；  
**ufunc：** 对数组进行处理的函数。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70_pic_center]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70_pic_center 1]  
.

### 1.1.1 创建NumPy 数组、查看数组的属性 ###

#### 1.1.1.1 np.array()函数 ####

最简单的创建ndarray对象的方式是使用array()函数，在调用该函数时传入一个列表或者元组。numpy.array(object, dtype=None, copy=True, order=‘K’, subok=False, ndmin=0)

object：表示想要创建的数组。无默认
    dtype：数组所需的数据类型。如果未给定，则选择保存对象所需的最小类型。默认为None
    ndim：指定生成数组的最小维度，默认为None

# 导入NumPy工具包
    import numpy as np   
    #从列表或元组创建一维数组
    arr1 = np.array([1,2,3,4])
    arr2 = np.array((5,6,7,8,))
    print(arr1)
    print(arr2)
    
    #从列表或元组创建二维数组
    arr3 = np.array([[1,2,3], [4,5,6], [7,8,9]])  # 嵌套列表
    print(arr3)
    
    # 查看数组的形状
    print(arr1.shape)
    print(arr3.shape)
    # 查看数组的维度
    print(arr3.ndim)
    # 查看数组的数据类型
    print(arr1.dtype)
    # 查看数组的数据元素总数
    print(arr3.size)
    # 查看数组每个元素的大小
    print(arr3.itemsize)

#### 1.1.1.2 其它内置函数创建数组 ####

**np.zeros()函数：** 创建元素值都是 0 的数组，第一个参数为元组，用来指定数组的大小，也可以用dtype来指定数组的数据类型。

**np.ones()函数：** 创建元素值都是 1 的数组，第一个参数为元组，用来指定数组的大小，也可以用dtype来指定数组的数据类型。

**np.empty()函数：** 未初始化数组，返回的是未初始的随机值（内存里的随机值）。

**np.diag()函数：** 创建以指定的值作为对角线元素值的数组

**np.eye() 函数：** 创建对角线元素值为 1 的数组（单位矩阵）

zero = np.zeros((4,5), dtype = int)
    ones =np.ones((5, 4))
    print(zero,"\n")
    print(ones)
    
    empty = np.empty((4, 5))
    print(empty)
    diag = np.diag([1,2,3,4])
    print("\n",diag,"\n")
    eye = np.eye(5)
    print(eye)

np.arange()函数：类似 python 的 range() ，创建一个一维数组。
    reshape()函数：重新调整数组的维数

# arange()创建一维数组
    z1 =  np.arange(15) # z注意从0开始
    # arange()创建指定范围的一维数组
    z2 = np.arange(4,15)
    # arange()创建[1,15)内等差值为2的数组
    z3 = np.arange(1,15,2)
    # arange()与reshape()联用调整数组的维数
    z4 = np.arange(15).reshape(3,5)
    print(z1)
    print(z2)
    print(z3)
    print("\n",z4)

np.linspace()函数：创建指定区间内均匀分布的数组,等差数列
    np.logspace()函数：创建等比序列

# 创建一个5个元素的数组，这5个数均匀的分布到 0~1
    L1 = np.linspace(0,1,5)
    # 创建一个5个元素的数组，这5个数均匀的分布到 2~10
    L2 = np.linspace(2,10,5)
    # 创建一个3个元素的数组，这3个数在1~100之间，呈等比关系
    L3 = np.logspace(0,2,3)# log10的对数的值==0,1,2 ==> 1,10,100
    
    print(L1)
    print(L2)
    print(L3)

#### 1.1.2.3 numpy.random模块：创建随机数数组 ####

与Python的random模块相比，NumPy的random模块功能更多，它增加了一些可以高效生成多种概率分布的样本值的函数。

random()函数：numpy.random.random(size=None)  
该函数作用产生\[0.0, 1.0)之间的浮点数。size表示生成元素个数。若没有参数输入，则生成一个数。

rand()函数：numpy.random.rand(d0, d1, …, dn)  
该函数作用生成一个(d0, d1, …, dn)维的数组，数组的元素取自\[0, 1)内均匀分布的随机数。若没有参数输入，则生成一个数。括号里面的参数是指定产生数组的形状。

randn()函数：numpy.random.randn(d0, d1, …, dn)  
该函数作用生成一个(d0, d1, …, dn)维的数组，数组的元素是标准正太分布随机数。若没有参数输入，则生成一个数。括号里面的参数是指定产生数组的形状。

randint()函数：numpy.random.randint(low \[low, high, size, dtype\])  
该函数作用生成指定范围的随机数，随机数取值区间为\[low, high)，若没有输入参数high则取值区间为\[0, low)。size参数是元组，用于确定数组的形状。

# 创建16个[0.0, 1.0)之间的随机数一维数组,用reshape(4,4)成4*4二维数组。
    np.random.random(16).reshape(4,4)
    
    # 创建一个[0, 1)之间的二维随机数数组，数组形状为2行3列
    n2 = np.random.rand(2,3)
    
    # 创建一个[0, 1)之间的三维随机数数组，数组形状为(2,3,4)
    n3 = np.random.rand(2,3,4)
    
    print(n2,"\n")
    print(n3)
    
    rn = np.random.randn(2,3)
    print("\n",rn)
    
    # 创建一个 3行4列的随机整数数组，元素在[2,10)之间
    ni = np.random.randint(2,10,size=(3,4))
    print(ni)

random模块常用随机数生成函数:

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70_pic_center 2]  
.

### 1.1.2 ndarry对象的数据类型 ###

ndarry对象的数据类型：NumPy的数据类型是由一个类型名和元素位长的数字组成。
    NumPy中常用的数据类型：每一个NumPy内置的数据类型都有一个特征码，它能唯一标识一种数据类型。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70_pic_center 3]

# 查看数据类型
    data_one = np.array([[1, 2, 3], [4, 5, 6]])
    print(data_one.dtype)

#### 1.1.2.1 创建数据类型: ####

> 自定义数据类型是一种异构数据类型。  
> 例如，创建一个存储书店库存信息的数据类型。其中，书名是用字符串表示的长度为30个字符，商品的库存数量用64位的整数来记录，书的价格用64位的单精度浮点数来记录。那么，使用自定义数据类型来创建数组的方法如下。  
> （1）使用dtype创建自定义数据类型；  
> （2）查看数据类型，可直接查看或使用numpy.dtype()函数查看；  
> （3）使用array()函数创建数组时，使用dtype指定数组的数据类型为自定义数据类型。

df = np.dtype([("name", np.str_, 30), ("number", np.int64), ("price",np.float64)])
    
    # 2）查看数据类型，可直接查看或使用 numpy.dtype() 函数查看
    print(df["name"])
    print(np.dtype(df["name"]))
    
    # 3）使用自定义的数据类型 df 创建一个书籍item 数组
    item = np.array([("斗罗大陆", 42, 26.14), ("斗破苍穹", 13, 25.72)], dtype=df)
    print(item)
    item

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70_pic_center 4]  
.

#### 1.1.2.2 转换数据类型 ####

转换数据类型  
① 类似Python中的强制类型转换  
② astype() 函数

data = np.array([[1, 2, 3], [4, 5, 6]]) 
    print(data.dtype)
    
    # astype()函数将 数据类型转换为 float64
    float_data = data.astype(np.float64) 
    print(float_data.dtype)
    
    # 创建一个浮点数二维数组
    float_data = np.array([1.2, 2.3, 3.5])
    print("\n",float_data)
    
    # astype()函数将数据类型转换为 int64
    int_data = float_data.astype(np.int64) 
    print(int_data)
    
    # 创建一个字符二维数组
    str_data = np.array(['1', '2', '3'])
    print("\n",str_data)
    
    # astype()函数将 数据类型转换为 int64
    int_data = str_data.astype(np.int64)
    print(int_data)

### 1.1.3 数组的切片与索引 ###

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70_pic_center 5]

# 创建一个一维数组
    arr = np.arange(10)
    # 获取索引为1~6的元素，步长为2
    print(arr[1:6:2])
    
    # 下标还可以用来修改元素的值
    arr[2:4] = 100,101
    print(arr)

# 创建二维数组
    arr2d = np.arange(1,10).reshape(3,3)
    print(arr2d)
    
    # 获取索引为1的元素
    print(arr2d[1])
    
    # 获取位于第1行第2列的元素
    print(arr2d[1,2])

多维数组的切片是沿着行或列的方向选取元素的，我们可以传入一个切片，
    也可以传入多个切片，还可以将切片与整数索引混合使用。

# 在一个中括号[ ] 里 以逗号 ， 分行与列
    print("传入一个切片：取连续多行:\n",arr2d[0:2])# 操作行
    
    print("取不连续的多行:\n",arr2d[[0,2]]) # 把[0,2]看成一个整体X，操作行
    
    # 取第2列,索引为1
    s = arr2d[:,1]
    print("第2列:\n",s)
    
    s1 = arr2d[:,1:3]
    print("取连续多列:\n",s1)
    
    s2 = arr2d[:,[0,2]]
    print("取不连续的多列:\n",s2)
    
    d = arr2d[0:3, 0:2]
    print("取3行2列:\n",d)
    
    a = arr2d[[0,2],[1,2]]
    print("取第0行第2个元素&最后一个元素:\n",a)

布尔型索引的基本使用:
    	布尔型索引指的是将一个布尔数组作为数组索引，
    	返回的数据是布尔数组中True对应位置的值。

arr = np.arange(16).reshape(4,4)
    print(arr)
    # 创建 mask 布尔数组 [1,0,1,0]
    mask = np.array([1,0,1,0],dtype = np.bool) # 索引[0,2] 为 True
    # 用 mask 索引第1、3行中第3列的元素
    print(mask)
    arr[mask,2]

# 存储学生姓名的数组
    student_name = np.array(['Tom', 'Lily', 'Jack', 'Rose'])
    
    # 存储学生成绩语数英的数组
    student_score = np.array([[79, 88, 80], [89, 90, 92],
     [83, 78, 85], [78, 76, 80]]) 
    
    # 如何提取Jack的成绩？ 1、确认索引为Jack为Ture的值，
    # 2、索引Ture的成绩数组
    print("Jack索引值：",student_name=="Jack")
    student_score[student_name=="Jack"]
    
    #【练习】arr = np.arange(24).reshape(4,6) 如果我们想
    # 把arr中小于10的数字替换为0，把大于10的替换为10，应该怎么做？？
    
    arr = np.arange(24).reshape(4,6)
    print("替换前的数组arr = \n", arr)
    arr[arr<10] = 0
    arr[arr>10] = 10
    print("替换后的数组arr = \n", arr)

numpy提供了一个三元运算符：where（）
    	where()函数是三元表达式 x if condition else y 的矢量化版本。
    	其格式为：np.where(condition, x, y)

# 用 where（）来实现上述需求
    arr = np.arange(24).reshape(4,6)
    print("替换前的数组arr = \n", arr)
    arr0 = np.where(arr<10, 0, 10)
    print("替换后的数组arr = \n", arr0)

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70_pic_center 6]  
.

### 1.1.4 展开函数 ###

# ravel()：展平数组
    arr = np.arange(12).reshape(3,4)
    print(arr)
    w1 = arr.ravel()
    print("ravel   展平：",w1)
    
    # flatten()：展平数组 与ravel() 的区别是：flatten() 可以选择横向或纵向展平
    print('flatten 数组展平为：',arr.flatten())  #横向展平
    print('flatten 数组展平为：',arr.flatten('F'))  #纵向展平

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70_pic_center 7]  
.

#### 1.1.4.1 数组的拼接和分裂 ####

数组的拼接（组合）
    hstack（）：数组横向组合；
    vstack（）：数组纵向组合；
    concatenate（）：axis=0时纵向组合，axis=1时横向组合。

arr1 = np.arange(12).reshape(3,4)
    print('创建的数组1为：\n',arr1)
    arr2 = arr1*3
    print('创建的数组2为：\n',arr2)
    
    # hstack函数横向组合
    print("横向组合：\n", np.hstack((arr1,arr2)))
    # vstack函数纵向组合
    print("纵向组合：\n", np.vstack((arr1,arr2)))
    
    # concatenate函数横向组合
    print("横向组合：\n", np.concatenate((arr1,arr2), axis = 1))
    # concatenate函数纵向组合
    print("纵向组合：\n", np.concatenate((arr1,arr2), axis = 0))

数组的分裂（分割）
     - hsplit（）：数组横向分割 
     - vsplit（）：数组纵向分割 
     - split（）：axis=0时纵向分割，axis=1时横向分割

arr = np.arange(16).reshape(4,4)
    print('创建的二维数组为：\n',arr)
    #hsplit函数横向分割
    print("横向分割成2个数组：\n", np.hsplit(arr, 2))
    
    #vsplit函数纵向分割
    print("纵向分割成2个数组：\n", np.vsplit(arr, 2))
    
    #split函数横向分割
    print("横向分割成4个数组：\n", np.split(arr, 4, axis=1))
    #split函数纵向分割
    print("纵向分割成4个数组：\n", np.split(arr, 4, axis = 0))

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70_pic_center 8]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70_pic_center]: /images/20221123/6218868b5b254c76a932697967ea3ae6.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70_pic_center 1]: /images/20221123/265228db3f494049a780a7d73cfb113e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70_pic_center 2]: /images/20221123/c82636f8e72c4ac8b9b98a65d19a4c70.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70_pic_center 3]: /images/20221123/1c38d7a329954c6fbc9f9ee37fabb9cf.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70_pic_center 4]: /images/20221123/0bf85b3eee06406ea238b1b64413499f.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70_pic_center 5]: /images/20221123/7183f3879685425db8b863dc28058937.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70_pic_center 6]: /images/20221123/349e97d2f2aa48faa8675a07c2cf917d.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70_pic_center 7]: /images/20221123/752fde90e39a48149b4ad6df522854f9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NDc3NTI1NQ_size_16_color_FFFFFF_t_70_pic_center 8]: /images/20221123/2bead1367e7a4f3f9ac92d04c00eb7e8.png