How To Use Python On Linux – Python Installation Steps

by

Python on Linux gives you direct access to system resources through the command line, making scripting more efficient. If you’re wondering how to use python on linux, you’ve come to the right place. This guide walks you through everything from installation to running scripts, managing packages, and automating tasks. Linux and Python are a natural pair, and by the end of this article, you’ll be comfortable using Python for system administration, data processing, and more.

Let’s start with the basics. Python comes pre-installed on most Linux distributions, but you might need to check the version and set up a proper environment. We’ll cover that first, then move to practical usage.

Checking Python Installation On Linux

Before you begin, verify if Python is already installed. Open your terminal and type:

python --version

Or for Python 3 specifically:

python3 --version

If you see a version number, you’re good to go. If not, you’ll need to install it. Most modern Linux distros include Python 3 by default, but older systems might only have Python 2. For this guide, we’ll focus on Python 3.

Installing Python If Missing

On Debian-based systems like Ubuntu, use:

sudo apt update
sudo apt install python3

For Red Hat-based systems like Fedora:

sudo dnf install python3

On Arch Linux:

sudo pacman -S python

After installation, verify again with python3 --version. You should see a version like Python 3.10.12 or similar.

How To Use Python On Linux

Now that Python is installed, let’s dive into actual usage. There are several ways to run Python code on Linux, each suited for different tasks.

Running Python In Interactive Mode

The simplest way is to open the Python interpreter directly in your terminal. Type:

python3

You’ll see a prompt like >>>. Here you can type Python commands and see immediate results. For example:

>>> print("Hello, Linux!")
Hello, Linux!

Interactive mode is great for testing small snippets or learning syntax. To exit, type exit() or press Ctrl+D.

Running Python Scripts

For anything more than a few lines, save your code in a file with a .py extension. Create a file called hello.py using any text editor:

nano hello.py

Add this content:

print("Hello from Python on Linux!")

Save and exit (Ctrl+O, then Ctrl+X in nano). Run the script with:

python3 hello.py

You should see the output. This is the standard way to execute Python programs on Linux.

Making Scripts Executable

You can make your Python script run like any other command. First, add a shebang line at the top of your script:

#!/usr/bin/env python3

Then make the file executable:

chmod +x hello.py

Now you can run it with just ./hello.py instead of python3 hello.py. This is useful for scripts you use frequently.

Managing Python Packages With Pip

Python’s power comes from its vast ecosystem of packages. Pip is the package installer for Python. Check if it’s installed:

pip3 --version

If not, install it:

sudo apt install python3-pip   # Debian/Ubuntu
sudo dnf install python3-pip   # Fedora

Installing Packages

To install a package, use:

pip3 install requests

This installs the Requests library for making HTTP calls. You can install multiple packages at once:

pip3 install numpy pandas matplotlib

Using Virtual Environments

Virtual environments keep project dependencies separate. Create one with:

python3 -m venv myprojectenv

Activate it:

source myprojectenv/bin/activate

Your terminal prompt will change to show the environment name. Now any packages you install with pip will only affect this environment. To deactivate, type deactivate.

Working With Files And Directories

Python on Linux excels at file manipulation. Here’s how to read and write files:

Reading A File

with open('example.txt', 'r') as file:
    content = file.read()
    print(content)

Writing To A File

with open('output.txt', 'w') as file:
    file.write('This is written by Python on Linux')

You can also list directory contents using the os module:

import os
for file in os.listdir('.'):
    print(file)

Automating System Tasks

Python can interact with the Linux system directly. Use the subprocess module to run shell commands:

import subprocess
result = subprocess.run(['ls', '-l'], capture_output=True, text=True)
print(result.stdout)

This runs the ls -l command and captures its output. You can use this to automate backups, monitor logs, or manage services.

Example: Backup Script

Here’s a simple script that copies files to a backup directory:

#!/usr/bin/env python3
import shutil
import os

source = '/home/user/documents'
destination = '/home/user/backup'

if not os.path.exists(destination):
    os.makedirs(destination)

for file in os.listdir(source):
    full_path = os.path.join(source, file)
    if os.path.isfile(full_path):
        shutil.copy(full_path, destination)
        print(f'Copied {file}')

Save this as backup.py, make it executable, and run it whenever you need a quick backup.

Debugging Python Scripts

When things go wrong, use Python’s built-in debugger. Insert this line in your script:

import pdb; pdb.set_trace()

When execution reaches that point, you’ll enter interactive debugging mode. You can inspect variables, step through code, and find errors. Alternatively, run your script with:

python3 -m pdb script.py

Common Errors And Fixes

  • SyntaxError: Check for missing colons, parentheses, or indentation issues.
  • ModuleNotFoundError: Install the missing package with pip.
  • PermissionError: Use sudo or adjust file permissions.
  • FileNotFoundError: Verify the file path exists.

Using Python For Data Processing

Linux is a popular platform for data science. With packages like Pandas and NumPy, you can process large datasets efficiently.

Installing Data Science Packages

pip3 install pandas numpy matplotlib scikit-learn

Example: Reading A CSV File

import pandas as pd
df = pd.read_csv('data.csv')
print(df.head())
print(df.describe())

This loads a CSV file into a DataFrame and shows summary statistics. You can filter, group, and visualize data directly from the terminal.

Integrating Python With Linux Commands

You can pipe data between Python and other Linux commands. For example, to count words in a file:

cat file.txt | python3 -c "import sys; print(len(sys.stdin.read().split()))"

This reads the file content from stdin, splits it into words, and prints the count. Python scripts can also accept command-line arguments using sys.argv.

Example: Command-Line Argument Parser

#!/usr/bin/env python3
import sys

if len(sys.argv) < 2:
    print("Usage: ./script.py ")
    sys.exit(1)

name = sys.argv[1]
print(f"Hello, {name}!")

Run it with ./script.py Alice to get a personalized greeting.

Setting Up A Python Development Environment

For serious projects, use a code editor or IDE. Popular choices on Linux include:

  • VS Code: Free, with excellent Python support
  • PyCharm: Full-featured IDE for Python
  • Vim/Neovim: Lightweight, terminal-based
  • Geany: Simple and fast

Install VS Code on Ubuntu with:

sudo snap install code --classic

Then install the Python extension for syntax highlighting, debugging, and linting.

Using Jupyter Notebooks

For interactive data analysis, Jupyter Notebooks are invaluable. Install with:

pip3 install jupyter

Launch with:

jupyter notebook

This opens a web interface where you can write and execute Python code in cells, mix with markdown, and see visualizations inline.

Scheduling Python Scripts With Cron

Linux’s cron daemon lets you run Python scripts automatically at set times. Edit your crontab with:

crontab -e

Add a line to run a script daily at 2 AM:

0 2 * * * /usr/bin/python3 /home/user/scripts/backup.py

Make sure to use the full path to Python and your script. Cron jobs run with a minimal environment, so test your script manually first.

Optimizing Python Performance On Linux

Linux offers tools to profile and optimize Python code. Use the time command to measure execution:

time python3 script.py

For detailed profiling, use Python’s built-in profiler:

python3 -m cProfile script.py

This shows which functions take the most time. You can also use memory_profiler to track memory usage:

pip3 install memory_profiler
python3 -m memory_profiler script.py

Common Pitfalls And How To Avoid Them

  • Using Python 2 instead of Python 3: Always use python3 explicitly.
  • Forgetting to activate virtual environment: Check your prompt for the environment name.
  • Mixing tabs and spaces: Python 3 doesn’t allow mixing; use spaces consistently.
  • Running scripts with sudo unnecessarily: Only use sudo when you need system-level access.
  • Ignoring file permissions: Ensure scripts are executable with chmod +x.

Frequently Asked Questions

How Do I Check Which Python Version Is Installed On Linux?

Open terminal and run python3 --version. This shows the installed Python 3 version. For Python 2, use python --version if available.

Can I Use Python On Linux Without Sudo?

Yes, you can run Python scripts without sudo. For package installation, use virtual environments or install packages with --user flag: pip3 install --user package_name.

What Is The Best Way To Learn Python On Linux?

Start with interactive mode for basics, then write small scripts. Use online resources like the official Python tutorial, and practice by automating simple tasks on your system.

How Do I Fix “Command Not Found” For Python?

Install Python using your package manager. For Ubuntu: sudo apt install python3. For Fedora: sudo dnf install python3. Then verify with python3 --version.

Can I Run Python Scripts From Any Directory?

Yes, if you provide the full path or add the script’s directory to your PATH. Alternatively, navigate to the script’s directory and run ./script.py after making it executable.

Conclusion

Learning how to use python on linux opens up a world of automation and development possibilities. From simple scripts to complex data pipelines, Python integrates seamlessly with the Linux environment. Start with the basics we covered here, experiment with small projects, and gradually take on more challenging tasks. The combination of Python’s simplicity and Linux’s power is hard to beat. Practice regularly, and you’ll soon be writing efficient scripts that save you time and effort. Remember to use virtual environments for project isolation, leverage pip for package management, and explore the extensive standard library. With these skills, you’re well on your way to becoming proficient in Python on Linux.