How To Run Python Script in Linux

Python is a versatile and powerful programming language that has gained immense popularity among developers worldwide. Its simplicity, readability, and extensive library support make it an ideal choice for a wide range of applications, from web development to data analysis and machine learning. Linux, being a robust and open-source operating system, provides an excellent platform for running Python scripts. In this comprehensive guide, we will explore various methods to run Python scripts in Linux, along with step-by-step instructions, troubleshooting tips, and additional resources to help you master the art of Python scripting on Linux.

Table of Contents

Prerequisites

Before we dive into the different ways to run Python scripts in Linux, let’s ensure that you have the necessary prerequisites in place:

Python Installation: Most Linux distributions come with Python pre-installed. To check if Python is installed on your system, open a terminal and type python --version or python3 --version. If Python is not installed, you can easily install it using your distribution’s package manager. For example, on Ubuntu or Debian, you can run sudo apt-get install python3 to install Python 3.
Text Editor: To write Python scripts, you’ll need a text editor. Linux offers a wide range of text editors, such as Vim, Emacs, Gedit, and Sublime Text. Choose the one that suits your preferences and install it if necessary.

Running Python Scripts from the Command Line

The most straightforward way to run a Python script in Linux is through the command line. Follow these steps to execute your Python script:

Open a Terminal: Launch the terminal application on your Linux system. You can usually find it in the applications menu or by pressing Ctrl+Alt+T.
Navigate to the Script Directory: Use the cd command to navigate to the directory where your Python script is located. For example, if your script is in the Documents folder, type cd Documents.
Run the Script: Once you are in the correct directory, you can run the Python script by typing python script_name.py or python3 script_name.py, replacing script_name.py with the actual name of your script file.

For instance, let’s say you have a script named hello.py with the following content:

print("Hello, World!")

To run this script, navigate to its directory and execute the following command:

python3 hello.py

You should see the output Hello, World! printed in the terminal.

Making Python Scripts Executable

Instead of explicitly invoking the Python interpreter every time you want to run a script, you can make the script itself executable. Here’s how:

Add Shebang Line: Open your Python script in a text editor and add the following line at the very top of the file:

#!/usr/bin/env python3

This line, known as the shebang, specifies the interpreter to be used for executing the script.

Make the Script Executable: Save the script and make it executable by running the following command in the terminal:

chmod +x script_name.py

Replace script_name.py with the actual name of your script file.

Run the Script: Now you can run the script directly by typing ./script_name.py in the terminal, without explicitly mentioning python or python3.

Running Python Scripts with Arguments

Python scripts can accept command-line arguments, allowing you to pass values or options to the script at runtime. Here’s an example of how to handle command-line arguments in your Python script:

import sys

if len(sys.argv) > 1:
    name = sys.argv[1]
    print(f"Hello, {name}!")
else:
    print("Please provide a name as an argument.")

In this script, we use the sys.argv list to access the command-line arguments. The first element of sys.argv is always the name of the script itself, and subsequent elements represent the arguments passed to the script.

To run this script with an argument, use the following command:

python3 script_name.py Meilana

The script will output Hello, Meilana!. If no argument is provided, it will display the message Please provide a name as an argument.

Running Python Scripts in an IDE

Integrated Development Environments (IDEs) provide a convenient way to write, debug, and run Python scripts. Popular Python IDEs include PyCharm, Visual Studio Code, and Sublime Text. Here’s a general workflow for running Python scripts in an IDE:

Install the IDE: Download and install your preferred Python IDE on your Linux system. Most IDEs provide installation instructions on their official websites.
Create a New Project: Launch the IDE and create a new project or open an existing one. Specify the project directory and select the Python interpreter to be used.
Write the Python Script: Create a new Python file within the project and write your script using the IDE’s text editor.
Run the Script: Most IDEs provide a “Run” button or menu option to execute the script. Alternatively, you can right-click on the script file and select “Run” or use a keyboard shortcut (e.g., Ctrl+Shift+F10 in PyCharm).

IDEs offer additional features like syntax highlighting, code completion, debugging tools, and integrated terminals, making the development process more efficient and enjoyable.

Troubleshooting Tips

If you encounter issues while running Python scripts in Linux, here are a few troubleshooting tips:

Permission Denied: If you receive a “Permission Denied” error when trying to run a script, ensure that the script file has executable permissions. Use the chmod +x script_name.py command to grant execute permissions.
Incorrect Interpreter: Verify that you are using the correct Python interpreter version. Use python --version or python3 --version to check the installed Python versions. Make sure the shebang line in your script matches the desired interpreter.
Module Not Found: If you get a “ModuleNotFoundError,” ensure that the required modules or libraries are installed. Use pip or pip3 to install missing dependencies. For example, pip3 install module_name.
Syntax Errors: Double-check your script for syntax errors. Python is sensitive to indentation, so make sure your code is properly indented. IDEs often provide syntax highlighting and error detection to help identify and fix syntax issues.