Today: realism, main args, nested loop parsing

How Do Command Line Arguments Work?

• Chronology of a program running...
• 1. Command line, starts the program
  python3 affirm.py -affirm Phil
• 2. Inside program:
  defs, functions calling other functions, parameters
• Q: What connects these two worlds?
• A: the main() function

Python-Main Guide

• Show the key code bits are show below
• See Python-Main for more details
• See "affirm" program example to run it yourself affirm.zip

Command Line Examples

-affirm and -hello options

$ python3 affirm.py -affirm Lisa
Everything is coming up Lisa
$ python3 affirm.py -affirm Bart
Looking good Bart
$ python3 affirm.py -affirm Maggie
Today is the day for Maggie
$ python3 affirm.py -hello Bob
Hello Bob
$

Command Line Option e.g. -affirm

• Often a command lines select certain options / modes
• e.g. -affirm
• Typically these start with a dash - a convention

main()

• When a program runs, what happens first?
• By convention, a function named "main()" runs
• It calls other functions to start everything

Command Line Args - args list

• Standard CS106A main() first line:
  args = sys.argv[1:]
  See the Python-main guide for explanation
• Sets up a list named args
• This list contains the command line args as string

$ python3 affirm.py -affirm Lisa
   ....
   e.g. args = ['-affirm', 'Lisa']


$ python3 affirm.py -affirm Bart
    ....
    e.g. args = ['-affirm', 'Bart']

Background: have print_affirm() etc. Functions to Call

Functions that do the work, main() will call them. In this case the functions are quite simple, but the key pattern is that main() can call functions, passing in the right data as their parameters.

def print_affirm(name):
    """
    Given name, print a random affirmation for that name.
    """
    affirmation = random.choice(AFFIRMATIONS)
    print(affirmation, name)


def print_hello(name):
    """
    Given name, print 'Hello' with that name.
    """
    print('Hello', name)


def print_n_copies(n, name):
    """
    Given int n and name, print n copies of that name.
    """
    for i in range(n):
        # Print each copy of the name with space instead of \n after it.
        print(name, end=' ')
    # Print a single \n after the whole thing.
    print()

How To Write main()

• If-statements in main() look at args
• One if-statement for each mode to detect
• Look at len(args)
• Look at args[0]
• Call functions based on args
  Pass in right data for each parameter

Code for -affirm

Make this command line work:

$ python3 affirm.py -affirm Lisa

• len(args) - the number of args
• args[0] - the first arg
• Strategy: check if there are 2 args and if first arg is '-affirm'
• The name to print is in args[1]

def main():
    args = sys.argv[1:]
    ....
    ....
    # 1. Check for the -affirm arg pattern:
    #   python3 affirm.py -affirm Bart
    #   e.g. args[0] is '-affirm' and args[1] is 'Bart'

    if len(args) == 2 and args[0] == '-affirm':
        print_affirm(args[1])

Code for -hello

    if len(args) == 2 and args[0] == '-hello':
        print_hello(args[1])

Last Time: all_brackets

Link to all_brackets() etc. from previous lecture > loop/break/parse problems

We got to this at the end

def all_brackets(s):
    search = 0
    result = []
    while search < len(s):
        left = s.find('[', search)
        if left == -1:
            break

        # Your code here
        right = s.find(']', left + 1)
        if right == -1:
            break
        result.append(s[left + 1:right])
        # Key: set up var at end of loop
        search = right + 1
    return result

What about that < vs. if/break

• What does that search < len(s) do?
• Turns out: nothing
• Try changing it to while True:
• Now the if/break logic takes care of exiting the loop always
• Think about the s = 'xxxx' - no '[' at all, trace the code
• Pattern:
  Use while True: at the top
  Use if/break logic inside the loop to detect "done" condition
• When to use if/break?
  If the done checking requires a couple steps
  e.g. calling s.find() and saving it in a var, as we have here
• For simple cases, while test: remains the easiest choice
• But we'll see more complex cases where if/break is required

Data and Parsing

Here's some fun looking data...

$GPGGA,005328.000,3726.1389,N,12210.2515,W,2,07,1.3,22.5,M,-25.7,M,2.0,0000*70
$GPGSA,M,3,09,23,07,16,30,03,27,,,,,,2.3,1.3,1.9*38
$GPRMC,005328.000,A,3726.1389,N,12210.2515,W,0.00,256.18,221217,,,D*78
$GPGGA,005329.000,3726.1389,N,12210.2515,W,2,07,1.3,22.5,M,-25.7,M,2.0,0000*71
$GPGSA,M,3,09,23,07,16,30,03,27,,,,,,2.3,1.3,1.9*38
$GPRMC,005329.000,A,3726.1389,N,12210.2515,W,0.00,256.18,221217,,,D*79
$GPGGA,005330.000,3726.1389,N,12210.2515,W,2,07,1.3,22.5,M,-25.7,M,3.0,0000*78
$GPGSA,M,3,09,23,07,16,30,03,27,,,,,,2.3,1.3,1.9*38
...

• The above is what a GPS chip outputs
  -buried deep in your phone, this is going on
• A standard: NMEA
  - NMEA_018 (wikipedia)
• It's just text!
  -a series of text lines
  -each line is made of chars
• Text is a common exchange format between systems
• "Parsing"
  -Have "raw" text like this
  -Find and pull out the data you want
• Big Data
• Analytics
• The first step every time...
• Parsing!
• Only then can we do analytics
• People want to work on like what color the lines in their great graph are
• Go look at that GPS data .. solve that first, then you can play with the colors

Parse-Words Example Functions

• We've reached the critical mass of features
  nested loops, break, list/append
• Today's functions are not easy
• Lab style - I'll demo, you try one
  Make drawing, think about code
• Then there's other problems for more practice
• Plus section

1. at_words(s)

• Demonstrate several patterns on this one
• Find all the @aaaa words in a string, return in a list
  Where 'a' is any alphabetic char
• 'xx @abc @ @xyz xx' -> ['abc', 'xyz']
• Not just the first word, all the words
• Establishes code patterns we'll re-use
• We'll work through this one carefully
• Points about this code:
  Keep "search" index - how far we are through s
  Use while True + if/break to detect done
  Use str.find() to locate each @
  Use a nested while to skip over alpha chars to find end
  Use < len(s) to protect use of s[]
  Remember to update "search" at loop bottom
  Var names: search, at, end - try to keep things straight

at_words(s): For each '@' in s, parse out the "word" substring of 1 or more alphabetic chars which immediately follow the '@', so '@abc @ @xyz' returns ['abc', 'xyz'].

Solution

def at_words(s):
    search = 0
    words = []
    while True:
        at = s.find('@', search)
        if at == -1:
            break
            
        # Pass over alpha chars to find end
        end = at + 1
        while end < len(s) and s[end].isalpha():
            end += 1
        
        word = s[at + 1:end]
        # Screen out len-0 word
        if len(word) > 0:
            words.append(word)
        
        # Set up next iteration
        search = end
    return words

at_word() #1 Done Test

• while True + if/break
• Think about the 'xxx' case
• Check that the if/break detects it
• Slight style preference order:
• 1. while/test does it without break .. the best
• 2. while/True with if/break if sufficient .. do that
• 3. while/test and also if/break .. the most complicated, only if necessary
• while/True + if/break is a common pattern

at_word() #2 Find End of Alpha Chars

• Consider the while loop to find the end of the alpha
• The following code looks reasonable
• This does not work .. why?

    while s[end].isalpha():
        end += 1

• Bug: run end off the end of s, testing non-existent s[end]
• e.g. s = '@abc'
  Think through how the loop works for that case
• Solution:
• Add guard < like this:
  while end < len(s) and s[end].isalpha():
• Only check s[end] after checking that end is valid
• Boolean Short Circuit
  Evaluate expression left-right
  As soon as boolean value determined, stops trying
  A False in the midst of an and stops
  So the < protects the s[end].isalpha()

at_word() #3 Observations

• Remember to update search= at end of loop! Infinite loop city!
• Here skipping over what we want, looking for first don't-want
• For later problems we'll see the opposite strategy:
  Skipping over what we don't want, looking for the first want

2. exclaim_words(s) - You Try It

• Like at_words, but right-left
• 'x hey!@ho! -> ['hey!', 'ho!']

exclaim_words(s): For each '!' in s, parse out the "word" substring of one or more alphabetic chars which are immediately to the left of the '!'. Return a list of all such words including the '!', so 'x hey!@ho! returns ['hey!', 'ho!']. (Like at_words, but right-to-left)

3. parse_words(s)

• Work this one as a demo
• The '@' to mark start is not realistic!
• e.g. we should be able to parse words without @
  '^^^abc xyz$' -> ['abc', 'xyz']
• Sketch out what the loops do, search/begin/end vars
• Have the outside while True: loop
• Now - 2 forms of while/skip inside
  Inner-loop-1 to find the first alphabetic char
  Inner-loop-2 to find the end of the word
• Sometimes skip over chars you want
• Sometimes skip over chars you don't want
• Lines which use s[xxx] have a xxx < len(s) guard

parse_words(s): Given a string s, parse out and return all "words", where a word is made of 1 or more adjacent alphabetic chars, so '^ abc xyz$' returns ['abc', 'xyz'].

Solution

def parse_words(s):
    search = 0
    words = []
    while True:
        # Find a first alpha char (note: not)
        begin = search
        while begin < len(s) and not s[begin].isalpha():
            begin += 1
        
        # No alphas found -> done
        if begin >= len(s):
            break
        
        # Move end past the group of alphas
        end = begin + 1
        while end < len(s) and s[end].isalpha():
            end += 1
        
        # Now we know where it is
        word = s[begin:end]
        words.append(word)
        search = end + 1
    return words

More Practice Problems

A first goal is being able to solve 1-3, which are hard enough. Later we may look at the 4-7 problems.