Now that we’ve seen assignment statements, it is also time to get more formal in the use of variable names. In Python, names come into existence when you assign values to them, but there are a few rules to follow when picking names for things in our program:

and

del

for

Is

raise

assert

elif

from

lamda

return

break

else

global

not

try

class

except

if

or

while

continue

exec

import

pass

yield[]

def

finally

in

print

Python’s reserved words are always all lowercase. And they are truly reserved; unlike names in the built-in scope that you will meet in the next part, you cannot redefine reserved words by assignment (e.g., and=1 is a syntax error).^[2] Furthermore, because module names in import statements become variables in your script, this constraint extends to your module filenames—you can code a file called and.py, but cannot import it; we’ll revisit this idea in Part V.

>>> x = 0            # x bound to an integer object
>>> x = "Hello"      # Now it's a string.
>>> x = [1, 2, 3]    # And now it's a list.

Beginning with Python 2.0, a set of additional assignment statement formats, listed in Table 8-4, are now available. Known as augmented assignment , and borrowed from the C language, these formats are mostly just shorthand. They imply the combination of a binary expression and an assignment. For instance, the following two formats are now roughly equivalent:

X = X + Y       # Traditional form
X += Y          # Newer augmented form

X += Y

X &= Y

X -= Y

X |= Y

X *= Y

X ^= Y

X /= Y

X »= Y

X %= Y

X «= Y

X **= Y

X //= Y

Augmented assignment works on any type that supports the implied binary expression. For example, here are two ways to add 1 to a name:

>>> x = 1
>>> x = x + 1          # Traditional
>>> x
2
>>> x += 1             # Augmented
>>> x
3

When applied to a string, the augmented form performs concatenation instead—exactly as if you had typed the longer: S = S + "SPAM“:

>>> S = "spam"
>>> S += "SPAM"        # Implied concatenation
>>> S
'spamSPAM'

As shown in Table 8-4, there are analogous augmented assignment forms for every Python binary expression operator (an operator with values on the left and right side). For instance, X*=Y multiplies and assigns, X>>=Y shifts right and assigns, and so on. X //= Y (for floor division) is new in Version 2.2. Augmented assignments have three advantages:^[4]

The last point here requires a bit more explanation. For augment assignments, in-place operations may be applied for mutable objects as an optimization. Recall that lists can be extended in a variety of ways. To add a single item to the end of a list, we can concatenate or append:

>>> L = [1, 2]
>>> L = L + [3]            # Concatenate: slower
>>> L
[1, 2, 3]
>>> L.append(4)            # Faster, but in-place
>>> L
[1, 2, 3, 4]

And to add a set of items at the end, we may either concatenate again, or call the list extend method:^[5]

>>> L = L + [5, 6]         # Concatenate: slower
>>> L
[1, 2, 3, 4, 5, 6]
>>> L.extend([7, 8])       # Faster, but in-place
>>> L
[1, 2, 3, 4, 5, 6, 7, 8]

In all of these, concatenation is less prone to the side effects of shared object references, but will generally run slower than the in-place equivalent. Concatenation must create a new object, copy in the list on the left, and then copy in the list on the right. By contrast, in-place method calls simply add items at the end of a memory block.

When augmented assignment is used to extend a list, we can forget these details—Python automatically calls the quicker extend method, instead of the slower concatenation operation implied by +:

>>> L += [9, 10]       # Mapped to L.extend([9, 10])
>>> L
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

To print a hello world message, you simply print it:

>>> print 'hello world'                 # Print a string object.
hello world

Since expression results are echoed in the interactive command line, you often don’t even need to use a print statement there; simply type expressions you’d like to have printed and their results are echoed back:

>>> 'hello world'                       # Interactive echoes
'hello world'

Really, the print statement is just an ergonomic feature of Python—it provides a user-friendly interface to the sys.stdout object, with a bit of default formatting. You can also code print operations this way:

>>> import sys                          # Printing the hard way
>>> sys.stdout.write('hello world
')
hello world

This code explicitly calls the write method of sys.stdout—an attribute preset when Python starts up to an open file object connected to the output stream. The print statement hides most of those details. It provides a simple tool for simple printing tasks.

The sys.stdout print equivalent turns out to be basis of a common technique in Python. In general, print and sys.stdout are related as follows:

print X

is equivalent to the longer:

import sys
sys.stdout.write(str(X) + '
')

that manually performs a string conversion with str, adds a newline with +, and calls the output stream’s write method. The long form isn’t all that useful for printing by itself. However, it is useful to know that this is exactly what print statements do, because it is possible to reassign sys.stdout to something different than the standard output stream. In other words, this equivalence provides a way for making your print statements send their text to other places. For example:

import sys
sys.stdout = open('log.txt', 'a')     # Redirects prints to file
...
print x, y, x                         # Shows up in log.txt

Here, we reset sys.stdout to a manually-opened output file object opened in append mode. After the reset, every print statement anywhere in the program will write its text to the end of file log.txt, instead of the original output stream. The print statements are happy to keep calling sys.stdout’s write method, no matter what sys.stdout happens to refer to.

In fact, as this chapter’s sidebar on print and stdout will explain, we can even reset sys.stdout to nonfile objects, as long as they have the expected protocol (a write method); when those objects are classes, printed text can be routed and processed arbitrarily.

class FileFaker:
    def write(self, string):
        # Do something with the string.
import sys
sys.stdout = FileFaker(  )
print someObjects         # Sends to the class write method

myobj = FileFaker(  )
print >> myobj, someObjects   # Does not reset sys.stdout

python script.py < inputfile > outputfile
python script.py | filterProgram

import sys
temp = sys.stdout                     # Save for restoring.
sys.stdout = open('log.txt', 'a')     # Redirects prints to file
...
print x, y, x                         # Print to file.
... 
sys.stdout = temp
print a, b, c                         # Print to original stdout.

log =  open('log.txt', 'a')     
print >> log, x, y, z                 # Print to a file-like object.
print a, b, c                         # Print to original stdout.