Mengapa menggunakan metode modul os Python daripada menjalankan perintah shell secara langsung?

Saya mencoba memahami apa motivasi di balik penggunaan fungsi pustaka Python untuk menjalankan tugas-tugas spesifik OS seperti membuat file / direktori, mengubah atribut file, dll. Daripada hanya menjalankan perintah-perintah itu melalui os.system()atau subprocess.call()?

Misalnya, mengapa saya ingin menggunakan os.chmoddaripada melakukan os.system("chmod...")?

Saya mengerti bahwa lebih "pythonic" untuk menggunakan metode pustaka Python yang tersedia sebanyak mungkin daripada hanya menjalankan perintah shell secara langsung. Tetapi, adakah motivasi lain di balik melakukan hal ini dari sudut pandang fungsionalitas?

Saya hanya berbicara tentang mengeksekusi perintah shell satu baris sederhana di sini. Ketika kita membutuhkan lebih banyak kontrol atas pelaksanaan tugas, saya mengerti bahwa menggunakan subprocessmodul lebih masuk akal, misalnya.

1. Ini lebih cepat , os.systemdan subprocess.callmembuat proses baru yang tidak perlu untuk sesuatu yang sederhana ini. Bahkan, os.systemdan subprocess.calldengan shellargumen biasanya membuat setidaknya dua proses baru: yang pertama adalah shell, dan yang kedua adalah perintah yang Anda jalankan (jika itu bukan shell built-in like test).

2. Beberapa perintah tidak berguna dalam proses terpisah . Misalnya, jika Anda menjalankan os.spawn("cd dir/"), itu akan mengubah direktori kerja saat ini dari proses anak, tetapi tidak dari proses Python. Anda perlu menggunakannya os.chdiruntuk itu.

3. Anda tidak perlu khawatir tentang karakter khusus yang ditafsirkan oleh shell. os.chmod(path, mode)akan bekerja tidak peduli apa nama file itu, sedangkan os.spawn("chmod 777 " + path)akan gagal total jika nama file itu seperti ; rm -rf ~. (Perhatikan bahwa Anda dapat mengatasi ini jika Anda menggunakan subprocess.calltanpa shellargumen.)

4. Anda tidak perlu khawatir tentang nama file yang dimulai dengan tanda hubung . os.chmod("--quiet", mode)akan mengubah izin file bernama --quiet, tetapi os.spawn("chmod 777 --quiet")akan gagal, sebagaimana --quietditafsirkan sebagai argumen. Ini berlaku bahkan untuk subprocess.call(["chmod", "777", "--quiet"]).

5. Anda memiliki lebih sedikit masalah lintas-platform dan lintas-shell, karena perpustakaan standar Python seharusnya menangani itu untuk Anda. Apakah sistem Anda memiliki chmodperintah? Apakah sudah diinstal? Apakah itu mendukung parameter yang Anda harapkan didukung? The osmodul akan mencoba untuk menjadi seperti cross-platform mungkin dan dokumen ketika bahwa itu tidak mungkin.

6. Jika perintah yang Anda jalankan memiliki keluaran yang Anda pedulikan, Anda perlu menguraikannya, yang lebih sulit daripada kedengarannya, karena Anda mungkin melupakan kasus sudut (nama file dengan spasi, tab, dan baris baru di dalamnya), bahkan ketika Anda tidak peduli tentang portabilitas.

Itu lebih aman. Untuk memberi Anda ide di sini adalah contoh skrip

import os
file = raw_input("Please enter a file: ")
os.system("chmod 777 " + file)

Jika input dari pengguna adalah test; rm -rf ~ini maka akan menghapus direktori home.

Inilah sebabnya mengapa lebih aman untuk menggunakan fungsi bawaan.

Karenanya mengapa Anda harus menggunakan subproses alih-alih sistem juga.

Ada empat kasus kuat untuk memilih metode Python yang lebih spesifik dalam osmodul daripada menggunakan os.systematau subprocessmodul saat menjalankan perintah:

• Redundansi - menelurkan proses lain adalah redundan dan membuang-buang waktu dan sumber daya.
• Portabilitas - Banyak metode dalam osmodul ini tersedia di berbagai platform sementara banyak perintah shell bersifat spesifik-os.
• Memahami hasil - Memunculkan proses untuk mengeksekusi perintah sewenang-wenang memaksa Anda untuk menguraikan hasil dari output dan memahami jika dan mengapa suatu perintah telah melakukan sesuatu yang salah.
• Keamanan - Suatu proses berpotensi mengeksekusi perintah apa pun yang diberikan. Ini adalah desain yang lemah dan dapat dihindari dengan menggunakan metode spesifik dalam osmodul.

Redundansi (lihat kode redundan ):

Anda sebenarnya mengeksekusi "perantara" yang berlebihan dalam perjalanan Anda ke panggilan sistem yang akhirnya ( chmoddalam contoh Anda). Orang tengah ini adalah proses atau sub-shell baru.

Dari os.system:

Jalankan perintah (string) dalam subkulit ...

Dan subprocesshanya sebuah modul untuk menelurkan proses baru.

Anda dapat melakukan apa yang Anda butuhkan tanpa memunculkan proses ini.

Portabilitas (lihat kode sumber portabilitas ):

Tujuan osmodul adalah untuk menyediakan layanan sistem operasi generik dan uraiannya dimulai dengan:

Modul ini menyediakan cara portabel menggunakan fungsionalitas yang tergantung pada sistem operasi.

Anda dapat menggunakan os.listdirkedua windows dan unix. Mencoba menggunakan os.system/ subprocessuntuk fungsi ini akan memaksa Anda untuk mempertahankan dua panggilan (untuk ls/ dir) dan memeriksa sistem operasi yang Anda gunakan . Ini tidak portabel dan akan menyebabkan frustrasi lebih banyak di kemudian hari (lihat Menangani Penanganan ).

Memahami hasil perintah:

Misalkan Anda ingin membuat daftar file dalam direktori.

Jika Anda menggunakan os.system("ls")/ subprocess.call(['ls']), Anda hanya bisa mendapatkan kembali proses, yang pada dasarnya adalah string besar dengan nama file.

Bagaimana Anda bisa memberi tahu file dengan spasi di namanya dari dua file?

Bagaimana jika Anda tidak memiliki izin untuk mendaftarkan file?

Bagaimana seharusnya Anda memetakan data ke objek python?

Ini hanya di atas kepala saya, dan sementara ada solusi untuk masalah ini - mengapa memecahkan lagi masalah yang dipecahkan untuk Anda?

Ini adalah contoh mengikuti prinsip Don't Repeat Yourself (Sering disebut sebagai "KERING") dengan tidak mengulangi implementasi yang sudah ada dan tersedia secara bebas untuk Anda.

Keamanan:

os.systemdan subprocesssangat kuat. Itu bagus ketika Anda membutuhkan kekuatan ini, tetapi itu berbahaya ketika Anda tidak. Ketika Anda menggunakan os.listdir, Anda tahu itu tidak bisa melakukan hal lain selain daftar file atau meningkatkan kesalahan. Ketika Anda menggunakan os.systematau subprocessuntuk mencapai perilaku yang sama, Anda berpotensi berakhir melakukan sesuatu yang tidak Anda inginkan.

Keselamatan Injeksi (lihat contoh injeksi shell ) :

Jika Anda menggunakan input dari pengguna sebagai perintah baru, pada dasarnya Anda memberinya shell. Ini seperti injeksi SQL yang menyediakan shell di DB untuk pengguna.

Contohnya adalah perintah dari formulir:

# ... read some user input
os.system(user_input + " some continutation")

Ini dapat dengan mudah dieksploitasi untuk menjalankan kode arbitrer apa pun menggunakan input: NASTY COMMAND;#untuk membuat akhirnya:

os.system("NASTY COMMAND; # some continuation")

Ada banyak perintah yang dapat membahayakan sistem Anda.

Untuk alasan sederhana - ketika Anda memanggil fungsi shell, itu membuat sub-shell yang dihancurkan setelah perintah Anda ada, jadi jika Anda mengubah direktori di shell - itu tidak mempengaruhi lingkungan Anda di Python.

Selain itu, membuat sub-shell memakan waktu, jadi menggunakan perintah OS secara langsung akan berdampak pada kinerja Anda

EDIT

Saya menjalankan beberapa tes waktu:

In [379]: %timeit os.chmod('Documents/recipes.txt', 0755)
10000 loops, best of 3: 215 us per loop

In [380]: %timeit os.system('chmod 0755 Documents/recipes.txt')
100 loops, best of 3: 2.47 ms per loop

In [382]: %timeit call(['chmod', '0755', 'Documents/recipes.txt'])
100 loops, best of 3: 2.93 ms per loop

Fungsi internal berjalan lebih dari 10 kali lebih cepat

EDIT2

Mungkin ada kasus ketika menjalankan executable eksternal dapat menghasilkan hasil yang lebih baik daripada paket Python - Saya baru ingat sebuah surat yang dikirim oleh seorang rekan saya bahwa kinerja gzip yang dipanggil melalui subproses jauh lebih tinggi daripada kinerja paket Python yang ia gunakan. Tetapi tentu saja tidak ketika kita berbicara tentang paket OS standar meniru perintah OS standar

Panggilan Shell bersifat spesifik OS sedangkan fungsi modul os Python tidak, dalam sebagian besar kasus. Dan itu menghindari menelurkan subproses.

Jauh lebih efisien. "Shell" hanyalah binari OS lain yang berisi banyak panggilan sistem. Mengapa harus mengeluarkan biaya untuk membuat seluruh proses shell hanya untuk pemanggilan sistem tunggal?

Situasinya bahkan lebih buruk ketika Anda menggunakan os.systemsesuatu yang bukan shell. Anda memulai proses shell yang pada gilirannya memulai executable yang kemudian (dua proses jauhnya) membuat panggilan sistem. Setidaknya subprocessakan menghilangkan kebutuhan untuk proses perantara shell.

Ini tidak spesifik untuk Python, ini. systemdadalah peningkatan waktu startup Linux untuk alasan yang sama: itu membuat sistem yang diperlukan memanggil dirinya sendiri bukannya menelurkan seribu shell.