基于PyQt5制作桌面应用便携版及整合QtCreator UI与计算代码问询

1. Convert UI File & Integrate Calculation Logic #

Let’s start by ensuring your UI conversion is properly set up, then wire in your Jupyter-based calculation logic into a cohesive app.

a. Finalize Odor.ui to ui-main.py Conversion #

If you haven’t already done this via Qt Creator, run this command from your Anaconda environment to convert the UI file:

pyuic5 -x Odor.ui -o ui-main.py

The -x flag adds a quick test block to the output file, so you can immediately verify the UI loads correctly by running ui-main.py.

b. Build the Main Application Wrapper #

Create a new file (e.g., main_app.py) that imports your converted UI and integrates your calculation code. Here’s a template tailored to your imports and workflow:

import os
import sys
import pandas as pd
import numpy as np
import scipy.stats
import xlsxwriter
import re
from PyQt5.QtWidgets import (QApplication, QMainWindow, QWidget, QInputDialog, 
                             QLineEdit, QFileDialog, QMessageBox, QTableWidgetItem, QHeaderView)
from PyQt5.QtCore import Qt, QEvent, QObject
# Import your converted UI class (check ui-main.py for the exact class name)
from ui_main import Ui_MainWindow  

class OdorAnalyzer(QMainWindow):
    def __init__(self):
        super(OdorAnalyzer, self).__init__()
        # Initialize the UI from the converted file
        self.ui = Ui_MainWindow()
        self.ui.setupUi(self)
        
        # Connect your UI buttons/widgets to calculation functions
        # Example: Link a "Run Analysis" button to your logic
        self.ui.run_analysis_btn.clicked.connect(self.execute_calculations)
        
    def execute_calculations(self):
        # Adapt your Jupyter calculation logic here
        # Replace notebook-specific code (like print statements) with UI updates
        try:
            # Prompt user to select input file
            file_path, _ = QFileDialog.getOpenFileName(self, "Select Input Excel", "", "Excel Files (*.xlsx)")
            if not file_path:
                return
            
            # Load data (match your Jupyter workflow)
            df = pd.read_excel(file_path)
            
            # Run your statistical calculations
            stat_result = scipy.stats.ttest_ind(df['sample1'], df['sample2'])
            # Add more calculations as needed from your notebook
            
            # Update UI with results (e.g., populate a table or label)
            self.ui.result_label.setText(f"T-Statistic: {stat_result.statistic:.2f} | P-Value: {stat_result.pvalue:.4f}")
            
            # Save results to Excel (using xlsxwriter)
            output_path = os.path.join(os.path.dirname(file_path), "analysis_results.xlsx")
            with pd.ExcelWriter(output_path, engine='xlsxwriter') as writer:
                df.to_excel(writer, sheet_name="Raw Data")
                pd.DataFrame({
                    "Statistic": [stat_result.statistic],
                    "P-Value": [stat_result.pvalue]
                }).to_excel(writer, sheet_name="Results")
            
            QMessageBox.information(self, "Success", f"Results saved to:\n{output_path}")
            
        except Exception as e:
            QMessageBox.critical(self, "Error", f"An error occurred:\n{str(e)}")

if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = OdorAnalyzer()
    window.show()
    sys.exit(app.exec_())

Key tips for this step:

• Double-check the class name in ui-main.py (it’s usually Ui_MainWindow, but confirm to avoid import errors).
• Connect all relevant UI elements (buttons, dropdowns) to your methods using PyQt’s signal-slot system.
• Wrap your calculation logic in a try-except block to catch errors and display user-friendly messages instead of crashing.

c. Test the Integrated App #

Run the app from your Anaconda environment to validate everything works:

python main_app.py

Fix any UI connection issues or calculation bugs before moving to portability.

2. Create a Portable Standalone Executable #

We’ll use PyInstaller (the most reliable tool for PyQt5 portability) to package your app into a single, runnable file.

a. Install PyInstaller in Your Anaconda Env #

conda install -c conda-forge pyinstaller

b. Build the Portable Executable #

Run this command from your project directory:

pyinstaller --onefile --windowed --name "OdorAnalyzer" main_app.py

Breakdown of the flags:

• --onefile: Packages all dependencies into a single executable (ideal for portability).
• --windowed: Hides the console window when the app runs (use --console instead if you need debug logs).
• --name "OdorAnalyzer": Sets the name of the output executable file.

c. Locate the Portable File #

After the build finishes, you’ll find the standalone executable in the dist folder of your project. This file can be copied to any machine (matching your build OS) and run without needing Python or Anaconda installed.

d. Troubleshooting Common Issues #

• Missing dependencies: If the app fails to launch, run the executable from a terminal to see error messages. Use --hidden-import to explicitly include missing packages (e.g., --hidden-import scipy.stats).
• UI resources not loading: If your UI uses icons or images, include them with --add-data (e.g., --add-data "icons/*.png;icons" on Windows, --add-data "icons/*.png:icons" on macOS/Linux).
• Large executable size: This is normal since PyInstaller packages the entire Python environment. To reduce size, build from a minimal Anaconda environment (only install required packages) or use upx to compress the executable.

内容的提问来源于stack exchange，提问作者Graygood