Lists¶

a type of sequence or container
ordered collection of values called elements or items
lists are similar to strings (ordered collections of characters) except that elements of a list can be of any type.

creating lists¶

several ways; the simplest is to enclose the elements in square brackets [ ]

In [3]:

alist = [] # an empty list

In [4]:

blist = list() # an empty list

In [11]:

# elements with same type
list1 = [10, 20, 30, 40]
list2 = ['spam', 'bungee', 'swallow']

In [6]:

# elements with different types
list3 = ["hello", 2.0, 10, [10, ('world', 'world'), 3.5], (1, 'uno')]

In [12]:

print(list3[len(list3)-1])

(1, 'uno')

In [9]:

print(len(list3))

In [13]:

list4 = list(range(1, 20, 2))

In [14]:

print(list4)

[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]

In [15]:

print(alist, list1, list2, list3)

[] [10, 20, 30, 40] ['spam', 'bungee', 'swallow'] ['hello', 2.0, 10, [10, ('world', 'world'), 3.5], (1, 'uno')]

accessing elements¶

same syntax for accessing characters of a string, the index operator: ['index']

In [16]:

list1

Out[16]:

[10, 20, 30, 40]

In [17]:

list1[0]

Out[17]:

In [18]:

list3

Out[18]:

['hello', 2.0, 10, [10, ('world', 'world'), 3.5], (1, 'uno')]

In [19]:

list3[2-2]

Out[19]:

'hello'

In [21]:

a = 0
print(list3[a])

hello

In [20]:

list3[1.0]

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-20-7447a11bec5d> in <module>()
----> 1 list3[1.0]

TypeError: list indices must be integers or slices, not float

In [22]:

len(list3)

Out[22]:

In [23]:

list3[10]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-23-2d72a649ac7f> in <module>()
----> 1 list3[10]

IndexError: list index out of range

In [24]:

list3

Out[24]:

['hello', 2.0, 10, [10, ('world', 'world'), 3.5], (1, 'uno')]

In [31]:

list3[3][1][1][-1]

Out[31]:

'd'

In [ ]:

list3[4][1]

list membership¶

"in" and "not in" boolean operators let's you check for memebership

In [5]:

horsemen = ["war", "famine", "pestilence", ["death"]]
print('death' in horsemen)
print('War' not in horsemen)

False
True

In [4]:

["death"] == ["death"]

Out[4]:

True

In [ ]:

list3

traverse list elements¶

for or while loop can be used to travers through each element of a list

In [7]:

# common technique; use for loop
for item in list3:
    print(item)

hello
2.0
10
[10, ('world', 'world'), 3.5]
(1, 'uno')

In [10]:

for lst in list3:
    if isinstance(lst, list) or isinstance(lst, tuple):
        for l in lst:
            print(l)
    else:
        print(lst)

hello
2.0
10
10
('world', 'world')
3.5
1
uno

In [8]:

horsemen = ["war", "famine", "pestilence", "death"]
for i in [0, 1, 2, 3]:
    print(horsemen[i])
# better way to do the same thing?

war
famine
pestilence
death

In [9]:

print("traversing using indices")
for i in range(len(horsemen)):
    print(horsemen[i])

print('traversing each element')
for ele in horsemen:
    print(ele)

traversing using indices
war
famine
pestilence
death
traversing each element
war
famine
pestilence
death

list operations¶

+ operator concatenates list
* operator repeats a list a given number of times

In [16]:

list2

Out[16]:

['spam', 'bungee', 'swallow']

In [14]:

list4 = list2+list3

In [15]:

list4

Out[15]:

['spam',
 'bungee',
 'swallow',
 'hello',
 2.0,
 10,
 [10, ('world', 'world'), 3.5],
 (1, 'uno')]

In [17]:

[0]*10

Out[17]:

[0, 0, 0, 0, 0, 0, 0, 0, 0, 0]

In [20]:

a = [1, 2, 3]*4

In [23]:

b = [a]*3

In [24]:

Out[24]:

[[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3],
 [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3],
 [1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]]

In [25]:

# 2-D list or matrix
matrix = [[1, 2], [3, 4], [5, 6]]

In [26]:

print(matrix)

[[1, 2], [3, 4], [5, 6]]

In [27]:

matrix

Out[27]:

[[1, 2], [3, 4], [5, 6]]

In [28]:

# How do you replace 5 with 50 in matrix?
matrix[2][0] = 50

In [29]:

matrix

Out[29]:

[[1, 2], [3, 4], [50, 6]]

list slicing¶

all the slice operations that work with strings also work with lists
[startIndex : endIndex : step]
startIndex is inclusive; endIndex is exclusive; step is optional by default 1

In [7]:

#alphas = ['a', 'b', 'c', 'd', 'e', 'f', 'h']
# wait there's better way to create lists of all lowercase ascii
import string
alphas = list(string.ascii_lowercase)

In [31]:

alphas

Out[31]:

['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']

In [35]:

print(alphas[:])

['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']

In [38]:

print(alphas[::3])

['a', 'd', 'g', 'j', 'm', 'p', 's', 'v', 'y']

In [39]:

print(alphas[1:3])

['b', 'c']

In [40]:

print(alphas[::-1])

['z', 'y', 'x', 'w', 'v', 'u', 't', 's', 'r', 'q', 'p', 'o', 'n', 'm', 'l', 'k', 'j', 'i', 'h', 'g', 'f', 'e', 'd', 'c', 'b', 'a']

lists and strings¶

match made in heaven - work together really well :)

In [41]:

alphaList = list(string.ascii_lowercase)

In [42]:

alphaList

Out[42]:

['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']

In [47]:

alphaStr = '|'.join(alphaList)

In [48]:

alphaStr

Out[48]:

'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'

lists are mutable¶

we can change their elements in place

In [1]:

names = ["john", "David", "Alice"]
names[0] = "jake"

In [2]:

names

Out[2]:

['jake', 'David', 'Alice']

In [3]:

# How to correct spelling of jake?
names[0][0]

Out[3]:

'j'

In [4]:

names[0][0] = 'J'

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-4-0442e9474c4b> in <module>()
----> 1 names[0][0] = 'J'

TypeError: 'str' object does not support item assignment

In [5]:

names[0] = 'Jake'

In [6]:

names

Out[6]:

['Jake', 'David', 'Alice']

In [8]:

alphas

Out[8]:

['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']

In [9]:

alphas[:4] = ['A', 'B', 'C', 'D']

In [10]:

alphas

Out[10]:

['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']

In [11]:

alphas[:4] = []

In [12]:

alphas

Out[12]:

['e',
 'f',
 'g',
 'h',
 'i',
 'j',
 'k',
 'l',
 'm',
 'n',
 'o',
 'p',
 'q',
 'r',
 's',
 't',
 'u',
 'v',
 'w',
 'x',
 'y',
 'z']

list element deletion¶

del statement removes an element from a list

In [13]:

alphas

Out[13]:

['e',
 'f',
 'g',
 'h',
 'i',
 'j',
 'k',
 'l',
 'm',
 'n',
 'o',
 'p',
 'q',
 'r',
 's',
 't',
 'u',
 'v',
 'w',
 'x',
 'y',
 'z']

In [14]:

del alphas[0]

In [15]:

alphas

Out[15]:

['f',
 'g',
 'h',
 'i',
 'j',
 'k',
 'l',
 'm',
 'n',
 'o',
 'p',
 'q',
 'r',
 's',
 't',
 'u',
 'v',
 'w',
 'x',
 'y',
 'z']

In [16]:

del alphas[26]

---------------------------------------------------------------------------
IndexError                                Traceback (most recent call last)
<ipython-input-16-80e1a19bb44c> in <module>()
----> 1 del alphas[26]

IndexError: list assignment index out of range

In [17]:

alphas.index('z')

Out[17]:

In [18]:

alphas.index(alphas[-1])

Out[18]:

In [19]:

del alphas[1:3]

In [20]:

alphas

Out[20]:

['f',
 'i',
 'j',
 'k',
 'l',
 'm',
 'n',
 'o',
 'p',
 'q',
 'r',
 's',
 't',
 'u',
 'v',
 'w',
 'x',
 'y',
 'z']

In [21]:

indexOfZ = alphas.index('z')
del alphas[indexOfZ]

In [22]:

print(alphas)

['f', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y']

objects and references¶

is operator can be used to test if two objects are referencing the same memory location or they're essentially the same object

In [23]:

a = 'apple'
b = 'apple'
a is b

Out[23]:

True

In [ ]:

# What about lists?
l1 = [1, 2, 3]
l2 = [1, 2, 3]
print(l1 == l2)
print(l1 is l2)

copying lists (Shallow copy vs Deep copy)¶

Use pythontutor.com to visualize aliasing

In [24]:

a = [1, 2, 3]
b = a
print(a is b)
print(a == b)

True
True

In [25]:

b[0] = 10
print(a)
print(b)

[10, 2, 3]
[10, 2, 3]

In [26]:

# How do you actually clone lists - do a deep copy?
c = a[:] # easy way shallow copy
d = a.copy() # shallow copy
import copy
e = copy.deepcopy(b)

In [27]:

c is a

Out[27]:

False

In [28]:

d is a

Out[28]:

False

In [29]:

b is e

Out[29]:

False

list methods¶

run help(list)

In [30]:

help(list)

Help on class list in module builtins:

class list(object)
 |  list(iterable=(), /)
 |  
 |  Built-in mutable sequence.
 |  
 |  If no argument is given, the constructor creates a new empty list.
 |  The argument must be an iterable if specified.
 |  
 |  Methods defined here:
 |  
 |  __add__(self, value, /)
 |      Return self+value.
 |  
 |  __contains__(self, key, /)
 |      Return key in self.
 |  
 |  __delitem__(self, key, /)
 |      Delete self[key].
 |  
 |  __eq__(self, value, /)
 |      Return self==value.
 |  
 |  __ge__(self, value, /)
 |      Return self>=value.
 |  
 |  __getattribute__(self, name, /)
 |      Return getattr(self, name).
 |  
 |  __getitem__(...)
 |      x.__getitem__(y) <==> x[y]
 |  
 |  __gt__(self, value, /)
 |      Return self>value.
 |  
 |  __iadd__(self, value, /)
 |      Implement self+=value.
 |  
 |  __imul__(self, value, /)
 |      Implement self*=value.
 |  
 |  __init__(self, /, *args, **kwargs)
 |      Initialize self.  See help(type(self)) for accurate signature.
 |  
 |  __iter__(self, /)
 |      Implement iter(self).
 |  
 |  __le__(self, value, /)
 |      Return self<=value.
 |  
 |  __len__(self, /)
 |      Return len(self).
 |  
 |  __lt__(self, value, /)
 |      Return self<value.
 |  
 |  __mul__(self, value, /)
 |      Return self*value.
 |  
 |  __ne__(self, value, /)
 |      Return self!=value.
 |  
 |  __repr__(self, /)
 |      Return repr(self).
 |  
 |  __reversed__(self, /)
 |      Return a reverse iterator over the list.
 |  
 |  __rmul__(self, value, /)
 |      Return value*self.
 |  
 |  __setitem__(self, key, value, /)
 |      Set self[key] to value.
 |  
 |  __sizeof__(self, /)
 |      Return the size of the list in memory, in bytes.
 |  
 |  append(self, object, /)
 |      Append object to the end of the list.
 |  
 |  clear(self, /)
 |      Remove all items from list.
 |  
 |  copy(self, /)
 |      Return a shallow copy of the list.
 |  
 |  count(self, value, /)
 |      Return number of occurrences of value.
 |  
 |  extend(self, iterable, /)
 |      Extend list by appending elements from the iterable.
 |  
 |  index(self, value, start=0, stop=9223372036854775807, /)
 |      Return first index of value.
 |      
 |      Raises ValueError if the value is not present.
 |  
 |  insert(self, index, object, /)
 |      Insert object before index.
 |  
 |  pop(self, index=-1, /)
 |      Remove and return item at index (default last).
 |      
 |      Raises IndexError if list is empty or index is out of range.
 |  
 |  remove(self, value, /)
 |      Remove first occurrence of value.
 |      
 |      Raises ValueError if the value is not present.
 |  
 |  reverse(self, /)
 |      Reverse *IN PLACE*.
 |  
 |  sort(self, /, *, key=None, reverse=False)
 |      Stable sort *IN PLACE*.
 |  
 |  ----------------------------------------------------------------------
 |  Static methods defined here:
 |  
 |  __new__(*args, **kwargs) from builtins.type
 |      Create and return a new object.  See help(type) for accurate signature.
 |  
 |  ----------------------------------------------------------------------
 |  Data and other attributes defined here:
 |  
 |  __hash__ = None

In [33]:

a = []
a.append(1)
a.append(2)
a.append([2, 3])

In [34]:

Out[34]:

[1, 2, [2, 3]]

In [35]:

a.extend([3, 4])

In [36]:

Out[36]:

[1, 2, [2, 3], 3, 4]

In [37]:

a.append([5, 6])

In [38]:

Out[38]:

[1, 2, [2, 3], 3, 4, [5, 6]]

In [39]:

a.insert(0, 'hi')

In [40]:

Out[40]:

['hi', 1, 2, [2, 3], 3, 4, [5, 6]]

In [41]:

a.reverse()

In [43]:

a[0].reverse()

In [44]:

Out[44]:

[[6, 5], 4, 3, [2, 3], 2, 1, 'hi']

In [45]:

a.sort()

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-45-2ed0d7de6146> in <module>()
----> 1 a.sort()

TypeError: '<' not supported between instances of 'int' and 'list'

In [46]:

blist = list(range(10, 0, -1))

In [47]:

blist

Out[47]:

[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

In [48]:

blist.sort()

In [49]:

print(blist)

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

In [50]:

blist.sort(reverse=True)

In [51]:

blist

Out[51]:

[10, 9, 8, 7, 6, 5, 4, 3, 2, 1]

In [55]:

m = max(blist)
mI = blist.index(m)

In [56]:

print(mI)

In [53]:

min(blist)

Out[53]:

In [58]:

print(blist.count(100))

string to list of integers¶

In [63]:

nums = '1 2 100 5'

In [64]:

nums = nums.split(' ')

In [69]:

intNums = []
for n in nums:
    intN = int(n)
    intNums.append(intN)

In [70]:

intNums

Out[70]:

[1, 100, 2, 5]

In [71]:

intNums.sort()

In [72]:

intNums

Out[72]:

[1, 2, 5, 100]

In [3]:

alist = []
print(alist)

[]

passing list to function - pass-by-reference¶

mutable types such as list are passed-by-reference

In [4]:

def getData(someList):# someList is formal parameter
    for i in range(5):
        a = int(input('enter a number: '))
        someList.append(a)
        

In [6]:

print(alist)
getData(alist) # alist is actual argument

[]
enter a number: 1
enter a number: 2
enter a number: 3
enter a number: 4
enter a number: 5

visualize - pass-by-reference ¶

In [7]:

alist

Out[7]:

[1, 2, 3, 4, 5]

In [8]:

getData(alist)

enter a number: 10
enter a number: 20
enter a number: 30
enter a number: 40
enter a number: 50

In [9]:

alist

Out[9]:

[1, 2, 3, 4, 5, 10, 20, 30, 40, 50]

return list from functions¶

lists can be returned from functions

In [12]:

def getMaxMin(alist):
    m = max(alist)
    minVal = min(alist)
    return [m, minVal]
    

[1999999, -1000]

In [13]:

alist = list(range(-1000, 2000000))
print(getMaxMin(alist))

[1999999, -1000]

In [15]:

assert getMaxMin(alist) == [1999999, -1000]

exercise¶

Practice with the rest of the methods of list

In [ ]:

Lists¶

creating lists¶

accessing elements¶

list membership¶

traverse list elements¶

list operations¶

list slicing¶

lists and strings¶

lists are mutable¶

list element deletion¶

objects and references¶

copying lists (Shallow copy vs Deep copy)¶

list methods¶

string to list of integers¶

passing list to function - pass-by-reference¶

visualize - pass-by-reference¶

return list from functions¶

exercise¶

visualize - pass-by-reference ¶