def NAME(PARAMATER1, PARAMATER2, ...):
  """
  Purpose
  Parameter description
  Return value description (if any)
  """
  #DO STUFF
  return VALUE #optional

while <COND>:
  <BODY>

Take a look at while_loops.py for some examples of while loops. Some can easily be implemented using a for loop instead. Some cannot. When are while loops needed? Are there cases where a for loop does things a while loop cannot?

Exercise:

Open the program while_exercise.py and implement a function getPositiveInteger() using a while loop.

Modifying Parameters

What is the result of modifying the parameter variable for a function? Do the results effect the arguments in the original calling function, or are all changes ignored? We will explore this question in more depth this week.

Take a look at oops_squareFunc.py, which squares the parameter values in a function. What do you think will happen at the end of this program? Test it out and then we will trace through the program to see what happened.

Immutable data types (float,str,int,bool) can never be modified; thus, any changes to the variable require reassigning it a new value. Reassignment breaks any sharing of values between the parameter and its original argument.

Mutable data types are different - they can be modified without reassignment. As an example, we will return to the list datatype and see its methods.

Lists

Lists are a data type in Python that hold a collection of items. Lists are a type of sequence of items. As we will see, many of the methods we use on strings can also be used on lists, since both are sequences. There are two major differences between lists and strings: lists are a sequence of items where the items can be any of any type including (e.g., str, int, etc) while strings are strictly a sequence of characters. The second meaningful difference is that lists are mutable, meaning we can change the contents of the list (strings are immutable).

List operations

An operation that is unique to lists is append(), which adds an item to the list (and thus changes its content)

lst = [0,10,20]
lst.append(30) # adds 30 to lst

for i in range(len(lst)):    # we can iterate over a list
    print lst[i]

One thing we can do with lists that we can't do with strings is change a single element.

lst = [0,10,20]
lst[0] = 5 #legal. Changes first element of list
print(lst)

text = "hello"
text[0] = "j" #illegal. Strings are immutable

Changing a single letter in a string is illegal, because string are immutable. Lists are mutable so it's possible to change a single element.

Exercise: write a fitness app

In main(), steps 1 and 4 have been given to you. Together, we will implement step 2, and then you will implement step 3 on your own.

Side effects with mutable parameters

Previously, we showed that reassigning the parameter variable had no effect on the original argument that was sent to the function. This is always the case with immutable data types as once they are created, they cannot be modified.

However, there are circumstances where parameters of mutable data type (e.g., list) can be modified in a function, and the result will have the side effect of also changing the argument variable, despite not returning anything. This can be a desired outcome, or it could be the source of an error in what we want our program to do. Using stack diagrams to understand this phenomena will help us understand why.

NOTE: in all circumstances, use of the assignment statement resets any connections variables may share---the arrow gets changed to a new location. This applies to lists as well.

Exercise: list modification with side effects.

In squareList.py, trace through the program and show that, despite not having a return value, our arguments are forever impacted by the function call.

Exercise: list modification

In makeZero.py, write and test a function which takes a list of integers as input, changes all the negative numbers to zero, and returns the number of "zeroed out" numbers.

Class Notes Week 5

Announcements

Week 5 Topics

Recap: Writing functions, while loops