diff()计算值与上一行中相同列的值之间的差值
计算值与上一行中相同列的值之间的差值。
diff() 是 Pandas 中用于计算数据差异的函数，它计算当前元素与前一个元素之间的差值。这在金融和经济数据分析中特别有用，例如计算价格或成本的连续变化。
语法
DataFrame.diff(periods=1, axis=0)
Series.diff(periods=1, axis=0)
参数
- periods: int，默认为 1。
- 表示计算差值时相差的时间间隔或行数。
periods=1表示与前一个元素比较，periods=-1表示与后一个元素比较。
- 表示计算差值时相差的时间间隔或行数。
- axis: {0 or 'index', 1 or 'columns'}，默认为 0。
axis=0表示沿着行操作，即计算每列的差值。axis=1表示沿着列操作，即计算每行的差值。
实际案例
假设我们有一个包含金融数据的 DataFrame，例如股票的日收盘价，我们希望计算连续两天之间的价格变化。
import pandas as pd
# 创建一个包含股票价格的 DataFrame
data = {
'Date': ['2023-01-01', '2023-01-02', '2023-01-03', '2023-01-04', '2023-01-05'],
'Price': [100, 102, 101, 105, 107]
}
df = pd.DataFrame(data)
df.set_index('Date', inplace=True)
print("Original DataFrame:")
print(df)
# 计算价格每天的变化
price_diff = df['Price'].diff()
print("\nPrice Differences:")
print(price_diff)
结果
Original DataFrame:
Price
Date
2023-01-01 100
2023-01-02 102
2023-01-03 101
2023-01-04 105
2023-01-05 107
Price Differences:
Date
2023-01-01 NaN # 第一天没有前一天的数据，因此差值为 NaN
2023-01-02 2.0 # 第二天比第一天多了 2
2023-01-03 -1.0 # 第三天比第二天少了 1
2023-01-04 4.0 # 第四天比第三天多了 4
2023-01-05 2.0 # 第五天比第四天多了 2
Name: Price, dtype: float64
在这个例子中：
df['Price'].diff()计算了股票价格每日的差异，帮助分析价格的变化趋势。
div()将 DataFrame 的值除以指定的值
将 DataFrame 的值除以指定的值。
div() 是 Pandas 中用于执行元素级别除法的函数。它可以将 DataFrame 或 Series 的每个元素与另一个数组、Series 或一个标量进行除法运算。
语法
DataFrame.div(other, axis='columns', level=None, fill_value=None)
Series.div(other, level=None, fill_value=None)
参数
- other: 数值、Series 或 DataFrame。这是除数，用于除以调用对象中的数据。
- axis: {0 or 'index', 1 or 'columns'}，仅适用于 DataFrame，默认为 'columns'。
axis='columns': 沿列应用除法（每列的数据除以other）。axis='index': 沿行应用除法（每行的数据除以other）。
- level: 指定多级索引的级别（对于多索引的 DataFrame 或 Series），默认为 None。
- fill_value: float or None，默认为 None。在进行运算前填充 NaN 的值。
实际案例
假设我们有一个 DataFrame 和一个 Series，我们希望对 DataFrame 的每列数据进行除法运算。
import pandas as pd
# 创建一个 DataFrame
df = pd.DataFrame({
'A': [10, 20, 30],
'B': [100, 200, 300]
})
# 创建一个 Series
s = pd.Series([2, 10])
print("Original DataFrame:")
print(df)
print("\nOriginal Series:")
print(s)
# 将 DataFrame 的每列除以 Series
result = df.div(s, axis='index')
print("\nResult of DataFrame divided by Series:")
print(result)
结果
Original DataFrame:
A B
0 10 100
1 20 200
2 30 300
Original Series:
0 2
1 10
dtype: int64
Result of DataFrame divided by Series:
A B
0 5.0 50.0
1 2.0 20.0
2 NaN NaN
在这个例子中：
- DataFrame 的每个元素按行与 Series 中的相应元素相除。由于 Series 的长度小于 DataFrame 的行数，第三行的计算结果为 NaN。
- 通过设置
axis='index'，我们指定了沿 DataFrame 的索引（行）对数据进行除法操作，而不是默认的列。
dot()用于矩阵乘法的函数，适用于 DataFrame 和 Series 的点积运算
将 DataFrame 的值与另一个类似数组的对象的值相乘，然后添加结果。
dot() 是 Pandas 中用于矩阵乘法的函数，适用于 DataFrame 和 Series 的点积运算。这个函数可以用来计算两个 DataFrame 或一个 DataFrame 与一个 Series 之间的线性代数点积。
语法
DataFrame.dot(other)
Series.dot(other)
参数
- other: 另一个 DataFrame、Series 或兼容对象（如 numpy 数组）。
实际案例
假设我们有两个 DataFrame，一个表示商品的价格，另一个表示商品的数量，我们想要计算总价格。
import pandas as pd
# 创建表示商品价格的 DataFrame
prices = pd.DataFrame({
'Apple': [1.2],
'Banana': [0.5],
'Cherry': [2.0]
})
# 创建表示商品数量的 DataFrame
quantities = pd.DataFrame({
'Apple': [10],
'Banana': [20],
'Cherry': [15]
}).T # 转置以匹配价格 DataFrame 的格式
print("Prices DataFrame:")
print(prices)
print("\nQuantities DataFrame:")
print(quantities)
# 使用 dot() 计算商品的总价格
total_price = prices.dot(quantities)
print("\nTotal Price for Each Fruit:")
print(total_price)
结果
Prices DataFrame:
Apple Banana Cherry
0 1.2 0.5 2.0
Quantities DataFrame:
0
Apple 10
Banana 20
Cherry 15
Total Price for Each Fruit:
0
0 53.0
在这个例子中：
pricesDataFrame 包含了每种水果的价格。quantitiesDataFrame 通过转置被设置成一个列向量，表示每种水果的数量。- 使用
dot()函数进行矩阵乘法，将价格和数量相乘，得到总价53.0。这显示了如何使用 Pandas 进行基本的线性代数运算，特别是在涉及到金融计算或库存管理系统时非常有用。
drop()删除指定的行/列
从 DataFrame 中删除指定的行/列。
drop() 是 Pandas 中用于删除 DataFrame 或 Series 中的行或列的函数。这个函数提供了一种便捷的方法来移除不需要的数据。
语法
参数
- labels: 单个标签或标签列表。要删除的行或列的标签。
- axis: {0 or 'index', 1 or 'columns'}，默认为 0。
0或 'index' 表示操作将在行上执行。1或 'columns' 表示操作将在列上执行。
- index: 单个标签或标签列表。是
labels参数的别名，用于更直观地指定行标签。 - columns: 单个标签或标签列表。是
labels参数的别名，用于更直观地指定列标签。 - level: int 或 level name，默认为 None。如果 DataFrame 是多层索引（MultiIndex），则指定要操作的级别。
- inplace: bool，默认为 False。
- 如果为
True，则进行原地修改，不返回新的 DataFrame。 - 如果为
False，则返回一个新的 DataFrame，原 DataFrame 不被修改。
- 如果为
- errors: {'ignore', 'raise'}，默认为 'raise'。
- 如果设置为 'raise'，并且指定的标签在数据中找不到，则会抛出一个错误。
- 如果设置为 'ignore'，则即使找不到也不会抛出错误，操作将静默执行。
实际案例
假设我们有一个 DataFrame，其中包含多列数据，我们希望删除某些不需要的列。
import pandas as pd
# 创建一个 DataFrame
df = pd.DataFrame({
'Name': ['Alice', 'Bob', 'Charlie'],
'Age': [25, 30, 35],
'City': ['New York', 'Los Angeles', 'Chicago'],
'Salary': [50000, 60000, 70000]
})
print("Original DataFrame:")
print(df)
# 删除 'Salary' 列
df_dropped = df.drop(columns='Salary')
print("\nDataFrame after dropping 'Salary' column:")
print(df_dropped)
结果
Original DataFrame:
Name Age City Salary
0 Alice 25 New York 50000
1 Bob 30 Los Angeles 60000
2 Charlie 35 Chicago 70000
DataFrame after dropping 'Salary' column:
Name Age City
0 Alice 25 New York
1 Bob 30 Los Angeles
2 Charlie 35 Chicago
在这个例子中：
drop()函数被用来从 DataFrame 中移除'Salary'列。- 通过设置
columns='Salary'，我们指定了要删除的列。 drop()函数默认返回一个新的 DataFrame，不改变原始 DataFrame，除非指定inplace=True。
drop_duplicates()删除重复值
从 DataFrame 中删除重复值。
drop_duplicates() 是 Pandas 中用于删除 DataFrame 中重复行的函数。该函数对于数据清洗非常有用，特别是在处理包含重复记录的数据集时。
语法
DataFrame.drop_duplicates(subset=None, keep='first',
inplace=False, ignore_index=False)
参数
- subset: 单个列名或列名的列表，用于识别重复行，默认为 None，表示使用所有列。
- keep: {'first', 'last', False}，默认为 'first'。
first: 保留每组重复行中的第一行。last: 保留每组重复行中的最后一行。False: 删除所有重复行。
- inplace: bool，默认为 False。
- 如果为
True，则原地修改 DataFrame 并返回 None。 - 如果为
False，则返回一个新的 DataFrame，原 DataFrame 保持不变。
- 如果为
- ignore_index: bool，默认为 False。
- 如果为
True，在删除重复项后，重新设置 DataFrame 的索引。
- 如果为
实际案例
假设我们有一个包含一些重复记录的 DataFrame，并且我们希望删除这些重复项。
import pandas as pd
# 创建一个包含重复数据的 DataFrame
df = pd.DataFrame({
'Name': ['Alice', 'Bob', 'Charlie', 'Bob', 'Charlie', 'Charlie'],
'Age': [25, 30, 35, 30, 35, 35],
'City': ['New York', 'Los Angeles', 'Chicago', 'Los Angeles', 'Chicago', 'Chicago']
})
print("Original DataFrame:")
print(df)
# 删除重复行
df_unique = df.drop_duplicates()
print("\nDataFrame after dropping duplicates:")
print(df_unique)
结果
Original DataFrame:
Name Age City
0 Alice 25 New York
1 Bob 30 Los Angeles
2 Charlie 35 Chicago
3 Bob 30 Los Angeles
4 Charlie 35 Chicago
5 Charlie 35 Chicago
DataFrame after dropping duplicates:
Name Age City
0 Alice 25 New York
1 Bob 30 Los Angeles
2 Charlie 35 Chicago
在这个例子中：
- 重复行
Bob和Charlie分别出现了多次，但我们只保留了第一次出现的记录。 drop_duplicates()根据所有列的组合来识别重复行，因为我们没有指定subset参数。- 默认行为是保留每组重复中的第一行（
keep='first'）。 - 结果 DataFrame
df_unique中不再包含任何完全重复的行。
droplevel()删除指定的索引/列
删除指定的索引/列。
droplevel() 是 Pandas 中用于删除 DataFrame 或 Series 的多级索引中的一个或多个级别的函数。这个操作常用于在处理具有复杂层次索引的数据时简化索引结构。
语法
DataFrame.droplevel(level, axis=0)
Series.droplevel(level, axis=0)
参数
- level: int、level name 或者是它们的列表。指定要删除的索引级别。
- axis: {0 or 'index', 1 or 'columns'}，默认为 0。
0或 'index' 表示从行索引中删除指定的级别。1或 'columns' 表示从列索引中删除指定的级别。
实际案例
假设我们有一个具有多级索引的 DataFrame，我们希望删除其中的一个索引级别。
import pandas as pd
# 创建一个具有多级索引的 DataFrame
index = pd.MultiIndex.from_tuples([
('A', 'x'),
('A', 'y'),
('B', 'x'),
('B', 'y')
], names=['level1', 'level2'])
df = pd.DataFrame({
'Data': [1, 2, 3, 4]
}, index=index)
print("Original DataFrame with MultiIndex:")
print(df)
# 删除第一个索引级别
df_dropped = df.droplevel('level1')
print("\nDataFrame after dropping 'level1':")
print(df_dropped)
结果
Original DataFrame with MultiIndex:
Data
level1 level2
A x 1
y 2
B x 3
y 4
DataFrame after dropping 'level1':
Data
level2
x 1
y 2
x 3
y 4
在这个例子中：
- 初始 DataFrame
df包含两个层次的索引，名为level1和level2。 - 使用
droplevel()函数删除level1索引，使 DataFrame 索引结构变得更简单。 - 删除索引级别后，DataFrame 只保留了
level2的索引。注意，尽管level2包含重复的标签（x, y），但因为它们现在是顶级索引，所以仍然有效。
这种方式非常适合在需要降低数据结构复杂度或准备数据以进行进一步分析时使用。
dropna()删除包含空值的所有行
删除包含空值的所有行。
dropna() 是 Pandas 中用于删除 DataFrame 或 Series 中包含缺失值的行或列的函数。这个函数在数据清洗过程中非常有用，尤其是在处理大量数据集时，常常需要删除缺失数据以保证数据质量。
语法
DataFrame.dropna(axis=0, how='any', thresh=None, subset=None, inplace=False)
Series.dropna(axis=0, inplace=False)
参数
- axis: {0 or 'index', 1 or 'columns'}, 默认为 0。
0或 'index' 表示删除含有缺失值的行。1或 'columns' 表示删除含有缺失值的列。
- how: {'any', 'all'}, 默认为 'any'。
any: 如果任何 NA 值存在，则删除该行或列。all: 如果所有值都是 NA，则删除该行或列。
- thresh: int, 默认为 None。
- 要求每行或每列中非 NA 值的最小数量，不满足则进行删除。
- subset: array-like, 默认为 None。
- 在一个数据帧的哪些列中查找缺失值，仅对这些列进行。
- inplace: bool, 默认为 False。
- 如果为 True，则进行原地修改 DataFrame，不返回新的 DataFrame。
实际案例
假设我们有一个 DataFrame，包含一些缺失数据，我们希望删除包含缺失值的行。
import pandas as pd
import numpy as np
# 创建一个包含缺失数据的 DataFrame
df = pd.DataFrame({
'Name': ['Alice', 'Bob', 'Charlie', None],
'Age': [25, 30, np.nan, 22],
'City': ['New York', None, 'Chicago', 'Los Angeles']
})
print("Original DataFrame:")
print(df)
# 删除含有任何缺失值的行
df_cleaned = df.dropna()
print("\nDataFrame after dropping rows with any NA values:")
print(df_cleaned)
结果
Original DataFrame:
Name Age City
0 Alice 25.0 New York
1 Bob 30.0 None
2 Charlie NaN Chicago
3 None 22.0 Los Angeles
DataFrame after dropping rows with any NA values:
Name Age City
0 Alice 25.0 New York
在这个例子中：
- 初始 DataFrame
df包含几行数据，其中一些行包括缺失值。 - 使用
dropna()函数删除了包含任何缺失值的行（即how='any'），只有第一行完全没有缺失值，因此被保留了。 - 这种方法对于在进行统计分析或机器学习模型训练前清洗数据集非常有效。
dtypes返回 DataFrame 列的数据类型
返回 DataFrame 列的数据类型
dtypes 是 Pandas 中用于获取 DataFrame 中每列的数据类型的属性。这个属性非常有用，因为它可以快速地告诉你每个列存储的数据类型，帮助你在数据处理或数据清洗时做出更好的决策。
语法
DataFrame.dtypes
dtypes 是一个属性，而不是一个方法，因此不需要在后面添加括号。
实际案例
假设我们有一个 DataFrame，包含不同类型的数据，我们希望查看每列的数据类型。
import pandas as pd
import numpy as np
# 创建一个 DataFrame
df = pd.DataFrame({
'A': [1, 2, 3],
'B': [1.1, 2.2, 3.3],
'C': ['foo', 'bar', 'baz'],
'D': pd.to_datetime(['2021-01-01', '2021-01-02', '2021-01-03']),
'E': pd.Series([1, 2, 3], dtype='Int64')
})
print("Original DataFrame:")
print(df)
# 获取 DataFrame 的数据类型
data_types = df.dtypes
print("\nData Types of Each Column:")
print(data_types)结果
Original DataFrame:
A B C D E
0 1 1.1 foo 2021-01-01 1
1 2 2.2 bar 2021-01-02 2
2 3 3.3 baz 2021-01-03 3
Data Types of Each Column:
A int64
B float64
C object
D datetime64[ns]
E Int64
dtype: object
在这个例子中：
- 列
A的数据类型是int64，代表整数。 - 列
B的数据类型是float64，代表浮点数。 - 列
C的数据类型是object，通常用于字符串或 Pandas 中的混合数据类型。 - 列
D的数据类型是datetime64[ns]，用于日期和时间数据。 - 列
E的数据类型是Int64，是 Pandas 的可空整数类型，可以处理缺失值。
使用 dtypes 属性可以快速检查 DataFrame 中每列的数据类型，这对于数据预处理和分析是非常重要的。
duplicated()标识重复行的函数
对于重复的行返回 True，否则返回 False。
duplicated() 是 Pandas 中用于标识重复行的函数。该函数返回一个布尔型 Series，标记 DataFrame 中的重复行。如果一行与之前的行相同，则标记为 True，否则为 False。
语法
DataFrame.duplicated(subset=None, keep='first')
参数
- subset: 列名列表，用于确定重复项的子集。如果为 None，则使用所有列。
- keep: {'first', 'last', False}，用于确定哪些重复项应该被标记为
True。first：除了第一次出现外，其它重复项被标记为True。last：除了最后一次出现外，其它重复项被标记为True。False：所有重复项都被标记为True。
实际案例
假设我们有一个包含一些重复行的 DataFrame，我们想要标识出这些重复行。
import pandas as pd
# 创建一个包含重复行的 DataFrame
df = pd.DataFrame({
'Name': ['Alice', 'Bob', 'Charlie', 'Bob', 'Charlie', 'Charlie'],
'Age': [25, 30, 35, 30, 35, 35],
'City': ['New York', 'Los Angeles', 'Chicago', 'Los Angeles', 'Chicago', 'Chicago']
})
print("Original DataFrame:")
print(df)
# 标识重复行
duplicates = df.duplicated()
print("\nDuplicated Rows:")
print(duplicates)结果
Original DataFrame:
Name Age City
0 Alice 25 New York
1 Bob 30 Los Angeles
2 Charlie 35 Chicago
3 Bob 30 Los Angeles
4 Charlie 35 Chicago
5 Charlie 35 Chicago
Duplicated Rows:
0 False
1 False
2 False
3 True
4 True
5 True
dtype: bool
在这个例子中：
- 初始 DataFrame
df包含一些重复行，比如 "Bob" 和 "Charlie" 在数据集中出现了多次。 - 使用
duplicated()函数，默认保留第一次出现的行，其它重复的行都被标记为True。 - 这个函数对于清洗数据和去除重复非常有用，特别是在处理大数据集时。
扫一扫
491
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
