精华内容
下载资源
问答
  • 利用PythonExcel数据进行处理

    千次阅读 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数据的方法:1、使用xlrd来处理;2、使用【xlutils+xlrd】来处理;3、使用xlwt来处理;4、使用pyExcelerator来处理;5、使用Pandas库来处理。 下面我们通过示例来看看xlrd、xlwt、xluntils、...

    前言

    python处理excel数据的方法:1、使用xlrd来处理;2、使用【xlutils+xlrd】来处理;3、使用xlwt来处理;4、使用pyExcelerator来处理;5、使用Pandas库来处理。

    下面我们通过示例来看看xlrd、xlwt、xluntils、pyExcelerator和Pandas是如何处理excel文件数据的。

    python处理excel数据的方法:

    方法一:使用xlrd来处理excel数据

    示例1:python读取excel文件特定数据

    示例2:python读取excel文件所有数据

    方法二:使用xlutils+xlrd来处理excel数据

    示例:向excel文件中写入数据

    方法三:使用xlwt来处理excel数据

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

    方法四:使用pyExcelerator来处理excel数据

    示例1:读excel文件中的数据

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

    方法五:使用Pandas库来处理excel数据

    示例1:读取excel数据

    示例2:操作Excel中的行列

     

     以上就是本篇文章的全部内容,希望能对大家的学习有所帮助。更多精彩内容大家可以关注微信公众号【编程简单学丶】中会有相关资料分享!!!

     

    展开全文
  • 作为一个学习用Python进行数据分析的新手来说,通过本文来记录分享一些我在用Python中的pandas、numpy来分析Excel表中数据数据清洗和整理的工作,目的是熟悉numpy以及pandas基础操作,所有操作利用Excel均可以方便...

    作为一个学习用Python进行数据分析的新手来说,通过本文来记录分享一些我在用Python中的pandas、numpy来分析Excel表中数据的数据清洗和整理的工作,目的是熟悉numpy以及pandas基础操作,所有操作利用Excel均可以方便实现。备注:本文中使用的是ipython完成的编辑

    数据来源及结构

    本文所分析的数据是通过爬虫抓取的微博数据。选取新浪微博为数据平台,选取我国34个省的旅游政务官方微博为研究对象,利用爬虫软件Gooseeker爬取微博信息,包括用户名、粉丝数、开博日期、当月原创微博总数No、当月总微博数N、单条博文的转发数、单条博文的评论数、条博文的点赞数。

    爬取的数据表格test.xlsx包括以下几个sheet中,基本表结构见下

    126893467_1_20180311020848802

    1、All(所有博文):所有字段见下:其中有用字段是‘用户名、微博内容、时间、转发数、评论数、点赞数’,共有6585条数据(备注:转发数中的缺失值为“转发”,评论数中的缺失值为“评论”,点赞数中的缺失值为“赞”):

    126893467_2_20180311020848943

    2、sf(各省信息表,此表中:省份名完整)

    126893467_3_201803110208495

    3、sfwibo (此表记录的是各个微博账号对应的省份名,省份名不完整,已知各个省份名只有前两个字完整)

    126893467_4_2018031102084937

    4、base_info2(爬取的微博账户的相关信息)(备注:此处的“昵称”与sfweibo中的“微博用户名”等同)

    126893467_5_2018031102084984

    本文思路:

    Step1:对于All表:1)取出有用字段。2)处理缺失值。3)数据透视

    Step2:对于sf 和sfweibo 表:1)以省份名做数据连接成sf_sfweibo。2)并与All表做数据连接sf_sfweibo_All。

    Step3:对于base_info表:1)与sf_sfweibo_All做数据连接 2)计算h值 3)处理数据4)计算相关性

    Step4:导出最后结果到一个Excel文件中,完成数据处理。、

    数据处理过程:

    step1 :

    # -*- coding=utf-8 -*-

    #导入需要的包

    from__future__import division

    import numpy as np

    import pandas as pd

    import matplotlib.pyplot as plt

    from numpy.randomimport randn

    from pandasimport Series, DataFrame

    from datetimeimport datetime

    import xlrd, openpyxl

    xlsx_file = pd.ExcelFile('test1.xlsx')

    All = xlsx_file.parse('All')

    1)取出有用字段

    #删掉表格中的无用列,保留有用列

    d1 = All.drop(All.columns[:11], axis=1, inplace = False)

    All = d1.drop(d1.columns[-1], axis=1, inplace = False)

    #显示表格前五行

    All.head()

    126893467_6_20180311020849162

    #查看去重未处理前表中记录长度

    len(All)

    126893467_7_20180311020849240

    #获取到重复的行的行号的前20个

    All[All.duplicated()==True].index[:20]

    126893467_8_20180311020849271

    #删除掉重复的行,在原值上直接修改

    All.drop_duplicates(inplace=True)

    len(All)#通过运行结果,可以发现确实删掉了,当前记录条数为6159条

    126893467_9_20180311020849334

    2)处理缺失值

    #处理缺失值,先获取该列,将列中的"转发”、"评论"、"赞"替换掉

    #为什么不在读取表格的时候直接设置呢?因为如果一开始就设置替换,会导致整张表中的"转发”、"评论"、"赞"均会被替换掉,造成信息损失

    All[u'转发数'][All[u'转发数']==u'转发'] = '0'

    All[u'评论数'][All[u'评论数']==u'评论'] = '0'

    All[u'点赞数'][All[u'点赞数']==u'赞'] = '0' #等价于# All[u'点赞数'].replace(u'赞','0')

    All.head()

    126893467_10_20180311020849396

    3)数据透视

    All.describe()

    126893467_11_20180311020849459

    备注:出现这个结果说明了数据类型不是数值型

    #查看表中各个列的数据类型

    All.dtypes

    126893467_12_20180311020849505

    #为了能进行数据透视,需要将对应列的数据类型转换成数值型

    #将DataFrame表中的某列数据进行转换类型

    All[u'转发数']=All[u'转发数'].astype('int64')

    All[u'评论数'] = All[u'评论数'].astype('int64')

    All[u'点赞数'] = All[u'点赞数'].astype('int64')

    All.describe()

    126893467_13_20180311020849552

    #查看表中各个列的数据类型

    All.dtypes

    126893467_14_20180311020849599

    #将预处理过的表保存到All.xlsx中

    All.to_excel('All.xlsx',index=False)

    #数据透视表

    All_pivot= All.pivot_table(values=[u'转发数',u'评论数',u'点赞数',u'微博内容'],index=[u'用户名'],\

    aggfunc={u'转发数':np.sum,u'评论数':np.sum,u'点赞数':np.sum,u'微博内容':np.size})

    #给该列换名称

    All_pivot.rename(columns={u'微博内容':u'当月总微博数'},inplace=True)

    All_pivot

    126893467_15_20180311020849646

    #将完成的透视表保存

    All_pivot.to_excel('All_pivot.xlsx')

    step2

    1)以省份名做数据连接成sf_sfweibo

    #读取test1.xlsx中的sf表

    sf = xlsx_file.parse('sf')

    sf.head()

    126893467_16_20180311020849709

    #读取test1.xlsx中的sfweibo表

    sfweibo = xlsx_file.parse('sfweibo')

    sfweibo.head()

    126893467_17_20180311020849755

    #通过上面的表格输出可以看出,要想将sf和sfweibo进行连接,需要对sf以及sf微博中的“省份名”

    #但是,由于sfweibo中的省份名是不完整的,已知名称中肯定包含省份中的前两个字,为此,需要对两个表格切割后,进行连接

    sf[u'省份前两字'] = np.nan

    for iin range(len(sf[u'省份名'])):

    sf[u'省份前两字'][i] = sf[u'省份名'][i][:2]

    sfweibo[u'省份前两字'] = np.nan

    for iin range(len(sfweibo[u'省份名'])):

    sfweibo[u'省份前两字'][i] = sfweibo[u'省份名'][i][:2]

    #显示表格的前五行

    sf.head()

    126893467_18_20180311020849787

    #显示表格的前五行

    sfweibo.head()

    126893467_19_20180311020849880

    #保存数据

    sf.to_excel('sf.xlsx',index=False)

    sfweibo.to_excel('sfweibo.xlsx',index=False)

    #连接两表

    sf_sfweibo = sf.merge(sfweibo,on=u'省份前两字')

    sf_sfweibo.head()

    126893467_20_201803110208506

    #获取连接后表格中需要的字段名,并重新排列

    sf_sfweibo1 = sf_sfweibo.iloc[:,[4,1,2]]

    sf_sfweibo1.head()

    126893467_21_2018031102085052

    #存储连接后的表

    sf_sfweibo1.to_excel('sf_sfweibo.xlsx',index=False)

    2)并与All表做数据连接sf_sfweibo_All

    #连接sf_sfweibo和All_pivot两表

    sf_sfweibo = sf_sfweibo1

    sf_sfweibo_All_pivot =pd.merge(sf_sfweibo,All_pivot,left_on=u'微博用户名',right_on=u'用户名',right_index=True)

    #显示连接后的表格的前五行

    sf_sfweibo_All_pivot.head()

    126893467_22_2018031102085099

    #将连接后的表进行存储

    sf_sfweibo_All_pivot.to_excel('sf_sfweibo_All_pivot.xlsx',index=False)

    step3:

    1)与sf_sfweibo_All做数据连接

    #处理爬取的用户的基本信息表base_info

    base = xlsx_file.parse('base_info')

    base.head()

    126893467_23_20180311020850162

    #将base表与sf_sfweibo_All_pivot进行连接

    sf_sfweibo_All_pivot_base = base.merge(sf_sfweibo_All_pivot,left_on=u'昵称',right_on=u'微博用户名')

    ssapb = sf_sfweibo_All_pivot_base #名称太长,换个名称

    ssapb.head()

    126893467_24_20180311020850224

    #替换某列的名字

    ssapb.rename(columns={u'当月总微博数_x':u'当月总微博数'},inplace=True)

    #删除其中的多余列

    ssapb = ssapb.drop([u'昵称',u'当月总微博数_y'],axis=1)

    #读取第一行的数

    ssapb.iloc[0]

    126893467_25_20180311020850318

    #添加一列(当月原创数=当月总微博数-当月转发数)

    ssapb[u'当月原创数'] = ssapb[u'当月总微博数']-ssapb[u'当月转发数']

    #将某列同时与某段字符串连接,通过观察网页可以发现这是网址的特点

    linkfix = "?is_ori=1&is_forward=1&is_text=1&is_pic=1&is_video=1&is_music=1&is_\

    article=1&key_word=&start_time=2017-05-01&end_time=2017-05-31&is_search=1&is_searchadv=1#_0"

    ssapb[u'当月博文网址'] = ssapb[u'主页链接']+linkfix

    allfix = "?profile_ftype=1&is_all=1#_0"

    ssapb[u'全部博文网址'] = ssapb[u'主页链接']+allfix

    #计算出篇均转发/点赞/评论,并添加列

    ssapb[u'篇均点赞'] = ssapb[u'点赞数']/ssapb[u'当月总微博数']

    ssapb[u'篇均转发'] = ssapb[u'转发数']/ssapb[u'当月总微博数']

    ssapb[u'篇均评论'] = ssapb[u'评论数']/ssapb[u'当月总微博数']

    #读取表中的第一行数据

    ssapb.iloc[0]

    126893467_26_20180311020850380

    #存储表格

    ssapb.to_excel('ssapb.xlsx',index=False)

    2)计算h值

    #将All表分组,获取表格的index值

    gb = All.groupby(u'用户名')

    gb1 = gb.size()

    gbindex = gb1.index

    print gbindex,gb1

    126893467_27_20180311020850459

    #根据h指数的定义,分别计算转发/评论/点赞h指数

    #再记录下每个“用户名的最大互动度max(转发+评论+点赞)”

    sortAllf = All.sort_values(by=[u'用户名',u'转发数'],ascending=[True,False])

    sortAllc = All.sort_values(by=[u'用户名',u'评论数'],ascending=[True,False])

    sortAlll = All.sort_values(by=[u'用户名',u'点赞数'],ascending=[True,False])

    mm = (sortAllf,sortAllc,sortAlll)

    #将计算得到的结果重新存储到一个新的DataFrame中

    All_h =pd.DataFrame(np.arange(136).reshape(34,4),columns=['fh','ch','lh','max_hdd'],index=gbindex)

    fh=[]

    ch=[]

    lh=[]

    max_hdd = []

    for jin range(len(mm)):

    for iin gbindex:

    tempdf =mm[j][mm[j][u'用户名']==i]

    tempdf['hdd'] = tempdf[u'转发数']+tempdf[u'评论数']+tempdf[u'点赞数']

    max_hdd.append(tempdf['hdd'].max())

    tempdf['numf'] = range(len(tempdf))

    if  j==0:

    a =len(tempdf[tempdf[u'转发数']>=tempdf['numf']+1])

    fh.append(a)

    elif  j==1:

    b =len(tempdf[tempdf[u'评论数']>=tempdf['numf']+1])

    ch.append(b)

    else:

    c = len(tempdf[tempdf[u'点赞数']>=tempdf['numf']+1])

    lh.append(c)

    All_h['fh']=fh

    All_h['ch']=ch

    All_h['lh']=lh

    #因为,前面的循环一共循环了三遍,使得All_h重复了3遍,因此只要获取前34位即可

    All_h['max_hdd']=max_hdd[:34]

    #插入一个综合h指数,该指数是转发/评论/点赞h指数三个的均值

    All_h.insert(3,'HS',All_h.iloc[:,:3].mean(1))

    #更改列名称

    All_h.rename(columns={'fh':u'转发h指数','ch':u'评论h指数',\

    'lh':u'点赞h指数','HS':u'综合h指数','max_hdd':u'单篇最大互动度'},inplace=True)

    All_h.head()

    126893467_28_20180311020850552

    #连接ssapb和All_h表格

    ssapb_All_h= pd.merge(ssapb, All_h, left_on=u'微博用户名',right_on=u'用户名',right_index=True)

    #加一列原创率

    ssapb_All_h[u'原创率'] = ssapb_All_h[u'当月原创数']/ssapb_All_h[u'当月总微博数']

    ssapb_All_h.iloc[0]

    126893467_29_20180311020850615

    #存档

    ssapb_All_h.to_excel('ssapb_All_h.xlsx',index=False)

    3)计算相关性

    #获取原DataFrame中的几列存储到新的DataFrame中,计算综合h指数与其他分指数之间的相关性

    f1 = ssapb_All_h.loc[:,[u'综合h指数',u'转发h指数',u'评论h指数',u'点赞h指数']]

    #计算f1中各列数据的相关性

    corr1 = f1.corr()

    #将该相关性结果存档

    corr1.to_excel('corr1.xlsx')

    corr1

    126893467_30_20180311020850693

    #获取原DataFrame中的几列存储到新的DataFrame中,计算综合h指数与其他微博信息之间的相关性

    f2 = ssapb_All_h.loc[:,[u'综合h指数',u'转发数',u'评论数',u'点赞数',u'篇均转发',u'篇均评论',u'篇均点赞']]

    corr2 = f2.corr()

    corr2.to_excel('corr2.xlsx')

    corr2

    126893467_31_20180311020850740

    #获取原DataFrame中的几列存储到新的DataFrame中,计算综合h指数与其他信息之间的相关性

    f3 = ssapb_All_h.loc[:,[u'综合h指数',u'原创率',u'粉丝数',u'微博总数',u'单篇最大互动度']]

    corr3 = f3.corr()

    corr3.to_excel('corr3.xlsx')

    corr3

    126893467_32_20180311020850802

    #重新排序列

    aa =ssapb_All_h.iloc[:,[8,9,10,5,15,16,0,1,2,3,4,6,14,7,11,12,13,24,20,21,22,23,17,18,19,25]]

    aa.to_excel('finally.xlsx')

    aa.iloc[0]

    126893467_33_20180311020850849

    4)处理数据,处理浮点位数/转成百分位数

    #将表中的浮点类型保留至小数点后四为

    f = lambda x:'%.4f' % x

    aa.ix[:,21:] = aa.ix[:,21:].applymap(f)

    aa.ix[:,21:] = aa.ix[:,21:].astype('float64')

    aa.iloc[0]

    126893467_34_20180311020850927

    #将原创率转成百分比形式

    f1 = lambda x :'%.2f%%' %  (x*100)

    aa[[u'原创率']]= aa[[u'原创率']].applymap(f1)

    aa.to_excel('finally1.xlsx',index=False)

    aa.iloc[0]

    126893467_35_2018031102085121

    aa.sort_values(by=u'综合h指数', ascending=False, inplace=True)

    #按照综合h指数降序排序,添加一个排序位数

    aa['rank'] =np.arange(34)+1

    #要想得到“综合h指数/排名"的列,需要将aa['rank']和aa[u'综合h指数']进行合并成一列,这就要求必须连接字符串类型

    aa['rank'] = aa['rank'].astype('string_')

    aa[u'综合h指数'] = aa[u'综合h指数'].astype('string_')

    #连接成一列

    aa[u'综合h指数/排名'] = aa[u'综合h指数']+'/'+ aa['rank']

    aa.iloc[0]

    126893467_36_20180311020851115

    step4

    1)存储最终数据

    #删除掉一列rank

    del aa['rank']

    #将该数据类型换回来,换成浮点型

    aa[u'综合h指数'] = aa[u'综合h指数'].astype('float64')

    aa.to_excel('finally2.xlsx',index=False)

    结语:

    至此,本次分析操作过程已全部结束,希望这些操作可以新手有一定的参考帮助

    展开全文
  • 利用pythonEXCEL的提取处理

    千次阅读 2021-03-09 08:17:07
    提示:利用python处理两个EXCEL表格,表A和表B第一列均为时间,若时间相同,就将表A对应时间的那一行数据提取出来 例如: 方案一: 采用简单的for循环,读入EXCEL数据,进行比较判断,输出保存 import xlrd import ...

    项目场景:

    提示:利用python处理两个EXCEL表格,表A和表B第一列均为时间,若时间相同,就将表A对应时间的那一行数据提取出来
    例如:如该图中两个表所示

    方案一:

    采用简单的for循环,读入EXCEL数据,进行比较判断,输出保存

    import xlrd
    import xlwt
    
    # 读取文件
    file_A_name = "I:\\EXLA.xls"
    file_B_name = "I:\\EXLB.xls"
    result_to_name = "I:\\Result.xlsx"
    file_A = xlrd.open_workbook(file_A_name)
    file_B = xlrd.open_workbook(file_B_name)
    # 读取文件中的某张表
    A_sheet = file_A.sheet_by_name("风速曲线")
    B_sheet = file_B.sheet_by_name("aaa")
    # 创建需要保存的写入文件
    workbook = xlwt.Workbook(encoding="ascii")
    # 创建写入sheet
    worksheet = workbook.add_sheet("same_time_date")
    
    # 啦啦啦,第一版程序,比较耗时,并且保存结果不连续
    for i in range (0,A_sheet.nrows):              # 遍历表A"风速曲线"sheet的每一行
        A_values_row1 = A_sheet.row_values(i)      # 保存第i行的数据至A_values_row1
        for j in range (0,B_sheet.nrows):          # 遍历表B"aaa"sheet的每一行
            B_values_row1 = B_sheet.row_values(j)  # 保存第i行的数据至A_values_row1
            if A_values_row1[0]==B_values_row1[0]: # 比较第一列(每一行第一个值)是否相等
                print(A_values_row1)
                # 保存相同结果
                for k in range(0,11):              # 若True,将表A第i行的12个数据保存至新建"same_time_date"sheet
                    worksheet.write(i, k, A_values_row1[k])
                    workbook.save(result_to_name)
    
    
    # 啦啦啦 ,关于读取某行,某列,或某具体数据的方法
    '''
    # 读取表A第一列数据
    colA_1_value = A_sheet.col_values(0)
    print(colA_1_value)
    
    # 第一行数据
    rowA_1_value = A_sheet.row_values(0)
    print(rowA_1_value)
    
    # 获取第一行第一列的数据
    cell_value = A_sheet.cell_value(0, 0)
    print(cell_value)
    
    # 获取表的行数
    nrows = A_sheet.nrows
    
    # 获取表的列数
    ncols = A_sheet.ncols
    print("nrows: %d, ncols: %d" % (nrows, ncols))
    
    # 输出Excel中表的个数
    print(file_A.nsheets)
    
    '''
    
    # 啦啦啦  加一个计数器就可以实现连续保存啦 如果每次只有两个时间会对应相等的话,那么找到这个相等的时间就无需再继续找啦
    
    '''
    m = 0                                          # 记录相同结果的次数
    for i in range (0,A_sheet.nrows):              # 遍历表A"风速曲线"sheet的每一行
        A_values_row1 = A_sheet.row_values(i)      # 保存第i行的数据至A_values_row1
        for j in range (0,B_sheet.nrows):          # 遍历表B"aaa"sheet的每一行
            B_values_row1 = B_sheet.row_values(j)  # 保存第i行的数据至A_values_row1
            if A_values_row1[0]==B_values_row1[0]: # 比较第一列(每一行第一个值)是否相等
                i++
                print(A_values_row1)
                # 保存相同结果  换成m
                for k in range(0,11):              # 若True,将表A第i行的12个数据保存至新建"same_time_date"sheet的第m行
                    worksheet.write(m, k, A_values_row1[k])
                    workbook.save(result_to_name)
                continue
    
    
    '''
    

    注意事项:

    提示:这里两个表的时间格式要保持一致,将其改为“数字转换为文本型数字”,否则python读入EXCEl时间数据后为一串float型数字,并且两相同时间数据的小数点并不一致(此处也不知为何)
    在这里插入图片描述


    方案二:

    采用pandas库,这里是小伙伴写的,我直接附上源码大家自行领会

    下面展示一些 内联代码片

    #  编码必须要,因为里面有中文,要不然索引不成功,已开始索引没成功就是因为编码问题;
    # coding=utf-8
    
    # 导入pandas库
    import pandas as pd
    
    # 这两个可以忽略,因为没用到;
    import numpy as np
    # 这个是数据库导入的,用来练手的,你们没有本地数据库也用不用;
    import pymysql
    # 导入数据
    Fpath1 = "K:/马雷/zy.xls";
    df1 = pd.read_excel(Fpath1);
    Fpath2 = "K:/马雷/03.xlsx"
    df2 = pd.read_excel(Fpath2)
    # 因为两个数据时间格式不一样,需要调整,然后且切片;
    df1.loc[:, "时间"] = df1["时间"].str.replace("-", "").str.slice(0, 14);
    # 数据二的日期不是字符串,进行了字符串的转换,这里也栽了大跟头;
    df2.loc[:, "时间"] = df2.时间.astype(str).str.replace("-", "").str[0:14]
    # 输出调整后的两个表,看是否样式一样;
    print(df1)
    print(df2)
    # 相同时间的日期匹配,进行了内联,数据库里面用过的;
    s5 = pd.merge(df2, df1, left_on="时间",right_on="时间",how="inner")
    print(s5)
    # 判断是否有缺失值,很高兴,发现没有缺失值,如果有的话会输出True
    print(s5.时间.isnull())
    # 保存数据,开始愉快的分析数据吧,
    s5.to_excel("K:/马雷/zy2015532.xls")
    # -----------------------------------------------#
    # -----------现在代码结束了-----------------------#
    # -----------底下是联系写的-----------------------#
    # ----------------------------------------------#
    
    # df1.to_excel("K:/马雷/zy1.xls")
    # s3 = df.set_index("最大风向", inplace=True, drop=False)
    # print(s3)
    # print(s3.head(5))
    
    # print(s2);
    # cloumes=["平均风速" ,"zuixiao"];
    # s3 = df(cloumes);
    # print(df.zuixiao)
    # print(df.describe())
    # print(df["最小风向"].mean)
    # print(df.cov())
    # print(df.corr())
    # s1 = df[1:3];
    # s1.to_excel("K:/马雷/zy1.xls", index=False)
    # s3 = df["最大风向"].fillna(0);
    # s4=df["最大风向"].notnull()
    # print(s4)
    # print(s3)
    # print(df["zuixiao"].df["zuida"])
    
    # print(df[1:3])
    
    # print(s3)
    # print(s1.index)
    # s1=pd.Series(re
    # ads.head(2))
    # print(reads.reindex)
    # print(reads.dtypes)
    #  导入数据库数据
    # conn = pymysql.connect(
    #     host="127.0.0.1",
    #     user="root",
    #     password="zy2015532",
    #     database="myemployees",
    #     charset="utf8"
    # )
    # mysql_page = pd.read_sql("select * from employees where salary>10000", con=conn)
    # print(mysql_page)
    
    

    到此结束,如有错误,敬请指正

    展开全文
  • pythonexcel数据分析常用功能 (一文学会如何用Python实现excel基础功能) 本文主要应用pandas包完成,先加载pandas包 import pandas as pd 1、excel数据读取 data = pd.read_excel(r"C:\\Users\\Desktop\\test....
  • 利用pandas模块进行操作前,可以先引入这个模块,如下:import pandas as pd2:读取Excel文件的两种方式:#方法一:默认读取第一个表单df=pd.read_excel('lemon.xlsx')#这个会直接默认读取到这个Excel的第一个表单...
  • Python筛选EXCEL数据

    千次阅读 2020-12-25 22:52:35
    我们在实际业务过程中,可能涉及到excel数据清洗的场景,本次代码处理的是客户个人基本信息的清洗操作,其中包含了身份证,性别,国籍,电话,职业,身份证地址,居住地地址,职业描述,以及证件起始日期的筛选操作...
  • 一,要读取的数据的格式:二,数据读取部分:# 1930workbook=xlrd.open_workbook('1930.xlsx')sheet= workbook.sheet_by_index(0)A1=[]B1=[]# sheet.cell_value(i,0):第i行的第0个元素for i in range(1,sheet.nrows):...
  • 当我们利用 excel 生成代码时,可以通过此类方式规范输入。 以下是:【openpyxl官方文档】 excel的基本操作 生成xlsx wb = Workbook() wb.save(xls_path) 加载excel文件 # 加载excel文件(data_only=True 代表以...
  • 1:pandas依赖处理Excel的xlrd模块,所以我们需要提前安装这个,安装命令是:pip install xlrd2:安装pandas模块还需要一定的编码环境,所以我们自己在安装的时候,确保你的电脑有这些环境:Net.4 、VC-Compiler以及...
  • 一, 读取数据1.打开excel文件,导入xlrd是必须的。首先需要 import xlrd,然后打开文件的指令是:xlrd.open_workbook(filename=None, logfile=, verbosity=0, use_mmap=1, file_contents=None, encoding_override=...
  • 准备工作 ...3.再对每一个excel文件进行操作(我求的是某一列数据的平均值) 代码实现 import xlrd import os classes = [] classes_name = [] classes_mark = [] origin_address = r"E:\py\marks\mar
  • 利用python操作excel

    2020-12-24 14:50:29
    //pypi.python.org/packages/source/x/xlrd/xlrd-0.9.3.tar.gztar-xzvfxlrd-0.9.3.tar.gzcdxlrd-0.9.3pythonsetup.pyinstall2)导入模块importxlrd3)打开Excel文件读取数据data=xl...
  • 前言Python的数据清洗功能有多厉害,相信不用我说大家都知道了,寥寥...今天给大家来点干货,教大家如何利用pythonEXCEL数据进行筛选,让大家可以对python快速入门,并可以领略到python的数据分析魅力。数据源我...
  • 利用python处理excel数据:将其读取出来,并且最终实现数据相乘,打印出相乘的结果,其他的运算如加减都可以类比得出 实质在于,将其转化为一个列表,接着进行赋值 以下的代码很简单,相当于一个模板,在数据...
  • df = pd.read_excel("excel文件.xlsx") print(df) print(df["X"]) # 显示中文 plt.rcParams['font.sans-serif'] = ['SimHei'] plt.rcParams['axes.unicode_minus'] = False plt.plot(df["日期"], df["X"], label='...
  • 最近的工作遇到一个需求,整理多个相同格式但是不标准的Excel表格,最终汇总成一个Excel表格,并进行数据透视分析。表格内涉及到合并的单元格...所以决定使用PythonExcel进行自动处理,实现一键导出目标Excel的目...
  • Python如何操作Excel

    2021-01-29 18:48:28
    以上可以根据需求的不同,选择合适的...xlutils介绍xlrd: 用于读取Excel文件xlwt: 用于写入Excel文件xlutils: 用于操作Excel文件的实用工具,比如复制,分割,筛选等安装: pip install 模块名称xlwt: 写入Excel示...
  • pythonExcel数据处理你可以考虑利用openpyxl,打开需要操作的文件,然后读入对应列的数据,将数据放到字典里面。同时开始写输出的列,如果字典里面没有数据的话,就顺序加1,存在数据的话,就将字典的数输出就...
  • 于是本能的想到用Python读取Excel文件之后进行文本分析,之后对每个链接进行一次HttpRequest,通过分析HttpResponse的内容来判断当前链接是否有效。于是上网搜了下,发现比较主流的是用xlrd的插件,但是实际...
  • # -*- coding:utf-8 -*- """ 作者:95345 日期:2021年05月31日 """ import xlrd import numpy as np import matplotlib.pyplot as plt ... table1 = data.sheet_by_name('flights') # 通过excel里面的
  • 利用pandas高效处理数据。pandas依赖xlrd模块来处理Excel。安装这个模块:pip install xlrd安装pandas,安装命令:pip install pandaspandas处理Excel表单提前准备一个Excel文件:dataFall2018.xlsx,有一个表单,...
  • 如何利用pythonexcel表格中筛选出来的每一份数据各自另存为新的excel文件?
  • php替换字符的实现方法_后端开发在php中可以使用“str_replace()”函数进行字符替换,“str_replace()”函数的语法是“str_replace(find,replace,string,count...在python语言中处理Excel的方法:在python项目中,新...
  • 这是06年的建模题目中的excel文件,我想这用python处理一下,只需要获取出版社代码为P115的数据,所以需要筛选。Paste_Image.png1、首先我先选择我所需要的那八行数据'出版社代码''出版社在您心中的位置''学科类别',...
  • 文章目录前言一、处理excel的第三方库二、openpyxl使用1.安装2.导入包3.打开文件 前言 在自动化测试中,会用到excel存储测试用例,并使用代码的方式读取excel,今天来介绍一下openpyxl读取excel的使用方法。 提示...
  • python如何读取excel数据并且画图

    千次阅读 2021-03-07 00:02:56
    python如何读取excel数据并且画图发布时间:2021-02-16 19:29:46来源:亿速云阅读:85作者:小新这篇文章主要介绍python如何读取excel数据并且画图,文中介绍的非常详细,具有一定的参考价值,感兴趣的小伙伴们一定...
  • 运用python操作excel求和

    千次阅读 2021-02-18 16:02:49
    展示pandas如何利用Python的完整的模块系统做一些简单的文字处理。 自动求和 数据如下: 第1步,求出每一行数据的和,并作为一个新列附加到数据中。在excel里,可能用公式是sum(A2:E2)。 在这里,这功能就可以用...
  • 1.Python操作Excel的函数库我主要尝试了3种读写Excel的方法:1>xlrd,xlwt,xlutils:这三个库的好处是不需要其它支持,在任何操作系统上都可以使用。xlrd可以读取.xls,.xlsx文件,非常好用;但因为xlwt不能直接修改...
  • 1.第一种方法直接用pandas读取数据处理 import pandas as pd data = pd.read_excel("test.xls") list = [] for i in data["票据号码"].values: list.append(str(i)) print(tuple(list)) 2.第二种方法,自定.

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 24,486
精华内容 9,794
关键字:

利用python处理excel数据

python 订阅