Can I somehow "compile" a python script to work on PC without Python installed?

Solution 1:

Here is one way to do it (for Windows, using py2exe).

First, install the py2exe on your Windows box.

Then create a python script named compile.py, like this:

import sys
from distutils.core import setup
import py2exe

entry_point = sys.argv[1]
sys.argv.pop()
sys.argv.append('py2exe')
sys.argv.append('-q')

opts = {
    'py2exe': {
        'compressed': 1,
        'optimize': 2,
        'bundle_files': 1
    }
}

setup(console=[entry_point], options=opts, zipfile=None)

To compile your Python script into a Windows executable, run this script with your program as its argument:

$ python compile.py myscript.py

It will spit out a binary executable (EXE) with a Python interpreter compiled inside. You can then just distribute this executable file.

Solution 2:

PyInstaller has worked well for me, generating reasonably small packages due to its use of upx. Its dependency detection was better than py2exe at the time as well. It seems not to have a lot of recent development and probably doesn't work with 3.x, however.

The source in the repository is a better starting point than the 1.4 package.

Also see the wiki page about working with Python 2.6+.

From the features list:

• Packaging of Python programs into standard executables, that work on computers without Python installed.
• Multiplatform: works under Windows (32-bit and 64-bit), Linux (32-bit and 64-bit) and Mac OS X (32-bit only for now, see MacOsCompatibility).
• Multiversion: works under any version of Python from 1.5 up to 2.7. NOTE: If you're using Python 2.6+ on Windows, see Python26Win.
• Flexible packaging mode:
• Single directory: build a directory containing an executable plus all the external binary modules (.dll, .pyd, .so) used by the program.
• Single file: build a single executable file, totally self-contained, which runs without any external dependency.
• Custom: you can automate PyInstaller to do whatever packaging mode you want through a simple script file in Python.
• Explicit intelligent support for many 3rd-packages (for hidden imports, external data files, etc.), to make them work with PyInstaller out-of-the-box (see SupportedPackages).
• Full single-file EGG support: required .egg files are automatically inspected for dependencies and bundled, and all the egg-specific features are supported at runtime as well (entry points, etc.).
• Partial directory EGG support: required .egg directories are automatically inspected for dependencies and bundled, but egg-specific features will not work at runtime.
• Automatic support for binary libraries used through ctypes (see CtypesDependencySupport for details).
• Support for automatic binary packing through the well-known UPX compressor.
• Optional console mode (see standard output and standard error at runtime).
• Windows-specific features:
• Support for code-signing executables.
• Full automatic support for CRTs: no need to manually distribute MSVCR*.DLL, redist installers, manifests, or anything else; true one-file applications that work everywhere!
• Selectable executable icon.
• Fully configurable version resource section and manifests in executable.
• Support for building COM servers.
• Mac-specific features:
• Preliminar support for bundles (see MacOsCompatibility)

Solution 3:

You want something like py2exe.

Solution 4:

There are multiple solutions like py2exe, cx-freeze or (only for Mac OS X) py2app.

Solution 5:

Here is a list of them.