Computer Science 2500, Winter '08
Course Diary

---

Copyright 2008 by H.T. Wareham
All rights reserved

---

Week 1, Week 2, Week 3, Week 4, Week 5, (Class Exam #1 Notes),
Week 6, Week 7, Week 8, Week 9, (Class Exam #2 Notes),
Week 10, Week 11, Week 12, Week 13, (Final Exam Notes),
(end of diary)

Monday, January 7 (Lecture #1)
[Lang, Section 1; LutzL, Section 1; Class Notes]

• Gave overview of course.
• Why use Python?

Wednesday, January 9 (Lecture #2)
[Lang, Section 2; LutzL, Sections 2 and 3; Class Notes]

• Went over course outline.
• Introduction to Python
  • Invoking Python
    • Using the interpreter.
    • Python scripts
  • What Python can do for you: Some sample scripts
    • Example: Printing the square of 10 (sq.py).
    • Example: Printing the square of a command-line argument (sqarg.py).
      • Uses system list-variables sys.argv
        • sys.argv[0]: python script filename
        • sys.argv[i] i > 0: command-line argument i.
      • Note conversion using int() -- this means all command-line arguments are strings by default.
    • Example: Printing the squares of all command-line arguments (no error-handling) (sqargs1.py).
      • Note interesting for-loop -- is operating over a list!
      • What happens if there are no command-line arguments? If a command line argument is not a number?
    • Example: Printing the squares of all command-line arguments (with error-handling) (sqargs2.py).
      • Uses try-except construct; note how much simpler this is than error-handling in other languages, e.g., Java. a list!

Friday, January 11 (Lecture #3)
[Lang, Section 3.1.4; LutzL, Sections, 9; Class Notes]

• Introduction to Python (Cont'd)
  • Example: Printing the squares of all numbers in a single-column file (sqfile1.py) [sqfile1_1.dat), sqfile1_2.dat)].
    • Note how much simpler Python file I/O is than in other languages, e.g., Java.
  • Example: Printing the squares of all numbers in a file (sqfile2.py) [sqfile2_1.dat)].
    • Note how much simpler splitting lines into arguments is in Python than Java.
  • Example: Counting the number of occurences of the word "line" in a file (woc1.py) [woc.dat)].
    • Note how much simpler splitting lines into arguments is in Python than Java.
  • Example: Counting the number of occurences of a command-line specified word in a file (woc2.py) [woc.dat)].
    • Note how much simpler splitting lines into arguments is in Python than Java.
  • Example: Multiple transformations of 4-column datafile (i.e., delete 1st column, swap 2nd and 4th columns, scale 3rd column by factor) (filetran.py) [filetran.dat)].
    • Note list-assignment statement -- have you ever seen anything like this before?
• Having seen some of the neat things Python can do (in remarkably little (and eminently comprehensible) code), let's get a grounding in the fundamentals of Python, starting with file I/O.
• Basic Python I: Text File I/O
  • Two types of files in Python: text and binary. Focus on text for now, and will return to binary when we discuss object file storage in Python later in the course.
  • File access commands:
    • f = open(filename) / f = open(filename, "r"): Open file for reading.
    • f = open(filename, "w"): Open file for writing
      • Careful! If file already exists, will erase contents and re-open for writing.
    • f = open(filename, "a"): Open existing file for writing to end of that file, i.e., appending.
    • f.close()
      • Python automatically closes all files when a script finishes, so you don't have to do this; however, it is still a good habit to clean up after yourself.
    • f.flush()
      • Write I/O buffer to file
    • open-command actually has third buffer size argument; setting this to 0 means (in case of writing) given string is immediately written out (can be handy in long-running programs which, if they crash, can lose buffer contents -- however, doing this means your program loses the speed benefits of buffered I/O).
  • Note access to a file-object in these commands; this is one of the inbuilt types in Python. We'll look at more of these types (namely, strings and the various types of numbers) a week or so from now.
  • File read commands:
    • line = f.readline(): Read and return line from file.
      • Returns null / 0-length string "" at end of file.
    • lines = f.readlines(): Read and return file as list of lines.
    • line = f.read(): Read and return file as a string (which may contain multiple lines).
  • Example: Print file to screen using readline() (cat1.py)
    • Note use of while-loop
    • Python does not allow assignment statements inside conditions; hence, cannot use classic C / Java construct "while (line = f.readline()) ...".

Monday, January 14 (Lecture #4)
[Lang, Sections 3.1.2 and 3.1.4; LutzL, Sections 9 and 10; Class Notes]

• Basic Python I: Text File I/O (Cont'd)
  • All the preceding talk of lines in files begs the following question: what is a line in Python?
    • A line is a character-string with a special terminator-character (or characters).
    • Line-terminators in Python include '\0' (null / end-of-file), '\n' (newline), '\r' (carriage return), and '\r\n' (Microsoft end-of-line).
    • When Python reads a line from a file, it reads characters until it encounters a terminator and it includes that terminator at the end of the returned line (can get rid of this with rstrip(); this is particularly handy when using print, which adds its own newline).
  • Example: Print file to screen using readlines() (cat2.py)
  • Example: Print file to screen using read() (cat3.py)
  • File read commands:
    • f.write(s): Write string s to file.
    • print >> f, e: Write string specified by expression e to file.
  • Until we look at string formatting commands later in this course, the "print >> f" command is a great shortcut for printing stuff to files.
  • Example: File-copy using readlines and write (copy1.py)
  • Example: File-copy using readlines and "print >>" (copy2.py)
• Basic Python I: Control Structures
  • General notes
    • Syntax: header: block {subheader2: block2 ... }
    • Note that a header-line always terminates with a semicolon (":").
    • Block is sert of statements all indented the same.
    • Control structures can be nested -- indenting can vary by block, but it must be the same within each block.
    • Can have multiple stements on one line -- separate them by a semi-colon.
      • Do not need statement terminator semicolons -- Python will let you do it, but is not part of the Python aesthetic, i.e., Python is not C / C++ / Java.
    • How can you have one statement over multiple lines?
      • Old way: Use backslashes at end of lines to be continued.
      • New (and preferred) way: Enclose in parenthesis / be part of continued expression via comma, e.g., print-statement argument list, or square-bracket, e.g., list-specification.

Wednesday, January 16 (Lecture #5)
[Lang, Section 3.1.2; LutzL, Sections 12 and 13; Class Notes]

• Basic Python I: Control Structures (Cont'd)
  • Conditional branching: The if-elif-else statement
    • Header: if (condition): block {{elif (condition2): block2 ...} {else: block2 }}
    • Example: Classifying food items (version #1) (produce1.py)
    • Conditions are boolean expressions
      • Consists of one or more boolean expressions connected by logical operators (not, and, or).
      • Boolean expressions can be literals (true (non-zero) or false (zero)) or relational expressions, e.g., s < 10, tag == "AUT".
      • Lutz recommends that parentheses should only be used where absolutely necessary -- however, this can compromise vcode readability, and is in my opinion an example of pushing the Python aesthetic too far.
    • Example: Computing numeric to letter grades (version #1) (grades1.py)
    • Example: Computing numeric to letter grades (version #2) (grades2.py)
      • Checks for out-of-range grades and uses nice range-check syntax construct.
    • Example: Computing numeric to letter grades (version #3) (grades3.py)
      • Implements efficient version (to account for classes in which most grades are low).

Friday, January 18 (Lecture #6)
[Lang, Section 3.1.2; LutzL, Sections 12 and 13; Class Notes]

• Basic Python I: Control Structures (Cont'd)
  • Deterministic looping: The for statement (the partial story)
    • header: for in iterable-thingie: block
    • By iterable-thingie, we mean anythihng that is a set of elements that you can iterate over. We already know we can do it with lists and textfiles. As we will see in lectures to come, this is also true for many other structures in python, e.g., strings, dictionaries.
    • This is all well and good; however, suppose I actually want a for-loop over an index, going from a lower to an upper point by some increment?
      • Try "for x in range({lower,} upper {, increment})" (if you are dealing with integers).
      • Example: Classifying food items (version #2) (produce2.py)
      • Example: Evaluating nested summation expressions (evalsum.py)
      • A for-loop over a floating-point index is best coded as a while-loop.
    • What if you want to stop partway through, though?
      • Unlike C or Java, cannot modify for-loop execution to stop partway through (at least with a condition (see below))!
  • Conditional looping: The while statement (the partial story)
    • header: while condition: block
    • Useful if you don't know how many times you are looping, or if you want to stop partway through a process.
    • Example: Finding an element in a list (Version #1) (find1.py)
  • Loop modification: The break and continue statements
    • The break and continue statements are very restricted versions of the dread goto statement, and are arguably the last gasp of goto in modern programming language design.
    • The continue statement inside a loop causes execution to ignore the statements below the continue in the loop body and jump directly into the next loop iteration -- can save a level of if-nesting.
    • The break statement inside a loop causes execution to jump to the first stement after the loop, i.e., it stops loop iteration cold -- in a while-loop, can save a level of if-nesting and extra conditions in the loop-condition designed to stop iteration parttway through (and in the case of for-loops, is the only thing that can stop iteration short of sys.exit()).
      • In the case of nested loops, a break only terminates the innermost loop in which it is nested -- the other loops still continue on.
    • Example: Finding an element in a list (Version #2) (find2.py)
    • The break and continue statements are handy, but they make code less readable and there are valid alternatives in the language -- hence, they probably shouldn't be used that much and when they are, they should be used with care.
  • Looping (the full story): The else clause
    • Often when using break to stop a loop, we need to know afterwards whether or not break was executed during the loop, e.g., was the requested item found in the list or not? As we saw above, this can be simulated with a boolean variable and some additional if-logic. However, this construct is so common that Python provided an easier way -- the else clause!
    • The block associated with a loop else-clause only executes if the loop terminated normally.
    • Example: Finding an element in a list (Version #3a: while-loop) (find3a.py)
    • Example: Finding an element in a list (Version #3b: for-loop) (find3b.py)
    • Perhaps this is how we get rid of the break statement for once and for all -- however, should elimination of one piece of special-purpose language syntax be done by introducing yet another piece of special-purpose language syntax? This is something for you future script-language designers to mull over.
  • Doing nothing at all: The pass statement
    • Yes, this is the statement that does nothing at all -- why bother?
      • To satisfy Python syntax, i.e., catching an exception and doing nothing about it.
      • As a placeholder for code that will be written later.
    • Like break and continue, a handy statement on occasion, but it probably shouldn't be used that much, and when it is, it should be used with care.