This question already has answers here:
When running a python script in IDLE, is there a way to pass in command line arguments (args)?
(12 answers)
Closed 10 years ago.
I have downloaded a python file xxxxxx.py that is supposed to run on the command line by
typing: python xxxxxx.py filename1 filename2
and that should take these two files as arguments.
I was wondering if there is a way I can use IDLE to pass in these arguments. Is there a way other than setting sys.argv ?
Thanks
It depends on the content of your Python file. If it is well-written, like:
#! /usr/bin/env python
def process(files):
for file in files:
# ...
if __name__ == '__main__'
# some error checking on sys.argv
process(sys.argv[1:])
sys.exit(0)
Then you could simply import the python file and run it like:
import name_of_file
# ...
name_of_file.process([file1, file2, file3])
# ...
So, it really depends on how it is written. If it isn't written well but you can edit it, I would refactor it so that it can be used as a library; otherwise, I would use the subprocess module to invoke the program.
You can do this from the command line with:
idle.py -r scriptname.py put arguments here
You can try a different IDE like ActivePython
Or you can patch IDLE:
http://bugs.python.org/issue5680
Related
This question already has answers here:
How do I execute a program or call a system command?
(65 answers)
Closed 1 year ago.
How can i run install.sh file using python code.Purpose is to implement software update functionality.The sh file is generated using makeself and it is a self-extractable archive.I get this output when i use os.system or subprocess.run
Failed to parse arguments: Unknown option -title
NB: The Script file don't require any arguments
subprocess.call (Python <=3.5) and subprocess.run (Python >3.5) would be a safer alternative to os.system.
Solution 1 : Use SubProcess
import subprocess
subprocess.call(['/path/to/your/script.sh', 'argument1', 'argument2', ..., 'argumentn'])
Solution 2 : Use Os
import os
os.system('/path/to/your/script.sh argument1 argument2 ... argumentn'])
Both will work fine, if you have the choice it's better to use subprocess since it will handle for you the formatting of your command with thing such as space in the command line or special characters.
This question already has an answer here:
terminal only running 2.7, even after changing alias
(1 answer)
Closed 1 year ago.
Thank you in advance for the feedback!
I have a simple hello.py file which I am exploring in the Command Line.
When I run the following command:
python hello.py
I get an expected output:
Hello World
But when I run it with the Execute Bit command
chmod +x hello.py
./hello.py
I get the following output:
('Hello', 'World')
I do not get why the second output is enclosed in parentheses and displayed as separately quoted strings. My python version is Python 3.8.5. If it matters my shell is zsh.
Here is the hello.py file:
import sys
# Define a main() function that prints a little greeting.
def main():
# Get the name from the command line, using 'World' as a fallback.
if len(sys.argv) >= 2:
name = sys.argv[1]
else:
name = 'World'
print ('Hello', name)
# This is the standard boilerplate that calls the main() function.
if __name__ == '__main__':
main()
For you to be able to run the script with just its name, the file needs to have a valid shebang line. You are not showing yours, but apparently your script has one, or else the shell would attempt to run it as a shell script. Unfortunately, your shebang is pointing to Python 2, where you would want it to point to Python 3.
On many Linux systems, #!/usr/bin/python (or the morally equivalent but somewhat more flexible #!/usr/bin/env python) will run Python 2, whereas #!/usr/bin/python3 (or #!/usr/bin/env python3) will run Python 3.
Whether python on the command line runs Python 3 is by and large irrelevant; this is probably an interactive alias set up by your shell, but it only works interactively.
This question already has answers here:
Actual meaning of 'shell=True' in subprocess
(7 answers)
Closed 8 months ago.
I would like to run a shell script from Python 3 in Linux passing two arguments that contain file paths to two different files. The shell script then calls a programme written in Python 2.
In Python 3, I call the shell script like this:
import os
import sys
os.chmod('/path/to/sh', 0o777)
subprocess.call(['/path/to/sh', '/path/to/file1', '/path/to/file2'], shell=True)
My shell script looks like this:
#!/bin/sh
set -x
path1=$1
path2=$2
python2 path/to/programme "$path1" "$path2"
Now, the file paths are empty, and the shell script returns something like python2 path/to/programme '' ''. Does someone know how I could correctly pass the file paths so that the programme written in Python 2 can read them?
Or is there even an easier solution such as using subprocess to directly call the programme written in Python 2?
There is no need for the shell script. You can use subprocess to run python2 directly.
a.py
#!/usr/bin/env python3
import subprocess
subprocess.call(['python2', './b.py', 'foo', 'bar'])
b.py
#!/usr/bin/env python2
import sys
print sys.argv
Running ./a.py outputs ['./b.py', 'foo', 'bar'].
You could also try using past.translation instead:
The past module provides an experimental translation package to help with importing and using old Python 2 modules in a Python 3 environment.
shell=True is only needed if you do something like
subprocess.run("/path/to/sh /path/to/file1 /path/to/file2", shell=True)
where the shell will split the single string into arguments that will identify as the program name and its arguments. But you already have the program name and its arguments identified, so
subprocess.run(['/path/to/sh', '/path/to/file1', '/path/to/file2'])
is all you need.
By using a list and shell=True, you are essentially asking Python to execute
sh -c /path/to/sh /path/to/file1 /path/to/file2
which uses /path/to/file1 to set the value of $0, not $1, in the command to execute.
This question already has answers here:
How to read/process command line arguments?
(22 answers)
Closed 2 years ago.
I'm looking to run a bash command that runs a python file ie: "python /Users/declanmcgranahan/airflow/dags/tasks/aircall_calls_to_csv.py". But I have a variable in that python file that I want to define in the bash command. Is this possible?
Do you mean something like python test.py var1 var2?
Take a look at this link: Python - Command Line Arguments
This even provides options function like python test.py -a var1 -b var2
You can pass arguments to the bash command and then read in those arguments into required variables in the __main__ handler function. Look up argparse library on how to use it to handle provided arguments. The code in your python file should have a block:
if __name__ == "__main__":
# use argparse to assign variables
you could pass a parameter to the python script on the command line, or you could set an environment variable in the script and have the script read it using getenv.
Command-line arguments: How to read/process command line arguments?
getenv: https://docs.python.org/3/library/os.html#os.getenv
I am attempting to start the python interpreter by typing python into my terminal. I also want to pass some command line arguments. If I try python arg1 it things I am trying to open and run a script called arg1. So my question is, how can I pass command line arguments to python in the command line interpreter mode?
You already are.
Your arg1 is a command line argument - to the python interpreter.
Maybe you're thinking of a command line option? (which really is just a specific type of command line argument)
Using the -h argument (python -h) will print all such options.
python -Q new, for example, will launch the interpreter with the new float division by default.
On the other hand, if you want to pass command line arguments to your script, you need to specify them after the script name: python my_script.py arg1
If you are on a UNIX based system, you can also use a shebang on your script, which will allow you to simply execute your script by name, skipping python:
#!/usr/bin/env python
#your script here
then run ./my_script.py arg1
An easy way to do it is by using the subprocess module and input variables.
An example would be:
from subprocess import call
x = raw_input('Which command line arguments? ')
call(x, shell=True)
Try it with an ls command (dir for Windows users), it should work.
You can access the command line arguments using sys.argv
import sys
print sys.argv
% python scrpt.py a b c d
outputs: ['scrpt.py', 'a', 'b', 'c', 'd']
Use - to mark the end of python's interpreter options:
python --interpreter-option-1 --interpreter-option-2 - --my-custom-option option-value my-custom-argument