Python has a great built-in list type named
list. List literals are written within square brackets
[ ]. Lists work similarly to strings — use the
len() function and square brackets
[ ] to access data, with the first element at index 0. (See the official Data Structures — Python 2.7 documentation)
colors = ['red', 'blue', 'green'] print colors ## red print colors ## green print len(colors) ## 3
Assignment with an
= on lists does not make a copy. Instead, assignment makes the two variables point to the one list in memory.
b = colors ## Does not copy the list
The “empty list” is just an empty pair of brackets
[ ]. The
+ works to append two lists, so
[1, 2] + [3, 4] yields
[1, 2, 3, 4] (this is just like
+ with strings).
in constructs are extremely useful, and the first use of them we’ll see is with lists. The
for construct —
for var in list — is an easy way to look at each element in a list (or other collection). Do not add or remove from the list during iteration.
squares = [1, 4, 9, 16] total = 0 for num in squares: total += num print total ## 30
If you know what sort of thing is in the list, use a variable name in the loop that captures that information such as
url. Since python code does not have other syntax to remind you of types, your variable names are a key way for you to keep straight what is going on.
in construct on its own is an easy way to test if an element appears in a list (or other collection) —
value in collection — tests if the value is in the collection, returning
list = ['larry', 'curly', 'moe'] if 'curly' in list: print 'yay'
in constructs are very commonly used in Python code and work on data types other than list, so you should just memorize their syntax. You may have habits from other languages where you start manually iterating over a collection, where in Python you should just use
You can also use
in to work on a string. The string acts like a list of its chars, so
for ch in s: print ch prints all the chars in a string.
range(n) function yields the numbers 0, 1, … n-1, and
range(a, b) returns a, a+1, … b-1 — up to but not including the last number. The combination of the
for-loop and the
range() function allow you to build a traditional numeric for loop:
## print the numbers from 0 through 99 for i in range(100): print i
There is a variant
xrange() which avoids the cost of building the whole list for performance sensitive cases (in Python 3.0,
range() will have the good performance behavior and you can forget about
Python also has the standard
while-loop. The above
in loops solves the common case of iterating over every element in a list, but the
while loop gives you total control over the index numbers. Here’s a while loop which accesses every 3rd element in a list:
## Access every 3rd element in a list a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ] i = 0 while i < len(a): print a[i] i = i + 3
continue give us some more control over what code is executed inside a loop.
break is encountered, Python immediate stops iterating over the loop (it also ignores all the code after the break within the block, if any). Here’s an example:
a = [1, 5, 3, 2, 4, 6, ] for element in a: print element if element == 2: break # quit the loop when element == 2 print -element # when element == 2, this line too won't execute
Here’s the code output:
1 -1 5 -5 3 -3 2
Note: 4 and 6 don’t get printed at all. 2 gets printed, but -2 does not, since
break happens before that.
continue is encountered, Python ignores the code after the
continue within the block, but “continues” iterating over the rest of the elements. Here’s an example:
a = [1, 5, 3, 2, 4, 6, ] for element in a: print element if element <= 2: continue # don't execute the rest if element <= 2 print -element # when element <= 2, this line too won't execute
Here’s the code output:
1 5 -5 3 -3 2 4 -4 6 -6
Note: All numbers get printed. However, for 1 and 2, the negative values don’t get printed because of the
continue can be used inside
while-loops as well.
Here are some other common list methods.
list.append(elem)— adds a single element to the end of the list. Common error: does not return the new list, just modifies the original.
list.insert(index, elem)— inserts the element at the given index, shifting elements to the right.
list.extend(list2)adds the elements in
list2to the end of the
+=on a list is similar to using
list.index(elem)— searches for the given element from the start of the list and returns its index. Throws a
ValueErrorif the element does not appear (use
into check without a
list.remove(elem)— searches for the first instance of the given element and removes it (throws
ValueErrorif not present)
list.sort()— sorts the list in place (does not return it). (The
sorted()function shown below is preferred.)
list.reverse()— reverses the list in place (does not return it)
list.pop(index)— removes and returns the element at the given index. Returns the rightmost element if index is omitted (roughly the opposite of
Notice that these are methods on a list object, while
len() is a function that takes the list (or string or whatever) as an argument.
list = ['larry', 'curly', 'moe'] list.append('shemp') ## append elem at end list.insert(0, 'xxx') ## insert elem at index 0 list.extend(['yyy', 'zzz']) ## add list of elems at end print list ## ['xxx', 'larry', 'curly', 'moe', 'shemp', 'yyy', 'zzz'] print list.index('curly') ## 2 list.remove('curly') ## search and remove that element list.pop(1) ## removes and returns 'larry' print list ## ['xxx', 'moe', 'shemp', 'yyy', 'zzz']
Common error: note that the above methods do not return the modified list, they just modify the original list.
list = [1, 2, 3] print list.append(4) ## NO, does not work, append() returns None ## Correct pattern: list.append(4) print list ## [1, 2, 3, 4]
One common pattern is to start a list as the empty list
, then use
extend() to add elements to it:
list =  ## Start as the empty list list.append('a') ## Use append() to add elements list.append('b')
Slices work on lists just as with strings, and can also be used to change sub-parts of the list.
list = ['a', 'b', 'c', 'd'] print list[1:-1] ## ['b', 'c'] list[0:2] = 'z' ## replace ['a', 'b'] with ['z'] print list ## ['z', 'c', 'd']
List comprehensions are a more advanced feature which is nice for some cases but is not needed for the exercises and is not something you need to learn at first (i.e. you can skip this section). A list comprehension is a compact way to write an expression that expands to a whole list. Suppose we have a list
[1, 2, 3, 4], here is the list comprehension to compute a list of their squares
[1, 4, 9, 16]:
nums = [1, 2, 3, 4] squares = [ n * n for n in nums ] ## [1, 4, 9, 16]
The syntax is
[ expr for var in list ] — the
for var in list looks like a regular
for-loop, but without the colon
expr to its left is evaluated once for each element to give the values for the new list. Here is an example with strings, where each string is changed to upper case with
strs = ['hello', 'and', 'goodbye'] shouting = [ s.upper() + '!!!' for s in strs ] ## ['HELLO!!!', 'AND!!!', 'GOODBYE!!!']
You can add an
if test to the right of the
for-loop to narrow the result. The
if test is evaluated for each element, including only the elements where the test is
## Select values <= 2 nums = [2, 8, 1, 6] small = [ n for n in nums if n <= 2 ] ## [2, 1] ## Select fruits containing 'a', change to upper case fruits = ['apple', 'cherry', 'bannana', 'lemon'] afruits = [ s.upper() for s in fruits if 'a' in s ] ## ['APPLE', 'BANNANA']