Python - Script Mode

In order to see output from a Python script, we'll introduce the print statement. This statement takes a list of values and prints their string representation on the standard output file. The standard output is typically directed to the Terminal window. We'll revisit this in depth in The print Statement.

print "PI = ", 355.0/113.0

We can have the Python interpreter execute our script files. Application program scripts can be of any size or complexity. For the following examples, we'll create a simple, two-line script, called example1.py.

Example 3.1. example1.py

print 65, "F"
print ( 65 - 32 ) * 5 / 9, "C"

There are several ways we can start the Python interpreter and have it evaluate our script file.

Explicitly from the command line. In this case we'll be running Python and providing the name of the script as an argument.
Implicitly from the command line. In this case, we'll either use the GNU/Linux shell comment (sharp-bang marker) or we'll depend on the file association in Windows.
Manually from within IDLE. It's important for newbies to remember that IDLE shouldn't be part of the final delivery of a working application. However, this is a great way to start development of an application program.

Running Python scripts from the command-line applies to all operating systems. It is the core of delivering final applications. We may add an icon for launching the application, but under the hood, an application program is essentially a command-line start of the Python interpreter.

Explicit Command Line

The simplest way to execute a script is to provide the script file name as a parameter to the python interpreter. In this style, we explicitly name both the interpreter and the input script. Here's an example.

Example 3.2. Command Line Execution

python example1.py

This will provide the example1.py file to the Python interpreter for execution.

Implicit Command-Line Execution

We can streamline the command that starts our application. For POSIX-standard operating systems (GNU/Linux, UNIX and MacOS), we make the script file itself executable and directing the shell to locate the Python interpreter for us. For Windows users, we associate our script file with the python.exe interpreter. There are one or two steps to this.

Associate your file with the Python interpreter. Except for Windows, you make sure the first line is the following: #!/usr/bin/env python. For Windows, you must assure that .py files are associated with python.exe and .pyw files are associated with pythonw.exe.

The whole file will look like this:
```
#!/usr/bin/env python
print 65, "F"
print ( 65 - 32 ) * 5 / 9, "C"
```
For POSIX-standard operating systems, do a chmod +x example1.py to make the file example1.py executable. You only do this once, typically the first time you try to run the file. For Windows, you don't need to do this.

Now you can run a script in most GNU/Linux environments by saying:

./example1.py

Windows Setup. Windows users will need to be sure that python.exe is on their PATH. This is done with the System control panel. Click on the Advanced tab. Click on the Environment Variables... button. Click on the System variables Path line, and click the Edit... button. This will often have a long list of items, sometimes starting with "%SystemRoot%". At the end of this list, add ";" and the direction location of Python.exe. On my machine, I put it in C:\Python23.

For Windows programmers, the windows command interpreter uses the last letters of the file name to associate a file with an interpreter. You can have Windows run the python.exe program whenever you double-click a .py file. This is done with the Folder Options control panel. The File Types tab allows you to pair a file type with a program that processes the file.

POSIX Setup. We have to be sure that the Python interpreter is in value of the PATH that our shell uses. We can't delve into the details of each of the available UNIX Shells. However, the general rule is that the person who administers your POSIX computer should have installed Python and updated the /etc/profile to make Python available to all users. If, for some reason that didn't get done, you can update your own .profile to add Python to your PATH variable.

The #! technique depends on the way all of the POSIX shells handle scripting languages. When you enter a command that is the name of a file, the shell must first check the file for the "x" (execute) mode; this was the mode you added with chmod +x . When execute mode is true, the shell must then check the first few bytes to see what kind of file it is. The first few bytes are termed the magic number; deep in the bowels of GNU/Linux there is a database that shows what the magic number means, and how to work with the various kinds of files. Some files are binary executables, and the operating system handles these directly. Other files, beginning with "#!", are script files. The rest of this first line names the program that will interpret the script. In this case, we asked the env program to find the python interpreter. The shell finds the named program and runs it automatically, passing the name of script file as the last argument to the interpreter it found.

The very cool part of this trick is that "#!" is a comment to Python. This first line is, in effect, directed at the shell, and ignored by Python. The shell glances at it to see what the language is, and Python studiously ignores it, since it was intended for the shell.

Another Script Example

Throughout the rest of this book, we're going to use this script processing mode as the standard way to run Python programs. Many of the examples will be shown as though a file was sent to the interpreter.

For debugging and testing, it is sometimes useful to import the program definitions, and do some manipulations interactively. We'll touch on this in the section called "Hacking Mode".

Here's a second example. We'll create a new file and write another small Python program. We'll call it example2.py.

Example 3.3. example2.py

#!/usr/bin/env python
"""Compute the odds of spinning red (or black) six times in a row
on an American roulette wheel. """
print (18.0/38.0)**6

This is a one-line Python program with a two line module document string. That's a good ratio to strive for.

After we finish editing, we mark this as executable using chmod +x example2.py. Since this is a property of the file, this is remains true no matter how many times we edit, copy or rename the file.

When we run this, we see the following.

$ 

./example2.py

0.0112962280375

Which says that spinning six reds in a row is about a one in eighty-nine probability.

Prev	Up	Next
The IDLE Development Environment	Home	Syntax Formalities

Published under the terms of the Open Publication License Design by Interspire