python - পাইথন একটি বাহ্যিক কমান্ড কল




shell command (20)

পাইথন স্ক্রিপ্টের মধ্যে থেকে কিভাবে আমি বাহ্যিক কমান্ড (যেমন আমি ইউনিক্স শেল বা উইন্ডোজ কমান্ড প্রম্পটে টাইপ করব) কল করতে পারি?


পাইথন একটি বাহ্যিক কমান্ড কল

সহজ, subprocess.run ব্যবহার subprocess.run , যা একটি CompletedProcess বস্তু প্রদান করে:

>>> import subprocess
>>> completed_process = subprocess.run('python --version')
Python 3.6.1 :: Anaconda 4.4.0 (64-bit)
>>> completed_process
CompletedProcess(args='python --version', returncode=0)

কেন?

পাইথন 3.5 হিসাবে, ডকুমেন্টেশন subprocess.run সুপারিশ:

সাবপ্রোকেসেসকে অবহিত করার প্রস্তাবিত পদ্ধতিটি হ্যান্ডেল করতে পারে এমন সমস্ত ব্যবহারের ক্ষেত্রে রান () ফাংশনটি ব্যবহার করা। আরও উন্নত ব্যবহারের ক্ষেত্রে, অন্তর্নিহিত পপেন ইন্টারফেস সরাসরি ব্যবহার করা যেতে পারে।

এখানে সর্বাধিক সম্ভাব্য ব্যবহারের উদাহরণ - এবং এটি ঠিক যেমন জিজ্ঞাসা করে:

>>> import subprocess
>>> completed_process = subprocess.run('python --version')
Python 3.6.1 :: Anaconda 4.4.0 (64-bit)
>>> completed_process
CompletedProcess(args='python --version', returncode=0)

run সফলভাবে শেষ করার জন্য অপেক্ষা করার জন্য অপেক্ষা করে, তারপর একটি CompletedProcess বস্তু প্রদান করে। এটি পরিবর্তে TimeoutExpired বাড়াতে TimeoutExpired (যদি আপনি এটি একটি timeout= যুক্তি প্রদান করেন) বা CalledProcessError (যদি এটি ব্যর্থ হয় এবং আপনি check=True পাস করেন)।

আপনি উপরের উদাহরণ থেকে অনুমান করতে পারেন, stdout এবং stderr উভয় ডিফল্টরূপে আপনার নিজস্ব stdout এবং stderr এ পাইপ পেতে।

আমরা প্রত্যাবর্তিত বস্তুর পরিদর্শন করতে পারি এবং প্রদত্ত নির্দেশটি এবং রিটার্নকোডটি দেখতে পারি:

>>> completed_process.args
'python --version'
>>> completed_process.returncode
0

আউটপুট ক্যাপচার

আপনি যদি আউটপুটটি ক্যাপচার করতে চান তবে আপনি যথাযথ stderr বা stdout subprocess.PIPE পাস করতে পারেন:

>>> cp = subprocess.run('python --version', 
                        stderr=subprocess.PIPE, 
                        stdout=subprocess.PIPE)
>>> cp.stderr
b'Python 3.6.1 :: Anaconda 4.4.0 (64-bit)\r\n'
>>> cp.stdout
b''

(আমি এটি আকর্ষণীয় এবং সামান্য প্রতিক্রিয়াশীল যে সংস্করণ তথ্য stdout পরিবর্তে stderr করা হয়।)

একটি কমান্ড তালিকা পাস করুন

একটি সহজেই প্রোগ্রামটি তৈরি একটি স্ট্রিং প্রদান করতে একটি কমান্ড স্ট্রিং (প্রশ্ন প্রস্তাব মত) ম্যানুয়ালি থেকে সরানো হতে পারে। প্রোগ্রামগতভাবে স্ট্রিং নির্মাণ করবেন না। এটি একটি সম্ভাব্য নিরাপত্তা সমস্যা। এটা ভাল আপনি ইনপুট বিশ্বাস করবেন না অনুমান।

>>> import textwrap
>>> args = ['python', textwrap.__file__]
>>> cp = subprocess.run(args, stdout=subprocess.PIPE)
>>> cp.stdout
b'Hello there.\r\n  This is indented.\r\n'

নোট, শুধুমাত্র args অবস্থানগতভাবে পাস করা উচিত।

সম্পূর্ণ স্বাক্ষর

এখানে উৎসের প্রকৃত স্বাক্ষর এবং সহায়তা হিসাবে দেখানো হয়েছে help(run) :

def run(*popenargs, input=None, timeout=None, check=False, **kwargs):

popenargs এবং kwargs popenargs kwargs দেওয়া হয়। input বাইটগুলির একটি স্ট্রিং (বা ইউনিকোড, যদি এনকোডিং বা universal_newlines=True উল্লেখ করে) উপপ্রয়াসের স্টেডিনে পাইপ করা যেতে পারে।

ডকুমেন্টেশন timeout= এবং check=True বর্ণনা আমি চেয়ে পারে ভাল:

সময়সীমা যুক্তি Popen.communicate পাস করা হয় ()। সময়সীমার মেয়াদ শেষ হয়ে গেলে শিশু প্রক্রিয়াটি মারা যাবে এবং অপেক্ষা করা হবে। শিশু প্রক্রিয়াকরণ শেষ হওয়ার পরে টাইমআউট এক্সপ্রেসড ব্যতিক্রমটি পুনর্বহাল করা হবে।

যদি চেকটি সত্য হয় এবং প্রক্রিয়াটি একটি অ-শূন্য প্রস্থান কোডের সাথে প্রস্থান করে তবে একটি CalledProcessError ব্যতিক্রম উত্থাপিত হবে। সেই ব্যতিক্রমগুলির বৈশিষ্ট্যগুলি আর্গুমেন্ট, প্রস্থান কোড, এবং স্টডাউট এবং স্টেডার যদি ধরে রাখা হয় তবে তা ধরে রাখুন।

এবং check=True জন্য এই উদাহরণটি এমন একের চেয়ে ভাল যা আমি এর সাথে আসতে পারি:

>>> subprocess.run("exit 1", shell=True, check=True)
Traceback (most recent call last):
  ...
subprocess.CalledProcessError: Command 'exit 1' returned non-zero exit status 1

সম্প্রসারিত স্বাক্ষর

এখানে ডকুমেন্টেশন দেওয়া হিসাবে একটি প্রসারিত স্বাক্ষর ,:

subprocess.run(args, *, stdin=None, input=None, stdout=None, stderr=None, 
shell=False, cwd=None, timeout=None, check=False, encoding=None, 
errors=None)

উল্লেখ্য যে এই ইঙ্গিত দেয় যে শুধুমাত্র আর্গুমেন্ট তালিকাটি স্থিরভাবে পাস করা উচিত। সুতরাং কীওয়ার্ড আর্গুমেন্ট হিসাবে অবশিষ্ট আর্গুমেন্ট পাস।

Popen

Popenপরিবর্তে ব্যবহার করবেন ? আমি শুধুমাত্র আর্গুমেন্ট উপর ভিত্তি করে ব্যবহার কেস খুঁজে সংগ্রাম করতে হবে। এর সরাসরি ব্যবহার Popenযদিও, poll'send_ignal', 'terminate' এবং 'অপেক্ষা' সহ তার পদ্ধতিগুলিতে অ্যাক্সেস দেয় ।

উৎসPopen হিসাবে দেওয়া এখানে স্বাক্ষর । আমি মনে করি এটি তথ্যগুলির সবচেয়ে সুনির্দিষ্ট সংযোজন (এর বিপরীতে ):help(Popen)

def __init__(self, args, bufsize=-1, executable=None,
             stdin=None, stdout=None, stderr=None,
             preexec_fn=None, close_fds=_PLATFORM_DEFAULT_CLOSE_FDS,
             shell=False, cwd=None, env=None, universal_newlines=False,
             startupinfo=None, creationflags=0,
             restore_signals=True, start_new_session=False,
             pass_fds=(), *, encoding=None, errors=None):

কিন্তু আরো তথ্যপূর্ণ ডকুমেন্টেশন :Popen

subprocess.Popen(args, bufsize=-1, executable=None, stdin=None,
                 stdout=None, stderr=None, preexec_fn=None, close_fds=True,
                 shell=False, cwd=None, env=None, universal_newlines=False,
                 startupinfo=None, creationflags=0, restore_signals=True,
                 start_new_session=False, pass_fds=(), *, encoding=None, errors=None)

একটি নতুন প্রক্রিয়া একটি শিশু প্রোগ্রাম এক্সিকিউট। POSIX এ, ক্লাসটি শিশু প্রোগ্রামটি চালানোর মতো আচরণগুলি os.execvp () ব্যবহার করে। উইন্ডোজ এ, ক্লাস উইন্ডোজ CreateProcess () ফাংশন ব্যবহার করে। নিম্নরূপ হিসাবে Popen আর্গুমেন্ট হয়।

অবশিষ্ট ডকুমেন্টেশন বোঝার Popenপাঠক জন্য ব্যায়াম হিসাবে বামে করা হবে।


স্ট্যান্ডার্ড লাইব্রেরী সঙ্গে

সাবপ্রোকেস মডিউল ব্যবহার করুন (পাইথন 3):

import subprocess
subprocess.run(['ls', '-l'])

এটা সুপারিশকৃত স্ট্যান্ডার্ড উপায়। যাইহোক, আরো জটিল কাজ (পাইপ, আউটপুট, ইনপুট, ইত্যাদি) গঠন এবং লেখার জন্য ক্লান্তিকর হতে পারে।

পাইথন সংস্করণে উল্লেখ্য: যদি আপনি এখনও Python 2 ব্যবহার করেন তবে subprocess.call একইভাবে কাজ করে।

ProTip: docs.python.org/2/library/shlex.html#shlex.split যদি আপনি চান না (অথবা আপনি না করতে পারেন) ক্ষেত্রে run , call এবং অন্যান্য subprocess কার্যকারিতা ফাংশনগুলির জন্য কমান্ডটি পার্স করতে সহায়তা করতে পারেন:

import shlex
import subprocess
subprocess.run(shlex.split('ls -l'))

বাহ্যিক নির্ভরতা সঙ্গে

যদি আপনি বহিরাগত নির্ভরতা মনে করেন না, plumbum ব্যবহার করুন:

from plumbum.cmd import ifconfig
print(ifconfig['wlan0']())

এটি সেরা subprocess wrapper। এটি ক্রস-প্ল্যাটফর্ম, অর্থাৎ এটি উইন্ডোজ এবং ইউনিক্স-এর মতো উভয় সিস্টেমে কাজ করে। pip install plumbum দ্বারা ইনস্টল করুন।

আরেকটি জনপ্রিয় লাইব্রেরি sh :

from sh import ifconfig
print(ifconfig('wlan0'))

যাইহোক, sh উইন্ডোজ সাপোর্ট বন্ধ করে দিয়েছে, তাই এটি ব্যবহার করা হিসাবে হিসাবে অসাধারণ নয়। pip install sh দ্বারা pip install sh


আপনি যদি কলিংয়ের কমান্ড থেকে আউটপুট প্রয়োজন হয়, তবে আপনি subprocess.check_output (পাইথন 2.7+) ব্যবহার করতে পারেন।

>>> subprocess.check_output(["ls", "-l", "/dev/null"])
'crw-rw-rw- 1 root root 1, 3 Oct 18  2007 /dev/null\n'

এছাড়াও shell পরামিতি নোট করুন।

শেল True , নির্দিষ্ট কমান্ডটি শেলের মাধ্যমে কার্যকর করা হবে। এটি ব্যবহারযোগ্য হতে পারে যদি আপনি প্রাথমিকভাবে উন্নত নিয়ন্ত্রণ প্রবাহের জন্য পাইথনটি ব্যবহার করেন তবে এটি বেশিরভাগ সিস্টেম শেলগুলিতে সরবরাহ করে এবং এখনও শেল পাইপ, ফাইলনাম ওয়াইল্ডকার্ড, পরিবেশ পরিবর্তনশীল সম্প্রসারণ এবং ব্যবহারকারীর বাড়ির বাড়ির অন্যান্য শেল বৈশিষ্ট্যগুলিতে সুবিধাজনক অ্যাক্সেস চায় ডিরেক্টরি। যাইহোক, নোট করুন যে পাইথন নিজেই শেল-এর মত বৈশিষ্ট্যগুলি প্রয়োগ করে (বিশেষত, fnmatch , os.path.expandvars() , os.path.expandvars() os.walk() , os.path.expandvars() , os.path.expanduser() , এবং shutil )।


আমি ওএস সিস্টেমে পরিবর্তে উপপরিচালক মডিউল ব্যবহার করার সুপারিশ করব কারণ এটি আপনার জন্য শেল পালাচ্ছে এবং এটি আরও নিরাপদ: http://docs.python.org/library/subprocess.html

subprocess.call(['ping', 'localhost'])

আমি সবসময় এই জিনিসগুলির জন্য fabric ব্যবহার করি:

from fabric.operations import local
result = local('ls', capture=True)
print "Content:/n%s" % (result, )

কিন্তু এটি একটি ভাল সরঞ্জাম বলে মনে হচ্ছে: sh (পাইথন সাবপ্রোকেস ইন্টারফেস)

একটি উদাহরণ দেখুন:

from sh import vgdisplay
print vgdisplay()
print vgdisplay('-v')
print vgdisplay(v=True)

আমি সাধারণত ব্যবহার:

import subprocess

p = subprocess.Popen('ls', shell=True, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
for line in p.stdout.readlines():
    print line,
retval = p.wait()

আপনি পাইপের stdout ডেটা দিয়ে যা চান তা করতে মুক্ত। আসলে, আপনি কেবলমাত্র সেই পরামিতিগুলিকে বাদ দিতে পারেন ( stdout= এবং stderr= ) এবং এটি os.system() মতো আচরণ করবে।


কিছু আহ্বান থেকে শিশু প্রক্রিয়া বিচ্ছিন্ন কিছু নির্দেশনা (পটভূমিতে শিশু প্রক্রিয়া শুরু)।

ধরুন আপনি একটি সিজিআই-স্ক্রিপ্ট থেকে দীর্ঘ কাজ শুরু করতে চান, এটি শিশু প্রক্রিয়াটিকে CGI-স্ক্রিপ্ট নির্বাহ প্রক্রিয়া থেকে বেশি সময় বাঁচাতে হবে।

সাবপ্রোকেস মডিউল ডক্স থেকে শাস্ত্রীয় উদাহরণ হল:

import subprocess
import sys

# some code here

pid = subprocess.Popen([sys.executable, "longtask.py"]) # call subprocess

# some more code here

এখানে লিংকটি 'call subprocess' লাইনে অপেক্ষা করতে চান না যতক্ষণ না longtask.py সমাপ্ত হয়। কিন্তু উদাহরণস্বরূপ লাইনের পরে এখানে আরও কিছু কোডের পরে কী ঘটেছে তা স্পষ্ট নয়।

আমার লক্ষ্য প্ল্যাটফর্ম freebsd ছিল, কিন্তু উন্নয়ন উইন্ডোজ ছিল, তাই আমি উইন্ডোজ প্রথম সমস্যা সম্মুখীন।

উইন্ডোগুলিতে (xp win), longtask.py এর কাজ শেষ না হওয়া পর্যন্ত মূল প্রক্রিয়াটি শেষ হবে না। এটা আপনি CGI-স্ক্রিপ্ট চান কি না। সমস্যা পিওথন নির্দিষ্ট নয়, পিএইচপি সম্প্রদায়ের মধ্যে সমস্যা একই।

সমাধানটি বিজয়ী API এ অন্তর্নিহিত CreateProcess ফাংশনটিতে DETACHED_PROCESS প্রক্রিয়া তৈরির পতাকাটি পাস করতে হয়। আপনি যদি pywin32 ইনস্টল করে থাকেন তবে আপনি win32process মডিউল থেকে পতাকা আমদানি করতে পারেন, অন্যথায় আপনাকে এটি নিজের সংজ্ঞায়িত করতে হবে:

DETACHED_PROCESS = 0x00000008

pid = subprocess.Popen([sys.executable, "longtask.py"],
                       creationflags=DETACHED_PROCESS).pid

/ * ইউপিডি 2015.10.27 @ ইরিক্সুন নোটস এর নীচের একটি মন্তব্যে, যে শব্দটি সঠিকভাবে পতাকাটি CREATE_NEW_CONSOLE (0x00000010) * /

Freebsd এ আমাদের আরেকটি সমস্যা আছে: যখন পিতা-মাতা প্রক্রিয়া সম্পন্ন হয়, তখন এটি শিশু প্রক্রিয়াগুলিকেও শেষ করে। এবং যেটি আপনি সিজিআই স্ক্রিপ্টে চান না। কিছু পরীক্ষা দেখায় যে সমস্যা sys.stdout ভাগ করে বলে মনে হচ্ছে। এবং কাজের সমাধান নিম্নলিখিত ছিল:

pid = subprocess.Popen([sys.executable, "longtask.py"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)

আমি অন্যান্য প্ল্যাটফর্মের কোডটি চেক করে নি এবং Freebsd এ আচরণের কারণগুলি জানি না। কেউ যদি জানেন, আপনার ধারনা শেয়ার করুন। Python মধ্যে ব্যাকগ্রাউন্ড প্রসেস শুরু উপর Googling এখনো কোন আলো চালানো হয় না।


পাইক্সন লাইব্রেরীটি "চাক্ষুষ" চেক করুন।

এটি বহিরাগত প্রোগ্রাম / কমান্ডের ইন্টারেক্টিভ কন্ট্রোলিং, এমনকি এসএসসি, FTP, টেলনেট ইত্যাদির জন্য অনুমতি দেয়। আপনি শুধু এমন কিছু টাইপ করতে পারেন:

child = pexpect.spawn('ftp 192.168.0.24')

child.expect('(?i)name .*: ')

child.sendline('anonymous')

child.expect('(?i)password')

বহিরাগত প্রোগ্রাম এবং প্রতিটি সুবিধার এবং অসুবিধা কল করার উপায়গুলির একটি সারসংক্ষেপ এখানে দেওয়া হয়েছে:

  1. os.system("some_command with args") আপনার সিস্টেমের শেলের কমান্ড এবং আর্গুমেন্টগুলি পাস করে। এটি চমৎকার কারণ আপনি আসলে এই পদ্ধতিতে একাধিক কমান্ড চালাতে পারেন এবং পাইপ এবং ইনপুট / আউটপুট পুনঃনির্দেশ সেট আপ করতে পারেন। উদাহরণ স্বরূপ:

    os.system("some_command < input_file | another_command > output_file")  
    

    যাইহোক, এটি সুবিধাজনক হলেও, আপনাকে স্পেস ইত্যাদি শেল অক্ষরের escaping হ্যান্ডেল করতে হবে। অন্যদিকে, এটি আপনাকে কমান্ডগুলি চালাতে দেয় যা কেবল শেল কমান্ডগুলি এবং আসলে বাহ্যিক প্রোগ্রাম নয়। ডকুমেন্টেশন দেখুন।

  2. stream = os.popen("some_command with args") os.system মতো একই জিনিস করবে, এটি ছাড়া এটি আপনাকে একটি ফাইলের মত বস্তু দেয় যা আপনি যে প্রক্রিয়াটির জন্য আদর্শ ইনপুট / আউটপুট অ্যাক্সেস করতে ব্যবহার করতে পারেন। পপেনের 3 টি ভিন্ন রূপ রয়েছে যা সবাই সামান্য ভিন্নভাবে আই / ও পরিচালনা করে। যদি আপনি একটি স্ট্রিং হিসাবে সবকিছু পাস করেন, তবে আপনার কমান্ডটি শেলে প্রেরণ করা হয়; যদি আপনি একটি তালিকা হিসাবে তাদের পাস তারপর আপনি কিছু escaping সম্পর্কে চিন্তা করতে হবে না। ডকুমেন্টেশন দেখুন।

  3. subprocess মডিউল Popen ক্লাস। এটি os.popen প্রতিস্থাপন হিসাবে os.popen তবে এত ব্যাপক হওয়ার কারণে এটি সামান্য জটিল হয়ে উঠছে। উদাহরণস্বরূপ, আপনি বলবেন:

    print subprocess.Popen("echo Hello World", shell=True, stdout=subprocess.PIPE).stdout.read()
    

    পরিবর্তে:

    print os.popen("echo Hello World").read()
    

    তবে চারটি ভিন্ন পপেন ফাংশনগুলির পরিবর্তে এক ঐক্যবদ্ধ শ্রেণিতে সমস্ত বিকল্প থাকা ভাল। ডকুমেন্টেশন দেখুন।

  4. subprocess মডিউল থেকে call ফাংশন। এটি মূলত Popen শ্রেণির মতো এবং একই রকম আর্গুমেন্টগুলি নেয় তবে এটি সম্পূর্ণভাবে অপেক্ষা না করেই অপেক্ষা করে এবং আপনাকে রিটার্ন কোড দেয়। উদাহরণ স্বরূপ:

    return_code = subprocess.call("echo Hello World", shell=True)  
    

    ডকুমেন্টেশন দেখুন।

  5. আপনি যদি Python 3.5 বা subprocess.run পরে থাকেন, তবে আপনি নতুন subprocess.run ফাংশনটি ব্যবহার করতে পারেন যা উপরে অনেকটা আরও বেশি নমনীয় এবং একটি CompletedProcess অবজেক্ট প্রদান করে যখন কমান্ডটি কার্যকর হয়।

  6. Os মডিউলটিতে আপনার সমস্ত সিঙ্ক প্রোগ্রামে ফর্ক / ফেক / স্পন ফাংশন রয়েছে, তবে আমি সরাসরি তাদের ব্যবহার করার প্রস্তাব দিই না।

subprocess মডিউল সম্ভবত আপনি ব্যবহার করা উচিত।

অবশেষে সচেতন থাকুন যে সমস্ত পদ্ধতির জন্য যেখানে আপনি শেল দ্বারা শূন্য দ্বারা চূড়ান্ত কমান্ডটি চালান এবং আপনি এটিকে পালানোর জন্য দায়ী হন। আপনি যে স্ট্রিংটি পাস করেন তার যে কোনও অংশ সম্পূর্ণরূপে বিশ্বস্ত হতে পারে না সেক্ষেত্রে গুরুতর নিরাপত্তা প্রভাব রয়েছে । উদাহরণস্বরূপ, একটি ব্যবহারকারী স্ট্রিং এর কিছু / কোনো অংশ প্রবেশ করা হয়। যদি আপনি অনিশ্চিত হন তবে শুধুমাত্র ধ্রুবকগুলির সাথে এই পদ্ধতিগুলি ব্যবহার করুন। আপনি এই কোড বিবেচনা প্রভাব একটি ইঙ্গিত দিতে:

print subprocess.Popen("echo %s " % user_input, stdout=PIPE).stdout.read()

এবং কল্পনা করুন যে ব্যবহারকারী প্রবেশ করে "আমার মা আমাকে ভালবাসে না & rm -rf /"।


বিভিন্ন লাইব্রেরিগুলি রয়েছে যা আপনাকে পাইথন সহ বাহ্যিক কমান্ডগুলি কল করার অনুমতি দেয়। প্রতিটি লাইব্রেরির জন্য আমি একটি বর্ণনা দিয়েছি এবং একটি বাহ্যিক কমান্ড কল করার উদাহরণ দেখিয়েছি। আমি উদাহরণ হিসাবে ব্যবহৃত কমান্ড ls -l (সব ফাইল তালিকা)। আপনি যদি লাইব্রেরির যে কোনও সম্পর্কে আরও জানতে চান তবে আমি তালিকাভুক্ত করেছি এবং তাদের প্রত্যেকের জন্য ডকুমেন্টেশন লিঙ্ক করেছি।

সূত্র:

এই সব লাইব্রেরি হয়:

আশা করি এটি আপনাকে লাইব্রেরি ব্যবহার করার সিদ্ধান্ত নিতে সহায়তা করবে :)

subprocess

সাবপ্রোসেস আপনাকে বাহ্যিক কমান্ডগুলি কল করতে এবং তাদের ইনপুট / আউটপুট / ত্রুটি পাইপগুলি (স্টেডিন, স্টডাউট এবং স্টারার) সাথে সংযোগ করতে দেয়। সাবপ্রোকেস কমান্ড চালানোর জন্য ডিফল্ট পছন্দ, তবে কখনও কখনও অন্যান্য মডিউল ভাল।

subprocess.run(["ls", "-l"]) # Run command
subprocess.run(["ls", "-l"], stdout=subprocess.PIPE) # This will run the command and return any output
subprocess.run(shlex.split("ls -l")) # You can also use the shlex library to split the command

অপারেটিং সিস্টেম

os "অপারেটিং সিস্টেম নির্ভরশীল কার্যকারিতা" জন্য ব্যবহার করা হয়। এটি os.system এবং os.popen সাথে বাহ্যিক কমান্ডগুলিতে কল করার জন্য ব্যবহার করা যেতে পারে (দ্রষ্টব্য: একটি উপপ্রোকাসপপেনও আছে)। os সর্বদা শেলটি চালাবে এবং এটি এমন একটি সাধারণ বিকল্প যা লোকেদের প্রয়োজন নেই, অথবা subprocess.run ব্যবহার করবেন না তা জানেন না।

os.system("ls -l") # run command
os.popen("ls -l").read() # This will run the command and return any output

SH

sh একটি উপ-প্রসেস ইন্টারফেস যা আপনাকে প্রোগ্রামগুলির মতো কল করতে দেয়। আপনি যদি একাধিক বার কমান্ড চালাতে চান তবে এটি দরকারী।

sh.ls("-l") # Run command normally
ls_cmd = sh.Command("ls") # Save command as a variable
ls_cmd() # Run command as if it were a function

সীসা

plumbum "স্ক্রিপ্ট মত" পাইথন প্রোগ্রামের জন্য একটি লাইব্রেরি। আপনি sh হিসাবে ফাংশন মত প্রোগ্রাম কল করতে পারেন। আপনি শেল ছাড়া একটি পাইপলাইন চালাতে চান Plumbum দরকারী।

ls_cmd = plumbum.local("ls -l") # get command
ls_cmd() # run command

pexpect

pexpect আপনি শিশু অ্যাপ্লিকেশন spawn করতে দেয়, তাদের নিয়ন্ত্রণ এবং তাদের আউটপুট নিদর্শন খুঁজে। এটি ইউনিক্সের একটি tty আশা করার জন্য কমান্ডগুলির জন্য উপ-প্রসেসের একটি ভাল বিকল্প।

pexpect.run("ls -l") # Run command as normal
child = pexpect.spawn('scp foo [email protected]:.') # Spawns child application
child.expect('Password:') # When this is the output
child.sendline('mypassword')

ফ্যাব্রিক

ফ্যাব্রিক একটি পাইথন 2.5 এবং 2.7 লাইব্রেরি। এটি আপনাকে স্থানীয় এবং দূরবর্তী শেল কমান্ডগুলি চালানোর অনুমতি দেয়। ফ্যাব্রিক একটি নিরাপদ শেল (এসএসএইচ) কমান্ড চালানোর জন্য সহজ বিকল্প

fabric.operations.local('ls -l') # Run command as normal
fabric.operations.local('ls -l', capture = True) # Run command and receive output

দূত

দূত "মানুষের জন্য subprocess" হিসাবে পরিচিত হয়। এটি subprocess মডিউলের চারপাশে একটি সুবিধাজনক মোড়ক হিসাবে ব্যবহৃত হয়।

r = envoy.run("ls -l") # Run command
r.std_out # get output

কমান্ড

commands os.popen জন্য os.popen ফাংশন রয়েছে, তবে এটি পাইথন 3 থেকে সরানো হয়েছে কারণ subprocess একটি ভাল বিকল্প।

সম্পাদনা জেএফ সেবাস্তিয়ানের মন্তব্যের উপর ভিত্তি করে ছিল।


স্ট্যান্ডার্ড লাইব্রেরীতে সাবপ্রোকেস মডিউলটি দেখুন :

from subprocess import call
call(["ls", "-l"])

উপপ্রকার বনাম সিস্টেমের সুবিধা এটি আরও বেশি নমনীয় (আপনি স্টডাউট , স্টারার , "বাস্তব" স্ট্যাটাস কোড, ভাল ত্রুটি পরিচালনা, ইত্যাদি পেতে পারেন ...)।

অফিসিয়াল ডকুমেন্টেশান বিকল্প os.system () উপর উপপ্রযুক্ত মডিউল সুপারিশ:

সাবপ্রোকেস মডিউল নতুন প্রসেসগুলি বজায় রাখার এবং তাদের ফলাফল পুনরুদ্ধারের জন্য আরও শক্তিশালী সুবিধা সরবরাহ করে; এই মডিউল ব্যবহার করে এই ফাংশন [ os.system() ] ব্যবহার করা আরও ভাল।

সাব - প্রসেস ডকুমেন্টেশনে " সাবপ্রোকেস মডিউল সহ পুরানো কাজগুলি প্রতিস্থাপনের " বিভাগটি কিছু সহায়ক রেসিপি থাকতে পারে।

উপপ্রযুক্তির মডিউলে অফিসিয়াল ডকুমেন্টেশন:


Plumbum

>>> from plumbum import local
>>> ls = local["ls"]
>>> ls
LocalCommand(<LocalPath /bin/ls>)
>>> ls()
u'build.py\ndist\ndocs\nLICENSE\nplumbum\nREADME.rst\nsetup.py\ntests\ntodo.txt\n'
>>> notepad = local["c:\\windows\\notepad.exe"]
>>> notepad()                                   # Notepad window pops up
u''                                             # Notepad window is closed by user, command returns

os.system ঠিক আছে, কিন্তু তারিখের ধরনের। এটা খুব নিরাপদ নয়। পরিবর্তে, subprocess চেষ্টা করুন। subprocess সরাসরি শ কল না এবং অতএব os.system তুলনায় আরো নিরাপদ।

এখানে আরও তথ্য পান।


os.systemআপনি ফলাফল সংরক্ষণ করার অনুমতি দেয় না, তাই আপনি কিছু তালিকা বা কিছু subprocess.callকাজ ফলাফল সংরক্ষণ করতে চান ।


আপনি Popen ব্যবহার করতে পারেন, এবং তারপর আপনি পদ্ধতির অবস্থা চেক করতে পারেন:

from subprocess import Popen

proc = Popen(['ls', '-l'])
if proc.poll() is None:
    proc.kill()

subprocess.Popen চেক আউট ।


এখানে আরেকটি পার্থক্য রয়েছে যা পূর্বে উল্লেখ করা হয়নি।

subprocess.Popenএকটি subprocess হিসাবে <কমান্ড> সঞ্চালিত হয়। আমার ক্ষেত্রে, আমাকে <a>> ফাইলটি চালানোর দরকার যা <a>> অন্য প্রোগ্রামের সাথে যোগাযোগ করতে হবে।

আমি subprocess চেষ্টা, এবং মৃত্যুদন্ড সফল হয়েছে। তবে <b> <a> এর সাথে যোগাযোগ করতে পারিনি। আমি টার্মিনাল থেকে উভয় রান যখন সবকিছু স্বাভাবিক।

আরও একটি: (দ্রষ্টব্য: kwrite অন্যান্য অ্যাপ্লিকেশন থেকে আলাদা আচরণ করে। যদি আপনি নীচের ফায়ারফক্সের সাথে চেষ্টা করেন তবে ফলাফল একই হবে না।)

আপনি যদি চেষ্টা করেন os.system("kwrite"), ব্যবহারকারীরা kwrite বন্ধ না হওয়া পর্যন্ত প্রোগ্রাম প্রবাহ স্থির করে। যে পরাস্ত করার পরিবর্তে আমি চেষ্টা করেছিলাম os.system(konsole -e kwrite)। এই সময় প্রোগ্রাম প্রবাহ অব্যাহত, কিন্তু kwrite কনসোল এর subprocess হয়ে ওঠে।

যে কেউ kwrite একটি subprocess না হয় (অর্থাৎ সিস্টেম মনিটর এটি গাছের বাম প্রান্তে প্রদর্শিত হবে)।


আমি তার সরলতা জন্য shell_command মত বেশ । এটি subprocess মডিউল শীর্ষে নির্মিত হয়।

এখানে ডক্স থেকে একটি উদাহরণ:

>>> from shell_command import shell_call
>>> shell_call("ls *.py")
setup.py  shell_command.py  test_shell_command.py
0
>>> shell_call("ls -l *.py")
-rw-r--r-- 1 ncoghlan ncoghlan  391 2011-12-11 12:07 setup.py
-rw-r--r-- 1 ncoghlan ncoghlan 7855 2011-12-11 16:16 shell_command.py
-rwxr-xr-x 1 ncoghlan ncoghlan 8463 2011-12-11 16:17 test_shell_command.py
0

উইন্ডোজ আপনি শুধু আমদানি করতে পারেন subprocessমডিউল এবং কল করে বহিরাগত কমান্ড সঞ্চালন করুন subprocess.Popen(), subprocess.Popen().communicate()এবং subprocess.Popen().wait()নিচের:

+--------------------------------------+------------+------+
| ID                                   | Label      | CIDR |
+--------------------------------------+------------+------+
| 431c9014-5b5d-4b51-a357-66020ffbb123 | test1      | None |
| 27a74fcd-37c0-4789-9414-9531b7e3f126 | External   | None |
| 5a2712e9-70dc-4b0e-9281-17e02f4684c9 | management | None |
| 7aa697f5-0e60-4c15-b4cc-9cb659698512 | Internal   | None |
+--------------------------------------+------------+------+

আউটপুট:

27a74fcd-37c0-4789-9414-9531b7e3f126

লিনাক্সের অধীনে, যদি আপনি একটি বাহ্যিক কমান্ড কল করতে চান যা স্বাধীনভাবে চালানো হবে (পাইথন স্ক্রিপ্টটি শেষ হওয়ার পরে চলবে), আপনি টাস্ক স্পুলার বা at কমান্ড হিসাবে একটি সরল সারি ব্যবহার করতে পারেন

টাস্ক স্পুলারের সাথে একটি উদাহরণ:

#!/usr/bin/python
import os
netid= "nova net-list | awk '/ External / { print $2 }'"
temp=os.popen(netid).read()  /* here temp also contains new line (\n) */
networkId=temp.rstrip()
print(networkId)

টাস্ক স্পুলার সম্পর্কে নোট ( ts):

  1. আপনি সমান্তরাল প্রসেসগুলির সংখ্যাটি চালানোর জন্য ("স্লটস") সেট করতে পারেন:

    ts -S <number-of-slots>

  2. ইনস্টলিং tsঅ্যাডমিন বিশেষাধিকার প্রয়োজন হয় না। আপনি সহজে উৎস থেকে এটি ডাউনলোড এবং সংকলন করতে পারেন make, এটি আপনার পথে যুক্ত করুন এবং আপনি সম্পন্ন হয়েছেন।


import os
cmd = 'ls -al'
os.system(cmd)

আপনি যদি কমান্ডের ফলাফলগুলি ফেরত দিতে চান তবে আপনি os.popen ব্যবহার করতে পারেন। যাইহোক, এটি উপ - প্রসেস মডিউলের পক্ষে সংস্করণ 2.6 এর থেকে অপ্রচলিত , যা অন্যান্য উত্তরগুলি ভালভাবে আচ্ছাদিত করেছে।





external