如何在打包Python EXE时仅含必要Python组件以缩减体积？

Great question—reducing the footprint of your Python EXE beyond just excluding third-party modules is totally doable, and there are several targeted tweaks for cx_Freeze and alternative tools that let you strip out unnecessary parts of the Python standard library and core runtime. Let’s break this down:

cx_Freeze gives you granular control over what gets included in your build—here’s how to cut out Python standard library bloat:

• Fine-tune module inclusion/exclusion
  Use the excludes parameter in your setup.py to explicitly drop entire standard library modules you don’t need. For example, if your app doesn’t use GUI tools, testing frameworks, or email functionality:

  build_exe_options = {
      "excludes": ["tkinter", "unittest", "email", "json", "xml"],
      "includes": ["your_required_modules"],
      "packages": []
  }
  

  Pro tip: Run your app and use sys.modules.keys() to list exactly which modules are loaded at runtime—this helps you identify safe modules to exclude without breaking functionality.

• Zip core packages to reduce file count and size
  Enable zip_include_packages to bundle most of the Python standard library into a single zip file (instead of hundreds of loose .pyc files). This automatically compresses the code and cleans up the build directory:

  build_exe_options = {
      "zip_include_packages": ["*"],
      "zip_exclude_packages": [],  # Leave empty unless you need specific packages unzipped
      "excludes": ["tkinter", "unittest"]
  }
  

• Optimize bytecode during build
  Add the --optimize=2 flag when running your setup script to compile your code into optimized bytecode (removes comments, docstrings, and unused code):

  python setup.py build --optimize=2
  

If cx_Freeze’s optimizations aren’t enough, consider these tools built specifically for smaller footprint builds:

• PyInstaller
  PyInstaller has robust size-reduction features out of the box:

  • Use --onefile to bundle everything into a single executable (you can then compress it further with UPX).
  • Exclude modules directly with --exclude-module (e.g., pyinstaller your_script.py --exclude-module tkinter --exclude-module unittest).
  • Integrate UPX compression with --upx-dir /path/to/upx to shrink compiled binaries significantly.
  • Run pyinstaller --clean to clear cached build files and avoid including outdated dependencies.

• Nuitka
  Nuitka takes a unique approach: it compiles your Python code directly to C, then builds a native executable. This eliminates the need to bundle the entire Python interpreter—only the compiled code and essential C dependencies are included. The resulting EXE is often much smaller than those from cx_Freeze or PyInstaller. Basic command:

  nuitka --standalone --onefile your_script.py
  

• Minimize your dependency tree first
  Use tools like pipreqs to generate a requirements.txt with only the packages your app actually uses. Avoid installing extra dev dependencies in the environment you use for building—this ensures site-packages doesn’t have unnecessary files.

• Avoid importing entire libraries
  Instead of import requests, use from requests import get if that’s all you need. While some bundlers might still include the full library, this helps with manual exclusion and reduces runtime module loading overhead.

• Test after every exclusion
  It’s easy to accidentally exclude a critical core module (like os or sys). Always run your compiled EXE after making changes to catch missing dependencies early.

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