I wrote the following command but I don't understand it.
from sys import argv
what is argv?
how to use it?
I wrote sycript,a,b=argv
but I am getting the error that need more than one value to unpack.
argv - The list of command line arguments passed to a Python script.
sycript,a,b=argv gives you "ValueError: need more than 1 value to unpack" because you have just run the script as python <script_name.py> without giving the two arguments.
Run the script like this: python <script_name.py> <arg1> <arg2>
For example,
script.py:
from sys import argv
arg,a,b=argv
print(arg,a,b)
run script.py "arg1" "arg2" and output:
script.py arg1 arg2
I think you should run the command by typing
python scriptname a b
By scriptname I mean the name by which you have saved the program code.
I hope this helps..
Related
I don't understand what am I doing wrong. I use gedit to write a simple python script which contains
from sys import argv
script, first, second, third = argv
for i in argv:
print(i)
Then from terminal (Ubuntu) I try to execute the script which gives error message
ValueError: Not enough values (expected 4, got 1)
script, first, second, third = argv unpacks 4 values from argv. This only works if argv has exactly 4 items. argv contains the name of the script followed by parameters to the script. So,
python3 myscript.py arg1 arg2 arg3
would work and script would hold "myscript.py", first would hold "arg1", and etc...
But
python3 myscript.py
would fail with your error because the 3 expected parameters are not there.
I'm trying to send a parameter on jenkins and have the parameter recognized on the a python file.
Is there a command where I could do this on bash:
param = "Hello World"
param -> /usr/green/test.py
Also how does the py file know to grab the parameter?
you can pass parameters from BASH to you python script via using sys egg in the python scripts. then pass on the environment variables in the command .
PyScript
import sys
print 'Number of arguments:', len(sys.argv), 'arguments.'
print 'Argument List:', str(sys.argv)
command in BASH :
$python test.py $BUILD_ID $BUILD_URL
output :
Number of arguments: 2 arguments.
Argument List: ['test.py', '107', 'http://0.0.0.0:8080/artefact/builds/24']
You can access parameters passed to the script this way:
import sys
print sys.argv[1]
~ python test.py 'hello world'
You have to put the script's arguments after the file path separated by spaces, like this:
/usr/green/test.py arg1 arg2 arg3
to pass the value of a bash variable to the script, you have to prefix the variable name with a $ (dollar sign):
param="Hello world"
/usr/green/test.py "$param"
The list of arguments in the python script can be accessed with sys.argv. The first element in the list is the path to the script therefore the second element is the first argument.
Example
/usr/green/test.py (Python 3):
import sys
print(sys.argv[1])
bash input:
param="Hello World"
python3 /usr/green/test.py "$param"
bash output:
Hello World
Note: You have to put the variable name in quotes or Hello and World will be passed as two separate arguments to test.py.
To execute the script without the python command, you can add a #! (shebang) line:
#!/usr/bin/python3
import sys
print(sys.argv[1])
Make the script executable by typing in bash:
chmod +x /usr/green/test.py
One solution would be to print the parameter and process through a pipe with python.
Like:
read.py:
#!/usr/bin/python
import sys
pythonparams = sys.stdin.read()
# do something
then
echo "$param"|./read.py
The error is at script, first, second, third = argv. I would like to understand why I am getting the error and how to fix it.
from sys import argv
script, first, second, third = argv
print("The script is called: ", script)
print("The first variable is: ", first)
print("The second variable is: ", second)
print("The third variable is: ", third)
Run it from the shell like this:
python script.py arg1 arg2 arg3
argv variable contains command line arguments. In your code you expected 4 arguments, but got only 1 (first argument always script name). You could configure arguments in pycharm. Go to Run -> Edit Configurations. Then create a new python configuration. And there you could specify Script parameters field. Or you could run your script from command line as mentioned by dnit13.
You could run it like this: python script.py first, second, third
I think you are running the following command:
python script.py
You are writing a program which is aksing for 4 inputs and you are giving onle one. That's why you are receiving an error. You can use the below command:
python script.py Hello How Are
I'm using similar approach to call python function from my shell script:
python -c 'import foo; print foo.hello()'
But I don't know how in this case I can pass arguments to python script and also is it possible to call function with parameters from command line?
python -c 'import foo, sys; print foo.hello(); print(sys.argv[1])' "This is a test"
or
echo "Wham" | python -c 'print(raw_input(""));'
There's also argparse (py3 link) that could be used to capture arguments, such as the -c which also can be found at sys.argv[0].
A second library do exist but is discuraged, called getopt.getopt.
You don't want to do that in shell script.
Try this. Create a file named "hello.py" and put the following code in the file (assuming you are on unix system):
#!/usr/bin/env python
print "Hello World"
and in your shell script, write something lke this
#!/bin/sh
python hello.py
and you should see Hello World in the terminal.
That's how you should invoke a script in shell/bash.
To the main question: how do you pass arguments?
Take this simple example:
#!/usr/bin/env python
import sys
def hello(name):
print "Hello, " + name
if __name__ == "__main__":
if len(sys.argv) > 1:
hello(sys.argv[1])
else:
raise SystemExit("usage: python hello.py <name>")
We expect the len of the argument to be at least two. Like shell programming, the first one (index 0) is always the file name.
Now modify the shell script to include the second argument (name) and see what happen.
haven't tested my code yet but conceptually that's how you should go about
edit:
If you just have a line or two simple python code, sure, -c works fine and is neat. But if you need more complex logic, please put the code into a module (.py file).
You need to create one .py file.
And after you call it this way :
python file.py argv1 argv2
And after in your file, you have sys.argv list, who give you list of argvs.
I am a newcomer to python (also very sorry if this is a newb question but) i have no idea what a command line argument is. when sys.argv is called, what exactly are the arguments? Any help with understanding this would be a great service.
Try running this program:
import sys
print(sys.argv)
You should see results similar to this:
% test.py
['/home/unutbu/pybin/test.py']
% test.py foo
['/home/unutbu/pybin/test.py', 'foo']
% test.py foo bar
['/home/unutbu/pybin/test.py', 'foo', 'bar']
% python test.py foo
['test.py', 'foo']
So, you see sys.argv is a list. The first item is the path to (or filename of) the script being run, followed by command-line arguments.
Given the command myscript.py arg1 arg2 arg3, the arguments are arg1, arg2 and arg3. sys.argv will also include the script name (i.e. myscript.py) in the first position.
Command line arguments are not specific to python.
Command line arguments are parameters you type after the script name. Eg. if you type: python test.py arg1, the first argument is arg1.
For examples, take a look at jhu.edu.
The command line arguments are the strings you type after a command in the command line, for instance:
python --help
Here --help is the argument for the python command, that shows a help page with the valid command line arguments for the python command.
In a python program, you have access to the arguments in sys.argv, so let's say you started a python script like this:
python myscript.py -x -y
When myscript.py starts, sys.argv[1] will have as value the string '-x' and sys.argv[2] will have as value the string '-y'. What you do with those arguments is up to you, and there are modules to help you easily define command line arguments, for instance argparse.
The arguments are usually used as a way of telling the program what it should do when it is run.
If I had a program named writefile.py, and I wanted the user to tell it which file to write, then I would run it with python writefile.py targetfile.txt. My sample writefile.py:
import sys
file = open(sys.argv[1], 'w') # sys.argv[0] = 'writefile.py' (unutbu's answer)
file.write('ABCDE')
file.close
After running this, I'll have a file named targetfile.txt with the contents "ABCDE". If I ran it with python writefile.py abcde.txt, I'd have abcde.txt with the contents "ABCDE".