4. Basic Statements

 

 

 

Python program structure

 

     Programs are composed of modules

     Modules contain statements

     Statements contain expressions: logic

     Expressions create and process objects

 

 

 

Statement

Examples

Assignment

curly, moe, larry = 'good', 'bad', 'ugly'

Calls

stdout.write("spam, ham, toast\n")

Print (a call in 3.X)

print 1, "spam", 4, 'u',

If/elif/else

if "python" in text: mail(poster, spam)

For/else

for peteSake in spam: print peteSake

While/else

while 1: print 'spam',i;  i=i+1

Pass

while 1: pass

Break, Continue

while 1: break

Try/except/finally

try: spam() except: print 'spam error'

Raise

raise overWorked, cause

Import, From

import chips; from refrigerator import beer

Def, Return,Yield

def f(a, b, c=1, *d): return a+b+c+d[0]

Class

class subclass(superclass): staticData = []

Global, Nonlocal (3.X)

def function(): global x, y; x = 'new'

Del

del spam[k]; del spam[i:j]; del spam.attr 

Exec (a call in 3.X)

exec "import " + moduleName in gdict, ldict

Assert

assert name != "", "empty name field"

With/As (2.6+)

with open('text.dat') as F: process(F)

 

 


 

General syntax concepts

 

 

 

Python syntax

 

     No variable/type declarations

     No braces or semicolons

     The “what you see is what you get” of languages

 

 

 

Python assignment

 

     Assignments create object references

     Names are created when first assigned

     Names must be assigned before being referenced

 

 

 

A Tale of Two Ifs…

 

 

C++/Java/etc.:

 

if (x) {

    x = y + z;      // braces, semicolons, parens

}

 

 

Python:

 

if x:

    x = y + z       # indented blocks, end of line, colon

 

 

      What Python removes [(), ;, {}], and adds [:]

      Why indentation syntax? [readability counts!]

 

 

 

 

Demo: coding read/eval loops

      while loop input, process, print

      Console input: input() in 3.X, raw_input() in 2.X

      Console output: print(reply) in 3.X, “print reply” in 2.X

      Adding converters, if/elif/else, try/except/else

 

 

 

 

Assignment

 

 

     ‘=’ assigns object references to names or components

     Implicit assignments: import, from, def, class, for, calls

 

 

Operation

Interpretation

 

 

spam = 'SPAM'

basic form

spam, ham = 'yum', 'YUM'

tuple assignment

[spam, ham] = ['yum', 'YUM']

list assignment

a, b, c, d = 'spam'

sequence assign

spam = ham = 'lunch'

multiple-target

spam += 42; ham *= 12

Augmented (2.0)

a, *b, c = [1, 2, 3, 4]

Extended (3.X)

 

 

See also “About the stars…” in functions unit, for “*X” forms that unpack instead of collecting

 

 

 

 

Variable name rules

 

     (‘_’ or letter) + (any number of letters, digits, ‘_’s)

     Case matters: ‘SPAM’ is not ‘spam’

     But can’t use reserved words:

     + “yield”, for generators (2.3 and later)

     + “with” and “as” for context managers (2.6, optional in 2.5 though not in 2.5 IDLE!)

     3.X: minusprint”, “exec”; plusNone”, “True”, “False”, “nonlocal” (and in 3.5+: “async”, “await”)

 

and   

assert

break

class

continue

def

del

elif

else

except

exec

finally

for

from

global

if

import

in

is

lambda

not

or

pass

print

raise

return

try

while

 

 

 

 

     Also applies to module file names:

     my-code.py’ can be run, but not imported!

 

 

 

Expressions

 

 

     Useful for calls, and interactive prints

     Expressions can be used as statements

     But statements cannot be used as expressions (‘=’)

 

 

 

Operation

Interpretation

spam(eggs, ham)

function calls

spam.ham(eggs)

method calls

spam

interactive print

spam < ham and ham != eggs

compound expr's

spam < ham < eggs

range tests

 

 

 

 

See ahead…

 

     Python 2.0+ “list comprehension” expressions (covered in Functions)

     Similar to map/lambda combination (result=[0,1,4,9])

[i**2 for i in range(4)]  …like…  map((lamba x: x**2), range(4))

 

 


    

Print

 

 

     ‘print’ statement writes objects to the ‘stdout’ stream

     File object ‘write’ methods write strings to files

     Adding a trailing comma suppresses line-feed

     Reset ‘sys.stdout’ to catch print output

     3.X: a built-in function call with arguments in “()”

 

 

Python 2.X form:

 

Operation

Interpretation

print spam, ham

print objects to sys.stdout

print spam, ham,

don’t add linefeed at end

print>>file, spam

Python 2.0: not to stdout

 

 

 

 

Python 3.X form:

 

  print(spam, ham, sep='::', end='.\n', file=open('save.txt', 'w'), flush=True)

 

 

Usable in 2.X via:

 

  from __future__ import print_function

 

 

Otherwise, 2.X    3.X mappings:

 

  print a          print(a)

  print a, b, c    print(a, b, c)

  print a, b,      print(a, b, end='')

  print>>F, a      print(a, file=F)

 

 

 

 

The Python ‘Hello world’ program

 

 

    Expression results don’t need to be printed at top-level

 

>>> print 'hello world'             # 3.X: print('text')

hello world

>>> 'hello world'

'hello world'

 

 

    The hard way

 

>>> x = 'hello world'

>>> import sys

>>> sys.stdout.write(str(x) + '\n')    

 

 

    sys.stdout can be assigned

  

>>> sys.stdout = open('log', 'a')         # or a class with .write

>>> print x

 

 

 

 

If selections

 

 

     Python’s main selection construct

     No ‘switch’: via if/elif/else, dictionaries, or lists

     See also expression ahead:  X = B if A else C

 

 

 

General format

 

if <test1>:

    <statements1>

elif <test2>:             # optional elif’s

    <statements2>

else:                     # optional else

    <statements3>

 

 

 

 

Examples

 

 

>>> if 3 > 2:

...     print 'yep'

...

yep

 

 

 

>>> x = 'killer rabbit'

>>> if x == 'bunny':

...     print 'hello little bunny'

... elif x == 'bugs':

...     print "what's up doc?"

... else:

...     print 'Run away!... Run away!...'

...

Run away!... Run away!...

 

 

 

>>> choice = 'ham'

>>> print {'spam':  1.25,         # dictionary switch

...        'ham':   1.99,

...        'eggs':  0.99,

...        'bacon': 1.10}[choice]

1.99

 

 

 

# with actions

{'spam':  (lambda: …),

 'ham':   (lambda: …),

 …}[choice]()

 

 

 

 

Python syntax rules

 

 

     Compound statements = header, ‘:’, indented statements

     Block and statement boundaries detected automatically

     Comments run from “#” through end of line

     Documentation strings at top of file, class, function

 

 

 

Block delimiters

 

      Block boundaries detected by line indentation

      Indentation is any combination of spaces and tabs

      Tabs = N spaces up to multiple of 8 (but don’t mix)

 

 

 

Statement delimiters

 

      Statement normally end at end-of-line, or ';'

      Statements may span lines if open syntactic pair: ( ), { }, [ ]

      Statements may span lines if end in backslash (outdated feature)

      Some string constants span lines too (triple-quotes)

 


 

Special cases

 

L = ["Good",

     "Bad",

     "Ugly"]            # open pairs may span lines

 

 

x = 1; y = 2; print x   # more than 1 simple statement

 

 

if 1: print 'hello'     # simple statement on header line

 

 

 

Nesting code blocks

 

x = 1            # block0

if x:

    y = 2        # block1

    if y:

        print 'block2'

    print 'block1'

print 'block0'

 

 

 

 

The documentation sources interlude

 

 

 

Form

Role

# comments

In-file documentation

The dir function

Lists of attributes available on objects

Docstrings: __doc__

In-file documentation attached to objects

PyDoc: The help function

Interactive help for objects

PyDoc: HTML reports

Module documentation in a browser

Standard manual set

Official language and library descriptions

Web resources

Online tutorial, examples, and so on

Published books

Commercially-available texts (see Resources)

 

 

 

>>> import sys

>>> dir(sys)                                              # also works on types, objects, etc.

['__displayhook__', '__doc__', '__excepthook__', '__name__', …

 

 

>>> print sys.__doc__

This module provides access to some objects …

 

 

>>> help(sys)

Help on built-in module sys: …

 

 

PyDoc

 

      GUI till 3.2:

      Start/App menu, PythonXX/ModuleDocs

      Or run Python script pydocgui.pyw in std lib

      Or command line “python -m pydoc –g” (or C:\Python3x\python …)

      Browser in 3.2+:

      Command line “python -m pydoc –b”

      Or on Windows “py −3 -m pydoc –b”

      Or on some Python 3.X: Start/App menu, PythonXX/ModuleDocs

 

 

 

Description: Description: Description: Description: Description: Description: Description: Description: Description: Description: Description: Description: Description: Description: Description: Description: Description: Description: Description: Description: pydoc-main-userdef

 

 

 

 

# File: docstrings.py

"""

Module documentation

Words Go Here

"""

 

spam = 40

 

def square(x):

    """

    function documentation

    can we have your liver then?

    """

    return x ** 2

 

class SomeClass:  # see ahead

    """

    class docs go here, and can also

    be in nested method def statements

    """

    pass

 

 

>>> import docstrings

>>> help(docstrings)

>>> help(docstrings.square)

 

 

 

 

Truth tests revisited

 

 

     True = non-zero number, or non-empty object

     Comparisons operators return “True” (1) or “False” (0)

     Boolean operators “short-circuit” when result known

     Boolean operators return an operand object

  

Object

Value

"spam"

true

""

false

[]

false

{}

false

1

true

0.0

false

None

false

 

 

Examples

 

>>> 2 < 3, 3 < 2        # return True (1) or False (0)

(True, False)

 

>>> 2 or 3, 3 or 2      # return left operand if true

(2, 3)                  # else return right operand (T|F)

>>> [] or 3

3

>>> [] or {}

{}

 

>>> 2 and 3, 3 and 2    # return left operand if false

(3, 2)                  # else return right operand (T|F)

>>> [] and {}

[]

>>> 3 and []

[]

 

 

 

 

C’s ternary operator in Python

 

    Prior to 2.5:   X = (A and B) or C

    New in 2.5:     X = B if A else C

if A:

    X = B

else:

    X = C

 

 

 

Boolean type (2.3+)

 

      bool is a subclass of int

      bool has two instances: True and False

      True,False are 1,0 but print differently

 

>>> 1 > 0

True

 

>>> True == 1, True is 1

(True, False)

 

>>> True + 1

2

 

 

 

 

 

While loops

 

 

     Python’s most general iteration construct

     One of two looping statements: while, for

     Implicit looping tools: map, reduce, filter, in, list (and other) comprehensions

 

 

General format

 

while <test>:
    <statements>

else:                     # optional else

    <statements2>         # run if didn’t exit with break

 

 

 

Examples

 

 

>>> while True:

...     print 'Type Ctrl-C to stop me!'

 

 

>>> count = 5

>>> while count:

...     print count,

...     count -= 1

... 

5 4 3 2 1

 

 

>>> x = 'spam'

>>> while x:

...     print x,

...     x = x[1:]      # strip first char off x

...

spam pam am m

 

 

>>> a=0; b=10

>>> while a < b:       # one way to code counter loops

...     print a,       # 3.X: print(a, end='')

...     a = a+1        # or:  a += 1

...

0 1 2 3 4 5 6 7 8 9


 

 

 

 

Break, continue, pass, and the loop else

 

 

     break         jumps out of the closest enclosing loop

     continue     jumps to the top of the closest enclosing loop

     pass          does nothing: an empty statement placeholder

     loop else    run if loop exits normally, without a ‘break’

     3.X  ‘…’   a literal ‘…’ ellipsis can work like a ‘pass’

 

 

 

General loop format

 

 

while <test>:

    <statements>

    if <test>: break         # exit loop now, skip else

    if <test>: continue      # go to top of loop now

else:

    <statements>             # if we didn’t hit a ‘break’

 

 


 

Examples

 

 

 

    Pass: an infinite loop

      Better example: stubbed-out function bodies, “TBD”

 

while True: pass   # ctrl-C to stop!

 

 

 

 

 

    Continue: print even numbers

      Avoids statement nesting (but use sparingly!)

 

 

x = 10

while x:

    x = x-1

    if x % 2 != 0: continue     # odd?--skip

    print x,

 

 

 

 

 

    Break: find factors

      Avoids search status flags

 

 

x = y / 2

while x > 1:

    if y % x == 0:                 # remainder

        print y, 'has factor', x

        break                      # skip else

    x = x-1

else:                              # normal exit

    print y, 'is prime'

 


  

 

 

For loops

 

 

     A general sequence (iterable) iterator

     Works on strings, lists, tuples, other

     Replaces most ‘counter’ style loops

     Original: repeatedly indexes object until IndexError detected

     Newer: repeatedly calls next(iter(object)) until StopIteration

     Preview: also works on Python classes and C types

 

 

 

General format

 

for <target> in <object>:   # assign object items to target

    <statements>

    if <test>: break        # exit loop now, skip else

    if <test>: continue     # go to top of loop now

else:

    <statements>            # if we didn’t hit a ‘break’

 

 

 

Examples

 

 

>>> for x in ["spam", "eggs", "spam"]:

...     print x,

...

spam eggs spam

 

 

>>> prod = 1

>>> for i in (1, 2, 3, 4): prod *= i        # tuples

...

>>> prod

24

 

 

>>> S = 'spam'

>>> for c in S: print c                     # strings

...

s

p

a

m

 

 

 

Works on any iterable object: files, dicts

              

 

>>> for line in open('data.txt'):

        print line.upper()        # calls next(), catches exc

    

>>> for key in D:

        print key, D[key]

 

 

 

 

Demo: iteration protocol and files

      file.__next__() gets next line, like file.readline(), but eof differs

      Use file.next() in 2.X, or next(file) in either 2.X or 3.X

      All iteration tools/contexts use the iteration protocol

      Protocol: I=iter(X), call next(I) * N, catch StopIteration

      iter(X) optional for single-scan iterables (e.g., files)

      Any such object works in for loops, comprehensions, …

      line.rstrip(), line.upper() are string methods

Comprehensions:

      [expr-with-var for var in iterable]

      [expr-with-var for var in iterable if expr-with-var]

      [expr-with-vars for var1 in iterable1 for var2 in iterable2]

      Also works for sets, dictionaries, generators in 2.7+: {}, ()

      Hint: comps have statement equivalents: for/if/append() nesting

      Hint: KISS! – if it’s hard for you read, don’t do it…

 

 

 

 

 

 

Loop coding techniques

 

 

     for subsumes most counter loops

     range generates a list of integers to iterate over

     xrange similar, but doesn’t create a real list

     avoid range, and the temptation to count things!

 

 

 

# The easy (and fast) way

 

>>> X = 'spam'

>>> for item in X: print item,            # step through items

...

s p a m

 

 

 

# The hard way: a C-style for loop

 

>>> i = 0

>>> while i < len(X):                     # manual while indexing

...     print X[i],; i += 1

...

s p a m

 

 

 

# Range and fixed repitions

 

>>> range(5), range(2, 5)

([0, 1, 2, 3, 4], [2, 3, 4])

 

>>> for i in range(4): print 'A shrubbery!'

...

A shrubbery!

A shrubbery!

A shrubbery!

A shrubbery!

 

 

 

# Using range to generate offsets (not items!)

 

>>> X

'spam'

>>> len(X)

4

>>> range(len(X))

[0, 1, 2, 3]

 

>>> for i in range(len(X)): print X[i],      # step through offsets

...

s p a m

 

 

 

# Using range and slicing for non-exhaustive traversals

 

>>> range(2,10,2)

[2, 4, 6, 8]

 

>>> S = 'abcdefghijk'

>>> for i in range(0,len(S),2): print S[i],

...

a c e g i k

 

 

in recent releases…

 

>>> for c in S[::2]: print c,             # S[::-1] reverses

...

a c e g i k

 

 

 

# Using range and enumerate to change a list in-place

 

>>> L = [1, 2, 3, 4]

>>> for x in L: x += 10

 

>>> L

[1, 2, 3, 4]

 

 

>>> for i in range(len(L)): L[i] += 10

 

>>> L

[11, 12, 13, 14]

 

 

 

    

List comprehensions

    

    

>>> M = [x + 10 for x in L]

>> M

21, 22, 23, 24]

    

>>> lines = [line.rstrip() for line in open('README.txt')]

    

>>> [row[1] for row in matrix]

    

… more in functions section

 

 

 

Demo: list comprehensions and files

      Unless covered earlier (see above)

 

 

 

Enumerate in 2.3+

              

>>> for (i, x) in enumerate(L):

     L[i] = x * 2

 

>>> L

[22, 24, 26, 28]

 

>>> enumerate(L)

<enumerate object at 0x00B48440>

 

>>> list(enumerate(L))

[(0, 22), (1, 24), (2, 26), (3, 28)]

 

>>> E = enumerate(L)

>>> E.next()

(0, 22)

>>> E.next()             # see generators in next section

(1, 24)

 

 

 

# Traversing sequences in parallel with zip

 

>>> L1 = [1,2,3,4]

>>> L2 = [5,6,7,8]

>>> 

>>> zip(L1,L2)

[(1, 5), (2, 6), (3, 7), (4, 8)]

>>> 

>>> for (x,y) in zip(L1, L2):

...     print x, y, '--', x+y

...

1 5 -- 6

2 6 -- 8

3 7 -- 10

4 8 -- 12

 

 

 

# Traversing dictionaries by sorted keys

 

>>> D = {'a':1, 'b':2, 'c':3}

>>> D

{'a': 1, 'c': 3, 'b': 2}

 

>>> Ks = D.keys()

>>> Ks.sort()

>>> for k in Ks: print D[k],

 

1 2 3

 

 

 

Sorted in 2.4+

 

>>> D

{'a': 1, 'c': 3, 'b': 2}

 

>>> for k in sorted(D): print D[k],

 

1 2 3

 

 

 

 

Comprehensive loop examples

 

 

 

Matrix processing, with nested loops + comprehensions

 

 

    See on class CD: Extras\Code\Misc\matrix-code.py

 

 

 

Common ways to read from files

 

 

# file creation

 

>>> myfile = open('myfile.txt', 'w')

>>> for i in range(3):

        myfile.write(('spam' * (i+1)) + '\n')

>>> myfile.close()

 

 

# all at once

 

>>> print open('myfile.txt').read()

spam

spamspam

spamspamspam

 

 

# line by line

 

>>> myfile = open('myfile.txt')

>>> while True:

        line = myfile.readline()

        if not line: break

        print line,

 

spam

spamspam

spamspamspam

 

 

# all lines at once

 

>>> for line in open('myfile.txt').readlines():

        print line,

    

spam

spamspam

spamspamspam

 

 

# file iterators: line by line

 

>>> for line in open('myfile.txt'):

        print line,

    

spam

spamspam

spamspamspam

 

 

# by byte counts

 

>>> myfile = open('myfile.txt')

>>> while True:

        line = myfile.read(10)

        if not line: break

        print '[' + line + ']',

 

[spam

spams] [pam

spamsp] [amspam

]

 

 

 

 

Summing data file columns

 

 

>>> print open('data.txt').read()

001.1 002.2 003.3

010.1 020.2 030.3 040.4

100.1 200.2 300.3

 

>>> sums = {}

>>> for line in open('data.txt'):

        cols = [float(col) for col in line.split()]  # next!

        for pos, val in enumerate(cols):

            sums[pos] = sums.get(pos, 0.0) + val

 

>>> for key in sorted(sums):

        print key, '=', sums[key]

 

0 = 111.3

1 = 222.6

2 = 333.9

3 = 40.4

 

>>> sums

{0: 111.3, 1: 222.59999999999999, 2: 333.90000000000003,

3: 40.399999999999999}

 

 

 

 

 

Basic coding gotchas

 

 

 

    Don’t forget to type a “:” at the end of compound statement headers

    Be sure to start top-level (unnested) code in column 1

    Blank lines in compound statements are ignored in files, but end the statement at the interactive prompt

    Avoid mixing tabs and spaces in indentation, unless you’re sure what your editor does with tabs

    C programmers: you don’t need “( )” around tests in “if” and “while”; you can’t use “{ }” around blocks

    In-place change operations like list.append() and list.sort() don’t return a value (really, they return “None”); call them without assigning the result.

    Add parens to call a function: “file.close()” is a call, “file.close” is a reference only

 

 


 

Preview: program unit statements

 

 

    Create and process higher-level program components

 

 

 

Unit

Role

Functions

procedural units

Modules

code/data packages

Exceptions

errors and special cases

Classes

new objects

C modules

optimization, customization, integration

 

  

  

 

 

 

Lab Session 3

 

Click here to go to lab exercises

Click here to go to exercise solutions

Click here to go to solution source files

Click here to go to lecture example files