cs101 ยป

```
# Investigating adding and appending to lists
# If you run the following four lines of codes, what are list1 and list2?
list1 = [1,2,3,4]
list2 = [1,2,3,4]
list1 = list1 + [5]
list2.append(5)
# to check, you can print them out using the print statements below.
#print list1
#print list2
# What is the difference between these two pieces of code?
def proc(mylist):
mylist = mylist + [6]
def proc2(mylist):
mylist.append(6)
# Can you explain the results given by the four print statements below? Remove
# the hashes # and run the code to check.
#print list1
#proc(list1)
#print list1
#print list2
#proc2(list2)
#print list2
# Python has a special assignment syntax: +=. Here is an example:
list3 = [1,2,3,4]
list3 += [5]
# Does this behave like list1 = list1 + [5] or list2.append(5)? Write a
# procedure, proc3 similar to proc and proc2, but for +=. When you've done
# that check your conclusion using the print-procedure call-print code as
# above.
# What happens when you try:
list1 = list1 + [7,8,9]
list2.append([7,8,9])
list3 += [7,8,9]
# When you've understood the difference between the three methods,
# write a procedure list_test which takes three lists as inputs. You should
# mutate the first input list to include 'a' as the last entry, mutate the
# second to include the entries 'a', 'b', 'c' and finally the last list should
# not be mutated but a copy should be returned with the additional entry 'w'.
def list_test():
# Your code here
first_input = [1,2,3]
second_input = [4,5,6]
third_input = [7,8,9]
#print list_test(first_input, second_input, third_input)
#>>> [7,8,9,'w']
#print first_input
#>>> [1,2,3,'a']
#print second_input
#>>> [4,5,6,'a','b','c']
#print third_input
#>>> [7,8,9]
```

```
# A list is symmetric if the first row is the same as the first column,
# the second row is the same as the second column and so on. Write a
# procedure, symmetric, which takes a list as input, and returns the
# boolean True if the list is symmetric and False if it is not.
def symmetric():
# Your code here
#print symmetric([[1, 2, 3],
# [2, 3, 4],
# [3, 4, 1]])
#>>> True
#print symmetric([["cat", "dog", "fish"],
# ["dog", "dog", "fish"],
# ["fish", "fish", "cat"]])
#>>> True
#print symmetric([["cat", "dog", "fish"],
# ["dog", "dog", "dog"],
# ["fish","fish","cat"]])
#>>> False
#print symmetric([[1, 2],
# [2, 1]])
#>>> True
#print symmetric([[1, 2, 3, 4],
# [2, 3, 4, 5],
# [3, 4, 5, 6]])
#>>> False
#print symmetric([[1,2,3],
# [2,3,1]])
#>>> False
```

```
# The mean of a set of numbers is the sum of the numbers divided by the
# number of numbers. Write a procedure, mean, which takes a list of numbers
# as its input and return the mean of the numbers in the list.
# Hint: You will need to work out how to make your division into decimal
# division instead of integer division. You get decimal division if any of
# the numbers involved are decimals.
def list_mean():
print list_mean([1,2,3,4])
#>>> 2.5
print list_mean([1,3,4,5,2])
#>>> 3.0
#print list_mean([])
#>>> ??? You decide. If you decide it should give an error, comment
# out the print line above to prevent your code from being graded as
# incorrect.
print list_mean([2])
#>>> 2.0
```