Pengantar Python Subprocess: Dasar-Dasar dan Contoh

Kapan menggunakan Python Subprocess

Mari kita lihat kapan sebaiknya menggunakan modul subprocess di Python.

Otomatisasi tugas sistem

Modul subprocess dapat digunakan untuk mengotomatiskan berbagai tugas sistem, seperti menjalankan backup, memulai dan menghentikan layanan, serta penjadwalan cron job. Misalnya, Anda dapat menggunakan modul subprocess untuk menjalankan perintah cp guna membuat salinan cadangan file atau systemctl (Linux modern) atau service (sistem lama) untuk memulai dan menghentikan layanan. Anda juga dapat menggunakan modul subprocess untuk memanggil alat penjadwalan (seperti cron di Linux atau Task Scheduler di Windows), namun penjadwalannya sendiri ditangani oleh alat tersebut, bukan oleh subprocess.

Menjalankan alat baris perintah

Modul subprocess dapat digunakan untuk menjalankan alat baris perintah seperti grep, sed, dan awk, lalu memproses outputnya di kode Python Anda. Misalnya, Anda dapat menggunakan modul subprocess untuk menjalankan perintah grep guna mencari pola tertentu dalam sebuah file, lalu memproses outputnya di kode Python Anda. Ini berguna untuk tugas seperti analisis log, pemrosesan data, dan manipulasi teks.

Menjalankan executable eksternal

Modul subprocess dapat menjalankan executable lain, seperti file .exe di Windows, dan mengendalikan perilakunya. Misalnya, Anda dapat menggunakan modul subprocess untuk menjalankan executable yang melakukan tugas tertentu lalu menggunakan output executable tersebut dalam kode Anda. Ini berguna untuk pemrosesan gambar, analisis data, dan tugas machine learning.

Menjalankan skrip sebagai proses latar belakang

Anda dapat menggunakan modul subprocess untuk menjalankan skrip sebagai proses latar belakang sehingga skrip tetap berjalan setelah program utama keluar. Misalnya, Anda dapat menggunakan modul subprocess untuk menjalankan skrip yang melakukan tugas tertentu dan keluar dari program utama tanpa menunggu skrip selesai. Ini berguna untuk pemantauan, pencatatan, dan pengumpulan data.

Menjalankan skrip dengan interpreter non-Python

Modul subprocess dapat membantu Anda menjalankan skrip yang ditulis dalam bahasa lain seperti Perl, Ruby, dan Bash. Misalnya, Anda dapat menggunakan modul subprocess untuk menjalankan skrip Perl yang melakukan tugas tertentu dan kemudian menggunakan output skrip tersebut dalam kode Anda. Ini berguna untuk pemrosesan data, manipulasi teks, dan administrasi sistem.

Pemrosesan paralel

Modul subprocess dapat digunakan untuk menjalankan banyak proses secara paralel, yang berguna untuk tugas seperti pemrosesan gambar, analisis data, dan machine learning. Misalnya, Anda dapat menggunakan modul subprocess untuk menjalankan beberapa instance dari skrip yang sama, masing-masing memproses bagian data yang berbeda, lalu menggabungkan hasilnya.

Contoh Python Subprocess 

Sekarang mari kita lihat beberapa contoh penggunaan subprocess di Python.

python subprocess run

Metode subprocess.run() adalah cara praktis untuk menjalankan sebuah subprocess dan menunggu hingga selesai. Anda dapat memilih perintah yang dijalankan dan menambahkan opsi seperti argumen, variabel lingkungan, serta pengalihan input/output. Setelah subprocess dimulai, metode run() akan memblokir hingga subprocess selesai dan mengembalikan objek CompletedProcess, yang berisi kode keluaran dan output subprocess.

Metode subprocess.run() menerima beberapa argumen, di antaranya:

• args: Perintah yang dijalankan beserta argumennya, diberikan sebagai daftar string.

• capture_output: Jika disetel True, akan menangkap standard output dan standard error.

• text: Jika disetel True, akan mengembalikan stdout dan stderr sebagai string, jika tidak maka sebagai bytes.

• check: nilai boolean yang menunjukkan apakah akan memeriksa kode keluaran subprocess; jika check bernilai true dan kode keluaran non-zero, maka akan dilempar CalledProcessError.

• timeout: Nilai dalam detik yang menentukan berapa lama menunggu subprocess selesai sebelum timeout.

• shell: Nilai boolean yang menunjukkan apakah perintah dijalankan di shell. Ini berarti perintah diberikan sebagai string, dan fitur khusus shell seperti ekspansi wildcard dan substitusi variabel dapat digunakan.

Metode subprocess.run() juga mengembalikan objek CompletedProcess, yang memiliki atribut berikut:

• args: Perintah dan argumen yang dijalankan.

• returncode: Kode keluaran dari subprocess.

• stdout: Standard output dari subprocess (string jika text=True, jika tidak bytes).

• stderr: Standard error dari subprocess (string jika text=True, jika tidak bytes).

Contoh 1: Menjalankan perintah shell:

import subprocess

result = subprocess.run("dir", shell=True, capture_output=True, text=True)

print(result.stdout)

Output: 

Volume in drive C has no label.

Volume Serial Number is E414-A41C

 Directory of C:\Users\owner

01/25/2023  10:56 AM    <DIR>          .

01/25/2023  10:56 AM    <DIR>          ..

07/19/2021  01:19 PM    <DIR>          .anaconda

07/19/2021  01:19 PM    <DIR>          .astropy

07/19/2021  01:19 PM    <DIR>          .aws

09/12/2022  08:48 AM               496 .bash_history

03/27/2022  03:08 PM    <DIR>          .cache

09/26/2021  06:58 AM    <DIR>          .conda

09/26/2021  06:59 AM                25 .condarc

…

Di Linux/macOS, gunakan: result = subprocess.run(["ls", "-la"], capture_output=True, text=True) (tidak perlu argumen shell).

Contoh 2: Menjalankan skrip Python:

Anda juga dapat menjalankan skrip Python menggunakan metode subprocess.run(). Mari mulai dengan membuat skrip Python sederhana dalam file .py

print(“This is the output from subprocess module”)

Simpan file ini sebagai file_donot_exist.py. Sekarang, Anda dapat menggunakan modul subprocess untuk menjalankan file ini:

import subprocess
import sys

result = subprocess.run(["python", "file_donot_exist.py"], capture_output=True, text=True, check=False)

print(result.stdout)

Output:

This is the output from subprocess module

Contoh 3: Menjalankan kode Python langsung dari sebuah fungsi:

Untuk kasus sederhana, Anda dapat langsung memberikan perintah python pada fungsi subprocess.run(). Berikut caranya:

result = subprocess.run([sys.executable, "-c", "print('This is directly from a subprocess.run() function')"], capture_output = True, text = True)

print(result.stdout)

Output:

This is directly from a subprocess.run() function

Dalam daftar args, elemen pertama sys.executable akan secara dinamis mengarah ke path interpreter Python yang sedang berjalan. Ini memastikan konsistensi dengan proses yang berjalan dan menghindari path hard-coded seperti "C:/...". Elemen kedua, "-c", menjalankan string berikutnya sebagai kode Python alih-alih skrip. Selalu sertakan import sys untuk mengakses sys.executable.

Contoh 4: Menggunakan argumen check

Argumen check adalah argumen opsional dari fungsi subprocess.run() dalam modul subprocess Python. Ini adalah nilai boolean yang mengontrol apakah fungsi harus memeriksa kode keluaran dari perintah yang dijalankan.

Saat check disetel ke True, fungsi akan memeriksa kode keluaran perintah dan melempar pengecualian CalledProcessError jika kode keluarannya non-zero. Pengecualian ini memiliki atribut return code, stdout, stderr, dan command.

Saat check disetel ke False (default), fungsi tidak akan melempar pengecualian meskipun perintah gagal — sebagai gantinya, Anda perlu memeriksa sendiri kode keluarannya.

import subprocess

result = subprocess.run(["python", "file_donot_exist.py"], capture_output=True, text=True, check=True)

print(result.stdout)

print(result.stderr)

Output:

---------------------------------------------------------------------------

CalledProcessError                        Traceback (most recent call last)

<ipython-input-81-503b60184db8> in <module>

      1 import subprocess

----> 2 result = subprocess.run(["python", "file_donot_exist.py"], capture_output=True, text=True, check=True)

      3 print(result.stdout)

      4 print(result.stderr)

~\anaconda3\lib\subprocess.py in run(input, capture_output, timeout, check, *popenargs, **kwargs)

    514         retcode = process.poll()

    515         if check and retcode:

--> 516             raise CalledProcessError(retcode, process.args,

    517                                      output=stdout, stderr=stderr)

    518     return CompletedProcess(process.args, retcode, stdout, stderr)

CalledProcessError: Command '['python', 'file_donot_exist.py']' returned non-zero exit status 2.

Perhatikan bahwa perintah gagal karena my_python_file2.py tidak ada, dan karena check=True diberikan, sebuah CalledProcessError dilempar. Jika Anda menyetel check=False (atau menghilangkannya sama sekali), proses Anda tidak akan melempar pengecualian; sebagai gantinya, Anda akan melihat pesan error di stderr dan dapat memutuskan sendiri cara menanganinya.

import subprocess

result = subprocess.run(["python", "my_python_file2.py"], capture_output=True, text=True, check=False)

print(result.stdout)

print(result.stderr)

Output:

python: can't open file 'my_python_file2.py': [Errno 2] No such file or directory

python subprocess Popen

subprocess.Popen() adalah antarmuka level lebih rendah untuk menjalankan subprocess, sedangkan subprocess.run adalah pembungkus level lebih tinggi di atas Popen yang dirancang agar lebih nyaman digunakan.

Popen memungkinkan Anda memulai proses baru dan berinteraksi dengan aliran standar input, output, dan error-nya. Fungsi ini mengembalikan handle ke proses yang berjalan yang dapat digunakan untuk menunggu proses selesai, memeriksa kode keluarannya, atau menghentikannya.

run() adalah fungsi yang lebih nyaman karena memungkinkan Anda menjalankan perintah dan menangkap outputnya dalam satu pemanggilan, tanpa perlu membuat objek Popen dan mengelola stream sendiri. Anda juga dapat menentukan berbagai opsi untuk menjalankan perintah, seperti apakah akan melempar pengecualian jika perintah gagal.

Secara umum, gunakan run() jika Anda hanya perlu menjalankan perintah dan menangkap outputnya, dan gunakan Popen jika Anda memerlukan kontrol lebih atas proses, seperti berinteraksi dengan stream input dan outputnya.

Kelas Popen menerima argumen yang sama seperti run(), termasuk args yang menentukan perintah yang akan dijalankan dan argumen opsional lain seperti stdin, stdout, stderr, shell, cwd, dan env. Selain itu, kelas Popen memiliki beberapa metode yang memungkinkan Anda berinteraksi dengan proses, seperti communicate(), poll(), wait(), terminate(), dan kill().

import subprocess

p = subprocess.Popen(["python", "--help"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)

output, errors = p.communicate()

print(output)

Output:

usage: python [option] ... [-c cmd | -m mod | file | -] [arg] ...

Options and arguments (and corresponding environment variables):

-b     : issue warnings about str(bytes_instance), str(bytearray_instance)

         and comparing bytes/bytearray with str. (-bb: issue errors)

-B     : don't write .pyc files on import; also PYTHONDONTWRITEBYTECODE=x

-c cmd : program passed in as string (terminates option list)

-d     : debug output from parser; also PYTHONDEBUG=x

-E     : ignore PYTHON* environment variables (such as PYTHONPATH)

…

Ini akan menjalankan perintah python –help dan membuat objek Popen baru, yang disimpan dalam variabel p. Standard output dan error dari perintah ditangkap menggunakan metode communicate() dan masing-masing disimpan dalam variabel output dan errors.

subprocess.Popen berguna saat Anda menginginkan kontrol lebih atas proses, seperti mengirim input, menerima output, atau menunggu proses selesai.

python subprocess call

subprocess.call() adalah fungsi dalam modul subprocess Python yang digunakan untuk menjalankan perintah dalam proses terpisah dan menunggu hingga selesai. Fungsi ini mengembalikan kode keluaran perintah, yang bernilai nol jika perintah berhasil, dan non-zero jika gagal.

Fungsi call() menerima argumen yang sama seperti run(), termasuk args yang menentukan perintah yang akan dijalankan, dan argumen opsional lain seperti stdin, stdout, stderr, shell, cwd, dan env.

Standard output dan error dari perintah akan dikirim ke stdout dan stderr yang sama dengan proses induk kecuali Anda mengalihkannya menggunakan argumen stdout dan stderr.

import sys
import subprocess

return_code = subprocess.call([sys.executable, "--version"])

if return_code == 0:
    print("Command executed successfully.")
else:
    print("Command failed with return code", return_code)

Output:

Command executed successfully.

Ini akan menjalankan perintah python -–version dalam proses terpisah dan menunggu hingga selesai. Kode keluaran perintah akan disimpan dalam variabel return_code, yang akan bernilai nol jika perintah berhasil, dan non-zero jika gagal.

subprocess.call() berguna ketika Anda ingin menjalankan perintah dan memeriksa kode keluarannya, tetapi tidak perlu menangkap outputnya.

python subprocess check_output

check_output adalah fungsi dalam modul subprocess yang mirip dengan run(), tetapi hanya mengembalikan standard output dari perintah, dan melempar pengecualian CalledProcessError jika kode keluaran non-zero.

Fungsi check_output() menerima argumen yang sama seperti run(), termasuk args (perintah yang dijalankan) dan argumen opsional seperti stdin, stderr, shell, cwd, dan env. Fungsi ini mengembalikan standard output perintah sebagai objek bytes atau string (jika text=True). Akan melempar CalledProcessError jika perintah gagal (status keluar non-zero).

Catatan: Secara bawaan, check_output() hanya menangkap stdout. Untuk menyertakan stderr dalam output, alihkan secara eksplisit menggunakan stderr=subprocess.STDOUT.

import subprocess
import sys

try:

    output = subprocess.check_output([sys.executable, "--version"], text=True)

    print(output)

except subprocess.CalledProcessError as e:

    print(f"Command failed with return code {e.returncode}")

Output:

Python 3.8.8

Python Subprocess Pipe

Modul subprocess di Python menyediakan cara untuk membuat dan berinteraksi dengan proses anak, yang dapat digunakan untuk menjalankan program atau perintah lain. Salah satu fiturnya adalah kemampuan membuat pipe, yang memungkinkan komunikasi antara proses induk dan anak.

Sebuah pipe adalah saluran komunikasi searah yang menghubungkan standard output satu proses ke standard input proses lain. Pipe dapat menghubungkan output dari satu perintah ke input perintah lain, sehingga output perintah pertama dapat digunakan sebagai input untuk perintah kedua.

Pipe dapat dibuat menggunakan modul subprocess dengan kelas Popen dengan menentukan argumen stdout atau stdin sebagai subprocess.PIPE.

Misalnya, kode berikut membuat pipe yang menghubungkan output perintah ls ke input perintah grep, yang memfilter output untuk hanya menampilkan baris yang mengandung kata "file":

import subprocess


ls_process = subprocess.Popen(["ls"], stdout=subprocess.PIPE, text=True)
grep_process = subprocess.Popen(
    ["grep", "sample"],
    stdin=ls_process.stdout,
    stdout=subprocess.PIPE,
    text=True
)
ls_process.stdout.close()  # POSIX-only: prevents deadlocks by closing the pipe
output, error = grep_process.communicate()


print(output)
print(error)

Output:

sample_data

Dalam contoh ini, kelas Popen digunakan untuk membuat dua proses anak, satu untuk perintah ls dan satu untuk perintah grep. stdout dari perintah ls dihubungkan ke stdin perintah grep menggunakan subprocess.PIPE, yang membuat pipe di antara kedua proses. Metode communicate() digunakan untuk mengirim output dari perintah ls ke perintah grep dan mengambil output yang telah difilter.

Kesimpulan

Modul subprocess di Python menyediakan cara yang kuat dan fleksibel untuk membuat dan berinteraksi dengan proses anak, memungkinkan Anda menjalankan program lain atau memberikan perintah dari dalam skrip Python. Mulai dari perintah sederhana seperti subprocess.call() hingga fitur lanjutan seperti pipe, pengalihan input dan output, serta penerusan variabel lingkungan, modul subprocess memiliki sesuatu untuk hampir setiap kasus penggunaan. Ini adalah cara yang hebat untuk mengotomatiskan tugas berulang, menjalankan perintah sistem, dan bahkan berinteraksi dengan bahasa pemrograman serta platform lain.

Saat bekerja dengan modul subprocess, penting diingat bahwa menjalankan perintah eksternal menimbulkan risiko keamanan, terutama saat menggunakan parameter shell=True atau meneruskan input yang tidak disanitasi. Sebaiknya gunakan fungsi subprocess.run() yang memungkinkan Anda menentukan berbagai opsi tentang bagaimana perintah dijalankan, seperti apakah akan melempar pengecualian jika perintah gagal. 

Jika Anda tertarik mendalami berbagai kemungkinan otomasi command line melalui Python, lihat kursus Command Line Automation in Python kami. Dalam kursus ini, Anda akan belajar menulis kode otomasi yang akan menelusuri filesystem, mencari file yang mengikuti pola tertentu, lalu menentukan apakah file merupakan duplikat dalam berbagai skenario. Setelah menyelesaikan kursus, Anda akan mampu mengelola dan berinteraksi dengan proses Unix serta mengotomatiskan berbagai aktivitas rutin pada sistem berkas. 

Tingkatkan Keahlian Python Tim Anda dengan DataCamp for Business

Jika Anda atau tim Anda ingin meningkatkan keterampilan dalam Python dan otomasi command line, pertimbangkan untuk menjelajahi DataCamp for Business. DataCamp menawarkan solusi pembelajaran yang disesuaikan untuk tim dari berbagai ukuran, membantu bisnis tetap unggul di lanskap teknologi yang cepat berubah. Dengan DataCamp for Business, Anda dapat meningkatkan keterampilan tim melalui kursus dan jalur pembelajaran khusus yang dirancang untuk membangun keahlian dalam Python, otomasi, dan berbagai alat data science penting lainnya. Baik Anda startup maupun perusahaan besar, DataCamp for Business menyediakan sumber daya dan fleksibilitas untuk mencapai tujuan pembelajaran tim Anda. Ajukan demo hari ini untuk mempelajari lebih lanjut.