In Python, posso chiamare main () di un modulo importato?

In Python ho un modulo myModule.py in cui definisco alcune funzioni e un main () , che accetta alcuni argomenti della riga di comando.

Di solito chiamo this main () da uno script bash. Ora, vorrei mettere tutto in un piccolo pacchetto , quindi ho pensato che forse avrei potuto trasformare il mio semplice script bash in uno script Python e inserirlo nel pacchetto.

Quindi, come posso effettivamente chiamare la funzione main () di myModule.py dalla funzione main () di MyFormerBashScript.py? Posso anche farlo? Come posso passare gli argomenti ad esso?

È solo una funzione. Importalo e chiamalo:

import myModule

myModule.main()

Se devi analizzare gli argomenti, hai due opzioni:

• Analizzali main(), ma passa sys.argvcome parametro (tutto il codice di seguito nello stesso modulo myModule):

  def main(args):
      # parse arguments using optparse or argparse or what have you
  
  if __name__ == '__main__':
      import sys
      main(sys.argv[1:])
  

  Ora puoi importare e chiamare myModule.main(['arg1', 'arg2', 'arg3'])da un altro un altro modulo.

• Avere main()accettare parametri che sono già analizzati (ancora una volta tutto il codice nel myModulemodulo):

  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)
  

  e importare e chiamare myModule.main(foovalue, barvalue, baz='ham')altrove e passare gli argomenti python secondo necessità.

Il trucco qui è rilevare quando il modulo viene utilizzato come script; quando esegui un file python come script principale ( python filename.py) non importviene utilizzata alcuna istruzione, quindi python chiama quel modulo "__main__". Ma se lo stesso filename.pycodice viene trattato come module ( import filename), allora python lo usa come nome del modulo. In entrambi i casi la variabile __name__è impostata e il test rispetto a quella ti dice come è stato eseguito il tuo codice.

La risposta di Martijen ha senso, ma mancava qualcosa di cruciale che potrebbe sembrare ovvio agli altri ma che per me era difficile da capire.

Nella versione in cui usi argparse, devi avere questa riga nel corpo principale.

args = parser.parse_args(args)

Normalmente, quando si utilizza argparse solo in uno script, è sufficiente scrivere

args = parser.parse_args()

e parse_args trova gli argomenti dalla riga di comando. Ma in questo caso la funzione main non ha accesso agli argomenti della riga di comando, quindi devi dire ad argparse quali sono gli argomenti.

Ecco un esempio

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:])

Supponendo che tu abbia chiamato questo mytest.py Per eseguirlo puoi fare uno di questi dalla riga di comando

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

che ritorna rispettivamente

X center: 8.0
Y center: 4

o

X center: 8.0
Y center: 2.0

o

X center: 2
Y center: 4

O se vuoi eseguire da un altro script Python puoi farlo

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

che ritorna

X center: 7.0
Y center: 6.0

Dipende. Se il codice principale è protetto da un ifcome in:

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

allora no, non puoi fare in modo che Python lo esegua perché non puoi influenzare la variabile automatica __name__.

Ma quando tutto il codice è in una funzione, allora potrebbe essere in grado di farlo. Provare

import myModule

myModule.main()

Funziona anche quando il modulo si protegge con un file __all__.

from myModule import *potrebbe non essere mainvisibile a te, quindi devi davvero importare il modulo stesso.

Ho avuto la stessa esigenza di utilizzo argparseanche. Il problema è che la parse_argsfunzione di argparse.ArgumentParserun'istanza di un oggetto prende implicitamente i suoi argomenti per impostazione predefinita da sys.args. Il lavoro, seguendo la linea di Martijn, consiste nel renderlo esplicito, in modo da poter cambiare gli argomenti a cui si passa parse_argscome desiderato.

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:])

Il punto chiave è passare gli argomenti alla parse_argsfunzione. Più tardi, per usare il principale, fai come dice Martijn.

La risposta che stavo cercando è stata risolta qui: Come usare python argparse con args diversi da sys.argv?

Se main.pye parse_args()è scritto in questo modo, l'analisi può essere eseguita correttamente

# 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)

Quindi puoi chiamare main()e analizzare argomenti con parser.parse_args(['--input', 'foobar.txt'])esso in un altro script python:

# 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)

Supponendo che tu stia tentando di passare anche gli argomenti della riga di comando.

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:])