Basic Scripting

Why Python?

• Two factors 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 programming speed and execution speed
  • Programmers write the same number of lines of code per day no matter what language they're using, so high-level languages are good
  • But the more abstract the language, the more work it is for the computer to figure out what you want it to do

  • Figure 6.1: Nimble vs. Sturdy Languages

• Python is:
  • Like the shell, only better
  • Freely available for many platforms
  • Widely used
  • Well documented
  • (Much) easier to 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
  • (Much) slower than C/C++ or Fortran
    • 10-100 times slower than compiled, optimized code
    • But it's relatively easy to call C/C++ and Fortran libraries from Python
  • Doesn't have all of MATLAB's numerical tools
    • But its Numeric package isn't bad
    • And it has a lot of things MATLAB doesn't
• This course isn't really about Python
  • It's about solving simple problems with the least effort
• But we have to write the examples in something
  • So we might as well choose something simple and useful
• 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
• Comment on this slide

Running Python Interactively

• Running a program in a sturdy language is a two-step process:
  • Compiler translates source code into something that can run
  • That “something” then runs
    • Directly on the hardware (C, C++, Fortran)
    • On a virtual machine (Java)
    • Some combination of the two (C#)
• Nimble languages typically combine the compiler and the virtual machine
  • A single program reads the user's code, translates it into something executable, and executes it right away

  • Figure 6.2: Sturdy vs. Nimble Execution

• This means that most nimble languages can run interactively, like a shell

  • $ python
    

    >>> 3 + 5
    8
    >>> x = 5 * 3 ** 2         # assign 5 times 3 squared to x
    >>> print x
    45
    >>> print 'some' + 'thing' # concatenate strings
    something
    

• Comment on this slide

Running Saved Programs

• Obviously don't have to retype program every time you want to run it
• Option 1: save program in a file with a .py extension, and type python filename.py
  • Python reads and executes the commands in the file exactly as if they'd been typed in interactively
• Option 2 (Unix only): make the following the first line of the .py file

  • #!/usr/bin/env python
    

  • This tells Unix to look up a program called python, and run it with the rest of the file as its input
• Option 3 (Windows only): associate .py files with Python
  • Double-clicking on anything ending in .py will then run it
  • Happens automatically when you run the Python Windows installer
• Example
  • Using an editor, put the following in powers.py

  • print 2, 2**2, 2**3, 2**4
    print 3, 3**2, 3**3, 3**4
    print 4, 4**2, 4**3, 4**5
    

  • Run using python powers.py
  • Should see the following

  • 2 4 8 16
    3 9 27 81
    4 16 64 1024
    

• Comment on this slide

Variables

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

  • Figure 6.3: Variables Refer to Values

• No types: a variable is just a name, and can refer to different types of values at different times
  • Although your code will be easier to understand if you don't abuse this
• Must give a variable a value before using it
  • Unlike some languages, Python doesn't try to guess a “sensible” value

  • print something
    

    Traceback (most recent call last):
      File "undefined.py", line 1, in ?
        print something
    NameError: name 'something' is not defined
    

• While variables don't have types, values do
  • If you try to operate on incompatible values, Python will complain

  • 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 "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
    

• Comment on this slide

Printing and Quoting

• The print statement prints zero or more values
  • Separated by spaces
  • Automatically puts a newline at the end
  • So print on its own just prints a blank line
• Use either single or double quotes to create strings
  • Must be consistent: if a string starts with one kind of quote, it must end with that kind of quote
    • But different strings in the same program can use different kinds of quotes
    • This was not necessarily a good design decision…

  • print 'a', "b", '"c"', "'d'"
    

    a b "c" 'd'
    

• The built-in function str converts things to strings

  • print 'carbon-' + str(14)
    

    carbon-14
    

  • Use similar functions called int, float, etc. to convert values to other types
• Use escape sequences to put special characters in strings
  • Single quotes in a single-quoted string: 'This isn\'t unusual.'
  • Double quotes in a double-quoted string: "She said, \"You can quote me on that!\""
  • Tab and newline characters: '\tIndented line\n'
• Comment on this slide

Numbers and Arithmetic

• The usual numeric types
  • 14 is an integer (32 bits long on most machines)
  • 14.0 is floating point (double precision, i.e., 64 bits long)
• Two unusual numeric types
  • 1+4j is a complex number (two 64-bit values)
  • 123456789L is a long integer
    • Arbitrary length: uses as much memory as it needs to
    • Operations are several times slower
    • Python automatically switches to long-integer mode when it needs to
• Python borrows C's numeric operators

  • 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 6.1: Numeric Operators in Python

• Python also supports 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…
• Comment on this slide

Booleans

• True and False are true and false (d'oh)
• Empty string, 0, and None are equivalent to false
  • Just as 3 is equivalent to 3.0
• (Almost) everything else is true
• Combine Booleans using and, or, not
  • and and or are short-circuit operators
  • Evaluate expressions left to right, and stop as soon as they know the answer
  • Result is the last thing evaluated, rather than True or False

  • 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 6.2: Boolean Operators in Python

• Comment on this slide

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 6.3: 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
• String comparison may not do what you expect
  • 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 6.4: Python String Comparisons

• Comment on this slide

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'
    

• Why indentation?
  • Based on studies from the 1980s, it's what everyone looks at anyway
  • 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
  • Tabs are expanded so that they're equivalent to (up to) eight characters
    • So don't ever indent with tabs, since your editor may interpret them differently
  • Many editors understand Python indentation, and will help you get it right
    • If you're fond of legacy character-oriented editors, Emacs and Vim both work well
    • If you want a free integrated development environment (IDE), try SPE or PyDev
    • If you'd prefer something with commercial support, Komodo and WingIDE are my favorites
• Comment on this slide

While Loops, Break, and Continue

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

  • a = 3
    while a > 0:
        print a
        a -= 1
    

    3
    2
    1
    

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

  • print 'before'
    a = -1
    while a > 0:
        print a
        a -=1
    print 'after'
    

    before
    after
    

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

  • a = 3
    while a > 0:
        print a
        # oops --- forgot to subtract one from a
    

    3
    3
    3
    

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

  • a = 30
    while True:
        print a
        a -= 1
        if (a % 5) == 0:  # if a is divisible by 5
            break
    

    30
    29
    28
    27
    26
    

  • Don't abuse this: put the test at the top of the loop unless there's a really good reason not to
• Can skip to the next iteration using continue

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

    top of loop 5
    top of loop 4
    ...bottom of loop 3
    top of loop 3
    top of loop 2
    ...bottom of loop 1
    top of loop 1
    

  • Again, don't abuse this by writing loops that are hard for other people to figure out
    • If only because “other people” includes you three months from now
• Comment on this slide