दिलचस्प पोस्ट
जावास्क्रिप्ट में लूपों में – कुंजी मान जोड़े android.database.sqlite.SQLiteCantOpenDatabaseException: अज्ञात त्रुटि (कोड 14): डेटाबेस नहीं खोल सका कैसे कोडनाम एक काम करता है? मुझे अंतरफलक और एक सार वर्ग के बीच अंतर कैसे समझाया जाना चाहिए? वर्तमान तारीख को न्यूनतम दिनांक पिक्चर दिनांक कैसे तय करें एंड्रॉइड में किसी दृश्य पर डबलटैप कैसे सुनें? मैं C ++ एप्लिकेशन में प्रतिबिंब कैसे जोड़ सकता हूँ? एक संग्रह के अंतिम एन तत्वों को पाने के लिए Linq का उपयोग करना? जावास्क्रिप्ट का उपयोग कर सेलेनियम वेबड्राइवर में एक तत्व को कैसे क्लिक करें dropdownlist MVC3 रेज़र में चयनित मान सेट करें JSP / Servlet ऐप में अपवादों को कैसे व्यवस्थित करें? आर में डेटा के लिए बहुपद मॉडल फिटिंग आईफोन एसडीके के साथ आईफोन के कॉल लॉग को एक्सेस करना जावास्क्रिप्ट में समय के अंतर की जांच करें एक पूर्णांक को देखते हुए, मैं बिट-ट्विडिंग का उपयोग करके दो की अगली सबसे बड़ी शक्ति कैसे प्राप्त करूं?

पायथन के बिना प्रक्रिया आउटपुट पढ़ना बंद करें?

लिनक्स के लिए मेरे पास एक पायथन प्रोग्राम है जो इस तरह दिखता है:

import os import time process = os.popen("top").readlines() time.sleep(1) os.popen("killall top") print process 

कार्यक्रम इस पंक्ति में लटका हुआ है:

 process = os.popen("top").readlines() 

और ऐसा उपकरण में होता है जो "टॉप" जैसे आउटपुट को अपडेट करते हैं

मेरी सबसे अच्छी परीक्षाएं:

 import os import time import subprocess process = subprocess.Popen('top') time.sleep(2) os.popen("killall top") print process 

यह पहले एक (यह kelled) से बेहतर काम किया है, लेकिन यह देता है:

 <subprocess.Popen object at 0x97a50cc> 

दूसरा परीक्षण:

 import os import time import subprocess process = subprocess.Popen('top').readlines() time.sleep(2) os.popen("killall top") print process 

पहले एक के समान इसे "रीडलाइन ()" के कारण लटका दिया गया

इसकी वापसी इस तरह से होनी चाहिए:

 top - 05:31:15 up 12:12, 5 users, load average: 0.25, 0.14, 0.11 Tasks: 174 total, 2 running, 172 sleeping, 0 stopped, 0 zombie Cpu(s): 9.3%us, 3.8%sy, 0.1%ni, 85.9%id, 0.9%wa, 0.0%hi, 0.0%si, 0.0%st Mem: 1992828k total, 1849456k used, 143372k free, 233048k buffers Swap: 4602876k total, 0k used, 4602876k free, 1122780k cached PID USER PR NI VIRT RES SHR S %CPU %MEM TIME+ COMMAND 31735 Barakat 20 0 246m 52m 20m S 19.4 2.7 13:54.91 totem 1907 root 20 0 91264 45m 15m S 1.9 2.3 38:54.14 Xorg 2138 Barakat 20 0 17356 5368 4284 S 1.9 0.3 3:00.15 at-spi-registry 2164 Barakat 9 -11 164m 7372 6252 S 1.9 0.4 2:54.58 pulseaudio 2394 Barakat 20 0 27212 9792 8256 S 1.9 0.5 6:01.48 multiload-apple 6498 Barakat 20 0 56364 30m 18m S 1.9 1.6 0:03.38 pyshell 1 root 20 0 2880 1416 1208 S 0.0 0.1 0:02.02 init 2 root 20 0 0 0 0 S 0.0 0.0 0:00.02 kthreadd 3 root RT 0 0 0 0 S 0.0 0.0 0:00.12 migration/0 4 root 20 0 0 0 0 S 0.0 0.0 0:02.07 ksoftirqd/0 5 root RT 0 0 0 0 S 0.0 0.0 0:00.00 watchdog/0 9 root 20 0 0 0 0 S 0.0 0.0 0:01.43 events/0 11 root 20 0 0 0 0 S 0.0 0.0 0:00.00 cpuset 12 root 20 0 0 0 0 S 0.0 0.0 0:00.02 khelper 13 root 20 0 0 0 0 S 0.0 0.0 0:00.00 netns 14 root 20 0 0 0 0 S 0.0 0.0 0:00.00 async/mgr 15 root 20 0 0 0 0 S 0.0 0.0 0:00.00 pm 

और चर "प्रक्रिया" में सहेजें मैं किसी भी विचार लोग, मैं वास्तव में अब अटक गया है?

वेब के समाधान से एकत्रित समाधान "पायथन के बिना प्रक्रिया आउटपुट पढ़ना बंद करें?"

 #!/usr/bin/env python """Start process; wait 2 seconds; kill the process; print all process output.""" import subprocess import tempfile import time def main(): # open temporary file (it automatically deleted when it is closed) # `Popen` requires `f.fileno()` so `SpooledTemporaryFile` adds nothing here f = tempfile.TemporaryFile() # start process, redirect stdout p = subprocess.Popen(["top"], stdout=f) # wait 2 seconds time.sleep(2) # kill process #NOTE: if it doesn't kill the process then `p.wait()` blocks forever p.terminate() p.wait() # wait for the process to terminate otherwise the output is garbled # print saved output f.seek(0) # rewind to the beginning of the file print f.read(), f.close() if __name__=="__main__": main() 

पूंछ जैसी सॉल्यूशंस जो केवल आउटपुट के हिस्से को प्रिंट करती हैं

आप किसी अन्य धागा में प्रक्रिया आउटपुट पढ़ सकते हैं और एक पंक्ति में अंतिम पंक्तियों की अपेक्षित संख्या को बचा सकते हैं:

 import collections import subprocess import time import threading def read_output(process, append): for line in iter(process.stdout.readline, ""): append(line) def main(): # start process, redirect stdout process = subprocess.Popen(["top"], stdout=subprocess.PIPE, close_fds=True) try: # save last `number_of_lines` lines of the process output number_of_lines = 200 q = collections.deque(maxlen=number_of_lines) # atomic .append() t = threading.Thread(target=read_output, args=(process, q.append)) t.daemon = True t.start() # time.sleep(2) finally: process.terminate() #NOTE: it doesn't ensure the process termination # print saved lines print ''.join(q) if __name__=="__main__": main() 

इस प्रकार की आवश्यकता है q.append() परमाणु आपरेशन होना। अन्यथा आउटपुट दूषित हो सकता है

signal.alarm() समाधान

आप signal.alarm() का उपयोग कर सकते हैं signal.alarm() को कॉल करने के लिए निर्दिष्ट थ्रेड के बजाय अन्य थ्रेड में हालांकि यह subprocess मॉड्यूल के साथ बहुत अच्छी तरह से बातचीत नहीं कर सकता है। एलेक्स मार्टले के उत्तर के आधार पर:

 import collections import signal import subprocess class Alarm(Exception): pass def alarm_handler(signum, frame): raise Alarm def main(): # start process, redirect stdout process = subprocess.Popen(["top"], stdout=subprocess.PIPE, close_fds=True) # set signal handler signal.signal(signal.SIGALRM, alarm_handler) signal.alarm(2) # produce SIGALRM in 2 seconds try: # save last `number_of_lines` lines of the process output number_of_lines = 200 q = collections.deque(maxlen=number_of_lines) for line in iter(process.stdout.readline, ""): q.append(line) signal.alarm(0) # cancel alarm except Alarm: process.terminate() finally: # print saved lines print ''.join(q) if __name__=="__main__": main() 

यह दृष्टिकोण केवल * निक्स सिस्टम पर काम करता है अगर process.stdout.readline() वापस नहीं आती है तो यह ब्लॉक कर सकता है।

threading.Timer समाधान

 import collections import subprocess import threading def main(): # start process, redirect stdout process = subprocess.Popen(["top"], stdout=subprocess.PIPE, close_fds=True) # terminate process in timeout seconds timeout = 2 # seconds timer = threading.Timer(timeout, process.terminate) timer.start() # save last `number_of_lines` lines of the process output number_of_lines = 200 q = collections.deque(process.stdout, maxlen=number_of_lines) timer.cancel() # print saved lines print ''.join(q), if __name__=="__main__": main() 

इस दृष्टिकोण को विंडोज पर भी काम करना चाहिए यहां मैंने एक पुनरावृत्ति के रूप में process.stdout उपयोग किया है; यह एक अतिरिक्त आउटपुट बफरिंग पेश कर सकता है, यदि आप वांछनीय नहीं हैं, तो आप iter(process.stdout.readline, "") दृष्टिकोण पर स्विच कर सकते हैं। अगर प्रक्रिया process.terminate() पर समाप्त नहीं होती है तो स्क्रिप्ट लटकाए जाते हैं।

कोई धागे नहीं, कोई संकेत समाधान नहीं

 import collections import subprocess import sys import time def main(): args = sys.argv[1:] if not args: args = ['top'] # start process, redirect stdout process = subprocess.Popen(args, stdout=subprocess.PIPE, close_fds=True) # save last `number_of_lines` lines of the process output number_of_lines = 200 q = collections.deque(maxlen=number_of_lines) timeout = 2 # seconds now = start = time.time() while (now - start) < timeout: line = process.stdout.readline() if not line: break q.append(line) now = time.time() else: # on timeout process.terminate() # print saved lines print ''.join(q), if __name__=="__main__": main() 

इस प्रकार का उपयोग न तो थ्रेड्स, कोई संकेत नहीं है लेकिन यह टर्मिनल में विकृत आउटपुट का उत्पादन करता है। यह process.stdout.readline() ब्लॉक करेगा अगर process.stdout.readline() ब्लॉकों

"शीर्ष" का उपयोग करने के बजाय मैं "पीएस" का उपयोग करने का सुझाव देता हूं जो आपको समान जानकारी देगा, लेकिन हमेशा की बजाय एक बार एक बार दूसरे अनंत काल के लिए

आपको ps के साथ कुछ झंडे भी उपयोग करने की आवश्यकता होगी, मैं "ps aux"

इस दृष्टिकोण के बजाय मैं क्या करूँगा, इस कार्यक्रम की जांच करनी है जिसे आप से जानकारी प्राप्त करने और उस जानकारी का अंतिम स्रोत निर्धारित करने का प्रयास कर रहे हैं। यह एक एपीआई कॉल या डिवाइस नोड हो सकता है फिर, कुछ अजगर लिखें जो इसे एक ही स्रोत से प्राप्त हो। इससे समस्याएं और "स्क्रैपिंग" "पकाए गए" डेटा के ओवरहेड को समाप्त होता है

(जेएफ सेबस्टियन आपके कोड महान काम करते हैं, मुझे लगता है कि यह मेरे समाधान से बेहतर है =))

मैंने इसे एक और तरीके से हल किया है।

सीधे टर्मिनल पर आउटपुट बनाने की बजाय मैं इसे "tmp_file" फ़ाइल में बना देता हूं:

 top >> tmp_file 

तो मैंने अपने आउटपुट को "कट ऑफ" टूल का इस्तेमाल किया है, जो कि प्रोसेस के मान के रूप में "शीर्ष आउटपुट" है

 cat tmp_file 

और ऐसा किया जो मैं करना चाहता हूं। यह अंतिम कोड है:

 import os import subprocess import time subprocess.Popen("top >> tmp_file",shell = True) time.sleep(1) os.popen("killall top") process = os.popen("cat tmp_file").read() os.popen("rm tmp_file") print process # Thing better than nothing =) 

मदद के लिए बहुत सारे लोग धन्यवाद

तथ्यों में, यदि आप आउटपुट बफर भरते हैं, तो आप कुछ उत्तर समाप्त कर देंगे इसलिए एक समाधान बफर को बड़े कचरा उत्पादन के साथ भरना है (~ 6000 वर्ण bufsize = 1 के साथ)

मान लीजिए, शीर्ष के बजाय, आपके पास एक अजगर स्क्रिप्ट है जो sys.stdout पर लिखते हैं:

 GARBAGE='.\n' sys.stdout.write(valuable_output) sys.stdout.write(GARBAGE*3000) 

सरल प्रक्रिया के बजाय लांचर की तरफ। रीडलाइन ():

 GARBAGE='.\n' line=process.readline() while line==GARBAGE: line=process.readline() 

काफी यकीन है कि 2000 के रूप में यह थोड़ा गंदे है, यह सबप्रोसेक कार्यान्वयन पर निर्भर है, लेकिन यह ठीक काम करता है और बहुत आसान है। कुछ भी सेट करना लेकिन bufsize = 1 मामले को बदतर बनाते हैं