精华内容
下载资源
问答
  • python对excel数据排序
    2020-11-22 19:29:45

    excel表数据如下

    要求实现:商品单价按降序排列,不值得买商品中哪件是最贵的

    1、商品单价按降序排列

    会用到pandas中的排序方法sort_values(),表示根据某一列排序。

    pd.sort_values(by="A",inplace=True)

    表示pd按照A这个字段排序,inplace默认为False,如果该值为True,那么就会在当前的dataframe上操作。

    ascending 默认等于True,按从小到大排列,改为False 按从大到小排。

    import pandas as pd

    stexcel=pd.read_excel('F:/Practice/py/practise_06.xlsx')

    stexcel.sort_values(by='单价',inplace=True,ascending=False)

    print(stexcel)

    2、不值得买商品中哪件是最贵的

    双重排序的话就要在by后边借一个list

    import pandas as pd

    stexcel=pd.read_excel('F:/Practice/py/practise_06.xlsx')

    stexcel.sort_values(by=['值得','单价'],inplace=True)

    print(stexcel)

    这样确定按照 是否值得排序的,但是单价没有按照降序的要求来排列。可以这样

    给ascending也加一个list 值得=True 单价=False,这样就得到了想要的数据。

    import pandas as pd

    stexcel=pd.read_excel('F:/Practice/py/practise_06.xlsx')

    stexcel.sort_values(by=['值得','单价'],inplace=True,ascending=[True,False])

    print(stexcel)

    更多相关内容
  • 使用python对excel数据处理

    千次阅读 2021-04-21 16:33:39
    其中xlrd在python3中建议使用1.2左右的版本,太高版本无法打开.xls文件,除了xlrd外openexcel也很好用(比如要设置边框线,要新建表,甚至插入特定大小的图片),如果只是对excel数据进行读取,pandas也是不错的选择...

    python数据处理基础请移步这篇博客,写的非常好
    https://blog.csdn.net/weixin_42641395/article/details/87987802

    首先说明目前python处理excel有多个模块可以使用,其中xlrd在python3中建议使用1.2左右的版本,太高版本无法打开.xls文件,除了xlrd外openexcel也很好用(比如要设置边框线,要新建表,甚至插入特定大小的图片),如果只是对excel数据进行读取,pandas也是不错的选择。

    这个是个人的excel读取的代码,把excel读取为个dict.
    readexcel_todict(file_str,None,1,0)
    参数分别是路径,dict中key的行(excel中任意可以作为key的行号,None就使用默认的key),后面是excel读取起始的行和sheet表编号

    import xlrd
    import collections
    def readexcel_todict(addr_str,key_num,begin_num,sheetnum):
        excel_workbook = xlrd.open_workbook(addr_str)
        excel_sheet01 = excel_workbook.sheets()[sheetnum]
        terminal_num_nrows = excel_sheet01.nrows
        terminal_num_ncols = excel_sheet01.ncols
        excel_dict = {}
        if isorder:
            excel_dict = collections.OrderedDict()
    
        if key_num == None:
            tempnum = 0
    
        for r in range(begin_num,terminal_num_nrows):
            if key_num == None:
                tempnum = tempnum + 1
                key_str = tempnum
            else:
                key_str = excel_sheet01.cell(r,key_num).value
            if type(key_str) is float:
                key_str = str(int(key_str))
            if check_is_nums(key_str):
                #print key_str + "123"
                key_str = str(key_str)
            hold = []
            #print int(key_str)
            for c in range(0,terminal_num_ncols):
                if type(excel_sheet01.cell(r,c).value) is float:
                    hold.append(str(int(excel_sheet01.cell(r,c).value)))
                else:
                    hold.append(excel_sheet01.cell(r,c).value)
            # 存入字典中
            excel_dict[key_str] =  hold
    
        return excel_dict
    
    def check_is_nums(str_check):
        isnum = True
        if type(str_check) == int:
            return str_check
        for key in str_check:
            if u'\u0030'<=key<=u'\u0039':
                pass
            else:
                isnum = False
                return isnum
    
        if str_check == "":
            isnum = False
        return isnum
    
    
    from excels_to_list.leotool.readexcel import readexcel_todict
    import re
    import copy
    from xpinyin import Pinyin
    file_str = r'XXX管护员.xlsx'
    #分割自然村
    def split_zrc():
        show_dict = readexcel_todict(file_str,None,1,0)
        show_out_list = []
        for key in show_dict:
            # 检验特殊字符
            # res = r"""!?。"$%&'()*+-/:;<=>@[\]^_`{|}~⦅⦆「」、〃》「」『』【】〔〕〖〗〘〙〚〛〜〝〞〟〰〾〿–—‘'‛“”„‟…‧﹏。。."""
            # re_punctuation = "[{}]+".format(res)
            # if len(re.compile(re_punctuation).findall(show_dict[key][2])) > 0:
            #     print(show_dict[key])
    
            # 根据标点进行拆分
            # ,|。|?正确的符号
            # ,|,|。|.错误的符号  总结是结尾要是问号
            split_list = re.split(',|。|,|\.|、',show_dict[key][2].strip())
            print(split_list)
            if len(split_list)>1:
                for split_str in split_list:
                    if split_str == "":
                        continue
                    if split_str.isnumeric():
                        split_str = split_str + '组'
                    show_dict[key][2] = split_str
                    temp_copy_list = copy.copy(show_dict[key])
                    show_out_list.append(temp_copy_list)
            else:
                show_dict[key][2] = split_list[0].strip()
                show_out_list.append(show_dict[key])
        import pandas as pd
        import numpy as np
        # data = np.arange(1,101).reshape((10,10))
        data_df = pd.DataFrame(show_out_list)
        writer = pd.ExcelWriter('zrc-formate.xlsx')
        data_df.to_excel(writer, float_format='%.5f')
        writer.save()
    

    ``
    读取excel数据库后,对数据进行处理,最后使用pandas重新创建个处理后的excel,一般要实现在原excel进行修改比较困难,能进行修改也是需要创建一个新的工作空间,然后整体写入。

    这里面使用正则表达式匹配特殊字符保证excel里面不会有特殊字符整出什么幺蛾子,re.split 使用后面多个分割字符对str进行分割。

    这里不得不说,pandas使用list生成excel真的非常好用方便

    # 去除excel里面各种格式
    def formate_tb2():
        show_dict = readexcel_todict(r'tb_2.xlsx',None,1,0)
        show_out_list = []
        for key in show_dict:
            for nums in range(len(show_dict[key])):
                check_str = show_dict[key][nums].strip().replace("\n", "")
                show_dict[key][nums] = check_str
    
            show_out_list.append(show_dict[key])
        import pandas as pd
        data_df = pd.DataFrame(show_out_list)
        writer = pd.ExcelWriter('tb_2_new.xlsx')
        data_df.to_excel(writer, float_format='%.7f')
        writer.save()
    

    这里是去除表格里面某些字段中带的换行符,同理,配合正则查询字符,可以去除各种指定特殊字符

    展开全文
  • Python处理Excel数据的方法

    千次阅读 多人点赞 2022-02-17 00:23:03
    当Excel中有大量需要进行处理的数据时,使用Python不失为一种便捷易学的方法。接下来,本文将详细介绍多种Python方法来处理Excel数据


    当Excel中有大量需要进行处理的数据时,使用Python不失为一种便捷易学的方法。接下来,本文将详细介绍多种Python方法来处理Excel数据。

    Excel处理经常用于数据可视化,那么如何利用提取到的Excel数据绘图呢?

    本文搭配Python绘图 \ 数据可视化一起使用效果更佳。

    电子表格格式

    我们在日常工作中常常见到各种后缀的电子表格,例如最常见的xlsx以及较为常见的csv、xls等格式的表格。同样是电子表格,它们之间有什么区别吗?

    xls为Excel早期表格格式。

    xls格式是Excel2003版本及其以前版本所生成的文件格式。 其最大的特点就是:仅有65536行、256列。因此规模过大的数据不可以使用xls格式读写。

    xlsx为Excel2007及其之后的表格格式,也是现在Excel表格的主流格式。

    与xls相比,它可以存储1048576行、16384列数据,存储相同数据,xlsx格式要比xls格式文件要小得很多。

    CSV为逗号分隔值文件。

    CSV逗号分隔值文件格式,其以纯文本形式存储表格数据(数字和文本),可以用Excel软件打开。

    xlrd模块既可读取xls文件也可读取xlsx文件;xlwt只可写xlsx文件;openpyxl可以读写xlsx文件;pandas可以同时读写xls、xlsx文件。

    1.使用 xlrd 来处理;

    xlrd命令

    import xlrd
    book = xlrd.open_workbook('excelFile.xlsx')  # 获取工作簿对象
    names = book.sheet_names()  # 获取所有工作表名称结果为列表
    
    mySheets = book.sheets()                 # 获取工作表list。
    sheet = mySheets[0]                    # 通过索引顺序获取。
    sheet = book.sheet_by_index(0)         # 通过索引顺序获取。
    sheet = book.sheet_by_name(u'Sheet1')  # 通过名称获取 u表示后面字符串以 Unicode 格式 进行编码,一般用在中文字符串前面,以防乱码
    
    # 获取行数和列数
    nrows = sheet.nrows
    ncols = sheet.ncols
    
    # 获取一行和一列
    row = sheet.row_values(i)               # i是行数,从0开始计数,返回list对象。
    col = sheet.col_values(i)               # i是列数,从0开始计数,返回list对象。
    
    # 读取单元格数据
    cell = sheet.cell_value(i, j)      # 直接获取单元格数据,i是行数,j是列数,行数和列数都是从0开始计数。
    cell = sheet.cell(i,j).value    
    

    示例1:Python读取Excel文件特定数据

    import xlrd
    data = xlrd.open_workbook('excelFile.xlsx') # 打开xlsx文件
    table = data.sheets()[0] # 打开第一张表
    nrows = table.nrows # 获取表的行数
    
    # 循环逐行输出
    for i in range(nrows):
       if i == 0: # 跳过第一行
           continue
       print(table.row_values(i)[:5]) # 取前五列数据
    

    示例2:Python读取Excel文件所有数据

    import xlrd
    
    workbook = xlrd.open_workbook('excelFile.xlsx')  # 打开一个xlsx文件
    worksheets = workbook.sheet_names()  # 抓取所有sheet页的名称
    print('worksheets is %s' %worksheets)
    worksheet1 = workbook.sheet_by_name(u'Sheet1')  # 如果存在sheet1文件则定位到sheet1
    
    
    """
    #遍历所有sheet对象
    for worksheet_name in worksheets:
    	worksheet = workbook.sheet_by_name(worksheet_name)
    """
    
    # 遍历sheet1中所有行row
    num_rows = worksheet1.nrows
    for curr_row in range(num_rows):
        row = worksheet1.row_values(curr_row)
        print('row%s is %s' %(curr_row,row))
    
    # 遍历sheet1中所有列col
    num_cols = worksheet1.ncols
    for curr_col in range(num_cols):
    	col = worksheet1.col_values(curr_col)
            print('col%s is %s' %(curr_col,col))
    
    # 遍历sheet1中所有单元格cell
    for rown in range(num_rows):
    	for coln in range(num_cols):
    		cell = worksheet1.cell_value(rown,coln)
    		print(cell)
    

    2.使用 xlwt 来处理;

    使用xlwt模块写入Excel文件

    xlwt模块只能写xls文件,不能写xlsx文件(写xlsx程序不会报错,但最后文件无法直接打开,会报错)。

    默认保存在py文件相同路径下,如果该路径下有相同文件,会被新创建的文件覆盖。

    import xlwt
    
    myWorkbook = xlwt.Workbook()  # 创建Excel工作薄 若要写入中文则添加参数encoding = 'utf-8'
    
    sheet = myWorkbook.add_sheet('New_Sheet')  # 创建Excel工作表
    
    ##sheet.write(m,n,'内容1') # 向单元格写入内容
    myStyle = xlwt.easyxf('font: name Times New Roman, color-index red, bold on', num_format_str='#,##0.00')   # 数据格式
    sheet.write(1, 1, 2022, myStyle)
    sheet.write(2, 0, 1)                          # 写入A3,数值等于1
    sheet.write(2, 1, 1)                          # 写入B3,数值等于1
    sheet.write(2, 2, xlwt.Formula("A3+B3"))      # 写入C3,数值等于2(A3+B3),xlwt支持写入公式
    
    # 保存
    myWorkbook.save('excelFile.xls')
    

    示例:新建excel文件并写入数据

    import xlwt
    # 创建workbook和sheet对象
    workbook = xlwt.Workbook() # 注意Workbook的开头W要大写
    sheet1 = workbook.add_sheet('sheet1',cell_overwrite_ok=True)
    sheet2 = workbook.add_sheet('sheet2',cell_overwrite_ok=True)
    
    # 向sheet页中写入数据
    sheet1.write(0,0,'sheet1')
    sheet1.write(0,1,'sheet1_content')
    sheet2.write(0,0,'sheet2')
    sheet2.write(1,2,'sheet2_content')
    
    # 保存该excel文件,有同名文件时直接覆盖
    workbook.save('test.xls')
    print('创建excel文件完成!')
    

    3.使用 openpyxl 来处理;

    openpyxl可以对excel文件进行读写操作

    openpyxl模块可实现对excel文件的读、写和修改,只能处理xlsx文件,不能处理xls文件。

    from openpyxl import Workbook
    from openpyxl import load_workbook
    from openpyxl.writer.excel import ExcelWriter
    
    wb = load_workbook(u"成绩单.xlsx")
    
    sheetnames = wb.sheetnames # 获得表单名字 
    print(sheetnames)
    
    title = sheet1.title  # 获取工作表名称
    rows = sheet1.max_row  # 获取工作表行数
    cols = sheet1.max_column  # 获取工作表列数
    
    sheet = wb[sheetnames[0]]
    print(sheet.cell(row=3,column=3).value)
    
    sheet['A1'] = 'grade'
    wb.save(u"成绩单_new.xlsx")  # 修改元素值并另存为xlsx文件
    
    sheet = wb.active  # 获取活动表
    print(sheet)
    print(sheet.dimensions)     # 获取表格的尺寸大小
    
    cell1 = sheet['B7']         # 获取B7单元格的数据
    print(cell1.value)  # cell1.value获取单元格B7中的值
    
    print(sheet['a2'].value)   # 使用excel单元格的表示法,字母不区分大小写 获取第2行第1列的数据
    
    print(cell.value, cell.row, cell.column, cell.coordinate)  # 获取某个格子的行数、列数以及坐标
    
    cell = sheet['A1:A5']  # 使用sheet['A1:A5']获取A1到A5的数据
    ##print(cell)
    # 打印A1到A5的数据
    for i in cell:
        for j in i:
            print(j.value)
    
    # openpyxl读取excel文件
    
    book = openpyxl.Workbook()  # 创建工作簿 如果写入中文为乱码,可添加参数encoding = 'utf-8'
    sheet = book.create_sheet('Sheet_name',0)  # 创建工作表,0表示创建的工作表在工作薄最前面
    sheet.cell(m,n,'content1')  # 向单元格写入内容:
    book.save('excelFile')  # 保存工作簿,默认保存在py文件相同路径下,如果该路径下有相同文件,会被新创建的文件覆盖。
    
    # openpyxl修改excel文件
    
    sheet.insert_rows(m)和sheet.insert_cols(n)分别表示在第m行、第n列前面插入行、列
    sheet.delete_rows(m)和sheet.delete_cols(n)分别表示删除第m行、第n列
    修改单元格内容:sheet.cell(m,n) = '内容1'或者sheet['B3'] = '内容2' 
    在最后追加行:sheet.append(可迭代对象)
    

    4.使用Pandas库来处理excel数据

    Pandas 可以从各种文件格式比如 CSV、JSON、SQL、Microsoft Excel 导入数据。

    import pandas as pd
    
    mydata = {
      'sites': ["SZ", "BJ", "SS"],
      'number': [1, 2, 3]
    }
    
    myvar = pd.DataFrame(mydata)
    print(myvar)
    
    '''
    output:
      sites  number
    0    SZ       1
    1    BJ       2
    2    SS       3
    '''
    
    import pandas as pd
    
    file_path = r'example.xlsx'
    df = pd.read_excel(file_path, sheet_name = "test") # sheet_name不指定时默认返回全表数据
    
    print(df)  # 打印表数据,如果数据太多,会略去中间部分
    
    print(df.head())  # 打印头部数据,仅查看数据示例时常用
    
    print(df.columns)  # 打印列标题
    
    print(df.index)  # 打印行
    
    print(df["ave"])   # 打印指定列
    
    # 描述数据
    print(df.describe())
    

    写excel

    from pandas import DataFrame
    
    data = { 'name': ['zs', 'ls', 'ww'], 'age': [11, 12, 13], 'gender': ['man', 'man', 'woman']}
    df = DataFrame(data)
    df.to_excel('new.xlsx')
    

    修改excel–以修改原Excel文件中gender列数据为例,把girl修改为female,boy修改为male:

    import pandas as pd
    from pandas import DataFrame
    
    file_path = r'test.xlsx'
    df = pd.read_excel(file_path)
    
    df['gender'][df['gender'] == 'girl'] = 'female'
    df['gender'][df['gender'] == 'boy'] = 'male'
    
    print(df)
    
    DataFrame(df).to_excel(file_path, sheet_name='Sheet1', index=False, header=True)
    
    df.loc[row_index] = [val1, val2, val3]  # 新增行
    df[colo_name] = None  # 新增列
    

    示例1:读取excel数据

    # 导入pandas模块
    import pandas as pd
    
    # 直接默认读取到这个Excel的第一个表单
    sheet = pd.read_excel('test.xlsx')
    
    # 默认读取前5行数据
    data=sheet.head()
    print("获取到所有的值:\n{0}".format(data)) # 格式化输出
    
    # 也可以通过指定表单名来读取数据
    sheet2=pd.read_excel('test.xlsx',sheet_name='test')
    data2=sheet2.head() # 默认读取前5行数据
    print("获取到所有的值:\n{0}".format(data2)) # 格式化输出
    

    示例2:操作Excel中的行列

    # 导入pandas模块
    import pandas as pd
    sheet=pd.read_excel('test.xlsx')  # 这个会直接默认读取到这个Excel的第一个表单
    
    # 读取制定的某一行数据:
    data=sheet.loc[0].values   # 0表示第一行 这里读取数据并不包含表头
    print("读取指定行的数据:\n{0}".format(data))
    
    # 读取指定的多行:
    data2=sheet.loc[[0,1]].values
    print("读取指定行的数据:\n{0}".format(data2))
    
    # 获取行号输出:
    print("输出行号列表",sheet.index.values)
    
    # 获取列名输出:
    print("输出列标题",sheet.columns.values)
    

    其他

    当收到的文件既有xls,又有xlsx时,先转换为统一格式再做统计修改更方便。

    需要用到pywin32库,方法如下:

    import win32com.client as win32
    
    fname = r"C:\User\Desktop\test.xlsx"
    excel = win32.gencache.EnsureDispatch('Excel.Application')
    wb = excel.Workbooks.Open(fname)
    
    # wb.SaveAs(fname+"x", FileFormat = 51)    #FileFormat = 51 is for .xlsx extension
    wb.SaveAs(fname[:-1], FileFormat = 56)      #FileFormat = 56 is for .xls extension
    wb.Close()
    excel.Application.Quit()
    
    展开全文
  • 从零基础开始用Python处理Excel数据
  • EXCEL的数值排序功能还是挺强大的,升序、降序,尤其自定义排序,能够多个字段进行排序工作。 那么,在Python大法中,有没有这样强大的排序功能呢?答案是有的,而且本人觉得Python排序功能,一点不比EXCEL的差...
  • 利用Python对Excel数据进行处理

    万次阅读 多人点赞 2021-07-07 21:29:58
    通过本文,记录分享我利用Python对已存在的excel表格进行数据处理。 1.功能分析 1. 加载文件夹内所有的Excel数据; 2. 生产贡献度分析图表(以柱状图显示表格数据); 3.提起Excel表格中指定列数据; 4. 定向筛选...

    通过本文,记录分享我利用Python对已存在的excel表格进行数据处理。

    因为是没学可视化之前做的,所以都展示在后台上。

    1. 功能分析

    1.1加载文件夹内所有的Excel数据;

    1.2 生产贡献度分析图表(以柱状图显示表格数据);

    1.3提起Excel表格中指定列数据;

    1.4定向筛选所需数据;

    1.5多表数据统计排行;

    1.6多表数据合并新excel文件。

    2. 系统开发必备

    2.1 系统开发环境

    本系统的软件开发及运行环境具体如下:

    • 操作系统:Windows7、Windows10;
    • Python版本:Python3.9
    • 开发工具:Pycharm

    2.2 文件夹组织结构

    3.导库

    import os
    import xlrd2 #xlrd: 对Excel进行读相关操作
    import xlwt #xlwt: 对Excel进行写相关操作,且只能创建一个全新的Excel然后进行写入和保存。
    import numpy
    import matplotlib
    from prettytable import PrettyTable  #PrettyTable 是python中的一个第三方库,可用来生成美观的ASCII格式的表格
    from matplotlib import pyplot as plt
    

    4. 主函数设计

    Excel数据分析师的主函数main(),主要用于实现系统的主界面。在主函数main()中,首先调用get_files_name()函数获取文件名。

    get_files_name()函数代码如下:

    #导入文件
    def get_files_name():
        """
        用于获取文件名
        :return: 返回值为文件名组成的列表
        """
        file_list = os.listdir('./data')
        return file_list
    

    然后调用load_data()函数来读取excel文件并字典方式保存。

    #保存生产excel表
    def load_data(file_list):
        """
        用于读取指定的文件并保存至字典数据结构中
        :param file_list: 需要加载的文件列表
        :return: 保存了文件内容的字典
        """
        dictory = {}
        for file in file_list:
            # 获取表格文件
            book = xlrd2.open_workbook('./data/'+file)
            # 获取表格中的所有sheet
            names = book.sheet_names()
            # 获取第一个sheet
            sheet = book.sheet_by_index(0)
            # 获取当前表格的行数
            rows = sheet.nrows
            # 获取当前表格的列数
            cols = sheet.ncols
            # 获取表头文件,即表格第一行
            head = sheet.row_values(0)
            for row in range(rows-1):
                # 如果当前字典中没有该城市则创建一个
                if not sheet.cell_value(row+1, 0) in dictory.keys():
                    dictory[sheet.cell_value(row+1, 0)] = {}
                for col in range(cols-1):
                    dictory[sheet.cell_value(row+1, 0)][head[col+1]] = float(sheet.cell_value(row+1, col+1))
        return dictory

    接着调用menu()函数生成功能选择菜单。

    menu()函数代码如下:

    # 打印菜单
    def menu():
        print("  ----------Excel 数据分析师----------")
        print("{:<30}".format("  ==============功能菜单============== "))
        print("{:<30}".format("   1. 显示当前数据                     "))
        print("{:<30}".format("   2. 以柱状图展示当前数据              "))
        print("{:<30}".format("   3. 提起指定列                       "))
        print("{:<30}".format("   4. 定向筛选指定元素                       "))
        print("{:<30}".format("   5. 数据排行                         "))
        print("{:<30}".format("   6. 重新加载数据                      "))
        print("{:<30}".format("   7. 保存当前数据                      "))
        print("{:<30}".format("   0. 退出程序                          "))
        print("{:<30}".format(" ==================================== "))
        print("{:<30}".format(" 说明:输入相应数字后按下回车选择指定功能 "))
        print('\n')
    

    并且应用if语句控制各个子函数的调用,从而实现对Excel文件的选择,Excel数据的加载,选择、筛选、合并、排序和统计等功能。

    主函数完整代码如下:

    if __name__ == "__main__":
        # 导入文件
        files = get_files_name()
        data = {}
        print("当前data文件夹下的文件如下:")
        num = 1
        for file in files:
            print(num, file)
            num += 1
        while(1):
            index_str = input("请选择需要导入的文件序号(多个文件导入时用空格分开, 输入0则导入所有文件,输入多文件则自动合并):")
            index_list = index_str.split(' ')
            try:
                index_list.remove('')
            except:
                pass
            choice_file_list = []
            if index_list[0] == '0':
                choice_file_list = files
                break
            else:
                try:
                    for item in index_list:
                        choice_file_list.append(files[int(item)-1])
                except:
                    print("输入序号有误")
                    continue
            if choice_file_list:
                break
            else:
                print("输入序号有误")
        data = load_data(choice_file_list)
        print("导入数据成功\n")
        # 调用函数,打印菜单
        menu()
        while 1:
            choice = input("请选择指定功能:")
            if choice == '0':
                print("\n退出程序\n")
                exit()
            elif choice == '1':
                print("当前功能:显示当前数据")
                show_data(data)
                input('\n按下回车返回菜单')
                menu()
            elif choice == '2':
                print("当前功能:以柱状图显示数据")
                draw_plot(data)
                input('\n按下回车返回菜单')
                menu()
            elif choice == '3':
                print("当前功能:筛选指定列")
                keys = list(data[list(data.keys())[0]].keys())
                print("当前表格中的列如下:")
                num = 1
                for key in keys:
                    print(num, key)
                    num += 1
                choice_col_list = []
                while (1):
                    index_str = input("请选择需要筛选出的列序号(多列之间用空格分开,0代表所有列):")
                    index_list = index_str.split(' ')
                    try:
                        index_list.remove('')
                    except:
                        pass
                    choice_file_list = []
                    if index_list[0] == '0':
                        choice_col_list = keys
                        break
                    else:
                        try:
                            for item in index_list:
                                choice_col_list.append(keys[int(item) - 1])
                        except:
                            print("输入序号有误")
                            continue
                    if choice_col_list:
                        break
                    else:
                        print("输入序号有误")
                data = get_specified_cols(data, choice_col_list)
                print("筛选成功")
                input('\n按下回车返回菜单')
                menu()
            elif choice == '4':
                print("当前功能:筛选指定行")
                keys = list(data[list(data.keys())[0]].keys())
                print("当前表格中的列如下:")
                num = 1
                print(num, "城市")
                num += 1
                for key in keys:
                    print(num, key)
                    num += 1
                col = int(input("请输入需要进行筛选的数据所在的列:"))-2
                if col == -1:
                    col = '城市'
                else:
                    col = keys[col]
                op_list = ['<', '<=', '=', '>=', '>']
                print("比较操作符如下:")
                num = 1
                for op in op_list:
                    print(num, op)
                    num += 1
                operation = int(input("请输入比较操作符前的序号:"))-1
                operation = op_list[operation]
                value = input("请输入需要筛选的值:")
                data = get_specified_data(data, operation, col, value)
                print("筛选成功")
                input('\n按下回车返回菜单')
                menu()
            elif choice == '5':
                print("当前功能:数据排序")
                keys = list(data[list(data.keys())[0]].keys())
                print("当前表格中的列如下:")
                num = 1
                for key in keys:
                    print(num, key) #显示当前表格中的所有的列
                    num += 1
                col = int(input("请输入需要进行排序的数据所在的列:")) - 1
                col = keys[col]
                reverse = input("排序方式:\n1 从大到小排序\n2 从小到大排序\n")
                if reverse == '1':
                    data = sort_data(data, col, True)
                elif reverse == '2':
                    data = sort_data(data, col, False)
                else:
                    print("输入有误")
                input('\n按下回车返回菜单')
                menu()
            elif choice == '6':
                # 导入文件
                files = get_files_name()
                data = {}
                print("当前文件夹下的文件如下:")
                num = 1
                for file in files:
                    print(num, file)
                    num += 1
                while (1):
                    index_str = input("请选择需要导入的文件序号(多个文件导入时用空格分开, 输入0则导入所有文件,输入多文件则自动合并):")
                    index_list = index_str.split(' ')
                    try:
                        index_list.remove('')
                    except:
                        pass
                    choice_file_list = []
                    if index_list[0] == '0':
                        choice_file_list = files
                        break
                    else:
                        try:
                            for item in index_list:
                                choice_file_list.append(files[int(item) - 1])
                        except:
                            print("输入序号有误")
                            continue
                    if choice_file_list:
                        break
                    else:
                        print("输入序号有误")
                data = load_data(choice_file_list)
                print("导入数据成功\n")
                # 打印菜单
                menu()
            elif choice == '7':
                print("当前功能:保存数据")
                save(data)
                input('\n按下回车返回菜单')
                menu()
            else:
                print("请输入正确的数字")
                input('\n按下回车返回菜单')
                menu()

    5.模块设计

    5.1 加载文件夹内所有的Excel数据

    show_data()函数通过PrettyTable 库(PrettyTable 库是python中的一个第三方库,可用来生成美观的ASCII格式的表格)将之前保存的字典数据生成表格。

    #加载显示数据
    def show_data(dictory):
        try:
            keys = list(dictory[list(dictory.keys())[0]].keys())
        except:
            print("当前数据为空")
            return
        head = ['城市']
        head.extend(keys)
        table = PrettyTable(head)
        for key in dictory.keys():
            line = [key]
            for key_2 in keys:
                line.append(dictory[key][key_2])
            table.add_row(line)
        print(table)

    效果图如下:

    5.2生产贡献度分析图表(以柱状图显示表格数据)

    draw_plot( )函数使用了matplotlib库。通过atplotlib.rc( )来设置字体,通过plt.bar( )函数来绘制柱状图,通过plt.legend( )函数来给图添加图例。

    #制作图表
    def draw_plot(dictory):
        font = {'family': 'MicroSoft Yahei', 'weight': 'bold', 'size': 7}
        matplotlib.rc('font', **font) #设置中文字体
        # 定义三个颜色
        index = numpy.arange(len(dictory.keys()))
        color = [(256 / 256, 0 / 256, 0 / 256, 1),
                (0 / 256, 0 / 256, 256 / 256, 1),
                (0 / 256, 256 / 256, 0 / 256, 1),
                (0 / 256, 0 / 256, 0 / 256, 1)]
        first_key = list(dictory.keys())
        first_key = first_key[0]
        cols = list(dictory[first_key].keys())
        data = []
        for i in range(len(cols)):
            data.append([])
        for key in dictory.keys():
            for col in range(len(cols)):
                data[col].append(dictory[key][cols[col]])
        offset = -1/4
        for i in range(len(cols)):
            plt.bar(index+offset, data[i], color=color[i], width=1 / 5) #通过bar函数可以用柱状图来表达一些变量的统计分布
            offset += 1/4
        plt.xticks(index, dictory.keys())#表示刻度
        plt.legend(cols)#给图像加上图例
        plt.show()

    效果图如下:

    5.3提起Excel表格中指定列数据

    get_specified_cols()函数根据用户在菜单输入的列名,通过字典的索引筛选出列名,加载指定列的所有数据。

    #提起指定列
    def get_specified_cols(dictory, col_name_list):
        """
        筛选出指定的列
        :param dictory:原始字典
        :param col_name_list: 需要筛选出的列名,城市名默认出现
        :return: 筛选之后的字典
        """
        new_dict = {}
        for key in dictory.keys():
            new_dict[key] = {}
            for col_name in col_name_list:
                new_dict[key][col_name] = dictory[key][col_name]
        return new_dict
    

    效果图如下:

    5.4定向筛选所需数据

    get_specified_data()函数根据输入的操作符、列名以及指定的value进行筛选,比如筛选出人均GDP大于5000的,则operation =  ‘>’ ;col_name =  ‘人均GDP’ ; value = 500。

    def get_specified_data(dictory, operation, col_name, value):
        """
        根据输入的操作符、列名以及指定的value进行筛选,比如筛选出人均GDP大于5000的,则operation = '>', col_name = '人均GDP', value = 5000
        :param dictory: 原始数据
        :param operation: 操作符
        :param col_name: 需要比较的列
        :param value: 需要比较的值
        :return: 筛选之后的字典
        """
        new_dict = {}
        if col_name != "城市":
            for key in dictory.keys():
                # flag用于标记是否需要添加该行
                value = float(value)
                flag = 0
                if operation == '>':
                    if dictory[key][col_name] > value:
                        flag = 1
                elif operation == '>=':
                    if dictory[key][col_name] >= value:
                        flag = 1
                elif operation == '=':
                    if dictory[key][col_name] == value:
                        flag = 1
                elif operation == '<=':
                    if dictory[key][col_name] <= value:
                        flag = 1
                elif operation == '<':
                    if dictory[key][col_name] < value:
                        flag = 1
                else:
                    flag = 0
                if flag == 1:
                    new_dict[key] = {}
                    new_dict[key] = dictory[key]
        else:
            for key in dictory.keys():
                # flag用于标记是否需要添加该行
                flag = 0
                if operation == '>':
                    if key > value:
                        flag = 1
                elif operation == '>=':
                    if key >= value:
                        flag = 1
                elif operation == '=':
                    if key == value:
                        flag = 1
                elif operation == '<=':
                    if key <= value:
                        flag = 1
                elif operation == '<':
                    if key < value:
                        flag = 1
                else:
                    flag = 0
                if flag == 1:
                    new_dict[key] = {}
                    new_dict[key] = dictory[key]
        return new_dict

    效果图如下:

    5.5多表数据统计排行

    sort_data()函数根据key和reverse对数据进行排序。dictory: 传入的字典对象。
    key: 需要排序的关键字,即哪一列。reverse: 是否从大到小排序,false即为从小到大排序,最后return 返回数据。

    #数据排行
    def sort_data(dictory, key, reverse):
        """
        根据key和reverse对数据进行排序
        :param dictory: 传入的字典对象
        :param key: 需要排序的关键字,即那一列
        :param reverse: 是否从大到小排序,false即为从小到大排序
        :return:
        """
        data = dictory
        if not reverse:
            data = dict(sorted(data.items(), key=lambda d: d[1][key], reverse=False)) #字典的升序
        else:
            data = dict(sorted(data.items(), key=lambda d: d[1][key], reverse=True)) #字典的降序
        return data
    
    

    效果图如下:

    5.6多表数据合并生成新excel文件

    该功能在主函数中实现并调用save()函数保存合并后的数据并生成新的excel文件。

    while(1):
            index_str = input("请选择需要导入的文件序号(多个文件导入时用空格分开, 输入0则导入所有文件,输入多文件则自动合并):")
            index_list = index_str.split(' ')
            try:
                index_list.remove('')
            except:
                pass
            choice_file_list = []
            if index_list[0] == '0':
                choice_file_list = files
                break
            else:
                try:
                    for item in index_list:
                        choice_file_list.append(files[int(item)-1])
                except:
                    print("输入序号有误")
                    continue
            if choice_file_list:
                break
            else:
                print("输入序号有误")
        data = load_data(choice_file_list)
        print("导入数据成功\n")
    
    
    
    
    
    
    
    
    def save(dictory):
        name = input("请输入文件名(无需加后缀):")
        book = xlwt.Workbook()
        sheet = book.add_sheet('Sheet1', cell_overwrite_ok=True)
        keys = list(data[list(data.keys())[0]].keys())
        head = ["城市"]
        head.extend(keys)
        for h in range(len(head)):
            sheet.write(0, h, head[h])
        cities = list(dictory.keys())
        for city in range(len(cities)):
            sheet.write(city+1, 0, cities[city])
            for key in range(len(keys)):
                sheet.write(city+1, key+1, dictory[cities[city]][keys[key]])
        book.save('./data/'+name+'.xls')
        print("保存成功")

    效果图如下:

    6.总结

    这个程序是我将课本上的纯理论应用到实践中,进一步加深了我对知识的理解。最后将完整代码奉上:

    import os
    import xlrd2 #xlrd: 对Excel进行读相关操作
    import xlwt #xlwt: 对Excel进行写相关操作,且只能创建一个全新的Excel然后进行写入和保存。
    import numpy
    import matplotlib
    from prettytable import PrettyTable  #PrettyTable 是python中的一个第三方库,可用来生成美观的ASCII格式的表格
    from matplotlib import pyplot as plt
    
    
    def get_files_name():
        """
        用于获取文件名
        :return: 返回值为文件名组成的列表
        """
        file_list = os.listdir('./data')
        return file_list
    
    #保存生产excel表
    def load_data(file_list):
        """
        用于读取指定的文件并保存至字典数据结构中
        :param file_list: 需要加载的文件列表
        :return: 保存了文件内容的字典
        """
        dictory = {}
        for file in file_list:
            # 获取表格文件
            book = xlrd2.open_workbook('./data/'+file)
            # 获取表格中的所有sheet
            names = book.sheet_names()
            # 获取第一个sheet
            sheet = book.sheet_by_index(0)
            # 获取当前表格的行数
            rows = sheet.nrows
            # 获取当前表格的列数
            cols = sheet.ncols
            # 获取表头文件,即表格第一行
            head = sheet.row_values(0)
            for row in range(rows-1):
                # 如果当前字典中没有该城市则创建一个
                if not sheet.cell_value(row+1, 0) in dictory.keys():
                    dictory[sheet.cell_value(row+1, 0)] = {}
                for col in range(cols-1):
                    dictory[sheet.cell_value(row+1, 0)][head[col+1]] = float(sheet.cell_value(row+1, col+1))
        return dictory
    
    #数据排行
    def sort_data(dictory, key, reverse):
        """
        根据key和reverse对数据进行排序
        :param dictory: 传入的字典对象
        :param key: 需要排序的关键字,即那一列
        :param reverse: 是否从大到小排序,false即为从小到大排序
        :return:
        """
        data = dictory
        if not reverse:
            data = dict(sorted(data.items(), key=lambda d: d[1][key], reverse=False)) #字典的升序
        else:
            data = dict(sorted(data.items(), key=lambda d: d[1][key], reverse=True)) #字典的降序
        return data
    
    
    def get_specified_cols(dictory, col_name_list):
        """
        筛选出指定的列
        :param dictory:原始字典
        :param col_name_list: 需要筛选出的列名,城市名默认出现
        :return: 筛选之后的字典
        """
        new_dict = {}
        for key in dictory.keys():
            new_dict[key] = {}
            for col_name in col_name_list:
                new_dict[key][col_name] = dictory[key][col_name]
        return new_dict
    
    
    def get_specified_data(dictory, operation, col_name, value):
        """
        根据输入的操作符、列名以及指定的value进行筛选,比如筛选出人均GDP大于5000的,则operation = '>', col_name = '人均GDP', value = 5000
        :param dictory: 原始数据
        :param operation: 操作符
        :param col_name: 需要比较的列
        :param value: 需要比较的值
        :return: 筛选之后的字典
        """
        new_dict = {}
        if col_name != "城市":
            for key in dictory.keys():
                # flag用于标记是否需要添加该行
                value = float(value)
                flag = 0
                if operation == '>':
                    if dictory[key][col_name] > value:
                        flag = 1
                elif operation == '>=':
                    if dictory[key][col_name] >= value:
                        flag = 1
                elif operation == '=':
                    if dictory[key][col_name] == value:
                        flag = 1
                elif operation == '<=':
                    if dictory[key][col_name] <= value:
                        flag = 1
                elif operation == '<':
                    if dictory[key][col_name] < value:
                        flag = 1
                else:
                    flag = 0
                if flag == 1:
                    new_dict[key] = {}
                    new_dict[key] = dictory[key]
        else:
            for key in dictory.keys():
                # flag用于标记是否需要添加该行
                flag = 0
                if operation == '>':
                    if key > value:
                        flag = 1
                elif operation == '>=':
                    if key >= value:
                        flag = 1
                elif operation == '=':
                    if key == value:
                        flag = 1
                elif operation == '<=':
                    if key <= value:
                        flag = 1
                elif operation == '<':
                    if key < value:
                        flag = 1
                else:
                    flag = 0
                if flag == 1:
                    new_dict[key] = {}
                    new_dict[key] = dictory[key]
        return new_dict
    
    #制作图表
    def draw_plot(dictory):
        font = {'family': 'MicroSoft Yahei', 'weight': 'bold', 'size': 7}
        matplotlib.rc('font', **font) #设置中文字体
        # 定义三个颜色
        index = numpy.arange(len(dictory.keys()))
        color = [(256 / 256, 0 / 256, 0 / 256, 1),
                (0 / 256, 0 / 256, 256 / 256, 1),
                (0 / 256, 256 / 256, 0 / 256, 1),
                (0 / 256, 0 / 256, 0 / 256, 1)]
        first_key = list(dictory.keys())
        first_key = first_key[0]
        cols = list(dictory[first_key].keys())
        data = []
        for i in range(len(cols)):
            data.append([])
        for key in dictory.keys():
            for col in range(len(cols)):
                data[col].append(dictory[key][cols[col]])
        offset = -1/4
        for i in range(len(cols)):
            plt.bar(index+offset, data[i], color=color[i], width=1 / 5) #通过bar函数可以用柱状图来表达一些变量的统计分布
            offset += 1/4
        plt.xticks(index, dictory.keys())#表示刻度
        plt.legend(cols)#给图像加上图例
        plt.show()
    
    
    def show_data(dictory):
        try:
            keys = list(dictory[list(dictory.keys())[0]].keys())
        except:
            print("当前数据为空")
            return
        head = ['城市']
        head.extend(keys)
        table = PrettyTable(head)
        for key in dictory.keys():
            line = [key]
            for key_2 in keys:
                line.append(dictory[key][key_2])
            table.add_row(line)
        print(table)
    
    
    def save(dictory):
        name = input("请输入文件名(无需加后缀):")
        book = xlwt.Workbook()
        sheet = book.add_sheet('Sheet1', cell_overwrite_ok=True)
        keys = list(data[list(data.keys())[0]].keys())
        head = ["城市"]
        head.extend(keys)
        for h in range(len(head)):
            sheet.write(0, h, head[h])
        cities = list(dictory.keys())
        for city in range(len(cities)):
            sheet.write(city+1, 0, cities[city])
            for key in range(len(keys)):
                sheet.write(city+1, key+1, dictory[cities[city]][keys[key]])
        book.save('./data/'+name+'.xls')
        print("保存成功")
    
    
    # 打印菜单
    def menu():
        print("  ----------Excel 数据分析师----------")
        print("{:<30}".format("  ==============功能菜单============== "))
        print("{:<30}".format("   1. 显示当前数据                     "))
        print("{:<30}".format("   2. 以柱状图展示当前数据              "))
        print("{:<30}".format("   3. 提起指定列                       "))
        print("{:<30}".format("   4. 定向筛选指定元素                       "))
        print("{:<30}".format("   5. 数据排行                         "))
        print("{:<30}".format("   6. 重新加载数据                      "))
        print("{:<30}".format("   7. 保存当前数据                      "))
        print("{:<30}".format("   0. 退出程序                          "))
        print("{:<30}".format(" ==================================== "))
        print("{:<30}".format(" 说明:输入相应数字后按下回车选择指定功能 "))
        print('\n')
    
    
    if __name__ == "__main__":
        # 导入文件
        files = get_files_name()
        data = {}
        print("当前data文件夹下的文件如下:")
        num = 1
        for file in files:
            print(num, file)
            num += 1
        while(1):
            index_str = input("请选择需要导入的文件序号(多个文件导入时用空格分开, 输入0则导入所有文件,输入多文件则自动合并):")
            index_list = index_str.split(' ')
            try:
                index_list.remove('')
            except:
                pass
            choice_file_list = []
            if index_list[0] == '0':
                choice_file_list = files
                break
            else:
                try:
                    for item in index_list:
                        choice_file_list.append(files[int(item)-1])
                except:
                    print("输入序号有误")
                    continue
            if choice_file_list:
                break
            else:
                print("输入序号有误")
        data = load_data(choice_file_list)
        print("导入数据成功\n")
        # 调用函数,打印菜单
        menu()
        while 1:
            choice = input("请选择指定功能:")
            if choice == '0':
                print("\n退出程序\n")
                exit()
            elif choice == '1':
                print("当前功能:显示当前数据")
                show_data(data)
                input('\n按下回车返回菜单')
                menu()
            elif choice == '2':
                print("当前功能:以柱状图显示数据")
                draw_plot(data)
                input('\n按下回车返回菜单')
                menu()
            elif choice == '3':
                print("当前功能:筛选指定列")
                keys = list(data[list(data.keys())[0]].keys())
                print("当前表格中的列如下:")
                num = 1
                for key in keys:
                    print(num, key)
                    num += 1
                choice_col_list = []
                while (1):
                    index_str = input("请选择需要筛选出的列序号(多列之间用空格分开,0代表所有列):")
                    index_list = index_str.split(' ')
                    try:
                        index_list.remove('')
                    except:
                        pass
                    choice_file_list = []
                    if index_list[0] == '0':
                        choice_col_list = keys
                        break
                    else:
                        try:
                            for item in index_list:
                                choice_col_list.append(keys[int(item) - 1])
                        except:
                            print("输入序号有误")
                            continue
                    if choice_col_list:
                        break
                    else:
                        print("输入序号有误")
                data = get_specified_cols(data, choice_col_list)
                print("筛选成功")
                input('\n按下回车返回菜单')
                menu()
            elif choice == '4':
                print("当前功能:筛选指定行")
                keys = list(data[list(data.keys())[0]].keys())
                print("当前表格中的列如下:")
                num = 1
                print(num, "城市")
                num += 1
                for key in keys:
                    print(num, key)
                    num += 1
                col = int(input("请输入需要进行筛选的数据所在的列:"))-2
                if col == -1:
                    col = '城市'
                else:
                    col = keys[col]
                op_list = ['<', '<=', '=', '>=', '>']
                print("比较操作符如下:")
                num = 1
                for op in op_list:
                    print(num, op)
                    num += 1
                operation = int(input("请输入比较操作符前的序号:"))-1
                operation = op_list[operation]
                value = input("请输入需要筛选的值:")
                data = get_specified_data(data, operation, col, value)
                print("筛选成功")
                input('\n按下回车返回菜单')
                menu()
            elif choice == '5':
                print("当前功能:数据排序")
                keys = list(data[list(data.keys())[0]].keys())
                print("当前表格中的列如下:")
                num = 1
                for key in keys:
                    print(num, key) #显示当前表格中的所有的列
                    num += 1
                col = int(input("请输入需要进行排序的数据所在的列:")) - 1
                col = keys[col]
                reverse = input("排序方式:\n1 从大到小排序\n2 从小到大排序\n")
                if reverse == '1':
                    data = sort_data(data, col, True)
                elif reverse == '2':
                    data = sort_data(data, col, False)
                else:
                    print("输入有误")
                input('\n按下回车返回菜单')
                menu()
            elif choice == '6':
                # 导入文件
                files = get_files_name()
                data = {}
                print("当前文件夹下的文件如下:")
                num = 1
                for file in files:
                    print(num, file)
                    num += 1
                while (1):
                    index_str = input("请选择需要导入的文件序号(多个文件导入时用空格分开, 输入0则导入所有文件,输入多文件则自动合并):")
                    index_list = index_str.split(' ')
                    try:
                        index_list.remove('')
                    except:
                        pass
                    choice_file_list = []
                    if index_list[0] == '0':
                        choice_file_list = files
                        break
                    else:
                        try:
                            for item in index_list:
                                choice_file_list.append(files[int(item) - 1])
                        except:
                            print("输入序号有误")
                            continue
                    if choice_file_list:
                        break
                    else:
                        print("输入序号有误")
                data = load_data(choice_file_list)
                print("导入数据成功\n")
                # 打印菜单
                menu()
            elif choice == '7':
                print("当前功能:保存数据")
                save(data)
                input('\n按下回车返回菜单')
                menu()
            else:
                print("请输入正确的数字")
                input('\n按下回车返回菜单')
                menu()

    展开全文
  • python读写excel文件有很多种方法: 用xlrd和xlwt进行excel读写 用openpyxl进行excel读写 用pandas进行excel读写 本文使用xlrd读取excel文件(xls,sxls格式),使用xlwt向excel写入数据 一、xlrd和xlwt的安装 安装...
  • Python编写Excel数据 .pdf
  • 因为近期需要将excel导入到SQL Server,但是使用的是其他语言,闲来无事就尝试着用python进行导入,速度还是挺快的,1w多条数据,也只用了1s多,代码也比较简单,就不多解释了。 用到的库有xlrd(用来处理excel),...
  • 正则表达式是一个特殊的字符序列,它能帮助你方便的检查一个字符串是否与某种模式匹配。正则表达式并不是Python的一部分。...本课程将python的正则表达式的技术应用到excel数据处理中,更加提高了数据处理的能力。
  • Python针对Excel数据处理(部分)

    千次阅读 2022-04-15 19:54:53
    提示:文章写完后,目录可以自动生成,如何生成可参考右边的帮助文档 目录 前言 ...一、该程序中的库函数介绍 ...1.在Excel中通过列名称整列...本次处理小白练手,运用行列索引实现对Excel数据的读取,将读取..
  • python对excel表进行排序

    千次阅读 2021-09-15 13:41:41
    这次的分享实用性比较强: 开发环境:mac pro,python3.8.8,wps ...sort_values()函数原理类似于SQL中的order by,可以将数据集依照某个字段中的数据进行排序,该函数即可根据指定列数据也可根据指定行的数据
  • 本文代码及数据集来自《超简单:用PythonExcel飞起来(实战150例)》 # 排序一个工作表中的数据(方法一) import pandas as pd data = pd.read_excel('销售表.xlsx', sheet_name='总表') data = data.sort_...
  • python处理excel的基础操作的第二篇。
  • python对excel数据分析常用功能 (一文学会如何用Python实现excel基础功能) 本文主要应用pandas包完成,先加载pandas包 import pandas as pd 1、excel数据读取 data = pd.read_excel(r"C:\\Users\\Desktop\\test....
  • Python处理Excel数据

    千次阅读 2020-12-18 19:33:14
    前段时间做了个小项目,帮个海洋系的教授做了个数据处理的软件。基本的功能很简单,就是excel里面的一些数据进行过滤,统计,多个表的内容进行合并等。之前没有处理excel数据的经验,甚至于自己都很少用到excel...
  • Python对Excel操作教程.pdf
  • 主要介绍了python3 读取Excel表格中的数据的相关资料,需要的朋友可以参考下
  • Python进行Excel数据处理

    万次阅读 多人点赞 2020-04-03 15:55:36
    Python进行Excel数据处理思路实现1. 使用openpyxl2. 使用xlrd和xlwt总结 前两天GF让用Python写个Excel表格处理脚本,在这里记录一下。某公司有个数据统计汇总表格,仅为初表,复制粘贴汇总而来。初表中,存在同一...
  • import openpyxl type_name = 'test4' file_name_rd = type_name+'.xlsx' wb = openpyxl.load_workbook(file_name_rd) # 获取工作表名 names = wb.sheetnames # 使用wb[name] 获取指定工作表 sheet1 = wb[names[0]]...
  • 从零基础开始用Python处理Excel数据
  • Python实现EXCEL表格的排序功能

    千次阅读 2020-11-30 10:23:17
    EXCEL的数值排序功能还是挺强大的,升序、降序,尤其自定义排序,能够多个字段进行排序工作。那么,在Python大法中,有没有这样强大的排序功能呢?答案是有的,而且本人觉得Python排序功能,一点不比EXCEL的差。...
  • 主要介绍了python 删除excel表格重复行,数据预处理操作,具有很好的参考价值,希望大家有所帮助。一起跟随小编过来看看吧
  • 【学习笔记】python实现excel数据处理

    万次阅读 多人点赞 2019-02-27 20:03:44
    概述 Excel固然功能强大,也有许多函数实现数据处理功能,但是Excel仍需大量人工操作,虽然能嵌入VB脚本宏,但也...因此,本文就python处理excel数据进行了学习,主要分为python对excel数据处理的常用数据类型以及...
  • 首先要做的就是数据提取了,excel中本身有一个text to column的功能,但是列中规律性不好的数据处理效果很差,不能分割出想要的数据,所以我果断选择用python来完成。 要用的库一个是对excel读写处理的,一个事...
  • python来自动生成excel数据文件。python处理excel文件主要是第三方模块库xlrd、xlwt、xluntils和pyExcelerator,除此之外,python处理excel还可以用win32com和openpyxl模块
  • python处理excel表格数据 方法一 你好! 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用Markdown编辑器, 可以仔细阅读这篇文章,了解一下Markdown的基本语法知识。 excel表格数据筛选功能 ...
  • Python DataFrame数据分组并排序并选择最优数据 目的:对数据按第一列分组,按第二列降序排序,按第三列升序排序,选择每组中最好的输出 数据: 开始: import pandas as pd df = pd.read_excel('product.xlsx',...
  • Python对Excel数据进行对比处理

    千次阅读 2022-01-14 18:00:35
    使用Python工具Pandas对Excel数据进行对比处理

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 70,102
精华内容 28,040
关键字:

python对excel数据排序