How to run a python function from Windows 10 command prompt in 'python filename.py funcname' format? - python-3.x

I have the following python file, named hello.py:
print('Hello')
def world():
print('Hello World')
If I type the following within the command prompt for windows 10 I get:
In: python hello.py
Out: 'Hello'
In: python hello.py world
Out: 'Hello'
Notice in the second command prompt, 'Hello World' is not an output. Any reason on why my file can't execute the python function when called in the command line but is able to load the file no problem?
Why do I need this?: I need to submit a larger file that has many functions for a project. For this file to be automatically graded I need to be able to call any given function from it using the specific sequence 'python filename.py functionname.'
Update: Some of the answers below do work, but they do not follow the specific sequence of 'python filename.py functionname' required for my project to be graded. I appreciate the insights that everyone has provided so far.

You can run functions directly from the command prompt by using:
python -c 'from hello import world; world()'
You can run the python interpreter as an alternative. cd to your file directory and launch python:
python
and then import the function from your file:
from hello import world
(Launching the python cmd from the same directory as your file.)
Then, you can run:
>>> world()
Hello World

Try this piece of code and type hello.py only:
print('Hello')
def world():
return'Hello World'
world()
##################################################################
def F1():
print('This is the first function.')
if __name__ == '__main__':
F1()
def F2():
print('This is the second function.')
if __name__ == '__main__':
F2()
now you can use form(file_name) import(function_name) create folder(1) with multiple functions in it and you can try to import the desired function into another folder(2) one at a time not all of them all at once by using this.
pardon me for the mistakes if found any feel free to ask further if this does not elaborate.

I found a solution that works for me:
After digging deeper, I realized that windows passes a sys.argv input that contains a string of all the command prompt inputs used to call the file.
In my case of 'python hello.py world', the system would pass ['hello.py','world'] as the argument for sys.argv. By creating a dictionary of callable functions, and then matching the string of the sys.argv with its respective function in the dictionary, I am able to execute the code as desired.
New code:
print('Hello')
def world():
print('Hello World')
import sys
callable_functions = {'world':world}
callable_functions[sys.argv[1]]()
Command prompt input and output now:
In: python hello.py world
Out: 'Hello'
Out: 'Hello World'

Related

how to run the selenium with python script for login using command line

here is my code
def test_login(self):
URL = (sys.argv[0])
Username = (sys.argv[1])
Password = (sys.argv[2])
self.driver.get(URL)
print ("Browser launched")
self.driver.find_element(By.NAME, "username").send_keys(Username)
self.driver.find_element(By.CLASS_NAME, "btn-login-submit").click()
time.sleep(7)
self.driver.find_element(By.NAME, "password").send_keys(Password)
self.driver.find_element(By.CLASS_NAME, "btn-login-submit").click()
time.sleep(10)
print('login successful')
how to run in the vscode terminal
i could not get the proper command line to run in terminal
Try the following:
Copy Paste the code in a .py file say test.py
I do not see the calling of the function (test_login). So call it or remove the function if it is not necessary.
in the VS code terminal, type this command Python3 test.py to execute your python script.

Python 3 does not recognize special characters

This is the app.py file.
#!/usr/bin/python3
import sys
def run():
print(sys.argv)
filename = sys.argv[1]
print(filename)
return
if __name__ == '__main__':
run()
I want to run this code from the command line, so I tried the two following lines each.
python3 app.py input.txt
python3 app.py < input.txt
The first command showed the result I expected, which is ['app.py', 'input.txt']. However the second command just ended up showing ['app.py'].
It seems like the Python code does not recognize the special symbols. How can I make the script recognize them without changing the script itself? i.e. not modifying the command like this: python3 app.py '<' input.txt.
The < character is special and will actually stream the file specified to stdin. You cannot override this behavior as it comes from your shell not python itself. Here is an example of what is really happening, and how you can get the file contents.
import sys
file_contents = sys.stdin.read() # This will read the entire stdin stream into file_contents
This will also work for the | character
echo "Hello, World" | python app.py

Pass arguments to jupyter notebook [duplicate]

I'm wondering if it's possible to populate sys.argv (or some other structure) with command line arguments in a jupyter/ipython notebook, similar to how it's done through a python script.
For instance, if I were to run a python script as follows:
python test.py False
Then sys.argv would contain the argument False. But if I run a jupyter notebook in a similar manner:
jupyter notebook test.ipynb False
Then the command line argument gets lost. Is there any way to access this argument from within the notebook itself?
After a lot of looking around I found very cumbersome, custom libraries, but solved it with a few lines of code which I thought was pretty slick. I used nbconvert to end up with an html report as output that contains all graphics and markdown from the notebook, but accepts command line parameters just as always through a minimal python wrapper:
The python file test_args.py (which takes command line params as normal):
import sys,os
IPYNB_FILENAME = 'test_argv.ipynb'
CONFIG_FILENAME = '.config_ipynb'
def main(argv):
with open(CONFIG_FILENAME,'w') as f:
f.write(' '.join(argv))
os.system('jupyter nbconvert --execute {:s} --to html'.format(IPYNB_FILENAME))
return None
if __name__ == '__main__':
main(sys.argv)
The notebook contains:
import sys,os,argparse
from IPython.display import HTML
CONFIG_FILE = '.config_ipynb'
if os.path.isfile(CONFIG_FILE):
with open(CONFIG_FILE) as f:
sys.argv = f.read().split()
else:
sys.argv = ['test_args.py', 'input_file', '--int_param', '12']
parser = argparse.ArgumentParser()
parser.add_argument("input_file",help="Input image, directory, or npy.")
parser.add_argument("--int_param", type=int, default=4, help="an optional integer parameter.")
args = parser.parse_args()
p = args.int_param
print(args.input_file,p)
and I can run the python notebook with arguments parsed as usual:
python test_args.py my_input_file --int_param 12
I tend to paste the block with argparse calls into the python wrapper so that command line errors are caught by the python script and -h works properly.
There are two projects I've found that do what you ask for
Papermill, will add a cell to your notebook with arguments that you pass to it on the command line. So this is quite straightforward, you define your defaults in the first cell (the should have parameters tag)
nbparameterise it is a similar concept but you don't tag your cell with defaults, it has to be first.
Here is a good resource discussing the issue: https://github.com/jupyter/help/issues/218
If the goal is to run a notebook with configurable arguments passed from commandline, I think the easiest way is to use environment variables, like this:
NB_ARGS=some_args jupyter nbconvert --execute --to html --template full some_notebook.ipynb
Then in the notebook, you can import os and use os.environ['NB_ARGS']. The variable value can be some text that contains key-value pairs or json for example.
At the top of the Jupyter cell, put a line like:
%%python - --option1 value1 --option2 value2 --etc
In your example:
%%python - True
This will run your script like in a command line with the args provided.
Example:
%%python - --option1 value1 --option2 value2 --etc
import sys
if __name__ == '__main__':
print(sys.argv)
will output:
['-', '--option1', 'value1', '--option2', 'value2', '--etc']
Hope it helps.
I think this Gist may help you : https://gist.github.com/gbishop/acf40b86a9bca2d571fa
This is an attempt at a simple argument parser for mostly key=value pairs that can be used both on the command line and in IPython notebooks. It support query parameters in notebook URLs and a Run command for notebooks.
Using args = parser.parse_args(args=[]) would work.
or for testing, you can declare it as class format.
class Args:
data = './data/penn'
model = 'LSTM'
emsize = 200
nhid = 200
args=Args()
sys.argv yields a list, so I used
sys.argv.append('hello')
in a jupyter notebook, which allowed me to append extra members and pretend like I'm passing in arguments from the command line.
I tried out the answers listed above, and came up with a different solution.
My original code was
ap = argparse.ArgumentParser()
ap.add_argument("-i", "--image", required=True, help="path to input image")
ap.add_argument("-y", "--yolo", required=True, help="base path to YOLO directory")
ap.add_argument("-c", "--confidence", type=float, default=0.5, help="minimum probability to filter weak detections")
ap.add_argument("-t", "--threshold", type=float, default=0.3, help="threshold when applying non-maxima suppression")
args = vars(ap.parse_args())
I tried to make a Class as
Class Args():
image='photo.jpg'
yolo='yolo-coco'
confidence=0.5
threshold=0.3
args=Args()
but futher code snippets were producing an error.
So I printed args after vars(ap.parse_args()) and found that it was a dictionary.
So just create a dictionary for the original args:
args={"image": 'photo.jpg', "yolo": 'yolo-coco', "confidence": 0.5,"threshold": 0.3}
A workaround is to make the jupyter notebook read the arguments from a file.
From the command line, modify the file and run the notebook.
I assume that you just want to parse some arguments to the notebooks, but it's not necessary to use the command line.
If you want to parse commands like.
python script.py --a A --b B
You can use the following code in the notebook:
cmd = '--a A --b B'
args = args = parser.parse_args(cmd)
For parse_args, you can find more information here.
A simple and naïve solution is to put the following snippet at the first line of your program:
import sys
sys.argv = "your expected command line arguments here".split()
After executing this command, packages like argparse will work well.
So, you can just run your scripts in the jupyter lab server, without opening a terminal and typing your arguments.

Why does QtWidgets.QApplication require sys.argv?

Hello guys i am learning pyqt5 from a series of tutorials at youtube and i didn't get why QtWidgets.QApplication have the argument sys.argv i am not familiar with sys library i read the documentation but still have no clue so sorry i know this question is kind of a noobish.
import sys
from PyQt5 import QtWidgets
def window():
app = QtWidgets.QApplication(sys.argv)
w=QtWidgets.QWidget()
w.show()
sys.exit(app.exec_())
window()
From the docs:
sys.argv
The list of command line arguments passed to a Python script. argv[0] is the script name (it is operating system dependent whether this is a full pathname or not). If the command was executed using the -c command line option to the interpreter, argv[0] is set to the string '-c'. If no script name was passed to the Python interpreter, argv[0] is the empty string.
To loop over the standard input, or the list of files given on the command line, see the fileinput module.
Example:
python foo.py
sys.argv = ['foo.py']
python foo.py bar baz
sys.argv = ['foo.py', 'bar', 'baz']
For your specific question, see this link: Why do I need "sys.argv" to start a QApplication in PyQt?
Basically, a QT application can take initialization arguments from the command line, the top answer should point you to a list of them with an explanation of what they do.

Can i access the variables of the python script after run that python script with console?

I run the python script using terminal command
python3 myScript.py
It's simply run my program but if i want to open python console after complete run of my script so that i can access my script's variables.
So, What should i do ? and How can i get my script's variables after run the code using terminal ?
Open a python terminal (type 'python' in cmd);
Paste this (replace 'myScript.py' with your script filename):
def run():
t = ""
with open('myScript.py') as f:
t = f.read()
return t
Type exec(run()). Now you will have access to the variables defined in myScript.py.
I needed to do this so I could explore the result of a request from the requests library, without having to paste the code to make the requests every time.
Make the program run the other program you want with the variables as arguments. For example:
#program1
var1=7
var2="hi"
import os
os.system("python %s %d %s" % (filename, var1, var2))
#program2
import sys
#do something such as:
print(sys.argv[1]) #for var1
print(sys.argv[2]) #for var2
Basically, you are running program2 with arguments that can be referenced later.
Hope this helps :)

Resources