How to use the command 'pypy' (with examples)

This article provides examples of various use cases for the ‘pypy’ command, which is a fast and compliant alternative implementation of the Python language.

Use case 1: Start a REPL (interactive shell)

Code:

pypy

Motivation: Starting a REPL allows you to quickly test out Python code and experiment with different language features without the need for writing a complete script. It is especially useful for interactive debugging and exploration.

Explanation: When you simply run the ‘pypy’ command without any arguments, it starts a Read-Eval-Print Loop (REPL) interactive shell. This shell allows you to enter Python expressions or statements interactively and immediately see the results.

Example output:

Python 2.7.18 (7.3.7+dfsg-1~ppa1~20.04, Feb 03 2023, 17:42:47)
[PyPy 7.3.7 with GCC 9.3.0] on linux
Type "help", "copyright", "credits" or "license" for more information.
And now for something completely different: ``PyPy is the fastest Python implementation, running around five times faster than the standard implementation on long-running benchmarks and often faster on short-running programs.''  (wink)
>>> print("Hello, world!")
Hello, world!

Use case 2: Execute script in a given Python file

Code:

pypy path/to/file.py

Motivation: Executing a Python script allows you to run a sequence of Python statements or functions saved in a file. This is useful when you have a larger program or functionality that needs to be executed as a whole.

Explanation: The ‘pypy’ command followed by the path to a Python file executes the script written in that file. It runs the code within the file, from top to bottom, executing any statements or function calls that are present.

Example output:

Assuming the ‘file.py’ contains the following code:

print("Hello, World!")

Hello, World!

Use case 3: Execute script as part of an interactive shell

Code:

pypy -i path/to/file.py

Motivation: Executing a script in an interactive shell allows you to run the script and then continue interacting with the environment, which can be useful for debugging or further exploration.

Explanation: The ‘-i’ option specified after the ‘pypy’ command makes the interpreter enter interactive mode after executing the script in the specified file. This allows you to interact with the environment after the script execution has completed.

Example output:

Assuming the ‘file.py’ contains the following code:

x = 10
print(x)

10
>>> x
10

Use case 4: Execute a Python expression

Code:

pypy -c "expression"

Motivation: Executing a single Python expression allows you to quickly evaluate and get the result of a simple or complex expression without the need to write a script or enter a full interactive shell.

Explanation: The ‘-c’ option followed by the Python expression enclosed in quotes allows you to execute the provided expression directly from the command line. The result of the expression is then printed to the console.

Example output:

pypy -c "2 + 3 * 4"

14

Use case 5: Run library module as a script

Code:

pypy -m module arguments

Motivation: Running a library module as a script allows you to directly execute a Python module that is designed to be run as a script or has a script-like functionality. This is useful when you want to utilize the features provided by a specific module from the command line.

Explanation: The ‘-m’ option followed by the module name and any necessary arguments allows you to run a specific Python module as a script. This is commonly used for modules that provide functionality for command-line execution, like ‘unittest’ or ‘json’.

Example output:

pypy -m unittest discover -s tests

.....
----------------------------------------------------------------------
Ran 5 tests in 0.004s

OK

Use case 6: Install a package using pip

Code:

pypy -m pip install package

Motivation: Installing a package using pip allows you to easily add new functionality to your Python environment. Using ‘pypy’ instead of the standard ‘pip’ command can provide potential performance advantages when working with large packages or complex dependencies.

Explanation: The ‘-m pip’ option followed by the ‘install’ command and the name of the package allows you to install the specified package using pip. This command will download the package from the Python Package Index (PyPI) and install it in your Python environment.

Example output:

pypy -m pip install requests

Collecting requests
  Downloading requests-2.27.1-py2.py3-none-any.whl (66 kB)
     |████████████████████████████████| 66 kB 1.1 MB/s
Installing collected packages: requests
Successfully installed requests-2.27.1

Use case 7: Interactively debug a Python script

Code:

pypy -m pdb path/to/file.py

Motivation: Interactively debugging a Python script allows you to step through the code and inspect variables, helping you identify and solve issues in your script’s logic or behavior. The ‘pdb’ module provides a powerful debugger for Python.

Explanation: The ‘-m pdb’ option followed by the path to a Python file enables interactive debugging for that script. It starts the debugger from the beginning of the script execution, allowing you to set breakpoints, step through the code, and examine variables at each step.

Example output:

Assuming the ‘file.py’ contains the following code:

def divide(num1, num2):
    result = num1 / num2
    return result

x = 10
y = 0
divide(x, y)

> path/to/file.py(1)<module>()
-> def divide(num1, num2):
(Pdb) n
> path/to/file.py(5)<module>()
-> x = 10
(Pdb) s
--Call--
> path/to/file.py(1)divide()
-> def divide(num1, num2):
(Pdb) p num1
10
(Pdb) p num2
0
(Pdb) c
Traceback (most recent call last):
  File "path/to/file.py", line 9, in <module>
    divide(x, y)
  File "path/to/file.py", line 3, in divide
    result = num1 / num2
ZeroDivisionError: division by zero
> path/to/file.py(9)<module>()
-> divide(x, y)
(Pdb) quit

Conclusion:

The ‘pypy’ command provides a fast and compliant alternative implementation of Python. It offers various use cases such as starting a REPL, executing scripts, running expressions, installing packages, and debugging scripts. Understanding these different use cases can help Python developers become more efficient and productive in their work.