头哥实践教学平台:实验十五 pandas数据处理https://pgedu.educoder.net/shixuns/tou9cyqi/challenges
文件可下载 https://share.weiyun.com/dZATr6nE

第1关数据准备:将txt文件转成Excel文件

它本来的超市销售数据如下:

由于我下载不了数据文件下来,所有我就复制了一部分数据下来,整理成了2个txt文件

saledata1.txt文件:

saledata2.txt文件:

现在需要做的是将两个txt文件合并在一起并转成一个Excel文件

import pandas as pd
import re

# Python TXT转换为Excel

def process_data_1(path):
    # 读取txt文件
    with open(path, 'r', encoding='utf-8') as file:
        lines = file.readlines()
    #处理数据 (按照空白字符切割)
    rawdata=[re.split(r'\s+',line.strip(),maxsplit=4) for line in lines]

    # 获取列名
    column_name=rawdata.pop(0)
    # 去除行索引列
    data=[x[1:] for x in rawdata]

    df=pd.DataFrame(data,columns=column_name)
    # 获取str对象,去掉左右两边的\t
    df['商品编码']=df['商品编码'].str.strip(r'\t')
    df['商品条码']=df['商品条码'].str.strip(r'\t')
    df['商品名称']=df['商品名称'].str.strip(r'\t')
    return df

def process_data_2(path):
    # 读取txt文件
    with open(path, 'r', encoding='utf-8') as file:
        lines = file.readlines()

    # 处理数据 (按照空白字符切割)
    rawdata = [re.split(r'\s+', line.strip()) for line in lines]

    # 获取列名
    column_name = rawdata.pop(0)
    # 去除行索引列
    data = [x[1:] for x in rawdata]
    df = pd.DataFrame(data, columns=column_name)
    return df

def write_excel(data):
    # 创建ExcelWriter对象(mode:文件模式,包括 w覆盖模式 和 a追加模式)
    excel_writer=pd.ExcelWriter('D:\\VS\\Python数据处理与编程\\saledata.xlsx',mode='w')
    # 将数据写入Excel文件(index参数设置为False表示不要写入行索引,header设置为True表示写入列名)
    data.to_excel(excel_writer=excel_writer,sheet_name='Sheet1',index=False,header=True)
    # 保存文件并关闭ExcelWriter对象
    excel_writer.save()

if __name__ == '__main__':
    path_1='D:\\VS\\Python数据处理与编程\\saledata1.txt'
    path_2='D:\\VS\\Python数据处理与编程\\saledata2.txt'
    data_1=process_data_1(path_1)
    data_2=process_data_2(path_2)
    # 拼接两个DataFrame
    data=pd.concat([data_1,data_2],axis=1)
    write_excel(data)

第1关:将超市销售Excel文件根据商品的类别筛选存储

任务描述

本关任务:
建立Excel文件"类别销售.xlsx",根据不同类别建立多个工作表,将相同类别的销售信息存放在相应的工作表中。
结果如下所示:

相关知识:

1. pd.read_excel()读取Excel文件

#从excel文件读入数据
pd.read_excel(filename,sheet_name=0,header=0,index_col=None,usecols=None,names=None,dtype=None)
#filename:指定excel文件的具体路径
#sheet_name:指定需要读取excel文件中的第几个sheet表格，默认的是工作簿中的第一个表格,既可以传递整数也可以传递具体的Sheet表格名称。可以同时读取多个表格的数据,如sheet_name=['sheet_name1','sheet_name2','sheet_name3'],返回的是一个字典,key为表格名称,value为相应的表格数据。如果读取工作簿中的所有表格，可以使用sheet_name=None。
# header：指定某一行作为表头。header=0 这是默认值，使用表格的第一行作为表头；header=None 针对没有表头的表，重新设置列索引；header=1指定第二行作为表头；
#index_col:指定哪些列用作数据框的行索引（设置行索引）
# names:重新设置列索引的名称，针对没有表头的数据可以使用，一般情况下用不到。
# dtypes:通过字典的形式，指定某些列需要转换的数据类型,dtype={'列名':'类型'}
#  usecols：指读取表格中的某些列,注意:不论读取几列，都要用方括号列表的形式,如usecols=['列名1']。或者用列标直接指定区域范围,如usecols='A:C',包括C列。
# nrows:指定读取前多少行，通常用于较大的数据文件中，默认None。
# skiprows：是指跳过指定的行。skiprows=1 跳过第1行。skiprows=[2,4,8] 跳过第2，4，8行。skiprows=lambda x:x%2==0，跳过偶数行，保留奇数行。

2. DataFrame.to_excel() 向excel文件写入数据

#向excel文件写入数据
DataFrame.to_excel(excel_writer, sheet_name='Sheet1', na_rep='',
 float_format=None, columns=None, header=True, index=True, 
 index_label=None, encoding=None)
# excel_writer : 文件路径或现有的ExcelWriter
#sheet_name :字符串,表的名称。默认“Sheet1”
#na_rep : 字符串,默认‘’,缺失数据表示方式
#float_format : 字符串,默认None。格式化浮点数的字符串。例如 float_format="%.2f" 会将 0.1234 格式化为 0.12。
#columns :  要写入excel中的列。list。一般默认None，即全部写入。
#header : 布尔或字符串列表，默认为True(表示写入列名)。如果给定字符串列表，则它是列名。
#index :默认为True写入行索引,index参数设置为False表示不要写入行索引
#index_label=None, 要写入excel中的index列。
#startrow=0, #从哪一行开始写入数据。默认为0，即第一行。
#startcol=0, #从哪一列开始写入数据。默认为0，即第一列。
注意：通过ExcelWriter写入后要同执行save()保存。

3. unique()唯一值函数

#唯一值函数
unique()是以数组形式返回列的所有唯一值

Examples
        --------
        >>> pd.Series([2, 1, 3, 3], name='A').unique()
        array([2, 1, 3])
        >>> pd.unique(pd.Series([2, 1, 3, 3]))
    	array([2, 1, 3])

4. 使用 loc 和 iloc 选择数据

#筛选数据
Pandas的.loc参数可以对多列数据进行筛选

• loc(用于标签) 是 location 的意思,逗号前面为行,逗号后面为列。
• iloc(用于整数) 中 i 的意思是指 integer,所以它只接受整数索引。

类型	描述
df.loc[val]	根据标签选择DataFrame的单行或多行
df.loc[:,val]	根据标签选择单列或多列
df.loc[val1,val2]	选择val1行中的val2列部分
df.iloc[where]	根据整数位置选择单行或多行
df.iloc[:,where]	根据整数位置选择单列或多列
df.iloc[where_i,where_j]	根据整数位置选择行和列

Examples
        --------

        >>> df = pd.DataFrame([[1, 2], [4, 5], [7, 8]],
        ...      index=['cobra', 'viper', 'sidewinder'],
        ...      columns=['max_speed', 'shield'])
        >>> df
                    max_speed  shield
        cobra               1       2
        viper               4       5
        sidewinder          7       8
        
        #Boolean list with the same length as the row axis长度与行轴相同的布尔列表
        >>> df.loc[[False, False, True]]
                    max_speed  shield
        sidewinder          7       8
        
        #Conditional that returns a boolean Series
        >>> df.loc[df['shield'] > 6]
                    max_speed  shield
        sidewinder          7       8

本关代码

import pandas as pd

df = pd.read_excel("D:\\VS\\Python数据处理与编程\\saledata.xlsx", dtype={'商品编码': str, '商品条码': str})
writer = pd.ExcelWriter("D:\\VS\\Python数据处理与编程\\类别销售.xlsx")
# unique()是以数组形式返回列的所有唯一值
categories = df['类别'].unique()
# categories =pd.unique(df['类别'])
print(categories)
for x in categories:
    # 筛选数据
    data = df.loc[df['类别'] == x]
    # 删除 '类别' 一列
    result=data.drop('类别',axis=1)
    # 保存多个DataFrame到同一个Excel文件的不同工作表中
    result.to_excel(writer,sheet_name=x,index=False,header=True)
writer.save()

第2关数据准备

我使用了DataFrame.sample()函数随机抽取了一些数据,并复制了下来,整理成了txt文件: 银行信息.txt

DataFrame.sample()

def sample(
        n: int | None = None,  # 指定随机抽取的样本数目(行数或者列数),默认随机抽取一行数据
        frac: float | None = None, #设置抽样比例,指定随机抽取行或列的比例
        replace: bool_t = False, #设置是否进行有放回抽样,False表示执行不放回抽样,True表示执行有放回抽样(允许对同一行/列数据进行多次抽取),默认为False
        weights=None, #设置样本权重。默认值是None(每个样本的权重相等),表示此时执行等概率抽样,也就是说每一行或每一列被抽到的概率是相等的。权重越大表示该行数据或该列数据被抽到的概率越大。可以给weights参数传递两种类型的数据:str类型和Series类型。str类型只能在执行行抽样时使用,str要求是DataFrame中的一个列名。
        random_state: RandomState | None = None, #随机数种子,使用相同的随机数种子,会得到相同的结果
        axis: Axis | None = None, #指定沿着哪个轴进行抽样。当axis指定为0或者'index'时,沿着行方向进行抽样;当axis指定为1或者'columns'时,沿着列方向进行抽样。默认执行的是行抽样。
        ignore_index: bool_t = False, #是否忽略原DataFrame的索引。如果为True，则生成的索引将标记为0，1，…，n-1。
)

将银行信息.txt文件转成Excel文件

import pandas as pd
import re

# Python TXT转换为Excel

def process_data(path):
    # 读取txt文件
    with open(path, 'r', encoding='utf-8') as file:
        lines = file.readlines()

    #处理数据 (按照空白字符切割)
    rawdata=[re.split(r'\s+',line.strip()) for line in lines]

    # 获取列名
    column_name=rawdata.pop(0)
    # 去除行索引列
    data=[x[1:] for x in rawdata]

    df=pd.DataFrame(data,columns=column_name)
    return df

def write_excel(data):
    # 创建ExcelWriter对象(mode:文件模式,包括 w覆盖模式 和 a追加模式)
    excel_writer=pd.ExcelWriter('D:\\VS\\Python数据处理与编程\\银行信息.xlsx',mode='w')
    # 将数据写入Excel文件(index参数设置为False表示不要写入行索引,header设置为True表示写入列名)
    data.to_excel(excel_writer=excel_writer,sheet_name='Sheet1',index=False,header=True)
    # 保存文件并关闭ExcelWriter对象
    excel_writer.save()

if __name__ == '__main__':
    path='D:\\VS\\Python数据处理与编程\\银行信息.txt'
    data=process_data(path)
    write_excel(data)

第2关：将银行信息excel文件按地区筛选存储

任务描述

本关任务:
编写一个将银行信息的excel文件筛选存储的小程序
银行分布excel文件如图所示:

请编写程序，在test文件夹下建立excel文件银行一线城市，将北京市、上海市、广州市、深圳市的银行编号、名称按银行编号从小到大的顺序放置到不同的excel工作表中

结果如下所示:

相关知识

DataFrame.sort_values()

# pandas中的sort_values()函数，可以将数据集依照某个字段中的数据进行排序。既可以根据列数据,也可根据行数据排序。指定by参数,即指定哪几行或哪几列;无法根据index和columns名排序。
DataFrame.sort_values(by, axis=0, ascending=True, inplace=False, kind='quicksort', na_position='last', ignore_index=False, key=None)

#by参数:str 或 str 列表,axis轴上的某个索引或索引列表。如根据哪一列或几列数据进行排序。
#axis参数：要排序的轴,{0 或 ‘index’，1 或 ‘columns’}，默认 0。若axis=0 或 ‘index’,则按照指定列中数据大小排序;若axis=1 或 ‘columns’,则按照指定索引中数据大小排序(按行排序)。
# ascending参数:默认为True,即升序排序;False为降序排序。当ascending为一个布尔列表时,则是分别指定每个列的排序方式。
#inplace参数:是否改变原数据,默认为False，当inplace=True时，将直接在原数据上进行排序
# kind参数：{‘quicksort’, ‘mergesort’, ‘heapsort’, ‘stable’}，默认 ‘quicksort’,排序算法的选择。
# na_position参数 : {'first', 'last'}, 默认是 'last'。如果是'first',则将NaN放在开头(即NaN最小);如果是'last',则将NaN放在最后(即NaN最大)。
# key: 自定义排序规则。示例:按照x-2后的绝对值排序
#ignore_index参数:是否忽略原DataFrame的索引。如果为True，则生成的轴将标记为0，1，…，n-1。
>>> sr = pd.Series([0,1,-1,2,-2])
>>> sr.sort_values(key=lambda x:abs(x-2))
    3    2
    1    1
    0    0
    2   -1
    4   -2
    dtype: int64

本关代码

import pandas as pd

df = pd.read_excel("D:\\VS\\Python数据处理与编程\\银行信息.xlsx", dtype={"银行编号": str})
# 创建ExcelWriter对象
writer = pd.ExcelWriter("D:\\VS\\Python数据处理与编程\\银行一线城市.xlsx")

city_list = ['北京市', '上海市', '广州市', '深圳市']
for city in city_list:
    city_data = df.loc[df['城市'] == city, ['银行编号', '名称']]
    city_data.sort_values(by="银行编号",inplace=True,ignore_index=True)
    city_data.to_excel(writer,sheet_name=city,index=False,header=True)

# 保存文件并关闭ExcelWriter对象
writer.save()

第3关数据准备

同理: 将txt文件转成Excel文件

import pandas as pd
import re

# Python TXT转换为Excel

def process_data(path):
    # 读取txt文件
    with open(path, 'r', encoding='utf-8') as file:
        lines = file.readlines()

    #处理数据 (按照空白字符切割)
    rawdata=[re.split(r'\s+',line.strip()) for line in lines]
    # 获取列名
    column_name=rawdata.pop(0)
    column_name.insert(0,'index')
    df = pd.DataFrame(rawdata, columns=column_name)
    # 去除index列
    data=df[['年份','省份','GDP']]
    return data

def write_excel(data):
    # 创建ExcelWriter对象(mode:文件模式,包括 w覆盖模式 和 a追加模式)
    excel_writer=pd.ExcelWriter('D:\\VS\\Python数据处理与编程\\各省GDP.xlsx',mode='w')
    # 将数据写入Excel文件(index参数设置为False表示不要写入行索引,header设置为True表示写入列名)
    data.to_excel(excel_writer=excel_writer,sheet_name='Sheet1',index=False,header=True)
    # 保存文件并关闭ExcelWriter对象
    excel_writer.save()

if __name__ == '__main__':
    path='D:\\VS\\Python数据处理与编程\\各省GDP.txt'
    data=process_data(path)
    write_excel(data)

第3关：将gdpecxcel文件按年份筛选存储

任务描述

本关任务：
编写一个将GDP信息的excel文件筛选存储的小程序
各省GDPexcel文件如图所示

请编写程序，在test文件夹下建立excel文件GDP分年份，将2000-2016年每年建一个工作表，将该年各省的省份、GDP称按GDP从大到小的顺序放置。
注意：工作表的名称为字符形
结果如下所示:

本关代码

import pandas as pd

# 创建ExcelWriter对象
writer=pd.ExcelWriter("D:\\VS\\Python数据处理与编程\\GDP分年份.xlsx")
data=pd.read_excel("D:\\VS\\Python数据处理与编程\\各省GDP.xlsx",dtype={"年份":str})
for year in range(2000,2017):
    year_data=data.loc[data['年份']==str(year),['省份','GDP']]
    year_data.sort_values(by='GDP',ascending=False,inplace=True)
    # 将数据写入Excel文件(index参数设置为False表示不要写入行索引,header设置为True表示写入列名)
    year_data.to_excel(writer,sheet_name=str(year),index=False,header=True)

# 保存文件并关闭ExcelWriter对象
writer.save()

第4关：统计超市销售excel文件各类别和各日的数据，并将统计结果存入新的工作簿

任务描述

任务描述:
本关任务： 打开超市销售数据工作簿

使用excel建立一个统计数据工作簿，建立一个工作表类别统计，按合计金额降序显示不同类别销售金额的和。

建立一个工作表日期统计，按日期升序显示不同日期销售金额的和

相关知识

sort_index()

sort_index()函数，可以将DataFrame依照行索引或列标签进行排序
# axis参数:默认为0,即默认按照行索引进行排序
# ascending参数:是否为升序排列，默认为True，如果降序需要设定为False。
# inplace：是否替换原来的dataframe，默认为False。
......

多级索引MultiIndex

多级索引MultiIndex也叫分层索引。

在Pandas中创建多级索引的6种方式

1. pd.MultiIndex.from_arrays()

• arrays参数: list / sequence of array-likes,len(arrays)是级别的数量
• names参数: 列表或序列,每一级索引的名称

>>> arrays = [['Falcon', 'Falcon', 'Parrot', 'Parrot'],
...           ['Captive', 'Wild', 'Captive', 'Wild']]
	#创建多级索引
>>> index = pd.MultiIndex.from_arrays(arrays=arrays,names=('Animal', 'Type'))
>>> df = pd.DataFrame({'Max Speed': [390., 350., 30., 20.]},
...                   index=index)
>>> df
                Max Speed
Animal Type
Falcon Captive      390.0
       Wild         350.0
Parrot Captive       30.0
       Wild          20.0

2. pd.MultiIndex.from_tuples()

• tuples参数: list / sequence of tuple-likes
• names参数: 列表或序列,每一级索引的名称

#tuples = ((1, 'red'), (1, 'green'),(2, 'red'), (2, 'green'))
>>> tuples = [(1, 'red'), (1, 'green'),(2, 'red'), (2, 'green')]
>>> index=pd.MultiIndex.from_tuples(tuples=tuples, names=['number', 'color'])
>>> df = pd.DataFrame({'Max Speed': [390., 350., 30., 20.]},index=index)
>>> df
             Max Speed
number color           
1      red        390.0
       green      350.0
2      red         30.0
       green       20.0

3. pd.MultiIndex.from_product()

• iterables参数: 可迭代对象的列表或序列，根据多个可迭代对象的笛卡尔积（元素间的两两组合）进行创建索引。
• names参数: 列表或序列,每一级索引的名称

>>> numbers = [0, 1, 2]
>>> colors = ['green', 'red']
>>> index=pd.MultiIndex.from_product(iterables=[numbers, colors],names=['number', 'color'])
>>> index
MultiIndex([(0, 'green'),
            (0,   'red'),
            (1, 'green'),
            (1,   'red'),
            (2, 'green'),
            (2,   'red')],
           names=['number', 'color'])
>>> df = pd.DataFrame({'Max Speed': [390., 350., 30., 20.,190.,238.]},index=index)
>>> df
              Max Speed
number color           
0      green      390.0
       red        350.0
1      green       30.0
       red         20.0
2      green      190.0
       red        238.0

4. pd.MultiIndex.from_frame()

根据现有的DataFrame来直接生成多级索引

>>> df = pd.DataFrame([['HI', 'Temp'], ['HI', 'Precip'],['NJ', 'Temp'], ['NJ', 'Precip']],columns=['a', 'b'])
>>> df
    a       b
0  HI    Temp
1  HI  Precip
2  NJ    Temp
3  NJ  Precip
>>> index0=pd.MultiIndex.from_frame(df)
>>> index0
MultiIndex([('HI',   'Temp'),
            ('HI', 'Precip'),
            ('NJ',   'Temp'),
            ('NJ', 'Precip')],
           names=['a', 'b'])
>>> index1=pd.MultiIndex.from_frame(df=df, names=['state', 'observation'])
>>> index1
MultiIndex([('HI',   'Temp'),
            ('HI', 'Precip'),
            ('NJ',   'Temp'),
            ('NJ', 'Precip')],
           names=['state', 'observation'])

5. groupby()

通过数据分组统计生成多级索引

>>> df = pd.DataFrame({
    'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
    'B': ['one', 'one', 'two', 'three', 'two', 'one', 'two', 'three'],
    'C': [1, 3, 2, 5, 4, 3, 2, 1]
})
>>> df
     A      B  C
0  foo    one  1
1  bar    one  3
2  foo    two  2
3  bar  three  5
4  foo    two  4
5  bar    one  3
6  foo    two  2
7  foo  three  1
# 使用 groupby+sum 创建多级索引
>>> grouped = df.groupby(['A', 'B']).sum()
>>> grouped
           C
A   B       
bar one    6
    three  5
foo one    1
    three  1
    two    8

6. pivot_table()

通过生成透视表的方式来得到多级索引

数据透视表：透视表是将原有的DataFrame的列分别作为行索引和列索引，然后对指定的列应用聚合函数，是一种可以对数据动态排布并且分类汇总的表格格式。

#pd.pivot_table会生成一个类型为DataFrame的透视表
pd.pivot_table(data, values=None, index=None, columns=None, aggfunc='mean', 
               fill_value=None, margins=False, dropna=True, margins_name='All', observed=False, sort=True)
'''
data参数:要进行数据透视的DataFrame数据集。
values参数:要聚合的列，默认情况下对所有数值型变量聚合。
index参数:按照index分组，可设置多个列，形成多级索引。
columns:可设置1到多个列,作为结果DataFrame的列索引。若设置1列,则该列的每个取值作为单独的1列;若设置多列,则会生成类似index的多层次字段。实现“长表”转化为“宽表”。
aggfunc: 对values进行计算，默认为np.mean。还可以以字典的方式,为不同的列分别设置不同的聚合函数。
fill_value:用来替换缺失值的值（在聚合后生成的数据透视表中）。
dropna:默认为True,意思为不包括条目全部为NaN的列，即一列的数据如果全部为NaN则被删除（在聚合后生成的数据透视表中）。
margins:是否添加行列的汇总,默认为False。True表示开启汇总行列的计算。不是简单的求和,而是与aggfunc的规则相同。
margins_name:自定义汇总行列的名称，默认为All。
sort: 布尔型，默认True. 是否将结果排序。自带的sort参数有时可能是没有效果的,可以使用sort_values函数来对结果进行排序。
'''

>>> df = pd.DataFrame({
    'Date': ['2021-01-02', '2021-01-02', '2021-01-01', '2021-01-02', '2021-01-01', '2021-01-01'],
    'Variable': ['A', 'C', 'B', 'B', 'C', 'A'],
    'Value': [10, 20, 15, 25, 30,np.nan]
})
# 创建多级索引的透视表
>>> pivot_table = pd.pivot_table(data=df, values='Value', index=['Date', 'Variable'], columns='Date', aggfunc=min,margins=True)
# 显示透视表
>>> pivot_table
Date      2021-01-01  2021-01-02   All
Variable                              
A                NaN        10.0  10.0
B               15.0        25.0  15.0
C               30.0        20.0  20.0
All             15.0        10.0  10.0

1. DataFrame有多级索引MultiIndex怎样筛选数据?
   在选择数据时:

• 元组(key1,key2)代表筛选多层索引,其中key1是索引第一级,key2是索引第二级。
• 列表[key1,key2]代表同一层的多个key,其中key1和key2是并列的同级索引。
• slice(None)代表筛选这一层索引的所有内容
• reset_index()可以把多层索引变成普通的列

>>> df = pd.DataFrame({
    'A': ['foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'foo'],
    'B': ['one', 'one', 'two', 'three', 'two', 'one', 'two', 'three'],
    'C': [1, 3, 2, 5, 4, 3, 2, 1]
})
>>> df
     A      B  C
0  foo    one  1
1  bar    one  3
2  foo    two  2
3  bar  three  5
4  foo    two  4
5  bar    one  3
6  foo    two  2
7  foo  three  1
# 使用 groupby+sum 创建多级索引
>>> grouped = df.groupby(['A', 'B']).sum()
>>> grouped
           C
A   B       
bar one    6
    three  5
foo one    1
    three  1
    two    8
>>> grouped.loc[(slice(None),'one'),:]
         C
A   B     
bar one  6
foo one  1
>>> grouped.reset_index(level=1,inplace=True)
>>> grouped
         B  C
A            
bar    one  6
bar  three  5
foo    one  1
foo  three  1
foo    two  8

DataFrame.reset_index()

#重置索引
DataFrame.reset_index(level=None, drop=False, inplace=False, col_level=0, col_fill='')
'''
level参数:int、str、元组或列表,指定要重置的索引名称或级别号。如果不指定,则默认重置所有索引级别,即将多层索引变成普通的列。若只传递一个级别的索引名称或级别号,则只将这一层索引变成普通的列。
drop参数:指定是否删除被重置的索引。如果设置为True,则会删除被重置的索引,即只重置索引,而不将其作为列插入。如果设置为False,则将被重置的索引作为一列保留下来,不删除。
inplace参数:是否在原来的dataframe上进行就地修改，默认为False,将修改后的DataFrame作为新的对象返回。
col_level参数: 如果列名(columns)有多个级别，决定被重置的索引将插入哪个级别，默认插入第一级
col_fill参数:如果列名(columns)有多个级别,决定其他级别如何命名。默认为'',若col_level=1,则将被重置的索引插入到''级别下,即''为第一层列索引,被重置的索引名为第二层列索引。如果为col_fill指定了不存在的级别,则会创建该级别。
'''
可以看看col_fill参数:https://www.cjavapy.com/article/763/

groupby()分组统计

先对数据分组,然后在每个分组上应用聚合函数、转换函数

Dataframe.groupby(by=None,axis=0,level=None,as_index=True,sort=True,group_keys=True,squeeze=False,observed=False)
"""
by参数:用于分组的数据列。
axis:默认值为0,{0 or 'index',1 or 'columns'},沿着行还是列拆分。
level:默认为None,针对index为MultiIndex的情况。根据哪一层索引进行分组。不要同时指定 by 和 level。该参数的用法可以看此链接:https://blog.csdn.net/qq_42067550/article/details/106290833
as_index参数:默认为True,返回分组标签(by的那列)作为索引;False表示不将分组标签作为索引,而是作为普通的列。
sort参数:分组后,是否根据by参数值进行排序。默认为True排序。
group_keys:布尔类型，默认为True,调用apply函数时，将分组键添加到索引以标识片段
dropna参数：是否将空值NaN删除,默认为True。若为True，且组键(by参数值)包含 NA 值时，则将删除 NA 值所在的行(沿行拆分)/列(沿列拆分)。若为 False，则 NA 值也将被视为组中的键。
返回值：DataFrameGroupBy,返回包含有关组的信息的groupby对象

"""

本关代码

from sklearn.utils import shuffle
import pandas as pd

# 创建ExcelWriter对象
writer=pd.ExcelWriter("D:\\VS\\Python数据处理与编程\\统计数据.xlsx")
data=pd.read_excel("D:\\VS\\Python数据处理与编程\\saledata.xlsx",dtype={'商品编码':str,'商品条码':str})

# 要查看DataFrame中每一列的数据类型,可以使用dtypes属性
print(data.dtypes)

df_categories=data.groupby(['类别'])['合计金额'].sum()
df_categories.sort_values(ascending=False,inplace=True)

df_date=data.groupby(['日期'])['合计金额'].sum()
# # 随机打乱DataFrame数据
# df_date=shuffle(df_date)
df_date.sort_index(inplace=True)

# 将数据写入Excel文件(index参数设置为True表示写入行索引,header设置为True表示写入列名)
df_categories.to_excel(writer,sheet_name='类别统计',index=True,header=True)
df_date.to_excel(writer,sheet_name='日期统计',index=True,header=True)

# 保存文件并关闭ExcelWriter对象
writer.save()

第5关：将超市销售excel文件分别存放在多个日期工作簿的不同类别工作表中

任务描述

本关任务：
超市销售数据如图所示 在xlscl/step3/rq文件夹下根据销售的日期建立不同的excel文件，

将同一类别的销售信息存放在excel文件的不同工作表中。

并建立类别统计工作表，显示该日各类别的合计金额的和，按合计金额的降序排列。

本关代码

import pandas as pd

df = pd.read_excel("D:\\VS\\Python数据处理与编程\\saledata.xlsx", dtype={"商品编码": str, "商品条码": str})
date_list = df["日期"].unique()
for date in date_list :
    # 删除日期中的-
    file_name = str(date).replace('-', '')
    # 创建ExcelWriter对象
    writer = pd.ExcelWriter('D:\\VS\\Python数据处理与编程\\result\\' + file_name + '.xlsx')

    df_date = df.loc[df["日期"] == date]
    types = df_date["类别"].unique()

    for type in types:
        df_type0 = df_date.loc[df["类别"] == type]
        df_type0.to_excel(writer, sheet_name=type,index=False)

    df_type1 = df_date.groupby(["类别"])["合计金额"].sum()
    df_type1.sort_values(ascending=False, inplace=True)
    df_type1.to_excel(writer, sheet_name="类别统计", index_label="类别")
    # 保存文件并关闭ExcelWriter对象
    writer.save()