舍务办 Excel 自动化合并

import base64
import sys
import os

import openpyxl
from PyQt5.QtCore import Qt
from PyQt5.QtGui import QIcon, QFont
from PyQt5.QtWidgets import QApplication, QHBoxLayout, QVBoxLayout, QLabel, QSpacerItem, 
    QSizePolicy, QFileDialog
from qfluentwidgets import InfoBar, ToolButton, ListWidget, LineEdit, 
    FluentIcon as FIF
from qframelesswindow import FramelessWindow, StandardTitleBar

file = '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'
svg = 'svg class=icon style=width 1em;height 1em;vertical-align middle;fill currentColor;overflow hidden; viewBox=0 0 1024 1024 version=1.1 xmlns=httpwww.w3.org2000svg p-id=4376path d=M855.733157 63.83998 168.264796 63.83998c-57.672514 0-104.425328 46.752814-104.425328 104.426351l0 687.46836c0 57.672514 46.752814 104.425328 104.425328 104.425328L855.733157 960.16002c57.672514 0 104.425328-46.752814 104.425328-104.425328L960.158485 168.266331C960.158485 110.592794 913.406694 63.83998 855.733157 63.83998zM665.702126 731.750913l-63.856353 0-71.352071-128.613216c-6.999414-12.591783-15.093766-28.780487-24.283056-48.567135-10.79281 14.591323-23.984251 30.082132-39.573297 46.468334L344.019683 731.750913l-77.94728 0 209.857589-222.149543L351.514377 292.249087l64.75584 0 56.661488 99.532901c14.989389 26.185382 23.581068 41.4746 25.783223 45.868677 5.194302 9.794064 10.891048 21.48636 17.08819 35.075867 14.787798-19.983123 37.670971-46.267766 68.653613-78.846766l96.534614-101.630678 76.747965 0L545.184285 519.194866 665.702126 731.750913z fill=#01A408 p-id=4377pathsvg'

class ExcelAuto
    def __init__(self, data dict = None)
        self.data = {
            'data' [
                {}, {}, {}
            ]
        }
        if data
            self.data = data
        self.classNum = 30
        self.title = self.time = self.workbook = self.sheet = self.worksheet = self.outFile = self.workbookO = 
            self.sheetO = self.worksheetO = None

    def setOutFile(self, out str)
        self.outFile = out
        try
            self.workbookO = openpyxl.load_workbook(self.outFile)
        except FileNotFoundError
            with open(self.outFile, 'wb') as f
                f.write(base64.b64decode(file.encode()))
            self.workbookO = openpyxl.load_workbook(self.outFile)
        self.sheetO = self.workbookO.sheetnames[0]
        self.worksheetO = self.workbookO[self.sheetO]

    def setFiles(self, file str  list)
        if type(file) == str
            self.init(file)
        else
            for i in file
                self.init(i)

    def save(self)
        if self.outFile
#             print(self.outFile)
            self.writeAll()
            self.workbookO.save(self.outFile)
            return True


    def init(self, file)
        self.workbook = openpyxl.load_workbook(file)
        self.sheet = self.workbook.sheetnames[0]
        self.worksheet = self.workbook[self.sheet]
        self.Grade()
#         pprint(self.data)

    def Grade(self)
        self.G1()
        self.G2()
        self.G3()

    def G1(self)
        for i in range(6, 6 + self.classNum)
            if self.readValue('A' + str(i))
                try
                    self.data['data'][0][self.readValue('A' + str(i))] += self.readValue('B' + str(i))
                except KeyError
                    self.data['data'][0][self.readValue('A' + str(i))] = self.readValue('B' + str(i))

    def G2(self)
        for i in range(6, 6 + self.classNum)
            if self.readValue('D' + str(i))
                try
                    self.data['data'][1][self.readValue('D' + str(i))] += self.readValue('E' + str(i))
                except KeyError
                    self.data['data'][1][self.readValue('D' + str(i))] = self.readValue('E' + str(i))

    def G3(self)
        for i in range(6, 6 + self.classNum)
            if self.readValue('G' + str(i))
                try
                    self.data['data'][2][self.readValue('G' + str(i))] += self.readValue('H' + str(i))
                except KeyError
                    self.data['data'][2][self.readValue('G' + str(i))] = self.readValue('H' + str(i))

    def writeAll(self)
        g1 = self.data['data'][0]
        for i in range(6, 6 + self.classNum)
            if self.readValue('A' + str(i))
                self.writeValue('B' + str(i), g1[self.readValue('A' + str(i))])

        g2 = self.data['data'][1]
        for i in range(6, 6 + self.classNum)
            if self.readValue('D' + str(i))
                self.writeValue('E' + str(i), g2[self.readValue('D' + str(i))])

        g3 = self.data['data'][2]
        for i in range(6, 6 + self.classNum)
            if self.readValue('G' + str(i))
                self.writeValue('H' + str(i), g3[self.readValue('G' + str(i))])

        return True

    def readValue(self, pos str)
        return self.worksheet[pos].value

    def writeValue(self, pos str, value)
        self.worksheetO[pos].value = value

class Ui(FramelessWindow)
    def __init__(self, parent=None)
        self.done = {}
        super().__init__(parent=parent)
        self.setTitleBar(StandardTitleBar(self))
        open('ico.svg', 'w', encoding='utf-8').write(svg)
        self.setWindowIcon(QIcon('ico.svg'))
        os.remove('ico.svg')
        self.setWindowTitle('Excel自动化工具  Bug反馈：hjylock@qq.com')
        self.excel = ExcelAuto()
        self.hbox = QHBoxLayout(self)
        self.verticalLayout = QVBoxLayout(self)
        self.verticalLayout.setObjectName(verticalLayout)
        self.head = QHBoxLayout()
        self.head.setObjectName(head)
        self.fileLabel = QLabel(self)
        self.fileLabel.setObjectName(fileLabel)
        self.head.addWidget(self.fileLabel)
        spacerItem = QSpacerItem(40, 20, QSizePolicy.Expanding, QSizePolicy.Minimum)
        self.head.addItem(spacerItem)
        self.fileButton = ToolButton(FIF.FOLDER, self)
        self.fileButton.setObjectName(fileButton)
        self.fileButton.clicked.connect(self.fileSelected)
        self.head.addWidget(self.fileButton)
        self.clearButton = ToolButton(FIF.CLOSE, self)
        self.clearButton.setObjectName(clearButton)
        self.clearButton.clicked.connect(self.clear)
        self.head.addWidget(self.clearButton)
        self.verticalLayout.addLayout(self.head)
        self.listWidget = ListWidget(self)
        self.listWidget.setObjectName(listWidget)
        self.verticalLayout.addWidget(self.listWidget)
        self.horizontalLayout_2 = QHBoxLayout()
        self.horizontalLayout_2.setObjectName(horizontalLayout_2)
        self.saveLabel = QLabel(self)
        self.saveLabel.setObjectName(saveLabel)
        self.horizontalLayout_2.addWidget(self.saveLabel)
        self.filePathLine = LineEdit(self)
        self.filePathLine.setObjectName(filePathLine)
        self.filePathLine.setReadOnly(True)
        self.filePathLine.setText('.end.xlsx')
        self.excel.setOutFile('.end.xlsx')
        self.horizontalLayout_2.addWidget(self.filePathLine)
        self.folderButton = ToolButton(FIF.FOLDER, self)
        self.folderButton.setObjectName(folderButton)
        self.folderButton.clicked.connect(self.outFile)
        self.horizontalLayout_2.addWidget(self.folderButton)
        self.saveButton = ToolButton(FIF.SAVE, self)
        self.saveButton.setObjectName(saveButton)
        self.saveButton.clicked.connect(self.save)
        self.horizontalLayout_2.addWidget(self.saveButton)
        self.verticalLayout.addLayout(self.horizontalLayout_2)
        self.hbox.addLayout(self.verticalLayout)
        self.hbox.setSpacing(0)
        self.hbox.setContentsMargins(9, self.titleBar.height(), 9, 9)

        self.fileLabel.setText(请添加文件：)
        self.fileLabel.setFont(QFont('华文细黑', 15))
        self.saveLabel.setText(请选择保存路径：)
        self.saveLabel.setFont(QFont('华文细黑', 15))
        self.initWindow()

    def save(self)
        if self.excel.save()
            InfoBar.success(
                title='',
                content='保存成功',
                parent=self
            )

    def initWindow(self)
        self.resize(900, 700)
        self.titleBar.setAttribute(Qt.WA_StyledBackground)
        desktop = QApplication.desktop().availableGeometry()
        w, h = desktop.width(), desktop.height()
        self.move(w  2 - self.width()  2, h  2 - self.height()  2)

    def fileSelected(self)
        t = []
        try
            tmp = QFileDialog.getOpenFileNames(filter='Excel文件 (.xlsx)')[0]
            for i in tmp
                try
                    if not self.done[i]
                        self.listWidget.addItem(str(i))
                        t.append(str(i))
                except KeyError
                    self.listWidget.addItem(str(i))
                    self.done[i] = True
                    t.append(str(i))
            self.excel.setFiles(t)
            InfoBar.success(
                title='',
                content='添加成功',
                parent=self,
            )
        except Exception as e
            InfoBar.error(
                title='警告',
                content=str(e),
                parent=self,
            )

    def clear(self)
        self.listWidget.clear()
        InfoBar.success(
            title='',
            content='删除成功',
            parent=self,
        )

    def outFile(self)
        path = QFileDialog.getExistingDirectory()
#         print(path)
        if path
            self.filePathLine.setText(str(path) + 'end.xlsx')
            self.excel.setOutFile(str(path) + 'end.xlsx')
#             pprint(self.done)


if __name__ == '__main__'
    QApplication.setHighDpiScaleFactorRoundingPolicy(
    Qt.HighDpiScaleFactorRoundingPolicy.PassThrough)
    QApplication.setAttribute(Qt.AA_EnableHighDpiScaling)
    QApplication.setAttribute(Qt.AA_UseHighDpiPixmaps)

    app = QApplication(sys.argv)
    w = Ui()
    w.show()
    app.exec_()