melt()的详细语法与实际案例
将 DataFrame 从宽表重塑为长表格
melt() 是 Pandas 库中的一个函数，用于将 DataFrame 从宽格式转换为长格式。它主要用于数据的重塑，以便更好地进行数据分析和可视化。
语法
pandas.melt(frame, id_vars=None, value_vars=None, var_name=None,
value_name='value', col_level=None, ignore_index=True)
参数
- frame：要重塑的 DataFrame。
- id_vars：要保留的列，通常是标识变量（如主键）。
- value_vars：要转换的列，默认是除
id_vars以外的所有列。 - var_name：新的“变量”列的名称。
- value_name：新的“值”列的名称，默认是 'value'。
- col_level：如果列是 MultiIndex，这指定使用哪个级别。
- ignore_index：如果为 True，原始索引将被忽略。
返回值
返回一个重塑后的 DataFrame。
实例代码
import pandas as pd
# 创建一个 DataFrame
data = {
'ID': [1, 2, 3],
'Name': ['Alice', 'Bob', 'Charlie'],
'Math': [85, 78, 90],
'Science': [92, 88, 95],
'English': [88, 76, 93]
}
df = pd.DataFrame(data)
print("原始数据集：")
print(df)
# 使用 melt 方法重塑 DataFrame
melted_df = pd.melt(df, id_vars=['ID', 'Name'], value_vars=['Math', 'Science', 'English'], var_name='Subject', value_name='Score')
print("\n重塑后的数据集：")
print(melted_df)
输出结果
原始数据集：
ID Name Math Science English
0 1 Alice 85 92 88
1 2 Bob 78 88 76
2 3 Charlie 90 95 93
重塑后的数据集：
ID Name Subject Score
0 1 Alice Math 85
1 2 Bob Math 78
2 3 Charlie Math 90
3 1 Alice Science 92
4 2 Bob Science 88
5 3 Charlie Science 95
6 1 Alice English 88
7 2 Bob English 76
8 3 Charlie English 93
总结
使用与应用场景
- 数据重塑：将宽格式的数据转换为长格式，以便更好地进行数据分析和可视化。
- 数据整理：在数据预处理中，对数据进行重塑以符合分析或建模的要求。
- 数据可视化：在可视化前，将数据转换为长格式，以便更好地使用可视化工具。
melt() 方法在数据重塑和整理过程中非常有用，可以将宽格式的数据转换为长格式，使得数据更加规范和易于处理。通过指定标识变量和要转换的列，可以灵活地对 DataFrame 进行重塑。
memory_usage()的详细语法与实际案例
返回每列的内存使用情况
memory_usage() 是 Pandas 库中的 DataFrame 和 Series 对象的方法，用于返回每个列或每个索引级别的内存使用情况。该方法对于检查和优化数据集的内存占用非常有用。
语法
DataFrame.memory_usage(index=True, deep=False)
Series.memory_usage(index=True, deep=False)
参数
- index (bool, default True)：是否包含索引的内存使用情况。如果设为 True，包含索引的内存使用情况。
- deep (bool, default False)：是否深度计算对象数组的内存使用情况。如果设为 True，将计算对象数组中所有元素的内存使用情况。
返回值
返回一个 Series，表示每列或每个索引级别的内存使用情况（以字节为单位）。
实例代码
import pandas as pd
# 创建一个 DataFrame
data = {
'A': [1, 2, 3, 4],
'B': [5, 6, 7, 8],
'C': ['a', 'b', 'c', 'd']
}
df = pd.DataFrame(data)
print("原始数据集：")
print(df)
# 计算 DataFrame 的内存使用情况
memory_usage_df = df.memory_usage()
print("\nDataFrame 的内存使用情况：")
print(memory_usage_df)
# 计算 DataFrame 的内存使用情况（深度计算）
memory_usage_df_deep = df.memory_usage(deep=True)
print("\nDataFrame 的内存使用情况（深度计算）：")
print(memory_usage_df_deep)
# 创建一个 Series
series = pd.Series([1, 2, 3, 4])
print("\n原始 Series 数据：")
print(series)
# 计算 Series 的内存使用情况
memory_usage_series = series.memory_usage()
print("\nSeries 的内存使用情况：")
print(memory_usage_series)
其输出结果
原始数据集：
A B C
0 1 5 a
1 2 6 b
2 3 7 c
3 4 8 d
DataFrame 的内存使用情况：
Index 128
A 32
B 32
C 32
dtype: int64
DataFrame 的内存使用情况（深度计算）：
Index 128
A 32
B 32
C 224
dtype: int64
原始 Series 数据：
0 1
1 2
2 3
3 4
dtype: int64
Series 的内存使用情况：
152
总结
使用与应用场景
- 内存监控：用于监控和检查 DataFrame 或 Series 中各列的内存使用情况，帮助用户优化内存占用。
- 内存优化：在处理大数据集时，了解各列的内存使用情况，有助于进行内存优化，如类型转换、数据分块等。
- 深度计算：对于包含对象类型（如字符串）的列，可以使用深度计算选项来获取更精确的内存使用情况。
memory_usage() 方法在数据处理和分析过程中非常有用，尤其是在处理大数据集时，可以帮助用户监控和优化内存使用情况。通过指定是否包含索引和是否进行深度计算，可以灵活地获取所需的内存使用信息。
merge()的详细语法与实际案例
合并DataFrame对象
merge() 是 Pandas 库中的一个函数，用于将两个 DataFrame 合并（类似于 SQL 中的 JOIN 操作）。它可以根据指定的键或索引将 DataFrame 合并在一起。
语法
pandas.merge(left, right, how='inner', on=None, left_on=None,
right_on=None, left_index=False, right_index=False,
sort=False, suffixes=('_x', '_y'), copy=True,
indicator=False, validate=None)
参数
- left：左侧 DataFrame。
- right：右侧 DataFrame。
- how：指定连接方式，默认是 'inner'。选项包括 'left'、'right'、'outer'、'inner'。
- on：用于连接的列或索引级别名称。必须存在于左右两个 DataFrame 中。
- left_on：左侧 DataFrame 中用于连接的列或索引级别名称。
- right_on：右侧 DataFrame 中用于连接的列或索引级别名称。
- left_index：使用左侧 DataFrame 的行索引进行连接，默认是 False。
- right_index：使用右侧 DataFrame 的行索引进行连接，默认是 False。
- sort：按照连接键对结果 DataFrame 进行排序，默认是 False。
- suffixes：后缀字符串的元组，默认为 ('_x', '_y')，用于区分左右 DataFrame 中重叠列。
- copy：如果为 False，则避免在结果中复制数据，默认是 True。
- indicator：在结果 DataFrame 中添加合并指示器列，显示每一行数据的来源。
- validate：检查是否存在特定的合并类型关系。
返回值
返回一个合并后的 DataFrame。
实例代码
import pandas as pd
# 创建两个 DataFrame
left = pd.DataFrame({
'ID': [1, 2, 3, 4],
'Name': ['Alice', 'Bob', 'Charlie', 'David'],
'Age': [25, 30, 35, 40]
})
right = pd.DataFrame({
'ID': [3, 4, 5, 6],
'City': ['New York', 'Los Angeles', 'Chicago', 'Houston'],
'Salary': [70000, 80000, 90000, 100000]
})
print("左侧数据集：")
print(left)
print("\n右侧数据集：")
print(right)
# 使用 merge 方法进行内连接
merged_inner = pd.merge(left, right, on='ID', how='inner')
print("\n内连接（inner join）结果：")
print(merged_inner)
# 使用 merge 方法进行左连接
merged_left = pd.merge(left, right, on='ID', how='left')
print("\n左连接（left join）结果：")
print(merged_left)
# 使用 merge 方法进行右连接
merged_right = pd.merge(left, right, on='ID', how='right')
print("\n右连接（right join）结果：")
print(merged_right)
# 使用 merge 方法进行外连接
merged_outer = pd.merge(left, right, on='ID', how='outer')
print("\n外连接（outer join）结果：")
print(merged_outer)
输出结果
左侧数据集：
ID Name Age
0 1 Alice 25
1 2 Bob 30
2 3 Charlie 35
3 4 David 40
右侧数据集：
ID City Salary
0 3 New York 70000
1 4 Los Angeles 80000
2 5 Chicago 90000
3 6 Houston 100000
内连接（inner join）结果：
ID Name Age City Salary
0 3 Charlie 35 New York 70000
1 4 David 40 Los Angeles 80000
左连接（left join）结果：
ID Name Age City Salary
0 1 Alice 25 NaN NaN
1 2 Bob 30 NaN NaN
2 3 Charlie 35 New York 70000.0
3 4 David 40 Los Angeles 80000.0
右连接（right join）结果：
ID Name Age City Salary
0 3 Charlie 35.0 New York 70000.0
1 4 David 40.0 Los Angeles 80000.0
2 5 NaN NaN Chicago 90000.0
3 6 NaN NaN Houston 100000.0
外连接（outer join）结果：
ID Name Age City Salary
0 1 Alice 25.0 NaN NaN
1 2 Bob 30.0 NaN NaN
2 3 Charlie 35.0 New York 70000.0
3 4 David 40.0 Los Angeles 80000.0
4 5 NaN NaN Chicago 90000.0
5 6 NaN NaN Houston 100000.0
总结
使用与应用场景
- 内连接（inner join）：返回两个 DataFrame 中键匹配的行。常用于获取两个表格中共有的数据。
- 左连接（left join）：返回左侧 DataFrame 中的所有行，以及右侧 DataFrame 中键匹配的行。常用于保留左表中的所有数据，并添加右表中的相关数据。
- 右连接（right join）：返回右侧 DataFrame 中的所有行，以及左侧 DataFrame 中键匹配的行。常用于保留右表中的所有数据，并添加左表中的相关数据。
- 外连接（outer join）：返回所有键匹配的行，并包含两个 DataFrame 中的所有行。如果某一行在某个 DataFrame 中不存在，则用 NaN 填充。常用于获取所有可能的组合。
merge() 方法在数据处理和分析过程中非常有用，特别是在需要将多个数据源结合起来进行综合分析时。通过指定连接键和连接方式，可以灵活地对 DataFrame 进行合并。
min()的详细语法与实际案例
返回指定轴中值的最小值
min() 是 Pandas 库中的 DataFrame 和 Series 对象的方法，用于计算数据中的最小值。该方法可以按列或按行计算，并且可以选择忽略 NaN 值。
语法
DataFrame.min(axis=0, skipna=True, level=None, numeric_only=None, **kwargs)
Series.min(axis=None, skipna=True, level=None, numeric_only=None, **kwargs)
参数
- axis (int, default 0)：指定沿哪个轴计算最小值。0 或 'index' 表示按列计算，1 或 'columns' 表示按行计算。
- skipna (bool, default True)：是否忽略 NaN 值。如果设为 True，则忽略 NaN 值。
- level (int or level name, default None)：如果轴是 MultiIndex，则按级别计算。
- numeric_only (bool, default None)：如果为 True，则只包含数字数据类型。如果为 None，将尝试包括所有数据类型。
- kwargs：其他关键词参数。
返回值
返回一个标量值或包含最小值的 Series 或 DataFrame。
实例代码
import pandas as pd
import numpy as np
# 创建一个 DataFrame
data = {
'A': [1, 2, 3, 4],
'B': [5, 6, 7, 8],
'C': [9, np.nan, 11, 12]
}
df = pd.DataFrame(data)
print("原始数据集：")
print(df)
# 计算每列的最小值
min_per_column = df.min()
print("\n每列的最小值：")
print(min_per_column)
# 计算每行的最小值
min_per_row = df.min(axis=1)
print("\n每行的最小值：")
print(min_per_row)
# 创建一个 Series
series = pd.Series([1, 2, 3, 4, np.nan, 6, 7, 8, 9])
print("\n原始 Series 数据：")
print(series)
# 计算 Series 的最小值
series_min = series.min()
print("\nSeries 的最小值：")
print(series_min)
输出结果
原始数据集：
A B C
0 1.0 5.0 9.0
1 2.0 6.0 NaN
2 3.0 7.0 11.0
3 4.0 8.0 12.0
每列的最小值：
A 1.0
B 5.0
C 9.0
dtype: float64
每行的最小值：
0 1.0
1 2.0
2 3.0
3 4.0
dtype: float64
原始 Series 数据：
0 1.0
1 2.0
2 3.0
3 4.0
4 NaN
5 6.0
6 7.0
7 8.0
8 9.0
dtype: float64
Series 的最小值：
1.0
总结
使用与应用场景
- 数据分析：计算数据集中每列或每行的最小值，以便理解数据的分布和极值。
- 缺失值处理：可以选择忽略 NaN 值，在数据中存在缺失值时计算最小值。
- 数据预处理：在数据分析和建模之前，对数据进行基本统计分析，获取最小值等指标。
min() 方法在数据分析和处理过程中非常有用，可以方便地计算数据的最小值，帮助理解数据的整体分布情况和极值。通过指定轴和是否忽略 NaN 值等参数，可以灵活地应用于各种数据集。
mod()的详细语法与实际案例
模块（查找剩余部分）DataFrame的值
mod() 是 Pandas 库中的 DataFrame 和 Series 对象的方法，用于执行元素级的取模操作。该方法返回一个与输入对象形状相同的对象，其中包含元素级的取模运算结果。
语法
DataFrame.mod(other, axis='columns', level=None, fill_value=None)
Series.mod(other, level=None, fill_value=None, axis=0)
参数
- other (scalar, sequence, Series, or DataFrame)：用于计算模的值。
- axis (默认 'columns')：用于对齐的轴。对于 DataFrame，这可以是 0 或 'index' 或 1 或 'columns'。
- level (默认 None)：如果轴是 MultiIndex，则沿指定级别进行广播。
- fill_value (默认 None)：在算术运算期间用于替换对齐的两个对象中的任何缺失值的值。
返回值
返回一个与输入对象形状相同的对象，包含取模运算结果。
实例代码
import pandas as pd
import numpy as np
# 创建一个 DataFrame
data = {
'A': [10, 20, 30, 40],
'B': [15, 25, 35, 45],
'C': [25, np.nan, 45, 55]
}
df = pd.DataFrame(data)
print("原始数据集：")
print(df)
# 对 DataFrame 的每个元素取模 7
mod_df = df.mod(7)
print("\n对 DataFrame 的每个元素取模 7 的结果：")
print(mod_df)
# 创建一个 Series
series = pd.Series([10, 20, 30, 40, np.nan, 50, 60, 70, 80])
print("\n原始 Series 数据：")
print(series)
# 对 Series 的每个元素取模 6
mod_series = series.mod(6)
print("\n对 Series 的每个元素取模 6 的结果：")
print(mod_series)
输出结果
原始数据集：
A B C
0 10.0 15.0 25.0
1 20.0 25.0 NaN
2 30.0 35.0 45.0
3 40.0 45.0 55.0
对 DataFrame 的每个元素取模 7 的结果：
A B C
0 3.0 1.0 4.0
1 6.0 4.0 NaN
2 2.0 0.0 3.0
3 5.0 3.0 6.0
原始 Series 数据：
0 10.0
1 20.0
2 30.0
3 40.0
4 NaN
5 50.0
6 60.0
7 70.0
8 80.0
dtype: float64
对 Series 的每个元素取模 6 的结果：
0 4.0
1 2.0
2 0.0
3 4.0
4 NaN
5 2.0
6 0.0
7 4.0
8 2.0
dtype: float64
总结
使用与应用场景
- 元素级操作：对 DataFrame 或 Series 的每个元素执行取模操作。
- 数据处理：在数据处理中，可以使用取模操作来对数据进行特定的转换或归一化处理。
- 缺失值处理：通过
fill_value参数，可以在操作过程中处理缺失值。
mod() 方法在数据处理和分析过程中非常有用，可以对数据进行逐元素的取模运算，帮助实现数据的特定转换和归一化。通过指定轴和处理缺失值的方式，可以灵活地应用于各种数据集。
mode()的详细语法与实际案例
mode() 是 Pandas 库中的 DataFrame 和 Series 对象的方法，用于计算数据的众数（即出现频率最高的值）。该方法可以按列或按行计算众数。
语法
DataFrame.mode(axis=0, numeric_only=False, dropna=True)
Series.mode(dropna=True)
参数
- axis (int, default 0)：指定沿哪个轴计算众数。0 或 'index' 表示按列计算，1 或 'columns' 表示按行计算。
- numeric_only (bool, default False)：如果为 True，则只包含数字数据类型。
- dropna (bool, default True)：是否忽略 NaN 值。如果设为 False，NaN 将包含在计算中。
返回值
返回一个 DataFrame 或 Series，其中包含每列或每行的众数。如果有多个众数，则返回多个值。
实例代码
import pandas as pd
import numpy as np
# 创建一个 DataFrame
data = {
'A': [1, 2, 2, 3, 3, 3, 4, 4, 4, 4],
'B': [5, 6, 7, 7, 8, 9, 9, 9, 9, 9],
'C': [np.nan, np.nan, 11, 11, 12, 12, 12, 12, 12, 12]
}
df = pd.DataFrame(data)
print("原始数据集：")
print(df)
# 计算每列的众数
mode_per_column = df.mode()
print("\n每列的众数：")
print(mode_per_column)
# 计算每行的众数
mode_per_row = df.mode(axis=1)
print("\n每行的众数：")
print(mode_per_row)
# 创建一个 Series
series = pd.Series([1, 2, 2, 3, 3, 3, 4, 4, 4, 4])
print("\n原始 Series 数据：")
print(series)
# 计算 Series 的众数
series_mode = series.mode()
print("\nSeries 的众数：")
print(series_mode)
输出结果
原始数据集：
A B C
0 1.0 5.0 NaN
1 2.0 6.0 NaN
2 2.0 7.0 11.0
3 3.0 7.0 11.0
4 3.0 8.0 12.0
5 3.0 9.0 12.0
6 4.0 9.0 12.0
7 4.0 9.0 12.0
8 4.0 9.0 12.0
9 4.0 9.0 12.0
每列的众数：
A B C
0 4.0 9.0 12.0
每行的众数：
0 1 2
0 1.0 5.0 NaN
1 2.0 6.0 NaN
2 2.0 7.0 11.0
3 3.0 7.0 11.0
4 3.0 8.0 12.0
5 3.0 9.0 12.0
6 4.0 9.0 12.0
7 4.0 9.0 12.0
8 4.0 9.0 12.0
9 4.0 9.0 12.0
原始 Series 数据：
0 1
1 2
2 2
3 3
4 3
5 3
6 4
7 4
8 4
9 4
dtype: int64
Series 的众数：
0 4
dtype: int64
总结
使用与应用场景
- 数据分析：计算数据集中每列或每行的众数，以便理解数据的集中趋势。
- 缺失值处理：可以选择忽略 NaN 值，在数据中存在缺失值时计算众数。
- 数据预处理：在数据分析和建模之前，对数据进行基本统计分析，获取众数等指标。
mode() 方法在数据分析和处理过程中非常有用，可以方便地计算数据的众数，帮助理解数据的整体趋势和集中情况。通过指定轴和是否忽略 NaN 值等参数，可以灵活地应用于各种数据集。
mul()的详细语法与实际案例
mul() 是 Pandas 库中的 DataFrame 和 Series 对象的方法，用于计算两个对象的逐元素乘法。它可以用于 DataFrame 和 Series 之间的元素级乘法操作。
语法
DataFrame.mul(other, axis='columns', level=None, fill_value=None)
Series.mul(other, level=None, fill_value=None, axis=0)
参数
- other：要与 DataFrame 或 Series 相乘的对象，可以是标量值、Series、DataFrame。
- axis (default 'columns')：用于对齐的轴，默认为列。如果是 Series，则默认为索引。
- level：如果轴是 MultiIndex，则沿指定级别进行操作。
- fill_value：在计算之前使用给定值填充缺失值。
返回值
返回一个 DataFrame 或 Series，包含两个对象逐元素相乘的结果。
实际案例
import pandas as pd
# 创建一个 DataFrame
data = {
'A': [1, 2, 3],
'B': [4, 5, 6],
'C': [7, 8, 9]
}
df = pd.DataFrame(data)
print("原始数据集：")
print(df)
# 示例 1：DataFrame 与标量值相乘
print("\nDataFrame 与标量值 2 相乘：")
result_scalar = df.mul(2)
print(result_scalar)
# 创建一个 Series
series = pd.Series([1, 2, 3], index=['A', 'B', 'C'])
print("\n原始 Series：")
print(series)
# 示例 2：DataFrame 与 Series 相乘
print("\nDataFrame 与 Series 相乘：")
result_series = df.mul(series, axis=1)
print(result_series)
# 创建另一个 DataFrame
data2 = {
'A': [2, 3, 4],
'B': [5, 6, 7],
'C': [8, 9, 10]
}
df2 = pd.DataFrame(data2)
print("\n另一个数据集：")
print(df2)
# 示例 3：DataFrame 之间逐元素相乘
print("\n两个 DataFrame 逐元素相乘：")
result_dataframe = df.mul(df2)
print(result_dataframe)
输出结果
原始数据集：
A B C
0 1 4 7
1 2 5 8
2 3 6 9
DataFrame 与标量值 2 相乘：
A B C
0 2 8 14
1 4 10 16
2 6 12 18
原始 Series：
A 1
B 2
C 3
dtype: int64
DataFrame 与 Series 相乘：
A B C
0 1 8 21
1 2 10 24
2 3 12 27
另一个数据集：
A B C
0 2 5 8
1 3 6 9
2 4 7 10
两个 DataFrame 逐元素相乘：
A B C
0 2 20 56
1 6 30 72
2 12 42 90
总结
使用与应用场景
- 标量乘法：将 DataFrame 或 Series 中的每个元素与一个标量值相乘，返回相同形状的对象。
- 逐元素乘法：将两个相同形状的 DataFrame 或 Series 逐元素相乘，返回相同形状的对象。
- 数据计算：
mul()方法用于各种数据计算和变换，适用于金融、科学计算和数据分析等领域。
mul() 方法在数据分析和科学计算中非常有用，可以方便地进行元素级的乘法操作，有助于进行数据的变换和计算。
ndim的详细语法与实际案例
ndim 是 Pandas 库中 DataFrame 和 Series 对象的属性，用于返回数组的维数。
语法
DataFrame.ndim
Series.ndim
参数
ndim 是一个属性，因此不需要任何参数。
返回值
返回一个整数，表示数组的维数。
实例代码
import pandas as pd
import numpy as np
# 创建一个 DataFrame
data = {
'A': [1, 2, 3, 4],
'B': [5, 6, 7, 8],
'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data)
print("原始数据集 (DataFrame)：")
print(df)
# 获取 DataFrame 的维数
df_ndim = df.ndim
print("\nDataFrame 的维数：")
print(df_ndim)
# 创建一个 Series
series = pd.Series([1, 2, 3, 4])
print("\n原始 Series 数据：")
print(series)
# 获取 Series 的维数
series_ndim = series.ndim
print("\nSeries 的维数：")
print(series_ndim)
输出结果
原始数据集 (DataFrame)：
A B C
0 1 5 9
1 2 6 10
2 3 7 11
3 4 8 12
DataFrame 的维数：
2
原始 Series 数据：
0 1
1 2
2 3
3 4
dtype: int64
Series 的维数：
1
ndim的详细语法与实际案例
ndim 是 Pandas 库中 DataFrame 和 Series 对象的属性，用于返回数组的维数。对于 Series 对象，维数始终为 1；对于 DataFrame 对象，维数始终为 2。
语法
DataFrame.ndim
Series.ndim
参数
ndim 是一个属性，因此不需要任何参数。
返回值
返回一个整数，表示数组的维数。
实例代码
import pandas as pd
import numpy as np
# 创建一个 DataFrame
data = {
'A': [1, 2, 3, 4],
'B': [5, 6, 7, 8],
'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data)
print("原始数据集 (DataFrame)：")
print(df)
# 获取 DataFrame 的维数
df_ndim = df.ndim
print("\nDataFrame 的维数：")
print(df_ndim)
# 创建一个 Series
series = pd.Series([1, 2, 3, 4])
print("\n原始 Series 数据：")
print(series)
# 获取 Series 的维数
series_ndim = series.ndim
print("\nSeries 的维数：")
print(series_ndim)
输出结果
原始数据集 (DataFrame)：
A B C
0 1 5 9
1 2 6 10
2 3 7 11
3 4 8 12
DataFrame 的维数：
2
原始 Series 数据：
0 1
1 2
2 3
3 4
dtype: int64
Series 的维数：
1
总结
使用与应用场景
- 检查数据结构：使用
ndim属性可以快速检查 Pandas 对象的维数，帮助理解数据结构。 - 数据验证：在数据处理和分析过程中，可以使用
ndim属性验证数据的维度是否符合预期。
ndim 属性在数据分析和处理过程中非常有用，可以方便地检查 Pandas 对象的维数，帮助理解和验证数据结构。对于 DataFrame 对象，维数始终为 2；对于 Series 对象，维数始终为 1。
ne()的详细语法与实际案例
对于不等于指定值的值，返回 True，否则返回 False
ne() 是 Pandas 库中的 DataFrame 和 Series 对象的方法，用于执行元素级的“不等于”操作。该方法返回一个与输入对象形状相同的布尔值 DataFrame 或 Series，其中包含“不等于”运算的结果。
语法
DataFrame.ne(other, axis='columns', level=None)
Series.ne(other, level=None, axis=0)
参数
- other (scalar, sequence, Series, or DataFrame)：与每个元素比较的值。
- axis (默认 'columns')：用于对齐的轴。对于 DataFrame，这可以是 0 或 'index' 或 1 或 'columns'。
- level (默认 None)：如果轴是 MultiIndex，则沿指定级别进行广播。
返回值
返回一个与输入对象形状相同的布尔值对象，表示每个元素是否与 other 不相等。
实例代码
import pandas as pd
import numpy as np
# 创建一个 DataFrame
data = {
'A': [1, 2, 3, 4],
'B': [5, 6, 7, 8],
'C': [9, 10, 11, 12]
}
df = pd.DataFrame(data)
print("原始数据集：")
print(df)
# 对 DataFrame 的每个元素进行不等于 5 的比较
ne_df = df.ne(5)
print("\nDataFrame 的每个元素是否不等于 5 的结果：")
print(ne_df)
# 创建一个 Series
series = pd.Series([1, 2, 3, 4, 5])
print("\n原始 Series 数据：")
print(series)
# 对 Series 的每个元素进行不等于 3 的比较
ne_series = series.ne(3)
print("\nSeries 的每个元素是否不等于 3 的结果：")
print(ne_series)
# DataFrame 与另一个 DataFrame 的不等比较
other_df = pd.DataFrame({
'A': [1, 0, 3, 4],
'B': [5, 6, 0, 8],
'C': [9, 10, 11, 0]
})
ne_df_with_df = df.ne(other_df)
print("\nDataFrame 与另一个 DataFrame 的不等比较结果：")
print(ne_df_with_df)
输出结果
原始数据集：
A B C
0 1 5 9
1 2 6 10
2 3 7 11
3 4 8 12
DataFrame 的每个元素是否不等于 5 的结果：
A B C
0 True False True
1 True True True
2 True True True
3 True True True
原始 Series 数据：
0 1
1 2
2 3
3 4
4 5
dtype: int64
Series 的每个元素是否不等于 3 的结果：
0 True
1 True
2 False
3 True
4 True
dtype: bool
DataFrame 与另一个 DataFrame 的不等比较结果：
A B C
0 False False False
1 True False False
2 False True False
3 False False True
总结
使用与应用场景
- 元素级比较：对 DataFrame 或 Series 的每个元素执行“不等于”操作。
- 数据处理和分析：在数据处理中，可以使用不等于操作来过滤或筛选数据。
- 数据验证：在数据分析过程中，可以使用不等于操作来比较两个数据集，找出不同的元素。
ne() 方法在数据处理和分析过程中非常有用，可以对数据进行逐元素的“不等于”运算，帮助实现数据过滤、筛选和验证。通过指定比较的对象，可以灵活地应用于各种数据集。
notna()的详细语法与实际案例
查找非数字的值
notna() 是 Pandas 库中的 DataFrame 和 Series 对象的方法，用于检测缺失值。与 isna() 相反，notna() 返回布尔值对象，表示每个元素是否不是缺失值（即不是 NaN）。
语法
DataFrame.notna()
Series.notna()
参数
notna() 是一个方法，因此没有参数。
返回值
返回一个与输入对象形状相同的布尔值对象，表示每个元素是否不是缺失值。
实例代码
import pandas as pd
import numpy as np
# 创建一个 DataFrame
data = {
'A': [1, 2, np.nan, 4, 5],
'B': [np.nan, 2, 3, 4, np.nan],
'C': [1, 2, 3, 4, 5]
}
df = pd.DataFrame(data)
print("原始数据集：")
print(df)
# 检测 DataFrame 中的非缺失值
notna_df = df.notna()
print("\nDataFrame 中的非缺失值检测结果：")
print(notna_df)
# 创建一个 Series
series = pd.Series([1, 2, np.nan, 4, np.nan])
print("\n原始 Series 数据：")
print(series)
# 检测 Series 中的非缺失值
notna_series = series.notna()
print("\nSeries 中的非缺失值检测结果：")
print(notna_series)
输出结果
原始数据集：
A B C
0 1.0 NaN 1
1 2.0 2.0 2
2 NaN 3.0 3
3 4.0 4.0 4
4 5.0 NaN 5
DataFrame 中的非缺失值检测结果：
A B C
0 True False True
1 True True True
2 False True True
3 True True True
4 True False True
原始 Series 数据：
0 1.0
1 2.0
2 NaN
3 4.0
4 NaN
dtype: float64
Series 中的非缺失值检测结果：
0 True
1 True
2 False
3 True
4 False
dtype: bool
总结
使用与应用场景
- 数据清洗：检测数据集中哪些元素不是缺失值，可以用来过滤或处理非缺失值数据。
- 缺失值处理：结合其他方法（如
dropna()、fillna()等）来处理缺失值。 - 数据验证：在数据分析过程中验证数据的完整性，确保重要列或行没有缺失值。
notna() 方法在数据处理和分析过程中非常有用，可以检测 DataFrame 和 Series 对象中的非缺失值，帮助实现数据的清洗和处理。通过简单的布尔值输出，可以方便地进行进一步的数据操作和分析。
notnull()的详细语法与实际案例
查找不为 NULL 的值。
notnull() 是 Pandas 库中的 DataFrame 和 Series 对象的方法，用于检测缺失值。notnull() 和 notna() 是等价的，返回布尔值对象，表示每个元素是否不是缺失值（即不是 NaN）。
语法
DataFrame.notnull()
Series.notnull()
参数
notnull() 是一个方法，因此没有参数。
返回值
返回一个与输入对象形状相同的布尔值对象，表示每个元素是否不是缺失值。
实例代码
import pandas as pd
import numpy as np
# 创建一个 DataFrame
data = {
'A': [1, 2, np.nan, 4, 5],
'B': [np.nan, 2, 3, 4, np.nan],
'C': [1, 2, 3, 4, 5]
}
df = pd.DataFrame(data)
print("原始数据集：")
print(df)
# 检测 DataFrame 中的非缺失值
notnull_df = df.notnull()
print("\nDataFrame 中的非缺失值检测结果：")
print(notnull_df)
# 创建一个 Series
series = pd.Series([1, 2, np.nan, 4, np.nan])
print("\n原始 Series 数据：")
print(series)
# 检测 Series 中的非缺失值
notnull_series = series.notnull()
print("\nSeries 中的非缺失值检测结果：")
print(notnull_series)
输出结果
原始数据集：
A B C
0 1.0 NaN 1
1 2.0 2.0 2
2 NaN 3.0 3
3 4.0 4.0 4
4 5.0 NaN 5
DataFrame 中的非缺失值检测结果：
A B C
0 True False True
1 True True True
2 False True True
3 True True True
4 True False True
原始 Series 数据：
0 1.0
1 2.0
2 NaN
3 4.0
4 NaN
dtype: float64
Series 中的非缺失值检测结果：
0 True
1 True
2 False
3 True
4 False
dtype: bool
总结
使用与应用场景
- 数据清洗：检测数据集中哪些元素不是缺失值，可以用来过滤或处理非缺失值数据。
- 缺失值处理：结合其他方法（如
dropna()、fillna()等）来处理缺失值。 - 数据验证：在数据分析过程中验证数据的完整性，确保重要列或行没有缺失值。
notnull() 方法在数据处理和分析过程中非常有用，可以检测 DataFrame 和 Series 对象中的非缺失值，帮助实现数据的清洗和处理。通过简单的布尔值输出，可以方便地进行进一步的数据操作和分析。
nsmallest()的详细语法与实际案例
按指定的列对 DataFrame 进行升序排序，并返回指定的行数。
nsmallest() 是 Pandas 库中的 DataFrame 和 Series 对象的方法，用于返回按值排序的前 n 个最小元素。
语法
DataFrame.nsmallest(n, columns, keep='first')
Series.nsmallest(n, keep='first')
参数
- n (int)：要返回的最小元素的数量。
- columns (str or list of str)：用于排序的列名称，适用于 DataFrame。
- keep (str, default 'first')：当出现重复值时，指定如何处理。'first' 表示优先返回先出现的，'last' 表示优先返回最后出现的，'all' 表示返回所有。
返回值
返回一个 DataFrame 或 Series，其中包含按值排序的前 n 个最小元素。
实例代码
import pandas as pd
# 创建一个 DataFrame
data = {
'A': [1, 2, 3, 4, 5],
'B': [5, 4, 3, 2, 1],
'C': [10, 20, 30, 40, 50]
}
df = pd.DataFrame(data)
print("原始数据集：")
print(df)
# 获取列 'A' 中的前 3 个最小值
nsmallest_A = df['A'].nsmallest(3)
print("\n列 'A' 中的前 3 个最小值：")
print(nsmallest_A)
# 获取 DataFrame 中，按列 'B' 排序的前 3 行
nsmallest_B = df.nsmallest(3, 'B')
print("\n按列 'B' 排序的前 3 行：")
print(nsmallest_B)
# 获取 DataFrame 中，按列 'C' 排序的前 2 行，保留所有出现的最小值
nsmallest_C_all = df.nsmallest(2, 'C', keep='all')
print("\n按列 'C' 排序的前 2 行，保留所有出现的最小值：")
print(nsmallest_C_all)
# 创建一个 Series
series = pd.Series([10, 20, 20, 30, 30, 30, 40, 50])
print("\n原始 Series 数据：")
print(series)
# 获取 Series 中的前 4 个最小值
nsmallest_series = series.nsmallest(4)
print("\nSeries 中的前 4 个最小值：")
print(nsmallest_series)
输出结果
原始数据集：
A B C
0 1 5 10
1 2 4 20
2 3 3 30
3 4 2 40
4 5 1 50
列 'A' 中的前 3 个最小值：
0 1
1 2
2 3
Name: A, dtype: int64
按列 'B' 排序的前 3 行：
A B C
4 5 1 50
3 4 2 40
2 3 3 30
按列 'C' 排序的前 2 行，保留所有出现的最小值：
A B C
0 1 5 10
1 2 4 20
原始 Series 数据：
0 10
1 20
2 20
3 30
4 30
5 30
6 40
7 50
dtype: int64
Series 中的前 4 个最小值：
0 10
1 20
2 20
3 30
dtype: int64
总结
使用与应用场景
- 数据排序：返回按值排序的前 n 个最小元素，方便进行数据分析和展示。
- 数据筛选：在大型数据集中快速筛选出最小的元素或行，适用于快速获取重要数据。
- 处理重复值：通过参数
keep，可以灵活处理出现重复值的情况，选择保留先出现的、最后出现的或所有重复值。
nsmallest() 方法在数据分析和处理过程中非常有用，可以方便地获取数据集中按值排序的前 n 个最小元素或行。通过指定列名称和保留策略，可以灵活地应用于各种数据集。
nlargest()的详细语法与实际案例
按指定的列、降序对DataFrame进行排序，并返回指定的行数
nlargest() 是 Pandas 库中的 DataFrame 和 Series 对象的方法，用于返回按值排序的前 n 个最大的元素。
语法
DataFrame.nlargest(n, columns, keep='first')
Series.nlargest(n, keep='first')
参数
- n (int)：要返回的最大元素的数量。
- columns (str or list of str)：用于排序的列名称，适用于 DataFrame。
- keep (str, default 'first')：当出现重复值时，指定如何处理。'first' 表示优先返回先出现的，'last' 表示优先返回最后出现的，'all' 表示返回所有。
返回值
返回一个 DataFrame 或 Series，其中包含按值排序的前 n 个最大的元素。
实例代码
import pandas as pd
# 创建一个 DataFrame
data = {
'A': [1, 2, 3, 4, 5],
'B': [5, 4, 3, 2, 1],
'C': [10, 20, 30, 40, 50]
}
df = pd.DataFrame(data)
print("原始数据集：")
print(df)
# 获取列 'A' 中的前 3 个最大值
nlargest_A = df['A'].nlargest(3)
print("\n列 'A' 中的前 3 个最大值：")
print(nlargest_A)
# 获取 DataFrame 中，按列 'B' 排序的前 3 行
nlargest_B = df.nlargest(3, 'B')
print("\n按列 'B' 排序的前 3 行：")
print(nlargest_B)
# 获取 DataFrame 中，按列 'C' 排序的前 2 行，保留所有出现的最大值
nlargest_C_all = df.nlargest(2, 'C', keep='all')
print("\n按列 'C' 排序的前 2 行，保留所有出现的最大值：")
print(nlargest_C_all)
# 创建一个 Series
series = pd.Series([10, 20, 20, 30, 30, 30, 40, 50])
print("\n原始 Series 数据：")
print(series)
# 获取 Series 中的前 4 个最大值
nlargest_series = series.nlargest(4)
print("\nSeries 中的前 4 个最大值：")
print(nlargest_series)
输出结果
原始数据集：
A B C
0 1 5 10
1 2 4 20
2 3 3 30
3 4 2 40
4 5 1 50
列 'A' 中的前 3 个最大值：
4 5
3 4
2 3
Name: A, dtype: int64
按列 'B' 排序的前 3 行：
A B C
0 1 5 10
1 2 4 20
2 3 3 30
按列 'C' 排序的前 2 行，保留所有出现的最大值：
A B C
4 5 1 50
3 4 2 40
原始 Series 数据：
0 10
1 20
2 20
3 30
4 30
5 30
6 40
7 50
dtype: int64
Series 中的前 4 个最大值：
7 50
6 40
3 30
4 30
dtype: int64
总结
使用与应用场景
- 数据排序：返回按值排序的前 n 个最大的元素，方便进行数据分析和展示。
- 数据筛选：在大型数据集中快速筛选出最大的元素或行，适用于快速获取重要数据。
- 处理重复值：通过参数
keep，可以灵活处理出现重复值的情况，选择保留先出现的、最后出现的或所有重复值。
nlargest() 方法在数据分析和处理过程中非常有用，可以方便地获取数据集中按值排序的前 n 个最大元素或行，通过指定列名称和保留策略，可以灵活地应用于各种数据集。
nunique()的详细语法与实际案例
返回指定轴中唯一值的数目。
nunique() 是 Pandas 库中的 DataFrame 和 Series 对象的方法，用于计算每列或每行中唯一值的数量。
语法
DataFrame.nunique(axis=0, dropna=True)
Series.nunique(dropna=True)
参数
- axis (int, default 0)：指定沿哪个轴计算唯一值的数量。0 或 'index' 表示按列计算，1 或 'columns' 表示按行计算。
- dropna (bool, default True)：是否排除 NaN 值。如果设为 True，则忽略 NaN 值。
返回值
返回一个 Series，表示每列或每行中唯一值的数量。
实例代码
import pandas as pd
import numpy as np
# 创建一个 DataFrame
data = {
'A': [1, 2, 2, 4, 5],
'B': [5, 6, 7, 7, 8],
'C': [10, np.nan, 10, 10, 12]
}
df = pd.DataFrame(data)
print("原始数据集：")
print(df)
# 计算每列的唯一值数量
nunique_per_column = df.nunique()
print("\n每列的唯一值数量：")
print(nunique_per_column)
# 计算每行的唯一值数量
nunique_per_row = df.nunique(axis=1)
print("\n每行的唯一值数量：")
print(nunique_per_row)
# 创建一个 Series
series = pd.Series([1, 2, 2, 3, np.nan, 4, 4, 4, 5])
print("\n原始 Series 数据：")
print(series)
# 计算 Series 中的唯一值数量
nunique_series = series.nunique()
print("\nSeries 中的唯一值数量：")
print(nunique_series)
输出结果
原始数据集：
A B C
0 1.0 5.0 10.0
1 2.0 6.0 NaN
2 2.0 7.0 10.0
3 4.0 7.0 10.0
4 5.0 8.0 12.0
每列的唯一值数量：
A 4
B 4
C 3
dtype: int64
每行的唯一值数量：
0 3
1 2
2 2
3 2
4 3
dtype: int64
原始 Series 数据：
0 1.0
1 2.0
2 2.0
3 3.0
4 NaN
5 4.0
6 4.0
7 4.0
8 5.0
dtype: float64
Series 中的唯一值数量：
5
总结
使用与应用场景
- 数据统计：计算数据集中每列或每行的唯一值数量，以便了解数据的分布和多样性。
- 数据清洗：检查数据中的重复值情况，可以用于数据清洗和预处理。
- 数据验证：在数据分析过程中验证数据的唯一性，确保数据质量。
nunique() 方法在数据分析和处理过程中非常有用，可以方便地计算数据集中每列或每行的唯一值数量，帮助理解数据的分布情况和多样性。通过指定轴和是否忽略 NaN 值等参数，可以灵活地应用于各种数据集。
unique()的详细语法与实际案例
unique() 是 Pandas 库中的 DataFrame 和 Series 对象的方法，用于返回包含唯一值的 NumPy 数组。
语法
Series.unique()
DataFrame[column].unique()
参数
unique() 是一个方法，没有参数。
返回值
返回一个 NumPy 数组，包含唯一值。
实例代码
import pandas as pd
import numpy as np
# 创建一个 DataFrame
data = {
'A': [1, 2, 2, 4, 5],
'B': [5, 6, 7, 7, 8],
'C': [10, np.nan, 10, 10, 12]
}
df = pd.DataFrame(data)
print("原始数据集：")
print(df)
# 获取列 'A' 的唯一值
unique_A = df['A'].unique()
print("\n列 'A' 的唯一值：")
print(unique_A)
# 获取列 'B' 的唯一值
unique_B = df['B'].unique()
print("\n列 'B' 的唯一值：")
print(unique_B)
# 获取列 'C' 的唯一值
unique_C = df['C'].unique()
print("\n列 'C' 的唯一值：")
print(unique_C)
# 创建一个 Series
series = pd.Series([1, 2, 2, 3, np.nan, 4, 4, 4, 5])
print("\n原始 Series 数据：")
print(series)
# 获取 Series 中的唯一值
unique_series = series.unique()
print("\nSeries 中的唯一值：")
print(unique_series)
输出结果
原始数据集：
A B C
0 1.0 5.0 10.0
1 2.0 6.0 NaN
2 2.0 7.0 10.0
3 4.0 7.0 10.0
4 5.0 8.0 12.0
列 'A' 的唯一值：
[1. 2. 4. 5.]
列 'B' 的唯一值：
[5. 6. 7. 8.]
列 'C' 的唯一值：
[10. nan 12.]
原始 Series 数据：
0 1.0
1 2.0
2 2.0
3 3.0
4 NaN
5 4.0
6 4.0
7 4.0
8 5.0
dtype: float64
Series 中的唯一值：
[ 1. 2. 3. nan 4. 5.]
总结
使用与应用场景
- 数据分析：获取数据集中每列或每行的唯一值，以便了解数据的分布和多样性。
- 数据清洗：检查数据中的重复值情况，可以用于数据清洗和预处理。
- 数据验证：在数据分析过程中验证数据的唯一性，确保数据质量。
unique() 方法在数据分析和处理过程中非常有用，可以方便地获取数据集中每列或每行的唯一值，帮助理解数据的分布情况和多样性。该方法返回一个包含唯一值的 NumPy 数组，便于进一步的数据操作和分析。
pct_change()的详细语法与实际案例
返回上一个值与当前值之间的百分比变化。
pct_change() 是 Pandas 库中的 DataFrame 和 Series 对象的方法，用于计算每个元素相对于前一个元素的百分比变化。
语法
DataFrame.pct_change(periods=1, fill_method='pad', limit=None,
freq=None, **kwargs)
Series.pct_change(periods=1, fill_method='pad', limit=None,
freq=None, **kwargs)
参数
- periods (int, default 1)：计算变化的周期数。例如，
periods=1表示当前值与前一个值相比，periods=2表示当前值与前两个值相比。 - fill_method (str, default 'pad')：用于处理缺失值的方法。可以是 'pad' 或 'ffill'，即前向填充；或者 'bfill'，即后向填充。
- limit (int, default None)：前向或后向填充的最大数量。
- freq (str or DateOffset, default None)：增量周期。如果指定频率，则重采样时间序列以指定频率并计算变化。
- kwargs：其他关键词参数。
返回值
返回一个与调用对象形状相同的对象，包含百分比变化。
实例代码
import pandas as pd
import numpy as np
# 创建一个 DataFrame
data = {
'A': [100, 200, 300, 400, 500],
'B': [10, 20, 15, 25, 30],
'C': [1, np.nan, 3, 4, 5]
}
df = pd.DataFrame(data)
print("原始数据集：")
print(df)
# 计算每列的百分比变化
pct_change_df = df.pct_change()
print("\n每列的百分比变化：")
print(pct_change_df)
# 计算每列的百分比变化，周期为 2
pct_change_df_periods = df.pct_change(periods=2)
print("\n每列的百分比变化，周期为 2：")
print(pct_change_df_periods)
# 创建一个 Series
series = pd.Series([1, 2, 4, 8, 16])
print("\n原始 Series 数据：")
print(series)
# 计算 Series 的百分比变化
pct_change_series = series.pct_change()
print("\nSeries 的百分比变化：")
print(pct_change_series)
输出结果
原始数据集：
A B C
0 100 10 1.0
1 200 20 NaN
2 300 15 3.0
3 400 25 4.0
4 500 30 5.0
每列的百分比变化：
A B C
0 NaN NaN NaN
1 1.000000 1.0 NaN
2 0.500000 -0.25 NaN
3 0.333333 0.666667 0.333333
4 0.250000 0.200000 0.250000
每列的百分比变化，周期为 2：
A B C
0 NaN NaN NaN
1 NaN NaN NaN
2 2.000000 0.500000 NaN
3 1.000000 0.250000 NaN
4 0.666667 1.000000 2.000000
原始 Series 数据：
0 1
1 2
2 4
3 8
4 16
dtype: int64
Series 的百分比变化：
0 NaN
1 1.000000
2 1.000000
3 1.000000
4 1.000000
dtype: float64
总结
使用与应用场景
- 时间序列分析：计算时间序列数据的百分比变化，常用于股票价格、经济指标等分析。
- 数据分析：在数据分析过程中，计算各数据点的相对变化，以便理解数据的增长或减少趋势。
- 缺失值处理：通过参数
fill_method可以处理数据中的缺失值，确保百分比变化的计算不受缺失值影响。
pct_change() 方法在数据分析和时间序列处理中非常有用，可以计算每个元素相对于前一个元素的百分比变化，帮助理解数据的变化趋势。通过指定周期和缺失值处理方式，可以灵活地应用于各种数据集。
pipe()的详细语法与实际案例
将函数应用于 DataFrame。
pipe() 是 Pandas 库中的 DataFrame 和 Series 对象的方法，用于将对象传递给函数，以便简化方法链中的多个函数调用。pipe() 的主要目的是使代码更加简洁和易读，特别是在多个函数调用的情况下。
语法
DataFrame.pipe(func, *args, **kwargs)
Series.pipe(func, *args, **kwargs)
参数
- func (function)：要应用的函数。函数的第一个参数应该是传递的对象（即 DataFrame 或 Series）。
- *args：传递给函数的额外位置参数。
- **kwargs：传递给函数的额外关键字参数。
返回值
返回应用函数后的结果。结果的类型取决于函数的返回值。
实例代码
import pandas as pd
# 创建一个 DataFrame
data = {
'A': [1, 2, 3, 4, 5],
'B': [5, 4, 3, 2, 1]
}
df = pd.DataFrame(data)
print("原始数据集：")
print(df)
# 定义一个函数，计算每列的平方
def square(df):
return df ** 2
# 使用 pipe 方法将 DataFrame 传递给 square 函数
squared_df = df.pipe(square)
print("\n每列元素平方后的数据集：")
print(squared_df)
# 定义另一个函数，计算每列的均值，并减去均值
def mean_diff(df):
return df - df.mean()
# 使用 pipe 方法将 DataFrame 传递给 mean_diff 函数
mean_diff_df = df.pipe(mean_diff)
print("\n每列减去均值后的数据集：")
print(mean_diff_df)
# 创建一个 Series
series = pd.Series([1, 2, 3, 4, 5])
print("\n原始 Series 数据：")
print(series)
# 定义一个函数，计算元素的平方
def square_series(s):
return s ** 2
# 使用 pipe 方法将 Series 传递给 square_series 函数
squared_series = series.pipe(square_series)
print("\nSeries 元素平方后的结果：")
print(squared_series)
输出结果
原始数据集：
A B
0 1 5
1 2 4
2 3 3
3 4 2
4 5 1
每列元素平方后的数据集：
A B
0 1 25
1 4 16
2 9 9
3 16 4
4 25 1
每列减去均值后的数据集：
A B
0 -2.0 2.0
1 -1.0 1.0
2 0.0 0.0
3 1.0 -1.0
4 2.0 -2.0
原始 Series 数据：
0 1
1 2
2 3
3 4
4 5
dtype: int64
Series 元素平方后的结果：
0 1
1 4
2 9
3 16
4 25
dtype: int64
总结
使用与应用场景
- 简化方法链：
pipe()方法使得在方法链中传递对象更加简洁和易读。 - 函数式编程：将对象传递给函数，以便应用一系列的转换或处理操作。
- 提高代码可读性：通过
pipe()方法，可以将复杂的操作链分解为更小、更易读的步骤。
pipe() 方法在数据分析和处理过程中非常有用，特别是当需要将对象传递给多个函数进行一系列处理时。通过 pipe() 方法，可以使代码更加简洁和易读，提高代码的可维护性。
pivot()的详细语法与实际案例及案例输出结果
重塑 DataFrame。
pivot() 是 Pandas 库中的 DataFrame 方法，用于将数据重塑为透视表（pivot table）。pivot() 方法基于索引/列值，重新排列 DataFrame 中的数据。
语法
DataFrame.pivot(index=None, columns=None, values=None)
参数
- index (str or object, optional)：要使用的列名或索引，作为结果的行索引。
- columns (str or object, optional)：要使用的列名或索引，作为结果的列。
- values (str or object, optional)：要使用的列名或索引，作为结果的值。
返回值
返回一个重塑后的 DataFrame。
实例代码
import pandas as pd
# 创建一个 DataFrame
data = {
'date': ['2023-01-01', '2023-01-01', '2023-01-02', '2023-01-02'],
'city': ['New York', 'Los Angeles', 'New York', 'Los Angeles'],
'temperature': [32, 75, 28, 78],
'humidity': [80, 50, 82, 48]
}
df = pd.DataFrame(data)
print("原始数据集：")
print(df)
# 使用 pivot 方法重塑 DataFrame
pivot_df_temp = df.pivot(index='date', columns='city', values='temperature')
print("\n使用 pivot 方法重塑后的 DataFrame（温度）：")
print(pivot_df_temp)
pivot_df_hum = df.pivot(index='date', columns='city', values='humidity')
print("\n使用 pivot 方法重塑后的 DataFrame（湿度）：")
print(pivot_df_hum)
# 同时显示温度和湿度
pivot_df_both = df.pivot(index='date', columns='city')
print("\n使用 pivot 方法重塑后的 DataFrame（温度和湿度）：")
print(pivot_df_both)
输出结果
原始数据集：
date city temperature humidity
0 2023-01-01 New York 32 80
1 2023-01-01 Los Angeles 75 50
2 2023-01-02 New York 28 82
3 2023-01-02 Los Angeles 78 48
使用 pivot 方法重塑后的 DataFrame（温度）：
city Los Angeles New York
date
2023-01-01 75 32
2023-01-02 78 28
使用 pivot 方法重塑后的 DataFrame（湿度）：
city Los Angeles New York
date
2023-01-01 50 80
2023-01-02 48 82
使用 pivot 方法重塑后的 DataFrame（温度和湿度）：
temperature humidity
city Los Angeles New York Los Angeles New York
date
2023-01-01 75 32 50 80
2023-01-02 78 28 48 82
总结
使用与应用场景
- 数据重塑：将长格式数据转换为宽格式数据，便于数据分析和可视化。
- 透视表：创建透视表，用于数据汇总和分析。
- 数据整理：在数据预处理过程中，通过重塑数据集，获得更易于理解和分析的格式。
pivot() 方法在数据分析和处理过程中非常有用，特别是在需要将长格式数据转换为宽格式数据时。通过指定索引、列和值，可以灵活地重塑 DataFrame，生成易于分析的透视表。
898
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
