Pandas进阶修炼120题-第五期（一些补充，101-120题）_pandas 高级测试

自己再写一遍的pandas习题，相比于标准答案添加了自己的理解与注释，也可直接下载链接上的原习题（未加注释的初始版带答案）
链接：https://pan.baidu.com/s/1arrqcBFZKqJngzRzUB2QfA?pwd=29eb
提取码：29eb
–来自百度网盘超级会员V3的分享

往期内容：

• 第一期：Pandas基础（1-20题）

• 第二期：Pandas数据处理（21-50题）

• 第三期：Pandas金融数据处理（51-80题）

• 第四期：当Pandas遇上NumPy（81-100题）

• 第五期：一些补充（101-120题）

第五期 一些补充

import numpy as np
import pandas as pd
1
2

101.从CSV文件中读取指定数据

# 备注：从数据1中的前10行中读取positionName, salary两列
df = pd.read_csv('pandas120_101_120_1.csv',encoding = 'gbk',usecols=['positionName','salary'],nrows=10)
df
1
2
3

102.从CSV文件中读取指定数据

# 备注：从数据2中读取数据并在读取数据时将薪资大于10000的为改为高
df = pd.read_csv('pandas120_101_120_2.csv',
                  converters={'薪资水平':lambda x: '高' if float(x) > 10000 else '低'}
                 )
df
1
2
3
4
5

1154 rows × 2 columns

converters:是一个参数，允许你为某些列定义转换函数，这个函数会在读取数据时应用

使用方法:

• 以字典键值对的形式出现.
• 键是你想要做出修改的列名，本例中键是 “薪资水平”
• 值就是一个 lambda 函数.

本例中:

• x “薪资水平” 这一列的一个值.
• float(x) 将x转化为浮点类型.
• 检查 x 代表的值是否大于 10,000.
• 如果是, 返回字符串 ‘高’.
• 如果不是, 返回字符串 ‘低’.

其他用法示例:

1:将字符串日期转换为真正的日期：

converters={'date_column': pd.to_datetime}

1
2

2:将某些特定的字符串值映射为 NaN：

converters={'some_column': lambda x: np.nan if x == 'unknown' else x}
1

3:对数值数据进行缩放：

converters={'value_column': lambda x: float(x) / 1000}
1

当使用 pandas 读取数据时，其他一些参数可以在加载数据时进行筛选或处理。以下是一些这样的参数及其功能：

1. dtype:

   • 用于指定列的数据类型。
   • 例如，你可以使用 dtype={'column_name': int} 来确保特定的列为整数类型。

2. usecols:

   • 允许你选择要加载的列。
   • 例如，usecols=['A', 'C'] 只会加载名为 ‘A’ 和 ‘C’ 的列。

3. skiprows:

   • 允许你跳过文件的前几行。
   • 如果你知道前两行是无关的标题或其他信息，你可以使用 skiprows=2 来跳过它们。

4. nrows:

   • 指定要读取的行数。
   • 如果你只想加载文件的前 100 行，可以使用 nrows=100。

5. na_values:

   • 指定应被解释为 NaN（即缺失数据）的值。
   • 例如，如果你的数据集中使用 “unknown” 或 “-” 表示缺失值，你可以使用 na_values=['unknown', '-']。

6. parse_dates:

   • 尝试将数据解析为日期。
   • 可以指定要解析为日期的列，例如 parse_dates=['date_column']。

7. date_parser:

   • 用于解析日期的函数。
   • 当与 parse_dates 一起使用时，它可以自定义日期解析的方式。

8. skipfooter:

   • 跳过文件的最后几行。
   • 如果你知道文件的最后三行是汇总或其他不需要的信息，你可以使用 skipfooter=3。

9. squeeze:

   • 如果解析的数据只有一列，则返回 Series 而不是 DataFrame。
   • 设置为 True 时，如果数据只有一列，将返回一个 Series 对象。

这些参数都可以帮助你在加载数据时根据需要对数据进行预处理和筛选。当然，这只是其中的一部分参数，pandas 为数据加载提供了丰富的选项。你可以参考 pandas 官方文档来了解更多详细信息。

103.从上一题数据中，对薪资水平列每隔20行进行一次抽样

df.iloc[::20,:][['薪资水平']]
1

其他采样示例

以下是一些常用的采样方法：

1. 随机采样:
   使用 DataFrame 的 sample() 方法，你可以轻松地进行随机抽样。

   # 抽取 10% 的数据
   sample_df = df.sample(frac=0.1)
   
   # 或者直接抽取 10 行数据
   sample_df = df.sample(n=10)
   1
   2
   3
   4
   5

2. 分层采样:
   如果你想根据某个特定的列进行分层抽样，你可以使用 groupby 配合 sample。例如，假设你想根据 “薪资水平” 列进行分层，每层抽取 5 个样本：

   sample_df = df.groupby('薪资水平').apply(lambda x: x.sample(n=5)).reset_index(drop=True)
   1

3. 时间序列数据的采样:
   如果你的数据是时间序列数据，你可能会想要按特定的频率进行采样。这时，你可以使用 resample 方法。

   # 假设 'date' 是一个日期列，并且已经被设置为索引
   # 以下代码每月抽取最后一个观测值
   sample_df = df.resample('M').last()
   1
   2
   3

4. 系统采样:
   你已经看到了如何使用 iloc 进行系统采样（例如每隔 20 行）。这是一种简单且常用的方法。

5. 权重采样:
   如果你希望根据某列的值作为权重进行抽样，你可以使用 sample 方法的 weights 参数。

   # 假设 'weights_column' 是权重列
   sample_df = df.sample(n=10, weights='weights_column')
   1
   2

6. 条件采样:
   你可以使用布尔索引来根据某些条件对数据进行筛选。

   # 例如，选择所有薪资大于 10000 的行
   high_salary_df = df[df['薪资水平'] > 10000]
   1
   2

选择哪种抽样方法取决于你的具体需求和数据的特性。在实际应用中，可能需要结合多种方法来达到理想的抽样效果。

104.将数据取消使用科学计数法

df = pd.DataFrame(np.random.random(10)**10,columns = ['column1'])
df
1
2

标准答案：round方法，实际上修改了数据值，谨慎使用

df.round(5)
1

推荐方法：pd.set_option(‘display.float_format’)

# 设置展示方式
pd.set_option('display.float_format','{:.10f}'.format)
1
2

df
1

# 重置展示方式
pd.reset_option('display.float_format')
1
2

两种方法的区别

这里我们看到了两列的对比：

1. display_setting 列：这列展示了在应用 pd.set_option('display.float_format', '{:.10f}'.format) 设置后的数据显示效果。所有的浮点数都显示为10位小数，但实际的数据值没有改变。

如果您想要取消之前设置的 display.float_format 选项并恢复到 Pandas 的默认显示设置，您可以使用 pd.reset_option() 方法。具体来说，为了重置浮点数的显示格式，可以这样做：

pd.reset_option('display.float_format')
1

执行上述代码后，Pandas 将不再使用您之前设置的浮点数格式，并恢复为默认的显示设置。

2. rounded 列：这列展示了在应用 df.round(5) 后的数据。这是DataFrame中的实际数据，四舍五入到了5位小数。

从这个对比中，您可以看到这两个操作在这个特定的DataFrame上产生了相同的显示效果。但重要的是要记住，它们在操作和目的上是完全不同的。pd.set_option 只更改显示，而 df.round 更改实际数据。

105.将上一题的数据转换为百分数

df
1

标准答案：df.style.format()方法 不会更改数据

df.style.format({'column1':'{0:.2%}'.format})
1

这是一个很好的方式来格式化 pandas DataFrame 的显示样式，而不真正更改 DataFrame 中的数据。

代码解析：

1. 使用 df.style.format() 来更改 DataFrame 的显示样式。
2. 通过传递一个字典 { 'data': '{0:.2%}'.format } 来指定列 'data' 的格式。
3. 字符串 '{0:.2%}' 是一个格式字符串，它会将数值转换为百分数并保留两位小数。
   • .2% 是一个特殊的格式，它会自动将数字乘以 100 并添加百分号，这意味着不需要额外的乘以 100 的操作。
4. .format 是一个方法，它将被应用于列 'data' 中的每个值来格式化显示。

要注意的是，使用 df.style.format() 只会更改 DataFrame 的显示样式，而不会更改 DataFrame 中的实际数据。

提问：修改的样式如何恢复?

答：当您使用 df.style.format() 方法更改了 DataFrame 的显示样式，实际上您并没有修改 DataFrame 本身的数据，只是修改了其显示的样式。

要“取消”样式更改并返回到原始显示，您只需直接调用 DataFrame 的名称。例如，如果您的 DataFrame 名称是 df，只需再次输入 df 即可。

但如果您已经将样式化的 DataFrame 分配给了另一个变量，例如 styled_df = df.style.format(...), 则原始的 df 仍然保持不变。在这种情况下，直接调用 df 会显示原始的未格式化数据。

总之，只需再次引用原始 DataFrame 的名称即可返回到未格式化的显示。

df
1

直接修改法：当数据类型为numpy.ndarray时 会更改数据本身

# 数据准备
numbers = np.random.random(10)**10
print(numbers)

# 转换数据为百分数
percentages = numbers * 100

# 将数字列表转化为百分数形式的字符串
formatted_percentages = ["{:.2f}%".format(p) for p in percentages]
formatted_percentages
1
2
3
4
5
6
7
8
9
10

[2.73666561e-10 1.57123441e-12 5.26265187e-02 9.85684929e-14
 2.58206465e-07 1.14402849e-04 5.41450503e-01 7.71294410e-02
 3.59544557e-02 7.83249726e-01]





['0.00%',
 '0.00%',
 '5.26%',
 '0.00%',
 '0.00%',
 '0.01%',
 '54.15%',
 '7.71%',
 '3.60%',
 '78.32%']
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

关键代码解析：[“{:.2f}%”.format§ for p in percentages]

当然可以，这段代码是一个列表推导式（list comprehension），用于格式化和转换数字列表为百分数字符串列表。下面是对这段代码的详细解析：

1. 列表推导式：[expression for item in iterable] 是一个简洁的方法来创建列表。它遍历每一个 item 在 iterable 中，并使用 expression 计算得到新的值，最后将这些值组合成一个新的列表。

2. "{:.2f}%".format(p)：这是一个字符串格式化表达式。

   • "{:.2f}" 是一个格式字符串，它告诉 Python 如何格式化一个浮点数。
     • . 表示小数点。
     • 2 表示小数点后保留两位数字。
     • f 表示浮点数格式。
   • % 是添加在字符串末尾的，将数字转换为百分比的形式。
   • .format(p) 是一个方法，用于将浮点数 p 插入到格式字符串中，产生一个格式化后的字符串。

3. for p in percentages：这是一个循环，它会遍历 percentages 列表中的每一个值，并将每个值赋给变量 p。

所以，这个列表推导式的工作方式是：对于 percentages 列表中的每一个数字 p，它都会创建一个新的字符串，其中 p 被格式化为百分数形式，并保留两位小数。最后，这些格式化的字符串被组合成一个新的列表。

直接修改法2：当数据类型为dataframe时 会修改数据本身

如果这列数据是一个 pandas DataFrame 的列，您可以使用 pandas 的 .apply() 方法来格式化每个值。以下是步骤：

1. 首先，确保您已导入 pandas 库。
2. 使用 .apply() 方法并传递一个 lambda 函数来格式化每个值。

假设您的 DataFrame 名称为 df 并且要格式化的列名为 'column_name'，那么您可以按以下方式操作：

df['column_name'] = df['column_name'].apply(lambda x: "{:.2f}%".format(x*100))
1

# 使用刚才的 `percentages` 数据来创建一个简单的 DataFrame，并将其转换为百分数格式
df2 = pd.DataFrame({'Values':percentages})

# 将Values列转换为百分数格式
df2['Values'] = df2['Values'].apply(lambda x:"{:.2f}%".format(x))

df2
1
2
3
4
5
6
7

再拓展 : “{:.2f}%”.format§ 与’{0:.2%}'.format§

总结一下：

“{:.2f}%”.format§ 是手动添加百分号的方式，您需要确保值已经乘以 100。

‘{0:.2%}’.format§ 会自动乘以 100 并添加百分号。

# 示例：
a = 0.5
print('{:.2f}%'.format(a))
print('{0:.2%}'.format(a))
1
2
3
4

0.50%
50.00%
1
2

此外：在字符串格式化中，{} 中的数字（如 {0}）表示参数的位置索引。当使用 .format() 方法传递多个参数时，这可以帮助您指定哪个参数应该放在哪个位置。例如：

"{} {}".format("Hello", "World")  # 输出 "Hello World"
"{1} {0}".format("Hello", "World")  # 输出 "World Hello"
1
2

但在大多数情况下，当您只有一个参数并且按顺序插入它们时，位置索引是可以省略的，因此以下两种写法是等效的：

1. "{:.2%}".format(value)
2. "{0:.2%}".format(value)

106.查找上一题数据中第3大值的行号

方法一：

查找某列数据中第3大值的行号。

选择了列 ‘column1’ 中的前三个最大值，然后直接从返回的索引中选择最后一个，即第3大值的索引。

# type(df['column1'].nlargest(3)) pandas.core.series.Series

df['column1'].nlargest(3).index[-1]
1
2
3

9
1

方法二：

使用 df['column1'].argsort() 会返回一个整数索引的 Series，该 Series 描述了如何对 df['column1'] 进行排序以使其按升序排列。

例如，如果您有以下 DataFrame：

import pandas as pd

data = {
    'column1': [50, 10, 40, 30, 20]
}
df = pd.DataFrame(data)
1
2
3
4
5
6

执行 df['column1'].argsort() 会返回：

1    1
4    4
3    3
2    2
0    0
Name: column1, dtype: int64
1
2
3
4
5
6

# 首先对列进行升序排序，得到索引从小到大的排序，然后使用 `iloc[-3]` 选择第3大的值，即为原始数第三大值的索引。
df['column1'].argsort().iloc[-3]
1
2

9
1

注意：

argsort() 默认是按升序排列，不直接提供选项来调整排序的方向。

如果想按降序排列，可以先取反（对于数字列），然后再使用 argsort()。例如：

desc_order_index = (-df['column1']).argsort()
1

这样，desc_order_index 就会表示按降序排列 df['column1'] 所需的索引顺序。

如果您想获取第3大的值的行号，可以使用：

third_largest_index = (-df['column1']).argsort().iloc[2]
1

这将首先对列进行降序排序，然后使用 iloc[2] 选择第3大的值的索引。

107.反转df的行

方法一：

# df.iloc[::-1].reset_index(drop=True) 此方法更接近实际使用，多了一个丢弃旧索引的步骤
df.iloc[::-1]
1
2

df[::-1]
1

方法二：本质是和方法一一样，但是有个容易忽略的点

df.iloc[::-1,:]
1

注意：df.iloc[::-1,:]可以达到同样的效果，但是df[::-1,:]会报错。

• df.iloc[::-1] 或 df.iloc[::-1, :] 可以用来反转 DataFrame 的行，并保留所有列。iloc 用于基于整数位置的索引。
• df[::-1] 也可以用来反转行，但不允许使用额外的列索引（:），因此 df[::-1, :] 会引发语法错误。

在 Pandas 中，df[::-1] 是一个简单的语法糖，它背后实际上是在使用 iloc。iloc 允许更复杂的索引选项，包括同时选择行和列，因此 df.iloc[::-1, :] 是有效的。

以下是一些例子来说明这些点：

import pandas as pd

# 创建一个 DataFrame
df = pd.DataFrame({
    'A': [1, 2, 3],
    'B': [4, 5, 6]
})

# 使用 df[::-1] 反转 DataFrame 的行
df_reversed_1 = df[::-1]

# 使用 df.iloc[::-1, :] 反转 DataFrame 的行
df_reversed_2 = df.iloc[::-1, :]
1
2
3
4
5
6
7
8
9
10
11
12
13

在这两种情况下，行都被成功反转，但索引保持不变。如果需要，您可以使用 reset_index(drop=True) 来重置索引。

108.按照多列对数据进行合并

# 输入
df1 = pd.DataFrame({
    'key1': ['K0', 'K0', 'K1', 'K2'],
    'key2': ['K0', 'K1', 'K0', 'K1'],
    'A': ['A0', 'A1', 'A2', 'A3'],
    'B': ['B0', 'B1', 'B2', 'B3']
})

df2 = pd.DataFrame({
    'key1': ['K0', 'K1', 'K1', 'K2'],
    'key2': ['K0', 'K0', 'K0', 'K0'],
    'C': ['C0', 'C1', 'C2', 'C3'],
    'D': ['D0', 'D1', 'D2', 'D3']
})
1
2
3
4
5
6
7
8
9
10
11
12
13
14

pd.merge(df1,df2,on = ['key1','key2'])
1

109.按照多列对数据进行合并

pd.merge(df1, df2, how='left', on=['key1', 'key2'])
1

注意区分上述两种数据处理方式的区别：

result = pd.merge(df1, df2, how='left', on=['key1', 'key2'])
1

这行代码会执行左连接（left join）合并操作。它将根据 key1 和 key2 列合并 df1 和 df2，并保留 df1（左侧 DataFrame）中的所有行。如果 df2（右侧 DataFrame）中存在匹配的行，则 df2 的值将被添加到结果中。如果 df2 中没有匹配的行，则结果中的相应单元格将被填充为 NaN。

具体效果如下：

1. df1 和 df2 中的所有列都将出现在结果 DataFrame 中。
2. df1 中的所有行都将出现在结果 DataFrame 中。
3. 如果 df2 中有与 df1 匹配的行（基于 key1 和 key2），则 df2 中的 C 和 D 列的值将被添加到结果中。
4. 如果 df2 中没有与 df1 匹配的行，则结果 DataFrame 中的 C 和 D 列将被填充为 NaN。

让我们来执行这个操作并查看结果。

合并的结果如下：

[
$$\begin{array}{cccccc} \text{key1} & \text{key2} & \text{A} & \text{B} & \text{C} & \text{D} \ \hline \text{K0} & \text{K0} & \text{A0} & \text{B0} & \text{C0} & \text{D0} \ \text{K0} & \text{K1} & \text{A1} & \text{B1} & \text{NaN} & \text{NaN} \ \text{K1} & \text{K0} & \text{A2} & \text{B2} & \text{C1} & \text{D1} \ \text{K1} & \text{K0} & \text{A2} & \text{B2} & \text{C2} & \text{D2} \ \text{K2} & \text{K1} & \text{A3} & \text{B3} & \text{NaN} & \text{NaN} \ \end{array}$$
]

如您所见：

• 第一行 (key1=K0, key2=K0) 在 df2 中有匹配的行，所以 C 和 D 列的值是 C0 和 D0。
• 第二行 (key1=K0, key2=K1) 在 df2 中没有匹配的行，所以 C 和 D 列的值是 NaN。
• 第三和第四行 (key1=K1, key2=K0) 在 df2 中有两个匹配的行，所以结果中分别有 C1, D1 和 C2, D2。
• 第五行 (key1=K2, key2=K1) 在 df2 中没有匹配的行，所以 C 和 D 列的值是 NaN。

110.再次读取数据1并显示所有的列

df = pd.read_csv('pandas120_101_120_1.csv', encoding='gbk')
pd.set_option("display.max.columns", None)
df
1
2
3

105 rows × 53 columns

拓展：pd.set_option(“display.max_columns”, None)

pd.set_option("display.max_columns", None) 是用来设置 Pandas 显示选项的，确保当您显示 DataFrame 时，所有的列都会被显示出来，而不是被截断。

• "display.max_columns" 是要设置的选项的名称。
• None 是分配给该选项的值，意味着没有列的最大数量限制。

例如，在处理具有大量列的大型 DataFrame 时，Pandas 默认只显示一部分列。使用上面的设置，您可以确保所有列都会被显示出来。

如果您想要设置其他显示选项，例如行的最大数量，您可以使用 pd.set_option("display.max_rows", None)。

这是一个例子，演示如何使用这个设置：

import pandas as pd

# 设置显示选项以显示所有列
pd.set_option("display.max_columns", None)

# 创建一个具有多个列的 DataFrame
df = pd.DataFrame({
    'A': [1, 2, 3],
    'B': [4, 5, 6],
    'C': [7, 8, 9],
    'D': [10, 11, 12],
    'E': [13, 14, 15]
})

# 显示 DataFrame
print(df)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

在这个例子中，无论您的屏幕有多宽，DataFrame 的所有列都会被显示出来。

如果您想要恢复 Pandas 的显示设置到默认值，您可以使用 pd.reset_option() 函数。您只需提供您想要重置的选项的名称作为参数。

例如：

• 要重置最大列数的显示设置，您可以使用：pd.reset_option("display.max_columns")
• 要重置最大行数的显示设置，您可以使用：pd.reset_option("display.max_rows")

如果您想要一次重置多个选项，只需将它们作为参数传递即可：

pd.reset_option("display.max_columns", "display.max_rows")
1

如果您想要重置所有的显示选项到默认设置，您可以使用：

pd.reset_option("all")
1

但是注意，使用 "all" 选项时，会出现一个额外的确认提示，因为这将重置所有的选项，不仅仅是显示相关的选项。

111.查找secondType与thirdType值相等的行号

方法一：布尔索引

mask = df[df['secondType']==df['thirdType']].index
mask
1
2

Int64Index([  0,   2,   4,   5,   6,  10,  14,  23,  25,  27,  28,  29,  30,
             33,  37,  38,  39,  40,  41,  48,  49,  52,  53,  55,  57,  61,
             65,  66,  67,  71,  73,  74,  75,  79,  80,  82,  85,  88,  89,
             91,  96, 100],
           dtype='int64')
1
2
3
4
5

方法二：loc方法

注意：用于基于标签的索引。当使用布尔序列进行索引时，它返回所有对应于 True 的行。

例如：df.loc[df[‘secondType’] == df[‘thirdType’]] 返回所有 secondType 和 thirdType 列值相等的行。

mask = df.loc[df['secondType'] == df['thirdType']].index
mask
1
2

Int64Index([  0,   2,   4,   5,   6,  10,  14,  23,  25,  27,  28,  29,  30,
             33,  37,  38,  39,  40,  41,  48,  49,  52,  53,  55,  57,  61,
             65,  66,  67,  71,  73,  74,  75,  79,  80,  82,  85,  88,  89,
             91,  96, 100],
           dtype='int64')
1
2
3
4
5

方法三：np.where()

np.where 函数用于返回输入数组（在这种情况下是一个布尔数组）中 True 值的索引。

当您使用它来比较 DataFrame 中的两列时，它将返回一个元组，其中包含满足条件的行索引。

本例中：使用 np.where 找到 secondType 和 thirdType 值相等的行号

equal_rows = np.where(df['secondType'] == df['thirdType'])
1

其中，equal_rows 将是一个元组，包含一个数组，数组中的值是满足条件的行号，可以通过 equal_rows[0] 来访问这个数组。

equal_rows_index = equal_rows[0] # 结果将是一个数组：array([0, 2])

equal_rows = np.where(df.secondType == df.thirdType)
equal_rows[0]
1
2

array([  0,   2,   4,   5,   6,  10,  14,  23,  25,  27,  28,  29,  30,
        33,  37,  38,  39,  40,  41,  48,  49,  52,  53,  55,  57,  61,
        65,  66,  67,  71,  73,  74,  75,  79,  80,  82,  85,  88,  89,
        91,  96, 100], dtype=int64)
1
2
3
4

112.查找薪资大于平均薪资的第三个数据

方法一：找到薪资大于均值的数据，选择第三个

mean_value = df['salary'].mean()
temp_df = df.loc[df['salary']>mean_value]['salary'].reset_index()
temp_df.loc[2,'index']
1
2
3

5
1

# 实际使用应该是要具体的值吧，以下是获取第三个值的代码
mean_value = df['salary'].mean()
temp_df = df.loc[df['salary']>mean_value]['salary'].reset_index()
temp_df.loc[2,'salary']
1
2
3
4

50000
1

方法二：np.argwhere()

np.argwhere(): 这是 NumPy 的一个函数，用于找出传入数组中非零（True）元素的索引。在这里，它被用于找出 ‘salary’ 列中大于平均工资的所有索引。

报错示例：np.argwhere(df[‘salary’]>df[‘salary’].mean())[2]

运行报错：ValueError: Length of values (1) does not match length of index (105)

说明:
这个错误是由于尝试使用 np.argwhere 处理 pandas 的 Series 时产生的。np.argwhere 与 pandas Series 之间存在一些不兼容的问题，特别是在返回值的形状上。这就是为什么你看到 “Length of values (1) does not match length of index (105)” 这个错误消息的原因。

为了解决这个问题，你可以将 pandas Series 转换为 NumPy 数组，然后应用 np.argwhere。以下是如何做到这一点的方法：

indices = np.argwhere(df['salary'].values > df['salary'].mean()).flatten()
index_of_third_entry = indices[2]
1
2

在这里，我们使用 .values 将 Series 转换为 NumPy 数组。flatten() 用于将结果从二维数组转换为一维数组。

temp_df = np.argwhere(df['salary'].values>df['salary'].mean()).flatten()
temp_df[2]
1
2

5
1

temp_df = np.argwhere(df['salary'].values>df['salary'].mean()).flatten()
df.loc[temp_df[2],'salary']
1
2

50000
1

113.将上一题数据的salary列开根号

np.sqrt(df['salary'])
1

0      193.649167
1      122.474487
2       59.160798
3      212.132034
4      173.205081
          ...    
100    158.113883
101    187.082869
102    173.205081
103    141.421356
104    146.628783
Name: salary, Length: 105, dtype: float64
1
2
3
4
5
6
7
8
9
10
11
12

df['salary'].apply(np.sqrt)
1

0      193.649167
1      122.474487
2       59.160798
3      212.132034
4      173.205081
          ...    
100    158.113883
101    187.082869
102    173.205081
103    141.421356
104    146.628783
Name: salary, Length: 105, dtype: float64
1
2
3
4
5
6
7
8
9
10
11
12

114.将上一题数据的linestaion列按_拆分

# 确定数据类型
df[['linestaion']].info()
1
2

<class 'pandas.core.frame.DataFrame'>
RangeIndex: 105 entries, 0 to 104
Data columns (total 1 columns):
 #   Column      Non-Null Count  Dtype 
---  ------      --------------  ----- 
 0   linestaion  45 non-null     object
dtypes: object(1)
memory usage: 968.0+ bytes
1
2
3
4
5
6
7
8

# 使用str.split拆分
temp_df = df['linestaion'].str.split('_')
temp_df
1
2
3

0                                        NaN
1                                        NaN
2              [4号线, 城星路;4号线, 市民中心;4号线, 江锦路]
3                                 [1号线, 文泽路]
4                                        NaN
                       ...                  
100                                      NaN
101                                      NaN
102    [1号线, 滨和路;1号线, 江陵路;1号线, 滨和路;1号线, 江陵路]
103                                      NaN
104                                      NaN
Name: linestaion, Length: 105, dtype: object
1
2
3
4
5
6
7
8
9
10
11
12

115.查看上一题数据中一共有多少列

df.shape[1]
1

53
1

116.提取industryField列以’数据’开头的行

df[df['industryField'].str.startswith('数据')]
1

117.按列制作数据透视表

pd.pivot_table 来制作数据透视表

pd.pivot_table(df, values=["salary", "score"], index="positionId")
1

这里的意思是：

• 使用 df（一个 pandas DataFrame）作为数据源。
• 将 positionId 列作为索引（行标签）。
• 对 salary 和 score 两列的值进行聚合。默认情况下，pd.pivot_table 使用 mean 作为聚合函数，这意味着它将为每个唯一的 positionId 计算 salary 和 score 的平均值。

结果将是一个新的 DataFrame，其中行标签是 positionId 的唯一值，列标签是 salary 和 score，每个单元格的值是对应 positionId 的 salary 和 score 的平均值。

如果你有其他特定的聚合函数或其他参数需要，你可以进一步定制 pd.pivot_table。例如，你可以通过添加 aggfunc 参数来指定其他聚合函数。

pd.pivot_table(df,values = ['salary','score'],index = 'positionId')
1

95 rows × 2 columns

118.同时对salary、score两列进行计算

注意：内置的聚合函数需要使用字符串指定，numpy的聚合函数直接指定即可

1. 内置的聚合函数：当使用pandas内置的聚合函数（如’sum’、‘mean’、'max’等）时，您应该使用它们的字符串表示。例如：df[['salary', 'score']].agg(['sum', 'mean', 'max'])

2. NumPy的聚合函数：当您想使用NumPy的聚合函数时，您应该直接传递函数，而不是它们的字符串表示。例如：df[['salary', 'score']].agg([np.sum, np.mean, np.max])

# 内置的聚合函数需要使用字符串指定
df[['salary','score']].agg(['sum','mean','max'])
1
2

# numpy的聚合函数直接指定即可
df[['salary','score']].agg([np.sum,np.mean,np.max])
1
2

119.对salary求平均，对score列求和

df[['salary','score']].agg([np.mean,np.sum])
1

df[['salary','score']].agg(['mean','sum'])
1

120.计算并提取平均薪资最高的区

df[['district','salary']].groupby(by = ['district']).mean().sort_values(by = 'district',ascending = False).head(1)
1