Pandas中的DataFrame数据类型API函数参考手册 二
- 目录
- 一、构造函数(Constructor)
- 二、属性和基础数据(Attributes and underlying data)
- 三、转换(Conversion)
- 四、索引、迭代(Indexing, iteration)
- 1. DataFrame.head([n])
- 2. DataFrame.at
- 3. DataFrame.iat
- 4. DataFrame.loc
- 5. DataFrame.iloc
- 6. DataFrame.insert(loc, column, value[, ...])
- 7. DataFrame.__iter__()
- 8. DataFrame.items()
- 9. DataFrame.keys()
- 10. DataFrame.iterrows()
- 11. DataFrame.itertuples([index, name])
- 12. DataFrame.pop(item)
- 13. DataFrame.tail([n])
- 14. DataFrame.xs(key[, axis, level, drop_level])
- 15. DataFrame.get(key[, default])
- 16. DataFrame.isin(values)
- 17. DataFrame.where(cond[, other, inplace, ...])
- 18. DataFrame.mask(cond[, other, inplace, axis, ...])
- 19. DataFrame.query(expr, *[, inplace])
目录
前言
一、构造函数(Constructor)
二、属性和基础数据(Attributes and underlying data)
三、转换(Conversion)
DataFrame.astype(dtype[, copy, errors]) # 将 pandas 对象转换为指定的 dtype dtype。
DataFrame.convert_dtypes([infer_objects, ...]) # 使用支持的数据类型将列转换为最佳数据类型pd.NA。
DataFrame.infer_objects([copy]) # 尝试为对象列推断出更好的数据类型。
DataFrame.copy([deep]) # 复制此对象的索引和数据。
DataFrame.bool() # 返回单个元素 Series 或 DataFrame 的 bool。
1. DataFrame.astype(dtype[, copy, errors])
DataFrame.astype(dtype, copy=None, errors='raise')
使用示例：
import pandas as pd
# 创建一个 DataFrame 对象
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4.0, 5.0, 6.0], 'C': ['7', '8', '9']})
# 将 'B' 列数据类型转换为整型
df['B'] = df['B'].astype(int)
# 将 'C' 列数据类型转换为浮点型
df['C'] = df['C'].astype(float)
# 打印转换后的 DataFrame 对象
print(df)
输出结果：
A B C
0 1 4 7.0
1 2 5 8.0
2 3 6 9.0
在这个示例中，首先创建了一个 DataFrame 对象 df。然后使用 df[‘B’] = df[‘B’].astype(int) 将 ‘B’ 列数据类型转换为整型，并使用 df[‘C’] = df[‘C’].astype(float) 将 ‘C’ 列数据类型转换为浮点型。最后打印转换后的 DataFrame 对象 df。
2. DataFrame.convert_dtypes([infer_objects, …])
DataFrame.convert_dtypes(
infer_objects=True,
convert_string=True,
convert_integer=True,
convert_boolean=True,
convert_floating=True,
dtype_backend='numpy_nullable'
)
使用示例：
import pandas as pd
# 创建一个 DataFrame 对象
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4.0, 5.0, 6.0], 'C': ['7', '8', '9'], 'D': [True, False, True]})
# 执行自动数据类型转换
df = df.convert_dtypes()
# 打印转换后的 DataFrame 对象
print(df)
输出结果：
A B C D
0 1 4 7 True
1 2 5 8 False
2 3 6 9 True
在这个示例中，首先创建了一个 DataFrame 对象 df。然后使用 df = df.convert_dtypes() 执行自动数据类型转换，将 ‘A’、‘B’、‘C’、‘D’ 列分别转换为 int64、float64、string 和 bool 数据类型。最后打印转换后的 DataFrame 对象 df。
也可以通过参数控制是否对某些数据类型进行转换。例如，使用 df = df.convert_dtypes(convert_string=False) 可以将 dataFrame 中的字符串列（'C’列）不进行自动转换。
使用示例：
import pandas as pd
# 创建一个 DataFrame 对象
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4.0, 5.0, 6.0], 'C': ['7', '8', '9'], 'D': [True, False, True]})
# 执行自动数据类型转换，排除字符串列
df = df.convert_dtypes(convert_string=False)
# 打印转换后的 DataFrame 对象
print(df)
输出结果：
A B C D
0 1 4 7 True
1 2 5 8 False
2 3 6 9 True
在这个示例中，首先创建了一个 DataFrame 对象 df。然后使用 df = df.convert_dtypes(convert_string=False) 执行自动数据类型转换，将 ‘A’、‘B’、‘D’ 列分别转换为 int64、float64 和 bool 数据类型，但不对 ‘C’ 列进行数据类型转换，保持其原有的字符串数据类型。最后打印转换后的 DataFrame 对象 df。
3. DataFrame.infer_objects([copy])
DataFrame.infer_objects(copy=None)
使用示例：
import pandas as pd
# 创建一个 DataFrame 对象
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4.0, 5.0, 6.0], 'C': ['2022-01-01', '2022-02-01', '2022-03-01'], 'D': [(1, 2), (3, 4), (5, 6)]})
# 执行对象类型推断
df = df.infer_objects()
# 打印转换后的 DataFrame 对象
print(df)
输出结果：
A B C D
0 1 4.0 2022-01-01 (1, 2)
1 2 5.0 2022-02-01 (3, 4)
2 3 6.0 2022-03-01 (5, 6)
在这个示例中，首先创建了一个 DataFrame 对象 df，其中 ‘A’、‘B’ 列的数据类型分别为 int64 和 float64，‘C’ 列的数据类型为 string，‘D’ 列的数据类型为 object。然后使用 df = df.infer_objects() 执行对象类型推断，将 ‘C’、‘D’ 列的数据类型分别转换为日期和元组对象。最后打印转换后的 DataFrame 对象 df。
4. DataFrame.copy([deep])
DataFrame.copy(deep=True)
使用示例：
import pandas as pd
# 创建一个 DataFrame 对象
df = pd.DataFrame({'A': [1, 2, 3], 'B': [4.0, 5.0, 6.0], 'C': ['a', 'b', 'c']})
# 复制 DataFrame 对象
df_copy = df.copy()
# 修改原始 DataFrame 对象并打印结果
df.loc[0, 'A'] = 999
print("Original DataFrame:")
print(df)
# 打印复制后的 DataFrame 对象
print("\nCopied DataFrame:")
print(df_copy)
输出结果：
Original DataFrame:
A B C
0 999 4.0 a
1 2 5.0 b
2 3 6.0 c
Copied DataFrame:
A B C
0 1 4.0 a
1 2 5.0 b
2 3 6.0 c
在这个示例中，首先创建了一个 DataFrame 对象 df，然后使用 df_copy = df.copy() 方法创建了一个 DataFrame 对象的副本 df_copy。接着修改原始 DataFrame 对象 df 的元素 df.loc[0, ‘A’] = 999，并打印原始 DataFrame 对象和副本 DataFrame 对象。
由输出结果可以看出，修改了原始 DataFrame 对象 df 的元素，而复制后的 DataFrame 对象 df_copy 并没有受到影响。
5. DataFrame.bool()
使用示例：
import pandas as pd
# 创建一个 DataFrame 对象
df = pd.DataFrame({'A': [1, 0, -1], 'B': [True, False, True]})
# 转换为布尔型数据并打印结果
bool_df = df.bool()
print(bool_df)
输出结果：
ValueError: The truth value of a DataFrame is ambiguous. Use a.empty, a.bool(), a.item(), a.any() or a.all().
使用示例：
import pandas as pd
# 创建一个 DataFrame 对象
df = pd.DataFrame({'A': [1, 0, -1], 'B': [True, False, True]})
# 将 DataFrame 转换为布尔值
if not df.empty:
df_bool = df.any().any()
print(df_bool)
else:
print("DataFrame 为空")
输出结果：
True
在上述示例代码中，我们首先检查 DataFrame 是否为空。如果 DataFrame 不为空，则使用 DataFrame.any().any() 将 DataFrame 转换为一个布尔值，表示 DataFrame 中是否存在任何 True 值。最后，我们使用 print() 输出结果。
四、索引、迭代(Indexing, iteration)
DataFrame.head([n]) # 返回前n行。
DataFrame.at # 访问行/列标签对的单个值。
DataFrame.iat # 按整数位置访问行/列对的单个值。
DataFrame.loc # 通过标签或布尔数组访问一组行和列。
DataFrame.iloc # 纯粹基于整数位置的索引，用于按位置选择。
DataFrame.insert(loc, column, value[, ...]) # 在指定位置将列插入 DataFrame。
DataFrame.__iter__() # 遍历信息轴。
DataFrame.items() # 迭代（列名，系列）对。
DataFrame.keys() # 获取“信息轴”（有关更多信息，请参阅索引）。
DataFrame.iterrows() # 作为 (index, Series) 对迭代 DataFrame 行。
DataFrame.itertuples([index, name]) # 作为命名元组迭代 DataFrame 行。
DataFrame.pop(item) # 返回项目并从框架中删除。
DataFrame.tail([n]) # 返回最后n行。
DataFrame.xs(key[, axis, level, drop_level]) # 从 Series/DataFrame 返回横截面。
DataFrame.get(key[, default]) # 从给定键的对象中获取项目（例如：DataFrame 列）。
DataFrame.isin(values) # DataFrame 中的每个元素是否包含在值中。
DataFrame.where(cond[, other, inplace, ...]) # 替换条件为 False 的值。
DataFrame.mask(cond[, other, inplace, axis, ...]) # 替换条件为 True 的值。
DataFrame.query(expr, *[, inplace]) # 使用布尔表达式查询 DataFrame 的列。
1. DataFrame.head([n])
DataFrame.head(n=5)
使用示例：
import pandas as pd
# 创建一个 DataFrame 对象
data = {'name': ['Alice', 'Bob', 'Charlie', 'David', 'Emily'],
'age': [23, 51, 18, 44, 31],
'city': ['New York', 'Paris', 'London', 'Tokyo', 'Beijing']}
df = pd.DataFrame(data)
# 查看 DataFrame 的前 3 行数据
print(df.head(3))
输出结果：
name age city
0 Alice 23 New York
1 Bob 51 Paris
2 Charlie 18 London
在上述示例代码中，我们首先创建了一个包含姓名、年龄和城市信息的 DataFrame 对象。然后，我们使用 df.head(3) 函数返回该 DataFrame 的前 3 行数据，并使用 print() 输出结果。
2. DataFrame.at
使用示例：
import pandas as pd
# 创建一个包含成绩信息的 DataFrame 对象
data = {'姓名': ['小明', '小红', '小刚'],
'语文': [76, 88, 90],
'数学': [85, 92, 94],
'英语': [64, 78, 89]}
df = pd.DataFrame(data)
print(df)
# 获取 '小明' 的语文成绩并输出
score = df.at[0, '语文']
print(f"小明的语文成绩是：{score}")
# 修改 '小明' 的英语成绩为 79
df.at[0, '英语'] = 79
print(df)
输出结果：
姓名 语文 数学 英语
0 小明 76 85 64
1 小红 88 92 78
2 小刚 90 94 89
小明的语文成绩是：76
姓名 语文 数学 英语
0 小明 76 85 79
1 小红 88 92 78
2 小刚 90 94 89
在上述示例代码中，我们首先创建了一个包含姓名、语文、数学和英语成绩信息的 DataFrame 对象，并使用 print() 函数输出结果。接着，我们使用 df.at[0, ‘语文’] 获取了行标签为 0（即第一行），列标签为 ‘语文’ 的元素值，并使用字符串格式化方式，输出了小明的语文成绩。最后，我们使用 df.at[0, ‘英语’] = 79 的方式，将行标签为 0，列标签为 ‘英语’ 的元素值修改为 79，并使用 print() 输出了修改后的 DataFrame。
3. DataFrame.iat
使用示例：
import pandas as pd
# 创建一个包含成绩信息的 DataFrame 对象
data = {'姓名': ['小明', '小红', '小刚'],
'语文': [76, 88, 90],
'数学': [85, 92, 94],
'英语': [64, 78, 89]}
df = pd.DataFrame(data)
print(df)
# 获取 '小明' 的语文成绩并输出
score = df.iat[0, 1]
print(f"小明的语文成绩是：{score}")
# 修改 '小明' 的英语成绩为 79
df.iat[0, 3] = 79
print(df)
输出结果：
姓名 语文 数学 英语
0 小明 76 85 64
1 小红 88 92 78
2 小刚 90 94 89
小明的语文成绩是：76
姓名 语文 数学 英语
0 小明 76 85 79
1 小红 88 92 78
2 小刚 90 94 89
在上述示例代码中，我们首先创建了一个包含姓名、语文、数学和英语成绩信息的 DataFrame 对象，并使用 print() 函数输出结果。接着，我们使用 df.iat[0, 1] 获取了行号为 0，列号为 1 的元素值，并使用字符串格式化方式，输出了小明的语文成绩。最后，我们使用 df.iat[0, 3] = 79 的方式，将行号为 0，列号为 3 的元素值修改为 79，并使用 print() 输出了修改后的 DataFrame。
4. DataFrame.loc
使用示例：
import pandas as pd
# 创建一个包含成绩信息的 DataFrame 对象
data = {'姓名': ['小明', '小红', '小刚'],
'语文': [76, 88, 90],
'数学': [85, 92, 94],
'英语': [64, 78, 89]}
df = pd.DataFrame(data)
print(df)
# 获取 '小明' 的全部成绩并输出
scores = df.loc[0, :]
print(f"小明的全部成绩是：{scores}")
# 获取 '小明' 和 '小红' 的语文和数学成绩并输出
scores = df.loc[[0, 1], ['语文', '数学']]
print(f"小明和小红的语文和数学成绩是：\n{scores}")
# 将 '小刚' 的英语成绩修改为 80
df.loc[2, '英语'] = 80
print(df)
输出结果：
姓名 语文 数学 英语
0 小明 76 85 64
1 小红 88 92 78
2 小刚 90 94 89
小明的全部成绩是：姓名 小明
语文 76
数学 85
英语 64
Name: 0, dtype: object
小明和小红的语文和数学成绩是：
语文 数学
0 76 85
1 88 92
姓名 语文 数学 英语
0 小明 76 85 64
1 小红 88 92 78
2 小刚 90 94 80
在上述示例代码中，我们首先创建了一个包含姓名、语文、数学和英语成绩信息的 DataFrame 对象，并使用 print() 函数输出结果。接着，我们使用 df.loc[0, :] 获取了行标签为 0（即第一行），列标签为所有列的元素值，并使用字符串格式化方式，输出了小明的全部成绩。然后，我们使用 df.loc[[0, 1], [‘语文’, ‘数学’]] 的方式，获取了行标签为 0 和 1，列标签为 ‘语文’ 和 ‘数学’ 的元素值，并使用字符串格式化方式，输出了小明和小红的语文和数学成绩。
最后，我们使用 df.loc[2, ‘英语’] = 80 的方式，将行标签为 2，列标签为 ‘英语’ 的元素值修改为 80，并使用 print() 输出了修改后的 DataFrame。
5. DataFrame.iloc
使用示例：
import pandas as pd
# 创建一个包含成绩信息的 DataFrame 对象
data = {'姓名': ['小明', '小红', '小刚'],
'语文': [76, 88, 90],
'数学': [85, 92, 94],
'英语': [64, 78, 89]}
df = pd.DataFrame(data)
print(df)
# 获取第一行的全部成绩并输出
scores = df.iloc[0, :]
print(f"第一行的全部成绩是：{scores}")
# 获取第一列和第二列的全部成绩并输出
scores = df.iloc[:, [1, 2]]
print(f"第一列和第二列的全部成绩是：\n{scores}")
# 将第三行的英语和数学成绩修改为 80 和 88
df.iloc[2, [2,3]] = [88, 80]
print(df)
输出结果：
姓名 语文 数学 英语
0 小明 76 85 64
1 小红 88 92 78
2 小刚 90 94 89
第一行的全部成绩是：姓名 小明
语文 76
数学 85
英语 64
Name: 0, dtype: object
第一列和第二列的全部成绩是：
语文 数学
0 76 85
1 88 92
2 90 94
姓名 语文 数学 英语
0 小明 76 85 64
1 小红 88 92 78
2 小刚 90 88 80
在上述示例代码中，我们首先创建了一个包含姓名、语文、数学和英语成绩信息的 DataFrame 对象，并使用 print() 函数输出结果。接着，我们使用 df.iloc[0, :] 获取了行索引位置为 0（即第一行），列索引位置为所有列的元素值，并使用字符串格式化方式，输出了第一行的全部成绩。然后，我们使用 df.iloc[:, [1, 2]] 的方式，获取了行索引位置为所有行，列索引位置为 1 和 2 的元素值，并使用字符串格式化方式，输出了第一列和第二列的全部成绩。
最后，我们使用 df.iloc[2, [2,3]] = [88, 80] 的方式，将行索引位置为 2，列索引位置为 2 和 3 的元素值分别修改为 88 和 80，并使用 print() 输出了修改后的 DataFrame。
使用示例1：
import pandas as pd
# 创建一个包含成绩信息的 DataFrame 对象
data = {'姓名': ['小明', '小红', '小刚'],
'语文': [76, 88, 90],
'数学': [85, 92, 94],
'英语': [64, 78, 89]}
df = pd.DataFrame(data)
# 尝试获取不存在的行，将抛出 IndexError 异常
df.iloc[3, :]
输出结果：
IndexError: single positional indexer is out-of-bounds
在第一个示例代码中，我们尝试使用 .iloc[3, :] 获取 DataFrame 中的第四行，由于 DataFrame 只有三行，因此这将导致 IndexError 异常。
使用示例2：
import pandas as pd
# 创建一个包含成绩信息的 DataFrame 对象
data = {'姓名': ['小明', '小红', '小刚'],
'语文': [76, 88, 90],
'数学': [85, 92, 94],
'英语': [64, 78, 89]}
df = pd.DataFrame(data)
# 尝试获取不存在的列，将抛出 IndexError 异常
df.iloc[:, 4]
输出结果：
IndexError: single positional indexer is out-of-bounds
同样的，第二个示例也会尝试获取 DataFrame 中不存在的第五列，因此会引发 IndexError 异常。
使用示例3：
import pandas as pd
# 创建一个包含成绩信息的 DataFrame 对象
data = {'姓名': ['小明', '小红', '小刚'],
'语文': [76, 88, 90],
'数学': [85, 92, 94],
'英语': [64, 78, 89]}
df = pd.DataFrame(data)
# 使用负数索引，将抛出 IndexError 异常
df.iloc[-4, :]
输出结果：
IndexError: single positional indexer is out-of-bounds
最后一个示例中我们使用负数索引，这将尝试访问 DataFrame 中不存在的行和列，并引发 IndexError 异常。
6. DataFrame.insert(loc, column, value[, …])
DataFrame.insert(loc, column, value, allow_duplicates=_NoDefault.no_default)
使用示例：
import pandas as pd
data = {"A": [1, 2, 3], "B": [4, 5, 6], "C": [7, 8, 9]}
df = pd.DataFrame(data)
# 在位置 2 插入新列 new_col
df.insert(2, "new_col", [10, 11, 12])
print(df)
输出结果：
A B new_col C
0 1 4 10 7
1 2 5 11 8
2 3 6 12 9
在该示例中，我们使用 df.insert() 方法在位置 2 插入新列 new_col，并将其填充为 [10, 11, 12]。结果 DataFrame 中的列顺序为 [‘A’, ‘B’, ‘new_col’, ‘C’]。请注意，插入新列不会更改原始 DataFrame 的列顺序，而是创建一个新的 DataFrame。
7. DataFrame.iter()
使用示例：
import pandas as pd
df = pd.DataFrame({'a': [1, 2], 'b': [3, 4], 'c': [5, 6]})
for col in df:
print(col)
输出结果：
a
b
c
在此示例中，我们创建了一个 DataFrame 对象，并使用 for 循环迭代它。由于 df 是一个 DataFrame 对象，Python 将自动调用 df.iter() 方法。该方法返回一个迭代器对象，然后可以遍历整个 DataFrame 对象中的每一列。for 循环通过遍历迭代器对象的方式，打印了 DataFrame 中每列的名称，即 a, b, 和 c。
需要注意的是，使用 DataFrame.iter() 方法仅遍历 DataFrame 的列名，并不遍历 DataFrame 对象的值。如果您需要遍历 DataFrame 对象的值，可以使用 .iterrows()、.itertuples() 或 .values() 方法来进行迭代。
8. DataFrame.items()
使用示例：
import pandas as pd
df = pd.DataFrame({'a': [1, 2], 'b': [3, 4], 'c': [5, 6]})
for name, data in df.items():
print('Column:', name)
print('Data:\n', data)
输出结果：
Column: a
Data:
0 1
1 2
Name: a, dtype: int64
Column: b
Data:
0 3
1 4
Name: b, dtype: int64
Column: c
Data:
0 5
1 6
Name: c, dtype: int64
在此示例中，我们创建了一个 DataFrame 对象，并使用 .items() 方法遍历所有的列名和对应列数据。for 循环迭代一次返回一个包含两个元素的元组，第一个元素是列名，第二个元素是 Pandas Series 对象，它包含该列的数据。
DataFrame.items() 方法在需要遍历 DataFrame 对象的每一列数据时非常有用。可以在循环中访问并处理每一列的数据内容，或者使用这个方法来合并不同的 DataFrame 对象的每一列。
9. DataFrame.keys()
使用示例：
import pandas as pd
df = pd.DataFrame({'a': [1, 2], 'b': [3, 4], 'c': [5, 6]})
print(df.keys())
输出结果：
Index(['a', 'b', 'c'], dtype='object')
在此示例中，我们创建了一个 DataFrame 对象，并使用 .keys() 属性获取 DataFrame 的列名。它返回一个包含列名的 Index 对象，这些列名是按照 DataFrame 中列的顺序排列的。
这个属性通常用于检查 DataFrame 对象的列标签，以及条件语句和函数的输入参数等操作。
需要注意的是，与 DataFrame.columns 和 DataFrame.columns.values 不同，DataFrame.keys() 返回的是一个视图而不是一个副本。如果您更改了 DataFrame 对象的列标签，DataFrame.colmuns 和 DataFrame.columns.values 可以反映出这些更改，但是 DataFrame.keys() 不会更改并且仍然显示原始列名。
10. DataFrame.iterrows()
使用示例：
import pandas as pd
df = pd.DataFrame({'a': [1, 2], 'b': [3, 4], 'c': [5, 6]})
for index, row in df.iterrows():
print('Index:', index)
print('Row:\n', row)
输出结果：
Index: 0
Row:
a 1
b 3
c 5
Name: 0, dtype: int64
Index: 1
Row:
a 2
b 4
c 6
Name: 1, dtype: int64
在此示例中，我们创建了一个 DataFrame 对象，并使用 .iterrows() 方法迭代每一行数据。for 循环迭代时，每一行数据会作为一个元组返回，第一个参数是该行数据对应的索引值，第二个参数是 Pandas Series 对象，该对象包含了该行数据的内容。
需要注意的是，使用 DataFrame.iterrows() 方法遍历 DataFrame 中的每一行并不是最有效率的方法，因为它会在 Python 和 Pandas 之间切换上下文。如果您要处理更大的数据集，可以使用矢量化操作或 Pandas 中的其他方法来进行迭代和操作。
11. DataFrame.itertuples([index, name])
DataFrame.itertuples(index=True, name='Pandas')
使用示例：
import pandas as pd
df = pd.DataFrame({'a': [1, 2], 'b': [3, 4], 'c': [5, 6]})
for row in df.itertuples(index=False, name='MyTuple'):
print(row)
输出结果：
MyTuple(a=1, b=3, c=5)
MyTuple(a=2, b=4, c=6)
在此示例中，我们创建了一个 DataFrame 对象，并使用 .itertuples() 方法迭代每一行数据。我们使用了参数 index=False 来省略索引列的输出，并使用参数 name=‘MyTuple’ 来定义生成的命名元组的名称。
每一行数据都会被返回为一个命名元组，元组的字段名是该 DataFrame 的列名，字段值是该行相应列的值。
与 DataFrame.iterrows() 相比，使用 DataFrame.itertuples() 更加高效，因为它不需要将每一行转换成 Pandas Series 对象。如果您需要处理大型数据集，则建议使用 DataFrame.itertuples() 来遍历行数据。
12. DataFrame.pop(item)
使用示例：
import pandas as pd
df = pd.DataFrame({'a': [1, 2], 'b': [3, 4], 'c': [5, 6]})
series_b = df.pop('b')
print(series_b)
print(df)
输出结果：
0 3
1 4
Name: b, dtype: int64
a c
0 1 5
1 2 6
在此示例中，我们创建了一个 DataFrame 对象，并使用 .pop() 方法删除 b 列。.pop() 方法返回了一个包含删除的列数据的 Pandas Series 对象，并且原始 DataFrame 对象被修改了，不再含有 b 列。
需要注意的是，如果您使用的是类似 df[‘b’] 的语法来访问和操作 DataFrame 的列，则不必使用 .pop() 方法，而可以使用 del df[‘b’] 来达到相同的效果。但是，如果您需要对 DataFrame 列进行连续操作或者需要将删除的列保存到变量中时，使用 .pop() 方法则更加方便。同时，如果您尝试从 DataFrame 中删除不存在的列，则会引发 KeyError 异常。
13. DataFrame.tail([n])
使用示例：
import pandas as pd
df = pd.DataFrame({'a': [1, 2, 3, 4, 5], 'b': [6, 7, 8, 9, 10], 'c': [11, 12, 13, 14, 15]})
tail_3 = df.tail(3)
print(tail_3)
输出结果：
a b c
2 3 8 13
3 4 9 14
4 5 10 15
在此示例中，我们创建了一个包含 5 行数据的 DataFrame 对象，并使用 .tail(3) 方法获取 DataFrame 的最后 3 行数据。
需要注意的是，返回的数据类型仍然是 Pandas DataFrame 对象，而不是 Pandas Series 对象。如果您只需要访问 DataFrame 的最后一行数据，则应该使用 .iloc[-1] 或 .tail(1) 方法获取。
同时，也可以使用 .head([n]) 方法来获取 DataFrame 的前 n 行数据。如果不指定参数 n，则默认返回前 5 行数据。
14. DataFrame.xs(key[, axis, level, drop_level])
DataFrame.xs(key, axis=0, level=None, drop_level=True)
使用示例：
import pandas as pd
df = pd.DataFrame({
'a': [1, 2, 3, 4],
'b': [5, 6, 7, 8],
'c': [9, 10, 11, 12],
})
df.set_index(['a', 'b'], inplace=True) # 将 a, b 两列设置为索引列
print(df)
# 按照行查询
xs_1 = df.xs(key=2, level='a')
print(xs_1)
print("------------")
# 按照列查询
xs_2 = df.xs(key='c', axis=1)
print(xs_2)
输出结果：
c
a b
1 5 9
2 6 10
3 7 11
4 8 12
c
b
6 10
------------
a b
1 5 9
2 6 10
3 7 11
4 8 12
Name: c, dtype: int64
在此示例中，我们首先创建了一个不含索引列的 DataFrame，并通过 set_index() 方法将 a 和 b 两列设置为索引列。然后，我们分别使用 xs() 方法按照行和列进行查询。
在第一个示例中，我们使用了 level 参数来指定要查询的层级；
在第二个示例中，我们将 axis 参数设置为 1 来按照列进行查询。需要注意的是，按照列查询的结果会保留多层结构的索引。
15. DataFrame.get(key[, default])
DataFrame.get(key, default=None)
使用示例：
import pandas as pd
df = pd.DataFrame({
'a': [1, 2, 3, 4],
'b': [5, 6, 7, 8],
'c': [9, 10, 11, 12],
})
# 获取存在的列
col_1 = df.get('a')
print(col_1)
# 获取不存在的列
col_2 = df.get('d', pd.Series([0, 0, 0, 0]))
print(col_2)
输出结果：
0 1
1 2
2 3
3 4
Name: a, dtype: int64
0 0
1 0
2 0
3 0
dtype: int64
在此示例中，我们创建了一个 DataFrame，包含三列数据。然后，我们使用 get() 方法分别查询了存在和不存在的列。
对于存在的列，get() 方法会返回该列的 Series 对象；对于不存在的列，如果指定了 default 参数，则返回指定的默认值（在本例中为全为 0 的 Series 对象）；否则返回 None。需要注意的是，无论是读取存在的列还是不存在的列，都不会对原始 DataFrame 产生影响。
16. DataFrame.isin(values)
使用示例：
import pandas as pd
df = pd.DataFrame({
'a': [1, 2, 3, 4],
'b': ['foo', 'bar', 'foo', 'bar'],
'c': [0.5, 2.2, 3.6, 4.0]
})
# 检查一个列
mask_1 = df['b'].isin(['foo'])
print(mask_1)
# 检查多个列
mask_2 = df[['a', 'b']].isin([1, 'bar'])
print(mask_2)
输出结果：
0 True
1 False
2 True
3 False
Name: b, dtype: bool
a b
0 True False
1 False True
2 False False
3 False True
在此示例中，我们创建了一个包含三列数据的 DataFrame，然后使用 isin() 方法分别检查了单独一列和多个列中的值是否在指定的可迭代对象中。
对于单独一列，isin() 方法会返回一个布尔型 Series 对象，其中的值表示该位置上的元素是否在指定的可迭代对象中。
对于多个列，isin() 方法同样会返回一个布尔型 DataFrame 对象，其中的值表示该位置上的元素是否在指定的可迭代对象中。需要注意的是，在查询多个列时，isin() 方法会针对每个列分别进行查询，最终返回的结果是逐个列进行或运算的结果。
17. DataFrame.where(cond[, other, inplace, …])
DataFrame.where(cond, other=_NoDefault.no_default, *, inplace=False, axis=None, level=None)
使用示例：
import pandas as pd
df = pd.DataFrame({
'a': [1, 2, 3, 4],
'b': [6, 0, 4, 2],
'c': [0.5, 2.2, 3.6, 4.0]
})
# 替换单个列中的值
new_df_1 = df.where(df['a'] > 2, -df)
print(new_df_1)
print('----------')
# 替换整个 DataFrame 中的值
new_df_2 = df.where(df > 2, other='*')
print(new_df_2)
输出结果：
a b c
0 -1 -6 -0.5
1 -2 0 -2.2
2 3 4 3.6
3 4 2 4.0
----------
a b c
0 * 6 *
1 * * 2.2
2 3 4 3.6
3 4 * 4.0
在此示例中，我们创建了一个包含三列数据的 DataFrame，然后使用 where() 方法根据不同的条件进行了值的替换操作。
在第一个示例中，我们使用了 df[‘a’] > 2 作为判断条件，只对列 a 中大于 2 的元素进行替换，其他位置上的元素不变。由于未指定 other 参数，所以未满足条件的位置上的元素被替换成了 NaN。
在第二个示例中，我们对整个 DataFrame 进行判断，将小于等于 2 的元素替换成了 ‘*’。需要注意的是，这里的 other 参数是标量类型，表示要替换成的值。
18. DataFrame.mask(cond[, other, inplace, axis, …])
DataFrame.mask(cond, other=_NoDefault.no_default, *, inplace=False, axis=None, level=None)
使用示例：
import pandas as pd
df = pd.DataFrame({
'A': [0, 3, 5],
'B': [-2, 4, 6],
})
# 使用 mask() 方法
df_masked = df.mask(df < 4, other='small')
print(df_masked)
输出结果：
A B
0 small small
1 small 4
2 5 6
在此示例中，我们创建了一个包含两列数据的 DataFrame，然后使用 mask() 方法将所有小于 4 的元素替换为 ‘small’。需要注意的是，这里的 other 参数是标量类型，表示要替换成的值。
19. DataFrame.query(expr, *[, inplace])
DataFrame.query(expr, *, inplace=False, **kwargs)
使用示例：
import pandas as pd
df = pd.DataFrame({
'name': ['Alice', 'Bob', 'Charlie', 'David', 'Eva'],
'age': [25, 30, 35, 40, 45],
'gender': ['F', 'M', 'M', 'M', 'F'],
'score': [78, 92, 85, 87, 80]
})
# 使用 query() 方法筛选出满足条件的行
query_result = df.query('age > 30 and gender == "M" and score >= 85')
print(query_result)
输出结果：
name age gender score
2 Charlie 35 M 85
3 David 40 M 87
在以上示例中，我们使用 query() 方法根据特定的条件筛选出了满足要求的行。具体来说，我们通过 age > 30、gender == ‘M’ 和 score >= 85 的条件进行了过滤操作。需要注意的是，在 query() 方法中，字符串必须使用单引号或双引号进行包裹。
