Python框架【Numpy】

---

---

提示：以下是本篇文章正文内容，下面案例可供参考

一、数据分析流程

1. 数据收集：数据从哪里来
2. 数据清洗：缺失值，错误数据，格式混乱
3. 数据分析：统计，分组对比等等
4. 数据可视化：折线图，柱状图，散点图

---

二、Anaconda

网上自行搜索

2.1 Jupyter命令

• ESC：从输入模式退出到命令模式
• a：在当前cell上面创建一个新的cell
• b：在当前cell下面创建一个新的cell
• dd：删除当前cell
• m：切换到markdown模式
• y：切换到code模式
• ctrl+Enter（回车）：运行cell
• shift+Enter（回车）：运行当前cell并创建一个新的cell

---

三、Numpy

Numpy是Python中用于科学计算的一个基础包！提供多维数组对象、各种派生对象（例如掩码数组和矩阵）以及用于对数组进行快速操作的各种方法，包括数学、逻辑、形状操作、排序、选择、IO、离散傅里叶变换、基本线性代数、基本统计运算、随机模拟等等。

3.1 ndarray特性

• 多维性：支持0维(标量)、1维(向量)、2维(矩阵)及更高维数组。
  

• 同质性：所有元素类型必须一致(通过dtype指定)。
  

• 高效性：基于连续内存块存储，支持向量化运算。->后续补充

---

3.2 ndarray属性

属性	描述
np.dim	数组的维度
np.shape	数组的形状：【X行X列】
np.size	数组的元素个数
np.dtype	数组的元素类型：数组元素类型遵从同质性，自动向上转型
np.T	数组元素的转置：转置的意思是将行变列，列变行
np.itemsize	单个元素占用的内存字节数
np.nbytes	数组总内存占用量：size * itemsize
np.flags	内存存储方式：是否连续存储（高级优化）

import numpy as np
arrs = np.array([[1,2,3],[4,5,6],[9,4,8]]) # 利用numpy的array对象创建数组
print(arrs)
print(arrs.shape) # shape方法：X行X列，打印数组形状
print(arrs.ndim) # 数组的维度
print(arrs.size) # 数组的个数
print(arrs.dtype) # 数组元素的类型
print(arrs.itemsize) # 单个元素占用的内存字节数
print(arrs.nbytes) # 数组内存总占用量
print(arrs.flags)

---

3.3 ndarray创建方式

3.3.1 基础构造

# 1.基础创建方法类型
list1 = [1, 2, 3, 4]

demo2 = np.array(list1,dtype=np.float64) # 将数组强转成float64类型
print(demo2.ndim)
print(demo2)
# copy
demo = np.copy(demo2) # 元素跟原始数组相同，但不是一个数组的，都是独立个体
demo[0] = 3
print(demo)

---

3.3.2 预定义形状填充

# 2.预定义形状填充
# 全0，全1，未初始化，固定值
# 全0
demo3 = np.zeros((2, 3), dtype=int)
print(demo3)
demo4 = np.zeros((2,), dtype=list)
print(demo4)
# 全1
demo5 = np.ones((5,6), dtype=int)
print(demo5)

---

3.3.3 未初始化填充

# 3.未初始化
demo6 = np.empty((5,6), dtype=int)
print(demo6)

---

3.3.4 固定值

# 4.固定值
demo7 = np.full((5,6), 3, dtype=int)
print(demo7)

---

3.3.5 扩充

# zeros_like：形状跟谁一样，并全部填充为0
demo8 = np.zeros_like(demo7)
print(demo8)
# ones_like：形状跟谁一样，并全部填充为1
demo9 = np.ones_like(demo7)
print(demo9)
# full_like：形状跟谁一样，并全部填充为指定数
demo10 = np.full_like(demo7,2026)
print(demo10)
demo11 = np.empty_like(demo7)
print(demo11)

---

3.3.5 等差数列

# 5. 等差数列
arr = np.arange(1,10,1)#左闭右开（开始，结束，步长）
print(arr)

---

3.3.6 等间隔数列

# 6.等间距数列
app = np.linspace(2,10,5,dtype=int)# float转int
print(app)

---

3.3.7 对数间隔数列

arr = np.logspace(0,4,5,base=2,dtype=int) #（起始幂，结束幂，计算次数，底，元素数据类型）
print(arr)

---

3.4 矩阵

1.定义：矩阵是由行和列排成的矩形数组。
2.形状：X行X列，如：2行3列矩阵。
3.元素：矩阵中的每个数字称为元素。

---

3.4.1 特殊矩阵

主对角线概念：（从左上到右下）上的元素全部为1。

# 特殊矩阵
# 单位矩阵：主对角线【从左上到右下】数字1，其他的数字为0
arr = np.eye(2, 3, dtype=int)  # 单数字，X行X列，两个数字：n行m列
print(arr)
# 对角矩阵：主对角线上非0的数字，其他的数字为0
arr = np.diag([5, 32, 32, 1, 2, 3])  # 几个数字就是几行几列，根据给的数字从左上到右下依次展示，其他区域元素为0
print(arr)
# 随机数组的生成
# 生成0-1之间的随机浮点数（均匀分布）
arr = np.random.randn(2, 3)  # X行Y列
print(arr)
print("-------------------------------------------")
# 生成指定范围内的随机浮点数
arr = np.random.uniform(2, 3, (3, 3))  #（low,high,(x,y)）范围左闭右开，(X行Y列)
print(arr)
print("-------------------------------------------")
# 扩充 我想让生成的浮点数保留X位小数
arr2 = np.round(arr, decimals=6)
print(arr2)
print("-------------------------------------------")
# 生成指定范围内的随机浮点数
arr3 = np.random.randint(1, 99, (3, 3))  #（low,high,(x,y)）范围左闭右开，(X行Y列)
print(arr3)
print("-------------------------------------------")
# 生成随机数列（正态分布：两边小，中件大）引:正态分布 = 中间最多，越往两边越少，而且左右对称。
arr = np.random.randn(2, 3)
print(arr)
print("-------------------------------------------")
# 设置随机种子(以下生成的随机数都是固定的)
np.random.seed(20)  # 钥匙对应锁子
arr = np.random.randint(1, 10, (2, 5))  #前面配置了种子参数，无论怎么生成都是固定值
print(arr)

---

3.5 ndarry数据类型

---

3.6 索引与切片

主要作用是查询数据

索引/切片类型	描述/用法
整数索引	通过整数索引直接访问元素，索引下标从0开始
行/列索引	使用冒号:切片语法选择行或列的子集
连续切片	从开始索引到结束索引按照步长进行切片
slice函数	slice(start,stop,step)定义切片规则
布尔索引	通过布尔条件筛选满足条件的元素。支持逻辑运算符&和

3.6.1 一维数组的索引和切片

# 创建一维数组
arr = np.random.randint(1, 100, 20)
# 获取全部
print(arr[:])
# 整数索引
print(arr[2])
# 行列式索引
# start：从哪个索引开始（包含）
# end：到哪个索引结束（不包含）
# step：步长，隔几个取一个
print(arr[2:8])  # start:end+1【左闭右开】
# 布尔索引
print(arr[(arr > 80) & (arr < 90)])
# slice函数
print(arr[slice(2, 8,2)])

---

3.6.2 二维数组的索引和切片

# 4行8列二维数组矩阵
arr = np.random.randint(1, 100, (4, 8))
# 全部打印
print(arr)
# 整数索引
print(arr[1, 3])  # 二维数组用逗号隔开
# 切片索引
print(arr[2, 2:5])  # 完成写法 句意：第2行中，从第2个元素开始，到第5-1（左包右不包）个元素结束并打印
print(arr[2,])  # 省略写法：逗号后面不写，默认就是 :（取全部）
# 布尔索引条件必须来自被筛选的那个数组本身！
print(arr[(arr > 50) & (arr < 60)])  # 返回一维数组
print(arr[2, :][arr[2] > 50])  # 第2行中所有大于50的数字
# 列
print(arr[:, 2][arr[:, 2] > 1])  # 筛选第3列

3.7 ndarray的运算

# python原生计算
c = [1, 2, 3]
d = [4, 5, 6]
for i in range(len(c)):
     d[i] = d[i] + c[i]
print(d) # 原列表不变：[4, 5, 6]

# numpy之ndarray计算
# 一维数组计算
arr = np.array([1, 2, 3])
arr2 = np.array([3, 4, 5])
print(arr + arr2)
print(arr - arr2)
print(arr * arr2)
print(arr / arr2)

# numpy之ndarray计算
# 二维数组计算
arr = np.array([[1, 2, 3], [3, 4, 5]])
arr2 = np.array([[3, 4, 5], [4, 5, 6]])
print(arr + arr2)
print(arr - arr2)
print(arr * arr2)
print(arr / arr2)
print('-----------------------')
print(arr ** 2)  # 全部平方
print(arr + 3)  # 全部加3->数组+标量运算

---

3.7.1 广播机制

多维数组之间进行运算时，数组长度不相同，当维度从后往前匹配，或其中一个维度为1时，NumPy 会自动复制扩展数组，使其形状一致，再进行运算。

符合条件：

• 全部右对齐进行比较
• 相同
• 出现1（包含补位）

---

3.7.2 矩阵相乘@运算【向量点积】【线性代数】

1.形状匹配：

• 运算：arr的行×arr2的列
• 条件：左矩阵的列数 = 右矩阵的行数
• 结果Shape：保留两头

2.形状不匹配：

• 1.进行转置：转置只互换 行、列，不做计算、不改数字，专门用来凑维度，满足 @ 的条件。

# 形状不匹配，需要进行转置
arr = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([[4, 5, 6], [7, 8, 9]])
# arr.T，行列转置
print(arr @ arr2.T)

---

3.8 Numpy常用函数

3.8.1 基本数学函数

※关于四舍五入round，在NumPy中，np.round 用的是「银行家舍入：四舍六入五成双」，不是我们小学的「四舍五入」，银行家舍入规则为：

• 小数＜0.5：舍去
• 小数＞0.5：进一
• 小数刚好 = 0.5 → 看整数位：偶数保留，奇数进位

# 基本数学函数
# 1.1 计算平方根,返回的结果数据类型是浮点数
print(np.sqrt(4))
print(np.sqrt([1,4,9]))
arr  =np.array([[1, 2, 3], [4, 5, 6],[7,8,9]])
print(np.sqrt(arr))
# 1.2 计算指数，e^x，【e是自然常数，约等于2.71828183】
print(np.exp(0))
# 1.3 计算自然对数
print(np.log(2.71))
# 1.4 计算sin/cos
print(np.sin(-1))
print(np.cos(-1))
# 1.5 计算绝对值
arr2 = np.array([[1, -2, 3], [4, -5, 6],[7,8,-9]])
print(np.abs(arr2))
print('--------')
# 计算a的b次幂
print(np.power(arr2, 3))
# 四舍五入
print(np.round([1.1,42.11,95.5]))
# 向上取整
print(np.ceil([1.1,42.11,95.5]))
# 向下取整
print(np.floor([1.1,42.11,95.5]))
# 检车缺失值NaN
arr3 = np.array([1,np.nan,42.11,95.5])
print(arr3[np.isnan(arr3)])
print(arr3[~np.isnan(arr3)])# 反取

3.8.2 统计函数

np.random.seed(0) # 固定种子
arr = np.random.randint(1, 100, 6)
arr2 = np.sort(arr)
print('原数组：',arr)
print('排序数组：',arr2)
# 求和
print(np.sum(arr))
# 平均数
print(np.mean(arr))
# 中位数->偶数就是中间两个数字的平均值
print(np.median(arr))
# 标准差=方差开根
print(np.std(arr))
# 方差 ((x1 - avg)^2 + (x2 - avg)^2 + (x..- avg)^2 / len(arr))
print(np.var(arr))
print('---------')
# 最大值,数组位置
print(np.max(arr),np.argmax(arr))
# 最小值,数字位置
print(np.min(arr),np.argmin(arr))
# 分位数（中位数是一个特殊的分位数）
print(np.percentile(arr2,50))
print(arr)
# 求和
print(np.sum(arr))
#累积和
print(np.cumsum(arr))
#累积积
print(np.cumprod(arr))

---

3.8.3 比较函数

# 自定义条件np.where(条件，符合条件，不符合条件)
print(arr)
print(np.where(arr > 60, arr, 'NAN'))
# 多嵌套
np.random.seed(2)
arr6 = np.random.randint(0, 100, 80)
print(arr6)
print(np.where(
    arr6 < 60, '不及格', np.where(
        arr6 < 80, '良', '优'
    )
))
# 第二种方法
print(np.select(
    [(arr6 > 80), (arr6 >= 60) & (arr6 <= 80),arr6<60],
    ['1', '0.5', '0'],
    default='11'
))

---

3.8.4 排序函数

np.random.seed(6)
arr9 = np.random.randint(1, 100, 20)
print(arr9)
# sort排序
print('-----')
# 改变数组
# arr6.sort()
# print(arr6)
# 不改变原数组
print('-----')
print(np.sort(arr9))
# 获取原排序后的索引
print('-----')
print(np.argsort(arr9))
# 去重函数
print(np.unique(arr9))
# 数组拼接
print('-----')
arr11 = np.array([1, 23, 33])
arr12 = np.array([22, 34])
print(np.concatenate((arr11, arr12)))
# 数组分割(数组，切割位置)
print(np.split(arr9, [6, 12, 18]))
# 调整数组形状(数组,[X行,Y列])
print(np.reshape(arr9, [2, 10]))

---