Today:
Last time, we taked about how to make and use lists. Some highlights from last time.
# defining lists:
xs = [1,2,4,1,5,"hello"]
print(xs)
# changing elements:
xs = [1,2,4,1,5,"hello"]
xs[0] = 999
print(xs)
# acccessing elements
print("the first element of the list is:", xs[0])
print("the last element of the list is:", xs[-1])
# length of list
print("the length of the list is:", len(xs))
# adding a new element to a list:
xs.append("goodbye")
print(xs)
# concatenating lists using +
xs = [1,2,3,4]
print(xs + ["hello", "goodbye"])
print("but xs is still:", xs)
# We could do:
xs = xs + ["hello", "goodbye"]
print(xs)
# alternatively, we can use extend
xs = [1,2,3,4]
xs.extend(["hello", "goodbye"])
print(xs)
# range
list(range(10))
list(range(5,10))
list(range(5, 20, 3))
# looping over a list using for
for i in range(10):
print(i)
In math, we use the following notation a lot when defining sets: $$ X = \{ 2n \,\, | \,\, n \in \mathbb{Z} \}$$ $X$ would be the set of even numbers. Similarly, we can define lists from other lists in Python.
In the tradition of naming things with words that ordinary people can't understand, this is called list comprehension.
evens = [2*n for n in range(10)]
print(evens)
odds = [n+1 for n in evens]
print(odds)
[ 2**(2**n) for n in range(10) ]
We didn't do this in lecture. But you can read it to see an example of using lists in a real problem.
One great reason to use lists is to have lots of variables to keep track of things.
We are looking for the numbers with the longest sequences in the $3n+1$ problem.
Recall that the $3n+1$ problem works as follows:
If we start with $a_0 = 3$, the sequences is: $3, 10, 5, 16, 8, 4, 2, 1$
If we start with $a_0 = 9$, the sequence is: $9, 28, 14, 7, 22, 11, 34, 17, 52, 26, 13, 40, 20, 10 5, 16, 8, 4, 2, 1$
The funny thing that nobody understands why is that the sequence seems to always ends with 1. This is sometimes called the Collatz conjecture.
Let's find the number $< 1000000$ with the longest sequence
# let's generate the list
def collist(a):
lst = []
while a!=1:
if a%2 == 0:
a = a // 2
else:
a = 3*a + 1
lst.append(a)
return lst
collist(9)
# let's generate just the length:
def collen(a):
return len(collist(a))
collen(9)
But note that we are making a whole list which is stored in memory just to compute its length. It makes no sense. We can just compute the length without making the whole list.
# let's generate the list
def collen(a):
total_len = 0
if a < 1:
return 0
while a!=1:
if a%2 == 0:
a = a // 2
else:
a = 3*a + 1
total_len += 1
return total_len
collen(9)
# still works:
Let's look for the maximum length up to 1000
mm = 1000
max_len = -1
max_len_came_from = -1
for i in range(mm):
le = collen(i)
if le > max_len:
max_len = le
max_len_came_from = i
print("maximum sequence length was for the number", max_len_came_from, "and it was", max_len)
Can we be more efficient?
Yes, in fact we keep doing the same things over and over again. For example, when computing collen(5), we see 5,16,8,4,2,1, but then we we look at collen(6), we look at 6,3,10,5,16,8,4,2,1. Redundant!!! SAD!
Solution: let's remember the lengths we already computed.
# start with list full of 0s
import time
mm = 1000000
llen = 10*mm
lengths = [0 for i in range(llen)]
def smart_collen(a):
total_len = 0
if a < 1:
return 0
while a!=1:
if a < llen and lengths[a] != 0:
return lengths[a]+total_len
#else
if a%2 == 0:
a = a // 2
else:
a = 3*a + 1
total_len += 1
return total_len
max_len = -1
max_len_came_from = -1
for i in range(mm):
le = smart_collen(i)
if le > max_len:
max_len = le
max_len_came_from = i
print("maximum sequence length was for the number", max_len_came_from, "and it was", max_len)
collist(837799)
This is something technical about how Python works but is very important.
# guess what will happen
x = 1
print(x)
# guess what will happen
y = x
x += 1
print(y, x)
Even though we said y=x, and then changed x, the value of y didn't change. Why?
It was because when we said y=x, it was the value of y that got get to value of x.
# Let's try the same with lists
x = [1,2,3,4]
y = x
x[0] = 999
print(y)
What is going on? We saw one behaviour for numbers, and a totally different behaviour for lists.
This is because numbers are immutable whereas lists are mutable.
If x refers to a mutable object, then, when we say y=x, y is referring to the same object, which exists as a separate entity to x and y. On the other hand, if x is immutable, then the value of x is just copied over to y.
More concretely, when we say x=1, in the memory of the computer, a location, which corresponds to x is created, and that location stores the value 1.
On the other hand, when we say x = [1,2,3,4], the list [1,2,3,4] is created somewhere in memory. A separate location, which corresponds to x is also created, but that location does not contain [1,2,3,4]. Instead, the location for x contains the address of the location where [1,2,3,4] is stored in memoty. We can think of x as a pointer to the actual place of [1,2,3,4] in memory.
Now, when we put x = [1,2,3,4] and then y=x, the address in memory that y refers to is changed to the address in memory that x refers to. So x and y are pointing to the same [1,2,3,4] in memory. This means that if we then change x[0], this will also change y[0].
# what will happen?
def f(a):
a += a
return a
x = 1
f(x)
print(x)
The value of x didn't change because x was a local variable inside the function.
Let's try the same with lists:
# what will happen?
def f(a):
a += a
return a
x = [1,2,3,4]
f(x)
x
The value of x did change!!! This was because x was a list was mutable. Which meant that it could be changed in the function.
This can actually be a good thing: it means that we can manipulate a list inside a function. In the homework, you will be asked to write a function that will reverse a list for example. You will just call reverse(x) and the list referred to by x will be reversed.
So what if x = [1,2,3,4] and we really want a copy of [1,2,3,4] that will be different? Easy:
import copy
x = [1,2,3,4]
y = copy.copy(x)
print(x,y)
x[0] = 999
print(x,y)