Python_数据科学与机器学习

1 数据处理_Numpy

        Numpy用于处理数值计算,尤其是针对ndarray多维数组的操作,并为 Pandas 等其他库提供高效的底层数组支持.使用 pip install numpy命令来安装 numpy.

1.1 数据结构

        ndarray是一个多维的、同质数据类型的数组对象,将数据存储在一个连续的内存块中,能对数组元素进行高效访问和运算,尤其适用于数值计算场景.

        ①维度(轴):可以是一维(向量)、二维(表格)或多维(多维数据),维度数量由 ndarray 的 ndim 属性表示.

        ②形状:每个维度上元素的数量,通过 shape 属性以元组形式呈现,决定了数组的布局.

        ③数据类型:ndarray 中所有元素的数据类型必须一致,由 dtype 属性指定.常见的数据类型y有整数(如 np.int32、np.int64)、浮点数(如 np.float32、np.float64)、布尔值(np.bool_)等.

1.2 创建

(1) 从 Python 序列创建

# 从列表创建一维数组
import numpy as np

python_list = [1, 2, 3, 4, 5]
ndarray_from_list = np.array(python_list)
print(ndarray_from_list)

# 从嵌套列表创建多维数组
nested_list = [
    [1, 2, 3]
    ,[4, 5, 6]]
two_d_ndarray = np.array(nested_list)
print(two_d_ndarray)

(2) 生成数据

import numpy as np

# 生成随机数数组,在[0, 1)区间内
random_uniform_1d = np.random.rand(3)  # 创建长度为3的一维均匀分布随机数数组
random_uniform_2d = np.random.rand(2, 2)  # 创建2行2列的二维均匀分布随机数数组
print(random_uniform_1d)
print(random_uniform_2d)

1.3 修改数据结构

(1) 修改数组形状

import numpy as np

# 1 resize:直接修改数组的形状
arr = np.array([1, 2, 3, 4, 5, 6])
print("resize前的数组:", arr)
# 改为 3x2 的数组
arr.resize(3, 2)
print("resize后的数组:\n", arr)

# 2 reshape:修改数组副本的形状
arr2 = np.array([1, 2, 3, 4, 5, 6])
print("\nreshape前的数组:", arr2)
# 改为 2x3 的数组
reshaped = arr2.reshape(2, 3)
print("reshape后的数组:\n", reshaped)

# 3 ravel:将多维数组转成一维数组
arr3 = np.array([[1, 2, 3], [4, 5, 6]])
print("\nravel前的数组:\n", arr3)
flattened = arr3.ravel()
print("ravel后的数组:", flattened)

# 4 expand_dims:增加维度
arr4 = np.array([1,2,3])
print("\nexpand_dims前的数组:\n", arr4)
expanded = np.expand_dims(arr4, axis=0)
print("\nexpand_dims后的数组:\n", expanded)

# 5 squeeze:减少维度
arr5 = np.array([[1,2,3]])
print("\nsqueeze前的数组:\n", arr5)
squeezed = np.squeeze(arr5)
print("\nsqueeze后的数组:\n", squeezed)

(2) 修改数组的类型

import numpy as np

arr = np.array([1.5, 2.7, 3.1])
# 转换为整数类型
int_arr = arr.astype(int)  
print(int_arr)

1.4 修改数据

(1) 添加或删除数据

        NumPy 的数组大小是固定的,不能直接添加或删除元素,但可以通过新建数组来实现.

①一维数组

import numpy as np

# 添加元素
arr = np.array([1, 2, 3])
new_arr = np.append(arr, [4, 5])  # 添加元素
print(new_arr)  # 输出: [1 2 3 4 5]

# 删除元素
arr = np.array([1, 2, 3, 4])
new_arr = np.delete(arr, [1, 3])  # 删除第 1 和第 3 个元素
print(new_arr)  # 输出: [1 3]

②二维数组

import numpy as np

# 添加元素
arr = np.array([[1, 2, 3], [4, 5, 6]])  # 原始二维数组
print("原始二维数组:\n", arr)

# 添加元素：在二维数组中添加一行
new_row = [7, 8, 9]
new_arr = np.append(arr, [new_row], axis=0)  # 添加新的一行
print("添加新行后的数组:\n", new_arr)

# 添加元素：在二维数组中添加一列
new_col = [[10], [11]]
new_arr_col = np.append(arr, new_col, axis=1)  # 添加新的一列
print("添加新列后的数组:\n", new_arr_col)

# 删除元素
arr = np.array([[1, 2, 3], [4, 5, 6]])  # 原始二维数组
print("\n原始二维数组:\n", arr)

# 删除第 0 行
new_arr_row_deleted = np.delete(arr, 0, axis=0)  # 删除第 0 行
print("删除第 0 行后的数组:\n", new_arr_row_deleted)

# 删除第 1 列
new_arr_col_deleted = np.delete(arr, 1, axis=1)  # 删除第 1 列
print("删除第 1 列后的数组:\n", new_arr_col_deleted)

  (2)  修改数据

import numpy as np

# 1 单个元素赋值
# 创建一个简单的ndarray
arr = np.array([[1, 2, 3], [4, 5, 6]])
print("原始数组:\n", arr)

arr[0, 1] = 10
print("单个元素赋值后:\n", arr)


# 2 元素切片赋值
# 创建一个新的ndarray
arr2 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("\n原始数组2:\n", arr2)

# 1: 表示从行索引为1开始,直到最后一行
# :2 表示从第一列开始,直到列索引为1
arr2[1:, :2] = np.array([[10, 11], [12, 13]])
print("切片赋值后:\n", arr2)

1.5 查询

(1) 索引查询

import numpy as np

# 创建一维数组
one_d_array = np.array([1, 3, 5, 7, 9])
# 单个索引查询
single_index = one_d_array[2]
print(f"一维数组单个元素索引（索引值为2）: {single_index}")

# 创建二维数组
two_d_array = np.array([[11, 12, 13], [14, 15, 16], [17, 18, 19]])
# 单个索引查询
two_d_single_index = two_d_array[1, 2]
print(f"二维数组单个元素索引（第2行第3列）: {two_d_single_index}")

# 查询多个索引
two_d_array = np.array([[11, 12, 13], [14, 15, 16], [17, 18, 19], [20, 21, 22]])
index_query = two_d_array[[1, 3], [2, 1]]
print(f"查询 (1, 2) 和 (3, 1) 位置的数据: {index_query}")

(2) 切片:获取子数组

import numpy as np

# 创建一维数组
one_d_array = np.array([10, 20, 30, 40, 50, 60])
# 一维数组切片
# 从索引1到索引3,步长为2
one_d_slice = one_d_array[1:4:2]
print(f"一维数组切片（从索引1到索引4，步长为2）: {one_d_slice}")

# 创建二维数组
two_d_array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
# 二维数组切片
# 所有行,从索引1到索引2
two_d_slice = two_d_array[:, 1:3]
print(f"二维数组切片（所有行，第2列到第3列）:\n {two_d_slice}")

(3) 筛选

①一维数组

import numpy as np

# 使用 布尔索引筛选
numbers = np.array([10, 20, 30, 40, 50])
result = numbers[numbers > 25]
print(result)

②二维数组

import numpy as np

# 布尔索引筛选,保留原有结构
people_info = np.array([
    [25, 4000],
    [35, 6000],
    [28, 4500],
    [32, 5500]
])

multi_column_row_based_bool_filter = people_info[(people_info[:, 0] > 30) & (people_info[:, 1] > 5000)]
# 打印结果及格式
print("\n布尔索引筛选结果（二维数组）：")
print(multi_column_row_based_bool_filter)

# 布尔索引筛选,返回元素
arr_2d= np.array([
    [1, 2, 3, 25],
    [4, 5, 6, 32],
    [7, 8, 9, 28],
    [10, 11, 12, 35],
    [13, 14, 15, 20]
])
filtered_arr= arr_2d[arr_2d > 30]
print(f"布尔索引筛选结果（元素）: {filtered_arr}")

 (4) 修改数组的排序

import numpy as np

arr = np.array([3, 1, 4, 2])
sorted_arr = np.sort(arr)
print(sorted_arr)

2 数据处理_Pandas

        Pandas 用于处理表格数据和时间序列数据,提供了高性能、易于使用的数据结构和数据分析工具.

2.1 特点

        ①支持多种数据类型,并提供了丰富的数据分析和操作功能,能够快速处理和分析大规模数据.

        ②提供了强大的时间序列处理功能,支持日期范围生成、频率转换、时间偏移等.

        ③与其它多种库集成,增强数据分析和可视化能力.

2.2 数据结构

        ①Series:是一种类似于一维数组的对象,具有数据和索引,类似于 Python 的列表或字典.

        ②DataFrame:是带有标签的二维数组,类似于电子表格或 SQL 表格.

2.3 Series

2.3.1 创建

import pandas as pd

# 从列表创建
data = [1, 2, 3, 4]
series = pd.Series(data)
print("从列表创建的 Series:\n", series)

# 从数组创建
array2 = np.array([5, 6, 7, 8])
series2 = pd.Series(array2,index=['x', 'y', 'z','a'])
print("从数组创建的 Series:\n", series2, "索引:\n", series2.index.tolist())

# 从字典创建
data3 = {'a': 1, 'b': 2, 'c': 3}
series3 = pd.Series(data3)
print("从字典创建的 Series:\n", series3)

2.3.2 修改

(1) 添加数据(合并series)

import pandas as pd

series = pd.Series([100, 200, 3], index=['new_x', 'new_y', 'z'])
new_series = pd.concat([series, pd.Series([300], index=['new'])])
print("\nInserted new element:\n", new_series)

(2) 删除数据

import pandas as pd

# 创建一个 Series 数据源
series = pd.Series({'a': 1, 'b': 2, 'c': 3, 'd': 4})

# 输出处理前的结果
print("处理前的 Series:\n",series)

# 使用 inplace=False（默认值），返回一个新的 Series
new_series = series.drop('a', inplace=False)
print("使用 inplace=False 后的新 Series:\n",new_series)
print("使用 inplace=False 后的原 Series:\n",series)

# 使用 inplace=True，直接修改原 Series
series.drop('b', inplace=True)
print("使用 inplace=True 后的原 Series:\n",series)

# 删除空值
data = pd.Series([10, None, 30])
new_s = data.dropna()
print("删除空值后的 Series:\n",new_s)

(3)  修改数据

import pandas as pd

# 修改单个元素
series1 = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
series1['a'] = 10
print("\nModified single element:\n", series1)

# 批量修改
series2 = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
series2[series2 > 2] = 0
print("\nBatch modified elements:\n", series2)


# 替换值
series3 = pd.Series([1, 2, 3, 4, 5])
new_series = series3.replace([2, 4], [99, 100])
print("\n替换值:\n", new_series)

# 替换值_使用字典
series4 = pd.Series([10, 0, 3], index=['new_x', 'new_y', 'z'])
series4.replace({10: 100, 0: 200}, inplace=True)
print("\n替换值_使用字典:\n", series4)

(4) 修改索引

import pandas as pd

# 修改索引
series = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
series.index = ['x', 'y', 'z']
print("\nModified index:\n", series)

# 重命名索引
series = pd.Series([1, 2, 3], index=['x', 'y', 'z'])
series.rename({'x': 'new_x', 'y': 'new_y'}, inplace=True)
print("\nRenamed index:\n", series)

2.3.3 查询

(1) 查询

import pandas as pd

# 索引查询
s = pd.Series([10, 20, 30, 40], index = ['a', 'b', 'c', 'd'])
print(s['b'])

# 切片查询
s2 = pd.Series([10, 20, 30, 40, 50], index = ['a', 'b', 'c', 'd', 'e'])
print(s2['b':'d'])

# 条件查询
series = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
filtered = series[series > 1]
print("\n值大于1的有:\n", filtered)

# 查询空值,isnull()或isna()
data = pd.Series([10, None, 30])
missing_values = data.isnull()
print(missing_values)

(2) 特殊查询

import pandas as pd

# 查询空值,isnull()或isna()
data = pd.Series([10, None, 30])
missing_values = data.isnull()
print(missing_values)

# 查询索引和值
series = pd.Series([1, 2, 3], index=['a', 'b', 'c'])
print("\nSeries index:", series.index)
print("Series values:", series.values)

(3) 排序

import pandas as pd

# 按值排序
s = pd.Series([30, 10, 20])
sorted_s = s.sort_values()
print(sorted_s)

# 按索引排序
s = pd.Series([10, 20, 30], index = ['c', 'a', 'b'])
sorted_index_s = s.sort_index(ascending = False)
print(sorted_index_s)

2.3.4 计算

(1) 基本计算

import pandas as pd

# 算术运算
s1 = pd.Series([1, 2, 3])
s2 = pd.Series([4, 5, 6])
result = s1 + s2
print(result)

# 标量运算
s2 = pd.Series([10, 20, 30])
new_s = s2 * 2
print(new_s)

(2) 汇总统计

import pandas as pd

# 创建一个示例 Series
data = [1, 2, 3, 4, None, 6, 7, 8, 9, 10]
series = pd.Series(data)

# 计算和
print("Sum:", series.sum())

# 计算平均值
print("Mean:", round( series.mean(),2) )

# 计算中位数
print("Median:", series.median())

# 计算最小值
print("Min:", series.min())
# 计算最大值
print("Max:", series.max())

# 计算数量
print("Total number of rows (using len):", len(series))
print("Total number of rows (using size):", series.size)
# 计算非空值的数量
print("Count:", series.count())

# 计算标准差
print("Standard Deviation:", series.std())
# 计算方差
print("Variance:", series.var())

# 获取描述性统计信息
print("\nDescriptive Statistics:\n", series.describe())

# 计算 50% 分位数（等同于中位数）
print("50% Quantile (Median):", series.quantile(0.50))

2.4 DataFrame

2.4.1 创建

import pandas as pd

# 从字典创建 DataFrame
data = {
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'City': ['New York', 'Los Angeles', 'Chicago']
}
df = pd.DataFrame(data)
print("DataFrame:\n", df)


# 从嵌套列表创建 DataFrame
data = [
    ['Alice', 25, 'New York'],
    ['Bob', 30, 'Los Angeles'],
    ['Charlie', 35, 'Chicago']
]
columns = ['Name', 'Age', 'City']
df = pd.DataFrame(data, columns=columns)
print("DataFrame:\n", df)

2.4.2 修改数据结构

(1) 增加列

# 增加列
import pandas as pd

# 创建 DataFrame
data = {
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'City': ['New York', 'Los Angeles', 'Chicago']
}
df = pd.DataFrame(data)

df['Salary'] = [50000, 60000, 70000]
print("After adding a column:\n", df)

(2) 删除列

import pandas as pd

# 创建 DataFrame
data = {
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'City': ['New York', 'Los Angeles', 'Chicago'],
    'Salary': [50000, 60000, 70000]
}
df = pd.DataFrame(data)

# 删除一列
df = df.drop(columns=['Salary'])
print("After deleting a column:\n", df)

2.4.3 修改数据

(1) 增加数据(合并dataframe)

import pandas as pd

# 创建 DataFrame
data = {
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'City': ['New York', 'Los Angeles', 'Chicago']
}
df = pd.DataFrame(data)

new_row = pd.DataFrame({'Name': ['David'], 'Age': [40], 'City': ['San Francisco']})
# ignore_index=True:合并时重置索引
df = pd.concat([df, new_row], ignore_index=True)
print("After adding a row:\n", df)

 (2) 删除 指定列的值有缺失的行

import pandas as pd

# 创建示例 DataFrame
data = {
    'Name': ['Alice', 'Bob', 'Charlie', None, 'Eve'],
    'Age': [25, 30, None, 40, 45],
    'Salary': [50000, None, 70000, 80000, None]
}
df = pd.DataFrame(data)

# 删除 'Age' 列中有缺失值的行
df_cleaned = df.dropna(subset=['Age'])
print("删除 'Age' 列中有缺失值的行后的 DataFrame:\n", df_cleaned)

(3) 修改数据

import pandas as pd

# 创建 DataFrame
data = {
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'City': ['New York', 'Los Angeles', 'Chicago']
}
df = pd.DataFrame(data)

df['Age'] = df['Age'] + 1  # 年龄加 1
print("After modifying a column:\n", df)

(4) 填充数据

import pandas as pd

# 创建包含缺失值的 DataFrame
data_missing_constant = {
    'Age': [25, None, 30, 35, None],
    'Salary': [50000, None, 60000, None, 70000],
    'Experience': [5, 10, None, 15, None],
    'Bonus': [None, 2000, 3000, None, 4000],
    'Performance': [None, 80, 90, None, 100]
}
df_missing_constant = pd.DataFrame(data_missing_constant)

# 填充规则
# 1. 常数填充
df_missing_constant['Age'] = df_missing_constant['Age'].fillna(20)

# 2. 中位数填充
median_salary = df_missing_constant['Salary'].median()
df_missing_constant['Salary'] = df_missing_constant['Salary'].fillna(median_salary)

# 3. 均值填充
mean_experience = df_missing_constant['Experience'].mean()
df_missing_constant['Experience'] = df_missing_constant['Experience'].fillna(mean_experience)

# 4. 三倍标准差法下边界填充
bonus_mean = df_missing_constant['Bonus'].mean()
bonus_std = df_missing_constant['Bonus'].std()
bonus_lower_bound = bonus_mean - 3 * bonus_std
df_missing_constant['Bonus'] = df_missing_constant['Bonus'].fillna(bonus_lower_bound)

# 5. 四分位距法下边界填充
q1 = df_missing_constant['Performance'].quantile(0.25)
q3 = df_missing_constant['Performance'].quantile(0.75)
iqr = q3 - q1
performance_lower_bound = q1 - 1.5 * iqr
df_missing_constant['Performance'] = df_missing_constant['Performance'].fillna(performance_lower_bound)

# 输出说明文字和填充后的 DataFrame
output_description = (
    "填充说明：'Age' 列使用常数 20 填充；"
    "'Salary' 列使用中位数填充；"
    "'Experience' 列使用均值填充；"
    "'Bonus' 列使用三倍标准差法下边界填充；"
    "'Performance' 列使用四分位距法下边界填充。"
)

print(output_description)
print("\n缺失值处理 - 填充后的 DataFrame:\n", df_missing_constant)

2.4.4 查询

(1) 查询

import pandas as pd

# 创建示例 DataFrame
data = {
    'Name': ['Alice', 'Bob', 'Charlie', 'David', 'Eve'],
    'Age': [25, 30, 35, 40, 45],
    'Salary': [50000, 60000, 70000, 80000, 90000],
    'Department': ['HR', 'IT', 'Finance', 'IT', 'HR']
}
df = pd.DataFrame(data)

# 1. 布尔索引筛选
# 筛选年龄大于30且工资大于60000的行
filtered_df_boolean = df[(df['Age'] > 30) & (df['Salary'] > 60000)]
print("布尔索引筛选结果:\n", filtered_df_boolean)

# 2. query 方法筛选
# 筛选年龄大于30且工资大于60000的行
# head:限制返回条数
filtered_df_query = df.query('Age > 30 and Salary > 60000').head(2)
print("\nquery 筛选结果:\n", filtered_df_query)

# 3. where 方法筛选
# 筛选年龄大于30且工资大于60000的行
filtered_df_where = df.where((df['Age'] > 30) & (df['Salary'] > 60000))
print("\nwhere 筛选结果:\n", filtered_df_where)

# 4. apply 方法筛选
# 筛选年龄是偶数的行
filtered_df_apply = df[df['Age'].apply(lambda x: x % 2 == 0)]
print("\napply 筛选结果:\n", filtered_df_apply)

# 5. 按索引查询
# 使用 iloc 按行索引筛选（例如，选择第2到4行）
filtered_df_iloc = df.iloc[1:4]
print("\niloc 按行索引筛选结果:\n", filtered_df_iloc)
# 使用 loc 按列名筛选（例如，选择 "Name" 和 "Age" 列）
filtered_df_loc = df.loc[:, ['Name', 'Age']]
print("\nloc 按列名筛选结果:\n", filtered_df_loc)

(2)  查询指定列的值有缺失的行

import pandas as pd

# 创建示例 DataFrame
data = {
    'Name': ['Alice', 'Bob', 'Charlie', None, 'Eve'],
    'Age': [25, 30, None, 40, 45],
    'Salary': [50000, None, 70000, 80000, None]
}
df = pd.DataFrame(data)

missing_age_rows = df[df['Age'].isnull()]
print("Age 字段数据缺失的行:\n", missing_age_rows)

2.4.5 计算

(1) 行列计算

①矢量计算

        直接在底层进行批量计算,代码简洁高效,用于简单计算.

import pandas as pd
import numpy as np

# 创建 DataFrame
data = {
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'Salary': [50000, 60000, 70000]
}
df = pd.DataFrame(data)

# 列计算：使用矢量化操作
df['Salary_in_10k'] = np.where(df['Salary'] > 55000, df['Salary'] / 10000, 0)
print("After custom calculation with condition:\n", df)

# 行计算：使用矢量化操作
df['Age_to_Salary_ratio'] = np.where(df['Age'] > 28, df['Salary'] / df['Age'], 0)
print("Age to Salary ratio with condition:\n", df)

②自定义计算

        逐行进行复杂的逻辑计算,性能较低,适用于复杂条件逻辑、复杂数据结构、复杂计算结果、动态计算、调用外部函数等场景.

import pandas as pd

# 创建 DataFrame
data = {
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'Salary': [50000, 60000, 70000]
}
df = pd.DataFrame(data)

# 列计算：使用 apply 方法
df['Salary_in_10k'] = df['Salary'].apply(lambda x: x / 10000 if x > 55000 else 0)
print("After custom calculation with condition:\n", df)

# 行计算：使用 apply 方法
# axis=1:按行操作
df['Age_to_Salary_ratio'] = df.apply(lambda row: row['Salary'] / row['Age'] if row['Age'] > 28 else 0, axis=1)
print("Age to Salary ratio with condition:\n", df)

(2) 列的统计

import pandas as pd

data = {
    '年龄': [25, 30, 30, 40, 45],
    '工资': [5000, 6000, 7000, 8000, 9000]
}
df = pd.DataFrame(data)

# 通用描述性统计
summary = df.describe()
print("通用描述性统计:\n", summary)
# 统计单列的描述性信息
print("Age statistics:\n", df['年龄'].describe())


# 特定统计量计算
sum_age = df['年龄'].sum()
print("\n年龄总和:", sum_age)

count_age = df['年龄'].count()
print("年龄计数:", count_age)

min_age = df['年龄'].min()
print("年龄最小值:", min_age)

max_age = df['年龄'].max()
print("年龄最大值:", max_age)

average_age = df['年龄'].mean()
print("平均年龄:", average_age)

median_salary = df['工资'].median()
print("工资中位数:", median_salary)

mode_age = df['年龄'].mode()
print("年龄众数:\n", mode_age)

std_salary = df['工资'].std()
print("工资标准差:", std_salary)

var_salary = df['工资'].var()
print("工资方差:", var_salary)

q25_salary = df['工资'].quantile(0.25)
print("工资列的25%分位数:", q25_salary)

(3) 分组聚合

import pandas as pd

data = {
    '年龄': [25, 30, 35, 40, 45],
    '工资': [5000, 6000, 7000, 8000, 9000],
    '工作年限': [2, 3, 5, 7, 10],
    '部门': ['销售部', '研发部', '销售部', '研发部', '销售部'],
    '性别': ['男', '女', '男', '女', '男']
}
df = pd.DataFrame(data)

# 1 聚合
multi_stats = df.agg({
    '年龄': ['mean', 'median'],
    '工资': ['sum', 'std'],
    '工作年限': ['min', 'max']
})
print(multi_stats)

# 2 分组汇总
grouped_stats = df.groupby('部门').agg({
    '工资': ['sum', 'mean'],
    '年龄': ['mean', 'std'],
    '工作年限': ['sum']
})
print(grouped_stats)    

(4) 排序和排名

import pandas as pd

data = {
    'Name': ['Alice', 'Bob', 'Charlie'],
    'Age': [25, 30, 35],
    'Salary': [50000, 60000, 70000]
}
df = pd.DataFrame(data)

# 排序
sorted_df = df.sort_values(by='Age', ascending=False)
print("Sorted by Age:\n", sorted_df)

# 进行排名
df['Salary_rank'] = df['Salary'].rank(ascending=False)
print("Salary rank:\n", df)