पाइथन में बैश बैकटिक्स के बराबर [डुप्लिकेट]

Question 1

पाइथन में रूबी और पर्ल में पाए जाने वाले बैकटिक्स के बराबर क्या है? यही है, रूबी में मैं यह कर सकता हूं:

foo = `cat /tmp/baz`

पायथन में समतुल्य कथन कैसा दिखता है? मैंने कोशिश की है, os.system("cat /tmp/baz")लेकिन यह परिणाम को मानक के बाहर रखता है और मुझे उस ऑपरेशन के त्रुटि कोड पर लौटाता है।

Question 2

output = os.popen('cat /tmp/baz').read()

Question 3

subprocessमॉड्यूल का उपयोग करने के लिए सबसे लचीला तरीका है :

import subprocess

out = subprocess.run(["cat", "/tmp/baz"], capture_output=True)
print("program output:", out)

capture_outputपायथन 3.7 में पेश किया गया था, पुराने संस्करणों के लिए check_output()इसके बजाय विशेष फ़ंक्शन का उपयोग किया जा सकता है:

out = subprocess.check_output(["cat", "/tmp/baz"])

यदि आप ठीक दानेदार नियंत्रण की आवश्यकता है, तो आप मैन्युअल रूप से एक उपप्रकार वस्तु का निर्माण भी कर सकते हैं:

proc = subprocess.Popen(["cat", "/tmp/baz"], stdout=subprocess.PIPE)
(out, err) = proc.communicate()

ये सभी फ़ंक्शन कीवर्ड मापदंडों को अनुकूलित करने के लिए समर्थन करते हैं कि कैसे सबप्रोसेस निष्पादित किया गया है। आप उदाहरण के लिए shell=Trueशेल के माध्यम से प्रोग्राम को निष्पादित करने के लिए उपयोग कर सकते हैं , यदि आपको फ़ाइल नाम विस्तार जैसी चीजों की आवश्यकता है *, लेकिन यह सीमाएं आती हैं ।

Question 4

sth सही है । आप os.popen () का उपयोग भी कर सकते हैं, लेकिन जहां उपलब्ध (पायथन 2.4+) उपप्रकार आमतौर पर बेहतर होता है।

हालांकि, कुछ भाषाओं के विपरीत, जो इसे प्रोत्साहित करती हैं, यह आमतौर पर एक उपप्रकार को फैलाने के लिए बुरा रूप माना जाता है जहां आप भाषा के अंदर एक ही काम कर सकते हैं। यह धीमा, कम विश्वसनीय और प्लेटफ़ॉर्म-निर्भर है। आपका उदाहरण बेहतर होगा:

foo= open('/tmp/baz').read()

ईटा:

baz एक निर्देशिका है और मैं उस निर्देशिका की सभी फ़ाइलों की सामग्री प्राप्त करने का प्रयास कर रहा हूं

? एक निर्देशिका पर बिल्ली मुझे एक त्रुटि मिलती है।

यदि आप फ़ाइलों की सूची चाहते हैं:

import os
foo= os.listdir('/tmp/baz')

यदि आप एक निर्देशिका में सभी फ़ाइलों की सामग्री चाहते हैं, तो कुछ इस तरह है:

contents= []
for leaf in os.listdir('/tmp/baz'):
    path= os.path.join('/tmp/baz', leaf)
    if os.path.isfile(path):
        contents.append(open(path, 'rb').read())
foo= ''.join(contents)

या, यदि आप सुनिश्चित कर सकते हैं कि वहां कोई निर्देशिका नहीं है, तो आप इसे एक-लाइनर में फिट कर सकते हैं:

path= '/tmp/baz'
foo= ''.join(open(os.path.join(path, child), 'rb').read() for child in os.listdir(path))

Question 5

foo = subprocess.check_output(["cat", "/tmp/baz"])

Question 6

पायथन 3.5 आगे से, अनुशंसित तरीका उपयोग करना है subprocess.run। पायथॉन 3.7 के बाद से, जैसा आप वर्णन करते हैं, वैसा ही व्यवहार पाने के लिए, आप उपयोग करेंगे:

cpe = subprocess.run("ls", shell=True, capture_output=True)

इससे कोई subprocess.CompletedProcessवस्तु वापस आ जाएगी । स्टडआउट के लिए आउटपुट में होगा cpe.stdout, स्टडर के लिए आउटपुट में होगा cpe.stderr, जो दोनों bytesऑब्जेक्ट होंगे। आप किसी strऑब्जेक्ट को प्राप्त करने के लिए आउटपुट को डिकोड कर सकते हैं cpe.stdout.decode()या पास होने text=Trueसे प्राप्त कर सकते हैं subprocess.run:

cpe = subprocess.run("ls", shell=True, capture_output=True, text=True)

बाद के मामले में, cpe.stdoutऔर cpe.stderrदोनों strवस्तुएं हैं।

Question 7

सबसे आसान तरीका कमांड पैकेज का उपयोग करना है।

import commands

commands.getoutput("whoami")

आउटपुट:

'Bganesan'

Question 8

import os
foo = os.popen('cat /tmp/baz', 'r').read()

Question 9

मैं उपयोग कर रहा हूँ

(६: ०) $ अजगर - विसर्जन पायथन २. 0.१

उपरोक्त उदाहरणों में से एक है:

import subprocess
proc = subprocess.Popen(["cat", "/tmp/baz"], stdout=subprocess.PIPE, shell=True)
(out, err) = proc.communicate()
print "program output:", out

मेरे लिए, यह निर्देशिका / tmp तक पहुँचने में विफल रहा। उपप्रकार के लिए डॉक्टर स्ट्रिंग को देखने के बाद मैंने प्रतिस्थापित किया

["प्रोग", "अर्ग"]

साथ में

"प्रोग आर्ग"

और खोल विस्तार का व्यवहार मिला जो वांछित था (एक ला पर्ल का `ठेला arg`)

प्रिंट सबप्रोसेस। पोपेन ("ls -ld / tmp / v *", stdout = subprocess.PIPE, शेल = ट्रू) .communicate () [0]।

मैंने थोड़ी देर पहले अजगर का उपयोग करना छोड़ दिया क्योंकि मैं perl `cmd ...` के बराबर करने की कठिनाई से नाराज था। मुझे खुशी है कि पायथन ने इसे उचित बनाया है।

Question 10

यदि आप उपप्रोसेस का उपयोग करते हैं। तो, bufsize निर्दिष्ट करना याद रखें। डिफ़ॉल्ट 0 है, जिसका अर्थ है "असंबद्ध", न कि "एक उचित डिफ़ॉल्ट चुनें"।

Question 11

यह python3 में काम नहीं करेगा, लेकिन python2 में आप strएक कस्टम __repr__विधि के साथ विस्तार कर सकते हैं जो आपके शेल कमांड को कॉल करता है और इसे इस तरह लौटाता है:

#!/usr/bin/env python

import os

class Command(str):
    """Call system commands"""

    def __repr__(cmd):
        return os.popen(cmd).read()

जिसे आप पसंद कर सकते हैं

#!/usr/bin/env python
from command import Command

who_i_am = `Command('whoami')`

# Or predeclare your shell command strings
whoami = Command('whoami')
who_i_am = `whoami`

Question 12

`repr()`

backtick( `) ऑपरेटर हटा दिया गया था में Python 3। यह एक एकल उद्धरण के समान भ्रामक है, और कुछ कीबोर्ड पर टाइप करना कठिन है। इसके बजाय backtick, समान अंतर्निहित फ़ंक्शन का उपयोग करें repr()।