Building Simulation/Interaction using Lists and Iteration - Student Copy
- Simulations/Interactions
- Lists
- Iteration
- Libaries
- Dictionaries
- Ordered Dictionaries
- Regular Dictionaries
- Code Examples
- Hacks
Iteration - Repitition of a Process For Loop - FOR LOOP repeats a function for a set number of times; I is the number of times repeated While Loop - The while loop is used to repeat a section of code an unknown number of times until a specific condition is met Initialization - What sets the counter variable to a starting value. For example (var i = 0) represents an initial value of 0. Condition - Allows the computer to know whether or not to keep repeating the loop. increment/decrement - Modifies the counter variable after each repetition. Indexing / List Index - The position of an element in a list, starting from 0 append, remove, pop - Various methods, append adds an element to the end, remove removes at an index, and pop removes the last item. Elements [in a list] - An item in a list. Nesting - Having one data type or function inside another data type or function, such as lists or loops. array - Another name for a list, depends on the language Key - the unique identifier associated with a value in a dictionary, such as name Value - the data associated with a key in a dictionary, such as age Pair - a key-value combination in a dictionary, such as a person's name + age Mutable - the ability to be changed or modified Tuple - an immutable ordered sequence of elements, similar to a list Insertion - the process of adding a new key-value pair to a dictionary Deletion - the process of removing a key-value pair from a dictionary Keys method/keys() - a built-in Python function that returns a list of all keys in a dictionary Values method/values() - a built-in Python function that returns a list of all values in a dictionary Items method/items() - a built-in Python function that returns a list of all key-value pairs in a dictionary as tuples Update method/update() - a built-in Python function that updates a dictionary with key-value pairs from another dictionary or iterable Clear method/clear() - a built-in Python function that removes all key-value pairs from a dictionary
Questions:
- Give an example of iteration.
- What is the difference between a for loop and while loop? That is, when would you use a for loop and when would you use a while loop?
- In the APCSP AP exam, what number do indexes start with? important to know
- Are dictionaries and lists mutable?
An example of iteration is a loop that repeats a section of code multiple times. For instance, a for loop that prints the numbers 1 to 5 would be an example of iteration, since the same code is executed repeatedly for each number in the range.
The main difference between a for loop and a while loop is that a for loop is used when the number of iterations is known in advance, whereas a while loop is used when the number of iterations is not known in advance and depends on a condition. In general, a for loop is used when iterating over a range of values or a sequence, while a while loop is used when iterating until a specific condition is met.
In the APCSP AP exam, indexes start with 0. This is important to remember when working with lists, since the first element in a list has an index of 0, not 1.
Lists are mutable, which means that their elements can be modified, added, or removed. Dictionaries are also mutable, since their key-value pairs can be modified, added, or removed.
Simulations/Interactions
Building a simulation o#r interaction using lists and iteration in VS Code can be accomplished using a few simple steps:
-
Define your data: First, you need to define the data that your simulation will be working with. This could be a list of numbers, a list of strings, or any other type of data that your simulation will be manipulating.
-
Write your simulation code: Once you have defined your data, you can start writing the code for your simulation. This code will typically involve iterating over your list of data, performing some operation on each item in the list, and updating the list accordingly.
-
Test your simulation: After you have written your simulation code, it is important to test it to make sure it is working as expected. You can do this by running your code and checking the output to see if it matches what you expect.
-
Refine your simulation: Once you have tested your simulation, you may need to refine it based on the results. This could involve tweaking the code to make it more efficient, adding new features, or fixing any bugs that you have discovered.
Why use simulations?
- Simulations can be useful because they can emulate real world situations without needing excessive resources (ex: money), time, or equipment. For example, a simulation of the effectiveness of a new seatbelt or airbag can be performed by simulating car crashes. This would be better than doing it in real life because you wouldn't want to place people in cars and then crash them for obvious reasons.
- However, simulatins do assume things about the real world and can have biases. They can be oversimplified because the real world often has more complications and factors that can affect something. In the case of our car crash simulation, other things can have a big impact, such as the weather and experience of the driver. However, these things can sometimes be held constant in the simulations.
-
Simulations can be used to model and simulate various real-world scenarios, such as the spread of a disease, traffic flow, financial systems, weather patterns, or the behavior of a physical system. For example, a simulation could be used to model the behavior of a car in different driving conditions, which could help car manufacturers test and improve the performance of their vehicles.
-
Simulations are useful and important because they allow us to study and understand complex systems and phenomena that may be difficult or impossible to observe or measure in the real world. Simulations can also be used to test and optimize systems before they are implemented, which can save time, money, and resources. Simulations can also provide insights and predictions that can inform decision-making and help us plan for the future. Additionally, simulations can be used to explore hypothetical scenarios and investigate "what-if" questions, which can be useful in fields such as economics, public policy, and engineering.
Here's a simple example of a simulation in Python that uses lists and iteration to calculate the average of a list of numbers:
numbers = [1, 2, 3, 4, 5]
# Initialize the sum and count variables
sum = 0
count = 0
# Iterate over the list of numbers, adding each number to the sum
for number in numbers:
sum += number
count += 1
# Calculate the average of the list of numbers
average = sum / count
# Print the average
print("The average of the list is:", average)
This code defines a list of numbers, iterates over the list to calculate the sum and count of the numbers, and then calculates the average by dividing the sum by the count. Finally, it prints the average to the console.
Lists
- Iteration statements can be used to traverse a list
- Knowldege of exisiting algorithms that use iteration can help in constructing new algorithms. Some are:
- Determining a minimum or maximum value in a list
- Computing a sum or average of a list of numbers
What are Lists?
- Lists are _________________.
- Each sequence is demarcated with an index, starting from 0. This is known as base 0 indexing
- In memory, it is stored as a variable name with multiple pointers to each variable stored in a certain order
- Lists can also be called arrays
- Lists have methods that act upon the list and change them. This moves the pointers within RAM to change the parts of the list.
Nested Lists
Uses of Nested lists
Placing lists within lists allows you to have arrays of similar data together, and create complexity.
Some uses include:
- Creating 2d Arrays
- Storing similar, but slightly different categories (sublists)
- Create a matrix
Iteration
Iterative statements are also called _____, and they repeat themselves over and over until the condition for stopping is met.
- In College Board's Pseudocode, the first is a REPEAT n TIMES loop, where the n represents some number.
The second type of loop is a REPEAT UNTIL (condition) loop, where the loop will continue to run until a condition is met.
Conceptually, a while loop is very similar to an if conditional, except that a while is continually executed until it's no longer true and an if is only executed once.
Iteration is needed when you have a task that needs to be repeated multiple times with different inputs or under different conditions. For example, if you want to print the square of the first 10 integers, you can use a for loop to iterate through the integers and calculate their squares.
A "REPEAT n TIMES" loop executes a block of code a fixed number of times, whereas a "REPEAT UNTIL (condition)" loop executes the block of code repeatedly until a certain condition is met. In the former, the number of iterations is known in advance, while in the latter, the number of iterations is determined by the condition. A "REPEAT n TIMES" loop is useful when you know exactly how many times you need to execute a block of code, while a "REPEAT UNTIL (condition)" loop is useful when you need to keep executing a block of code until a certain condition is satisfied. For example, if you want to roll a die until you get a 6, you can use a "REPEAT UNTIL (condition)" loop to keep rolling the die until a 6 is rolled.
Libaries
- A software library contains procedures that may be used in creating new programs.
- Existing code segments can come from internal or external sources, such as libaries or previously written code.
- The use of libaries simplifies the task of creating complex programs.
APIs
Application program interfaces (APIs) are specifications for how the procedures in a libary behave and can be used as documentation for an API/libary is necessary in understanding the behaviors provided by the API and how to use them.
A file that contains procedures that can be used in a program is considered a libary.
- API provides specifications for how procedures in a library behave and can be used.
- Many companies use APIs for programmers to interact with their products.
Questions:
- What are some libraries that we've learned about? What are their advantages/disadvantages?
NumPy - a library for working with arrays and matrices in Python. It provides fast and efficient operations on large arrays and includes a number of useful mathematical functions. Advantages include fast and efficient computation, extensive documentation and community support. Disadvantages include a steeper learning curve and potential memory usage issues with large arrays.
Dictionaries
What are Dictionaries?
- an unordered collection of key-value pairs, where each key is _______ and associated with a specific value
- known as associative arrays, maps, or hash tables in some programming languages
- used to store and retrieve data efficiently, as they allow fast access to values based on their associated keys
- useful for a wide range of tasks, such as storing, indexing, and counting
What are the types of Dictionaries?
Ordered Dictionaries
- Iterates over keys and values in the same order that the keys were inserted
- If an entry is deleted and reinserted, then it will be moved to the end of the dictionary
- Specially designed to keep its items ordered
- Useful in situations where the order of insertion is important and when you need to process data in a specific order
- If the order of the data is important, an ordered dictionary is the better choice
How to create an ordered dictionary?
- Import OrderedDict from collections
- Create an empty ordered dictionary by instantiating OrderedDict without providing arguments to the constructor
- Add key-value pairs to the dictionary by providing a key in square brackets ([]) and assigning a value to that key.
- Print the ordered dictionary
- Iterate over the items in the ordered dictionary
Regular Dictionaries
- Mutable; can add, remove, and modify key-value pairs after they have been created
- Used to store data values in key:value pairs
- Can be iterated over using loops
- If order is not important, a regular dictionary may provide better performance
How to create a regular dictionary?
- Create a variable name which will be the name of the dictionary
- Assign the variable to an empty set of curly braces {}
- Create a dictionary with the dict() OR empty curly brackets
Questions:
- Compare and contrast lists and dictionaries.
- Do dictionary keys need to be unique?
folklore_album = {
"title": "Folklore",
"artist": "Taylor Swift",
"year": 2020,
"genre": ["Alternative/Indie", "Pop"],
"tracks": {
1: ["the 1", 7],
2: ["cardigan", 9],
3: ["the last great american dynasty", 7],
4: ["exile (ft. Bon Iver)", 10],
5: ["my tears ricochet", 7],
6: ["mirrorball", 6],
7: ["seven", 5],
8: ["august", 7],
9: ["this is me trying", 7],
10: ["illicit affairs", 8],
11: ["invisible string", 6],
12: ["mad woman", 7],
13: ["epiphany", 6],
14: ["betty", 8],
15: ["peace", 9],
16: ["hoax", 7],
17: ["the lakes", 6]
}
}
# Printing the dictionary
print(folklore_album)
for i in folklore_album["tracks"]:
print("track #" + str(i) + ": " + folklore_album["tracks"][i][0])
print(" my rating: " + str(folklore_album["tracks"][i][1]) + "/10")
Reverse a list utilizing features of lists and iteration
original_list = [1, 2, 3, 4, 5]
print("List before reverse : ",original_list)
reversed_list = []
for value in original_list:
reversed_list = [value] + reversed_list
# print("List after reverse : ", reversed_list)
Similar to insertion sort, this algorithm takes an unsorted array and returns a sorted array. Unlike insertion sort where you iterate through the each element and move the smaller elements to the front, this algorithm starts at the beginning and swaps the position of every element in the array
list = [9, 8, 4, 3, 5, 2, 6, 7, 1, 0]
print(f"array before sort {list}")
def insertion_sort(list):
for index in range(1,len(list)): # repeats through length of the array
value = list[index]
i = index - 1
while i >= 0:
if value < list[i]:
list[i+1] = list[i] # shift number in slot i to the right
list[i] = value # shift value left into slot i
i = i - 1
else:
break
IS = insertion_sort(list)
# print(f"array after sort {list}")
Here is a list comprehension example, using lists to create lists.
Below, only songs in the folklore album that have less than 7 characters in their titles are printed.
TS_folklore = ["exile", "my tears ricochet", "this is me trying", "illicit affairs", "august", "mirrorball", "betty", "mad woman", "epiphany", "peace", "cardigan"]
# this list is only songs that have less than 10 characters in the title
TS_folklore_updated = [x for x in TS_folklore if len(x) < 7]
print("These are the songs in Taylor Swift's folklore album that have less than 7 characters in their title")
print(TS_folklore_updated)
Below, only songs that have a rating greater than 7 will be printed.
TS_folklore_ratings = {"exile": 8, "my tears ricochet": 6, "this is me trying": 7, "illicit affairs": 8, "august": 4, "mirrorball": 3, "betty": 6, "mad woman": 6, "epiphany": 2, "peace": 10, "cardigan": 10}
TS_folklore_best = {k:v for (k,v) in TS_folklore_ratings.items() if v>7}
print("These are the songs in Taylor Swift's folklore album that I give a rating greater than 7")
print(TS_folklore_best)
Questions:
- How is list comprehension similar to iteration?
List comprehension is a concise way of creating a new list by iterating over an existing iterable and applying a transformation or filtering operation to each element. The resulting list is constructed in a single line of code, rather than using a loop to append elements to an empty list.
playlist = {
'song1': {
'artist': 'John Mayer',
'genre': 'Pop',
'length': 4.5
},
'song2': {
'artist': 'Ed Sheeran',
'genre': 'Pop',
'length': 3.2
},
'song3': {
'artist': 'Adele',
'genre': 'Pop',
'length': 5.1
},
'song4': {
'artist': 'The Beatles',
'genre': 'Rock',
'length': 2.8
},
'song5': {
'artist': 'Taylor Swift',
'genre': 'Country',
'length': 3.6
}
}
# Define a function to sort the playlist by song length
def sort_by_length(playlist):
sorted_list = sorted(playlist.items(), key=lambda x: x[1]['length'])
return sorted_list
# Define a function to sort the playlist by artist name
def sort_by_artist(playlist):
sorted_list = sorted(playlist.items(), key=lambda x: x[1]['artist'])
return sorted_list
# Define a function to filter the playlist by genre
def filter_by_genre(playlist, genre):
filtered_list = []
for song, details in playlist.items():
if details['genre'] == genre:
filtered_list.append((song, details))
return filtered_list
# Test the functions
print(sort_by_length(playlist))
print(sort_by_artist(playlist))
print(filter_by_genre(playlist, 'Pop'))
import random
symbols = ["🍎", "🍊", "🍋", "🍉", "🍇"]
pay_table = {"🍎": 10, "🍊": 20, "🍋": 30, "🍉": 40, "🍇": 50}
def spin():
reel1 = random.choice(symbols)
reel2 = random.choice(symbols)
reel3 = random.choice(symbols)
result = [reel1, reel2, reel3]
payout = calculate_payout(result)
print(result)
if payout > 0:
print("You won {} coins!".format(payout))
else:
print("Better luck next time.")
def calculate_payout(result):
if result.count(result[0]) == 3:
return pay_table[result[0]] * 10
elif result.count(result[0]) == 2:
return pay_table[result[0]] * 2
elif len(set(result)) == 2:
return pay_table[result[0]]
else:
return 0
spin()
