4.12 Pandas中的DataFrame数据类型API函数参考手册(二) (Python)

ibun.song

已于 2023-10-08 17:04:00 修改

阅读量1.2k

点赞数 2

分类专栏： Python 文章标签： python pandas 数据分析

于 2023-06-19 14:44:32 首次发布

本文链接：https://blog.csdn.net/qq_40805441/article/details/131248592

版权

Python 专栏收录该内容

13 篇文章 1 订阅

订阅专栏

Pandas中的DataFrame数据类型API函数参考手册二

Pandas 是一个专门用于数据处理和分析的 Python 库，它提供了众多强大的数据结构和函数，帮助用户更加轻松、高效地完成数据处理和分析任务。其中，DataFrame 数据类型是 Pandas 中非常重要的一种数据结构，可以方便地对二维表格数据进行操作、处理、统计和可视化等工作。

Pandas 中 DataFrame 的一些特点和优势，比如：

可以灵活处理不同类型的数据，包括数字、文本、日期等等。
提供了许多强大的数据处理函数，比如过滤、排序、聚合等操作。
方便进行数据可视化和统计分析，例如可视化不同变量之间的关系、计算各种统计量等。
易于与其他 Python 库相集成使用，比如 NumPy、Matplotlib 等库。

一、构造函数(Constructor)

参考上篇文章：
4.11 Pandas中的DataFrame数据类型API函数参考手册(一) (Python)

二、属性和基础数据(Attributes and underlying data)

参考上篇文章：
4.11 Pandas中的DataFrame数据类型API函数参考手册(一) (Python)

三、转换(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')

DataFrame.astype() 是 Pandas 数据分析库中 DataFrame 对象用于数据类型转换的方法，它的主要作用是将 DataFrame 对象中的数据类型转换为给定的数据类型。
其中：

dtype：表示要转换的数据类型，可以是字符串、NumPy 数组类型或 Pandas 数据类型。
copy：如果为 True，则会返回一个新的 DataFrame 对象，否则直接修改原对象。默认为 None，表示根据转换后的数据类型自动选择是否返回新对象。
errors：表示对于无法进行类型转换的数据的处理方式。如果为 ‘raise’，则抛出一个异常；如果为 ‘ignore’，则不做任何处理，保持原有数据类型。默认为 ‘raise’。

需要注意的是，DataFrame.astype() 方法只能对 DataFrame 中的数值型和布尔型数据进行数据类型转换，不能对字符串类型进行转换。

使用示例：

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'
)

DataFrame.convert_dtypes() 是 Pandas 数据分析库中 DataFrame 对象用于数据类型自动推断和转换的方法，它的主要作用是通过一系列自动推断的规则来将 DataFrame 对象中的数据类型转换为最适合当前数据的数据类型。
其中各个参数的意义如下：

infer_objects：表示是否尝试将 DataFrame 对象中非数值类型的列转换为更适合的数据类型，默认为 True。
convert_string：表示是否尝试将 DataFrame 对象中值为字符串类型的列转换为更适合的数据类型，默认为 True。
convert_integer：表示是否尝试将 DataFrame 对象中值为整型的列转换为最小可能的整型数据类型，默认为 True。
convert_boolean：表示是否尝试将 DataFrame 对象中值为布尔型的列转换为 bool 数据类型，默认为 True。
convert_floating：表示是否尝试将 DataFrame 对象中值为浮点型的列转换为最小可能的浮点型数据类型，默认为 True。
dtype_backend：表示转换后存储数据的数据类型，可以是 ‘numpy’ 或 ‘numpy_nullable’，默认为 ‘numpy_nullable’。

需要注意的是，DataFrame.convert_dtypes() 方法只能对 DataFrame 中的数值型和布尔型数据进行自动数据类型转换，不能对字符串类型进行转换。

使用示例：

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)

将 DataFrame 对象中的数据类型转换为最适合当前数据的数据类型的方法。与 DataFrame.convert_dtypes() 不同，它只尝试将 DataFrame 中的对象数据类型转换为最适合的数据类型。如果一列数据无法被转换，其仍将保持为原始数据类型。
其中:

copy 参数表示是否拷贝数据。默认为 None。如果设置为 True, 那么一定会返回副本而不是引用。

需要注意的是，DataFrame.infer_objects() 适用于 DataFrame 对象中存在的 object 数据类型列，例如字符串、日期、元组等等。这个方法是一个比较昂贵的操作，建议在必要时再使用。

使用示例：

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)

DataFrame.copy() 方法是 Pandas 数据分析库中 DataFrame 对象用于创建 DataFrame 对象的副本的方法。
其中：

deep 参数，默认值为 True，表示是否执行深度复制。
如果 deep=True，则复制所有的 DataFrame 数据，包括数据和索引；如果 deep=False，则仅复制对象本身。

需要注意的是，如果使用浅复制，则在对原始 DataFrame 进行更改时，副本也会被更改。这可能会导致不必要的结果。

使用示例：

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()

DataFrame.bool() 方法是 Pandas 数据分析库中 DataFrame 对象用于将 DataFrame 对象转换为布尔型数据的方法。该方法返回 DataFrame 的逻辑值，其中 DataFrame 中的每个元素表示为 True 或 False。
这必须是布尔标量值，可以为True，也可以为False。如果Series或DataFrame没有恰好1个元素，或者该元素不是布尔值（整数值0和1也会引发异常），则它将引发ValueError。
需要注意的是，如果 DataFrame 中包含缺失值 NaN，则它们在转换后被视为 False。

使用示例：

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().

这个异常通常是由于在布尔运算过程中得到了一个 DataFrame 对象而导致的。在 Python 中，布尔运算结果只能是 True 或 False，但是 DataFrame 对象转换为布尔型数据时无法确定整个 DataFrame 是否为 True 或 False，因为它包含多个元素。因此，当 Pandas 遇到这种情况时，会抛出 ValueError: The truth value of a DataFrame is ambiguous 异常，提示无法确定 DataFrame 的布尔值。
如果您需要对 DataFrame 执行布尔运算，那么您可以在 DataFrame 对象上使用以下方法来将其转换为一个可用的布尔值：

使用 DataFrame.empty 方法检查 DataFrame 是否为空。
使用 DataFrame.bool() 方法将 DataFrame 转换为布尔值。
如果 DataFrame 包含单个元素，则可以使用 DataFrame.item() 方法获取该元素，并将其转换为布尔值（注意：只有当 DataFrame 仅包含一个元素时才可以使用此方法）。
使用 DataFrame.any() 方法检查 DataFrame 中是否存在任何 True 值。
使用 DataFrame.all() 方法检查 DataFrame 中的所有值是否都为 True。

使用示例：

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)

返回 DataFrame 的前几行数据，可以用于快速查看数据集的概况，以及数据是否符合预期。

参数：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

DataFrame.at 是 Pandas 库中用于获取或设置 DataFrame 中单个元素的函数。它可以使用行标签和列标签来定位要操作的元素。

使用示例：

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

DataFrame.iat 是 Pandas 库中用于获取或设置 DataFrame 中单个元素的函数。它和 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.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

DataFrame.loc 函数是 Pandas 库中用于基于标签定位和操作单个元素或多个元素的函数。它可以使用行标签和列标签来定位要操作的元素或切片，可以同时操作行和列。

使用示例：

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

DataFrame.iloc 函数是 Pandas 库中用于基于索引位置定位和操作单个元素或多个元素的函数。它可以使用整数索引或整数切片来定位要操作的元素或切片，只能操作行或列中的其中一项。

.iloc[]主要是基于整数位置（从0轴到 length-1轴），但也可以与布尔数组一起使用。
允许的输入是：

一个整数，例如5。
整数列表或数组，例如.[4, 3, 0]
带有整数的切片对象，例如1:7.
一个布尔数组。
具有一个callable参数（调用 Series 或 DataFrame）并返回用于索引的有效输出（上述之一）的函数。这在方法链中很有用，当您没有对调用对象的引用，但希望将您的选择基于某个值时。
行和列索引的元组。元组元素由上述输入之一组成，例如.(0, 1)

使用示例：

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。

.iloc 函数在使用时可能会引发 IndexError 异常，特别是当超出索引范围时。

使用示例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)

DataFrame.insert() 方法用于插入新的列到指定的位置，并可以指定列的名称、值以及是否允许重复添加同名列。
以下是该方法的详细参数说明：

loc：表示要插入新列的位置，可以是整数，也可以是字符串类型的列名。如果整数，则表示要插入到该位置之前。如果给定的位置大于 DataFrame 列数，将在最后添加新列。
column：表示新列的名称，必须是字符串类型。
value：表示新列的数据，可以是标量、数组或 Series 对象。如果传递标量，则将使用相同的值填充整个列。
allow_duplicates：表示是否允许添加重复列，默认情况下为 False，即不允许。如果设置为 True，则可以添加重复列。

使用示例：

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()

DataFrame.iter() 是在 Python 内部调用 DataFrame 对象时，返回迭代器对象的方法。它返回一个迭代器对象，该迭代器对象可以使用 for 循环轮询数据集中的每一列。
在使用 for 循环迭代 DataFrame 对象时，它将自动调用 DataFrame 类的 iter() 方法。这个方法会返回一个迭代器对象，提供了一个迭代接口来访问 DataFrame 中的元素。

使用示例：

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()

DataFrame.items() 方法返回一个包含每个列名称和列内容对的键值对列表。这些键值对以元组的形式返回，其中包括两个元素：第一个元素是列名，第二个元素是对应列的 Pandas Series 对象。

使用示例：

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()

DataFrame.keys() 是一个属性，用于返回 DataFrame 对象的列标签。该属性不对 DataFrame 对象进行修改，只是返回列标签的视图。

使用示例：

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()

DataFrame.iterrows() 是一个生成器，可以用于遍历 Pandas 数据帧中的每一行。在迭代过程中，每一行会作为一个元组返回，第一个元素是该行数据的索引，第二个元素是该行数据组成的 Pandas Series 对象。

使用示例：

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')

DataFrame.itertuples() 方法是一个生成器，它可以迭代 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)

DataFrame.pop(item) 方法用于删除并返回 Pandas DataFrame 中指定的列。该方法会从 DataFrame 中删除指定的列，并返回一个包含删除的列数据的 Pandas Series 对象。

使用示例：

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])

DataFrame.tail([n]) 方法用于返回 Pandas DataFrame 对象的最后 n 行数据。如果未指定参数 n，则默认返回最后 5 行数据。

使用示例：

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)

DataFrame.xs(key[, axis, level, drop_level]) 方法用于返回 Pandas DataFrame 对象的指定行或列。

key: 表示索引的值或者列名的值。
axis: 对应 0 表示按照行进行查询，对应 1 表示按照列进行查询。默认为 0。0
level: 如果 DataFrame 是一个层次化索引，则可以通过 level 参数指定要查询的级别（从 0 开始）。
drop_level: 当 key 包含多层结构时，可以通过 drop_level 参数来指定是否将多余的索引级别剔除。

使用示例：

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)

DataFrame.get(key[, default]) 方法用于根据给定的 key 返回 DataFrame 中对应的列。

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)

DataFrame.isin(values) 方法用于检查 DataFrame 中的每个元素是否在指定的可迭代对象 values 中。

values：要检查的值，可以是列表、元组、Series 或 DataFrame。

使用示例：

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)

DataFrame.where(cond, other=_NoDefault.no_default, *, inplace=False, axis=None, level=None) 方法用于根据条件 cond 在 DataFrame 中选择性地替换元素。

cond：一个布尔型 DataFrame，表示要替换的值。cond 的形状必须和 DataFrame 相同。
other：可选参数，用于表示要替换的值。可以是标量、Series、DataFrame 或可调用对象（callable）。如果未指定，则默认会将 DataFrame 中所有不满足条件的元素替换为 NaN。
inplace：可选参数，表示是否在原始 DataFrame 中进行替换操作。默认为 False。
axis：可选参数，表示要进行操作的轴。默认为 None，表示对整个 DataFrame 进行操作。
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)

DataFrame.mask(cond, other=_NoDefault.no_default, *, inplace=False, axis=None, level=None) 方法用于根据条件 cond 在 DataFrame 中选择性地替换元素。

cond：一个布尔型 DataFrame，表示要替换的值。cond 的形状必须和 DataFrame 相同。
other：可选参数，用于表示要替换的值。可以是标量、Series、DataFrame 或可调用对象（callable）。如果未指定，则默认会将 DataFrame 中所有满足条件的元素替换为 NaN。
inplace：可选参数，表示是否在原始 DataFrame 中进行替换操作。默认为 False。
axis：可选参数，表示要进行操作的轴。默认为 None，表示对整个 DataFrame 进行操作。
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)

DataFrame.query() 方法用于使用布尔型表达式筛选 DataFrame 中的行。具体来说，query() 方法接受一个字符串或一个可计算为字符串的表达式，该表达式将被应用于 DataFrame 的列，并返回一个包含满足条件的行的新 DataFrame。

query() 方法支持使用 @ 符号引用 Python 变量，以及使用 Pandas 对象方法和 NumPy 函数等进行计算。同时，query() 方法还支持 in 和 not in 关键字、比较操作符（如 <、>、<= 和 >= 等）、与和或等逻辑操作符，以及按位取反运算符（~）等操作。

以下是 DataFrame.query() 方法的详细参数说明：

expr：用于筛选行的表达式字符串。
inplace：可选参数，表示是否在原始 DataFrame 上进行操作。默认为 False，即返回一个新的 DataFrame。如果设为 True，则会在原始 DataFrame 上直接进行修改操作。
kwargs：额外的关键字参数，可以传递给 eval() 函数。

使用示例：

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() 方法中，字符串必须使用单引号或双引号进行包裹。

ibun.song

关注

2
点赞
踩
5

收藏

觉得还不错? 一键收藏
打赏
1
评论
4.12 Pandas中的DataFrame数据类型API函数参考手册(二) (Python)

Pandas 是一个专门用于数据处理和分析的 Python 库，它提供了众多强大的数据结构和函数，帮助用户更加轻松、高效地完成数据处理和分析任务。其中，DataFrame 数据类型是 Pandas 中非常重要的一种数据结构，可以方便地对二维表格数据进行操作、处理、统计和可视化等工作。可以灵活处理不同类型的数据，包括数字、文本、日期等等。提供了许多强大的数据处理函数，比如过滤、排序、聚合等操作。方便进行数据可视化和统计分析，例如可视化不同变量之间的关系、计算各种统计量等。
复制链接

扫一扫