Python Methods for Retrieving PID by Process Name

Introduction

In Linux system administration and process monitoring, retrieving the Process ID (PID) corresponding to a process name is a common requirement. For instance, when monitoring specific application statuses, terminating abnormal processes, or conducting resource analysis, quickly and accurately locating the target process's PID is crucial. This article systematically explores multiple technical approaches to achieve this functionality using the Python programming language.

Core Method: Using subprocess Module to Invoke pidof Command

The most direct and effective approach utilizes Python's subprocess module to call the Linux system's built-in pidof command. The pidof command is specifically designed to find PIDs based on process names, featuring concise syntax and high execution efficiency.

The basic implementation code is as follows:

from subprocess import check_output
def get_pid(name):
    return check_output(["pidof", name])

This code defines a get_pid function that executes the pidof process_name command via check_output and returns the output. Note that check_output raises a CalledProcessError exception when the command returns a non-zero status code, so appropriate error handling should be considered in practical applications.

When the target process may have multiple running instances, pidof returns all relevant PIDs separated by spaces. To handle this data more conveniently in Python, it can be converted to an integer list:

from subprocess import check_output
def get_pid(name):
    return list(map(int, check_output(["pidof", name]).split()))

Here, the split() method divides the output string, and map(int, ...) converts each string to an integer, ultimately returning a PID list. This approach is particularly suitable for applications like Chrome browser that typically maintain multiple processes.

If only a single PID is needed (e.g., the first started process instance), the -s parameter can be added to the pidof command:

def get_pid_single(name):
    return int(check_output(["pidof", "-s", name]))

This method directly returns an integer PID, simplifying subsequent processing.

Alternative Approach: Using psutil Third-party Library

Beyond system command invocation, the powerful psutil (process and system utilities) third-party library can be employed. This library provides cross-platform process and system monitoring capabilities, installed as follows:

pip install psutil

Example code using psutil to retrieve PIDs:

import psutil
process_name = "chrome"
pid = None
for proc in psutil.process_iter(["name", "pid"]):
    if process_name in proc.info["name"]:
        pid = proc.info["pid"]
        break
print("PID:", pid)

This code iterates through all running processes via psutil.process_iter(), checking if each process's name contains the target string. Note that this method may match processes whose names contain but are not identical to the target string (e.g., "chromedriver" would also be matched), so more precise matching conditions may be needed in practice.

The main advantages of the psutil approach are cross-platform compatibility (supporting Windows, Linux, macOS, etc.) and rich process information retrieval capabilities, though it incurs slightly higher performance overhead compared to directly calling the pidof command.

Method Comparison and Selection Recommendations

Comparing the two main methods:

subprocess + pidof approach:

• Advantages: High execution efficiency, directly utilizing native system commands; concise code; particularly suitable for Linux environments
• Disadvantages: Dependency on system commands, limited cross-platform compatibility; requires handling command execution exceptions

psutil approach:

• Advantages: Good cross-platform support; provides rich process information interfaces; no need to handle underlying system commands
• Disadvantages: Requires additional third-party library installation; relatively lower performance; matching logic may need adjustment

Selection recommendations:

1. If the target environment is confirmed to be Linux and high performance is required, the subprocess approach calling pidof command is recommended
2. If cross-platform support is needed, or additional process information beyond PID (such as CPU usage, memory consumption, etc.) is required, psutil is the better choice
3. In production environments, it is advisable to encapsulate core functionality as independent functions or classes, with appropriate exception handling and logging

Practical Application Example

Below is a production-level example incorporating exception handling and logging:

import subprocess
import logging
logging.basicConfig(level=logging.INFO)
def get_pid_safe(process_name, single=True):
    """
    Safely retrieve process PID
    :param process_name: Process name
    :param single: Whether to return only a single PID
    :return: PID (integer) or PID list, returns None on failure
    """
    try:
        if single:
            cmd = ["pidof", "-s", process_name]
            result = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
            return int(result.strip())
        else:
            cmd = ["pidof", process_name]
            result = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
            return [int(pid) for pid in result.strip().split()]
    except subprocess.CalledProcessError as e:
        logging.warning(f"Process '{process_name}' not found or command execution failed: {e.output}")
        return None
    except ValueError as e:
        logging.error(f"PID conversion failed: {e}")
        return None
    except Exception as e:
        logging.error(f"Unknown error: {e}")
        return None

This enhanced version adds comprehensive exception handling mechanisms, properly addressing various edge cases such as non-existent processes, command execution failures, and data conversion exceptions, while providing debugging information through logging.

Conclusion

Retrieving PID by process name is a fundamental operation in system administration and process monitoring. This article details two mainstream implementation approaches: the method based on the subprocess module calling system commands offers efficiency and simplicity, particularly suitable for Linux environments; while the approach using the psutil third-party library provides better cross-platform support and richer functional extensions. Developers should choose appropriate methods based on specific requirements, target environments, and performance considerations, while fully accounting for exception handling and edge cases in practical applications to ensure program robustness and reliability.