Tips："分享是快乐的源泉💧，在我的博客里，不仅有知识的海洋🌊，还有满满的正能量加持💪，快来和我一起分享这份快乐吧😊！
喜欢我的博客的话，记得点个红心❤️和小关小注哦！您的支持是我创作的动力！"
数据可视化（三）：Pandas技术的基本操作案例，让你快速掌握数据处理技术
目录
- 数据可视化（三）：Pandas技术的基本操作案例，让你快速掌握数据处理技术
- 1. 创建一个范围为[0,1]的长度为12的等差数列
- 2. numpy排序函数有哪些？功能？
- 3. 创建一个10x10的ndarray对象，满足矩阵边界为1，里面全为0
- 4. 将数组arr中所有奇数置为-1对应的语句是
- 5. 根据要求编写代码
- 小知识：np.info()函数可以查阅numpy文档
- 6. 请创建一组值为 0 到 9 （包括9）的 ndarray 数组，并指定为 int8 类型，然后将其改为布尔类型，以及float16类型
- 7. 下列有一组数据，请使用一行代码同时获取 2.7、42、36 这三个元素:
- 8. 求数组 arr中所有元素的绝对值、四舍五入值、最大值和最小值：
- 9. 数组A和B如下，在不创建新数组的情况下，如何计算 (A+B)/(A-B) 的值？
- 10. 计算半径分别为 1,2,3, ... , 30的30个圆面积，结果保留两位小数，并以ndarray形式输出。
- 11. 下面是一组学生的数学成绩，请筛选得分大于 60 的人数：
- 12. 下列是一组学生的身高体重数据
- 13. 定义RGB结构
- 14. 创建一个8 x 8棋盘形状数组，输出如下样式：
- 15. 下面是一个数组，根据二维数组第二列的值，将数组升序排列。
- 16. 在数组arr中交换第一列和第二列
- 17. 获取下面数组a中前5个最大值
- 18. 下面数组按行计算去重后的元素数量（难）
- 19. 对于两个随机数组A和B，检查它们是否相等
- 20. 检查一个二维数组是否有空列（全0列）？
import numpy as np
1. 创建一个范围为[0,1]的长度为12的等差数列
# 编程
arrary = np.linspace(0,1,12,True)
display(arrary)
2. numpy排序函数有哪些？功能？
以下是几个主要的排序函数及其功能：
# 1. numpy.sort()：
（1）功能:对数组进行排序，返回排好序的数组副本。
（2）参数:
a:待排序数组。
axis:指定排序的轴。如果没有指定，则按最后一个轴排序。例如，axis=0表示按列排序，axis=1表示按行排序。
kind:指定排序算法，默认为'quicksort'（快速排序），还可以选择'mergesort'（归并排序）或'heapsort'（堆排序）。
order:如果数组包含字段，则用于指明排序的字段。
（3）示例:对二维数组按列排序或按行排序。
# 2. numpy.argsort()：
（1）功能:先对数组进行排序，然后提取排序后的数组索引，以数组形式返回。原数组不会被修改，通过索引可以得到排序结果。
（2）示例:得到排序后元素的原始索引。
# 3. numpy.lexsort()：
（1）功能:用于对多个序列进行排序，类似于SQL中的ORDER BY多个字段。可以想象成对电子表格进行排序，每一列代表一个序列，越后面的列优先级越高。原数组不会被修改，该函数提取排序后的数组索引，以数组形式返回，通过索引可以得到排序结果。
（2）示例:对多个数组或矩阵的列进行排序。
除了上述的排序函数，NumPy还提供了其他与排序相关的函数，如numpy.nonzero()（返回输入数组中非零元素的索引）和numpy.where()（返回输入数组中满足给定条件的元素的索引）等。
这些排序函数使得在NumPy中对数组进行排序变得非常便捷和高效。需要注意的是，直接排序函数（如numpy.sort()）会返回排序后的数组副本，而间接排序函数（如numpy.argsort()和numpy.lexsort()）则返回排序后的索引数组，原数组不会被修改。
2.1. 使用numpy.sort函数可以对数组进行排序，并返回排序好的数组。
numpy.sort(a, axis=-1, kind=None, order=None)
- a : 要排序的数组；
- axis ： 按什么轴进行排序，默认按最后一个轴进行排序；
- kind ：排序方法，默认是快速排序；
- order : 当数组定义了字段属性时，可以按照某个属性进行排序；
ndarray.sort(axis=-1, kind=None, order=None)
与numpy.sort()类似，在自身数组进行排序，很影响自身
arr = np.array([[1,8,2,4],
[4,5,1,3]])
# 默认按最后一个轴排序，这里按行排序
np.sort(arr)
# 轴设为0，即按列排序
np.sort(arr,axis=0)
# 轴设为1，即按行排序
np.sort(arr,axis=1)
下面试下按照字段属性进行排序，需要用到order参数。
# 自定义字段类型
dtype = [('Name', 'S10'), ('Height', float), ('Age', int)]
# 各字段值
values = [('Li', 1.8, 41), ('Wang', 1.9, 38),('Duan', 1.7, 38)]
# 创建数组
arr = np.array(values, dtype=dtype)
arr
# 按照属性Height进行排序,此时参数为字符串
np.sort(arr, order=['Height'])
# 先按照属性Age排序,如果Age相等，再按照Height排序，此时参数为列表
np.sort(arr, order=['Age', 'Height'])
2.2. numpy.argsort函数用于将数组排序后，返回数组元素从小到大依次排序的所有元素索引
使用方法（和sort类似）
numpy.argsort(a, axis=-1, kind=None, order=None)
- a : 要排序的数组；
- axis ： 按什么轴进行排序，默认按最后一个轴进行排序；
- kind ：排序方法，默认是快速排序；
- order : 当数组定义了字段属性时，可以按照某个属性进行排序；
arr = np.array([3, 1, 2])
# 获取排序后的索引
np.argsort(arr)
arr = np.array([[0, 3], [2, 2]])
# 默认按照最后一个轴进行排序，即行排序
# 获取排序后的索引
np.argsort(arr)
2.3. numpy.lexsort函数用于按照多个条件（键）进行排序，返回排序后索引
numpy.lexsort(keys, axis=-1)
- keys ：序列或元组，要排序的不同的列；
- axis ：沿指定轴进行排序；
- 给定多个排序键，lexsort返回一个整数索引数组，该数组描述按多个列排序的顺序。
- 序列中的最后一个键用于主排序顺序，倒数第二个键用于辅助排序顺序，依此类推。
# 英语成绩
english = [90,85,95,80]
# 数学成绩
math = [80,95,90,85]
# 总成绩
total = [170,170,185,165]
# 排序，获取索引
'''
先按总成绩total进行排序，
再按数学成绩math进行排序，
最后按英语成绩进行排序。
可以看到total里有两个170，
这时候就按下一级math排序，
最后获取排序后的索引
'''
np.lexsort((english, math, total))
# 也可以直接传入数组
score = np.array([[90,85,95,80],[80,95,90,85],[170,170,185,165]])
np.lexsort(score)
3. 创建一个10x10的ndarray对象，满足矩阵边界为1，里面全为0
# 编程
import numpy as np
def create_boundary_matrix(size):
# 创建一个size x size的矩阵，所有元素初始化为0
matrix = np.zeros((size, size), dtype=int)
# 将矩阵的边界设置为1
matrix[0, :] = 1 # 设置第一行为1
matrix[-1, :] = 1 # 设置最后一行为1
matrix[:, 0] = 1 # 设置第一列为1
matrix[:, -1] = 1 # 设置最后一列为1
return matrix
# 使用函数创建一个10x10的矩阵
boundary_matrix = create_boundary_matrix(10)
display(boundary_matrix)
4. 将数组arr中所有奇数置为-1对应的语句是
# 编程
arr = [1, 2, 3, 4, 5, 6, 7, 8, 9] # 示例数组
arr = [-1 if num % 2 != 0 else num for num in arr]
print(arr)
5. 根据要求编写代码
1. 利用numpy提供的函数创建一个多维随机数组，范围0到12，6个元素，两行3列
2. 打印数组所占的内存大小
3. 打印数组根据第一列进行排序后的结果
4. 假设不清楚数组内的数据大小，从数组中找出与给定值5最接近的值 （提示：np.abs()）
# 编程
import numpy as np
# 1. 利用numpy提供的函数创建一个多维随机数组，范围0到12，6个元素，两行3列
# 生成一个两行三列，元素取值范围在0到12之间的随机整数数组
# 注意：numpy.random.randint不包括上界，因此使用13作为上界
arr = np.random.randint(0, 13, size=(2, 3))
print("原始随机数组:")
print(arr)
# 2. 打印数组所占的内存大小
# 方法一：
# 打印数组所占用的内存大小（以字节为单位）
memory_size = arr.size * arr.itemsize
print("数组所占内存大小（字节）:", memory_size)
# 方法二：
import sys
print("数组所占内存大小（字节）:", sys.getsizeof(arr))
# 3. 打印数组根据第一列进行排序后的结果
# 使用lexsort先根据第一列排序，这里我们实际上只需要第一列进行排序
# 但由于lexsort接收的是一个元组，即使我们只需要根据一列排序，也需要以元组的形式传入
sorted_indices = np.lexsort((arr[:, 0],))
# 使用得到的索引对原数组进行排序
sorted_arr = arr[sorted_indices]
print("根据第一列排序后的数组:")
print(sorted_arr)
# 4. 假设不清楚数组内的数据大小，从数组中找出与给定值5最接近的值 （提示：np.abs()）
# 假设要找的值为5
target_value = 5
# 计算数组中每个元素与给定值的差的绝对值
abs_diff = np.abs(arr - target_value)
# 找到最小差的索引
min_diff_index = np.argmin(abs_diff)
# 找到与给定值最接近的元素
closest_value = arr.flat[min_diff_index]
print("与给定值5最接近的值是:", closest_value)
小知识：np.info()函数可以查阅numpy文档
例如：
np.info(np.add)
6. 请创建一组值为 0 到 9 （包括9）的 ndarray 数组，并指定为 int8 类型，然后将其改为布尔类型，以及float16类型
# 编程
import numpy as np
# 创建一个值为 0 到 9 的 ndarray 数组，并指定为 int8 类型
arr_int8 = np.arange(10, dtype=np.int8)
print("原始 int8 类型数组:")
print(arr_int8)
# 将数组改为布尔类型
# 在这里，非零元素会被转换为 True，零元素会被转换为 False
arr_bool = arr_int8.astype(np.bool_)
print("布尔类型数组:")
print(arr_bool)
# 将数组改为 float16 类型
arr_float16 = arr_int8.astype(np.float16)
print("float16 类型数组:")
print(arr_float16)
7. 下列有一组数据，请使用一行代码同时获取 2.7、42、36 这三个元素:
[3.0833, 2.7, 3.0833, 2.5, 2.75, 3.5, 3.9167, 42, 36, 0.75]
# 编程
data = [3.0833, 2.7, 3.0833, 2.5, 2.75, 3.5, 3.9167, 42, 36, 0.75]
target_values = [val for val in data if val in [2.7, 42, 36]]
target_values
8. 求数组 arr中所有元素的绝对值、四舍五入值、最大值和最小值：
arr = np.array([-3.2, 53, -3.6, 68, -4.5, 6.8571, -1.56, 8.4, -7])
# 编程
arr = np.array([-3.2, 53, -3.6, 68, -4.5, 6.8571, -1.56, 8.4, -7])
# 计算所有元素的绝对值
absolute_values = [abs(x) for x in arr]
print("绝对值:", absolute_values)
# 计算所有元素的四舍五入值
rounded_values = [round(x) for x in arr]
print("四舍五入值:", rounded_values)
# 计算最大值
max_value = max(arr)
print("最大值:", max_value)
# 计算最小值
min_value = min(arr)
print("最小值:", min_value)
9. 数组A和B如下，在不创建新数组的情况下，如何计算 (A+B)/(A-B) 的值？
A = np.ones(3) * 1
B = np.ones(3) * 2
提示: np.add(out=), np.subtract(out=), np.divide(out=)
# 编程
import numpy as np
# 初始化数组 A 和 B
A = np.ones(3) * 1
B = np.ones(3) * 2
# 计算 (A+B) 并保存在 A 中
np.add(A, B, out=A)
# 计算 (A-B) 并保存在 B 中（此时 A 已经被 (A+B) 覆盖）
np.subtract(A, B, out=B)
# 计算 (A+B)/(A-B) 并保存在 A 中（此时 A 是 (A+B) 的结果，B 是 (A-B) 的结果）
np.divide(A, B, out=A)
# A 现在包含了 (A+B)/(A-B) 的结果
print(A)
10. 计算半径分别为 1,2,3, … , 30的30个圆面积，结果保留两位小数，并以ndarray形式输出。
圆面积公式为：S=πr²。
π 值可以调用 np.pi 获得。
# 编程
import numpy as np
# 生成半径数组
radii = np.arange(1, 31) # 从 1 到 30 的整数数组
# 计算面积
areas = np.pi * radii ** 2
# 保留两位小数
areas_rounded = np.round(areas, 2)
# 输出结果
print(areas_rounded)
11. 下面是一组学生的数学成绩，请筛选得分大于 60 的人数：
np.random.seed(2023)
arr = np.random.randint(0, 100, 1000)
# 编程
import numpy as np
np.random.seed(2023)
arr = np.random.randint(0, 100, 1000) # 生成包含1000个随机整数（0到99之间）的数组
# 使用布尔索引筛选得分大于60的元素
scores_above_60 = arr[arr > 60]
# 计算得分大于60的人数
count_above_60 = len(scores_above_60)
print("得分大于60的人数是:", count_above_60)
12. 下列是一组学生的身高体重数据
height = np.array([1.73, 1.86, 1.56, 1.69, 1.53, 1.89, 1.87, 1.53, 1.66, 1.53])
weight = np.array([51, 64, 75, 58, 67, 59, 62, 70, 62, 59])
- 问1:请输出身体质量指数 (BMI)的排序结果
- 问2:请输出身体质量指数 (BMI)大于正常(>24)的元素数量
BMI = 体重(公斤)/身高²
# 编程
import numpy as np
height = np.array([1.73, 1.86, 1.56, 1.69, 1.53, 1.89, 1.87, 1.53, 1.66, 1.53])
weight = np.array([51, 64, 75, 58, 67, 59, 62, 70, 62, 59])
# 计算BMI
bmi = weight / (height ** 2)
# 问1: 输出BMI的排序结果
sorted_bmi_indices = np.argsort(bmi)
sorted_bmi = bmi[sorted_bmi_indices]
print("BMI的排序结果：", sorted_bmi)
# 问2: 输出BMI大于正常(>24)的元素数量
count_over_24 = np.sum(bmi > 24)
print("BMI大于正常(>24)的元素数量：", count_over_24)
13. 定义RGB结构
红色在RGB颜色模式中所对应的值就是255，0，0；绿色在RGB颜色模式中所对应的值就是0，255，0；蓝色在RGB颜色模式中所对应的值就是0，0，255。
获取用户输入的信息，编写代码定义一个复杂的dtype结构，数组元素包含三部分，分别为R、G、B的颜色值。
dtype结构元素名称分别为R、G、B类型的无符号8位整型，输出颜色值数组。
输入示例
[(254, 253, 252), (0, 0, 0), (255, 255, 255)]
输出示例
array([(254, 253, 252), ( 0, 0, 0), (255, 255, 255)],
dtype=[(‘R’, ‘u1’), (‘G’, ‘u1’), (‘B’, ‘u1’)])
# 编程
import numpy as np
# 定义dtype结构
color_dtype = np.dtype([('R', 'u1'), ('G', 'u1'), ('B', 'u1')])
# 输入示例数据
colors = [(254, 253, 252), (0, 0, 0), (255, 255, 255)]
# 创建颜色值数组
color_array = np.array(colors, dtype=color_dtype)
color_array
14. 创建一个8 x 8棋盘形状数组，输出如下样式：
[[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]
[0 1 0 1 0 1 0 1]
[1 0 1 0 1 0 1 0]]
# 编程
import numpy as np
# 创建一个8 x 8的棋盘形状数组
chessboard = np.zeros((8, 8), dtype=int)
chessboard[1::2, ::2] = 1 # 奇数行，偶数列赋值为1
chessboard[::2, 1::2] = 1 # 偶数行，奇数列赋值为1
print(chessboard)
15. 下面是一个数组，根据二维数组第二列的值，将数组升序排列。
np.random.seed(123)
n = np.random.randint(0, 10, (3, 4))
输出示例
[[0 1 9 0]
[2 2 6 1]
[3 9 6 1]]
# 编程
import numpy as np
np.random.seed(123)
n = np.random.randint(0, 10, (3, 4))
sorted_indices = np.argsort(n[:, 1]) # 根据第二列的值获取升序排序的索引
sorted_n = n[sorted_indices] # 使用索引重新排序原始数组
print(sorted_n)
16. 在数组arr中交换第一列和第二列
数组有如下代码生成：
arr = np.arange(9).reshape(3,3)
# 编程
import numpy as np
arr = np.arange(9).reshape(3, 3)
print("原来的数组:\n",arr)
# 交换第一列和第二列
arr[:, [0, 1]] = arr[:, [1, 0]]
print("变化后的数组：\n", arr)
17. 获取下面数组a中前5个最大值
数组如下：
np.random.seed(100)
arr = np.random.uniform(1,50, 20)
# 编程
import numpy as np
np.random.seed(100)
arr = np.random.uniform(1, 50, 20)
print("原来的数组：",arr)
# 找出前5个最大值的索引
max_indices = np.argsort(arr)[-5:]
# 获取前5个最大值
top5_max_values = arr[max_indices]
print(top5_max_values)
18. 下面数组按行计算去重后的元素数量（难）
数组如下：
np.random.seed(100)
arr = np.random.randint(1, 11, size=(6, 10))
# 编程
import numpy as np
np.random.seed(100)
arr = np.random.randint(1, 11, size=(6, 10))
# 定义函数计算每一行去重后的元素数量
def count_unique_elements(row):
unique_elements = set(row)
return len(unique_elements)
# 应用函数到每一行，编写的函数没有传参的效果
unique_counts = np.apply_along_axis(count_unique_elements, axis=1, arr=arr)
print(unique_counts)
19. 对于两个随机数组A和B，检查它们是否相等
A = np.arange(1, 5)
B = np.arange(3, 7)
提示：np.allclose比较两个array是不是每一元素都相等
# 编程
import numpy as np
A = np.arange(1, 5)
B = np.arange(3, 7)
print("A数组：",A)
print("B数组：",B)
are_equal = np.allclose(A, B)
print(are_equal)
20. 检查一个二维数组是否有空列（全0列）？
提示：ndarray.any()方法
以下是数组：
arr = np.random.randint(0, 3, (3, 10))
# 编程
import numpy as np
# 假设我们有一个3x10的随机整数数组，范围在0到2之间
arr = np.random.randint(0, 3, (3, 10))
# 使用any方法沿着行的方向（axis=0）检查每一列是否至少有一个非零元素
has_non_zero = arr.any(axis=0)
# 找出哪些列是全0的（即any方法返回False的列）
empty_columns = np.where(~has_non_zero)[0]
# 输出空列的索引
print("空列的索引:", empty_columns)
# 如果要检查是否有空列，只需检查empty_columns数组是否为空
has_empty_columns = len(empty_columns) > 0
print("是否有空列:", has_empty_columns)
1483
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
