1) Introduction

• Two things determine time to solution:
  • How long it takes to write a program (human time)
  • How long it takes that program to run (machine time)
• Different languages make different tradeoffs between these [Prechelt 2000]
  • High-level languages let programmers express their thoughts more quickly...
  • ...but the more abstract the language, the more slowly it runs
• This series of lectures introduces a versatile high-level language called [Python]
  • A good way to build tools and crunch data

2) You Can Skim This Lecture If...

• You know Python, Perl, Ruby, Tcl, or Rexx
  • Same basic ideas
  • Different syntax

3) Python's Strengths

• As flexible as the shell, but with real data structures
  • Don't have to squeeze everything into lists of strings
• Freely available for many platforms
• Widely used and well documented
• Much easier to learn and read than Perl
  • Material that took three days to teach in Perl took only two to teach in Python
  • Follow-up surveys showed significantly higher retention rates

4) Python's Weaknesses

• Nimble languages like Python are slower than sturdy languages like Fortran, C/C++, or Java
  • Factor of 20 is common
  • But it's relatively easy to call libraries in those other languages from Python
• Doesn't have as many numerical or statistical tools as MATLAB
  • But its Numeric package isn't bad
• Not as widely used as Perl
  • But it's catching up

5) Why Another Language?

• This course isn't really about Python
  • It's about solving software engineering problems
• But we have to write the examples in something
  • Might as well choose something useful
  • And it puts everyone on an equal footing
• For more information:
  • [Lutz & Ascher 2003] is the standard introduction
  • [Martelli 2005] is a collection of useful tips and tricks
  • See [Python Cookbook] for the on-line version

6) Execution Cycle

• Sturdy languages use a two-step execution cycle
  • Compile source code, putting machine-oriented form in file
  • Run the contents of that file on top of an operating system or virtual machine
• Nimble languages combine these two steps
  • Compiler and virtual machine are the same program
  • Load source code, translate into more compact form if necessary, and execute

• This is why sturdy programs run faster, but nimble programs are faster to write
  • Compiling gives the computer a chance to optimize
  • Load-and-go makes human turnaround faster
    • And as we'll see Python Advanced Object-Oriented Programming, it permits some powerful high-level programming tricks

7) Running Python Programs

• Can run Python interactively, like the shell
  • ^D represents control-D, which is Unix's way of saying "end of input"

$ python
Python 2.4.2 (#67, Sep 28 2005, 12:41:11) [MSC v.1310 32 bit (Intel)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>> print 124/28

4

>>> print 124.0/28.0

4.4285714285714288

>>> ^D

• Obviously don't want to retype program every time you want to run it
  • Save program in a file with a .py extension, and type python filename.py

$ cat saved.py

print 124/28
print 124.0/28.0

$ python saved.py

4
4.42857142857

8) Execution Shortcuts

• On Unix, make #!/usr/bin/python the first line of the program
  • This tells Unix to execute /usr/bin/python with the rest of the file as its input
• Of course, this doesn't work if Python is installed somewhere else
  • Use which python to find out
• Better: use #!/usr/bin/env python as the first line
  • This tells Unix to use /usr/bin/env to find Python, then run the script with it

$ cat hashbang.py

#!/usr/bin/env python
print 124/28
print 124.0/28.0

$ hashbang.py

4
4.42857142857

• On Windows, associate .py files with Python
  • Happens automatically when you run the Python Windows installer
  • Double-clicking on anything ending in .py will then run it

9) Variables

• Variables are names for values
  • No declarations: variables are created when something is assigned to them

planet = "Pluto"
moon = "Charon"
p = planet

• No types: a variable is just a name, and can refer to different types of values at different times

planet = "Pluto"
moon = "Charon"
p = planet
planet = 9

• Your code will be easier to understand if you don't abuse this

10) Possible Mistakes

• Must give a variable a value before using it

planet = "Sedna"
print plant      # note the misspelling

Traceback (most recent call last):
  File "lec/inc/py01/undefined_var.py", line 2, in ?
    print plant      # note the misspelling
NameError: name 'plant' is not defined

• Unlike some languages, Python doesn't provide a default value
  • Because doing so can hide a lot of errors
• Note: anything from "#" to the end of the line is a comment

11) Who Has a Type?

• Variables don't have types, but values do
  • Python complains if you try to operate on incompatible values

x = "two"       # "two" is a string
y = 2           # 2 is an integer
print x * y     # multiplying a string concatenates it repeatedly
print x + y     # but you can't add an integer and a string

twotwo

Traceback (most recent call last):
  File "lec/inc/py01/add_int_str.py", line 4, in ?
    print x + y            # but you can't add an integer and a string
TypeError: cannot concatenate 'str' and 'int' objects

12) Printing

• The print statement prints zero or more values to standard output
  • Separated by spaces
• Automatically puts a newline at the end
  • So print on its own just prints a blank line
  • Putting a comma at the end of the line suppresses the newline

planet = "Pluto"
num_moons = 1
moon = "Charon"
print planet, "has", num_moons, "satellite",
print "and its name is", moon

Pluto has 1 satellite and its name is Charon

13) Quoting

• Use either single or double quotes to create strings
  • Each string must start and end with the same kind of quote
  • But different strings in the same program can use different kinds of quotes

print "He said, \"It ain't what you know, it's what you can.\""

He said, "It ain't what you know, it's what you can."

• Use triple quotes (of either kind) to create a multi-line string

print "Sedna was discovered in 2004"
print 'It takes 10,500 years to circle the sun.'
print '''The tiny world may be part of the Oort Cloud,
a shell of icy proto-comets left over from
the formation of the Solar System.'''

14) Converting Values to Strings

• The built-in function str converts things to strings

print "Diameter: " + str(1280) + "-" + str(1760) + " km"

Diameter: 1280-1760 km

• Use int, float, etc. to convert values to other types

print int(12.3)
print float(4)

12
4.0

15) Escape Sequences

• Use escape sequences to put special characters in strings
  • Borrowed directly from C
  • Most common are tab "\t" and newline "\n"

Expression	Meaning
\\	backslash
\'	single quote
\	double quote
\b	backspace
\n	newline
\r	carriage return
\t	tab

Table 2.1: Character Escape Sequences

16) Numbers

• 14 is an integer (32 bits long on most machines)
• 14.0 is double-precision floating point (64 bits long)
• 1+4j is a complex number (two 64-bit values)
  • Use x.real and x.imag to get the real and imaginary parts
• 123456789L is a long integer
  • Arbitrary length: uses as much memory as it needs to
  • Operations are several times slower

17) Arithmetic

• Python borrows C's numeric operators
  • And adds ** for exponentiation

  Name	Operator	Use	Value	Notes
  Addition	+	35 + 22	57
  		'Py' + 'thon'	'Python'
  Subtraction	-	35 - 22	13
  Multiplication	*	3 * 2	6
  		'Py' * 2	'PyPy'	2 * 'Py' is illegal
  Division	/	3.0 / 2	1.5
  		3 / 2	1	Integer division rounds down: -3 / 2 is -2, not -1
  Exponentiation	**	2 ** 0.5	1.4142135623730951
  Remainder	%	13 % 5	3

  Table 2.2: Numeric Operators in Python

• Python also has C's in-place operators
  • x += 3 does the same thing as x = x + 3
  • 5 += 3 is an error, since you can't assign a new value to 5...

18) Booleans

• True and False are true and false (d'oh)
• Empty string and 0 are considered false
  • Just as 3 is equivalent to 3.0
• (Almost) everything else is true
• Combine Booleans using and, or, not

Expression	Result	Notes
True or False	True
True and False	False
'a' or 'b'	'a'	or is true if either side is true, so it stops after evaluating 'a'
'a' and 'b'	'b'	and is only true if both sides are true, so it doesn't stop until it has evaluated 'b'
0 or 'b'	'b'	0 is false, but 'b' is true
0 and 'b'	0	Since 0 is false, Python can stop evaluating there
0 and (1/0)	0	1/0 would be an error, but Python never gets that far
(x and 'set') or 'not set'	It depends	If x is true, this expression's value is 'set'; if x is false, it is 'not set'

Table 2.3: Boolean Operators in Python

19) Short-Circuit Evaluation

• and and or are short-circuit operators
  • Evaluate expressions left to right
  • Stop as soon as answer is known
  • Result is the last thing evaluated (rather than True or False)
  

  Figure 2.4: Short-Circuit Evaluation

• Can be used to create expressions like val = cond and left or right
  • If cond is True, val is assigned left
  • If cond is False, val is assigned right
  • It works, but it's hard to read
  • Clever isn't always smart

20) Comparisons

• Python borrows C's comparison operators, too
  • But allows you to chain comparisons together, just as in mathematics

Expression	Value
3 < 5	True
3.0 < 5	True
3 != 5	True
3 == 5	False
3 < 5 <= 7	True
3 < 5 >= 2	True (but please don't write this: it's hard to read)
3+2j < 5	Error: can only use == and != on complex numbers

Table 2.4: Comparison Operators in Python

• Note the difference between assignment and testing for equality
  • Use a single equals sign = for assignment
  • Use a double equals sign == to test if two things have equal values

21) String Comparisons

• Characters are encoded as numbers: digits come before uppercase letters, all of which come before lowercase letters
  • Punctuation is mixed in between, just to make matters difficult
• Strings are compared character by character from first to last until:
  • One character is less than another
  • One string runs out of characters

Expression	Value
'abc' < 'def'	True
'abc' < 'Abc'	False
'ab' < 'abc'	True
'0' < '9'	True
'100' < '2'	True

Table 2.5: String Comparisons in Python

22) Conditionals

• Python uses if, elif (not else if), and else
• Use a colon and indentation to show nesting

a = 3
if a < 0:
    print 'less'
elif a == 0:
    print 'equal'
else:
    print 'greater'

greater

23) Why Indentation?

• Why doesn't Python use begin/end or {...}?
  • Because studies showed that indentation is what everyone actually pays attention to
  • Just count the number of warnings in C/Java books about misleading indentation
• Doesn't matter how much you use, but:
  • Everything in the block must be indented the same amount
  • And most people use four spaces
• Please do not use tabs
  • Python interprets them as (up to) eight characters
  • But different editors may display them differently

24) While Loops

• Do something repeatedly as long as some condition is true
  • Again, use colon and indentation to show nesting

num_moons = 3
while num_moons > 0:
    print num_moons
    num_moons -= 1

3
2
1

• Do the "something" zero times if the condition is false the first time it is tested

print 'before'
num_moons = -1
while num_moons > 0:
    print num_moons
    num_moons -=1
print 'after'

before
after

• If the condition is always true, the loop never ends

num_moons = 3
while num_moons > 0:
    print num_moons
    # oops --- forgot to subtract one

3
3
3

25) Break and Continue

• Can break out of the middle of a loop using break

num_moons = 3
while True:             # Looks like an infinite loop...
    print num_moons
    num_moons -= 1
    if num_moons <= 1:
        break           # ...but there's a way out

3
2

• Can skip to the next iteration using continue

num_moons = 5
while num_moons > 0:
    print 'top:', num_moons
    num_moons -= 1
    if (num_moons % 2) == 0:
        continue
    print '...bottom:', num_moons

top: 5
top: 4
...bottom: 3
top: 3
top: 2
...bottom: 1
top: 1

• Don't abuse these
  • A single test at the top of the loop makes code much easier to read

26) String Formatting

• Python's % operator formats output
  • Left side is a string specifying how things are to be formatted
  • Right side is the values to be formatted
    • One value on its own...
    • ...or several values in parentheses, separated by commas
• 'here %s go' % 'we' creates "here we go"
  • The "%s" in the left string means "insert a string here"
  • Creates a new string (since strings are immutable)

27) Format Specifiers

• 'left %d right %d' % (-1, 1) creates "left -1 right 1"
  • "%d" stands for "decimal integer"
• '%04d' % 13 creates "0013"
  • The leading zero means "pad with zeroes"
  • The 4 means "at least 4 characters wide"
  • '[%-4d]' % 13 creates "[13~~]"
• '%6.4f %%' % 37.2 creates "37.2000 %"
  • A floating point number, at least six characters wide, padded on the left with spaces, with four characters after the decimal point
  • "%%" is translated into a single "%"
    • Just as "\\" is how you represent a single "\" in a string

28) Supported Formats

29) Summary

• Scripting languages are increasingly popular because they optimize human time
  • Which is now more expensive than machine time in all but a handful of cases
• Python is one of the cleanest scripting languages around
  • A good tool in its own right
  • An excellent way to build other tools