Running Files with Command Lines

Once youve saved this text file, you can ask Python to run it by listing its full filename
as the first argument to a python command, typed at the system shell prompt:
% python script1.py
win32
1267650600228229401496703205376
Spam!Spam!Spam!Spam!Spam!Spam!Spam!Spam!

Again, you can type such a system shell command in whatever your system provides
for command-line entrya Windows Command Prompt window, an xterm window,
or similar. Remember to replace python with a full directory path, as before, if your
PATH setting is not configured.
If all works as planned, this shell command makes Python run the code in this file line
by line, and you will see the output of the scripts three print statementsthe name
of the underlying platform, 2 raised to the power 100, and the result of the same string
repetition expression we saw earlier (again, more on the last two of these in Chapter 4).
If all didnt work as planned, youll get an error messagemake sure youve entered
the code in your file exactly as shown, and try again. Well talk about debugging options
in the sidebar Debugging Python Code on page 67, but at this point in the book
your best bet is probably rote imitation.
Because this scheme uses shell command lines to start Python programs, all the usual
shell syntax applies. For instance, you can route the output of a Python script to a file
to save it for later use or inspection by using special shell syntax: % python script1.py > saveit.txt
In this case, the three output lines shown in the prior run are stored in the file
saveit.txt instead of being printed. This is generally known as stream redirection; it
works for input and output text and is available on Windows and Unix-like systems.
It also has little to do with Python (Python simply supports it), so we will skip further
details on shell redirection syntax here.
If you are working on a Windows platform, this example works the same, but the system
prompt is normally different:
C:\Python30> python script1.py
win32
1267650600228229401496703205376
Spam!Spam!Spam!Spam!Spam!Spam!Spam!Spam!

As usual, be sure to type the full path to Python if you havent set your PATH environment
variable to include this path or run a change-directory command to go to the path:
D:\temp> C:\python30\python script1.py
win32
1267650600228229401496703205376
Spam!Spam!Spam!Spam!Spam!Spam!Spam!Spam!

On all recent versions of Windows, you can also type just the name of your script, and
omit the name of Python itself. Because newer Windows systems use the Windows
Registry to find a program with which to run a file, you dont need to name python
on the command line explicitly to run a .py file. The prior command, for example, could
be simplified to this on most Windows machines:
D:\temp> script1.py

Finally, remember to give the full path to your script file if it lives in a different directory
from the one in which you are working. For example, the following system command
line, run from D:\other, assumes Python is in your system path but runs a file located
elsewhere:
D:\other> python c:\code\otherscript.py

If your PATH doesnt include Pythons directory, and neither Python nor your script file
is in the directory youre working in, use full paths for both:
D:\other> C:\Python30\python c:\code\otherscript.py

Using Command Lines and Files

Running program files from system command lines is also a fairly straightforward
launch option, especially if you are familiar with command lines in general from prior
work. For newcomers, though, here are a few pointers about common beginner traps

that might help you avoid some frustration:

Beware of automatic extensions on Windows. If you use the Notepad program
to code program files on Windows, be careful to pick the type All Files when it
comes time to save your file, and give the file a .py suffix explicitly. Otherwise,
Notepad will save your file with a .txt extension (e.g., as script1.py.txt), making it
difficult to run in some launching schemes.
Worse, Windows hides file extensions by default, so unless you have changed your
view options you may not even notice that youve coded a text file and not a Python
file. The files icon may give this awayif it doesnt have a snake on it, you may
have trouble. Uncolored code in IDLE and files that open to edit instead of run
when clicked are other symptoms of this problem.
Microsoft Word similarly adds a .doc extension by default; much worse, it adds
formatting characters that are not legal Python syntax. As a rule of thumb, always
pick All Files when saving under Windows, or use a more programmer-friendly
text editor such as IDLE. IDLE does not even add a .py suffix automaticallya
feature programmers tend to like, but users do not.
Use file extensions and directory paths at system prompts, but not for imports.
Dont forget to type the full name of your file in system command lines
that is, use python script1.py rather than python script1. By contrast, Pythons
import statements, which well meet later in this chapter, omit both the .py file
suffix and the directory path (e.g., import script1). This may seem trivial, but
confusing these two is a common mistake.
At the system prompt, you are in a system shell, not Python, so Pythons module
file search rules do not apply. Because of that, you must include both the .py extension
and, if necessary, the full directory path leading to the file you wish to run.
For instance, to run a file that resides in a different directory from the one in
which you are working, you would typically list its full path (e.g.,
python d:\tests\spam.py). Within Python code, however, you can just say
import spam and rely on the Python module search path to locate your file, as
described later.
Use print statements in files. Yes, weve already been over this, but it is such a
common mistake that its worth repeating at least once here. Unlike in interactive
coding, you generally must use print statements to see output from program files.
If you dont see any output, make sure youve said print in your file. Again,
though, print statements are not required in an interactive session, since Python
automatically echoes expression results; prints dont Unix Executable Scripts (#!)
If you are going to use Python on a Unix, Linux, or Unix-like system, you can also turn
files of Python code into executable programs, much as you would for programs coded
in a shell language such as csh or ksh. Such files are usually called executable scripts.
In simple terms, Unix-style executable scripts are just normal text files containing Python
statements, but with two special properties:
Their first line is special. Scripts usually start with a line that begins with the
characters #! (often called hash bang), followed by the path to the Python interpreter
on your machine.
They usually have executable privileges. Script files are usually marked as executable
to tell the operating system that they may be run as top-level programs.
On Unix systems, a command such as chmod +x file.py usually does the trick.
Lets look at an example for Unix-like systems. Use your text editor again to create a
file of Python code called brian:
#!/usr/local/bin/python
print('The Bright Side ' + 'of Life...') # + means concatenate for strings

The special line at the top of the file tells the system where the Python interpreter lives.
Technically, the first line is a Python comment. As mentioned earlier, all comments in
Python programs start with a # and span to the end of the line; they are a place to insert
extra information for human readers of your code. But when a comment such as the

first line in this file appears, its special because the operating system uses it to find an
interpreter for running the program code in the rest of the file.
Also, note that this file is called simply brian, without the .py suffix used for the module
file earlier. Adding a .py to the name wouldnt hurt (and might help you remember that
this is a Python program file), but because you dont plan on letting other modules
import the code in this file, the name of the file is irrelevant. If you give the file executable
privileges with a chmod +x brian shell command, you can run it from the operating
system shell as though it were a binary program:
% brian
The Bright Side of Life...

A note for Windows users: the method described here is a Unix trick, and it may not
work on your platform. Not to worry; just use the basic command-line technique explored
earlier. List the files name on an explicit python command line:*
* As we discussed when exploring command lines, modern Windows versions also let you type just the name
of a .py file at the system command linethey use the Registry to determine that the file should be opened
with Python (e.g., typing brian.py is equivalent to typing python brian.py). This command-line mode is
similar in spirit to the Unix #!, though it is system-wide on Windows, not per-file. Note that some
programs may actually interpret and use a first #! line on Windows much like on Unix, but the DOS system
shell on Windows simply ignores it.
C:\misc> python brian
The Bright Side of Life...

In this case, you dont need the special #! comment at the top (although Python just
ignores it if its present), and the file doesnt need to be given executable privileges. In
fact, if you want to run files portably between Unix and Microsoft Windows, your life
will probably be simpler if you always use the basic command-line approach, not Unixstyle
scripts, to launch programs.

The Unix env Lookup Trick

On some Unix systems, you can avoid hardcoding the path to the Python interpreter
by writing the special first-line comment like this:
#!/usr/bin/env python
...script goes here...

When coded this way, the env program locates the Python interpreter according to your
system search path settings (i.e., in most Unix shells, by looking in all the directories
listed in the PATH environment variable). This scheme can be more portable, as you
dont need to hardcode a Python install path in the first line of all your scripts.
Provided you have access to env everywhere, your scripts will run no matter where
Python lives on your systemyou need only change the PATH environment variable
settings across platforms, not in the first line in all your scripts. Of course, this assumes
that env lives in the same place everywhere (on some machines, it may be
in /sbin, /bin, or elsewhere); if not, all portability bets are off!

Clicking File Icons

On Windows, the Registry makes opening files with icon clicks easy. Python automatically
registers itself to be the program that opens Python program files when they are
clicked. Because of that, it is possible to launch the Python programs you write by
simply clicking (or double-clicking) on their file icons with your mouse cursor.
On non-Windows systems, you will probably be able to perform a similar trick, but
the icons, file explorer, navigation schemes, and more may differ slightly. On some
Unix systems, for instance, you may need to register the .py extension with your file
explorer GUI, make your script executable using the #! trick discussed in the previous
section, or associate the file MIME type with an application or command by editing
files, installing programs, or using other tools. See your file explorers documentation
for more details if clicks do not work correctly right off the bat.

Clicking Icons on Windows

To illustrate, lets keep using the script we wrote earlier, script1.py, repeated here to
minimize page flipping: