Parsing Argumen di Python

Jika Anda merencanakan proyek data science atau machine learning, memulainya di Jupyter Notebook bukanlah hal yang asing. Notebook menyediakan interaktivitas untuk alat komputasi Anda, memungkinkan Anda menjalankan modul dengan cepat, dan sebagainya. Ada banyak alasan untuk memilih Jupyter Notebook sebagai senjata utama, terutama untuk proyek data science atau machine learning. Namun, tutorial ini tidak bertujuan membahas bagian tersebut.

Bayangkan Anda perlu menjalankan skrip Python sebagai batch job untuk keperluan ingestion data dalam proyek data science Anda. Atau Anda perlu menjalankan skrip Python untuk melakukan deployment model machine learning ke server jarak jauh. Dalam kasus seperti ini, mengeksekusi python your_script.py saja mungkin tidak cukup. Anda mungkin perlu mengoper lebih banyak opsi atau argumen bersamaan dengan python your_script.py. Anda mungkin sudah familier dengan penggunaan argumen tambahan saat menjalankan perintah (seperti ps, ls, dll.) di terminal Linux.

Dalam tutorial ini, Anda akan mempelajari cara mem-parsing argumen dan opsi tambahan dari command line yang dikirimkan bersama skrip Python. Berikut ringkasan materi untuk tutorial hari ini:

• Pengenalan dasar parsing argumen
• Parsing argumen di Python
  • Menggunakan sys.argv
  • Menggunakan getopt
  • Menggunakan argparse

Catatan bahwa tutorial ini mengasumsikan Anda telah familier dengan dasar-dasar Python.

Apa itu parsing argumen?

Jika Anda pengguna Linux, kemungkinan besar Anda sudah tahu ini. Untuk mendapatkan ringkasan berkas dan folder yang ada di direktori tertentu, perintah ls sering digunakan. Keluaran tipikal saat menjalankan perintah ls terlihat seperti ini -

Namun, Anda dapat memberikan banyak opsi ke perintah ls, misalnya -l. Mari lihat seperti apa keluarannya -

Dengan memberikan opsi -l, Anda mendapatkan informasi lebih banyak. Sekarang, ada sedikit perbedaan antara sebuah opsi dan sebuah argumen dalam konteks ini. Untuk menghapus berkas atau folder dari direktori kerja saat ini, perintah rm sering digunakan. Misalkan Anda memiliki berkas teks bernama demo.txt dan Anda menjalankan rm demo.txt untuk menghapusnya. Dalam kasus ini, demo.txt adalah argumen yang Anda berikan ke perintah rm. Jika Anda tidak memberikan argumen apa pun ke perintah rm, Anda akan mendapat galat seperti ini -

Lalu, apa bedanya opsi dan argumen? Sekarang sudah cukup jelas. Opsi bersifat opsional untuk diberikan sedangkan argumen (sering kali) diperlukan untuk diberikan. Tidak wajib memberikan apa pun ke perintah ls agar menghasilkan keluaran.

Saat Anda mengetik ls -l atau rm demo.txt, sistem operasi akan mem-parsing-nya dengan cara tertentu di balik layar. Mekanisme ini umumnya ditentukan oleh pengembang sistem operasi, dan dikenal sebagai parsing.

Jika Anda tertarik mengetahui lebih banyak perintah Linux serta berbagai opsi dan argumen yang didukungnya, membaca buku Unix Concepts and Applications sangat direkomendasikan.

Itulah pengantar dasar tentang parsing argumen. Hampir semua bahasa pemrograman mendukung parsing argumen. Python bukan pengecualian. Ada tiga cara yang sangat lazim untuk melakukan parsing argumen di Python -

• sys.argv
• getopt
• argparse

Selanjutnya Anda akan membahas masing-masing opsi di atas satu per satu dan melihat cara menggunakannya untuk mem-parsing argumen (dan opsi). Mari mulai secara kronologis.

Parsing Argumen menggunakan sys.argv

Mari mulai dari yang sederhana. Dalam contoh pertama ini, Anda akan membuat berkas Python bernama demo1.py. Program Anda akan menerima sejumlah argumen sewenang-wenang yang diberikan dari command line (atau terminal) saat dieksekusi. Program akan mencetak argumen yang diberikan dan total jumlah argumen.

Misalnya, jika Anda mengeksekusi python demo1.py abc 123, maka program akan menghasilkan -

Number of arguments: 3
Argument(s) passed: ['demo1.py', 'abc', '123']

Perhatikan bahwa argumen pertama selalu nama berkas Python. Namun, kodenya bisa dimodifikasi agar tidak menyertakannya.

Sekarang ke kodenya -

import sys

print('Number of arguments: {}'.format(len(sys.argv)))
print('Argument(s) passed: {}'.format(str(sys.argv)))

Anda terlebih dahulu mengimpor modul Python sys, yang disertakan dalam instalasi standar Python. Lalu Anda menggunakan submodul argv yang mengembalikan daftar argumen yang diberikan ke skrip Python, di mana argv[0] berisi nama skrip Python. Jika Anda menjalankan sys.argv di sebuah sel kode seperti berikut, Anda akan mendapatkan daftar berkas konfigurasi yang bertanggung jawab membuat kernel IPython berjalan dengan semestinya. Sebaiknya jangan mengutak-atiknya.

sys.argv

['/home/nbuser/anaconda3_501/lib/python3.6/site-packages/ipykernel/__main__.py',
 '-f',
 '/home/nbuser/.local/share/jupyter/runtime/kernel-dabba4f7-e3e0-4c39-99d2-261ba835c53f.json']

Sekarang mari lihat cara menggunakan modul getopt untuk mem-parsing argumen (dan opsi).

Parsing argumen menggunakan getopt

Dibandingkan dengan sys.argv, modul getopt menawarkan fleksibilitas yang jauh lebih besar. Mari merancang skenario contoh terlebih dahulu dan menuliskan kodenya sesuai itu.

Misalnya, Anda telah merilis skrip Python yang belum Anda dokumentasikan. Namun Anda ingin dapat memberikan umpan balik yang bermakna kepada pengguna ketika mereka mengeksekusi skrip tersebut dengan cara yang tidak semestinya. Skrip Python Anda melakukan tugas sederhana menjumlahkan dua angka dan memberikan keluaran. Satu-satunya ketentuannya adalah pengguna harus memberikan input dalam bentuk argumen command line bersamaan dengan skrip Python.

Secara lebih praktis, skrip idealnya dieksekusi seperti ini -

python add_numbers.py -a 3 -b 8

Keluarannya harus 11. Di sini, -a dan -b adalah opsi, dan 3, 8 adalah argumen yang Anda berikan ke skrip. Opsi tidak hanya meningkatkan keterbacaan, tetapi juga membantu menentukan alur evaluasi (bayangkan jika Anda melakukan pembagian alih-alih penjumlahan). Mari kita lihat kodenya terlebih dahulu.

import getopt
import sys

# Get the arguments from the command-line except the filename
argv = sys.argv[1:]
sum = 0

try:
    # Define the getopt parameters
    opts, args = getopt.getopt(argv, 'a:b:', ['foperand', 'soperand'])
    # Check if the options' length is 2 (can be enhanced)
    if len(opts) == 0 and len(opts) > 2:
      print ('usage: add.py -a <first_operand> -b <second_operand>')
    else:
      # Iterate the options and get the corresponding values
      for opt, arg in opts:
         sum += int(arg)
      print('Sum is {}'.format(sum))

except getopt.GetoptError:
    # Print something useful
    print ('usage: add.py -a <first_operand> -b <second_operand>')
    sys.exit(2)

Idenya adalah terlebih dahulu mengambil semua argumen menggunakan sys.argv lalu memprosesnya. Sekarang mari ke baris kode yang paling penting - opts, args = getopt.getopt(argv, 'a:b:', ['foperand', 'soperand'])

Tanda tangan metode getopt() terlihat seperti:

getopt.getopt(args, shortopts, longopts=[])

• args adalah daftar argumen yang diambil dari command line.
• shortopts adalah tempat Anda menentukan huruf opsi. Jika Anda memberikan a:, itu berarti skrip Anda harus diberi opsi a diikuti nilai sebagai argumennya. Secara teknis, Anda dapat menggunakan sejumlah opsi di sini. Saat Anda memberikan opsi ini dari command line, opsi harus diawali dengan '-'.
• longopts adalah tempat Anda dapat menentukan versi panjang dari shortopts. Opsi ini harus diawali dengan '--'.

Anda mendefinisikan shortopts sebagai a:b: yang berarti skrip Python Anda akan menerima dua opsi berupa huruf - 'a' dan 'b'. Dengan menuliskan ':' Anda secara eksplisit memberi tahu bahwa opsi tersebut akan diikuti argumen.

Anda mendefinisikan longopts sebagai ['foperand', 'soperand'] yang merupakan cara untuk memberi tahu kode agar menerima f_operand dan s_operand sebagai pengganti a dan b sebagai opsi. Namun opsi panjang ini harus selalu diawali --.

Modul getopt juga menyediakan kelas Exception GetoptError yang praktis untuk mendefinisikan pesan yang berguna, sehingga dapat memandu pengguna tentang cara memakai skrip Python Anda. Inilah mengapa Anda membungkus bagian fungsional skrip dalam blok try dan mendefinisikan blok except sesuai kebutuhan.

Begini cara Anda menjalankan skrip Python tersebut:

Catatan bahwa skrip di atas tidak didefinisikan untuk menangani longopts. Ini bisa Anda coba sebagai latihan.

Sekarang mari lihat cara menggunakan argparse untuk parsing argumen.

Parsing argumen menggunakan argparse

Dari dua opsi di atas, cukup jelas bahwa keduanya tidak terlalu mudah dibaca. Setelah Anda melihat argparse beraksi, Anda juga akan sepakat bahwa dua opsi sebelumnya kurang fleksibel. Untuk memahami penggunaan argparse, mari mulai dengan potongan kode yang mengimplementasikan skenario pada bagian sebelumnya.

import argparse

# Construct the argument parser
ap = argparse.ArgumentParser()

# Add the arguments to the parser
ap.add_argument("-a", "--foperand", required=True,
   help="first operand")
ap.add_argument("-b", "--soperand", required=True,
   help="second operand")
args = vars(ap.parse_args())

# Calculate the sum
print("Sum is {}".format(int(args['foperand']) + int(args['soperand'])))

Pertama-tama, argparse seperti dua modul lain yang dibahas di atas, sudah termasuk dalam instalasi standar Python. Anda memulainya dengan membuat instance objek argparse. Selebihnya menjadi jauh lebih mudah ditulis. Mari ambil contoh baris kode berikut -

ap.add_argument("-a", "--foperand", required=True, help="first operand")

Di sini Anda menambahkan argumen yang Anda harapkan diberikan bersama skrip Python saat dijalankan. Anda menyediakan versi huruf dari argumen beserta versi panjangnya. Dengan menuliskan required=True Anda secara eksplisit meminta pengguna untuk memberikan argumen tersebut. Terakhir, Anda menambahkan deskripsi bermakna tentang argumen yang akan ditampilkan kepada pengguna jika ia tidak mengeksekusi skrip dengan benar.

Bagian definisi argumen sama untuk argumen kedua. Anda mengakses argumen yang diberikan dengan menyebutkan indeksnya masing-masing.

Potongan kode di atas jelas menunjukkan betapa mudah dan fleksibelnya mendefinisikan tugas parsing argumen command line dengan argparse. Berikut cara Anda mencoba skrip Python di atas:

Perhatikan betapa jauh lebih mudah prosesnya dengan argparse.

Langkah Selanjutnya

Terima kasih sudah membaca tutorial hari ini hingga akhir. Kini, Anda dibekali modul-modul bawaan Python yang mampu mem-parsing argumen yang diberikan dari command line bersama skrip Python Anda. Sebagai latihan, Anda dapat menyesuaikan proyek machine learning dan data science Anda untuk memfasilitasi parsing argumen dan mengubahnya menjadi utilitas skrip yang berguna. Bukan hanya untuk machine learning atau data science, tetapi di mana pun Anda rasa relevan. Itu saja untuk tutorial hari ini. Jika Anda tertarik meningkatkan keterampilan Python, Anda mungkin ingin mengikuti kursus Python Data Science Toolbox (Bagian 1) dari DataCamp.