title

Tasks

1. Complete reading this lesson, which involves the following:
   1. Introduction
   2. Loops for list manipulation
   3. Slicing
   4. Copying and passing lists
   5. Built-in methods
2. Complete quiz 7 to verify your reading and understanding.
3. Read and complete the activities at Zybook, Z8: Lists.

Learning Outcomes

By the end of this lesson, you should be able to:

1. Explain the use of lists in programming.
2. Discuss the implementation of lists in Python programming.
3. Modify lists using loops.
4. Use slicing to retrieve data from lists.
5. Design programs that can pass lists between functions.

Key Terms/Concepts

• List, slicing, arguments, pass by value, pass by reference, indexing.

Introduction

A list object is a container that groups together data. Up until now, you have assigned a single value to a variable. A single container on the other hand can be used to store multiple values. For example, consider a customer's address that we need to store. The house number, street name, city, and postal code belong together. Rather than using four separate variables, we can use a single list to store it. Values with different datatypes can be combined in one list.

Similarly, we can use lists where we have a lot of data. If we are designing a program to store marks of 100 students and find the average and maximum score in a class, it is much more efficient and easier to work with a single list rather than 100 variables.

A list is a sequence as well. This means that each data element has a unique position (called index) in the list, and it can be accessed using its index. Two lists are shown below. The first list is named got_address and contains a home address, whereas the second list contains student marks and is called final_marks.

got_address:

final_marks:

The top row in each list shows the index of each data element, whereas the bottom row has the actual data values. An index is always an integer. got_address combines two integers and three strings in the same list. final_marks has a combination of integers and floats. The first element of a list is always at index number 0.

Index positions always start from 0, so the n^th element of the list will be at index position (n-1).

Reverse Indexing

Every list has forward indexing as well as reverse indexing. The last example depicted forward indexing, which started from zero. Reverse indexing uses negative integers to specify element position. The last element of a list is at index -1, and the first element is at index -length. As we will see later, reverse indexing is useful to access the last element of the list or the last n elements of the list.

The following example shows forward and reverse indexing for a list. The first row shows reverse indexing and the second row shows forward indexing. The length of the list final_marks remains 9.

final_marks:

8.2.1 Creating and Accessing lists

Lists are mutable. Mutable objects can be changed without changing the identity. They can grow and shrink as the elements are modified, added, and deleted. Python uses square brackets for accessing elements through indexes. Prog 8-01 in Console Listing 1 shows a demo of creating lists and accessing and modifying the elements through forward and reverse indexing.

 # Program Name: Prog 8-01
 # This program is part of Lesson 08 of the course 
  
 def main ():
        final_marks = [70, 40, 30, 22, 80, 90, 90, 99, 67]
    
        got_address = [13, 'Univ Avenue', 'Kings Landing', 44000, 'Westeros']
  
        print(f"Number of students: {len(final_marks)}")
        length_got = len(got_address)
        print(f"Lenth of address: {length_got}")
  
        final_marks[2] = 30.5
    final_marks[3] = 22.5

    got_address[2] = "White Harbour"
    got_address[length_got - 1] = "North"
    got_address[-1] = "The North"
    got_address[-length_got] = 100
 
    print(f"Final marks: {final_marks}")
    print("\nAddress:")
    print(f'{got_address[-length_got]} {got_address[1]},')
    print(f'{got_address[2]}, {got_address[3]},')
    print(f'{got_address[-1]}')

main()

Let's go through the source code line by line.

Repetition and Concatenation

A list can be repeated, and multiple lists can be concatenated using asterisk (*) and plus (+) symbols respectively. Python executes differently if the operands are numbers compared to when they are lists. Prog 8-02 in Code Listing 2 shows list repetition and concatenation.

 # Program Name: Prog 8-02
 # This program is part of Lesson 08 of the course 
  
 def main ():
        group1_marks_q1 = [151, 140, 130]
        bonus_marks = [2] * 3
  
        group1_marks_q1[0] = group1_marks_q1[0] + bonus_marks[0]
        group1_marks_q1[1] = group1_marks_q1[1] + bonus_marks[1]
        group1_marks_q1[2] = group1_marks_q1[2] + bonus_marks[2]
  
        print("Course CP999 data:")
        print(f"Group 1 marks in Quiz 1: {group1_marks_q1}")

    group1_marks_q2 = [190, 190, 30.5]
    group1_marks = group1_marks_q1 + group1_marks_q2

    group1_student_id = [123, 124, 125]
    group1_student_id = group1_student_id * 2
 
    print()
    print(f"Student ID:\t\t{group1_student_id}")
    print(f"Quiz 1 and 2 marks:\t{group1_marks}")

main()

Prog 8-02 displays the marks of two quizzes for the three students enrolled in CP999. Each of the three students is given two bonus marks in quiz 1 as well.

The output of the program is shown in Console 2. The last two lines of the output show student Ids and below the Id are the marks of the respective pupils.

Course CP999 data:
Group 1 marks in Quiz 1: [153, 142, 132]

Student ID:     [123, 124, 125, 123, 124, 125]
Quiz 1 and 2 marks: [153, 142, 132, 190, 190, 30.5]

Loops and Lists

Loops are ideally suited to process and manipulate the data in lists. Consider a list containing sales data for a thousand days. We have a list of a thousand floats, and we want to find out how many days the sales were below a given threshold. A Python program can perform this efficiently using loops. A loop will iterate over the list, element by element, and count the number of values which are below the threshold.

8.4.1 While Loops

We have worked with while loops before, so we will jump to a code example right away. Prog 8-03 has a list containing students' data. Each student has the following information recorded in the list:

1. Name
2. Score in course 1
3. Score in course 2

Data for all the students is concatenated in a single list like below. Cathy scored 84 in course 1 and 77 in course 2.

Figure 1. A school principal.  Retrieved from https://pixabay.com/. Free for commercial use.

The School principal is interested to know the average marks in each of the two courses. Code Listing 3 shows the source code of the program.

There are two loops in the program.

The first loop displays the full raw data. Data is displayed on the console, with each student in a separate row.

The second loop calculates the average score in each of the two subjects. A single loop is used to calculate averages for both the courses.

The program will function properly only if the following requirements are met:

1. Students marks are integers or floats.
2. Each student has name and marks in two subjects listed, i.e. three elements per student.
3. Marks for course 1 are mentioned before marks for course 2.
4. Student data is concatenated together one after the other without interleaving.

 # Program Name: Prog 8-03
 # This program is part of Lesson 08 of the course 
  
 def main ():
        st_data = ["Harris", 80, 90, "Maria", 90, 99, "Cathy", 84, 77]
        no_students = len(st_data)  / 3
  
        count = 0
        print("Raw Data: ")
        while count < len(st_data):
            print (f"{st_data[count]}", end = ' ')
            if ((count + 1) % 3 == 0):
                print()
            count += 1

    print()

    count = 1
    total_course_1 = 0
        total_course_2 = 0

    while (count < len(st_data)):
        total_course_1 += st_data[count]
        total_course_2 += st_data[count + 1]
        count += 3

    av_course_1 = total_course_1 / no_students
    av_course_2 = total_course_2 / no_students

30.         print(f"Course 1 Average: {av_course_1:.2f}")
3       print(f"Course 2 Average: {av_course_2:.2f}")
3  
3 main()

The output of the program is shown in Console 3.

Raw Data: 
Harris 80 90 
Maria 90 99 
Cathy 84 77 

Course 1 Average: 84.67
Course 2 Average: 88.67

8.4.2 For Loops

For loops are designed for iterating over containers. In comparison to while loops, you will see the iterations are simpler to manage using for loops, but on the other hand the control over the iterations is limited as well. Prog 8-04 in Code Listing 4 shows a program with four for loops. The first and the fourth loops iterate over the indexes of the list, whereas the second and the third loops iterate over the values in the list.

In this program we have three lists:

1. A list with the names of the weekdays in a short form.
2. A list with high temperatures for each day of the week.
3. A list with low temperatures for each day of the week.

The name of a weekday and its corresponding high and low temperatures are all stored at the same index position in every list. The program calculates and prints the following information on the console:

1. A table with the weekdays, high and low temperatures for each day. This is achieved in the first for loop, which iterates over the index positions.
2. Average high temperature of the week. It is calculated using a for loop (second loop in the program). The for loop iterates over the values of high_temperatures.
3. Average low temperature of the week. It is calculated using a for loop (third loop in the program) and it iterates over the values of low_temperatures.
4. A table with weekdays and an approximate average temperature of each day is computed and printed. A for loop is used, which iterates over the indexes of the three lists.

 # Program Name: Prog 8-04
 # This program is part of Lesson 08 of the course 
  
 def main ():
        days = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
        high_temperatures = [35, 30, 32, 40, 28, 29, 29]
        low_temperatures = [8, 7, 7, 0, 1, -1, 5]
  
        print("Daily High and Low Temperatures")
        print (f"{'Day'}\t{'High'}\t{'Low'}")
        for idx in range(len(days)):
            print(f"{days[idx]}\t{high_temperatures[idx]}\t{low_temperatures[idx]}")
        print()

    total_high = 0
    for val in high_temperatures:
        total_high += val
    print(f"Average High:\t{total_high / 7:.1f}")

        total_low = 0
    for val in low_temperatures:
        total_low += val
    print(f"Average Low:\t{total_low / 7:.1f}")

    print("\nDaily Averages")
    print (f"{'Day'}\t{'Average'}")
    for idx in range(len(days)):
        avg = (high_temperatures[idx] + low_temperatures[idx]) / 2
        print(f"{days[idx]}\t{avg}")
30.  
3 main()

First, let's go over the code in lines 5 to 7 and lines 15 to 23.

The syntax and loop formation was simplest in the second and third loop, but we had very little control. If we want to print multiple lists together (like in the first loop) or perform computations using data from multiple lists (like in fourth loop), we need to iterate over a list using index positions. It gives relatively more control to the programmer. Next, we will go through the code in lines 9 to 13 and 25 to 29 to demonstrate iteration over the index positions.

The output of the program is shown in Console 4.

Daily High and Low Temperatures
Day High    Low
Mon 35  8
Tue 30  7
Wed 32  7
Thu 40  0
Fri 28  1
Sat 29  -1
Sun 29  5

Average High:   31.9
Average Low:    3.9

Daily Averages
Day Average
Mon 21.5
Tue 18.5
Wed 19.5
Thu 20.0
Fri 14.5
Sat 14.0

Slicing

List slicing is a powerful method to read a subset of elements. We have used the following syntax for extracting a single element from a list:

element = my_list[2]

Rather than just specifying an index position in the square brackets, we can specify multiple indexes separated by colons. Prog 8-05 in Code Listing 5 shows code that creates a list of noble gasses and then uses slicing to retrieve data from the list. The print statements in the program output an element or a subset of elements in each line of code. Along with the output, the code is also included as a string to assist in understanding.

 # Program Name: Prog 8-05
 # This program is part of Lesson 08 of the course 
  
 def main ():
        nobles = ['helium', 'neon', 'argon', 'krypton', 'xenon', 'radon']
        print(f"nobles[1]\t{nobles[1]}")
        print(f"nobles[len - 1]\t{nobles[len(nobles) - 1]}")
  
        print("***slicing***")
  
        print(f"nobles[1:3]\t{nobles[1:3]}")
        print(f"nobles[1:2]\t{nobles[1:2]}")
        print(f"nobles[1:13]\t{nobles[1:13]}")
    print(f"nobles[1:5:2]\t{nobles[1:5:2]}")
    print(f"nobles[:]\t{nobles[:]}")
    print(f"nobles[1:]\t{nobles[1:]}")
    print(f"nobles[:3]\t{nobles[:3]}")
    print(f"nobles[-3:-1]\t{nobles[-3:-1]}")
    print(f"nobles[5:1:-1]\t{nobles[5:1:-1]}")
        print(f"nobles[0:len]\t{nobles[0: len(nobles)]}")

main()

Line by line code description is given below:

The output of Prog 8-05 is given in Console 5.

nobles[1]   neon
nobles[len-1] radon
***slicing***
nobles[1:3] ['neon', 'argon']
nobles[1:2] ['neon']
nobles[1:13]    ['neon', 'argon', 'krypton', 'xenon', 'radon']
nobles[1:5:2]   ['neon', 'krypton']
nobles[:]   ['helium', 'neon', 'argon', 'krypton', 'xenon', 'radon']
nobles[1:]  ['neon', 'argon', 'krypton', 'xenon', 'radon']
nobles[:3]  ['helium', 'neon', 'argon']
nobles[-3:-1]   ['krypton', 'xenon']
nobles[5:1:-1]  ['radon', 'xenon', 'krypton', 'argon']
nobles[0:len]   ['helium', 'neon', 'argon', 'krypton', 'xenon', 'radon']

Lists in Functions

There are two methods of passing data. One is pass by value, and the second is pass by reference. When we pass parameters to a function, the data is passed by value for strings, integers, and floats, but in case of lists, it is passed by reference.

Figure 2. Man and woman collaborating on a computer. Retrieved from https://pixabay.com/. Free for commercial use.

Let's take a real world example. Suppose you are working with your friend on an essay. You complete a few sections of the essay, and now you friend needs to write a few sections. You have two options:

1. You make a copy of the essay you wrote and mail it to your friend to work on it. In this case, you keep the original copy separately. Any changes that your friend makes will not be reflected in the original. This is pass by value.
2. You send the address of the original copy that you were working on. Your friend gets the original and works on it. In this case any changes your friend makes will be made in the original copy. On the other hand, you saved a few papers. This is pass by reference.

8.6.1 Copying lists

Prog 8-06 has two lists containing names of domestic and wild animals. It shows three methods to copy data from a list. The first method is copying by reference, whereas the other two are copying by value. The source code is shown in Code Listing 6.

 # Program Name: Prog 8-06
 # This program is part of Lesson 08 of the course 
  
 def main ():
        domestic = ["cat", "dog", "parrot"]
        wild = ["tiger", "lion", "cheetah"]
  
        domestic_copy = domestic
        domestic_copy[0] = "goat"
        print(f"domestic\t{domestic}")
        print(f"domestic_copy\t{domestic_copy}")
  
        wild_copy_1 = wild.copy()
    wild_copy_1[0] = "elephant"
    print(f"wild\t\t{wild}")
    print(f"wild_copy_1\t{wild_copy_1}")

    wild_copy_2 = wild[:]
    wild_copy_2[0] = "giraffe"
        print(f"wild\t\t{wild}")
    print(f"wild_copy_2\t{wild_copy_2}")    

main()

Line by line discussion of the source code is given below:

The output of the program is shown in Console 6. The change made in domestic_copy is also reflected in domestic, whereas changes made to wild_copy_1 and wild_copy_2 did not alter wild.

domestic        ['goat', 'dog', 'parrot']
domestic_copy   ['goat', 'dog', 'parrot']
wild            ['tiger', 'lion', 'cheetah']
wild_copy_1     ['elephant', 'lion', 'cheetah']
wild            ['tiger', 'lion', 'cheetah']
wild_copy_2     ['giraffe', 'lion', 'cheetah']

Figure 3. Copying data by reference. Created by Muhammad Muddassir Malik. Used with permission.

Figure 4. Copying data by value. Created by Muhammad Muddassir Malik. Used with permission.

8.6.2 Passing Lists as Arguments

Strings and numbers are passed to another function by value. Lists are always passed by reference. That means, if a function changes a list that was passed to it, the change will be reflected in the original as well. Passing by reference has a big advantage in terms of memory consumption.

Consider a list containing ages of all the voters for the upcoming federal elections. Understandably, this list will be quite large. We have a function that can calculate statistical measures like total number of voters, voters above the age of 50, and the average age of the voters. If such a long list is passed to the function by value, the copying will take time and also the copied list will consume a lot of additional memory. On the other hand, the changes you make will be permanent. A programmer needs to use copy by value or copy by reference appropriately.

Code Listing 7 shows Prog 8-07. A list named team_exp contains the experience of the team members in years.

 # Program Name: Prog 8-07
 # This program is part of Lesson 08 of the course 
  
 def statistical_measures (li):
        minimum = min(li)
        maximum = max(li)
        total = sum(li)
        average = total / len(li)
  
        print(f"Min: {minimum:d}, Max: {maximum:d}")
        print(f"Average: {average:.2f}")
  
 def sort_data (li):
    choice = input("A for ascending, D for decending: ")
    if (choice == "A"):
        li.sort()
    elif (choice == "D"):
        li.sort(reverse = True)
    else:
            print("Sorting Failed")

2 def find_new(li, years):
    li.sort()
    cutoff = 0
    for idx in range(len(li)):
        if (li[idx] > 7):
            cutoff = idx
            break
    return li[0: cutoff]
30.  
3 def main ():
3       team_exp = [10, 4, 5, 7, 8, 8, 3, 2, 1, 10, 10]
3       print("1. team_exp ", team_exp)
3  
3       statistical_measures (team_exp)
3       print("2. team_exp ", team_exp) 
3  
3       sort_data (team_exp)
3       print("3. team_exp ", team_exp)
40.  
4       new_players = find_new(team_exp.copy(), 7)
4       print("4. team_exp ", team_exp)
4       print("5. new_players ", new_players)
4   
4 main()

The program performs the following functionality:

1. Calculate the minimum, maximum and average experience of the team members. These computations are performed in a function named statistical_measures. The calculations will not change the original data, so we can safely pass the list by reference to such a function without risking any changes.
2. Sort the data in ascending order or descending order based on user input. This is accomplished in the sort_data function. We want the original data to be sorted, so passing by reference is the right choice in this case too.
3. Make a list of new players with experience less than or equal to 7 years. find_new function does this job. A new list with a subset of data will be generated in this function, so we do not want the original to be modified. In this case passing by value is a better choice.

There are 5 print statements in the program, and 4 of the print statements display team_exp at different points of execution. The serial numbers are printed to assist in relating output to the appropriate print call. The output of the program is shown in Console 7.

1. team_exp is passed by reference to statistical_measures, but as the function does not change any data, the list remains the same. See the first and the second print statements.
2. team_exp is passed by reference to sort_data, and the intention is to modify the original data. The function does not return anything, but the changes are reflected in team_exp inside the main function. See the second and the third print statements.
3. team_exp is passed by value to find_new by using the copy function. team_exp in the main function and li in the find_new function point to different lists. find_new creates a new list and returns it to the main function. team_exp remains unchanged (see the third and the fourth print statements)

1. team_exp  [10, 4, 5, 7, 8, 8, 3, 2, 1, 10, 10]
Min: 1, Max: 10
Average: 6.18
2. team_exp  [10, 4, 5, 7, 8, 8, 3, 2, 1, 10, 10]
A for ascending, D for decending: D
3. team_exp  [10, 10, 10, 8, 8, 7, 5, 4, 3, 2, 1]
4. team_exp  [10, 10, 10, 8, 8, 7, 5, 4, 3, 2, 1]
5. new_players  [1, 2, 3, 4, 5, 7]

Built-in Methods

We have seen build-in methods in previous lessons. Lists have some methods which are specifically designed for processing data stored in lists. The description of these methods is given on the official Python website.

Prog 8-08 shown in Code Listing 8 demonstrates the use of some of the common methods. The program has a list named schools. Serial numbers are included in the print statements to make it easier to correlate the output with the code.

 # Program Name: Prog 8-08
 # This program is part of Lesson 08 of the course 
  
 def main ():
        schools = ["WLU", "CalgaryU", "McGill", "TUWien"]
        schools.insert(3, "NU")
        print("1. ", schools)
        schools.append("uToronto")
        print("2. ", schools)
  
        schools.append("WLU")
        occ_of_WLU = schools.count("WLU")
        print("3. ", occ_of_WLU)
    del schools[len(schools) - 1]
    print("4. ", schools)
    print("5. ", schools.count("CalgaryU"))

    schools.extend(["KU", "NUS", "BU"])
    print("6. ", schools)
 
    print("7. ", schools.index("TUWien", 2))

    schools.insert(1, "MIT")
    print("8. ", schools)

    print("9. ", schools.pop())
    print(" ", schools)

    print(" ", schools.pop(0))
30.         schools.append("WLU")
3       print(" ", schools)
3  
3       schools.reverse()
3       print(" ", schools)
3  
3       schools.sort()
3       print(" ", schools)
3  
3       schools.sort(reverse = True)
40.         print(" ", schools)
4  
4       schools.clear()
4       print(" ", schools) 
4  
4 main()

The table below lists the methods used in the above program and the description of their functionality.

The output of the program is shown in Console 8.

 ['WLU', 'CalgaryU', 'McGill', 'NU', 'TUWien']
 ['WLU', 'CalgaryU', 'McGill', 'NU', 'TUWien', 'uToronto']
 2
 ['WLU', 'CalgaryU', 'McGill', 'NU', 'TUWien', 'uToronto']
 1
 ['WLU', 'CalgaryU', 'McGill', 'NU', 'TUWien', 'uToronto', 'KU', 'NUS', 'BU']
 4
 ['WLU', 'MIT', 'CalgaryU', 'McGill', 'NU', 'TUWien', 'uToronto', 'KU', 'NUS', 'BU']
 BU
  ['WLU', 'MIT', 'CalgaryU', 'McGill', 'NU', 'TUWien', 'uToronto', 'KU', 'NUS']
  WLU
  ['MIT', 'CalgaryU', 'McGill', 'NU', 'TUWien', 'uToronto', 'KU', 'NUS', 'WLU']
  ['WLU', 'NUS', 'KU', 'uToronto', 'TUWien', 'NU', 'McGill', 'CalgaryU', 'MIT']
  ['CalgaryU', 'KU', 'MIT', 'McGill', 'NU', 'NUS', 'TUWien', 'WLU', 'uToronto']
  ['uToronto', 'WLU', 'TUWien', 'NUS', 'NU', 'McGill', 'MIT', 'KU', 'CalgaryU']
  []

Conclusion

In this lesson, we learnt how we can use lists to put together data and to process them efficiently. for loops are designed to process data in the containers. while loops provide us with more control. Build-in methods of list and slicing help programmers achieve functionality with less code.

The assignment will reinforce the concepts covered in this lesson and in the textbook. In the next lesson you will learn more about strings. The indexing of strings also starts with zero like in the case of lists.

We hope you are ready to attempt this week’s quiz and assignment now. They are available on MyLearningSpace. You are encouraged to consult the syllabus for clarity about the deadlines for the preparation activities, quizzes, and assignments. Please regularly visit MyLearningSpace for announcements, course materials, and discussion boards.