Today: string char class, more string loops, if/else, Doctests, grid, peeps example

Strategy - Code Patterns

• Patterns - when writing code, think of similar problems solved before
• Code has some stock/common parts, and some novel parts
• I have a string and I want to look at each char to build a result
  double_char() lays out a basic pattern for this
• Re-use the basic code from double_char(), add in custom code

Recall: double_char(s) Example/Pattern

> double_char

Pattern for: look at every char in a string, build up a result string.

1. Loop over all the chars: for i in range(len(s))

Use in the loop: s[i]

2. Build up result string. result = '' to start. In the loop: result += xxx

def double_char(s):
    result = ''
    
    for i in range(len(s)):
        result += s[i] + s[i]
    
    return result

Pattern strategy: problems below where we look at each char, we'll think back to the double_char() code as a first step.

String Character Class Tests

• A string is made of characters, aka chars
• Characters are divided into character classes:
• 1. Alphabetic - e.g. 'a', 'k', 'Z' .. used to make words
• 2. Digits - '0' '1' .. '9' used to make numbers
• 3. Space - space ' ' , newline '\n' tab '\t', - aka "whitespace"
  Newline '\n' is char from the return/enter key on keyboard
  The backslash form '\XXX` is a way to write special characters, e.g. '\n' is newline
• 4 Misc - '$' '%' ';' ... miscellaneous chars not in the first 3 categories
• There are noun.verb tests s.isalpha() s.isdigit() s.isspace() returning boolean True or False if a char is in a category
  There is not a test for "misc", which is just a char which is not alpha or digit or space
• For empty string these return False (a weird edge case)

s.isalpha() - True for alphabetic word char, i.e. 'a-z' and 'A-Z'. Python uses "unicode" to support many alphabets, e.g. 'Ω' is another alphabetic char.

s.isdigit() - True if all chars in s are digits '0' '1' .. '9'

s.isspace() - True for whitespace char, e.g. space, tab, newline

>>> 'a'.isalpha()
True
>>> '$'.isalpha()
False
>>> 'abc'.isalpha()  # works for multiple chars too
True
>>> 'Z'.isalpha()
True
>>> 'Ω'.isalpha()  # Greek Omega char (unicode)
True
>>> '水'.isalpha()  # Mandarin "water" char (unicode)
True
>>> '9'.isdigit()
True
>>> 'Ω'.isdigit()
False
>>> ' '.isspace()
True
>>> '\n'.isspace()
True
>>>

(demo/exercise) alpha_only(s)

> alpha_only

'H4ip$' -> 'Hip'
'12ab34ba' -> 'abba'

Hint: Use if-logic on each char. Use s[i].isalpha() to test each char

• Given string s
• Return a string of the alphabetic chars in s
• e.g. 'H4ip$' returns 'Hip'
• Use the standard for/i/range loop
• If logic inside the loop
  Control if a char is added to result or not
• The double_char() code sets the pattern - look at every char
• Example or exercise
  First step - build straight copy of s
  Second - add logic to grab only alpha chars

Aside: handy lecture music during coding exercises - Creative Commons (CC) licensed music.

alpha_only() Solution

def alpha_only(s):
    result = ''
    
    # Loop over all index numbers
    for i in range(len(s)):
        # Access each s[i]
        if s[i].isalpha():
            result += s[i]
    
    return result

Regular if

Just as a reminder, here is the regular if-statement we've used many times. If the test is True, the lines are run. Otherwise if the test is False, the lines are skipped.

if test-expression:
  lines

One of: (1) run lines, (2) do nothing

if Variation: if / else

See guide for more if/else details: Python-if

Adding the else: clause to the if-statement:

if test-expression:
  lines-1  # run if test True
else:
  lines-2  # run if test False

One of: (1) run lines-1, (2) run lines-2

• if/else variant:
  There are two sets of lines to control, lines-1 and lines-2
• Run lines-1 if test is True
• Run lines-2 if test is False
• Use the if/else form if...
  There are 2 possible actions
  You always want to run one action or the other
• The regular if with 1 action is more common
• There is a more rare "elif" option we may cover later
• You do not need to use "else" on HW2
• Nick's slight preference: if you can write it without "else", do so
  Reserve "else" for the cases where it's required

Example: str_dx()

> str_dx

'1a24$' -> 'dxddx'

• Return string where every digit changes to 'd'
  And every other char changed to 'x'
• e.g. 'ab42z' returns 'xxddx'
• Use if/else

str_dx() Solution

def str_dx(s):
    result = ''
    for i in range(len(s)):
        if s[i].isdigit():
            result += 'd'
        else:
            result += 'x'
    return result

else vs. not

Suppose you want to do something if a test is False. Sometimes people sort of back into using else to do that, like the following, but this is not the best way:

if some_test:
     pass  # do nothing here
else:
     do_something

The correct way to do that is with not:

if not some_test:
    do_something

Early-Return Strategy

The double_char code needs to go all the way to its last line to have its answer.

BUT sometimes an algorithm can figure out an answer earlier, using a return in that case to provide an answer without running the lines below. This is form of the pick-off strategy where sometimes we figure out the answer early.

has_alpha() Logic

You know at some level that the interior of the computer is very logical. This problem embodies that theme of very neat, sharp logic.

Consider this function:

> has_alpha

has_alpha(s): Given string s. Return True if there is an alphabetic char within s. If there is no alphabetic char within s, return False.

'3$abc' -> True
'42$@@' -> False

We might say this algorithm is like the book Are You My Mother?

has_alpha() Cases

Think about solving this problem. Look through the chars of the string. When do you know the answer?

Logic strategy: look at each char. (1) If we see an alpha char, return True immediately. We do not need to look at any more chars. (2) If we look at every char, and never see an alpha char, must conclude that there are no alpha chars and the result should be False. The (1) code goes in the loop. The (2) code goes after the loop - a sort of "by exhaustion" strategy.

has_alpha() Solution

def has_alpha(s):
    for i in range(len(s)):
        if s[i].isalpha():
            # 1. Return True immediately if find
            # alpha char - we're done.
            return True
    # 2. If we get to here, there was no
    # alpha char, so return False.
    return False

Big Picture - Program, Functions, Testing

Big Picture - program made of many functions. Want to build out the functions efficiently, concentrating on one function at a time.

How Do You Know A Function is Correct?

Bad news: You can't tell if a function is correct by looking at it.

Function Test - Cases - input/output pairs

Good news: It's pretty easy to have a few input/output tests for a function. Tests don't prove 100% that the function is correct, but in practice they work very well.

We're going to show you have to run and write your own function tests in Python. Python is very advanced for this - tests are easy to write, easy to run.

Old Days

In the old days, you could write separate functions, but it was hard to test them one at a time. You would end up testing the functions all together, and so you would have bugs in function a() and at the same time bugs in b(). The output would be a mixture of both bugs interfering with each other. It could be a real disaster. Now we can test each function on its own. Much better!

Tests - Work One Function at a Time

• Divide and Conquer strategy
• Divide program into many functions
• Work on one function at a time
  Deal with each function at a time
  Ideally test that function at the same time
• Write helper functions first, test them
• Later functions can call the helpers after they are tested
• Avoid debugging multiple functions at once
• Today: Python Doctest system for testing a function as you go

str1 project

• If you want to try this example yourself
• Download str1.zip project
• Expand to get "str1" folder
• Open the str1 folder in PyCharm, look at str1.py code

Aside: Fix for "No Interpreter"

If it says "no interpreter" at the lower right of PyCharm window. Click it. Select a recent Python version, such as 3.11 or 3.12. If they are not in the list, click Add Local Interpreter. Then System Interpreter, and select a python3 version. Any recent python3 version is fine. On my laptop, the most recent has the cryptic name "/usr/bin/python3"

digits_only(s) Function

We'll use this function to see how tests work.

Given string s, return a string of its digit chars.

'Hi4x3' -> '43'

Python Function Doctests

Doctests are the Python technology for easily testing a function.

For more details, see the Doctest chapter in the guide

• Look at the digits_only() or str_dx() functions
• Look at the triple-quote """Pydoc""" of each
• Each ">>>" phrase is a test known as a Doctest

digits_only(s)

def digits_only(s):
    """
    Given a string s.
    Return a string made of all
    the chars in s which are digits,
    so 'Hi4!x3' returns '43'.
    Use a for/i/range loop.
    (this code is complete)
    >>> digits_only('Hi4!x3')
    '43'
    >>> digits_only('123')
    '123'
    >>> digits_only('xyz')
    ''
    >>> digits_only('')
    ''
    """
    result = ''
    for i in range(len(s)):
        if s[i].isdigit():
            result += s[i]
    return result

Python Function - Doctest

Here are the key lines that make one Doctest:

    >>> digits_only('Hi4!x3')
    '43'

• That syntax spells a test of 1 case
• Looks like a function call
• Input between the parens
• Output on the next line
• Very much in the black-box view of a function - input and outputs
• (Interpreter needs to be set for this to work - lower right of PyCharm window)
• In PyCharm:
  Right click on the text of the Doctest
  Select "Run Doctest ..."
  Sometimes need to click a second time - PyCharm quirk
• Success: little green checkmark below the code area
  "Tests passed, 4 of 4"
  That means it worked perfectly
  This message could be more fun about the result!
• Otherwise: "Tests failed" in red
  Scroll down to see the input / expected / got data
  Look at got - your code produced that - why?
• Experiment: try putting in a bug, run Doctest, fix the bug
• Protip:
  Green "play" button at left re-runs most recent test
  Even better: ctrl-r (see top of Run menu for the keystroke for your machine)
  Re-running tests is super-common, so have a quick way to do it
• Aslo, can right-click at another place in the file .. run all the tests in the file

Doctest Command Line

Usually we run Doctests from within PyCharm. It's also possible to run from the command line like this:

$ python3 -m doctest str1.py 

The output is nothing if the tests pass, otherwise it lists all the failures. This runs all the tests in the file.

Workflow: Functions with Tests

• Starting work on a function
• Write two or three Doctests first, before writing code
• Start with a "basic" looking test like: 'Hi4!x3'
• Add an "edge" case tests, e.g. empty string '', or 'aaa', or '123'
• Work on the code, run the tests to see where you are
  Debugging with these little tests is relatively easy
  Use green triangle button to re-run easily (control-r may work too)
• Eventually the tests pass and you're done!
• Green Checkmark!

We'll use Doctests to drive the examples in section and on homework-3.

Grid - Peeps Example

Today's grid example peeps.zip

Grid - 2D Algorithms

• We have done lots of 2D algorithms on images
  Always with RGB input/output
  Nice, but just one corner of 2D algorithms
• Grid - generic 2D facility
• In the grid.py file
• 2D storage of string, int, .. anything
• Reference: Grid Reference

Grid Functions

• grid = Grid(3, 2) - create, all squares None initially
• Zero based x,y coordinates for every square in the grid:
  origin at upper left
  x: 0..grid.width - 1
  y: 0..grid.height - 1
• grid.width, grid.height - access width or height
• grid.get(0, 0) - returns contents at x,y (error if out of bounds)
• grid.set(0, 0, 'a') - set at x,y
• grid.in_bounds(2, 2) - return True if x,y is in bounds

Grid Example Code

grid = Grid(3, 2)
grid.width # returns 3
grid.set(2, 0, 'a')
grid.set(2, 1, 'b')

grid.get(2, 0)  -> 'a'
grid.in_bounds(2, 0) -> True
grid.in_bounds(3, 0) -> False

Grid of Peeps

Suppose we have a 2-d grid of peeps candy bunnies. A square in the grid is either 'p' if it contains a peep, or is None if empty.

Does This x, y have a Happy Peep?

We'll say an x, y has a happy peep, if that square contains a peep and there is another peep immediately to its left or right.

Look at the grid squares again. For each x, y .. is that a happy peep x, y?

x, y happy?
(top row)
0, 0 -> False (no peep there)
1, 0 -> True
2, 0 -> True

(2nd row, nobody happy)
0, 1 -> False
1, 1 -> False
2, 1 -> False

is_happy(grid, x, y) Plan

• Build the is_happy(grid, x, y) function
• Write Doctests to check its output
• Need to be able write out a little grid for the tests

First Need: Grid Square Bracket Syntax

Here is the syntax for the above grid. The first [ .. ] is the first row, the second [ .. ] is the second row. This is fine for writing the data of a small grid, which is good enough for writing a test.

grid = Grid.build([[None, 'p', 'p'], ['p', None, 'p']])

is_happy() Step 1 - Doctests

def is_happy(grid, x, y):
    """
    >>> grid = Grid.build([[None, 'p', 'p'], ['p', None, 'p']])
    >>> is_happy(grid, 0, 0)
    False
    >>> is_happy(grid, 1, 0)
    True
    >>> is_happy(grid, 2, 0)
    True
    >>> is_happy(grid, 0, 1)
    False
    >>> is_happy(grid, 2, 1)
    False
    """
    pass

Checking 5 representative squares. Removed """doc words""" so tests and drawing fit on screen at once.

Write is_happy() Code

This is important example, showing the best-practice workflow for building complex code.

We have tests and no code. Run the tests, see the test failures. Use if/pick-off strategy to add in code to fix problems prompted by the test failures.

• Use the if/return pick-off strategy
• Run
• Failed: output is nothing
• 1. Pick off the case where x,y is not a peep, return False
• Run
• Failed: (1, 0) should be happy
• 2. Look for another peep to right of x, y, happy if found
  What does "right" mean? .. x + 1
  Return True if peep at x + 1
  Return False at the bottom
• Run .. (1, 0) correct now
• Failed: (2, 0) is crashing
• 3. Add in-bounds check
  Look at failure
  Code crashes with out of bounds get(2, 0)
  Add a check that x + 1 is in bounds before calling get()
• Run
• Failed: (2, 0) returns False, should be True
• 4. Need to look for peep to the left, x - 1
  Add code to look to the left, which is x - 1
• Run .. all tests pass, it works!

Workflow — Run, look at the top failed case. Look at the wrong output and the code that produced it to think of your next step. Easier to do this than staring at a blank screen. Also we are more confident it's right when we're done, since we do have a range of tests.

is_happy() Code v1

This code is fine. Using the "pick-off strategy, looking for cases to return True. Then return False as the bottom if none of the cases found another peep.

def is_happy(grid, x, y):
    """
    Given a grid of peeps and in bounds x,y.
    Return True if there is a peep at that x,y
    and it is happy.
    A peep is happy if there is another peep
    immediately to its left or right.
    >>> grid = Grid.build([[None, 'p', 'p'], ['p', None, 'p']])
    >>> is_happy(grid, 0, 0)
    False
    >>> is_happy(grid, 1, 0)
    True
    >>> is_happy(grid, 2, 0)
    True
    >>> is_happy(grid, 0, 1)
    False
    >>> is_happy(grid, 2, 1)
    False
    """
    # 1. Check if there's a peep at x,y
    # If not we can return False immediately.
    if grid.get(x, y) != 'p':
        return False

    # 2. Happy because of peep to right?
    # Must check that x+1 is in bounds before calling get()
    if grid.in_bounds(x + 1, y):
        if grid.get(x + 1, y) == 'p':
            return True

    # 3. Similarly, is there a peep to the left?
    if grid.in_bounds(x - 1, y):
        if grid.get(x - 1, y) == 'p':
            return True

    # 4. If we get to here, not a happy peep,
    # so return False
    return False

is_happy() Using and

The in_bounds() checks can be done with and instead nesting 2 ifs. This works because the "and" works through its tests left-to-right, and stops as soon as it gets a False. This code is a little shorter, but both approaches are fine.

    # 2. Happy because of peep to right?
    # here using "and" instead of 2 ifs
    if grid.in_bounds(x + 1, y) and grid.get(x + 1, y) == 'p':
        return True

Example - has_happy()

(Do this if we have time.)

Say we want to know for one column in the grid, is there a happy peep in there? A column in the grid is identified by its x value - e.g. x == 2 is one column in the grid.

Below is the def for this. The parameters are grid and x - the x identifies the column to check. The return True/False strategy is similar to the one seen in the has_alpha() example above. Doctests are provided, write the code to make it work.

def has_happy(grid, x):
    """
    Given grid of peeps and an in-bounds x.
    Return True if there is a happy peep in
    that column somewhere, or False if there
    is no happy peep.
    >>> grid = Grid.build([[None, 'p', 'p'], ['p', None, 'p']])
    >>> has_happy(grid, 0)
    False
    >>> has_happy(grid, 1)
    True
    """
    # your code here
    pass

has_happy() Solution

def has_happy(grid, x):
    """
    Given grid of peeps and an in-bounds x.
    Return True if there is a happy peep in
    that column somewhere, or False if there
    is no happy peep.
    >>> grid = Grid.build([[None, 'p', 'p'], ['p', None, 'p']])
    >>> has_happy(grid, 0)
    False
    >>> has_happy(grid, 1)
    True
    """
    # x is specified in parameter, loop over all y
    for y in range(grid.height):
        if is_happy(grid, x, y):
            return True
    # if we get here .. no happy peep found
    return False

Doctest Strategy

We're just starting down this path with Doctests. Doctests enable writing little tests for each black-box function as you go, which turns out to be big productivity booster. We will play with this in section and on homework-3.