A quick introduction to working with lists in Python.
Lists are a general container in Python. Lists are a sequence-type of data structure that can be growns and reduced in size dynamically, i.e. as needed during your program.
Lists are sortable.
We can declare a list with square brackets []. Accessing a single element from within a list is done by using the square brackets and entering desired index location.
# this is a empty list a = [] print(a)
[]
# this is a list with elements of type integer b = [1,2,3] print(b)
[1, 2, 3]
# this is a list with elements of different basic data types c = [1, 1.2, "text"] print(c)
[1, 1.2, 'text']
# lets check the data types of the list c, and its elements type(c)
list
type(c[0])
int
type(c[1])
float
type(c[2])
str
As can be seen from above example list indexing starts at 0.
The lists shown above have 1 dimension – but a list can have multiple dimensions. This is done by storing lists inside lists. He is an example of a list with 2 dimensions:
d = [[1,2],[3,4]] d[0]
[1, 2]
Using the first set of square brackets allows controlling the first dimension. In this case the first row of the two dimensional matrix accessed.
Below, I acces first element in first row.
d[0][0]
1
A list is an object in itself. This is why I can put a list inside another list. And that list could have another list inside itself. And so on. But, I can also have different levels inside my list.
Below is an example where first element is 3 levels deep, the second element is 2 levels deep and the third element has only its first level:
e = [[[1,4],[3,6]],[1,2,3],"abcdefg"]
# accessing first element from lowest level of first element in list "e" e[0][0][0]
1
# accessing first element from lowest level of second element in list "e" e[1][0]
1
# accessing third element in list "e", which has no further levels below it e[2]
'abcdefg'
In my last comment I wrote that the last element in list “e” has no further levels. It is actually not 100% true since a string itself is a sequence and its characters can thus be accessed in similar way as elements in a list:
e[2][2]
'c'
Index -1 indicates the last index in a list:
e[-1]
'abcdefg'
Index -2 indicates second last index in a list:
e[-2]
[1, 2, 3]
# another example, a going one level deeper e[-2][-2]
2
-3 indicates third last index in list, and so on and so forth:
e[-3][1][-2]
3
Lists can be merged, using the + operator:
[1,2,3] + [4,5,6]
[1, 2, 3, 4, 5, 6]
This also means that I cannot conduct elementwise mathematical operations by using operators such as + or -. For this I would have to delcare arrays in NumPy (a Python module).
Lists have a series or handy methods. I demonstrate all of them in the remaining lines of this post!
append() appends something to the end of a list
f = [1,2,3] f.append("text") print(f)
[1, 2, 3, 'text']
extend() enables extending a list with another list
g = [1,2,3] g.extend([4,5,6]) print(g)
[1, 2, 3, 4, 5, 6]
insert() enables inserting an element at specified index in a list
h = [1,2,3] h.insert(0,"prefix") print(h)
['prefix', 1, 2, 3]
h.insert(4,"postfix") print(h)
['prefix', 1, 2, 3, 'postfix']
remove() remoces an element from a list; remove() only removes first match
h.remove("postfix") print(h)
['prefix', 1, 2, 3]
i = [1,1,1,2,2,2] i.remove(1) print(i)
[1, 1, 2, 2, 2]
index() returns smallest index of a match in a list
j = [1,2,3,3,3,4,5,6,1] j.index(1)
0
count() returns the number of matches within a list
j.count(3)
3
j.count(6)
1
pop() returns and removes last element in a list; or at given index
k = [1,2,3,4,5] k.pop()
5
print(k)
[1, 2, 3, 4]
k.pop(2)
3
print(k)
[1, 2, 4]
k.pop(-2) # pops second last element in list
2
print(k)
[1, 4]
reverse() reverses list order
# reverse() reverses a list l = ["a","b","c","d"] l.reverse() print(l)
['d', 'c', 'b', 'a']
in Python 3+ .cop() returns a shallow copy of the list
m = l.copy() print(m)
['a', 'b', 'c', 'd']
clear() clears a list from all its elements
# clear() clears a list m.clear() print(m)
[]
print(l)
['d', 'c', 'b', 'a']
There are many functions that are not list methods but can be used on lists
any(): takes a list (or any other iterable) and returns True if at least one element is True
any([1,2,3])
True
any([2,2,2])
True
any([0,-1])
True
any([0,0])
False
any(["text","book"])
True
any("text")
True
any("false")
True
any([True,False,False])
True
all() returns True if all elements in a list are True
all([1,0])
False
all([1,1])
True
ascii() returns printable notation of list
ascii(["!!?%&!","å","ø"])
"['!!?%&!', '\\xe5', '\\xf8']"
enumerate() returns index to an iterable object, and returns the object including indexing
m = enumerate("text",start=0) for letter in m: print(letter)
(0, 't') (1, 'e') (2, 'x') (3, 't')
# enumerate returns a tuple for every element of the iterable,containing (index, element) l.reverse() for i in enumerate(l,start=0): if i[0] > 1: print(i)
(2, 'c') (3, 'd')
print(l)
['a', 'b', 'c', 'd']
print(enumerate(l,start=2))
<enumerate object at 0x000002141DDAE0E8>

Data scientist focusing on simulation, optimization and modeling in R, SQL, VBA and Python
Leave a Reply