pandas中文文档

Pandas 是 Python 中用于数据分析和处理的重要工具，它提供了丰富的数据操作和处理功能。下面是 Pandas 的一些常用操作：

读取数据

可以使用 read_csv 方法读取 CSV 文件，使用 read_excel 方法读取 Excel 文件，使用 read_sql 方法读取 SQL 数据库等。例如：

import pandas as pd
# 读取 CSV 文件
df = pd.read_csv('data.csv')
# 读取 Excel 文件
df = pd.read_excel('data.xlsx')
# 读取 SQL 数据库
import sqlite3
conn = sqlite3.connect('example.db')
df = pd.read_sql('SELECT * FROM table_name', conn)

在pandas中，可以使用skiprows参数指定从哪一行开始读取数据。具体用法如下：

import pandas as pd
# 从第3行开始读取数据
df = pd.read_csv('文件路径', skiprows=2

上述代码中，skiprows参数的值为2，表示从第3行开始读取数据。这个参数也可以接受一个列表作为参数，来指定要跳过的多行行号。
另外，如果读取的文件没有列名，可以使用header=None参数来指定没有列名，如下所示：

# 从第3行开始读取数据，且没有列名
df = pd.read_csv('文件路径', skiprows=2, header=None)

如果需要读取除最后N行以外的所有行，可以使用skipfooter参数，如下所示：

# 读取除最后2行以外的所有行
df = pd.read_csv('文件路径', skipfooter=2)

需要注意的是，使用skiprows和skipfooter参数时，需要保证读取的数据完整和准确，否则可能会出现数据偏移或丢失的情况。建议在使用前先确认数据的行数和内容。

查看数据

可以使用 head、tail 方法查看数据的前几行或后几行，使用 info 方法查看数据的摘要信息，使用 describe 方法查看数据的统计信息等。例如：

# 查看前 5 行数据
df.head()
# 查看后 5 行数据
df.tail()
# 查看数据的摘要信息
df.info()
# 查看数据的统计信息
df.describe()

选择数据

可以使用 loc 方法按标签选择数据，使用 iloc 方法按位置选择数据，使用 [] 运算符按列选择数据等。例如：

# 按行和列选择数据
df.loc[2:4, ['name', 'age']]
# 按位置选择数据
df.iloc[2:4, [0, 2]]
# 按列选择数据
df['name']
df[['name', 'age']]

筛选数据 数据过滤

可以使用 query 方法使用表达式筛选数据，使用布尔运算符筛选数据，使用 isin 方法筛选数据等。例如：

# 使用表达式筛选数据
df.query('age > 30')
# 使用布尔运算符筛选数据
df[(df['age'] > 30) & (df['gender'] == 'male')]
# 使用 isin 方法筛选数据
df[df['name'].isin(['Alice', 'Bob'])]

dataFrame模糊匹配筛选

import pandas as pd
# 读取数据并将其存储为DataFrame对象
df = pd.read_csv('数据文件路径')
# 使用contains()方法筛选包含指定关键字的行
keyword = '要筛选的关键字'
filtered_df = df[df['列名'].str.contains(keyword)]
print(filtered_df)

dataFrame模糊匹配按匹配度来筛选过滤

使用pandas中的字符串方法来实现DataFrame的模糊筛选关键字。具体步骤如下：

import pandas as pd

使用pandas中的字符串方法中的str.similar()方法来实现DataFrame的基于匹配度的模糊匹配筛选。str.similar()方法可以计算两个字符串之间的相似度得分，得分越高表示两个字符串的相似度越高。具体步骤如下：

使用字符串方法中的similar()方法计算每行数据与指定关键字之间的相似度得分：

keyword = '要筛选的关键字'
filtered_df = df[df['列名'].apply(lambda x: x.similar(keyword)) > 0.5]

上述代码中，apply()方法用于将similar()方法应用于指定列的每个元素，返回一个包含每个元素相似度得分的Series对象。然后使用>运算符和0.5进行比较，筛选出相似度得分大于0.5的行。

完整示例代码：

import pandas as pd
df = pd.read_excel('报价.xlsx', skiprows=4,header=None)# skipping the first 3 rows
df.columns = ['列1名称', '列2名称','列3','列4','列5']
# 读取数据并将其存储为DataFrame对象
# 使用similar()方法计算每行数据与指定关键字之间的相似度得分
from difflib import SequenceMatcher
def similar(a, b):
    return SequenceMatcher(None, a, b).ratio()
print(df)
keyword = 'G1955'
filtered_df = df[df['列2名称'].apply(lambda x: similar(x, keyword)) > 0.6]
print(filtered_df)

筛选报错问题：
相关报错
File “pandas\core\frame.py”, line 4060, in query
File “pandas\core\frame.py”, line 4191, in eval
File “pandas\core\computation\eval.py”, line 324, in eval
ValueError: multi-line expressions are only valid in the context of data, use DataFrame.eval
这个错误通常是由于在 pandas 的 query 函数或 eval 函数中使用了多行表达式或语句，而这些函数只能处理一行表达式或语句。
可以尝试修改代码，将多行表达式或语句拆分成单行，或者使用其他方式处理多行表达式或语句。
以下是一个示例，将多行表达式拆分成单行：

df_selected = df.query("(标题.str.contains('xx市潮阳区国有土地使用权招拍挂出让成交公告')) & (成交时间.str.contains('2021-08-01'))")

在上面的代码中，我们将原来的多行表达式拆分成了两行，每行只有一个表达式。这样就可以避免 query 函数出现多行表达式的错误。
可以尝试修改代码，将多行表达式或语句拆分成单行，或者使用其他方式处理多行表达式或语句。
以下是一个示例，将多行表达式拆分成单行：

df_selected = df.query("(标题.str.contains('汕头市潮阳区国有土地使用权招拍挂出让成交公告')) & (成交时间.str.contains('2021-08-01'))")

在上面的代码中，我们将原来的多行表达式拆分成了两行，每行只有一个表达式。这样就可以避免 query 函数出现多行表达式的错误。
另外，如果仍然出现错误，可以尝试使用 eval 函数替代 query 函数。例如，可以将原来的代码：

df_new = df.query('成交公示标题=="%s"' % titletext)

修改为

df_new = df[df["成交公示标题"].eq(titletext)]

这样也可以实现相同的筛选功能。

修改数据 数据填充

可以使用 fillna 方法填充缺失值，使用 replace 方法替换数据，使用 drop 方法删除数据等。例如：

# 填充缺失值
df.fillna(0)
# 替换数据
df.replace({'gender': {'male': 0, 'female': 1}})
# 删除数据
df.drop([2, 3])

统计数据

可以使用 count 方法统计非空值的数量，使用 sum 方法计算总和，使用 mean 方法计算平均值等。例如：

# 统计非空值的数量
df.count()
# 计算总和
df['age'].sum()
# 计算平均值
df['age'].mean()

分组数据

可以使用 groupby 方法按列分组数据，使用 agg 方法对每个组进行聚合计算。例如：

# 按 gender 列分组并计算平均值
df.groupby('gender').mean()
# 对每个组计算多个值
df.groupby('gender').agg({'age': 'mean', 'salary': 'max'})

合并数据

可以使用 merge 方法将两个数据框按列或行进行合并，使用 concat 方法将多个数据框按列或行进行连接。例如：

# 按列合并两个数据框
df1 = pd.DataFrame({'name': ['Alice', 'Bob'], 'age': [25, 30]})
df2 = pd.DataFrame({'salary': [5000, 8000], 'gender': ['female', 'male']})
pd.merge(df1, df2, left_index=True, right_index=True)
# 按行连接多个数据框
df1 = pd.DataFrame({'name': ['Alice', 'Bob'], 'age': [25, 30]})
df2 = pd.DataFrame({'name': ['Charlie', 'David'], 'age': [35, 40]})
pd.concat([df1, df2])

重塑数据

可以使用 pivot 方法将长格式的数据转换成宽格式，使用 melt 方法将宽格式的数据转换成长格式。例如：

# 将长格式的数据转换成宽格式
df = pd.DataFrame({'name': ['Alice', 'Bob'], 'year': [2018, 2018], 'sales': [100, 200]})
df.pivot(index='name', columns='year', values='sales')
# 将宽格式的数据转换成长格式
df = pd.DataFrame({'name': ['Alice', 'Bob'], '2018': [100, 200], '2019': [150, 250]})
df.melt(id_vars='name', var_name='year', value_name='sales')

时间序列

可以使用 to_datetime 方法将字符串转换成日期格式，使用 resample 方法对时间序列进行重采样，使用 rolling 方法对时间序列进行滑动窗口计算。例如：

# 将字符串转换成日期格式
df['date'] = pd.to_datetime(df['date'])
# 对时间序列进行重采样
df.resample('D', on='date').sum()
# 对时间序列进行滑动窗口计算
df.rolling(window=2).mean()

多级索引

可以使用 set_index 方法设置多级索引，使用 reset_index 方法重置索引，使用 sort_index 方法对索引排序等。例如：

# 设置多级索引
df.set_index(['name', 'year'])
# 重置索引
df.reset_index()
# 对索引排序
df.sort_index(level='year')

向量化计算

Pandas 支持向量化计算，可以使用 apply 方法对数据框或数据框的某一列进行函数计算，使用 map 方法对数据框或数据框的某一列进行映射计算。例如：

# 对数据框的某一列进行函数计算
df['sales'].apply(lambda x: x * 2)
# 对数据框的某一列进行映射计算
df['gender'].map({'male': 0, 'female': 1})

可视化

可以使用 plot 方法对数据进行可视化，支持多种图表类型，例如折线图、柱状图、散点图等。例如：

# 折线图
df.plot(x='date', y='sales')
# 柱状图
df.plot(kind='bar', x='name', y='sales')
# 散点图
df.plot(kind='scatter', x='age', y='salary')

分组操作

可以使用 groupby 方法对数据进行分组操作，然后使用聚合函数进行统计计算，例如 sum, mean, count, max, min 等。例如：

# 对数据进行分组操作并计算平均值
df.groupby('gender')['salary'].mean()
# 对多列数据进行分组操作并计算总和
df.groupby(['gender', 'age'])['salary', 'sales'].sum()

数据透视表

可以使用 pivot_table 方法创建数据透视表，可以统计数据的各种汇总信息，例如计数、平均值、标准差等。例如：

# 创建数据透视表并计算平均值
pd.pivot_table(df, values='salary', index='gender', columns='age', aggfunc='mean')
# 创建数据透视表并计算总和、平均值、标准差
pd.pivot_table(df, values=['salary', 'sales'], index='gender', columns='age', aggfunc={'salary': 'sum', 'sales': ['mean', 'std']})

缺失值处理

可以使用 dropna 方法删除缺失值，使用 fillna 方法填充缺失值，使用 interpolate 方法插值填充缺失值。例如：

# 删除缺失值
df.dropna()
# 填充缺失值
df.fillna(0)
# 插值填充缺失值
df.interpolate()

文本处理

可以使用 str 属性对数据框中的字符串进行处理，例如使用 contains 方法判断字符串是否包含某个子串，使用 replace 方法替换字符串。例如：

# 判断字符串是否包含某个子串
df['name'].str.contains('A')
# 替换字符串
df['name'].replace('Alice', 'Eva')

合并数据

可以使用 concat 方法将多个数据框按行或按列合并，使用 merge 方法根据某一列或多列进行数据的连接。例如：

# 将多个数据框按行合并
pd.concat([df1, df2, df3])
# 将多个数据框按列合并
pd.concat([df1, df2], axis=1)
# 根据某一列进行连接
pd.merge(df1, df2, on='id')
# 根据多列进行连接
pd.merge(df1, df2, on=['id', 'name'])

时间差计算

可以使用 pd.Timedelta 方法计算时间差，例如计算两个日期之间的时间差，或者计算时间差的和。例如：

# 计算两个日期之间的时间差
pd.Timestamp('2021-06-01') - pd.Timestamp('2021-05-01')
# 计算时间差的和
pd.Timedelta('1 days') + pd.Timedelta('2 hours')

数据类型转换

可以使用 astype 方法将数据框中的数据类型进行转换，例如将字符串类型转换成整数类型，将浮点类型转换成整数类型等。例如：

# 将字符串类型转换成整数类型
df['age'] = df['age'].astype(int)
# 将浮点类型转换成整数类型
df['salary'] = df['salary'].astype(int)

分位数计算

可以使用 quantile 方法计算数据的分位数，例如计算数据的中位数、四分位数等。例如：

# 计算数据的中位数
df['salary'].quantile(0.5)
# 计算数据的四分位数
df['salary'].quantile([0.25, 0.5, 0.75])

数据采样

可以使用 sample 方法对数据进行采样，例如随机抽取数据中的一部分进行分析。例如：

# 随机抽取数据中的一部分进行分析
df.sample(n=10)

数据存储

可以使用 to_csv 方法将数据框中的数据保存成 CSV 文件，使用 to_excel 方法将数据框中的数据保存成 Excel 文件。例如：

# 将数据保存成 CSV 文件
df.to_csv('data.csv', index=False)
# 将数据保存成 Excel 文件
df.to_excel('data.xlsx', index=False)

时间序列

可以使用 pd.date_range 方法创建时间序列，例如创建一个时间范围内的日期序列，或者创建一个时间范围内的时间序列。例如：

# 创建一个时间范围内的日期序列
pd.date_range(start='2021-01-01', end='2021-12-31')
# 创建一个时间范围内的时间序列
pd.date_range(start='2021-01-01 00:00:00', end='2021-01-01 23:59:59', freq='H')

数据重塑

可以使用 melt 方法将数据框进行重塑，例如将宽格式的数据框转换成长格式的数据框。例如：

# 将宽格式的数据框转换成长格式的数据框
pd.melt(df, id_vars=['id', 'name'], value_vars=['salary', 'sales'], var_name='key', value_name='value')

数据排序

可以使用 sort_values 方法对数据框中的数据进行排序，例如按照某一列或多列进行升序或降序排序。例如：

# 按照某一列进行升序排序
df.sort_values('age')
# 按照多列进行升序排序
df.sort_values(['gender', 'age'])
# 按照某一列进行降序排序
df.sort_values('salary', ascending=False)

数据聚合

可以使用 agg 方法对数据框中的数据进行聚合操作，例如使用自定义函数进行聚合操作。例如：

# 使用自定义函数进行聚合操作
def my_func(x):
    return x.max() - x.min()
df.groupby('gender')['salary'].agg(my_func)

数据归一化

可以使用 MinMaxScaler 方法对数据进行归一化操作，将数据缩放到指定的区间内，例如将数据缩放到 [0, 1] 区间内。例如：

# 将数据缩放到 [0, 1] 区间内
from sklearn.preprocessing import MinMaxScaler
scaler = MinMaxScaler()
df['salary_normalized'] = scaler.fit_transform(df[['salary']])

数据填充

可以使用 fillna 方法对数据框中的缺失值进行填充，例如使用均值、中位数、众数等进行填充。例如：

# 使用均值进行填充
df['age'].fillna(df['age'].mean(), inplace=True)
# 使用中位数进行填充
df['salary'].fillna(df['salary'].median(), inplace=True)
# 使用众数进行填充
df['department'].fillna(df['department'].mode()[0], inplace=True)

数据抽样

可以使用 resample 方法对时间序列数据进行抽样，例如对数据进行按天、按周、按月等频率的抽样。例如：

# 对数据进行按天抽样
df.resample('D').mean()
# 对数据进行按周抽样
df.resample('W').mean()
# 对数据进行按月抽样
df.resample('M').mean()

从某行开始生成新的dataFrame

match_idx为df的行数， 从改行开始，生成新的dataframe，没有表头

# 有表头，为原来的表头
new_df = df.iloc[start_row:]

# 没有表头
new_df = pd.DataFrame(df.values[match_idx:], columns=list(range(df.shape[1])))
# 读取指定的某行数据，做为一维数组进行返回

row_array = df.iloc[row_num].values
# 指定dataframe 设置指定的表头
new_header = ['col1', 'col2', 'col3']
df.columns = new_header

根据列表头查找字符串并生成新的dataFrame

需要修改 还没修改~
根据列的下标，查找某个字符串，查找到以后，将查找到的这列作为新的表头，下面的数据作为新的数据，并组合成新的dataframe

def search_and_rearrange(df, col_name, search_str):
    """
    根据指定列的值查找并重组DataFrame
    :param df: 要处理的DataFrame
    :param col_name: 要查找的列名
    :param search_str: 要查找的字符串
    :return: 新的DataFrame
    """
    # 查找指定列中是否存在指定的字符串
    try:

        df[col_name] = df[col_name].astype(str)
        mask = df[col_name].str.contains(search_str)
    except:
        print(f"列中不支持的数据类型 {col_name}.")
        return None
    if not mask.any():
        print(f"找不到的匹配行 {search_str} in column {col_name}.")
        return None
    # 获取第一个匹配行的索引
    match_idx = mask.idxmax()
    # 将匹配行作为表头，并重置索引
    new_df = pd.DataFrame(df.loc[match_idx]).transpose()
    new_df.columns = df.columns
    new_df = pd.concat([new_df, df.loc[match_idx+1:].reset_index(drop=True)])
    print(new_df)
    return new_df

根据列表头查找 两个字符串，并将中间的数据生成新的dataFrame

需要修改完善 ，！！！！！！！！！！！！！！！！！！！！！！！！！
根据指定列 查找两个字符串，查找到第一个字符串后，将该字符传作为表头， 再查找第二个字符串，并将两个字符串中间的数据
作为新的df 数据进行保存

def search_and_rearrange(df, col_name, search_str1, search_str2):
    """
    根据指定列的值查找并重组DataFrame
    :param df: 要处理的DataFrame
    :param col_name: 要查找的列名
    :param search_str1: 要查找的第一个字符串
    :param search_str2: 要查找的第二个字符串
    :return: 新的DataFrame
    """
    # 查找指定列中是否存在指定的字符串
    try:
        df[col_name] = df[col_name].astype(str)
        mask1 = df[col_name].str.contains(search_str1)
        mask2 = df[col_name].str.contains(search_str2)
    except:
        print(f"Unsupported data type in column {col_name}.")
        return None
    if not mask1.any() or not mask2.any():
        print(f"No matching row found for {search_str1} or {search_str2} in column {col_name}.")
        return None
    # 获取两个匹配行的索引
    match_idx1 = mask1.idxmax()
    match_idx2 = mask2.idxmax()
    # 将两个匹配行之间的行作为新的DataFrame
    new_df = df.loc[match_idx1+1:match_idx2-1].reset_index(drop=True)
    # 将第一个匹配行作为表头
    new_df.columns = df.loc[match_idx1]
    new_df = new_df.iloc[1:]
    print(new_df)
    return new_df

根据a_df中的filter_header和b_df中的filter_header选择b_header1和b_header2列，将b_df的行和a_df的行合并到一起形成一个新的DataFrame。
如果b_header2不为空，则将b_df的行和b_header2的行合并到一起形成一个新的DataFrame。
合并的行应该遵循a_df中的filter_header和b_df中的filter_header的顺序。
如果a_df和b_df都不存在于此数据集中，则返回一个空的DataFrame。

def merge_dataframes(a_df, b_df,a_filter_header,b_filter_header,b_header1,b_header2=None):
    '''
    根据a_df中的filter_header和b_df中的filter_header选择b_header1和b_header2列，将b_df的行和a_df的行合并到一起形成一个新的DataFrame。
    如果b_header2不为空，则将b_df的行和b_header2的行合并到一起形成一个新的DataFrame。
    合并的行应该遵循a_df中的filter_header和b_df中的filter_header的顺序。
    如果a_df和b_df都不存在于此数据集中，则返回一个空的DataFrame。
    :param a_df:
    :param b_df:
    :param a_filter_header: str  a数据表筛选表头
    :param b_filter_header: str  b数据表筛选表头
    :param b_header1: str   b_header1是第一个列名称
    :param b_header2: str   b_header2是第二个列名称
    :return: 筛选后，合并的数据
    '''

    # 将b_df中的b_filter_header列转为字符串
    a_df[a_filter_header] = a_df[a_filter_header].astype(str)

    # 将b_df中的b_filter_header列转为字符串
    b_df[b_filter_header] = b_df[b_filter_header].astype(str)

    # 遍历 a 的每一行，将 b 中对应行的公司信息写入到 a 中
    for index, row in a_df.iterrows():
        code = row[a_filter_header]
        # 根据期权交易编码在 b 中进行筛选
        b_row = b_df[b_df[b_filter_header] == code]
        if not b_row.empty:
            # 如果找到了对应的行，则将对应的公司名称和公司简称写入到 a 中
            a_df.at[index, b_header1] = b_row[b_header1].values[0]
            if b_header2 is not None:
                a_df.at[index, b_header2] = b_row[b_header2].values[0]
    return a_df

创建一个新的dataframe 表格以df_new_zc数据表头为准

b_dataframe = pd.DataFrame(columns=df_new_zc.columns)

筛选并追加写写入新的数据表dataframe

def append_data(a_dataframe, b_dataframe,a_column_name,sortb):
    '''
    根据关键字筛选a_dataframe指定列的内容，筛选后将数据进行读取，追加写入b_dataframe
    :param a_dataframe: 源数据表
    :param b_dataframe: 追加写入的新数据表
    :param a_column_name: a_dataframe的列名
    :param sortb: sortb，需要筛选的字段
    :return: 
    '''
    # 对 a_dataframe 进行数据筛选，得到需要追加到 b_dataframe 中的数据
    selected_data = a_dataframe[a_dataframe[a_column_name] == sortb]
    # 使用 concat() 函数将 selected_data 追加到 b_dataframe 中
    b_dataframe = pd.concat([b_dataframe, selected_data])
    # 使用 reset_index() 函数重置 b_dataframe 的行索引，以保持连续性
    b_dataframe.reset_index(drop=True, inplace=True)
    # 返回 b_dataframe
    print(b_dataframe)
    return b_dataframe

判断dataframe是否包含某个类型 复制并添加

判断dataframe的品种名称里面是否包含花和菜，如果包含菜，就拷贝第一行数据，添加到菜上面
并将拷贝的品种名称改为苹，如果包含花就拷贝到花的上面，如果菜和花都没有，就拷贝到最后一行

  if '菜' in df_screen_to_word1['品种名称'].values:
      idx = df_screen_to_word1[df_screen_to_word1['品种名称'] == '菜'].index[0]
  elif '花' in df_screen_to_word1['品种名称'].values:
      idx = df_screen_to_word1[df_screen_to_word1['品种名称'] == '花'].index[0]
  else:
      idx = df_screen_to_word1.index[-1]
  # 复制数据到菜油的上面或花生的上面
  new_row = df_screen_to_word1.loc[idx].copy()
  new_row['品种名称'] = '苹'
  df_screen_to_word1 = pd.concat(
      [df_screen_to_word1.loc[:idx - 1], pd.DataFrame([new_row]), df_screen_to_word1.loc[idx:]]).reset_index(
      drop=True)

判断某列里面数据是否完全一致

使用pandas库中的value_counts方法来计算某一列中每个元素出现的次数。如果结果中只有一个元素，说明该列完全一致，否则说明该列不完全一致。如果该列不完全一致，可以使用groupby方法按照该列的值进行分类，并进行进一步的筛选。

import pandas as pd

df = pd.read_excel('品种对照表.xlsx')
# 判断某一列是否完全一致
col_name = '品种名称'
if len(df[col_name].value_counts()) == 1:
    print("xx完全一致，正常发函")

else:
    # 按照该列的值进行分类
    grouped = df.groupby(col_name)
    for name, group in grouped:
        # 对每个分组进行进一步的筛选
        # ...
        print('xx列不一致',name)
        #按name再次进行筛选；筛选后进行发函，发函

转换日期格式 %Y年%m月

    desired_format = "%Y年%m月"  # 修改后的日期格式
    new_columns = []
    for col in merged_df.columns:
        # print(col)
        # print(col[0], type(col[0]))
        if isinstance(col[0], datetime.datetime):

            formatted_date = col[0].strftime(desired_format)
            # # print(formatted_date, type(formatted_date))
            col = (formatted_date,) + col[1:]  # 用修改后的字符串替换列名中的datetime.datetime对象
        new_columns.append(col)

    merged_df.columns = new_columns
    merged_df.columns = pd.MultiIndex.from_tuples(new_columns)

日期按 年月进行顺序排序

```python

def group_dates_by_month(dates):
‘’’
将日期列表根据月份进行分组
:param dates:日期数组字符串
:return:分组好的字典，key为年月，value为对应的日期列表
‘’’
grouped_dates = defaultdict(list)
for date in dates:
year = date[:4] # 提取年份部分
month = date[5:7] # 提取月份部分
year_month = year + “年” + month + “月” # 构建年月格式
grouped_dates[year_month].append(date)
return grouped_dates

```