Ik heb deze code:
def hello():
return 'Hi :)'
Hoe zou ik dit rechtstreeks van de opdrachtregel uitvoeren?
Antwoord 1, Autoriteit 100%
Met de -c(opdracht) Argument (aannemen van uw bestand is de naam foo.py):
$ python -c 'import foo; print foo.hello()'
Als alternatief, als u niet geeft om de vervuiling van Namespace:
$ python -c 'from foo import *; print hello()'
en de middelste grond:
$ python -c 'from foo import hello; print hello()'
Antwoord 2, Autoriteit 21%
Zet gewoon hello()ergens onder de functie en het zal uitvoeren wanneer u python your_file.py
Voor een nateroplossing kunt u dit gebruiken:
if __name__ == '__main__':
hello()
Op die manier wordt de functie alleen uitgevoerd als u het bestand uitvoert, niet wanneer u het bestand importeert.
Antwoord 3, Autoriteit 11%
python -c 'from myfile import hello; hello()'Waar myfilemoet worden vervangen door de basenaam van uw Python-script. (B.v. myfile.pywordt myfile).
Indien hello()is uw “permanente” hoofdinvoerpunt in uw Python-script, dan is de gebruikelijke manier om dit te doen als volgt:
def hello():
print "Hi :)"
if __name__ == "__main__":
hello()
Hierdoor kunt u het script eenvoudig uitvoeren door python myfile.pyof python -m myfileuit te voeren.
Hier wat uitleg: __name__is een speciale Python-variabele die de naam bevat van de module die momenteel wordt uitgevoerd, behalvewanneer de module wordt gestart vanaf de opdrachtregel, in in welk geval het "__main__"wordt.
Antwoord 4, autoriteit 8%
voeg dit fragment onderaan je script toe
def myfunction():
...
if __name__ == '__main__':
globals()[sys.argv[1]]()
U kunt nu uw functie aanroepen door uit te voeren
python myscript.py myfunction
Dit werkt omdat je het commandoregelargument (een tekenreeks van de functienaam) doorgeeft aan locals, een woordenboek met een actuele lokale symbooltabel. De haakjes aan het einde zorgen ervoor dat de functie wordt aangeroepen.
update:als je wilt dat de functie een parameter van de opdrachtregel accepteert, kun je sys.argv[2]als volgt doorgeven:
def myfunction(mystring):
print(mystring)
if __name__ == '__main__':
globals()[sys.argv[1]](sys.argv[2])
Op deze manier zal het uitvoeren van python myscript.py myfunction "hello"helloopleveren.
Antwoord 5, autoriteit 4%
Ik heb een snel klein Python-script geschreven dat kan worden aangeroepen vanaf een bash-opdrachtregel. Het heeft de naam van de module, klasse en methode die u wilt aanroepen en de parameters die u wilt doorgeven. Ik noem het PyRun en liet de .py-extensie achterwege en maakte het uitvoerbaar met chmod +x PyRun zodat ik het snel als volgt kan noemen:
./PyRun PyTest.ClassName.Method1 Param1
Sla dit op in een bestand genaamd PyRun
#!/usr/bin/env python
#make executable in bash chmod +x PyRun
import sys
import inspect
import importlib
import os
if __name__ == "__main__":
cmd_folder = os.path.realpath(os.path.abspath(os.path.split(inspect.getfile( inspect.currentframe() ))[0]))
if cmd_folder not in sys.path:
sys.path.insert(0, cmd_folder)
# get the second argument from the command line
methodname = sys.argv[1]
# split this into module, class and function name
modulename, classname, funcname = methodname.split(".")
# get pointers to the objects based on the string names
themodule = importlib.import_module(modulename)
theclass = getattr(themodule, classname)
thefunc = getattr(theclass, funcname)
# pass all the parameters from the third until the end of
# what the function needs & ignore the rest
args = inspect.getargspec(thefunc)
z = len(args[0]) + 2
params=sys.argv[2:z]
thefunc(*params)
Hier is een voorbeeldmodule om te laten zien hoe het werkt. Dit wordt opgeslagen in een bestand genaamd PyTest.py:
class SomeClass:
@staticmethod
def First():
print "First"
@staticmethod
def Second(x):
print(x)
# for x1 in x:
# print x1
@staticmethod
def Third(x, y):
print x
print y
class OtherClass:
@staticmethod
def Uno():
print("Uno")
Probeer deze voorbeelden uit te voeren:
./PyRun PyTest.SomeClass.First
./PyRun PyTest.SomeClass.Second Hello
./PyRun PyTest.SomeClass.Third Hello World
./PyRun PyTest.OtherClass.Uno
./PyRun PyTest.SomeClass.Second "Hello"
./PyRun PyTest.SomeClass.Second \(Hello, World\)
Let op het laatste voorbeeld van het escapen van de haakjes om een tuple door te geven als de enige parameter voor de tweede methode.
Als je te weinig parameters doorgeeft voor wat de methode nodig heeft, krijg je een foutmelding. Als je te veel passeert, negeert het de extra’s. De module moet in de huidige werkmap staan, PyRun kan overal op je pad staan.
Antwoord 6
Laten we het onszelf een beetje makkelijker maken en gewoon een module gebruiken…
Probeer: pip install compago
Schrijf dan:
import compago
app = compago.Application()
@app.command
def hello():
print "hi there!"
@app.command
def goodbye():
print "see ya later."
if __name__ == "__main__":
app.run()
Gebruik dan zo:
$ python test.py hello
hi there!
$ python test.py goodbye
see ya later.
Opmerking: er is momenteel een bugin Python 3, maar deze werkt prima met Python 2.
Bewerken:een nog betere optie is naar mijn mening de module firedoor Google, wat het gemakkelijk maakt om ook functieargumenten door te geven. Het wordt geïnstalleerd met pip install fire. Van hun GitHub:
Hier is een eenvoudig voorbeeld.
import fire
class Calculator(object):
"""A simple calculator class."""
def double(self, number):
return 2 * number
if __name__ == '__main__':
fire.Fire(Calculator)
Vervolgens kunt u vanaf de opdrachtregel uitvoeren:
python calculator.py double 10 # 20
python calculator.py double --number=15 # 30
Antwoord 7
Interessant genoeg, als het doel was om af te drukken naar de opdrachtregelconsole of een andere kleine python-bewerking uit te voeren, kun je invoer als volgt naar de python-interpreter sturen:
echo print("hi:)") | python
evenals pijpbestanden..
python < foo.py
*Merk op dat de extensie niet .py hoeft te zijn om de tweede te laten werken.
**Houd er ook rekening mee dat je voor bash mogelijk moet ontsnappen aan de karakters
echo print\(\"hi:\)\"\) | python
Antwoord 8
Als u het runp-pakket installeert met pip install runpis het een kwestie van uitvoeren:
runp myfile.py hello
Je kunt de repository vinden op: https://github.com/vascop/runp
Antwoord 9
Ik moest verschillende python-hulpprogramma’s (bereik, tekenreeks, enz.) op de opdrachtregel gebruiken en had de tool pyfuncspeciaal daarvoor. U kunt het gebruiken om uw ervaring met het gebruik van de opdrachtregel te verrijken:
$ pyfunc -m range -a 1 7 2
1
3
5
$ pyfunc -m string.upper -a test
TEST
$ pyfunc -m string.replace -a 'analyze what' 'what' 'this'
analyze this
Antwoord 10
We kunnen zoiets schrijven. Ik heb gebruikt met python-3.7.x
import sys
def print_fn():
print("Hi")
def sum_fn(a, b):
print(a + b)
if __name__ == "__main__":
args = sys.argv
# args[0] = current file
# args[1] = function name
# args[2:] = function args : (*unpacked)
globals()[args[1]](*args[2:])
python demo.py print_fn
python demo.py sum_fn 5 8
Antwoord 11
Het is altijd een optie om Python in te voeren op de opdrachtregel met de opdracht Python
Importeer vervolgens uw bestand, dus Import Example_File
Voer vervolgens de opdracht uit met example_file.hello ()
Dit vermijdt de rare .pyc-kopieerfunctie die gewassen elke keer dat u Python -C -C-enz. Wordt.
Misschien niet zo handig als een enkele opdracht, maar een goede snelle oplossing om een bestand van de opdrachtregel te sms’en en kunt u Python gebruiken om te bellen en uw bestand uit te voeren.
Antwoord 12
zoiets:
call_from_terminal.py
# call_from_terminal.py
# Ex to run from terminal
# ip='"hi"'
# python -c "import call_from_terminal as cft; cft.test_term_fun(${ip})"
# or
# fun_name='call_from_terminal'
# python -c "import ${fun_name} as cft; cft.test_term_fun(${ip})"
def test_term_fun(ip):
print ip
Dit werkt in bash.
$ ip='"hi"' ; fun_name='call_from_terminal'
$ python -c "import ${fun_name} as cft; cft.test_term_fun(${ip})"
hi
Antwoord 13
Hieronder staat het oneven_even_function.py-bestand met de definitie van de functie.
def OE(n):
for a in range(n):
if a % 2 == 0:
print(a)
else:
print(a, "ODD")
Om nu hetzelfde te bellen vanaf de opdrachtprompt hieronder, zijn de opties die voor mij werkten.
Opties 1
Volledig pad van de exe\python.exe -c
“import Odd_Even_function; Odd_Even_function.OE(100)”
Optie 2
Volledig pad van de exe\python.exe -c
“van Odd_Even_function import OE; OE(100)”
Bedankt.
Antwoord 14
Deze functie kan niet worden uitgevoerd vanaf de opdrachtregel, omdat deze een waarde retourneert die niet wordt gebruikt. U kunt de retourzending verwijderen en in plaats daarvan afdrukken gebruiken
Antwoord 15
Gebruik de python-ctool (pip install python-c) en schrijf dan gewoon:
$ python-c foo 'hello()'
of als je geen functienaam clashes hebt in je python-bestanden:
$ python-c 'hello()'
Antwoord 16
Eerst moet je de functie aanroepen zoals ze je vertelden, anders geeft de functie niets weer in de uitvoer, sla daarna het bestand op en kopieer het pad van het bestand door met de rechtermuisknop op de map van het bestand te klikken en op “kopiëren” te klikken. bestand” ga dan naar terminal en schrijf:
– cd “het pad van het bestand”
– python “naam van het bestand bijvoorbeeld (main.py)”
daarna wordt de uitvoer van uw code weergegeven.
Antwoord 17
Maak uw leven gemakkelijker, installeer Spyder. Open uw bestand en voer het uit (klik op de groene pijl). Daarna is uw hello()-methode gedefinieerd en bekend bij de IPython-console, zodat u deze vanuit de console kunt aanroepen.