More Lists

From Knowledge Kitchen
Jump to: navigation, 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

Examples

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
print(y)


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


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 = [
        "tomatoes",
        "potatoes",
        "sprats",
        "frings",
        "diet coke",
    ]

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

# 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:
    print(i)

List functions

x = [] #create a blank list
x.append("bob") #add an element to the list
x.append("sheila")
x.append("ramon")
x.append("polina")
x.append("francisco")
x.pop() #removes the last element from the list
x.pop()
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
homeTowns.pop()
homeTowns.pop(len(homeTowns)-1)

#remove the first occurance of a specific value
homeTowns.remove("Medellin")

#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":
        homeTowns.pop(counter)
    counter = counter + 1
        
#reverse the order of a list
homeTowns.reverse()

#sort the order of a list alphabetically or numerically
homeTowns.sort()

print(homeTowns)


Sort order

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

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

#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?
#print(x)

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

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

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)
        listOfNumbers.append(num)
    else:
        print("Please enter a number...")
        
#reverse the order of the list
#listOfNumbers.reverse()
listOfNumbers = listOfNumbers[::-1] 

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

print("Done")

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":
        moods.append(response)


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:
        break

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

print(average)

mood = getMoodFromNumber(average)
print(mood)


Characters

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:
    print(character)


Aliases

x = [
        "tomatos",
        "potatoes",
        "sprats",
        "frings",
        "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:
    print(element)

Slicing

x = [
        "tomatos",
        "potatoes",
        "sprats",
        "frings",
        "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:
    print(element)

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="")
        print()
         

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

player = "0"
counter = 0

while True:
    showBoard()
    
    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"
    else:
        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
    print("-------")
    for row in board:
        print("|", end="")
        for col in row:
            col = format(col, "1s")
            print(col, end="|")
        print()
        print("-------")
    

#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
    printBoard()
    
    #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")
        continue

    #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)
    else:
        print("Sorry, that's not a valid move...")
        print("Please enter the row and column as integers starting from zero serparated by commas")
        continue
    

    #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
        else:
            print("Sorry, that position is taken.  Please try a different position")
            continue
    else:
        print("Sorry, that's not a valid move...")
        print("Please enter the row and column as integers starting from zero serparated by commas")
        continue

    #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
        break
        

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


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

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


What links here