PyInstaller打包Windows应用的折中方案咨询

Hey there! I totally get your frustration—PyInstaller's OneFile mode is great for clean distribution, but that slow unpacking on launch can be a real drag, and sending out a loose directory feels risky for keeping your app's files intact. Let's break down some practical workarounds that balance speed, integrity, and ease of use:

1. Onedir模式 + 轻量自解压包 #

This is probably the most straightforward middle ground. Here's how it works:

• First, package your app using PyInstaller's default onedir mode (skip the --onefile flag). This generates a directory with your main executable and all supporting files/dependencies.
• Use a tool like 7-Zip's Self-Extracting (SFX) module to wrap this entire directory into a single executable file. You can configure the SFX to automatically extract the directory to a temporary system folder (like %TEMP%\YourAppName) when launched, run your main executable, and even clean up the temporary files after the app closes.
• Example command for 7-Zip:

  7z a -sfx YourApp.exe ./dist/YourAppDir/*
  

  You can tweak the SFX settings via a config file to control the extraction path, auto-run behavior, and cleanup rules—so users only ever see a single file to double-click, no messy directories to deal with.

2. Embed support files and load them on demand #

Instead of unpacking everything at launch, embed your support files directly into the main executable and only extract/load them when needed:

• Use PyInstaller's --add-data flag to bundle your support files, but instead of placing them in the output directory, write a custom script to embed them as binary resources in the executable. You can use libraries like pywin32 or even raw ctypes to access Windows' resource API and read these files.
• For example, if your app needs a config.json file only when initializing settings, write a helper function that extracts this file from the embedded resource to a temporary in-memory file or a small temp file on disk, uses it, then discards it. This way, you avoid the full unpacking hit of OneFile, since only necessary files are loaded when required.

3. Use a virtual filesystem to read files directly from a bundle #

If you want to avoid unpacking entirely, package your support files into a compressed archive (like a ZIP) and read them directly from the archive without extracting to disk:

• Bundle your support files into a ZIP archive, then either distribute it alongside your main executable or embed it into the executable using PyInstaller's --add-data.
• In your Python code, use libraries like zipfile or pyzipper to open the archive and read files directly from it. For example, instead of opening ./assets/icon.png, you'd open zipfile.ZipFile('resources.zip').open('assets/icon.png') and load the content into memory.
• This method keeps your distribution clean (either one file + one ZIP, or a single embedded file) and skips all unpacking overhead, since files are read directly from the compressed bundle.

Quick Notes #

• For the SFX method, make sure your app has permissions to write to the system's temporary directory (most standard user accounts will have this, but it's worth testing).
• When embedding resources, be mindful of executable size—if you have large support files, embedding them might bloat your exe, but it's still faster than OneFile's full unpack.
• For DLLs or other binary dependencies that need to be loaded by the system, you might still need to extract them to a temp directory, but you can do this only once at launch for critical dependencies, not all files.

备注：内容来源于stack exchange，提问作者Sterling Butters