Today: more string algorithms, str in, if/else, quick-return, str.find(), slices

More detailed guides: Python-String, Python-If

Problems today:

> str2 functions

Patterns Foreach Accumulate

Loop over string, adding to result as we go.

• "Patterns" - common code forms
• Handy to know common patterns, idiomatic
• result = '' at start
• result += xxxxx in loop
• return result at end

String Functions

• s.isdigit() - is digit
• s.isalpha() - is alphabetic "word" char
• s.islower() - is lowercase version
• s.isupper() - is uppercase version
• s.lower() - return lowercase version
• s.upper() - return uppercase version

>>> 'a'.isalpha()
True
>>> '5'.isdigit()
True
>>> 'H'.isupper()
True
>>> 'H'.islower()
False
>>> 'H'.lower()
'h'
>>> 'H'.isalpha()
True
>>> 'a'.upper()
'A'
>>> '5'.isalpha()
False
>>> '5'.upper()  # other chars unchanged
'5'

alpha_up()

'12abc34' -> 'ABC'

Given string s. Return a string made of all the alphabetic chars in s, converted to uppercase form.

Use string functions .isalpha() and .upper()

Solution

def alpha_up(s):
    result = ''
    for i in range(len(s)):
        if s[i].isalpha():
            result += s[i].upper()
    return result

if Variation: if / else

if test:
  Lines-A
else:
  Lines-B

• See guide: Python-if
• Regular if - do the body lines, or do nothing
• if/else variant:
  Choose between 2 actions
  Always do one of them
• Run lines-A if test is True
• Run lines-B if test is False
• Style: use if/else to choose 1 of 2 actions
• Avoid using "else" if it is not needed
  The regular "if" we've seen is most common

str_dx()

'12abc34' -> 'ddxxxdd'

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

Solution code

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

catty()

'xCtxxxAax' -> 'CtAa'

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

• Compute lowercase version of each char
• Can write with "or"
• Can write with "in" - cute

Idea: Decomp By Var

• Use var= to improve code
• Use var = X to avoid duplication
• 1. Shorten the code
• 2. Variable name helps make it readable

• A handy style technique
• Some phrase X repeated in code
  e.g. below 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

Solution

def catty(s):
    result = ''
    for i in range(len(s)):
        # Create "low" var of intermediate result
        low = s[i].lower()
        if low == 'c' or low == 'a' or low == 't':
            result += s[i]  # Use original, not low
    return result
    # Cute non-obvious alternative: use "in"
    # to do the "or" logic for us, like this:
    # if low in 'cat':

Without Decomp-by-var

if s[i].lower() == 'c' or s[i].lower() == 'a' or s[i].lower() == 't':

With Decomp-by-var - better

low = s[i].lower()
if low == 'c' or low == 'a' or low == 't':

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
• Can write catty() which cute "in" trick above

>>> 'c' in 'abcd'
True
>>> 'bc' in 'abcd'
True
>>> 'bx' in 'abcd'
False
>>> 'A' in 'abcd'
False

Pattern: Quick Return

• Loop over, looking for X
  If find X, return answer immediately
• If there is no X found in loop
  Run return line after the loop - "not found" case

first_alpha()

'123abc' -> 'a'

Given a string s, return the first alphabetic char in s, or None if there is no alphabetic char. Demonstrates quick-return strategy.

Solution

def first_alpha(s):
    for i in range(len(s)):
        if s[i].isalpha():
            return s[i]
            # 1. Exit immediately if found
    # 2. If we get here,
    # there was no alpha char.
    return None

has_digit()

Use quick-return strategy, returning True or False.

Given a string s, return True if there is a digit in the string somewhere, False otherwise.

Solution - same pattern as first_alpha(), but returns boolean instead of a char

    for i in range(len(s)):
        if s[i].isdigit():
            # 1. Exit immediately if found
            return True
    # 2. If we get here,
    # there was no digit.
    return False

String find()

• s.find(target_str)- search s for target_str
• Returns int index where found, searching from start of s
• Or -1 if not found
• str noun.verb function call style (aka "object oriented")
• Alternate form: 2nd "start_index" parameter, starts search from there
  s.find(target_str, start_index) (use this later)

>>> s = 'Python'
>>> s.find('t')
2
>>> s.find('th')
2
>>> s.find('n')
5
>>> s.find('N')
-1
>>> s.find('x')
-1

Python String Slices

• This is a great feature
• Dense! i.e. slow down when writing a slice
• "substring" - contiguous sub-part of a string
• Access substring with 2 numbers
• "slice" uses colon to indicate a range of indexes
• s[1:3]
• Start at first number
• Up to but not including second number UBNI
• If start index is omitted, uses start of string
• If end index is omitted, uses end of string
• If number is too big .. uses end also
• Note perfect split: s[:4] and s[4:]
  Number used as both start and end
  Splits the str into 2 pieces
• 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]
'yt'
>>> s[1:5]
'ytho'
>>> s[1:1]    # "not including" dominates
''
>>>
>>> s[:3]     # omit = from/to end
'Pyt'
>>> s[4:]
'on'
>>> s[4:999]  # too big = to end
'on'
>>> s[:4]     # "perfect split" on 4
'Pyth'
>>> s[4:]
'on'
>>> s[:]      # the whole thing
'Python'

brackets()

A first venture into using index numbers and slices. Many, 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 .find()
  left = s.find('[')
• 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 Observations

• Make a diagram - 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

Solution

def brackets(s):
    left = s.find('[')
    if left == -1:
        return ''
    right = s.find(']')
    # Use slice to pull out chars between left/right
    # make a drawing!
    return s[left + 1: right]

Optional: Negative Slice

• We'll cover this someday maybe
• Optional / advanced shorthand
• 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.

>>> s = 'Python'
>>> s[len(s)-1]
'n'
>>> s[-1]
'n'
>>> s[-2]
'o'
>>> s[1:-3]
'yt'
>>> s[-3:]
'hon'