পাইথন স্ক্রিপ্ট থেকে আপনি কীভাবে কোনও বাহ্যিক কমান্ড কল করবেন (যেন আমি এটি ইউনিক্স শেল বা উইন্ডোজ কমান্ড প্রম্পটে টাইপ করেছি)?
পাইথন স্ক্রিপ্ট থেকে আপনি কীভাবে কোনও বাহ্যিক কমান্ড কল করবেন (যেন আমি এটি ইউনিক্স শেল বা উইন্ডোজ কমান্ড প্রম্পটে টাইপ করেছি)?
উত্তর:
স্ট্যান্ডার্ড লাইব্রেরিতে সাব - প্রসেস মডিউলটি দেখুন:
import subprocess
subprocess.run(["ls", "-l"])সুবিধা subprocessবনাম systemযে এটি আরো নমনীয় (আপনি পেতে পারেন stdout, stderr"বাস্তবিক" স্থিতি কোড, ভাল ত্রুটি পরিচালনা, ইত্যাদি ...)।
সরকারী ডকুমেন্টেশন বিশেষ পরামর্শ দেওয়া হচ্ছে subprocessবিকল্প উপর মডিউল os.system():
subprocessমডিউল নতুন প্রসেস ডিম ছাড়ার এবং তাদের ফলাফল পুনরুদ্ধারের জন্য আরো শক্তিশালী সুবিধা প্রদান করে; এই ফাংশনটি ব্যবহার করার ক্ষেত্রে সেই মডিউলটি ব্যবহার করা ভালos.system()।
Subprocess মডিউলটির প্রতিস্থাপন করা হচ্ছে পুরাতন কার্যাবলী অধ্যায় subprocessডকুমেন্টেশন কিছু সহায়ক রেসিপি থাকতে পারে।
৩.৫ এর আগে পাইথনের সংস্করণগুলির জন্য, ব্যবহার করুন call:
import subprocess
subprocess.call(["ls", "-l"])shell=Trueএটি কাজ করার জন্য আপনাকে ব্যবহার করতে হবে ।
shell=True, এই উদ্দেশ্যে পাইথন আসছেন os.path.expandvars সহ । আপনার যদি আপনি লিখতে পারেন: os.path.expandvars("$PATH")। @ শেঠমোর্টন দয়া করে আপনার মন্তব্যটি পুনর্বিবেচনা করুন -> কেন শেল ব্যবহার করবেন না = সত্য
forলুপে একাধিক কমান্ড চালাতে চাই তবে এটি কীভাবে এটি করব আমার অজগর স্ক্রিপ্টটি ব্লক না করে? কমান্ডের আউটপুট সম্পর্কে আমি মাথা ঘামাই না আমি কেবল তাদের প্রচুর চালাতে চাই।
subprocessকখন কখন ব্যবহার করা যেতে পারে shell=False, তারপরে shlex.splitএই ডকস.পাইথন.আর
বাহ্যিক প্রোগ্রামগুলি কল করার উপায়গুলির সংক্ষিপ্তসার এবং এর প্রতিটিটির সুবিধা এবং অসুবিধা:
os.system("some_command with args")আপনার সিস্টেমের শেলের কাছে কমান্ড এবং আর্গুমেন্টগুলি পাস করে। এটি দুর্দান্ত কারণ আপনি এই পদ্ধতিতে একবারে একাধিক কমান্ড চালাতে পারেন এবং পাইপ এবং ইনপুট / আউটপুট পুনঃনির্দেশ সেটআপ করতে পারেন। উদাহরণ স্বরূপ:
os.system("some_command < input_file | another_command > output_file") যাইহোক, এটি সুবিধাজনক হওয়ার পরে শেল অক্ষর যেমন ফাঁকা স্থান ইত্যাদির সন্ধানের জন্য আপনাকে ম্যানুয়ালি হ্যান্ডেল করতে হবে অন্যদিকে, এটি আপনাকে কমান্ডগুলি চালাতে দেয় যা কেবল শেল কমান্ড এবং আসলে বাহ্যিক প্রোগ্রাম নয়। ডকুমেন্টেশন দেখুন ।
stream = os.popen("some_command with args")একই জিনিসটি os.systemবাদ দিলে এটি আপনাকে কোনও ফাইলের মতো বস্তু দেয় যা আপনি সেই প্রক্রিয়াটির জন্য স্ট্যান্ডার্ড ইনপুট / আউটপুট অ্যাক্সেস করতে ব্যবহার করতে পারেন। পপেনের 3 টি অন্যান্য রূপ রয়েছে যা সমস্ত i / o কিছুটা আলাদাভাবে পরিচালনা করে। আপনি যদি স্ট্রিং হিসাবে সমস্ত কিছু পাস করেন, তবে আপনার কমান্ডটি শেলের কাছে দেওয়া হবে; যদি আপনি এগুলি তালিকা হিসাবে পাস করেন তবে আপনার কোনও কিছু পালানোর বিষয়ে চিন্তা করার দরকার নেই। ডকুমেন্টেশন দেখুন ।
Popenবর্গ subprocessমডিউল। এটি এর প্রতিস্থাপন হিসাবে তৈরি করা হয়েছে os.popenতবে এত বিস্তৃত হওয়ার গুণে কিছুটা জটিল হওয়ার খারাপ দিক রয়েছে। উদাহরণস্বরূপ, আপনি বলতে চাইবেন:
print subprocess.Popen("echo Hello World", shell=True, stdout=subprocess.PIPE).stdout.read()পরিবর্তে:
print os.popen("echo Hello World").read()তবে সেখানে 4 টি পৃথক পপেন ফাংশনগুলির পরিবর্তে একটি ইউনিফাইড শ্রেণিতে সমস্ত অপশন থাকা ভাল nice ডকুমেন্টেশন দেখুন ।
callথেকে ফাংশন subprocessমডিউল। এটি মূলত Popenক্লাসের মতো এবং একই সাথে সমস্ত আর্গুমেন্ট গ্রহণ করে, তবে কমান্ডটি সম্পূর্ণ না হওয়া এবং আপনাকে রিটার্ন কোড না দেওয়া পর্যন্ত এটি কেবল অপেক্ষা করে। উদাহরণ স্বরূপ:
return_code = subprocess.call("echo Hello World", shell=True) ডকুমেন্টেশন দেখুন ।
আপনি যদি পাইথন 3.5 বা তার বেশি পরে থাকেন তবে আপনি নতুন subprocess.runফাংশনটি ব্যবহার করতে পারেন যা উপরের মতো অনেক বেশি তবে আরও নমনীয় এবং CompletedProcessকমান্ডটি সম্পাদন শেষ হলে কোনও বস্তু ফেরত দেয় ।
ওএস মডিউলটিতে আপনার সি সি প্রোগ্রামে থাকা কাঁটাচাটি / এক্সিকিউটিভ / স্পন ফাংশনগুলিরও সমস্ত রয়েছে, তবে আমি সেগুলি সরাসরি ব্যবহারের প্রস্তাব দিই না।
subprocessমডিউল সম্ভবত হওয়া উচিত কি আপনি ব্যবহার করেন।
অবশেষে দয়া করে সচেতন হন যে সমস্ত পদ্ধতির জন্য আপনি শেল দ্বারা একটি স্ট্রিং হিসাবে চালিত হওয়ার জন্য চূড়ান্ত কমান্ডটি পাস করেন এবং এটি থেকে বেরিয়ে আসার জন্য আপনি দায়ী। আপনার পাস করা স্ট্রিংয়ের কোনও অংশ পুরোপুরি বিশ্বাসযোগ্য না হলে গুরুতর সুরক্ষিত জালিয়াতি রয়েছে । উদাহরণস্বরূপ, যদি কোনও ব্যবহারকারী স্ট্রিংয়ের কোনও / অংশে প্রবেশ করে। আপনি যদি অনিশ্চিত হন তবে কেবল ধ্রুবক সহ এই পদ্ধতিগুলি ব্যবহার করুন। আপনাকে বোঝাতে ইঙ্গিত দেওয়ার জন্য এই কোডটি বিবেচনা করুন:
print subprocess.Popen("echo %s " % user_input, stdout=PIPE).stdout.read()এবং কল্পনা করুন যে ব্যবহারকারী "আমার মামা আমাকে && rm -rf /" ভালবাসেন না এমন কিছু প্রবেশ করে যা পুরো ফাইল সিস্টেমটি মুছে ফেলতে পারে।
open।
subprocess.run()। docs.python.org/3.5/library/subprocess.html#subprocess.run
subprocess.run(..)ঠিক কী করবে "এটি ডিফল্টরূপে স্টাডাউট বা স্ট্ডারকে ক্যাপচার করে না।" পরোক্ষভাবে? subprocess.check_output(..)এসটিডিআরআর সম্পর্কে কী ?
echoস্ট্রিং এর সামনে লক্ষ্য করা হয়েছে Popen? সুতরাং সম্পূর্ণ কমান্ড হবে echo my mama didnt love me && rm -rf /।
subprocess.run()বা এর বড় ভাই-বোন subprocess.check_call()ইত্যাদি ইত্যাদি al এগুলি পর্যাপ্ত নয় এমন ক্ষেত্রে দেখুন subprocess.Popen()। os.popen()সম্ভবত একেবারেই উল্লেখ করা উচিত নয়, বা "নিজের কাঁটাচামচ / এক্সিকিউটিভ / স্প্যান কোড হ্যাক করুন" এর পরেও আসা উচিত।
সাধারণ বাস্তবায়ন:
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()।
.readlines()সমস্ত লাইন একবারে পড়া হয় , এটি সাবপ্রসেসটি প্রস্থান না হওয়া অবধি অবরুদ্ধ হয় (পাইপের শেষ প্রান্তটি বন্ধ করে দেয়)। রিয়েল টাইমে পড়তে (যদি কোনও বাফারিং সমস্যা না থাকে) আপনি করতে পারেন:for line in iter(p.stdout.readline, ''): print line,
p.stdout.readline()(দ্রষ্টব্য: sশেষ নেই) যতক্ষণ না শিশু তার বাফারটি পূরণ করে কোনও ডেটা দেখতে পাবে না। যদি শিশুটি খুব বেশি ডেটা তৈরি করে না তবে আউটপুট আসল সময়ে হবে না। প্রশ্নে দ্বিতীয় কারণটি দেখুন : কেন কেবল পাইপ ব্যবহার করবেন না (পপেন ())? । এই উত্তরে কিছু কর্মক্ষেত্র সরবরাহ করা হয়েছে (pexpect, pty, stdbuf)
Popenসহজ কাজের জন্য সুপারিশ করা উচিত নয় । এটি অযথাও নির্দিষ্ট করে shell=True। একটি subprocess.run()উত্তর চেষ্টা করুন ।
কলিং এক থেকে শিশু প্রক্রিয়াটি বিচ্ছিন্ন করার বিষয়ে কিছু ইঙ্গিত (পটভূমিতে শিশু প্রক্রিয়া শুরু করা)।
মনে করুন আপনি কোনও সিজিআই স্ক্রিপ্ট থেকে একটি দীর্ঘ কাজ শুরু করতে চান। অর্থাৎ, শিশু প্রক্রিয়াটি সিজিআই স্ক্রিপ্ট সম্পাদন প্রক্রিয়াটির চেয়ে বেশি দীর্ঘস্থায়ী হওয়া উচিত।
সাবপ্রসেস মডিউল ডকুমেন্টেশন থেকে শাস্ত্রীয় উদাহরণটি হ'ল:
import subprocess
import sys
# Some code here
pid = subprocess.Popen([sys.executable, "longtask.py"]) # Call subprocess
# Some more code hereএখানে ধারণাটি হ'ল লংটাস্ক.পি শেষ না হওয়া পর্যন্ত আপনি 'কল সাবপ্রসেস' লাইনে অপেক্ষা করতে চান না। তবে উদাহরণ থেকে 'আরও কিছু কোড এখানে' রেখার পরে কী হবে তা পরিষ্কার নয়।
আমার লক্ষ্য প্ল্যাটফর্মটি ছিল ফ্রিবিএসডি, তবে বিকাশটি উইন্ডোজে ছিল, তাই আমি প্রথমে উইন্ডোজটিতে সমস্যার মুখোমুখি হয়েছি।
উইন্ডোজ (উইন্ডোজ এক্সপি) এ, লংটাস্ক.পি. এর কাজ শেষ না হওয়া পর্যন্ত পিতামাতার প্রক্রিয়া শেষ হবে না। আপনি সিজিআই স্ক্রিপ্টে যা চান তা নয়। সমস্যাটি পাইথনের সাথে নির্দিষ্ট নয়; পিএইচপি সম্প্রদায়ে সমস্যাগুলি একই রকম।
সমাধানটি হল উইন্ডোজ এপিআইয়ের অন্তর্নিহিত ক্রিয়েটপ্রসেস ফাংশনে DETACHED_PROCESS প্রক্রিয়া তৈরির পতাকাটি প্রেরণ করা । আপনি যদি পাইউইন 32 ইনস্টল করে ফেলেছেন, আপনি উইন 32 প্রসেস মডিউল থেকে পতাকাটি আমদানি করতে পারেন, অন্যথায় আপনি এটি নিজেরাই সংজ্ঞায়িত করতে পারেন:
DETACHED_PROCESS = 0x00000008
pid = subprocess.Popen([sys.executable, "longtask.py"],
creationflags=DETACHED_PROCESS).pid/ * UPD 2015.10.27 @ryksun নোটগুলির নীচে দেওয়া মন্তব্যে, শব্দার্থগতভাবে সঠিক পতাকাটি CREATE_NEW_CONSOLE (0x00000010) * /
ফ্রিবিএসডি-তে আমাদের আরেকটি সমস্যা রয়েছে: পিতামাতার প্রক্রিয়াটি শেষ হয়ে গেলে এটি শিশু প্রক্রিয়াগুলিও শেষ করে ishes এবং এটি কোনও সিজিআই স্ক্রিপ্টে আপনি চান তা নয়। কিছু পরীক্ষা-নিরীক্ষায় দেখা গেছে যে সমস্যাটি সিস্টেস্টস্টাউট ভাগ করে নেওয়ার ক্ষেত্রে বলে মনে হচ্ছে। এবং কার্যনির্বাহী সমাধানটি ছিল:
pid = subprocess.Popen([sys.executable, "longtask.py"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE)আমি অন্যান্য প্ল্যাটফর্মে কোডটি পরীক্ষা করে নিইনি এবং ফ্রিবিএসডি-তে আচরণের কারণগুলিও জানি না। যদি কেউ জানে তবে আপনার মতামত শেয়ার করুন। পাইথনে ব্যাকগ্রাউন্ড প্রক্রিয়া শুরু করার বিষয়ে গুগলিং এখনও কোনও আলো ফেলে না।
DETACHED_PROCESSকরা creationflagsশিশুকে উত্তরাধিকার সূত্রে বা কনসোল তৈরি করে বাধা দিয়ে এড়ানো যায়। পরিবর্তে আপনি যদি নতুন কনসোল চান তবে CREATE_NEW_CONSOLE(0x00000010) ব্যবহার করুন ।
os.devnullকিছু কনসোল প্রোগ্রাম অন্যথায় ত্রুটিযুক্তভাবে প্রস্থান করে। যখন আপনি চান শিশু প্রক্রিয়াটি প্যারেন্ট প্রসেসের সাথে একই সাথে ব্যবহারকারীর সাথে ইন্টারঅ্যাক্ট করতে চান তখন একটি নতুন কনসোল তৈরি করুন। একক উইন্ডোতে উভয়ই করার চেষ্টা করা বিভ্রান্তিকর হবে।
import os
os.system("your command")লক্ষ্য করুন যে এটি বিপজ্জনক, যেহেতু আদেশটি পরিষ্কার করা হয়নি। আমি 'OS' এবং 'sys' মডিউলগুলিতে প্রাসঙ্গিক ডকুমেন্টেশনের জন্য গুগল এ ছেড়ে দিচ্ছি। ফাংশনগুলির একটি গুচ্ছ রয়েছে (এক্সিকিউটি * এবং স্পন *) যা একই রকম কাজ করবে।
subprocessআরও কিছুটা বহুমুখী এবং বহনযোগ্য সমাধান হিসাবে চিহ্নিত করা উচিত । বাহ্যিক কমান্ডগুলি চালানো অবশ্যই অন্তর্নিহিত অপ্রয়োজনীয় (আপনাকে নিশ্চিত করতে হবে যে কমান্ডটি আপনাকে সমর্থন করার জন্য প্রয়োজনীয় প্রতিটি আর্কিটেকচারে উপস্থিত রয়েছে) এবং বাহ্যিক কমান্ড হিসাবে ব্যবহারকারী ইনপুটটি অন্তর্নিহিত অনিরাপদ।
আমি ও.এসসিস্টেমের পরিবর্তে সাবপ্রসেস মডিউলটি ব্যবহার করার পরামর্শ দেব কারণ এটি আপনার পক্ষে শেল পলায়ন করে এবং তাই এটি আরও নিরাপদ।
subprocess.call(['ping', 'localhost'])subprocessকখন সাথে ব্যবহার করা যেতে পারে shell=False, তারপরে shlex.splitএই ডকস.পিথোন.আর / 2 / লিবারি / শ্লেক্স। Html#shlex.split করার সহজ পদ্ধতির জন্য ব্যবহার করুন ( এটা ডক্স অনুযায়ী প্রস্তাবিত উপায় হচ্ছে docs.python.org/2/library/subprocess.html#popen-constructor )
import os
cmd = 'ls -al'
os.system(cmd)আপনি যদি কমান্ডের ফলাফলগুলি ফিরিয়ে দিতে চান তবে আপনি এটি ব্যবহার করতে পারেন os.popen। তবে সাব - প্রসেস মডিউলটির পক্ষে এটি ২.6 সংস্করণ থেকে অবহিত করা হয়েছে , যা অন্য উত্তরগুলি ভালভাবে কভার করেছে।
এখানে প্রচুর বিভিন্ন লাইব্রেরি রয়েছে যা আপনাকে পাইথন সহ বাহ্যিক আদেশগুলি কল করতে দেয় allow প্রতিটি লাইব্রেরির জন্য আমি একটি বিবরণ দিয়েছি এবং একটি বাহ্যিক কমান্ড কল করার একটি উদাহরণ দেখিয়েছি। উদাহরণ হিসাবে আমি যে কমান্ডটি ব্যবহার করেছি তা হ'ল 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.systemএবং os.popen(দ্রষ্টব্য: একটি সাবপ্রসেস.পোপেনও রয়েছে) সহ বাহ্যিক আদেশগুলি কল করতে ব্যবহার করা যেতে পারে । ওএস সর্বদা শেলটি চালাবে এবং এমন লোকদের জন্য একটি সহজ বিকল্প যাঁদের প্রয়োজন হয় না, বা কীভাবে ব্যবহার করতে হয় তা জানেন না subprocess.run।
os.system("ls -l") # run command
os.popen("ls -l").read() # This will run the command and return any outputSH
sh একটি সাবপ্রসেস ইন্টারফেস যা আপনাকে প্রোগ্রামগুলি কল করতে দেয় যেমন তারা ফাংশন were আপনি একাধিকবার কমান্ড চালাতে চাইলে এটি কার্যকর।
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সীসা
প্লাম্বাম পাইথন প্রোগ্রামগুলির জন্য "স্ক্রিপ্ট-জাতীয়" লাইব্রেরি। আপনি যেমন কর্ম হিসাবে কল করতে পারেন প্রোগ্রাম sh। প্লাম্বাম দরকারী যদি আপনি শেল ছাড়াই পাইপলাইন চালাতে চান।
ls_cmd = plumbum.local("ls -l") # get command
ls_cmd() # run commandpexpect
pexpect আপনাকে চাইল্ড অ্যাপ্লিকেশনগুলি স্প্যান করতে, এগুলিকে নিয়ন্ত্রণ করতে এবং তাদের আউটপুটে নিদর্শনগুলি খুঁজে পেতে দেয়। এটি কমান্ডগুলির জন্য সাবপ্রসেসির একটি ভাল বিকল্প যা ইউনিক্সে একটি টিটিটি আশা করে।
pexpect.run("ls -l") # Run command as normal
child = pexpect.spawn('scp foo user@example.com:.') # 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মডিউলটির চারপাশে সুবিধাযুক্ত মোড়ক হিসাবে ব্যবহৃত হয় ।
r = envoy.run("ls -l") # Run command
r.std_out # get outputকমান্ড
commandsএর জন্য মোড়কের কাজগুলি রয়েছে os.popenতবে এটি পাইথন 3 থেকে অপসারণ করা হয়েছেsubprocess এটি একটি ভাল বিকল্প।
সম্পাদনাটি জেএফ সেবাস্তিয়ানের মন্তব্যের ভিত্তিতে করা হয়েছিল।
আমি সবসময় 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)পাইথন লাইব্রেরিটিও "পেরেস্পেক্টেপেক্ট" দেখুন।
এটি বাহ্যিক প্রোগ্রাম / কমান্ডগুলি এমনকি এসএসএস, এফটিপি, টেলনেট ইত্যাদির ইন্টারেক্টিভ নিয়ন্ত্রণের অনুমতি দেয় আপনি কেবল কিছু টাইপ করতে পারেন:
child = pexpect.spawn('ftp 192.168.0.24')
child.expect('(?i)name .*: ')
child.sendline('anonymous')
child.expect('(?i)password')সাবপ্রসেস মডিউলটি ব্যবহার করুন (পাইথন 3):
import subprocess
subprocess.run(['ls', '-l'])এটি প্রস্তাবিত মানক উপায়। তবে আরও জটিল কাজ (পাইপ, আউটপুট, ইনপুট ইত্যাদি) নির্মাণ এবং লেখার জন্য ক্লান্তিকর হতে পারে।
পাইথন সংস্করণে দ্রষ্টব্য: আপনি যদি এখনও পাইথন 2 ব্যবহার করে থাকেন তবে সাবপ্রসেসক্লায়েল একইভাবে কাজ করে।
ProTip: shlex.split তোমার জন্য কমান্ড বিশ্লেষণ করতে সাহায্য করতে পারেন run, callএবং অন্যান্য subprocessক্ষেত্রে ফাংশন তুমি কি চাও না (অথবা তুমি পারবে না!) তালিকা আকারে তাদের প্রদান:
import shlex
import subprocess
subprocess.run(shlex.split('ls -l'))আপনি যদি বাহ্যিক নির্ভরতা আপত্তি না করেন তবে প্লাম্বাম ব্যবহার করুন :
from plumbum.cmd import ifconfig
print(ifconfig['wlan0']())এটি সেরা subprocessর্যাপার। এটি ক্রস প্ল্যাটফর্ম, অর্থাৎ এটি উইন্ডোজ এবং ইউনিক্স-উভয় সিস্টেমে কাজ করে। দ্বারা ইনস্টল করুন pip install plumbum।
আর একটি জনপ্রিয় গ্রন্থাগার হ'ল শ :
from sh import ifconfig
print(ifconfig('wlan0'))যাইহোক, shউইন্ডোজ সমর্থন বাদ দেওয়া হয়েছে, সুতরাং এটি আগের মতো ভয়ঙ্কর নয়। দ্বারা ইনস্টল করুন pip install sh।
আপনি যে কমান্ডটি কল করছেন তার আউটপুট আপনার যদি প্রয়োজন হয় তবে আপনি সাবপ্রসেস.সিচ_আউটপুট (পাইথন ২.7+ ) ব্যবহার করতে পারেন ।
>>> subprocess.check_output(["ls", "-l", "/dev/null"])
'crw-rw-rw- 1 root root 1, 3 Oct 18 2007 /dev/null\n'শেল প্যারামিটারটিও নোট করুন ।
শেলটি থাকলে শেলটির
Trueমাধ্যমে নির্দিষ্ট কমান্ডটি কার্যকর করা হবে। আপনি যদি পাইথনটি প্রাথমিকভাবে বর্ধিত নিয়ন্ত্রণ প্রবাহের জন্য ব্যবহার করে থাকেন তবে এটি বেশিরভাগ সিস্টেমের শেলের উপরে সরবরাহ করে এবং এখনও শেল পাইপ, ফাইলের নাম ওয়াইল্ডকার্ডস, পরিবেশের পরিবর্তনশীল প্রসারণ এবং ব্যবহারকারীর বাড়ির ~ প্রসারণের মতো অন্যান্য শেল বৈশিষ্ট্যগুলিতে সুবিধাজনক অ্যাক্সেস চান want ডিরেক্টরি। যাইহোক, দয়া করে মনে রাখবেন পাইথন নিজেই বাস্তবায়নের উপলব্ধ করা হয় অনেক শেল মত বৈশিষ্ট্য (বিশেষত,glob,fnmatch,os.walk(),os.path.expandvars(),os.path.expanduser(), এবংshutil)।
check_outputস্ট্রিং পরিবর্তে একটি তালিকা প্রয়োজন। আপনি যদি আপনার কলকে বৈধ করতে কোট করা জায়গাগুলির উপর নির্ভর না করেন তবে এটি করার সহজতম, সর্বাধিক পঠনযোগ্য উপায় subprocess.check_output("ls -l /dev/null".split())।
এইভাবে আমি আমার কমান্ডগুলি চালাই। এই কোডটিতে আপনার বেশ কিছু প্রয়োজন রয়েছে
from subprocess import Popen, PIPE
cmd = "ls -l ~/"
p = Popen(cmd , shell=True, stdout=PIPE, stderr=PIPE)
out, err = p.communicate()
print "Return code: ", p.returncode
print out.rstrip(), err.rstrip()subprocess.runপাইথন 3.5 হিসাবে প্রস্তাবিত পদ্ধতিটি যদি আপনার কোডটি পূর্ববর্তী পাইথন সংস্করণগুলির সাথে সামঞ্জস্য বজায় রাখার প্রয়োজন না হয়। এটি আরও সামঞ্জস্যপূর্ণ এবং দূত হিসাবে অনুরূপ সহজেই ব্যবহারের অফার দেয়। (পাইপিং যদিও তত সরল নয় how কীভাবে এই প্রশ্নটি দেখুন ))
এখানে ডকুমেন্টেশন থেকে কিছু উদাহরণ ।
একটি প্রক্রিয়া চালান:
>>> subprocess.run(["ls", "-l"]) # Doesn't capture output
CompletedProcess(args=['ls', '-l'], returncode=0)ব্যর্থ রান উপর উত্থাপন:
>>> 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(["ls", "-l", "/dev/null"], stdout=subprocess.PIPE)
CompletedProcess(args=['ls', '-l', '/dev/null'], returncode=0,
stdout=b'crw-rw-rw- 1 root root 1, 3 Jan 23 16:23 /dev/null\n')আমি দূত চেষ্টা করার পরামর্শ দিচ্ছি । এটি সাবপ্রসেসের জন্য একটি মোড়ক, যা ঘুরে আসে পরিবর্তে পুরানো মডিউল এবং ফাংশনগুলি প্রতিস্থাপন করা হবে। দূত মানুষের জন্য উপ-প্রসেস sub
README থেকে ব্যবহারের উদাহরণ :
>>> r = envoy.run('git config', data='data to pipe in', timeout=2)
>>> r.status_code
129
>>> r.std_out
'usage: git config [options]'
>>> r.std_err
''পাইপ স্টাফ চারপাশে:
>>> r = envoy.run('uptime | pbcopy')
>>> r.command
'pbcopy'
>>> r.status_code
0
>>> r.history
[<Response 'uptime'>]পাইথনে একটি বাহ্যিক কমান্ড কল করা
সরল, ব্যবহার 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 হিসাবে, ডকুমেন্টেশন সাবপ্রসেস.আরুনকে সুপারিশ করে :
উপ-প্রক্রিয়াগুলি চালিত হওয়ার জন্য প্রস্তাবিত পদ্ধতির হ'ল এটি ব্যবহার করতে পারে এমন সমস্ত ব্যবহারের ক্ষেত্রে রান () ফাংশন ব্যবহার করা। আরও উন্নত ব্যবহারের ক্ষেত্রে, অন্তর্নিহিত পোপেন ইন্টারফেসটি সরাসরি ব্যবহার করা যেতে পারে।
এখানে সম্ভাব্যতম সহজ ব্যবহারের উদাহরণ - এবং এটি যেমনটি জিজ্ঞাসা করা ঠিক তেমন করে:
>>> 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(যদি আপনি এটি একটি timeout=যুক্তি দেন) বা CalledProcessError(যদি এটি ব্যর্থ হয় এবং আপনি পাস করেন check=True)।
আপনি উপরের উদাহরণটি থেকে অনুমান করতে পারেন, stdout এবং stderr উভয়ই ডিফল্টরূপে আপনার নিজস্ব স্টাডাউট এবং স্ট্ডারকে পাইপ করা হবে।
আমরা প্রত্যাবর্তিত বস্তুটি পরীক্ষা করতে পারি এবং প্রদত্ত আদেশ এবং রিটার্ন কোডটি দেখতে পারি:
>>> completed_process.args
'python --version'
>>> completed_process.returncode
0আপনি যদি আউটপুট ক্যাপচার করতে চান তবে আপনি subprocess.PIPEউপযুক্ত stderrবা stdout:
>>> 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''(আমি এটি আকর্ষণীয় এবং সামান্য বিপরীতমুখী বলে মনে করি যে সংস্করণ তথ্য স্টাডআউটের পরিবর্তে স্ট্যাডারকে দেওয়া হয়েছে))
কেউ সহজেই একটি কমান্ড স্ট্রিং সরবরাহ করে (প্রোগ্রামের মতো প্রশ্নের পরামর্শ দেয়) থেকে প্রোগ্রামিয়ালি নির্মিত স্ট্রিং সরবরাহ করতে পারে। প্রোগ্রামিংভাবে স্ট্রিংগুলি তৈরি করবেন না। এটি একটি সম্ভাব্য সুরক্ষা সমস্যা। আপনি ইনপুটকে বিশ্বাস করেন না এটি ধরে নেওয়া ভাল।
>>> 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দেওয়া হয় Popenকন্সট্রাকটর। inputবাইটের একটি স্ট্রিং (অথবা ইউনিকোড, যদি এনকোডিং নির্দিষ্ট করে থাকে বা canuniversal_newlines=True ) হতে পারে যা সাবপ্রসেসের স্টিডিনে পাইপ করা হবে।
ডকুমেন্টেশন বর্ণনা করে timeout=এবং check=Trueআমার চেয়ে ভাল:
সময়সীমা আর্গুমেন্ট পপেন.কমিউনেট () এ দেওয়া হয়েছে। সময়সীমা শেষ হলে, শিশু প্রক্রিয়াটি মেরে ফেলার জন্য অপেক্ষা করতে থাকবে। শিশু প্রক্রিয়াটি সমাপ্ত হওয়ার পরে টাইমআউট এক্সপায়ার্ড ব্যতিক্রমটি পুনরায় উত্থাপিত হবে।
যদি চেকটি সত্য হয়, এবং প্রক্রিয়াটি একটি শূন্য-বহির্গমন কোডের সাথে প্রস্থান করে, একটি কলযুক্তপ্রসেসরর ব্যতিক্রম উত্থাপিত হবে। এই ব্যাতিক্রমের বৈশিষ্ট্যগুলি আর্গুমেন্টগুলি, প্রস্থান কোড এবং স্টাডআউট এবং স্টেডারকে ধারণ করে যদি তাদের ধারণ করা হয়।
এবং এই উদাহরণটি 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আপনাকে এর পদ্ধতি সহ অ্যাক্সেস দেয়poll 'প্রেরণ_সিংগাল', 'সমাপ্তি', এবং 'অপেক্ষা' ।
উত্স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)একটি নতুন প্রক্রিয়াতে একটি শিশু প্রোগ্রাম কার্যকর করুন। পসিক্সে, ক্লাসটি শিশু প্রোগ্রাম চালানোর জন্য os.execvp () - এর মতো আচরণ ব্যবহার করে। উইন্ডোজে, ক্লাসটি উইন্ডোজ ক্রিয়েটপ্রসেস () ফাংশন ব্যবহার করে। পোপেনের পক্ষে যুক্তিগুলি নিম্নরূপ।
বাকি ডকুমেন্টেশনগুলি বোঝা Popenপাঠকের পক্ষে অনুশীলন হিসাবে ছেড়ে দেওয়া হবে।
shell=Trueকমান্ডটি তালিকা হিসাবে পাস করা উচিত বা (আরও ভাল) হওয়া উচিত ।
os.systemঠিক আছে, কিন্তু তারিখের মত। এটি খুব নিরাপদও নয়। পরিবর্তে, চেষ্টা করুন subprocess। subprocesssh কে সরাসরি কল করে না এবং তাই এর চেয়ে বেশি সুরক্ষিতos.system ।
আরও তথ্য পান এখানে ।
subprocessসুরক্ষা সংক্রান্ত সমস্ত সমস্যা সরিয়ে নেই এবং এর নিজস্ব কিছু জটিল সমস্যা রয়েছে।
রয়েছে লিড
>>> 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ব্যবহার করুন:
import os
cmd = 'ls -al'
os.system(cmd)OS - এই মডিউলটি অপারেটিং সিস্টেম-নির্ভরশীল কার্যকারিতা ব্যবহারের বহনযোগ্য উপায় সরবরাহ করে।
আরও osফাংশনগুলির জন্য, এখানে ডকুমেন্টেশন রয়েছে।
এটি এই সহজ হতে পারে:
import os
cmd = "your command"
os.system(cmd)os.systemস্পষ্টভাবে এর পক্ষে ডকুমেন্টেশন এটির পক্ষে এড়াতে সুপারিশ করে 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.Popen<কম্যান্ড> একটি উপ-প্রসেস হিসাবে কার্যকর করে। আমার ক্ষেত্রে, আমাকে ফাইলটি </a> প্রয়োগ করতে হবে যা অন্য প্রোগ্রামের সাথে <b> যোগাযোগ করতে হবে।
আমি সাব-প্রসেস চেষ্টা করেছিলাম, এবং কার্যকর কার্যকর হয়েছিল। তবে <b> <a> সাথে যোগাযোগ করতে পারেনি। আমি যখন টার্মিনাল থেকে উভয় চালাই তখন সমস্ত কিছু স্বাভাবিক।
আরও একটি: (দ্রষ্টব্য: কৌরাইট অন্যান্য অ্যাপ্লিকেশনগুলির চেয়ে আলাদা আচরণ করে Firef আপনি যদি ফায়ারফক্সের সাথে নীচে চেষ্টা করেন তবে ফলাফলগুলি একই রকম হবে না))
আপনি যদি চেষ্টা os.system("kwrite")করেন তবে ব্যবহারকারী কৌরাইট বন্ধ না করা পর্যন্ত প্রোগ্রাম প্রবাহ হিমশীতল হয়। এটি কাটিয়ে উঠতে আমি পরিবর্তে চেষ্টা করেছি os.system(konsole -e kwrite)। এই বারের প্রোগ্রামটি প্রবাহিত হতে থাকে, তবে কুইরাইট কনসোলের সাবপ্রসেসে পরিণত হয়েছিল।
যে কেউ সাব-প্রসেস না হয়ে কুইরাইট চালায় (যেমন সিস্টেম মনিটরে এটি অবশ্যই গাছের বামতম প্রান্তে উপস্থিত হওয়া উচিত)।
os.systemআপনাকে ফলাফল সংরক্ষণের অনুমতি দেয় না, তাই আপনি যদি কিছু তালিকা বা কিছুতে ফলাফল সংরক্ষণ করতে চান তবে একটি subprocess.callকাজ।
আমি শ্লেক্সের সাথে একসাথে সাব-প্রসেস ব্যবহার করার প্রবণতা পাই (উদ্ধৃত স্ট্রিংয়ের পলায়ন পরিচালনা করতে):
>>> import subprocess, shlex
>>> command = 'ls -l "/your/path/with spaces/"'
>>> call_params = shlex.split(command)
>>> print call_params
["ls", "-l", "/your/path/with spaces/"]
>>> subprocess.call(call_params)নির্লজ্জ প্লাগ, আমি এটির জন্য একটি লাইব্রেরি লিখেছি: পি https://github.com/houqp/shell.py
এটি মূলত পপেন এবং আপাতত শ্লেক্সের জন্য একটি মোড়ক। এটি পাইপিং কমান্ডগুলিকে সমর্থন করে যাতে আপনি পাইথনে কমান্ডগুলি আরও সহজ করে তুলতে পারেন। সুতরাং আপনি যেমন কাজ করতে পারেন:
ex('echo hello shell.py') | "awk '{print $2}'"উইন্ডোজ আপনি শুধু আমদানি করতে পারেন subprocessমডিউল এবং কল করে বহিরাগত কমান্ড সঞ্চালন করুন subprocess.Popen(), subprocess.Popen().communicate()এবং subprocess.Popen().wait()নিচের হিসাবে:
# Python script to run a command line
import subprocess
def execute(cmd):
"""
Purpose : To execute a command and return exit status
Argument : cmd - command to execute
Return : exit_code
"""
process = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
(result, error) = process.communicate()
rc = process.wait()
if rc != 0:
print "Error: failed to execute command:", cmd
print error
return result
# def
command = "tasklist | grep python"
print "This process detail: \n", execute(command)আউটপুট:
This process detail:
python.exe 604 RDP-Tcp#0 4 5,660 Kলিনাক্সের অধীনে, আপনি যদি কোনও বাহ্যিক কমান্ড কল করতে চান যা স্বাধীনভাবে কার্যকর হবে (পাইথন স্ক্রিপ্ট সমাপ্তির পরে চলতে থাকবে), আপনি টাস্ক স্পোলার বা অ্যাট কমান্ড হিসাবে একটি সাধারণ সারি ব্যবহার করতে পারেন
টাস্ক স্পুলার সহ একটি উদাহরণ:
import os
os.system('ts <your-command>')টাস্ক স্পুলার ( ts) সম্পর্কে নোট :
আপনি চালানোর জন্য সমবর্তী প্রক্রিয়াগুলির সংখ্যা নির্ধারণ করতে পারেন ("স্লট") এর সাথে:
ts -S <number-of-slots>
ইনস্টল করার tsজন্য প্রশাসকের অধিকারের প্রয়োজন হয় না। আপনি এটি উত্স থেকে একটি সাধারণ দিয়ে ডাউনলোড এবং সংকলন করতে পারেন make, এটি আপনার পথে যুক্ত করুন এবং আপনার কাজ শেষ।
tsআমি জানি এমন কোনও ডিস্ট্রো মানক নয়, যদিও পয়েন্টারটি atহালকাভাবে কার্যকর। আপনি সম্ভবত উল্লেখ করা উচিত batch। অন্য কোথাও, os.system()প্রস্তাবটি সম্ভবত কমপক্ষে উল্লেখ করা উচিত subprocessযা এটির প্রস্তাবিত প্রতিস্থাপন।
আপনি পপেন ব্যবহার করতে পারেন এবং তারপরে আপনি প্রক্রিয়াটির স্থিতি পরীক্ষা করতে পারেন:
from subprocess import Popen
proc = Popen(['ls', '-l'])
if proc.poll() is None:
proc.kill()পরীক্ষা করে দেখুন subprocess.Popen ।
ওপেনস্ট্যাক নিউট্রন থেকে নেটওয়ার্ক আইডি আনতে :
#!/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)নোভা নেট-তালিকার আউটপুট
+--------------------------------------+------------+------+
| 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-9531b7e3f126os.popen()2016 সালের প্রস্তাব দেওয়া উচিত নয় Aw আওক স্ক্রিপ্টটি সহজেই স্থানীয় পাইথন কোডের সাথে প্রতিস্থাপন করা যেতে পারে।
echo $PATHব্যবহার করে করার চেষ্টা করেছিcall(["echo", "$PATH"]), তবে এটি$PATHকোনও প্রতিস্থাপনের পরিবর্তে কেবল আক্ষরিক স্ট্রিংকে প্রতিধ্বনিত করেছে । আমি জানি আমি প্যাথ এনভায়রনমেন্ট ভেরিয়েবলটি পেতে পারি, তবে আমি ভাবছি যে কমান্ডটি ঠিক তেমন আচরণ করতে পারে যাতে আমি বাশকে এটি কার্যকর করেছিলাম।