INTRODUCTION

Sometimes you have to store values that belong together, but their exact number is not known during the creation of the program. Because of this, you will need a data structure where you can store multiple values. The structure should be flexible enough to take the order of the added values into account. It is obvious in this case to use a sequence of simple containers, which you have already heard about, namely a list. Here you will find out in detail how to work with lists.

A list consists of individual elements arranged one after the other. In contrast to an unstructured set of elements, there is a first and a last element, and all the other elements except the last have a successor.

Lists (and similar containers) are enormously important for programming. The operations possible with lists are very descriptive. The most important are:

	Adding elements (at the end, at the beginning, somewhere in between)
	Reading elements
	Changing elements
	Removing elements
	Iterating all elements
	Sorting elements
	Searching for elements

In Python you can store any data in lists, not only numbers. The individual elements can even have a different type and you can, for example, store numbers and letters in the same list.

GRADE LIST

You can interpret a list as a variable. It thus has a name and a value, namely its elements. You create it with a pair of square brackets, e.g. li = [1, 2, 3] generates a list with the elements 1, 2 and 3. A list can also be empty. You can define an empty list with li = [].

You can view the list at any time with a print command, just simply write print bioGrades.
If you want to calculate your grade point average, you have to run through the list. You can do this easily and elegantly with a for loop, because

for grade in bioGrades:

copies every list value in order to the variable grade, and you can then use this in the loop body.

bioGrades = []
bioGrades.append(5.5)
print(bioGrades)
bioGrades.append(5)
print(bioGrades)
bioGrades.append(5.5)
print(bioGrades)
bioGrades.append(6)
print(bioGrades)
count = 0
for note in bioGrades:
    count += note
print("Average: " + str(count / len(bioGrades)))

MEMO

LIST WITH A FIXED NUMBER OF ELEMENTS

It is often already known how long a container list has to be, and that all elements have the same data type, when creating the program. In many programming languages you call such a data structure an array. The individual elements are usually accessed via their index. In Python there is no such data type with fixed length and instead you use a list.

The program defines a polygon as a list with 4 vertices (these are again defined as lists with 2 coordinates). In order to access them with indices from the start, create a list with 4 zeros polygon = [0, 0, 0, 0]. You can also use the shorthand notation polygon = [0] * 4. After that, you copy in the 4 vertices, which replaces the zeros by point lists. With a for loop you display the polygon.

from gpanel import *

pA = [0, -3]
pB = [5, -3]
pC = [0, 7]
pD = [-5, 7]

makeGPanel(-10, 10, -10, 10)
line(-10, 0, 10, 0)
line(0, -10, 0, 10)

polygon = [0] * 4  # list with 4 elements, initialized with 0
polygon[0] = pA
polygon[1] = pB
polygon[2] = pC
polygon[3] = pD

for i in range(4):
    k = i + 1
    if k == 4:
        k = 0
    line(polygon[i], polygon[k])

MEMO

INSERTING AND DELETING ELEMENTS

The program shows how a word processor works. The entered characters are inserted into a list of letters. It is clear that you do not know how many letters you will enter in the beginning, so a list is the ideal data structure. In addition, you see a text cursor which can be set to any position in the text with a mouse click.

When you type using a character key the letter is inserted to the right of the cursor and the list grows. When you use the backspace key the character to the left of the cursor is deleted and the list shrinks. In order to represent everything nicely, you write the characters as text with a text color and background color in a GPanel. For this you run through the list with a list index i.

from gpanel import *

BS = 8
SPACE = 32
DEL = 127

def showInfo(key):
    text = "List length = " + str(len(letterList))
    if key != "":
        text += ". Last key code = " + str(ord(key))
    setStatusText(text)  
        
def updateGraphics():
    clear()
    for i in range(len(letterList)):
        text(i, 2, letterList[i], Font("Courier", Font.PLAIN, 24), 
              "blue", "light gray")
    line(cursorPos - 0.2, 1.7, cursorPos - 0.2, 2.7) 

def onMousePressed(x, y):
    setCursor(x)
    updateGraphics()

def setCursor(x):
    global cursorPos
    pos = int(x + 0.7)
    if pos <= len(letterList):    
       cursorPos = pos

makeGPanel(-1, 30, 0, 12, mousePressed = onMousePressed)

letterList = []
cursorPos = 0
addStatusBar(30)
setStatusText("Enter Text. Backspace to delete. Mouse to set cursor.")
lineWidth(3)

while True:
    delay(10)
    key = getKey()
    if key == "":
        continue
    keyCode = ord(key)
    if keyCode == BS:  # backspace
        if cursorPos > 0:
            cursorPos -= 1
            letterList.pop(cursorPos)
    elif keyCode >= SPACE and keyCode != DEL:      
        letterList.insert(cursorPos, key)
        cursorPos += 1
    updateGraphics()
    showInfo(key)

MEMO

ALREADY A PROFESSIONAL PROGRAM

You are already able to visualize a graph with your knowledge [more... Graph Drawing is a whole topic of computer science]

The task (also called "program specification") is the following:
You can create filled circles in the graphics window with a right mouse click, which are considered to be nodes of a graph, where the nodes are interconnected with lines, called edges. Go on a node with the mouse; with a left mouse press and subsequent dragging you can move it around while the graph is updated constantly. If you right click on an existing node, it will be removed.

It is wise that you solve complex tasks by first looking at a subtask that has not yet met all of the final program specifications. For example, first write a program with which you can create nodes with each click. They should already be connected with all other existing nodes, but you cannot move them yet. It seems obvious to model the graph with a list graph in which you store the node points.

The nodes themselves are points with two coordinates P(x, y) that you model with a point list pointlist [x, y]. It is therefore a list, that then again contains lists as elements (but with a fixed length of 2). You accomplish joining the nodes with double for loop, but you must make sure that the nodes are only connected once.

from gpanel import *

def drawGraph():
    clear()
    for pt in graph:
        move(pt) 
        fillCircle(2)
    
    for i in range(len(graph)):
        for k in range(i, len(graph)):
            line(graph[i], graph[k])

def onMousePressed(x, y):
    pt = [x, y]
    graph.append(pt)
    drawGraph()

graph = []
makeGPanel(0, 100, 0, 100, mousePressed = onMousePressed)

MEMO

EXERCISES

MUTABLE AND IMMUTABLE DATA TYPES

In Python all data types are stored as objects, including the numeric types (integer, float, long, complex). As you know, you can access an object by its name. It is also said that the name refers to or is bound to the object. Therefore, such a variable is also called a reference variable.

A particular object can be referred to by more than one name. AN additional name is also called an alias. The following example shows how to deal with this.

A triangle is defined by the three vertex lists a, b, c. You can create an alias with the statement a_alias = a, so that a and a_alias both refer to the same list. If you alter the vertex list with the name a, the changes are obviously also visible in a_alias, since a and a_alias refer to the same list.

from gpanel import *

makeGPanel(-10, 10, -10, 10)

a = [0, 0]  
a_alias = a
b = [0, 5]
c = [5, 0]

fillTriangle(a, b, c)
a[0] = 1
setColor("green")
fillTriangle(a_alias, b, c)

What is the explanation for that? The reason is that numbers are immutable objects and the statement xA = 1 generates a new number. xA_alias is therefore still 0.

The difference between immutable and mutable data types can also be seen when passing parameters to functions. When an immutable object is passed, it cannot be changed inside the function. When a mutable object is delivered, the function can change the object. Such a change is called a secondary or side effect. In order to have a good programming style, you should use side effects sparingly because they can cause some annoying misconduct that is difficult to trace.

In the following example, the function translate() changes the passed vertex lists.

from gpanel import *

def translate(pA, pB, pC):
  pA[0] = pA[0] + 5
  pA[1] = pA[1] + 2
  pB[0] = pB[0] + 5
  pB[1] = pB[1] + 2
  pC[0] = pC[0] + 5
  pC[1] = pC[1] + 2

makeGPanel(-10, 10, -10, 10)

a = [0, 0]  
b = [0, 5]
c = [5, 0]
fillTriangle(a, b, c)
translate(a, b, c)
setColor("green")
fillTriangle(a, b, c)

MEMO