Today: string in/not-in, foreach, start lists, how to write main()

More String Features

See "string4" on server - examples of features below: "foreach" and "in"

String in Test

• The word in - Boolean test if a substring appears in a string
  Essentially: does the small thing appear in the big thing
• Mnemonic: same word inside for-loop, like Python wants to introduce very few new words
• Chars must match exactly - upper/lower are considered different
• Python in test works for other structures too, but here look at string

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

Variant: not in

The form not in inverts the in test, True if the small thing is not in the big thing. Say for example we have a string of bad_chars, and we want to print a char if it is not bad. Using the "not in" form, the code reads very nicely.

if ch not in bad_chars:
    print(ch)

We could use regular "in", and then add a "not" to its left, like the following form. This works, but the above form is the preferred style and reads better.

if not ch in bad_chars:
    print(ch)

Aside: Case-Sensitive vs. Case-Insensitive

In Python 'a' and 'A' are not equal, and so 'apple' and 'Apple' are two different strings. This is called "case-sensitive", and it is the default behavior in Python. If a problem does not state anything about case-sensitivity, assume case-sensitive, which is generally the easier form to compute.

If an algorithm does extra work to treat 'a' and 'A' the same, that is called the "case-insensitive" approach, and it is generally more work. If we want your code to compute something case-insensitive, we will always say so explicitly in the problem description.

String foreach

• We have used for/i/range to index into string
• This highlighted the role of index numbers in string algorithms
  Which we wanted to do, to fit with find() and slices
• There is a simpler way to loop over the chars in a string
• for ch in s:
  aka the "foreach" loop
  Loops over all the chars in s, left to right
  You do not get the index number here, just the char
  No square brackets [ ] in this form
• The variable name ch or char is idiomatic for one character
• Use this form if you do not need access to index numbers
• Use the for/i/range form if you need access to index numbers

for ch in s:
    # use ch in here,
    # will be one char from s

Example 1: double_char2()

Like earlier double_char, but using foreach.

Solution

def double_char2(s):
    result = ''
    for ch in s:
        result = result + ch + ch
    return result

Example 2: intersect(a, b)

Demonstrates both foreach and in

intersect(a, b): Given two strings, a and b. Return a version of a, including only those chars which also appear in b. Use a case-sensitive comparison. Use a for/ch/s loop.

Solution

def intersect(a, b):
    result = ''
    # Look at all chars in a, check
    # each using "in"
    for ch in a:
        if ch in b:
            result += ch
    return result

Python Lists

See the guide: Python List for more details about lists

• A list a linear collection of any type of python value
  The formal name of the type is "list"
• A very common type, up there with int and string
• Use list to store many of something
  e.g. a thousand urls - a list of url strings
  e.g. a million temperature readings - a list of float values
• Things in a list are called "elements"
• Theme: python tries to be uniform:
  len(), square brackets .. list works the same as string
• "lst" is a generic list variable name

Examples on Server list1

See the "list1" examples on the experimental server

• list_n() - create list [0, 1, 2, 3, ..n-1] - use range() and append()
• donut_index() - use "in" and index()
• list_censor() - use everything

1. List Literal: [1, 2, 3]

Use square brackets [..] to write a list in code (a "literal" list value), separating elements with commas. Python will print out a list value using this same square bracket format.

>>> lst = ['a', 'b', 'c', 'd']
>>> lst
['a', 'b', 'c', 'd']
>>> 

"empty list" is just 2 square brackets with nothing within: []

2. Length of list: len(lst)

Use len() function, just like string. As a nice point of consistency, many things that work on strings work the same on lists - they are after all both linear collections using zero-based indexing.

>>> len(lst)
4

3. Square Brackets to access element

Use square brackets to access an element in a list, like string again (bad index err possible). Valid index numbers are 0..len-1.

>>> lst[0]
'a'
>>> lst[2]
'c'
>>> lst[9]
Error:list index out of range

List Mutable

The big difference from strings is that lists are mutable - lists can be changed. Elements can be added, removed, changed over time. We'll look at four list features.

1. List append()

• Lists can contain any type (today int, str)
• lst.append('something') - adds an elem to end of list
• Modifies the list, returns nothing
• Common list-build pattern:

# 1. make empty list, then call .append() on it
>>> nums = []         
>>> nums.append(1)
>>> nums.append(2)
>>> nums.append(3)
>>> 
>>> lst
[1, 2, 3]
>>> len(lst)
3
>>> lst[0]
1
>>> lst[2]
3
>>>
# 2. Similar, using loop/range to call .append()
>>> nums = []
>>> for i in range(6):
...     nums.append(i * 10)
... 
>>> nums
[0, 10, 20, 30, 40, 50]
>>> len(nums)
6
>>> nums[5]
50

Example: list_n()

See the "list1" section on the experimental server.

list_n(n): Given non-negative int n, return a list of the form [0, 1, 2, ... n-1]. e.g. n=4 returns [0, 1, 2, 3] For n=0 return the empty list. Use for/i/range and append().

Solution

def list_n(n):
    nums = []
    for i in range(n):
        nums.append(i)
    return nums

2. List "in" / "not in" Tests

• How to tell if a value is in a list?
  hint: like string!
• The in operator tests if a value is in a list
• not in works too, reads nicely
• Style preference
  x not in lst - preferred form
  'not x in lst` - equivalent, but not preferred (applies to string too)

>>> lst = ['a', 'b', 'c', 'd']
>>> 'c' in lst
True
>>> 'x' in lst
False
>>> 'x' not in lst  # preferred form to check not-in
True
>>> not 'x' in lst  # equivalent form
True

3. Foreach On List

• for "foreach" loop works on a list
• for var in list:
• Probably the most common loop form
  Many algorithms want to look at every element
• The variable points to each element in turn, one element per loop
• No Change do not change the list - add/remove/change - during iteration
  Kind of reasonable rule: how would iteration work if elements left and appeared in the midst of iteration

>>> lst = ['a', 'b', 'c', 'd']
>>> for s in lst:
...   # use s in here
...   print(s)
... 
a
b
c
d

4. list.index(target) - Find Index of Target

• Similar to str.find(), but with one big difference
• list.index(target) - returns int index of target if found
• Flaw: list.index() only works if the target is in the list, failing with an error otherwise
• Code should check with in first, only call lst.index() if in is True
• This design is annoying
  It would be easier if lst.index() just returned -1, but it doesn't
• Variant: list.index(target, start_index) - begin search at start_index instead of 0

>>> lst = ['a', 'b', 'c', 'd']
>>> lst.index('c')
2
>>> lst.index('x')
ValueError: 'x' is not in list
>>> 'x' in lst
False
>>> 'c' in lst
True

Example: donut_index(foods)

donut_index(foods): Given "foods" list of food name strings. If 'donut' appears in the list return its int index. Otherwise return -1. No loops, use .index(). The solution is quite short.

Solution

def donut_index(foods):
    if 'donut' in foods:
        return foods.index('donut')
    return -1

Example: list_censor()

list_censor(n, censor): Given non-negative int n, and a list of "censored" int values, return a list of the form [1, 2, 3, .. n], except omit any numbers which are in the censor list. e.g. n=5 and censor=[1, 3] return [2, 4, 5]. For n=0 return the empty list.

Solution

def list_censor(n, censor):
    nums = []
    for i in range(n):
        # Introduce "num" var since we use it twice
        # Use "in" to check censor
        num = i + 1
        if num not in censor:
            nums.append(num)
    return nums

Style Note: Lists and the letter "s"

As your algorithms grow more complicated, with three or four variables running through your code, it can become difficult to keep straight in your mind which variable, say, is the number and which variable is the list of all the numbers. Many little bugs have the form of wrong-variable mixups like that.

Therefore, an excellent practice is to name your list variables ending with the letter "s", like "nums" above, or "urls" or "weights". Then when you have an append, or a loop, you can see the singular and plural variables next to each other, reassuring that you have it right.

    url = (some crazy computation)
    urls.append(url)

Or like this

    for url in urls:

Constants in Python

STATES = ['CA, 'NY', 'NV', 'KY', 'OK']

• Simple form name=value at far left, not within a def
• This is a type of "global" variable
• A variable not inside a function
• In this case it is a constant for the program
• Functions can just refer to STATES to get its value
• Python Convention: upper case means its a constant
• Style: it's a read-only value, code should not modify it

ALPHABET Constant in HW4

# provided ALPHABET constant - list of the regular alphabet
# in lowercase. Refer to this simply as ALPHABET in your code.
# This list should not be modified.
ALPHABET = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z']

...

def foo():
    for ch in ALPHABET:  # this works
        print(ch)

If we get through this on Fri fine, otherwise we'll do it monday.

How Do Command Line Arguments Work?
How to write main() code?

For details see guide: Python main() (uses affirm example too)

affirm.zip Example/exercise of main() command line args. You can do it yourself here, or just watch the examples below to see the ideas.

First Run To See The Arg

First run the code, see what the command line arguments (aka "args") do:
-affirm and -hello options (aka "flags")

$ 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 or modes of the program
• e.g. -affirm tells the program to print an affirmation
• The convention is that each option starts with a dash, e.g. -affirm
• These are also known as "flags"

The "args" To a Program

The command line arguments, or "args", are the extra words you type on the command line to tell the program what to do. The system is deceptively simple - the command line arguments are just the words after the program.py on the command line, separated from each other by spaces. So in this command line:

$ python3 affirm.py -affirm Lisa

The words -affirm and Lisa are the 2 command line args.

args Python List

When a Python program starts running, typically the run begins in a special function named main(). This function can look at the command line arguments, and figure out what other functions to call.

In our main() code the variable args is set up as a Python list containing the command line args.

$ 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

For this example, say we have functions print_affirm(name) and print_hello(name) which are already written. The main() function will look at the args and call the appropriate functions. The key pattern is that main() can call functions, passing in the right data as their parameters.

Functions to call:

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()

• args is a Python list of the args typed on the command line
• Each typed arg is a string in the list
• If-statements in main() look at args
• One if-statement for each option/flag
• Demo: in main() try print(args) to see the args list in action
• (affirm.py code is done, use affirm-exercise.py to write the code)
• Look at len(args)
• Look at args[0]
• Call functions based on args
  Pass in right data for each parameter

Exercise 1: Make -affirm Work

Make this command line work, editing the file affirm-exercise.py:

$ python3 affirm-exercise.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]

Solution code

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])

Exercise 2: Make -hello Work

Write if-logic in main() to looking for the following command line form, call print_hello(name), passing in correct string.

$ python3 affirm-exercise.py -hello Bart

Solution code

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

Exercise 3 (optional): Make -n Work

In this case, the function to call is print_n_copies(n, name), where n is an int param, and name is the name to print. Note that the command line args are all strings.

$ python3 affirm-exercise.py -n 10000 Hermione