Lists and Dictionaries

Repeat Warning

In order to be sucessful in computer science, an important skill that you must develop is understanding how to implement and develop a specification, and knowing when you can take liberty with the specification. You also need to distingush between implementing and developing a specification. In the course work for CSC111, we ask for some things very precisely. It is important that you read every word of lab and assignment descriptions. Misreading or ignoring directions will result in incorrect software/code.

Take a few minutes and introduce yourself to your lab partner. Answer the questions: “Smarties vs. M&Ms?”, “Rockets vs. Smarties?”, “Mars/Milky Way vs Snickers vs Twix”

Setup: We added prompts to remind you to switch driver/navigator roles, but feel free to switch more frequently or mid task.

Lists: Overview

Note: If the navigator is not comfortable reading out loud, both partners should read over this section independently.

A list is a collection of items. In general, these items should be related in some way (although there are no restrictions on what can be stored in a python list).

dogs = ['border collie', 'australian cattle dog', 'labrador retriever']

dogs = ['border collie', 
        'australian cattle dog', 
        'labrador retriever']

first_dog = dogs[0]
print(first_dog)

second_dog = dogs[1]
print(second_dog)

last_dog = dogs[-1]
print(last_dog)

nonexistant_dog = dogs[-4] # error

for dog in dogs:
    print(dog)

dogs[0] = 'australian shepherd'
print(dogs)

print(dogs.index('australian cattle dog'))

print(dogs.index('poodle'))

print('australian cattle dog' in dogs)
print('poodle' in dogs)

dogs.append('poodle')
for dog in dogs:
    print(dog.title() + "s are cool.")

dogs = ['border collie', 
        'australian cattle dog', 
        'labrador retriever']
dogs.insert(1, 'poodle')
print(dogs)

# Remove the first dog from the list.
del dogs[0]
print(dogs)

dogs = ['border collie', 'australian cattle dog', 'labrador retriever']
# Remove australian cattle dog from the list.
dogs.remove('australian cattle dog')
print(dogs)

letters = ['a', 'b', 'c', 'a', 'b', 'c']
# Remove the letter a from the list.
letters.remove('a')
print(letters)

Step 1: Favorite Songs

• Create a new file called lab5p1.py in which you and your partner will work. Add the usual header, including both your names.
• Create an empty list called songs.
• Use a while loop to ask the user to enter the titles of their favorite songs (one at a time). End the loop when the user types “DONE”.
• Use the .append() method to add each song title to songs.
• After the loop ends, .sort() the list and print out the songs in a nicely-formatted way (you choose how it looks).

Dictionaries: Overview

Note: If the navigator is not comfortable reading out loud, both partners should read over this section independently.

Dictionaries are another way to store information that is connected in some way. Dictionaries store information in key-value pairs, so that any one piece of information in a dictionary is connected to at least one other piece of information. If we want, we can define them explicitly using key:value pairs and curly braces:

python_words = {'list': 'A collection of values that are not connected, but have an order.',
                'dictionary': 'A collection of key-value pairs.',
                'function': 'A named set of instructions that defines a set of actions in Python.',
                }

# Create an empty dictionary.
python_words = {}
# Fill the dictionary, pair by pair.
python_words['list'] ='A collection of values that are not connected, but have an order.'
python_words['dictionary'] = 'A collection of key-value pairs.'
python_words['function'] = 'A named set of instructions that defines a set of actions in Python.'

print("\nWord: {0}".format('list'))
print("Meaning: {0}".format(python_words['list']))
      
print("\nWord: {0}".format('dictionary'))
print("Meaning: {0}".format(python_words['dictionary']))
print("\nWord: {0}".format('function'))
print("Meaning: {0}".format(python_words['function']))

# Print out the items in the dictionary.
for word, meaning in python_words.items():
    print("\nWord: {0}".format(word))
    print("Meaning: {0}".format(meaning))

for key_name, value_name in dictionary_name.items():
    print(key_name) # The key is stored in whatever you called the first variable.
    print(value_name) # The value associated with that key is stored in your second variable.

python_words['noItem']

Traceback (most recent call last):
  File "<pyshell>", line 1, in <module>
KeyError: 'noItem'

print(python_words.get('noItem'))
print(python_words.get('list'))

None
A collection of values that are not connected, but have an order.

# Clarify one of the meanings.
python_words['dictionary'] = 'A collection of key-value pairs. Each key can be used to access its corresponding value.'
print('dictionary:', python_words['dictionary'])

python_words = {'list': 'A collection of values that are not connected, but have an order.',
                'dictionary': 'A collection of key-value pairs.',
                'function': 'A named set of instructions that defines a set of actions in Python.',
                }
# Show the current set of words and meanings.
print("\n\nThese are the Python words I know:")
for word, meaning in python_words.items():
    print("\nWord: {0}".format(word))
    print("Meaning: {0}".format(meaning))
    
# Remove the word 'list' and its meaning.
del python_words['list']
# Show the current set of words and meanings.
print("\n\nThese are the Python words I know:")
for word, meaning in python_words.items():
    print("\nWord: {0}".format(word))
    print("Meaning: {0}".format(meaning))

def show_words_meanings(python_words):
    # This function takes in a dictionary of python words and meanings,
    #  and prints out each word with its meaning.
    print("\n\nThese are the Python words I know:")
    for word, meaning in python_words.items():
        print("\n{0}: {1}".format(word, meaning))
        
python_words = {'list': 'A collection of values that are not connected, but have an order.',
                'dictionary': 'A collection of key-value pairs.',
                'function': 'A named set of instructions that defines a set of actions in Python.',
                }
show_words_meanings(python_words)
    
# Remove the word 'list' and its meaning.
del python_words['list']
show_words_meanings(python_words)

Step 2: Mountain Heights

• Wikipedia has a list of the tallest mountains in the world, complete with each mountain’s elevation. Pick your five favorite mountains from this list.
• Create a new file called lab5p2.py in which you and your partner will work. Add the usual header, including both your names.
• Create a dictionary with the mountain names as keys, and the elevations as values.
• Print out just the mountains’ names by looping through the keys of your dictionary.
• Print out just the mountains’ elevations by looping through the values of your dictionary.
• Print out a series of statements telling how tall each mountain is: “Everest is 8848 meters tall.”
• Put each of these in their own function.

Step 3: YouTube Playlist

Making a YouTube playlist with lists and dictionaries.

Create a new file called lab5p3.py in which you and your partner will work. Add the usual header, including both your names.

Review and add the following code to your file.

import webbrowser
from time import sleep
def playNewSong():
    # Ask for info about song
    title = input("Song title: ")
    url = input("YouTube video: ")
    duration = input("Video duration (MM:SS): ")
    
    # Convert 'duration' string into seconds
    time = duration.split(":")
    total_seconds = int(time[0])*60 + int(time[1])
    print("Now playing", title)
    sleep(2) # Wait 2 seconds before opening the video
    
    webbrowser.open(url)
    
    sleep(total_seconds) # Wait until the video is over
    print("Song is over!")

This function asks the user to enter a song title, youtube link, and the duration of the video. It then prints the song information, launches a browser window containing the YouTube video (which should play automatically), and then goes to sleep for the duration of the song.

• Rather than storing the data in individual variables, organize them into a dictionary called song that has keys title, url, and duration
• Add a loop that allows the user to enter as many songs as they want. Store each song in a list called playlist (this will be a list of dictionaries) End the loop when the user types DONE.
• To make testing your code easier, consider starting your dictionary with your favorite songs already entered. To figure out the format of your dictionary, print out your dictionary after adding a few songs the first time.
• Using the code in playNewSong() (above), write a new function called playSong(title, url, duration) that plays a single song given the parameters (title, url, duration).
• Next write a function called playSongs(song_dict) that takes a songs dictionary and makes a random playlist and plays all the songs in the playlist. This function should call playSong and be called after the user enters DONE.
• Now your playlist program is complete.

Lab Submission

If you have time, we encourage you to get started on your homework assignment in lab this week.

(Bonus) List Comprehensions

Note: this section is included because people have been asking about it. If you’re already feeling a little shaky on lists, don’t worry. For now, it is good enough to know they exist, and to recognize them when you see them. If you like them, go ahead and start trying to use them now.

Let’s consider how we might make a list of the first ten square numbers. We could do it like this:

# Store the first ten square numbers in a list.
# Make an empty list that will hold our square numbers.
squares = []
# Go through the first ten numbers, square them, and add them to our list.
for number in range(1,11):
    new_square = number**2
    squares.append(new_square)
    
# Show that our list is correct.
for square in squares:
    print(square)

This should make sense at this point. If it doesn’t, go over the code with these thoughts in mind:

• We make an empty list called squares that will hold the values we are interested in.
• Using the range() function, we start a loop that will go through the numbers 1-10.
• Each time we pass through the loop, we find the square of the current number by raising it to the second power.
• We add this new value to our list squares.
• We go through our newly-defined list and print out each value

Now let’s make this code more efficient. We don’t really need to store the new square in its own variable new_square; we can just add it directly to the list of squares:

# Store the first ten square numbers in a list.
# Make an empty list that will hold our square numbers.
squares = []
# Go through the first ten numbers, square them, and add them to our list.
for number in range(1,11):
    squares.append(number**2)
    
# Show that our list is correct.
for square in squares:
    print(square)

List comprehensions allow us to collapse the first three lines of code into one line. Here’s what it looks like:

# Store the first ten square numbers in a list.
squares = [number**2 for number in range(1,11)]
# Show that our list is correct.
for square in squares:
    print(square)

It should be pretty clear that this code is more efficient than our previous approach, but it may not be clear what is happening. Let’s take a look at everything that is happening in that first line:

We first define a list called squares.

Look at the second part of what’s in square brackets:

for number in range(1,11)

This sets up a loop that goes through the numbers 1-10, storing each value in the variable number. Now we can see what happens to each number in the loop:

number**2

Each number is raised to the second power, and this is the value that is stored in the list we defined. We might read this line in the following way:

squares = [raise number to the second power, for each number in the range 1-10]