An Introduction To Python - Tables, List Algorithms

An Introduction To Software

Development Using Python

Spring Semester, 2014

Class #12:

Tables,

List Algorithms

Let’s Talk About: Tables

• It often happens that you want to storecollections of values that have a two-dimensional tabular layout.

• Such data sets commonly occur in financial and scientific applications.

• An arrangement consisting of rows and columns of values is called a table, or a matrix.

Image Credit: www.rafainspirationhomedecor.com

How To Create Tables

• Python does not have a data type for creating tables.

• A two-dimensional tabular structure can be created using Python lists.

• A table is simply a list in which each element is itself another list

Accessing Elements Of A Table

• To access a particular element in the table, you need to specify two index values inseparate brackets to select the row and column, respectively.

medalCount = counts[3][1] = 0

Access All Elements In A Table

• To access all elements in a table, you use two nested loops.

for i in range(COUNTRIES) :# Process the i th row.for j in range(MEDALS) :

# Process the j th column in the i th row.print("%8d" % counts[i][j], end="")

print() # Start a new line at the end of the row.

a

Finding Your Neighbors In A Table

• Some programs that work with tables need to locate the elements that are adjacent to an element.

• You need to be careful about computing neighbors at the boundary of the list.

• You need to check whether the element is located at the top or bottom of the table

b

Computing Row Totals

• A common task is to compute row or column totals.

• In our example, the row totals give us the total number of medals won by a particular country.

• Finding the correct index values is a bit tricky, and it is a good idea to make a quick sketch.

• To compute the total of row i:

c

Computing Column Totals

• Computing column totals is similar.

• Form the sum of counts[i][j] , where i rangesfrom 0 to COUNTRIES - 1.

d

List Algorithms: Maximum and Minimum

• In order to find the maximum value that is stored in a list:

largest = values[0]for i in range(1, len(values)) :

if values[i] > largest :largest = values[i]

Note that the loop starts at 1 because we initialize largest with values[0] .

• To compute the smallest element, reverse the comparison.

e

List Algorithms: Fill A List

• We want to both create and fill a list with values at the same time.

n = 100values = []for i in range(n) :

values.append(0)

List Algorithms: Combining List Elements

• If you want to compute the sum of a list of numbers, you can simply call the sum function.

• But suppose you have a list of strings and want to concatenate them. Then the sum method doesn’t work.

• Here is how to compute a sum of numbers in the list “values”:

result = ""for element in names :

result = result + element

f

List Algorithms: Element Separators

• When you display the elements of a list, you usually want to separate them, often with commas or vertical lines, like this:Harry, Emily, Bob

• Note that there is one fewer separator than there are numbers.

• Add the separator before each element in the sequence except the initial one (with index 0), like this:

for i in range(len(names)) :if i > 0 :

result = result + ", "result = result + names[i]

g

List Algorithms: Linear Search

• You often need to search for the position of a specific element in a list so that you can replace or remove it.

• If you simply want to find the position of a value, you can use the index method:

searchedValue = 100if searchedValue in values

pos = values.index(searchedValue)print("Found at position:", pos)

else print("Not found")

h

List Algorithms: Linear Search

• However, if you want to find the position of a value that has a given property, you have to know how the index method works.

• Consider the task of finding the first value that is > 100. You need to visit all elements until you have found a match or you have come to the end of the list.

• This algorithm is called linear search or sequential search because you inspect the elements in sequence.

limit = 100pos = 0found = Falsewhile pos < len(values) and not found :

if values[pos] > limit found = True

else pos = pos + 1

if found print("Found at

position:", pos)else

print("Not found")

List Algorithms: Collecting and Counting Matches

• In the preceding section, you saw how to find the position of the first element that fulfills a particular condition.

• Suppose we want to know all matches. You can simply append them to an initially empty list.

• Here, we collect all values that are > 100:

limit = 100result = []for element in values :

if (element > limit) :result.append(element)

• Sometimes you just want to know how many matches there are without counting them.

• Then you increment a counter instead of collecting the matches:

limit = 100counter = 0for element in values :if (element > limit) :

counter = counter + 1

Image Credit: www.clipartof.com

List Algorithms: Removing Matches

• A common processing task is to remove all elements that match a particular condition.

• Suppose, for example, that we want to remove all strings of length < 4 from a list.

• Of course, you traverse the list and look for matching elements:

for i in range(len(words)) :word = words[i]if len(word) < 4 :

Remove the element at index i.

• But there is a subtle problem. After you remove the element, the for loop increments i , skipping past the next element.

List Algorithms: Removing Matches

• Consider this concrete example, where words contains the strings "Welcome", "to", "the", "island!".

• When i is 1, we remove the word "to" at index 1.

• Then i is incremented to 2, and the word "the", which is now at position 1, is never examined.

• We should not increment the index when removing a word.

• Because we don’t always increment the index, a for loop is not appropriate for this algorithm. Instead, use a while loop:

i = 0while i < len(words) :

word = words[i]if len(word) < 4 :

words.pop(i)else :

i = i + 1

List Algorithms: Swapping Elements

• You often need to swap elements of a list.

• For example, you can sort a list by repeatedly swapping elements that are not in order.

• Consider the task of swapping the elements at positions i and j of a list values.

• We’d like to set values[i] to values[j] . That overwrites the value that is currently stored in values[i] , so we want to save that first:

temp = values[i]values[i] = values[j]

# Now we can set values[j] to the saved value.values[j] = temp

List Algorithms: Reading Input

• It is very common to read input from a user and store it in a list for later processing.

• Start with an empty list and, as each value is read, append the value to the end of thelist:

values = []print("Please enter values, Q to quit:")userInput = input("")while userInput.upper() != "Q" :

values.append(float(userInput))userInput = input("")

Image Credit: all-free-download.com

What We Covered Today

1. Tables

1. Creating

2. Accessing

3. Neighbors

4. Summing

2. List Algorithms

Image Credit: http://www.tswdj.com/blog/2011/05/17/the-grooms-checklist/

What We’ll Be Covering Next Time

1. Processing Strings

Image Credit: http://merchantblog.thefind.com/2011/01/merchant-newsletter/resolve-to-take-advantage-of-these-5-e-commerce-trends/attachment/crystal-ball-fullsize/