How to compile and run Python code on Linux Ubuntu Terminal

Although compiling Python code (for an interpreted language) is not a common practice among many Python programmers, there are scenarios where compiling Python code on Linux can be beneficial.

These requirements/needs from a coder may require a Python programmer to compile Python code:

1. By converting the code to a binary executable, the interpreter overhead is reduced, resulting in faster execution. Thus, slightly high-performance Python program.
2. Compiling Python code allows you to distribute your application as a standalone executable, which can be convenient when you want to share your code with others who may not have Python or the required dependencies installed.
3. Compiling your Python code can help protect your intellectual property by making it harder to reverse engineer. Although it’s not foolproof, compiling the code can add an extra layer of obfuscation.

With such needs, a compiled Python program may well suit your objectives.

But the initial question that still lingers in many Python programmers is:

Can you compile Python on Linux?

You can compile Python code on Linux. The process of compiling Python code involves the creation of bytecode files (.pyc).

However, note that the bytecode files created during compilation are not entirely converted into native machine code.

Here are the key differences between the two:

Bytecode (.pyc file)	Native machine code
Bytecode is an intermediate representation of the Python code that is generated by the Python compiler.	Native machine code, on the other hand, is specific to the underlying hardware and operating system.
It is a low-level, platform-independent representation of the code.	Native machine code is highly optimized for the specific architecture and can execute more efficiently than bytecode.
Bytecode is executed by the Python interpreter, which interprets and executes the bytecode instructions.	Native machine code consists of instructions that the processor can directly execute.
The bytecode is stored in .pyc files and can be executed on any system with a compatible Python interpreter.	Native machine code is produced by compiling a programming language directly into machine code using a compiler specific to the target platform.

In summary, the bytecode generated during the compilation of Python code is a lower-level representation of the code, but it is not directly executable by the hardware.

It requires a Python interpreter to interpret and execute the bytecode instructions.

If you are using Visual Studio Code in your Linux machine, you can use the Integrated Terminal to compile your Python code.

This is beneficial because you can compile your code even when you are running a different operatings system such as Windows or MacOs.

To compile Python code in Visual Studio Code, check out this guide I have written for you.

Now that you know how Python code is compiled, let’s explore how you can compile Python code on Linux.

How do I compile a Python file in Linux?

Before we begin, ensure that you have Python installed on your Linux system (Kali Linux, Ubuntu, etc).

Open a terminal

To open the terminal windows on most Debian systems, press CTRL + ALT + T. Alternatively, you can search the Terminal app icon in the Apps list and click to open it.

The Terminal app should look like this:

After opening the Terminal, type the following command to check that you have an active Python installation on your computer/laptop:

python3 --version

If you have Python installed, you should see the following results:

Python 3.x.x

If Python is not installed on your Ubuntu machine, you can install it using the package manager specific to your distro.

For example, on Ubuntu, you can use the apt package manager:

sudo apt install python3

Once you’re done with confirming the Python version or installing it, you can compile your Python file in the Terminal like this:

Compiling Python file:

To compile a Python file, navigate to the directory where the file is located using the cd command.

For example:

cd /path/to/your/python/file/

Once you are in the correct directory, use the following command to compile the Python file:

python3 -m py_compile your_python_file.py

This command will create a bytecode file with a .pyc extension in the same directory as your Python file. If you do not find it there, look for your .pyc files inside the newly created directory named __pycache_.

ls __pycache__

Your bytecode files should be listed here.

Why use py_compile?

py_compile is a module in Python’s standard library that provides functions for compiling Python source files into bytecode files (.pyc).

It is used to create optimized bytecode representations of Python scripts, which can be executed by the Python interpreter more efficiently.

The py_compile module offers a simple way to compile individual Python files without the need for external tools or third-party libraries.

It can be invoked from the command line or used within Python scripts.

The primary function provided by py_compile is compile(). This function takes a source file as input and generates a bytecode file in the same directory.

Here’s the general syntax to use compile():

import py_compile

py_compile.compile('path/to/source/file.py')

The compile() function performs the following steps:

1. It checks if the source file has been modified since the corresponding bytecode file was created. If the source file is unchanged, the compilation process is skipped, and the existing bytecode file is used.
2. If the source file has been modified or no bytecode file exists, the compile() function compiles the source file into bytecode and creates a new bytecode file with a .pyc extension.

Python also provides another module called compileall that offers more flexibility and convenience for batch compilation of multiple Python files.

The compileall module provides functions to recursively compile all Python files in a given directory or directory tree.

It can compile both individual files and entire directories of Python code.

So, if you have multiple Python files that you need to compile, you can compile them using the compileall command.

Here’s

How to compile multiple Python files on Linux Terminal

To compile multiple Python files on the Linux terminal, you can use the compileall module combined with shell commands.

Here’s a how-to guide:

1. Open a terminal

Navigate to the directory that contains the Python files you want to compile.

2. Use the command python3 -m compileall . to complete multiple Python files

The dot (.) specifies the current directory as the target for compilation.

The compileall module will recursively search the current directory and compile all Python files it finds, generating bytecode files (.pyc) alongside the corresponding source files.

Both the py_compile and compileall modules serve the purpose of creating bytecode files for Python scripts.

The choice between them depends on whether you need to compile a single file or multiple files simultaneously.

Now that you have compiled your Python code, how do you run the bytecode in your Linux system?

How to run a compiled Python file in Linux Terminal

Running a compiled Python file can be a straightforward way to execute your code efficiently.

Here’s how:

a. Open a terminal and navigate to the directory containing the compiled Python file.

cd /path/to/your/compiled/python/file/

b. Use the python3 command followed by the name of the compiled Python file to execute it.

python3 your_compiled_file.pyc

c. The Python interpreter will load the bytecode file and execute the code within it.

You will see the output of your program in the terminal.

Running a compiled Python program is as easy as that!

FAQs

Conclusion

In conclusion, this article has provided comprehensive guidance on compiling and running Python code in the Linux terminal.

We explored the concepts of Python compilation, discussed tools like py_compile and compileall, and learned how to run compiled Python files.

By following the steps outlined here, you can harness the benefits of bytecode compilation and execute your Python programs efficiently.

Whether you’re seeking performance optimizations or distribution options, this knowledge empowers you to navigate the world of Python development on Linux with confidence.

Create, inspire, repeat!