6. list

6. List
1ARULKUMAR V Ap/CSE SECE

Opening Problem
Read one hundred numbers, compute their
average, and find out how many numbers are
above the average.

Solution
3
DataAnalysis Run
ARULKUMAR V Ap/CSE SECE

Objectives
• To describe why lists are useful in programming (§10.1).
• To create lists (§10.2.1).
• To invoke list’s append, insert, extend, remove, pop, index, count, sort, reverse methods
(§10.2.2).
• To use the len, min/max, sum, and random.shuffle functions for a list (§10.2.3).
• To access list elements using indexed variables (§10.2.4).
• To obtain a sublist using the slicing operator [start:end] (§10.2.5).
• To use +, *, and in/not in operators on lists (§10.2.6).
• To traverse elements in a list using a for-each loop (§10.2.7).
• To create lists using list comprehension (§10.2.8).
• To compare lists using comparison operators (§10.2.9).
• To split a string to a list using the str’s split method (§10.2.10).
• To use lists in the application development (§§10.3–10.5).
• To copy contents from one list to another (§10.6).
• To develop and invoke functions with list arguments and return value (§10.7–10.9).
• To search elements using the linear (§10.10.1) or binary (§10.10.2) search algorithm.
• To sort a list using the selection sort (§10.11.1)
• To sort a list using the insertion sort (§10.11.2).
• To develop the bouncing ball animation using a list (§10.12).

Creating Lists
5
list1 = list() # Create an empty list
list2 = list([2, 3, 4]) # Create a list with elements 2, 3, 4
list3 = list(["red", "green", "blue"]) # Create a list with strings
list4 = list(range(3, 6)) # Create a list with elements 3, 4, 5
list5 = list("abcd") # Create a list with characters a, b, c
list1 = [] # Same as list()
list2 = [2, 3, 4] # Same as list([2, 3, 4])
list3 = ["red", "green"] # Same as list(["red", "green"])
Creating list using the list class
For convenience, you may create a list using the following syntax:

list Methods
6
list
append(x: object): None
insert(index: int, x: object):
None
remove(x: object): None
index(x: object): int
count(x: object): int
sort(): None
reverse(): None
extend(l: list): None
pop([i]): object
Add an item x to the end of the list.
Insert an item x at a given index. Note that the first element in
the list has index 0.
Remove the first occurrence of the item x from the list.
Return the index of the item x in the list.
Return the number of times item x appears in the list.
Sort the items in the list.
Reverse the items in the list.
Append all the items in L to the list.
Remove the item at the given position and return it. The square
bracket denotes that parameter is optional. If no index is
specified, list.pop() removes and returns the last item in the
list.

Functions for lists
>>> list1 = [2, 3, 4, 1, 32]
>>> len(list1)
5
>>> max(list1)
32
>>> min(list1)
1
>>> sum(list1)
42
>>> import random
>>> random.shuffle(list1) # Shuffle the items in the list
>>> list1
[4, 1, 2, 32, 3]

Indexer Operator []
8
5.6
4.5
3.3
13.2
4.0
34.33
34.0
45.45
99.993
11123
myList = [5.6, 4.5, 3.3, 13.2, 4.0, 34.33, 34.0, 45.45, 99.993, 11123]
myList reference
myList[0]
myList[1]
myList[2]
myList[3]
myList[4]
myList[5]
myList[6]
myList[7]
myList[8]
myList[9]
Element value
list reference
variable
list element at
index 5

The +, *, [ : ], and in Operators
>>> list1 = [2, 3]
>>> list2 = [1, 9]
>>> list3 = list1 + list2
>>> list3
[2, 3, 1, 9]
>>> list3 = 2 * list1
>>> list3
[2, 3, 2, 3, 2, 3]
>>> list4 = list3[2 : 4]
>>> list4
[2, 3]

The +, *, [ : ], and in Operators
>>> list1 = [2, 3, 5, 2, 33, 21]
>>> list1[-1]
21
>>> list1[-3]
2
10
>>> list1 = [2, 3, 5, 2, 33, 21]
>>> 2 in list1
True
>>> list1 = [2, 3, 5, 2, 33, 21]
>>> 2.5 in list1
False

off-by-one Error
i = 0
while i <= len(lst):
print(lst[i])
i += 1

List Comprehension
List comprehensions provide a concise way to create items
from sequence. A list comprehension consists of brackets
containing an expression followed by a for clause, then
zero or more for or if clauses. The result will be a list
resulting from evaluating the expression. Here are some
examples:
12
>>> list1 = [x for x range(0, 5)] # Returns a list of 0, 1, 2, 4
>>> list1
[0, 1, 2, 3, 4]
>>> list2 = [0.5 * x for x in list1]
>>> list2
[0.0, 0.5, 1.0, 1.5, 2.0]
>>> list3 = [x for x in list2 if x < 1.5]
>>> list3
[0.0, 0.5, 1.0]

Comparing Lists
13
>>>list1 = ["green", "red", "blue"]
>>>list2 = ["red", "blue", "green"]
>>>list2 == list1
False
>>>list2 != list1
True
>>>list2 >= list1
False
>>>list2 > list1
False
>>>list2 < list1
True
>>>list2 <= list1
True

Splitting a String to a List
items = "Welcome to the US".split()
print(items)
['Welcome', 'to', 'the', 'US']
items = "34#13#78#45".split("#")
print(items)
['34', '13', '78', '45']

Problem: Lotto Numbers
Suppose you play the Pick-10 lotto. Each ticket has
10 unique numbers ranging from 1 to 99. You buy
a lot of tickets. You like to have your tickets to
cover all numbers from 1 to 99. Write a program
that reads the ticket numbers from a file and
checks whether all numbers are covered. Assume
the last number in the file is 0.
15
LottoNumbers RunLotto Numbers Sample Data

Problem: Lotto Numbers
16
False
False
False
False
.
.
.
False
False
isCovered
[0]
[1]
[2]
[3]
[98]
(a)
[97]
True
False
False
False
.
.
.
False
False
isCovered
[0]
[1]
[2]
[3]
[98]
(b)
[97]
True
True
False
False
.
.
.
False
False
isCovered
[0]
[1]
[2]
[3]
[98]
(c)
[97]
True
True
True
False
.
.
.
False
False
isCovered
[0]
[1]
[2]
[3]
[98]
(d)
[97]
True
True
True
False
.
.
.
False
True
isCovered
[0]
[1]
[2]
[3]
[98]
(e)
[97]

Problem: Deck of Cards
The problem is to write a program that picks four cards
randomly from a deck of 52 cards. All the cards can be
represented using a list named deck, filled with initial
values 0 to 51, as follows:
deck = [x for x in range(0, 52)]
17
DeckOfCards Run

Problem: Deck of Cards, cont.
18
0
.
.
.
12
13
.
.
.
25
26
.
.
.
38
39
.
.
.
51
13 Spades (♠)
13 Hearts (♥)
13 Diamonds (♦)
13 Clubs (♣)
0
.
.
.
12
13
.
.
.
25
26
.
.
.
38
39
.
.
.
51
deck
[0]
.
.
.
[12]
[13]
.
.
.
[25]
[26]
.
.
.
[38]
[39]
.
.
.
[51]
Random shuffle
6
48
11
24
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
deck
[0]
[1]
[2]
[3]
[4]
[5]
.
.
.
[25]
[26]
.
.
.
[38]
[39]
.
.
.
[51]
Card number 6 is the
7 (6 % 13 = 6) of
Spades (7 / 13 is 0)
10 (48 % 13 = 9) of
Clubs (48 / 13 is 3)
Queen (11 % 13 = 11) of
Spades (11 / 13 is 0)
Queen (24 % 13 = 11) of
Hearts (24 / 13 is 1)

Problem: Deck of Cards, cont.
19
cardNumber / 13 =
0 Spades
1 Hearts
2 Diamonds
3 Clubs
cardNumber % 13 =
0 Ace
1 2
.
.
10 Jack
11 Queen
12 King
DeckOfCards Run

GUI: Deck of Cards
20
DeckOfCardsDeckOfCardsGUI

Copying Lists
Often, in a program, you need to duplicate a list or a part
of a list. In such cases you could attempt to use the
assignment statement (=), as follows:
list2 = list1;
21
Contents
of list1
list1
Contents
of list2
list2
Before the assignment
list2 = list1;
Contents
of list1
list1
Contents
of list2
list2
After the assignment
list2 = list1;
Garbage

Passing Lists to Functios
def printList(lst):
for element in lst:
print(element)
22
Invoke the function
lst = [3, 1, 2, 6, 4, 2]
printList(lst)
Invoke the function
printList([3, 1, 2, 6, 4, 2])
Anonymous list

Pass By Value
Python uses pass-by-value to pass arguments to a
function. There are important differences between
passing the values of variables of numbers and
strings and passing lists.
Immutable objects
Changeable objects

Pass By Value (Immutable objects)
For an argument of a number or a string, the
original value of the number and string outside the
function is not changed, because numbers and
strings are immutable in Python.

Pass By Value (changeable objects)
For an argument of a list, the value of the
argument is a reference to a list; this reference
value is passed to the function. Semantically, it can
be best described as pass-by-sharing, i.e., the list in
the function is the same as the list being passed. So
if you change the list in the function, you will see
the change outside the function.

Simple Example
def main():
x = 1 # x represents an int value
y = [1, 2, 3] # y represents a list
m(x, y) # Invoke f with arguments x and y
print("x is " + str(x))
print("y[0] is " + str(y[0]))
def m(number, numbers):
number = 1001 # Assign a new value to number
numbers[0] = 5555 # Assign a new value to numbers[0]
main()

Subtle Issues Regarding Default Arguments
def add(x, lst = []):
if not(x in lst):
lst.append(x)
return lst
list1 = add(1)
print(list1)
list2 = add(2)
print(list2)
list3 = add(3, [11, 12, 13, 14])
print(list3)
list4 = add(4)
print(list4)
27
[1]
[1, 2]
[11, 12, 13, 14]
[1, 2, 4]
Output
default value is
created only once.

Returning a List from a Function
list1 = [1, 2, 3, 4, 5, 6]
list2 = reverse(list1)
28
def reverse(list):
result = []
for element in list:
result.insert(0, element)
return result
list
result
Note that list already has the reverse method
list.reverse()

Problem: Counting Occurrence of Each Letter
• Generate 100 lowercase
letters randomly and assign
to a list of characters.
• Count the occurrence of
each letter in the list.
29
CountLettersInList Run
…
…
chars[0]
chars[1]
…
…
chars[98]
chars[99]
…
…
counts[0]
counts[1]
…
…
counts[24]
counts[25]

Searching Lists
Searching is the process of looking for a specific element in
a list; for example, discovering whether a certain score is
included in a list of scores. Searching is a common task in
computer programming. There are many algorithms and
data structures devoted to searching. In this section, two
commonly used approaches are discussed, linear search
and binary search.
30
# The function for finding a key in the list
def linearSearch(lst, key):
for i in range(0, len(lst)):
if key == lst[i]:
return i
return -1
lst
key Compare key with lst[i] for i = 0, 1, …
[0] [1] [2] …

Linear Search
The linear search approach compares the key
element, key, sequentially with each element
in list. The method continues to do so until the
key matches an element in the list or the list is
exhausted without a match being found. If a
match is made, the linear search returns the
index of the element in the list that matches
the key. If no match is found, the search
returns -1.

Linear Search Animation
32
6 4 1 9 7 3 2 8
6 4 1 9 7 3 2 8
6 4 1 9 7 3 2 8
6 4 1 9 7 3 2 8
6 4 1 9 7 3 2 8
6 4 1 9 7 3 2 8
3
3
3
3
3
3
animation
Key List

Linear Search Animation
http://www.cs.armstrong.edu/liang/animation/LinearSea
rchAnimation.html
33
animation
Run

Binary Search
For binary search to work, the elements in the
list must already be ordered. Without loss of
generality, assume that the list is in ascending
order.
e.g., 2 4 7 10 11 45 50 59 60 66 69 70 79
The binary search first compares the key with
the element in the middle of the list.

Binary Search, cont.
• If the key is less than the middle element,
you only need to search the key in the first
half of the list.
• If the key is equal to the middle element,
the search ends with a match.
• If the key is greater than the middle
element, you only need to search the key in
the second half of the list.
35
Consider the following three cases:

Binary Search
36
1 2 3 4 6 7 8 9
1 2 3 4 6 7 8 9
1 2 3 4 6 7 8 9
8
8
8
Key List
animation

Binary Search Animation
http://www.cs.armstrong.edu/liang/animation/BinarySea
rchAnimation.html
37
animation
Run

38
[0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12]
2 4 7 10 11 45 50 59 60 66 69 70 79
key is 11
key < 50
lst
mid
[0] [1] [2] [3] [4] [5]
key > 7
key == 11
highlow
mid highlow
lst
[3] [4] [5]
mid highlow
lst
2 4 7 10 11 45
10 11 45

39
[0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12]
2 4 7 10 11 45 50 59 60 66 69 70 79
key is 54
key > 50
lst
mid
[0] [1] [2] [3] [4] [5] [6] [7] [8] [9] [10] [11] [12]
key < 66
key < 59
highlow
mid highlow
lst
[7] [8]
mid highlow
lst
59 60 66 69 70 79
59 60
[6] [7] [8]
highlow
59 60

The binarySearch method returns the index of the
element in the list that matches the search key if it
is contained in the list. Otherwise, it returns
-insertion point - 1.
The insertion point is the point at which the key
would be inserted into the list.

From Idea to Soluton
# Use binary search to find the key in the list
def binarySearch(lst, key):
low = 0
high = len(lst) - 1
while high >= low:
mid = (low + high) // 2
if key < lst[mid]:
high = mid - 1
elif key == lst[mid]:
return mid
else:
low = mid + 1
return –low - 1 # Now high < low, key not found

Sorting Lists
Sorting, like searching, is also a common task in
computer programming. Many different algorithms
have been developed for sorting. This section
introduces two simple, intuitive sorting algorithms:
selection sort and insertion sort.

Selection Sort
Selection sort finds the largest number in the list and places it last. It then finds the
largest number remaining and places it next to last, and so on until the list contains only a
single number. Figure 6.17 shows how to sort the list {2, 9, 5, 4, 8, 1, 6} using selection
sort.
43
2 9 5 4 8 1 6
swap
Select 1 (the smallest) and swap it
with 2 (the first) in the list
1 9 5 4 8 2 6
swap
The number 1 is now in the
correct position and thus no
longer needs to be considered.
1 2 5 4 8 9 6
swap
1 2 4 5 8 9 6
with 9 (the first) in the remaining
list
list
1 2 4 5 8 9 6Select 6 (the smallest) and swap it
list
1 2 4 5 6 9 8
swap
1 2 4 5 6 8 9
list
Since there is only one element
remaining in the list, sort is
completed
5 is the smallest and in the right
position. No swap is necessary
swap

Selection Sort Animation
http://www.cs.armstrong.edu/liang/animation/Selection
SortAnimation.html
44
animation
Run

From Idea to Solution
45
select the smallest element in lst[i.. len(lst)-1]
swap the smallest with lst[i], if necessary
# lst[i] is in its correct position.
# The next iteration apply on lst[i+1..len(lst)-1]
lst[0] lst[1] lst[2] lst[3] ... lst[10]
...

Expand
46
currentMin = lst[i]
currentMinIndex = i
for j in range(i + 1, len(lst)):
if currentMin > lst[j]:
currentMin = lst[j]
currentMinIndex = j

Expand
47
# Find the minimum in the lst[i..len(lst)-1]
currentMin = lst[i]
currentMinIndex = i
currentMin = lst[j]
currentMinIndex = j
# Swap lst[i] with lst[currentMinIndex] if necessary
if currentMinIndex != i:
lst[currentMinIndex] = lst[i]
lst[i] = currentMin ARULKUMAR V Ap/CSE SECE

Wrap it in a Function
48
# The function for sorting the numbers
def selectionSort(lst):
for i in range(0, len(lst) - 1):
# Find the minimum in the lst[i..len(lst)-1]
currentMin = lst[i]
currentMinIndex = i
currentMin = lst[j]
currentMinIndex = j
# Swap lst[i] with lst[currentMinIndex] if necessary
if currentMinIndex != i:
lst[currentMinIndex] = lst[i]
lst[i] = currentMin
Invoke it
selectionSort(yourList)

Insertion Sort
myList = [2, 9, 5, 4, 8, 1, 6] # Unsorted
49
The insertion sort
algorithm sorts a list
of values by
repeatedly inserting
an unsorted element
into a sorted sublist
until the whole list
is sorted.
2 9 5 4 8 1 6Step 1: Initially, the sorted sublist contains the
first element in the list. Insert 9 into the sublist.
2 9 5 4 8 1 6Step2: The sorted sublist is [2, 9]. Insert 5 into the
sublist.
2 5 9 4 8 1 6Step 3: The sorted sublist is [2, 5, 9]. Insert 4 into
the sublist.
2 4 5 9 8 1 6Step 4: The sorted sublist is [2, 4, 5, 9]. Insert 8
into the sublist.
2 4 5 8 9 1 6Step 5: The sorted sublist is [2, 4, 5, 8, 9]. Insert
1 into the sublist.
1 2 4 5 8 9 6Step 6: The sorted sublist is [1, 2, 4, 5, 8, 9].
Insert 6 into the sublist.
1 2 4 5 6 8 9Step 7: The entire list is now sorted

Insertion Sort Animation
http://www.cs.armstrong.edu/liang/animation/Insertion
SortAnimation.html
50
animation
Run

Insertion Sort
myList = [2, 9, 5, 4, 8, 1, 6] # Unsorted
51
2 9 5 4 8 1 6
2 9 5 4 8 1 6
2 5 9 4 8 1 6
2 4 5 8 9 1 6
1 2 4 5 8 9 6
2 4 5 9 8 1 6
1 2 4 5 6 8 9
animation

How to Insert?
52
The insertion sort
algorithm sorts a list
of values by
repeatedly inserting
an unsorted element
into a sorted sublist
until the whole list
is sorted.
[0] [1] [2] [3] [4] [5] [6]
2 5 9 4list Step 1: Save 4 to a temporary variable currentElement
[0] [1] [2] [3] [4] [5] [6]
2 5 9list Step 2: Move list[2] to list[3]
[0] [1] [2] [3] [4] [5] [6]
2 5 9list Step 3: Move list[1] to list[2]
[0] [1] [2] [3] [4] [5] [6]
2 4 5 9list Step 4: Assign currentElement to list[1]

53
insert lst[i] into a sorted sublist lst[0..i-1] so that
lst[0..i] is sorted.
lst[0]
lst[0] lst[1]
lst[0] lst[1] lst[2]
lst[0] lst[1] lst[2] lst[3]
lst[0] lst[1] lst[2] lst[3] ...

54
insert lst[i] into a sorted sublist lst[0..i-1] so that
lst[0..i] is sorted.
InsertSort
Expand
k = i - 1
while k >= 0 and lst[k] > currentElement:
lst[k + 1] = lst[k]
k -= 1
# Insert the current element into lst[k + 1]
lst[k + 1] = currentElement

Case Studies: Bouncing Balls
55
BouncingBalls Run
Ball
x: int
y: int
dx: int
dy: int
color: Color
radius: int
The x-, y-coordinates for the center of the
ball. By default, it is (0, 0).
dx and dy are the increment for (x, y).
The color of the ball.
The radius of the ball.

6. list

Recommended

Recommended

More Related Content

What's hot

What's hot (19)

Similar to 6. list

Similar to 6. list (20)

More from PhD Research Scholar

More from PhD Research Scholar (20)

Recently uploaded

Recently uploaded (20)

6. list