More Lists

From Knowledge Kitchen
Jump to navigation Jump to search

List functions

  • x = [0, 1, 2]
  • find out how many elements are in a list: len(x) -> 3
  • append a single value to a list: x.append(3) -> [0, 1, 2, 3]
  • append a sequence to a list: x.extend("cat") -> [0, 1, 2, 3, 'c', 'a', 't']
  • remove the last element from a list: x.pop() -> [0, 1, 2, 3, 'c', 'a']
  • remove any element from a list: x.pop(4) -> [0, 1, 2, 3, 'a']
  • remove the first occurance: x.remove("a") -> [0, 1, 2, 3]
  • insert an element into the list: x.insert(2, "foo") -> [0,1,'foo',2,3]
  • reverse a list: x.reverse() -> [3, 2, 1, 0]
  • sort a list: x.sort() -> [0, 1, 2, 3]

Multidimensional Lists

A two-dimensional list:

x = [

	[ "this is" , "the first" , "row" ],
	[ "another", "list, another", "row" ],
	[ "the" , "last" , "row" ]

  • access individual elements: x[1][0] -> "another"
  • overwrite individual elements: x[2][2] = "stand"
  • looping through multidimensional list with nested for loops


Comparison of mutable vs. immutable data types

#ints, floats, bools, nonetypes, and strings are all immutable
#lists and dictionaries are mutable

x = 5
y = x #for immutable data types, the assignment operator makes a copy
x = 10

x = [1,2,3,4]
y = x #for mutable data types, the assignment operator makes an alias

Referring to list elements by their index numbers

# this is indexing. x[1] will access to second element, x[0] will access to first element, etc.

# x points to a particular list value in memory
x = [
        "diet coke",

#so x[0] will print out tomatoes, x[1] will print out potatoes

# manually add a new element to the list
#x[5] = "carrots" # this causes an error, because the the index 5 is higher than any element in the list
x.append("carrots") #this is the proper way to add a new element to the list at index 5

# example of how to loop through the elements of a list
for i in x:

List functions

x = [] #create a blank list
x.append("bob") #add an element to the list
x.pop() #removes the last element from the list
x.pop(1) #if you indicate an index, it deletes the element with that index
x.insert(1, "francisco") #inserts a new element at index 1
x.extend("kat")#extend adds elements from a sequence into the list

#note that apend and extend do different things... know the difference!
#x.extend(["harry", "alicia", "shmuli"])
#x.append(["harry", "alicia", "shmuli"])

print(x) #do you really need a comment explaining this line?

List functions (again)

homeTowns = ["Denver", "Brooklyn", "Croton-on-Hudson", "Tupelo", "Mahopac", "Albany", "Boston", "Istanbul", "Medellin", "Jacksonville", "Osnabrueck", "Seattle", "San Diego", "Scranton", "San Antonio", "Sacramento", "Montval", "Weston"]

#get the length of any list using the len() function
lengthOfList = len(homeTowns)

#add another element to the list
homeTowns.append("New York")

#insert a new element into position #3 the old-school way
pos = 8
firstPart = homeTowns[:pos]
secondPart = homeTowns[pos:]
homeTowns = firstPart + ["Newark"] + secondPart

#insert a new element into position #3 the modern way
homeTowns.insert(8, "Vancouver")

#extend the list
homeTowns.extend(["foo", "bar"])

#remove the last element from the list based on its position

#remove the first occurance of a specific value

#try to remove the first occurance of a specific value that is actually not in the list
counter = 0
for value in homeTowns:
    if value == "San Francisco":
    counter = counter + 1
#reverse the order of a list

#sort the order of a list alphabetically or numerically


Sort order

#sort numeric lists
x = [10, 20.1, 5.0, 100, -6, 1]
x.reverse() #flip it in reverse order

#sort string lists
x = ["bob", "rodrigo", "alonso", "zlata", "kevin", "xio"]

#cannot sort mixed type lists
#x = ["bob", 10, True, None, 1.9, False, [], "harry"]
#x.sort() #an error... why would you ever want to do this?

#sort boolean list
x = [False, True, False, True, True, False, False]
x.sort() #falses are like 0, Trues are like 1

#cannot sort NoneType values... why would you want to?
#x = [None, None, None, None]
#x.sort() #an error

Populating a list from user input, and then reversing its order

listOfNumbers = [] #blank list

keepLooping = True #flag

#loop until the flag is false
while keepLooping:
    num = input("What's the number?")
    if num.lower() == "get me out of here!":
        keepLooping = False
    elif num.isnumeric():
        num = int(num)
        print("Please enter a number...")
#reverse the order of the list
listOfNumbers = listOfNumbers[::-1] 

#loop through the list and print out all the values
for value in listOfNumbers:


Calculating averages

average = 0
readings = []

reading = ""
while reading != "exit":
    reading = input("Please enter a reading: ")
    if reading.isnumeric():
        reading = int(reading)
        readings.append(reading) #add new element to list

sum = 0
for reading in readings:
    sum = sum + reading    

numReadings = len(readings) #how many readings are there?
average = sum / numReadings  #caculate the average

print("The average reading was: ", average)

Mood diagnostic tool

def getNumberFromMood(mood):
    if mood == "angry":
        return 0
    elif mood == "sad":
        return 1
    elif mood == "apathetic":
        return 2
    elif mood == "happy":
        return 3

def getMoodFromNumber(num):
    if num == 0:
        return "angry"
    elif num == 1:
        return "sad"
    elif num == 2:
        return "apathetic"
    elif num == 3:
        return "happy"
moods = []

response = ""
while response != "exit":
    response = input("Please enter your current mood: ")
    if response != "exit":

sum = 0
i = len(moods) - 1
counter = 0
while i > 0:
    sum = sum + getNumberFromMood(moods[i])
    i = i - 1
    counter = counter + 1
    if counter == 7:

average = sum / len(moods)
average = round(average) #round to the closest integer


mood = getMoodFromNumber(average)


Strings and Lists are both Sequence data types, and so share a lot in common.

x = "this is a string"

#x[2] = "u" #this is an error... you cannot modify strings... they are immutable

#loop through the characters in the string, the same way you loop through elements in a list
for character in x:


x = [
        "diet coke",

# make an alias of x that points to the same list value in memory
y = x

# this works just like the previous example.
y[2] = "buttered haddock"

for element in x:


x = [
        "diet coke",

# copy of the first 3 element in x stored in y
y = x[0:3] #use slice indexing

x[2] = 'butternut squash'

#loop through the copy
for element in y:

y = x[::] # starting:ending:spacing(?) if the last one is -1, the list will be backwards.
# negative number always start from end of list to the biginning

#check whether a value exists as an element in the list
if "sprats" in x:
    print("ooooh, you like sprats??")

Tic Tac Toe (the basic idea)

A game of Tic Tac Toe requires a variety of list-related techniques in one example. The following code shows the basic idea of how to store the game board as a two-dimensional list.

def showBoard():
    global board
    for row in board:
        for col in row:
            print(col, end="")

board = [
           ["-", "-", "-"],
           ["-", "-", "-"],
           ["-", "-", "-"] 

player = "0"
counter = 0

while True:
    print("Please enter the row and column where you'd like to move in the format: 1,1")
     move = input("Where would you like to go?")

    #the split method chops up a string and returns a list
    coordinates = move.split(",")
    row = int(coordinates[0])
    col = int(coordinates[1]) 

    board[row][col] = player

    if counter % 2 == 0:
        player = "X"
        player = "O" 

    counter = counter + 1

Tic Tac Toe (complete)

This version of the Tic Tac Toe game includes various kinds of input validation, and checks for wins with each move.

def printBoard():
    global board
    for row in board:
        print("|", end="")
        for col in row:
            col = format(col, "1s")
            print(col, end="|")

#set up the blank game board as a two-dimensional list
board = [

            ["", "", ""],
            ["", "", ""],
            ["", "", ""]


#set up variables for each player
player1 = "X"
player2 = "O"

#set a variable that stores the player whose turn it is currently
currentPlayer = player1

#kick into the game loop

while True:
    #print out the board
    #ask the user to enter their move
    print("It is", currentPlayer + "'s turn.")
    move = input("Where would you like to go?")

    #convert what the user entered into two numbers (as strings for now)
    move = move.replace(" ", "") #remove any spaces from the input

    #validate the input
    if move.find(",") < 0:
        print("Sorry, that's not a valid move...")
        print("Please enter the row and column as integers starting from zero serparated by commas")

    #parse the move    
    pos = move.split(",") #spit the input into two parts, around the comma
    row = pos[0] #get the first value
    col = pos[1] #get the second value

    #convert them to integers, if possible
    if row.isnumeric() and col.isnumeric():
        row = int(row)
        col = int(col)
        print("Sorry, that's not a valid move...")
        print("Please enter the row and column as integers starting from zero serparated by commas")

    #implement the move...

    isValidNumbers = len(board) > row and len(board[row]) > col
    if isValidNumbers:
        isEmptySpot = board[row][col] == ""
        if isEmptySpot:
            #allow the move to occur
            board[row][col] = currentPlayer
            print("Sorry, that position is taken.  Please try a different position")
        print("Sorry, that's not a valid move...")
        print("Please enter the row and column as integers starting from zero serparated by commas")

    #check to see whether anybody won...

    #set up a flag    
    isWon = False

    #check for horizontal wins in each row by seeing if the same values are in each column... ignore empty rows
    if board[0][0] != "" and (board[0][0] == board[0][1] == board[0][2]):
        isWon = True
    if board[1][0] != "" and (board[1][0] == board[1][1] == board[1][2]):
        isWon = True
    if board[2][0] != "" and (board[2][0] == board[2][1] == board[2][2]):
        isWon = True

    #check for vertical win in each column by seeing whether the same values are in each row... ignore empty columns
    if board[0][0] != "" and (board[0][0] == board[1][0] == board[2][0]):
        isWon = True
    if board[0][1] != "" and (board[0][1] == board[1][1] == board[2][1]):
        isWon = True
    if board[0][2] != "" and (board[0][2] == board[1][2] == board[2][2]):
        isWon = True

    #check for diagonal wins in both directions... ignore empty diagonal lines
    if board[0][0] != "" and (board[0][0] == board[1][1] == board[2][2]):
        isWon = True
    if board[0][2] != "" and (board[0][2] == board[1][1] == board[2][0]):
        isWon = True
    if isWon:
        #quit the loop

    #flip turns
    if currentPlayer == player1:
        currentPlayer = player2
        currentPlayer = player1

#if the program reaches this point, the game is over...
#print the board one last time

#announce the winner
print("The game is over")
print(currentPlayer, "won.")

What links here