पायथन में, क्या मैं एक आयातित मॉड्यूल के मुख्य () को कॉल कर सकता हूं?

Question 1

पायथन में मेरे पास एक मॉड्यूल myModule.py है जहां मैं कुछ फ़ंक्शन और एक मुख्य () को परिभाषित करता हूं , जो कुछ कमांड कमांड तर्क लेता है।

मैं आमतौर पर एक बैश स्क्रिप्ट से इस मुख्य () को कॉल करता हूं। अब, मैं सब कुछ एक छोटे पैकेज में रखना चाहूंगा , इसलिए मैंने सोचा कि शायद मैं अपनी साधारण बैश स्क्रिप्ट को पायथन स्क्रिप्ट में बदल सकता हूं और इसे पैकेज में डाल सकता हूं।

तो, कैसे मैं वास्तव में है मुख्य () फोन myModule.py का कार्य मुख्य () फ़ंक्शन से MyFormerBashScript.py की? क्या मैं भी ऐसा कर सकता हूं? मैं इसके लिए कोई तर्क कैसे पारित करूं ?

Question 2

यह सिर्फ एक समारोह है। इसे आयात करें और इसे कॉल करें:

import myModule

myModule.main()

यदि आपको तर्कों को पार्स करने की आवश्यकता है, तो आपके पास दो विकल्प हैं:

उन्हें पार्स करें main(), लेकिन sys.argvएक पैरामीटर के रूप में पास करें (सभी कोड नीचे एक ही मॉड्यूल में myModule):
```
def main(args):
    # parse arguments using optparse or argparse or what have you

if __name__ == '__main__':
    import sys
    main(sys.argv[1:])
```
अब आप myModule.main(['arg1', 'arg2', 'arg3'])दूसरे मॉड्यूल से आयात और कॉल कर सकते हैं ।
उन main()मापदंडों को स्वीकार करें जो पहले से ही पार्स हैं (फिर से myModuleमॉड्यूल में सभी कोड ):
```
def main(foo, bar, baz='spam'):
    # run with already parsed arguments

if __name__ == '__main__':
    import sys
    # parse sys.argv[1:] using optparse or argparse or what have you
    main(foovalue, barvalue, **dictofoptions)
```
और आयात और कॉल myModule.main(foovalue, barvalue, baz='ham')कहीं और जरूरत के अनुसार अजगर तर्कों में गुजर रहा है।

यहां ट्रिक यह पता लगाना है कि आपके मॉड्यूल को स्क्रिप्ट के रूप में कब इस्तेमाल किया जा रहा है; जब आप एक अजगर फ़ाइल को मुख्य स्क्रिप्ट के रूप में चलाते हैं ( python filename.py) कोई importकथन का उपयोग नहीं किया जा रहा है, तो अजगर उस मॉड्यूल को कॉल करता है "__main__"। लेकिन अगर उसी filename.pyकोड को एक मॉड्यूल ( import filename) के रूप में माना जाता है , तो अजगर उस के बजाय मॉड्यूल नाम के रूप में उपयोग करता है। दोनों मामलों में चर __name__सेट है, और इसके खिलाफ परीक्षण आपको बताता है कि आपका कोड कैसे चलाया गया था।

Question 3

मार्टिज़न का जवाब समझ में आता है, लेकिन यह कुछ महत्वपूर्ण याद आ रहा था जो दूसरों के लिए स्पष्ट लग सकता है लेकिन मेरे लिए यह पता लगाना कठिन था।

उस संस्करण में जहां आप argparse का उपयोग करते हैं, आपको मुख्य बॉडी में इस लाइन का होना आवश्यक है।

args = parser.parse_args(args)

आम तौर पर जब आप सिर्फ एक स्क्रिप्ट में अर्गपर्स का उपयोग कर रहे होते हैं, जिसे आप लिखते हैं

args = parser.parse_args()

और parse_args कमांड लाइन से तर्क ढूंढते हैं। लेकिन इस मामले में मुख्य फ़ंक्शन के पास कमांड लाइन के तर्कों तक पहुंच नहीं है, इसलिए आपको यह बताना होगा कि तर्क क्या हैं।

यहाँ एक उदाहरण है

import argparse
import sys

def x(x_center, y_center):
    print "X center:", x_center
    print "Y center:", y_center

def main(args):
    parser = argparse.ArgumentParser(description="Do something.")
    parser.add_argument("-x", "--xcenter", type=float, default= 2, required=False)
    parser.add_argument("-y", "--ycenter", type=float, default= 4, required=False)
    args = parser.parse_args(args)
    x(args.xcenter, args.ycenter)

if __name__ == '__main__':
    main(sys.argv[1:])

यह मानते हुए कि आपने mytest.py नाम दिया है इसे चलाने के लिए आप कमांड लाइन से इनमें से कोई भी कर सकते हैं

python ./mytest.py -x 8
python ./mytest.py -x 8 -y 2
python ./mytest.py

जो क्रमशः लौटता है

X center: 8.0
Y center: 4

या

X center: 8.0
Y center: 2.0

या

X center: 2
Y center: 4

या यदि आप एक और अजगर स्क्रिप्ट से भागना चाहते हैं तो आप कर सकते हैं

import mytest
mytest.main(["-x","7","-y","6"])

जो लौटता है

X center: 7.0
Y center: 6.0

Question 4

निर्भर करता है। यदि मुख्य कोड निम्नानुसार संरक्षित है if:

if __name__ == '__main__':
    ...main code...

तब नहीं, आप पायथन को निष्पादित नहीं कर सकते हैं क्योंकि आप स्वचालित चर को प्रभावित नहीं कर सकते हैं __name__।

लेकिन जब सभी कोड किसी फ़ंक्शन में होते हैं, तो हो सकता है। प्रयत्न

import myModule

myModule.main()

यह तब भी काम करता है जब मॉड्यूल खुद की सुरक्षा करता है __all__।

from myModule import *हो सकता है कि mainआपको दिखाई न दे, इसलिए आपको वास्तव में मॉड्यूल को स्वयं आयात करना होगा।

Question 5

मुझे भी इसी तरह की ज़रूरत argparseथी। यह वस्तु parse_argsएक argparse.ArgumentParserवस्तु उदाहरण का कार्य है, जो मूल रूप से डिफ़ॉल्ट रूप से अपने तर्क लेती है sys.args। मार्टिज्न लाइन के बाद के काम के बारे में बताया गया है कि यह स्पष्ट है, इसलिए आप उन तर्कों को बदल सकते हैं जिन्हें आप parse_argsइच्छा के रूप में पास करते हैं ।

def main(args):
    # some stuff
    parser = argparse.ArgumentParser()
    # some other stuff
    parsed_args = parser.parse_args(args)
    # more stuff with the args

if __name__ == '__main__':
    import sys
    main(sys.argv[1:])

कुंजी बिंदु parse_argsकार्य करने के लिए args गुजर रहा है । बाद में, मुख्य का उपयोग करने के लिए, आप सिर्फ मार्टिज़न को बताते हैं।

Question 6

मैं जिस उत्तर की खोज कर रहा था, उसका उत्तर यहाँ दिया गया था: sys.argv के अलावा अन्य आर्ग्स के साथ अजगर argparse का उपयोग कैसे करें?

तो main.pyऔर parse_args()इस तरह से लिखा है, तो पार्स अच्छी तरह से किया जा सकता है

# main.py
import argparse
def parse_args():
    parser = argparse.ArgumentParser(description="")
    parser.add_argument('--input', default='my_input.txt')
    return parser

def main(args):
    print(args.input)

if __name__ == "__main__":
    parser = parse_args()
    args = parser.parse_args()
    main(args)

तब आप किसी अन्य अजगर लिपि में इसके main()साथ तर्कों को कॉल और पार्स कर सकते हैं parser.parse_args(['--input', 'foobar.txt']):

# temp.py
from main import main, parse_args
parser = parse_args()
args = parser.parse_args([]) # note the square bracket
# to overwrite default, use parser.parse_args(['--input', 'foobar.txt'])
print(args) # Namespace(input='my_input.txt')
main(args)

Question 7

मान लें कि आप कमांड लाइन के तर्कों को भी पारित करना चाहते हैं।

import sys
import myModule


def main():
    # this will just pass all of the system arguments as is
    myModule.main(*sys.argv)

    # all the argv but the script name
    myModule.main(*sys.argv[1:])