Today: string in, if/elif, string .find(), slices

See chapters in Guide: String - If

String in Test

• String in - test if a substring appears in a string
• Chars must match exactly - upper/lower are considered different
• This is True/False test - use .find() (below) to know where substring is
• Mnemonic: Python re-uses the word "in" from the for loop
• Strategy: don't write code for something that Python has built-in

>>> 'Dog' in 'CatDogBird'
True
>>> 'dog' in 'CatDogBird'   # upper vs. lower case
False
>>> 'd' in 'CatDogBird'     # finds d at the end
True
>>> 
>>> 'i' in 'CatDogBird'
True
>>> 
>>> 'x' in 'CatDogBird'
False

Strategy: Built In Functions

Python has many built-in functions, and we will see all the important ones in CS106A. You want to know the common built-in functions, since using a built-in is far preferable to writing code for it yourself - "in" is a nice example. The "in" operators works for several data structure to see if a value is in there, and its use with strings is our first example of it.

Example: has_pi()

has_pi(s): Given a string s, return True if it contains the substrings '3' and '14' somewhere within it, but not necessarily together. Use "in".

> has_pi()

Note these functions are in the string-3 section on the Experimental server

boolean-test AND boolean-test

This form works in English but not in Python:

if '3' and '14' in s:   # NO does not work
    ... 

The and should connect two fully formed boolean tests, such as you would write with "in" or "==", so this works

if '3' in s and '14' in s:
    ...

Practice: has_first()

> has_first()

Example: catty()

> catty()

'xCtxxxAax' -> 'CtAa'

Return a string made of the chars from the original string, whenever the chars are one of 'c' 'a' 't', (either lower or upper case). So the string 'xaCxxxTx' returns 'aCT'.

Catty Version That Doesn't Work - V1

Here is a natural way to think of the code, but it does not work:

def catty(s):
    result = ''
    for i in range(len(s)):
        if s[i] == 'c' or s[i] == 'a' or s[i] == 't':
            result += s[i]
    return result
    

What is the problem? Upper vs. lower case. We are not getting any uppercase chars 'C' for example.

Catty Solution V2

Solution: convert each char to lowercase form .lower(), then test.

Solution - this works, but that if-test is quite long, can we do better?

def catty(s):
    result = ''
    for i in range(len(s)):
        if s[i].lower() == 'c' or s[i].lower() == 'a' or s[i].lower() == 't':
            result += s[i]
    return result

Idea: Decomp By Var

• The code is getting a little lengthy
• The repeated s[i].lower() is irksome
• Compute the value once, store in a variable
• Advantages
• 1. Shorten the code, less repetitive typing
• 2. Variable name helps the code "read" better
• 3. A sort of decomp within a function - break the big thing into little steps

Decomp Var Steps

• Some phrase X repeated in code
  e.g. s[i].lower()
• Used several times, or it's just wordy to type
• Create a variable, compute once and store
  low = s[i].lower()
• Use that variable on later lines
• Variable name noun - code "reads" better
• Aside: can name the var anything, and the code still works

Catty Solution V3 - Better

Start with the v2 code. Create variable to hold the repeated computation - shorten the code and it "reads" better with the new variable.

    low = s[i].lower()

The complete solution

def catty(s):
    result = ''
    for i in range(len(s)):
        low = s[i].lower()   # decomp by var
        if low == 'c' or low == 'a' or low == 't':
            result += s[i]
    return result

We will often do this with 106a code. If the solution is getting a little lengthy, introduce a variable for some part of the data like this.

Style: Variable Names

The name of a variable should label that value in the code, helping the programmer to keep their ideas straight. Other than that, the name can be short. The name does not need to repeat every true thing about the value. Just enough to distinguish it from other values in this algorithm.

1. Good names for this example, short but including essential details: low, low_char

2. Names with more detail, probably too long: low_char_i, low_char_in_s

3. Avoid this name: lower - name is ok, but avoid using a name which is the same as the name of a function, just to avoid confusion.

The V2 code above is acceptable, but V3 is shorter and nicer. The V3 code also runs faster, as it does not needlessly re-compute the lowercase form three times per char.

Recall If / Return Pickoff Strategy

The if/return "pick off" strategy is good strategy for a function. An if statement detects a case and returns the answer for that case. Later lines deal with other cases, and we have a sort of "none of the above" return at the bottom. Each return represents 1 of the n cases the function can handle. In this case, handling a case is also synonymous with leaving the function.

def foo():
    if case-1
        return case-1 result

    if case-2
        return case-2 result

    return none-of-above result

The if/elif structure below has the same 1-of-n-cases structure, but does not leave the function.

if/elif Structure

• if/elif structure - a series of if-tests
• Mentioning for completeness, we don't tend to use it
• The plain if-statement is used much more often
• Evaluate test1, test2, test3
• As soon as test is true
  Runs that action
  Exits the if/elif structure
  No further tests/actions will run
• Can be used in a loop to select 1 of n actions
• Optional "else:" at end runs if no test is true
• Mnemonic: "else" and "elif" are the same length

if test1:
  action-1
elif test2:
  action-2
else:
  action-3

Example: str_adx()

> str_adx()

str_adx(s): Given string s. Return a string of the same length. For every alphabetic char in s, the result has an 'a', for every digit a 'd', and for every other type of char the result has an 'x'. So 'Hi4!x3' returns 'aadxad'. Use an if/elif structure.

• If/elif logic to check for different char types
• alpha char → 'a', digit → 'd', otherwise → 'x'
• e.g. 'Z5$$t' → 'adxxa'

Solution

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

String find()

• s.find(target_str)- search s for target_str
• Returns int index where found first, searching from start of s
• Returns -1 if not found
• Alternate form: 2nd "start_index" parameter, starts search from there
  s.find(target_str, start_index) (use this later)

>>> s = 'Python'
>>> 
>>> s.find('th')
2
>>> s.find('o')
4
>>> s.find('y')
1
>>> s.find('x')
-1
>>> s.find('N')
-1
>>> s.find('P')
0

Strategy: Dense = Slow Down

• Some lines of code are routine
• Require just normal attention
• An advantage of using idiomatic phrases
  for i in range(len(s)):
• But some lines are dense
• Slow down for those, work carefuly
• Slices (below) are dense!
• Dense = Powerful!

Python String Slices

• This is a fantastic feature
• "substring" - contiguous sub-part of a string
• Access substring with 2 numbers
• "slice" uses colon to indicate a range of indexes
• s[1:3] returns 'yt'
• Start at first number
• Up to but not including second number UBNI
• s[3:3] = empty string
  "Not including" dominates the "starting at"
• Try it in the interpreter
• Style: typically written with no spaces around ":"

>>> s = 'Python'
>>> s[1:3]    # 1 .. UBNI
'yt'
>>> s[1:5]
'ytho'
>>> s[4:5]
'o'
>>> s[4:4]    # "not including" dominates
''

Slice Without Start/End

• If start index is omitted, goes from start of string
• If end index is omitted, goes through end of string
• If number is too big .. uses end also
  This is a little unusual
  In other cases, Python will halt with an error if an index is too big, but not with slices
• Note perfect split: s[:4] and s[4:]
  Number used as both start and end
  Splits the string into 2 pieces exactly

>>> s[:3]     # omit = from/to end
'Pyt'
>>> s[4:]
'on'
>>> s[4:999]  # too big = through the end
'on'
>>> s[:4]     # "perfect split" on 4
'Pyth'
>>> s[4:]
'on'
>>> s[:]      # the whole thing
'Python'

Example: brackets()

A first venture into using index numbers and slices. Many problems work in this domain - e.g. extracting all the hashtags from your text messages.

'cat[dog]bird' -> 'dog'

> brackets

• Problem spec: either 2 brackets, or zero brackets
• Strategy:
• Use s.find()
  left = s.find('[')
right = s.find(']')
• Switch between drawing and code
• Decomp by var
  Store in variable left for later lines
  Nice to have words left and right in code narrative
• Look for right bracket
• Use slice to pull out and return answer

Brackets Drawing

Brackets Observations

• Make a drawing - work out the index numbers
• Diagram / example strategy
• Code should work in general
• BUT can use specific string to work out numbers
• e.g. 'cat[dog]bird'
• Empty string input - works?
• What about input 'a[]z'
  Verify that our slice works here too

Brackets Solution

def brackets(s):
    left = s.find('[')
    if left == -1:
        return ''
    right = s.find(']')
    return s[left + 1:right]

Brackets Without Decomp-by-var

The variables left and right are a very natural example of decomp-by-var. In the code, the variables name an intermediate value that runs through the computation.

Below is what the code looks like without the variable. It works fine, and it's one line shorter, but the readability is clearly worse. It also likely runs a little slower, as it computes the left-bracket index twice.

def brackets(s):
    if s.find('[') == -1:
        return ''
    return s[s.find('[') + 1: s.find(']')]

The first solution with its variables looks better and is more readable.

Aside: Off By One Error

We have seen many examples of int indexing to access a part of a structure. So of course doing it slightly wrong is very common as well. So common, there is a phrase for it - "off by one error" or OBO — it even has its own wikipedia page. You can feel some kinship with other programmers each time you stumble on one of these.

"My code is perfect! Why is this not working? Why is this not work ... oh, off by one error. We meet again!"

Exercise: at_3()

Here is a problem similar to brackets for you to try. If we have enough time in lecture, we'll do it in lecture. A drawing really helps the OBO on this one.

> at_3

Exercise: parens()

> parens()

'x)x(abc)xxx' -> 'abc'

This is nice, realistic string problem with a little logic in it.

s.find() variant with 2 params: s.find(target, start_index) - start search at start_index vs. starting search at index 0. Returns -1 if not found, as usual.

Suppose we have the string '[xyz['. How to find the second '['?

>>> s = '[xyz['
>>> s.find('[')      # find first [
0
>>> s.find('[', 1)   # start search at 1
4

Thinking about this input: '))(abc)'. Starting hint code, something like this, to find the right paren after the left paren:

    left = s.find('(')
    ...
    right = s.find(')', left + 1)

Optional: Negative Slice

• Optional / advanced shorthand if we have time
• Handy way to refer to chars near end of string
• Negative numbers to refer to chars at end of string
• -1 is the last char
• -2 is the next to last char
• Works in slices etc.
• Maybe just memorize this one:
  s[-1] is the last char in s

>>> s = 'Python'
>>> s[len(s) - 1]
'n'
>>> s[-1]  # -1 is the last char
'n'
>>> s[-2]
'o'
>>> s[-3]
'h'
>>> s[1:-3]  # works in slices too
'yt'
>>> s[-3:]
'hon'