35 | 36 | [Back to top](#top) 37 | -------------------------------------------------------------------------------- /practice/unit_3/solutions/exercise_1_solution.md: -------------------------------------------------------------------------------- 1 | # Unit 3 Practice Solutions 2 | 3 | ## **Exercise 1 Solution** 4 | 5 | ### **1.1** 6 | 7 | ```python 8 | fruits = { 9 | 'apple': .65, 10 | 'banana': .5, 11 | 'guava': .33 12 | } 13 | 14 | # Display the price of a fruit 15 | print(f"Apples cost ${fruits['apple']} each") 16 | 17 | # Add a fruit to the dictionary, print the dictionary to verify its creation 18 | 19 | # add 'grapes 20 | fruits['grapes'] = .99 21 | print(f"Added 'grapes': {fruits}") 22 | 23 | # Remove a fruit from the dictionary, print the dictionary to verify its deletion 24 | 25 | # delete the key:value pair at 'banana' 26 | del fruits['banana'] 27 | print(f"Removed 'banana': {fruits}") 28 | ``` 29 | 30 | Output: 31 | 32 | Apples cost $0.65 each 33 | Added 'grapes': {'apple': 0.65, 'banana': 0.5, 'guava': 0.33, 'grapes': 0.99} 34 | Removed 'banana': {'apple': 0.65, 'guava': 0.33, 'grapes': 0.99} 35 | 36 | ### **1.2** 37 | 38 | ```python 39 | fruits = { 40 | 'apple': .65, 41 | 'banana': .5, 42 | 'guava': .33 43 | } 44 | 45 | # display the header label 46 | print(" Fruits ") 47 | print("----------") 48 | 49 | # loop through the keys in the fruits dictionary 50 | fruit_names = fruits.keys() 51 | for fruit_name in fruit_names: 52 | 53 | # get the price of the fruit using its name as the key 54 | price_per = fruits[fruit_name] 55 | 56 | # print the item 57 | print(f'{fruit_name}: {price_per}') 58 | ``` 59 | 60 | **Output:** 61 | 62 | Fruits 63 | ---------- 64 | apple: 0.65 65 | banana: 0.5 66 | guava: 0.33 67 | 68 | ### **1.3** 69 | 70 | **The Code:** 71 | 72 | ```python 73 | # fruits and their prices per item 74 | fruit_prices = { 75 | 'apple': .65, 76 | 'banana': .5, 77 | 'guava': .33 78 | } 79 | 80 | # fruits in the basket and their quantities 81 | shopping_basket = { 82 | 'apple': 4, 83 | 'banana': 6, 84 | 'guava': 8 85 | } 86 | 87 | # set the grand_total to zero 88 | grand_total = 0 89 | 90 | # loop through each fruit in the basket 91 | for fruit in shopping_basket: 92 | 93 | # get the quantity of the current fruit 94 | quantity = shopping_basket[fruit] 95 | 96 | # calculate the sub_total for current fruit 97 | sub_total = quantity * fruit_prices[fruit] 98 | 99 | # add the sub_total for the current 100 | # fruit to the grand total 101 | grand_total += sub_total 102 | 103 | # print the sub_total for the current fruit 104 | print(f'{quantity} {fruit.capitalize()}s: ${sub_total}') 105 | 106 | print("-------------") 107 | print(f'Grand Total: ${grand_total}') 108 | ``` 109 | 110 | **Output:** 111 | 112 | 4 Apples: $2.6 113 | 6 Bananas: $3.0 114 | 8 Guavas: $2.64 115 | ------------- 116 | Grand Total: $8.24 117 | 118 | Keep in mind that this is just one potential solution. 119 | 120 | ## [< Exercise 1](../exercise_1.md) | [Exercise 2 >](../exercise_2.md) 121 | 122 | --- 123 | 124 | ### [<< Back to Unit 3 Practice](/practice/unit_3/) 125 | -------------------------------------------------------------------------------- /practice/unit_2/solutions/exercise_2_solution.md: -------------------------------------------------------------------------------- 1 | # Unit 2 Practice Solutions 2 | 3 | ## **Exercise 2** 4 | 5 | ### **2.1 Solution** 6 | 7 | ```python 8 | # create a blank list called colors 9 | colors = [] 10 | 11 | # begin REPL 12 | while True: 13 | 14 | # prompt the user for a color 15 | color = input("Please enter a color to add it to the list or enter 'done' to exit: ") 16 | 17 | # If the user enters 'done' instead of a `color`, 18 | # display the list of colors to the user and exit the loop. 19 | if color == 'done': 20 | 21 | # display the colors using .join() to 22 | # place a comma and a space between each color 23 | print(f"The colors you entered were: {', '.join(colors)}") 24 | 25 | # end the loop 26 | break 27 | 28 | # If the color is already in the colors list, 29 | # inform the user that the color is already in the list 30 | # and repeat the loop 31 | if color in colors: 32 | 33 | # inform the user the color is in the list 34 | print(f'The color {color} is already in the list!') 35 | 36 | # go to the top of the loop 37 | continue 38 | 39 | # If the color is not already in the colors list, 40 | # add it and tell the user it was added. 41 | print(f'The color {color} was added to the list!') 42 | colors.append(color) 43 | ``` 44 | 45 | ### **2.2 Solution** 46 | 47 | ```python 48 | # Define a function get_color() 49 | # which prompts the user for a color 50 | # and then returns that color. 51 | def get_color(): 52 | ''' 53 | Prompt the user for a color. Return the color. 54 | ''' 55 | color = input("Please enter a color to add it to the list or enter 'done' to exit: ") 56 | 57 | # return the user's color to the 58 | # line on which get_color() was called 59 | return color 60 | 61 | # create a blank list called colors 62 | colors = [] 63 | 64 | # begin REPL 65 | while True: 66 | # call the get_color() to 67 | # get a color from the user 68 | color = get_color() 69 | 70 | # If the user enters 'done' instead of a `color`, 71 | # display the list of colors to the user and exit the loop. 72 | if color == 'done': 73 | 74 | # display the colors using .join() 75 | # to place a comma and a space between each color 76 | print(f"The colors you entered were: {', '.join(colors)}") 77 | 78 | # end the loop 79 | break 80 | 81 | # If the color is already in the colors list, 82 | # inform the user that the color is already in the 83 | # list and repeat the loop 84 | if color in colors: 85 | print(f'The color {color} is already in the list!') 86 | 87 | # repeat the loop 88 | continue 89 | 90 | # If the color is not already in the `colors` list, 91 | # add it and tell the user it was added. 92 | print(f'The color {color} was added to the list!') 93 | colors.append(color) 94 | ``` 95 | 96 | Keep in mind that this is just one potential solution. 97 | 98 | --- 99 | 100 | ## [< Exercise 2](../exercise_2.md) | [Exercise 3 >](../exercise_3.md) 101 | 102 | ### [<< Back to Unit 2 Practice](/practice/unit_2/) 103 | -------------------------------------------------------------------------------- /practice/unit_4/solutions/exercise_2/exercise_2_1_solution.md: -------------------------------------------------------------------------------- 1 | # Unit 4 Practice Solutions 2 | 3 | ## **Exercise 2 Solution** 4 | 5 | ### **2.1** 6 | 7 |
8 | 
9 |
10 |
11 |
9 | 12 | 13 | As shown in the flowchart, this solution will consists of a REPL loop performing a series of two actions for each character. 14 | 15 | 1. One of the characters will attack and the other's `hp` will be reduced. 16 | 2. Check if the non-attacking character's `hp` is less than or equal to zero (i.e. they've been defeated). 17 | 18 | As soon as one character is defeated, a message will print saying who won the battle and the loop will end. 19 | 20 | We'll be adding an `input()` before each character attacks to make the battle more interactive. This step isn't represented in the flowchart, but will be in the code. 21 | 22 | We'll also be adding `print()` functions periodically to provide feedback on the status of the battle to the user. 23 | 24 | ```python 25 | # ----------------------------------------------------------- # 26 | # Setup 27 | # ----------------------------------------------------------- # 28 | 29 | 30 | # define hero/villain stats 31 | hero = { 32 | "name": "Andromeda", 33 | "hp": 100, 34 | "attack": 35 35 | } 36 | 37 | villain = { 38 | "name": "Helios", 39 | "hp": 100, 40 | "attack": 33 41 | } 42 | 43 | def is_defeated(character): 44 | ''' 45 | Returns False if the character's hp is greater than zero 46 | Returns True if the character's hp is less than or equal to 47 | ''' 48 | return character['hp'] <= 0 49 | 50 | 51 | # ----------------------------------------------------------- # 52 | # Battle! 53 | # ----------------------------------------------------------- # 54 | 55 | while True: 56 | # display hp 57 | print(f"{hero['name']} has {hero['hp']} hp!") 58 | print(f"{villain['name']} has {villain['hp']} hp!") 59 | 60 | input("\nPress enter to begin the battle!") 61 | 62 | # Hero attacks 63 | print(f"\n{hero['name']} attacks!") 64 | 65 | # subtract hero's attack strength from the villain's hp 66 | villain['hp'] -= hero['attack'] 67 | 68 | # check if the villain is defeated 69 | if is_defeated(villain): 70 | print(f"{villain['name']} has been defeated! {hero['name']} is victorious!") 71 | break # end the loop 72 | 73 | # display hp 74 | print(f"{hero['name']} has {hero['hp']} hp!") 75 | print(f"{villain['name']} has {villain['hp']} hp!") 76 | 77 | input("\nPress enter to continue the battle!") 78 | 79 | # Villain attacks 80 | print(f"\n{villain['name']} attacks!") 81 | 82 | # subtract hero's attack strength from the villain's hp 83 | hero['hp'] -= villain['attack'] 84 | 85 | # check if the hero is defeated 86 | if is_defeated(hero): 87 | print(f"\n{hero['name']} has been defeated! {villain['name']} is victorious!") 88 | break # end the loop 89 | 90 | ``` 91 | 92 | 93 | Keep in mind that this is just one potential solution. 94 | 95 | ## [< Exercise 2](../exercise_2.md) | [2.2 Solution >](./exercise_2_2_solution.md) 96 | 97 | --- 98 | 99 | ### [<< Back to Unit 4 Practice](/practice/unit_4/) 100 | -------------------------------------------------------------------------------- /resources/example_lessons/unit_3/unit_2_review_template.py: -------------------------------------------------------------------------------- 1 | ''' 2 | Programming 102 3 | Unit 2 Review 4 | ''' 5 | 6 | import random 7 | 8 | ''' 9 | R ead 10 | E valuate 11 | P rint 12 | L oop 13 | ''' 14 | 15 | # -------------------------------------------------------------------------------- # 16 | 17 | # This REPL will only loop if the user enters exactly 'yes' 18 | 19 | # ------------------------------------------------------------------------------- # 20 | 21 | # This REPL displays different things for 'y','n' and invalid options 22 | # but will loop unless the user enters 'n' 23 | 24 | # ------------------------------------------------------------------------------ # 25 | 26 | # This REPL will ensure that the user enters a valid choice 27 | # and will output a message accordingly. 28 | 29 | 30 | # ------------------------------------------------------------------------------------- # 31 | 32 | # Functions 33 | 34 | # named code blocks that perform specific tasks 35 | # take in data, manipulate it and return the result to where the function was called 36 | # must be executed with parentheses after their name 37 | 38 | # keyword 'def' to define a function 39 | 40 | # variables in the parentheses in the function's definition are called 'parameters' 41 | # parameters are empty variables, awaiting data (can also be given default values) 42 | def multiply(): 43 | pass 44 | 45 | # define a variable using the return value from the function 46 | 47 | # define a variable using the sum of the 48 | # return values from two function calls 49 | 50 | 51 | 52 | # A function call is equal to its return value 53 | 54 | 55 | # 'arguments' must be passed to fill parameters if no default values are provided 56 | 57 | 58 | # ----------------------------------------------------------------------------------------- # 59 | 60 | def punctuate(): 61 | pass 62 | 63 | # ------------------------------------------------------------------------------------------ # 64 | 65 | # Return True if the 'number' is between 'low' and 'high'. Otherwise return False. 66 | def is_in_bounds(number, low, high): 67 | pass 68 | 69 | 70 | 71 | # display different messages if the number is in bounds or not 72 | 73 | # ------------------------------------------------------------------------------------------- # 74 | 75 | ### THIS CAN BE SKIPPED, IF NEEDED 76 | 77 | def generate_random_numbers(): 78 | pass 79 | 80 | # process all the numbers in the list and count all the numbers that are in a particular range: 81 | 82 | 83 | # ------------------------------------------------------------------- # 84 | ### THIS CAN BE SKIPPED IF NEEDED 85 | 86 | # Scope - Four 'layers' in which variables exist 87 | 88 | # built-in, global, enclosed, local 89 | 90 | # Built-in scope = all built in functions, error messages, etc 91 | 92 | 93 | # ---------------------------------------------------------------------------------- # 94 | ### THIS CAN BE SKIPPED IF NEEDED 95 | 96 | numbers = [] 97 | 98 | ''' 99 | # Don't do this 100 | def add_number_to_list(number): 101 | # Since the numbers list isn't being passed 102 | # through the parameters, it is confusing 103 | # because it's not obvious where the numbers 104 | # variable is coming from 105 | numbers.append(number) 106 | ''' 107 | 108 | ''' 109 | # Do this instead 110 | def add_number_to_list(number, numbers): 111 | # Now it is obvious where the numbers variable 112 | # is coming from. It is passed through the 113 | # parameters, manipulated and returned 114 | numbers.append(number) 115 | return numbers 116 | ''' -------------------------------------------------------------------------------- /labs/turtle.md: -------------------------------------------------------------------------------- 1 | # Lab 5: Turtle 2 | 3 | ## Explanation 4 | 5 | Turtle is a python `module` that allows us to move a virtual turtle around the screen using programming statements. This turtle has a position and a heading. Below are a list of commands, you can more in the [turtle docs](https://docs.python.org/3.6/library/turtle.html). 6 | 7 | - `forward(distance)` moves the turtle forward the given number of pixels 8 | - `left(angle)` and `right(angle)` turns the turtle left or right by the given angle (in degrees) 9 | - `color(color_name)` sets the pen's color, which can be `penup()` `penup()` `penup()` 10 | - `penup()` raises the pen, a line won't be drawn when the turtle moves, `pendown()` lowers the pen again 11 | 12 | - `setposition(x, y)` moves the turtle to the given position 13 | 14 | - `fillcolor(color_name)` sets the fill color, `begin_fill()` indicates you'd like to begin filling in whatever you draw, `end_fill()` actually fills the shape in. 15 | 16 | Use these functions to draw a stick figure with a head, body, two arms, and two legs. Once you're done, go through the examples below and create your own drawing. 17 | 18 | ## Examples 19 | 20 | ### Drawing a Square 21 | 22 | ```python 23 | from turtle import * 24 | 25 | forward(100) 26 | left(90) 27 | forward(100) 28 | left(90) 29 | forward(100) 30 | left(90) 31 | forward(100) 32 | left(90) 33 | 34 | done() 35 | 36 | ``` 37 | 38 | ### Filling in a Square 39 | 40 | ```python 41 | from turtle import * 42 | 43 | fillcolor('red') 44 | begin_fill() 45 | 46 | forward(100) 47 | left(90) 48 | forward(100) 49 | left(90) 50 | forward(100) 51 | left(90) 52 | forward(100) 53 | left(90) 54 | 55 | end_fill() 56 | 57 | done() 58 | 59 | ``` 60 | 61 | ### Drawing a Star 62 | 63 | ```python 64 | from turtle import * 65 | 66 | forward(100) 67 | right(144) 68 | forward(100) 69 | right(144) 70 | forward(100) 71 | right(144) 72 | forward(100) 73 | right(144) 74 | forward(100) 75 | 76 | done() 77 | 78 | ``` 79 | 80 | ### Drawing a Square with a Loop 81 | 82 | ```python 83 | from turtle import * 84 | 85 | i = 0 86 | while i < 4: 87 | forward(100) 88 | left(90) 89 | i = i + 1 90 | 91 | done() 92 | ``` 93 | 94 | ### Drawing a Staircase 95 | 96 | ```python 97 | from turtle import * 98 | 99 | i = 0 100 | while i < 4: 101 | forward(100) 102 | left(90) 103 | forward(100) 104 | right(90) 105 | i = i + 1 106 | done() 107 | ``` 108 | 109 | ### Filling in a Square 110 | 111 | ```python 112 | from turtle import * 113 | 114 | fillcolor('red') 115 | begin_fill() 116 | 117 | forward(100) 118 | left(90) 119 | forward(100) 120 | left(90) 121 | forward(100) 122 | left(90) 123 | forward(100) 124 | left(90) 125 | 126 | end_fill() 127 | 128 | done() 129 | 130 | ``` 131 | 132 | ### Draw an N-Sided figure 133 | 134 | ```python 135 | from turtle import * 136 | 137 | edge_length = 100 138 | n_sides = 5 139 | 140 | i = 0 141 | while i < n_sides: 142 | forward(edge_length/n_sides) 143 | right(360/n_sides) 144 | i = i + 1 145 | 146 | done() 147 | 148 | ``` 149 | 150 | ### 8-Sided Spiral 151 | 152 | ```python 153 | from turtle import * 154 | 155 | fillcolor('blue') 156 | 157 | n_sides = 8 158 | edge_length = 0 159 | 160 | i = 0 161 | begin_fill() 162 | while i < 150: 163 | forward(edge_length) 164 | right(360/n_sides) 165 | i = i + 1 166 | edge_length = edge_length + 1 167 | end_fill() 168 | done() 169 | 170 | ``` 171 | 172 | ### Expanding Star 173 | 174 | ```python 175 | from turtle import * 176 | 177 | edge_length = 0 178 | i = 0 179 | while i < 100: 180 | forward(edge_length) 181 | right(144) 182 | 183 | edge_length += 4 184 | 185 | done() 186 | ``` 187 | -------------------------------------------------------------------------------- /resources/example_lessons/unit_5/utilities.py: -------------------------------------------------------------------------------- 1 | from string import punctuation 2 | 3 | def read_text_file(filename): 4 | '''Open a text file, read its contents and return them as a giant string''' 5 | with open('alice.txt', 'r') as text_file: 6 | # alice.txt is open ONLY in this code block 7 | 8 | # read the file's contents and save to a variable as a giant string 9 | contents = text_file.read() 10 | # text file is closed at this indentation level 11 | 12 | return contents 13 | 14 | def scrub_text(dirty_text): 15 | '''Clean text by lowercasing everything, removing new line characters and punctuation 16 | and splitting at each space into a list of words. Return the list of words.''' 17 | # lowercase everything 18 | clean_text = dirty_text.lower() 19 | 20 | # remove all newline characters 21 | clean_text = clean_text.replace('\n', ' ') 22 | 23 | # remove all punctuation 24 | # loop through each punctuation character and remove it from the text 25 | for punct in punctuation: 26 | clean_text = clean_text.replace(punct, '') 27 | 28 | # split the text at each space to form a list of words 29 | word_list = clean_text.split(' ') 30 | 31 | # return list of lowercase words with no punctuation or new lines 32 | return word_list 33 | 34 | def tally_words(word_list): 35 | '''Loop through the list of words and populate 36 | a dictionary with the words as keys and their 37 | occurances as values. Return the dictionary of counts''' 38 | # store the words and their counts in a dictionary 39 | word_counts = {} 40 | 41 | # loop through the list of words 42 | for word in word_list: 43 | 44 | # skip all blank strings 45 | if word == '': 46 | continue 47 | 48 | # if the word is not a key in the dictionary, 49 | if word not in word_counts: 50 | # add it with a value of 1 51 | word_counts[word] = 1 52 | 53 | # if the word IS ALREADY a key in the dictionary, 54 | elif word in word_counts: 55 | # add 1 to its value 56 | word_counts[word] += 1 57 | 58 | return word_counts 59 | 60 | def sort_by_value(tup): 61 | '''return the first item of the tuple for sorting''' 62 | return tup[1] 63 | 64 | def find_most_frequent(word_counts, n): 65 | '''Return a dictionary of the top n most frequently ocurring 66 | words in the word_counts dictionary.''' 67 | words = list(word_counts.items()) 68 | 69 | # sort the list of tuple items by value in descending order 70 | words.sort(key=sort_by_value, reverse=True) 71 | 72 | # empty list for top n words 73 | top_n = [] # list slicing - words[0:n] # list_name[start_index:stop_index] 74 | 75 | # loop 0 - 9 76 | for index in range(n): 77 | # add each of the top ten words to the list 78 | top_n.append(words[index]) 79 | 80 | top_n = dict(top_n) 81 | 82 | return top_n 83 | 84 | def write_text_file(filename, top_n, n): 85 | '''Write contents as a string to the filename, 86 | displaying top n words and their counts.''' 87 | # label for output 88 | output = f'Top {n} Words\n-------------\n' 89 | 90 | # number for labeling words 91 | word_num = 1 92 | 93 | # 'unpack' the word and count for each item into two variables 94 | for word, count in top_n.items(): 95 | # add the current word and its count to the output string with a new line after 96 | output += f'{word_num}. {word} - {count}\n' 97 | 98 | # increment word number 99 | word_num += 1 100 | 101 | # open new text file in WRITE mode ('w') 102 | with open(filename, 'w') as text_file: 103 | # write the output string to the text file 104 | text_file.write(output) 105 | 106 | return output 107 | -------------------------------------------------------------------------------- /practice/unit_4/solutions/exercise_2/exercise_2_2_solution.md: -------------------------------------------------------------------------------- 1 | # Unit 4 Practice Solutions 2 | 3 | ## **Exercise 2 Solution** 4 | 5 | ### **2.2** 6 | 7 |
8 | 
9 |
10 |
11 |
9 | 12 | 13 | Since the hero and the villain were both performing the same actions each round, we can reduce repetition by writing more generic logic that can apply to either character. 14 | 15 | Here we've created a function called `attack()` which is going to handle the active character's turn. We'll pass the current `attacker` and their `opponent` and the process of applying damage to the opponent will take place inside the function. 16 | 17 | We'll also use the `is_defeated()` function to return a boolean from `attack()` indicating whether or not the battle is over. 18 | 19 | ```python 20 | # ----------------------------------------------------------- # 21 | # Setup 22 | # ----------------------------------------------------------- # 23 | 24 | hero = { 25 | "name": "Andromeda", 26 | "hp": 100, 27 | "attack": 35 28 | } 29 | 30 | villain = { 31 | "name": "Helios", 32 | "hp": 100, 33 | "attack": 33 34 | } 35 | 36 | def is_defeated(character): 37 | ''' 38 | Returns False if the character's hp is greater than zero 39 | Returns True if the character's hp is less than or equal to 40 | ''' 41 | return character['hp'] <= 0 42 | 43 | 44 | def attack(active, opponent): 45 | ''' 46 | Apply battle damage to the opponent using the active characters's attack stat 47 | If the opponent is defeated, return True, signifying the battle is over 48 | Otherwise return False, signifying the battle will continue for another round 49 | ''' 50 | print(f"{active['name']} has {active['hp']} hp!") 51 | print(f"{opponent['name']} has {opponent['hp']} hp!") 52 | 53 | input("\nPress enter to battle!") 54 | 55 | # active character attacks 56 | print(f"\n{active['name']} attacks!") 57 | 58 | # subtract active character's attack strength from the opponents's hp 59 | opponent['hp'] -= active['attack'] 60 | 61 | # return True if the opponent is defeated, otherwise False 62 | return is_defeated(opponent) 63 | 64 | # ----------------------------------------------------------- # 65 | # Battle! 66 | # ----------------------------------------------------------- # 67 | 68 | 69 | # this will alternate between 0 and 1 to decide whose turn it is 70 | turn_counter = 0 71 | 72 | while True: 73 | 74 | # stat dictionaries stored at matching keys 75 | all_stats = { 76 | 'hero': hero, 77 | 'villain': villain 78 | } 79 | 80 | # keys for the all_stats dictionary 81 | # the turn_counter will alternate between 0 and 1 to decide whose turn it is 82 | stat_keys = list(all_stats.keys()) # ['hero', 'villain'] 83 | 84 | # get the key of the active character 85 | active_key = stat_keys[turn_counter] 86 | # get the stat dictionary of the active character 87 | active = all_stats[active_key] 88 | 89 | 90 | # get the key of the opponent 91 | # index -1 if turn_counter is 0 92 | # index 0 if the turn_counter is 1 93 | opponent_key = stat_keys[turn_counter - 1] 94 | # get the stat dictionary of the opponent 95 | opponent = all_stats[opponent_key] 96 | 97 | # execute current round of battle 98 | # receive True if opponent is defeated, otherwise False 99 | victorious = attack(active, opponent) 100 | 101 | # check the outcome of the battle. 102 | # if the opponent was defeated, end the loop 103 | if victorious: 104 | print(f"{opponent['name']} has been defeated! {active['name']} is victorious!") 105 | break # end the loop 106 | 107 | 108 | # increment the turn_counter 109 | turn_counter += 1 110 | 111 | # make sure the turn_counter will only ever be 0 or 1 using % 2; if/elif could be used instead 112 | turn_counter %= 2 113 | ``` 114 | 115 | 116 | 117 | 118 | Keep in mind that this is just one potential solution. 119 | 120 | ## [< 2.1 Solution](./exercise_2_1_solution.md)| [2.3 Solution >](./exercise_2_3_solution.md) 121 | 122 | --- 123 | 124 | ### [<< Back to Unit 4 Practice](/practice/unit_4/) 125 | -------------------------------------------------------------------------------- /resources/lessons/lesson_3: -------------------------------------------------------------------------------- 1 | ''' 2 | Programming 102 3 | Unit 3 4 | ''' 5 | 6 | ''' 7 | Dictionaries ('dict') 8 | 9 | - one of the most powerful datatypes in Python 10 | - can be used to store large amounts of data and make accessing that data quick and easy 11 | - collections of key:value pairs 12 | - keys are used to access values 13 | 14 | - are defined using curly brackets {} 15 | - keys and values are separated with colons 16 | - key:value pairs are called 'items' 17 | - items are separated with commas 18 | ''' 19 | 20 | # blank dictionary 21 | blank_dictionary = {} 22 | 23 | # print(blank_dictionary, type(blank_dictionary)) # {}
2.1
6 | ---
7 | Create two dictionaries, `hero` and `villain`. The items in each dictionary will represent each characters stats.
8 |
9 |
10 |
11 | |Stat|Datatype|Values|
12 | |-|-|-|
13 | |`name`| string| any|
14 | |`hp`| integer | 0 - 100|
15 | |`attack` | integer |1 - 10|
16 |
17 |
18 | 19 |
20 | 21 | ## `is_defeated()` 22 | The `is_defeated()` function will determine if a player's `hp` is at or below zero, meaning they're been defeated. Here's the function's definition: 23 | 24 | ```python 25 | def is_defeated(character): 26 | ''' 27 | Returns False if the character's hp is greater than zero 28 | Returns True if the character's hp is less than or equal to 29 | ''' 30 | # ... your code here ... 31 | 32 | pass # replace 'pass' with a return statement 33 | ``` 34 | 35 |
36 |
37 | 38 | 39 |
40 | 41 | Write a REPL which allows the two characters to do battle. Each character will attack during every loop. 42 | 43 | Each attack will subtract the character's `attack` strength from its opponents `hp`. Since the `attack` stat has a range from 1 - 10, **feel free to multiply it by *5* or *10* to speed up the battle.** 44 | 45 | Use the `is_defeated()` function to determine if the opponent has lost the battle, announce who won and end the loop. 46 | 47 | An `input()` function can be used to slow the battle down a bit and allow the user to decide when the next round of the battle will be executed. This way the battle will be more interactive and won't happen instantaneously. 48 | 49 |
50 | 51 | ### [Exercise 2.1 Solution](./solutions/exercise_2/exercise_2_1_solution.md) 52 | 53 |
54 |
55 | 56 | ##
2.2
57 | ---
58 |
59 |
60 | Chances are that there is a fair amount of reptition in the logic which performs each character's turn in the battle, since the same steps will need to be executed by each character during their turn.
61 |
62 | Create a function `attack()` to handle each round of the battle.
63 |
64 | ```python
65 | def attack(attacker, opponent):
66 | '''
67 | Apply battle damage to the opponent using the attacker's attack stat
68 | If the opponent is defeated, return True, signifying the battle is over
69 | Otherwise return False, signifying the battle will continue for another round
70 | '''
71 | # ... your code here ...
72 |
73 | return # use is_defeated() to return True/False if the battle is over
74 | ```
75 |
76 | Subtract the value of the attacker's `attack` stat from the opponents `hp` stat. Return `True` if the opponent is defeated, otherwise return `False`. This boolean will be used to determine if the battle is over or if it will continue for another round.
77 |
78 | 79 | 80 | ### [Exercise 2.2 Solution](./solutions/exercise_2/exercise_2_2_solution.md) 81 | 82 | 83 |
84 |
85 | 86 | ##
2.3
87 | ---
88 |
89 |
90 | Add additional stats `defense` and `stance` and add allow each the characters to choose their `stance` each round.
91 |
92 |
93 |
94 |
95 | |Stat|Datatype|Values|
96 | |-|-|-|
97 | |`name`| string| any|
98 | |`hp`| integer | 0 - 100|
99 | |`attack` | integer |1 - 10|
100 | |`defense` |integer |1 - 10|
101 | |`stance`| string |`'attack'` / `'defend'`|
102 |
103 |
104 |
105 | 106 | 107 | If a character chooses to defend, they will not attack this turn. 108 | 109 | If the character's stance is set to `'defend'` when their opponent attacks, the damage they receive is reduced. If the character's stance is set to `'attack'`, no change is made to the incoming damage. 110 | 111 | Two additional functions could be added to handle these modifications: 112 | 113 |
114 | 115 | ## `set_stance()` 116 | 117 | This function will take in a character dictionary and allow them to choose whether they want to set their `stance` stat to`attack` or `defend` this round using a REPL. 118 | 119 | ```python 120 | def set_stance(character): 121 | ''' 122 | Ask the user which stance they would like to take this round. 123 | Change the value at the key of 'stance' to match the user's choice. 124 | Stance options: 'attack', 'defend' 125 | ''' 126 | 127 | # ... your code here ... 128 | 129 | # return the character dictionary with adjusted stance stat 130 | return character 131 | 132 | ``` 133 | 134 |
135 | 136 | ## `defend()` 137 | 138 | The function `defend()` will be used to adjust the incoming damage to a character when it's their opponent's turn to attack. 139 | 140 | Below are the damage reduction rates for different `'defense'` stat levels: 141 | 142 |
143 | 144 |
145 |
146 | |Defense Level|Damage Reduction|
147 | |-|-|
148 | |0 - 4|10%|
149 | |5 - 7|33%|
150 | |8 - 10|66%|
151 |
152 |
153 |
154 | 155 | 156 | ```python 157 | def defend(character, incoming_damage): 158 | ''' 159 | Calculate the amount the incoming_damage will be reduced 160 | based on the character's 'defense' stat. 161 | 162 | Return the amount the incoming_damage will be reduced 163 | in a variable called 'damage_reduction' 164 | 165 | 0 - 4 = 10%, 5 - 7 = 33%, 8 - 10 = 66% 166 | ''' 167 | 168 | # return the reduction amount, rounded to the nearest integer 169 | return round(damage_reduction) 170 | ``` 171 | 172 |
173 | 174 | ### [Exercise 2.3 Solution](./solutions/exercise_2/exercise_2_3_solution.md) 175 | 176 | 177 |
178 |
179 | 180 | --- 181 | 182 | ###
Extra Challenge
183 |
184 | Add some more fun features. Pull from your favorite games or stories and get creative! Some ideas might include:
185 |
186 | - Special, stronger attacks. These could even require a few rounds to build up power before they're able to be used.
187 | - randomized stats
188 | - randomize which character attacks first
189 | - add `'heal'` as a possible `stance` option and increase the character's `hp` that round if chosen based on a `healing` stat
190 | - have the opponent's choices be made by code, rather than user input
191 | - add a third character
192 | - More than one `villain` (list of dictionaries). The `hero` could `level_up()` with each opponent it defeats.
193 |
194 |
195 | ---
196 |
197 | ### [<< Back to Unit 4 Practice](/practice/unit_4/)
198 |
--------------------------------------------------------------------------------
/resources/example_lessons/unit_2/unit_2_lesson.py:
--------------------------------------------------------------------------------
1 | '''
2 | Programming 102
3 | Unit 2
4 | '''
5 |
6 | import random
7 |
8 | '''
9 | R ead
10 | E valuate
11 | P rint
12 | L oop
13 | '''
14 |
15 | ### INTRODUCE THE TERMINAL AS A REPL
16 |
17 | '''
18 | play_again = 'yes'
19 |
20 | # this loop will only loop if the user enters exactly 'yes'
21 | while play_again == 'yes':
22 | # loop this code block
23 |
24 | print('\nWelcome to the game!')
25 |
26 | # ...
27 | # ... other code ...
28 | # ...
29 |
30 | # ask the user if they want to play again
31 | play_again = input("Do you want to play again? yes/no: ")
32 |
33 | else:
34 | print("\nThanks for playing!")
35 | '''
36 | # ------------------------------------------------------------------------------- #
37 |
38 | '''
39 | while True: # infinite loop, requiring 'break' to end the loop
40 | # ask the user for a color and give them the option to quit
41 | color = input("\nEnter a color or 'done' to quit: ")
42 |
43 | # check if the user wants to quit
44 | if color == 'done':
45 | print('Goodbye!')
46 | break # end the loop
47 |
48 |
49 | print(f"\nThanks for entering '{color}'")
50 |
51 | '''
52 |
53 | # ------------------------------------------------------------------------------------------ #
54 |
55 | # Functions!
56 |
57 | # built-in functions
58 | # print(), type(), input(), len(), str(), int(), float(), list(), bool(), range()
59 |
60 | '''
61 | Functions
62 |
63 | - named code blocks
64 | - run only when called upon with parentheses after their name
65 | - typically designed to perform a single task
66 | - once defined, a function can be called as many times as needed with different data
67 | - receive data & return data after it's been manipulated
68 | '''
69 |
70 | # ---------------------------------------------------------------------------------- #
71 |
72 | ### INTRODUCE INCREMENTALLY
73 | ### 1. KEYWORD def
74 | ### 2. function_name, PARENTHESES, AND COLON
75 | ### 3. EXPLAIN THAT THE CODE BLOCK WILL BE CALLED WHEN THE FUNCTION IS RUN
76 | ### 4. DEFINE PARAMETERS TO ALLOW DATA TO BE PASSED INTO THE FUNCTION
77 | ### 5. EXPLAIN THAT THE DATA THAT IS PASSED TO THE PARAMETERS IS MANIPULATED IN THE FUNCTION
78 | ### 6. EXPLAIN return, THE VALUE THAT'S RETURNED AS WELL AS TO WHERE IT'S RETURNED
79 | ### 7. CALL THE FUNCTION, PASS ARGUMENTS, DEFINE VARIABLE WITH RETURN VALUE
80 |
81 | ### 8. THIS FORMAT CAN BE USED TO DEFINE ALL THE OTHER FUNCTIONS TOO
82 |
83 | # keyword 'def' to define a function
84 | '''
85 | # parameters are empty variables in a function's definition which await data from the function call
86 | def function_name(parameter_1, parameter_2, ...):
87 | # this code block will be run
88 | # when the function is 'called'
89 |
90 | # manipulate the parameters somehow
91 |
92 | # send the result back to where the function was called
93 | # with the keyword 'return'
94 | # if no return value is specified, a function will return 'None' by default
95 | return manipulate_parameters
96 |
97 | # call the function and save the return value in a variable
98 | data_returned_from_function = function_name(argument_1, argument_2, ...)
99 | # data passed to functions to fill parameters are called 'arguments'
100 | '''
101 | # ----------------------------------------------------------------------------------- #
102 |
103 | # increment(number) - add one to the number and return the result
104 |
105 | def increment(number):
106 | result = number + 1
107 | return result
108 |
109 | # call the function with a value for 'number'
110 | result = increment(9)
111 | # print(result)
112 |
113 | result = increment(result)
114 | # print(result)
115 |
116 | # use the function in a loop
117 | x = 0
118 |
119 | while x < 10:
120 | # print(x)
121 |
122 | # use the function to increment x
123 | x = increment(x)
124 |
125 | # -------------------------------------------------------------------------------------- #
126 |
127 | # arguments MUST be passed to fill parameters (unless default values are provided)
128 | # increment() # TypeError: increment() missing 1 required positional argument: 'number'
129 |
130 | # ---------------------------------------------------------------------------------------- #
131 |
132 | # add(a, b) - return the sum of two numbers, 'a' and 'b'
133 |
134 | def add(a=1, b=1):
135 | return a + b
136 |
137 | # if NO default values are provided for parameters:
138 | # add() # TypeError: add() missing 2 required positional arguments: 'a' and 'b'
139 | # add(9) # TypeError: add() missing 1 required positional argument: 'b'
140 | # print(add(9, 1)) # 10 - a=9, b=1
141 |
142 | # if default values ARE provided for parameters
143 | # print(add(10)) # 11 - (a=10, b=default)
144 | # print(add()) # 2 - (a=default, b=default)
145 | # print(add(5, 2)) # 7 - (a=5, b=2)
146 | # print(add(b=7)) # 8 - (a=default, b=7)
147 | # print(add(b=7, a=5)) # 12 - (a=5, b=7)
148 |
149 | # ------------------------------------------------------------------------------------- #
150 |
151 | # 'shred' a string and return a randomized list of its characters
152 |
153 | def shred_string(string):
154 | # convert the string to a list of its characters
155 | characters = list(string)
156 |
157 | # randomize the list
158 | random.shuffle(characters)
159 |
160 | return characters
161 |
162 |
163 |
164 | shredded = shred_string('hello world')
165 | # print(shredded)
166 |
167 | shredded = shred_string('ABCDEFG')
168 | # print(shredded)
169 |
170 | # -------------------------------------------------------------------------------------- #
171 |
172 | # generate a list of 'k' integers between 'low' and 'high'
173 |
174 | def generate_random_numbers(k, low=0, high=100):
175 | # create a blank list to store the numbers
176 | numbers = []
177 |
178 | # loop 'k' times
179 | for x in range(k):
180 | # generate a random number between 'low' and 'high'
181 | random_number = random.randint(low, high)
182 |
183 | # add the number to the list
184 | numbers.append(random_number)
185 |
186 | return numbers
187 |
188 |
189 | random_numbers = generate_random_numbers(10)
190 | # print(random_numbers) # [80, 94, 71, 99, 3, 48, 74, 29, 41, 12]
191 |
192 | random_numbers = generate_random_numbers(3, 10, 20)
193 | # print(random_numbers) # [15, 17, 17]
194 |
195 | random_numbers = generate_random_numbers(1000, -100, 100)
196 | # print(random_numbers)
197 |
198 |
--------------------------------------------------------------------------------
/practice/unit_2/solutions/exercise_4_solution.md:
--------------------------------------------------------------------------------
1 | # Unit 2 Practice Solutions
2 |
3 | ## **Exercise 4 - Calculator**
4 |
5 | ### **4.1**
6 |
7 | ```python
8 | def add(a, b):
9 | '''return the sum of two numbers, a and b'''
10 | return a + b
11 |
12 | def subtract(a, b):
13 | '''return the difference of two numbers, a and b'''
14 | return a - b
15 |
16 |
17 | while True:
18 | # ask the user for the operation
19 | operation = input("Enter the operation you would like to perform or 'done' to quit: ")
20 |
21 | # check if the user would like to quit
22 | if operation == 'done':
23 | print('Goodbye!')
24 | break # end the REPL
25 |
26 | # get the operands from the user
27 | operand_1 = input('Enter the first operand: ')
28 | operand_2 = input('Enter the second operand: ')
29 |
30 | # convert strings to floats
31 | operand_1 = float(operand_1)
32 | operand_2 = float(operand_2)
33 |
34 | # check the operation and call appropriate function
35 | if operation == '+':
36 | result = add(operand_1, operand_2)
37 | elif operation == '-':
38 | result = subtract(operand_1, operand_2)
39 |
40 | # display the result
41 | print(f'{operand_1} {operation} {operand_2} = {result}')
42 | ```
43 | ---
44 |
45 | ### **2.2**
46 |
47 | ```python
48 |
49 | # add these two functions
50 | def multiply(a, b):
51 | '''return the product of two numbers, a and b'''
52 | return a * b
53 |
54 | def divide(a, b):
55 | '''return the quotient of two numbers, a and b'''
56 | return a / b
57 |
58 | # ---------------------------------------------------- #
59 |
60 | # add checks for multiplication and division
61 | if operation == '+':
62 | result = add(operand_1, operand_2)
63 | elif operation == '-':
64 | result = subtract(operand_1, operand_2)
65 | elif operation == '*':
66 | result = multiply(operand_1, operand_2)
67 | elif operation == '/':
68 | result = divide(operand_1, operand_2)
69 |
70 | ```
71 |
72 | ---
73 | ### **2.3**
74 | ```python
75 | def add(a, b):
76 | '''return the sum of two numbers, a and b'''
77 | return a + b
78 |
79 | def subtract(a, b):
80 | '''return the difference of two numbers, a and b'''
81 | return a - b
82 |
83 | def multiply(a, b):
84 | '''return the product of two numbers, a and b'''
85 | return a * b
86 |
87 | def divide(a, b):
88 | '''return the quotient of two numbers, a and b'''
89 | return a / b
90 |
91 | # initialize the running total to None
92 | total = None
93 |
94 | while True:
95 | # ask the user for the operation
96 | operation = input("\n\nEnter the operation you would like to perform or 'done' to quit: ")
97 |
98 | # check if the user would like to quit
99 | if operation == 'done':
100 | # print final total
101 | print(f'\nYour final total was: {total}')
102 |
103 | print('\nGoodbye!')
104 | break # end the REPL
105 |
106 | # if total still contains the value None, get both operands from the user
107 | # note: this will only be True on the first loop
108 | if not total:
109 | # get the operands from the user
110 | operand_1 = input('Enter the first operand: ')
111 | operand_2 = input('Enter the second operand: ')
112 |
113 | else:
114 | # if the total is already defined, set it as the first operand and get the other operand from the user
115 | operand_1 = total
116 | operand_2 = input(f'\n{total} {operation} x:\n\nEnter x: ')
117 |
118 | # convert strings to floats
119 | operand_1 = float(operand_1)
120 | operand_2 = float(operand_2)
121 |
122 | # check the operation and call appropriate function
123 | if operation == '+':
124 | total = add(operand_1, operand_2)
125 |
126 | elif operation == '-':
127 | total = subtract(operand_1, operand_2)
128 |
129 | elif operation == '*':
130 | total = multiply(operand_1, operand_2)
131 |
132 | elif operation == '/':
133 | total = divide(operand_1, operand_2)
134 |
135 | # display the result
136 | print(f'\n{operand_1} {operation} {operand_2} = {total}')
137 | ```
138 |
139 | ---
140 | ### **2.4**
141 | ```python
142 | def add(a, b):
143 | '''return the sum of two numbers, a and b'''
144 | return a + b
145 |
146 | def subtract(a, b):
147 | '''return the difference of two numbers, a and b'''
148 | return a - b
149 |
150 | def multiply(a, b):
151 | '''return the product of two numbers, a and b'''
152 | return a * b
153 |
154 | def divide(a, b):
155 | '''return the quotient of two numbers, a and b'''
156 | return a / b
157 |
158 | # dictionary of operators as keys and their respective functions as values
159 | operations = {
160 | '+': add,
161 | '-': subtract,
162 | '*': multiply,
163 | '/': divide
164 | }
165 |
166 | # begin running total
167 | total = None
168 |
169 | while True:
170 | # ask the user for the operation
171 | operator = input("\nEnter the operation you would like to perform or 'done' to quit: ")
172 |
173 | # check if the user would like to quit
174 | if operator == 'done':
175 | # print final total
176 | print(f'\nYour final total was: {total}')
177 |
178 | print('\nGoodbye!')
179 | break # end the REPL
180 |
181 | # if total still contains the value None
182 | # note: this will only be True on the first loop
183 | if not total:
184 | # get the operands from the user
185 | operand_1 = input('Enter the first operand: ')
186 | operand_2 = input('Enter the second operand: ')
187 |
188 | else:
189 | # if the total is already defined, set it as the first operand
190 | operand_1 = total
191 | operand_2 = input(f'\n{total} {operator} x:\n\nEnter x: ')
192 |
193 | # convert strings to floats
194 | operand_1 = float(operand_1)
195 | operand_2 = float(operand_2)
196 |
197 | # retrieve the function at the key of the chosen operator
198 | operation = operations[operator]
199 |
200 | # perform the calculation on the total
201 | total = operation(operand_1, operand_2)
202 |
203 |
204 | # display the result
205 | print(f'{operand_1} {operator} {operand_2} = {total}')
206 | ```
207 | ---
208 | Keep in mind that this is just one potential solution.
209 |
210 | ---
211 |
212 | ## [< Exercise 3](../exercise_3.md)
213 |
214 | ### [<< Back to Unit 2 Practice](/practice/unit_2/)
215 |
--------------------------------------------------------------------------------
/resources/example_lessons/unit_4/unit_3_review.py:
--------------------------------------------------------------------------------
1 | '''
2 | Unit 3 Review
3 | '''
4 |
5 | # dictionaries are defined using curly brackets
6 | # key:value pairs are separated with commas
7 |
8 | blank_dictionary = {}
9 |
10 | todo = {
11 | # key: value,
12 | 'title': 'Go grocery shopping',
13 | 'completed': False
14 | }
15 |
16 | # dict keys are usually strings
17 | # dict values can be ANY datatype, including other dicts
18 |
19 | # ---------------------------------------------------------------------------------- #
20 |
21 | # when accessing values with keys,
22 | # the keys go in SQUARE brackets
23 | title = todo['title']
24 | # print(title) # Go grocery shopping
25 |
26 | # integers in square brackets generally mean lists
27 | # string in square brackets generally mean dictionaries
28 |
29 | # --------------------------------------------------------------------------------- #
30 |
31 | # cannot access a value at a non-existant key
32 | # todo['id'] # KeyError: 'id'
33 |
34 | # values can be added to keys that don't yet exist
35 | todo['id'] = 1
36 | # print(todo) # 'title': 'Go grocery shopping', 'completed': False, 'id': 1}
37 |
38 | # change the value at a key
39 | # the to do has been finished
40 | todo['completed'] = True
41 | # print(todo) # {'title': 'Go grocery shopping', 'completed': True, 'id': 1}
42 |
43 | # ----------------------------------------------------------------------------- #
44 |
45 | # .pop(key) delete the key:value pair at the key and return it
46 | todo_id = todo.pop('id')
47 | # print(todo_id, todo) # 1 {'title': 'Go grocery shopping', 'completed': True}
48 |
49 |
50 | # alternative to the .get() method:
51 | key = 'title'
52 | default = f"'{key}' is not a valid key in the dictionary."
53 |
54 | # check if the key is in the dictionary before using it
55 | if key in todo.keys():
56 | value = todo[key]
57 |
58 | else:
59 | value = default
60 |
61 | # print(value)
62 |
63 | # .get(key, default) - return the value at the key if it exists or the default if it doesn't
64 |
65 | key = 'id'
66 | default = f"'{key}' is not a valid key in the dictionary."
67 |
68 | value = todo.get(key, default)
69 | # print(value) # 'id' is not a valid key in the dictionary.
70 |
71 | # --------------------------------------------------------- #
72 |
73 | key = 'title'
74 | default = f"'{key}' is not a valid key in the dictionary."
75 |
76 | value = todo.get(key, default)
77 | # print(value) # Go grocery shopping
78 |
79 | # ------------------------------------------------------------------------- #
80 |
81 | #.update(new_dictionary) add the new_dictionary to the original
82 |
83 | todo.update({
84 | 'id': 1,
85 | 'user': 'KG'
86 | })
87 | # print(todo) # {'title': 'Go grocery shopping', 'completed': True, 'id': 1, 'user': 'KG'}
88 |
89 | # ------------------------------------- #
90 |
91 | # Display the todo item
92 | todo_display = f"""
93 | {todo['id']}. {todo['title']}
94 | Created by: {todo['user']}
95 | Completed: {todo['completed']}"""
96 |
97 | # print(todo_display)
98 |
99 | # ---------------------------------------- #
100 |
101 | # looping dictionaries
102 | # .keys(), .values(), .items() - access different parts of the a dictionary
103 |
104 | # print(todo.keys()) # dict_keys(['title', 'completed', 'id', 'user'])
105 |
106 | # loop through keys
107 | for key in todo.keys():
108 | # get the value at the current key
109 | value = todo[key]
110 | # print(f"{key}: {value}")
111 |
112 |
113 | # -------------------------------------------------------------------------- #
114 |
115 | # .values()
116 | # print(todo.values()) # dict_values(['Go grocery shopping', True, 1, 'KG'])
117 | '''
118 | for value in todo.values():
119 | print(value)
120 | '''
121 |
122 | # ----------------------------------------------------------------------- #
123 | # loop through the key:value pairs (items)
124 |
125 | # tuple - unchangeable list, uses indices but cannot accept new values
126 | # print(todo.items()) # dict_items([('title', 'Go grocery shopping'), ('completed', True), ('id', 1), ('user', 'KG')])
127 | '''
128 | for item in todo.items():
129 | key = item[0]
130 | value = item[1]
131 | print(f"{key}: {value}")
132 |
133 | '''
134 | # -------------------------------------------------------- #
135 |
136 | # 'in' to check if a key is in the dictionary
137 | # print('title' in todo.keys())
138 | # print('completed' in todo) # .keys() is optional
139 |
140 | # -------------------------------------------------------- #
141 |
142 | # instead of multiple, individual todo item dictionaries, create a list of dictionaries instead
143 | todo_1 = {'title': 'Go grocery shopping', 'completed': False, 'id': 1}
144 | todo_2 = {'title': 'Water the garden', 'completed': True, 'id': 2}
145 | todo_3 = {'title': 'Master Python dictionaries', 'completed': False, 'id': 3}
146 |
147 |
148 | # list of dictionaries
149 | todo_list = [
150 | {'title': 'Go grocery shopping', 'completed': False, 'id': 1},
151 | {'title': 'Water the garden', 'completed': True, 'id': 2},
152 | {'title': 'Master Python dictionaries', 'completed': False, 'id': 3}
153 | ]
154 |
155 | # list of dictionaries organized vertically
156 | todo_list = [
157 | {
158 | 'title': 'Go grocery shopping',
159 | 'completed': False,
160 | 'id': 1
161 | },
162 | {
163 | 'title': 'Water the garden',
164 | 'completed': True,
165 | 'id': 2
166 | },
167 | {
168 | 'title': 'Master Python dictionaries',
169 | 'completed': False,
170 | 'id': 3
171 | }
172 | ]
173 |
174 | # pull out one dictionary at a time from the list
175 | # print(todo_list[0]) # {'title': 'Go grocery shopping', 'completed': False, 'id': 1}
176 | # print(todo_list[0]['title']) # Go grocery shopping
177 |
178 | # loop through the todo_list
179 | for todo in todo_list:
180 | # if todo['completed'] == False:
181 | if not todo['completed']: # same as line 168
182 | todo_display = f"""
183 | {todo['id']}. {todo['title']}
184 | Completed: {todo['completed']}"""
185 |
186 | # print(todo_display)
187 |
188 | # ------------------------------------------------------------ #
189 |
190 | # nested dictionaries
191 |
192 | fruit_prices = {
193 | 'apple': {
194 | 'green': 2.12,
195 | 'yellow': 3.13,
196 | 'red': {
197 | 'price': 4.14,
198 | 'inventory': 100
199 | }
200 | },
201 | 'grape': 3.13
202 | }
203 |
204 | # print(fruit_prices['apple']) # {'green': 2.12, 'yellow': 3.13, 'red': 4.14}
205 |
206 | apple_prices = fruit_prices['apple']
207 | # print(apple_prices['green']) # 2.12
208 |
209 | # print(fruit_prices['apple']['green']) # 2.12
210 |
211 | # print(fruit_prices['apple']['red']) # {'price': 4.14, 'inventory': 100}
212 | # print(fruit_prices['apple']['red']['price']) # 4.14
213 |
--------------------------------------------------------------------------------
/practice/unit_4/solutions/exercise_2/exercise_2_3_solution.md:
--------------------------------------------------------------------------------
1 | # Unit 4 Practice Solutions
2 |
3 | ## **Exercise 2 Solution**
4 |
5 | ### **2.3**
6 |
7 |
8 | 
9 |
10 |
11 |
9 | 12 | 13 | In this version, we're going to allow the active player to choose if they want to attack or defend each round. If they choose to defend, the next damage they receive will be reduced based on their `defense` stat. 14 | 15 | We'll be introducing two more functions, `set_stance()` and `defend()`. 16 | 17 | ### `set_stance()` 18 | 19 | This function will contain a REPL which will allow the user to choose which stance the active character should take this round. The function will take in the user's input, set the active character's stance stat and return the updated character dictionary. 20 | 21 | ### `defend()` 22 | 23 | This function will take in the opponent's stat dictionary and the amount of incoming damage from the active player's `attack` stat, reduce the incoming damage based on the opponent's `defense` stat and return the reduced damage amount. 24 | 25 | ```python 26 | 27 | # ----------------------------------------------------------- # 28 | # Setup 29 | # ----------------------------------------------------------- # 30 | hero = { 31 | "name": "Andromeda", 32 | "hp": 100, 33 | "attack": 7, 34 | "defense": 6, 35 | "stance": "" # 'attack' or 'defend' 36 | } 37 | 38 | villain = { 39 | "name": "Helios", 40 | "hp": 100, 41 | "attack": 5, 42 | "defense": 5, 43 | "stance": "" # 'attack' or 'defend' 44 | } 45 | 46 | 47 | def is_defeated(character): 48 | ''' 49 | Returns False if the character's hp is greater than zero 50 | Returns True if the character's hp is less than or equal to 51 | ''' 52 | return character['hp'] <= 0 53 | 54 | 55 | def set_stance(character): 56 | ''' 57 | Set the character's stance stat with user 58 | input and return the updated dictionary 59 | ''' 60 | 61 | stance_options = { 62 | '1': 'attack', 63 | '2': 'defend' 64 | } 65 | 66 | prompt = f""" 67 | {character['name']}, how would you like to proceed? 68 | 69 | 1. Attack 70 | 2. Defend 71 | 72 | Enter the number of the option 73 | > """ 74 | 75 | stance_number = input(prompt) 76 | 77 | # make sure the user entered a valid selection 78 | while stance_number not in stance_options.keys(): 79 | print('\n!***! Invalid selection !***!') 80 | stance_number = input(prompt) 81 | 82 | # Once the user has entered a valid selection, set the dictionary- 83 | character['stance'] = stance_options[stance_number] 84 | 85 | return character 86 | 87 | 88 | def defend(character, incoming_damage): 89 | ''' 90 | Calculate the amount the incoming_damage will be reduced 91 | based on the character's 'defense' stat. 92 | 93 | Return the amount the incoming_damage will be reduced 94 | in a variable called 'damage_reduction' 95 | 96 | 0 - 4 = 10%, 5 - 7 = 33%, 8 - 10 = 66% 97 | ''' 98 | defense = character['defense'] 99 | if defense < 5: 100 | damage_reduction = incoming_damage * .1 101 | elif defense < 8: 102 | damage_reduction = incoming_damage * .33 103 | else: 104 | damage_reduction = incoming_damage * .66 105 | 106 | # return the reduction amount, rounded to the nearest integer 107 | return round(damage_reduction) 108 | 109 | 110 | def attack(active, opponent): 111 | ''' 112 | Apply battle damage to the opponent using the attacker's attack stat 113 | If the opponent is defeated, return True, signifying the battle is over 114 | Otherwise return False, signifying the battle will continue for another round 115 | ''' 116 | battle_over = False 117 | 118 | print("\n" + ("-" * 50)) # print a divider 119 | 120 | # display hp 121 | print(f"\n{active['name']} has {active['hp']} hp!") 122 | print(f"{opponent['name']} has {opponent['hp']} hp!") 123 | 124 | input("\nPress enter to battle!") 125 | 126 | 127 | # active character chooses stance 128 | active = set_stance(active) 129 | 130 | print("\n" + ("-" * 50)) # print a divider 131 | 132 | if active['stance'] == 'attack': 133 | # active character attacks 134 | print(f"\n{active['name']} attacks!") 135 | 136 | # damage to be dealt to the opponent 137 | damage = active['attack'] * 5 # multiply damage to speed up the game 138 | 139 | # if the opponent chose to defend last turn 140 | if opponent['stance'] == 'defend': 141 | # calculate the damage reduction 142 | damage_reduction = defend(opponent, damage) 143 | 144 | # reduce damage 145 | damage -= damage_reduction 146 | 147 | print(f"\n{opponent['name']} defends! Damage reduced by {damage_reduction}!") 148 | 149 | # subtract attackers's attack strength from the opponents's hp 150 | opponent['hp'] -= damage 151 | 152 | print(f"{opponent['name']} takes {damage} damage!") 153 | 154 | elif active['stance'] == 'defend': 155 | print(f"\n{active['name']}, the next damage you receive will be reduced!") 156 | 157 | # return True if the opponent is defeated, otherwise False 158 | return is_defeated(opponent) 159 | 160 | 161 | 162 | 163 | # ----------------------------------------------------------- # 164 | # Battle! 165 | # ----------------------------------------------------------- # 166 | 167 | # this will alternate between 0 and 1 to decide whose turn it is 168 | turn_counter = 0 169 | 170 | while True: 171 | 172 | # stat dictionaries stored at matching keys 173 | all_stats = { 174 | 'hero': hero, 175 | 'villain': villain 176 | } 177 | 178 | # keys for the all_stats dictionary 179 | # the turn_counter will alternate between 0 and 1 to decide whose turn it is 180 | stat_keys = list(all_stats.keys()) # ['hero', 'villain'] 181 | 182 | # get the key of the active player 183 | active_key = stat_keys[turn_counter] 184 | # get the stat dictionary of the active player 185 | active = all_stats[active_key] 186 | 187 | 188 | # get the key of the current opponent 189 | # index -1 if turn_counter is 0 190 | # index 0 if the turn_counter is 1 191 | opponent_key = stat_keys[turn_counter - 1] 192 | # get the stat dictionary of the opponent 193 | opponent = all_stats[opponent_key] 194 | 195 | # execute current round of battle 196 | # receive True if opponent is defeated, otherwise False 197 | victorious = attack(active, opponent) 198 | 199 | # check the outcome of the battle. 200 | # if the opponent was defeated, end the loop 201 | if victorious: 202 | print(f"\n{opponent['name']} has been defeated! {active['name']} is victorious!") 203 | break # end the loop 204 | 205 | ``` 206 | 207 | 208 | 209 | 210 | Keep in mind that this is just one potential solution. 211 | 212 | ## [< 2.2 Solution](./exercise_2_2_solution.md) 213 | --- 214 | 215 | ### [<< Back to Unit 4 Practice](/practice/unit_4/) 216 | -------------------------------------------------------------------------------- /resources/lessons/lesson_3_review: -------------------------------------------------------------------------------- 1 | ''' 2 | Unit 3 Review 3 | ''' 4 | 5 | # dictionaries are defined using curly brackets 6 | # key:value pairs are separated with commas 7 | 8 | blank_dictionary = {} 9 | 10 | 11 | todo = { 12 | # key:value 13 | 'title':'Go grocery shopping', 14 | 'completed': False 15 | } 16 | 17 | 18 | # dict keys are usually strings 19 | # dict values can be ANY datatype, including other dicts 20 | 21 | # ---------------------------------------------------------------------------------- # 22 | 23 | # when accessing values with keys, 24 | # the keys go in SQUARE brackets 25 | 26 | title = todo['title'] 27 | # print(title) # Go grocery shopping 28 | 29 | # integers in square brackets generally mean lists 30 | # string in square brackets generally mean dictionaries 31 | 32 | # --------------------------------------------------------------------------------- # 33 | 34 | # cannot access a value at a non-existant key 35 | 36 | # todo['id'] # KeyError: 'id' 37 | 38 | # values can be added to keys that don't yet exist 39 | 40 | todo['id'] = 1 41 | 42 | # print(todo) # {'title': 'Go grocery shopping', 'completed': False, 'id': 1} 43 | 44 | # change the value at a key 45 | # the todo has been finished 46 | 47 | todo['completed'] = True 48 | # print(todo) {'title': 'Go grocery shopping', 'completed': True, 'id': 1} 49 | 50 | # ----------------------------------------------------------------------------- # 51 | '''Dictionary Methods''' 52 | 53 | # .pop(key) delete the key:value pair at the key and return the value 54 | 55 | todo_id = todo.pop('id') 56 | # print(todo_id, todo) # 1 {'title': 'Go grocery shopping', 'completed': True} 57 | 58 | # ----------------------------------------------------------------------------- # 59 | 60 | # alternative to the .get() method: 61 | 62 | key = 'title' 63 | 64 | default = f"'{key}' is not a valid key in the dictionary." 65 | 66 | # check if the key is in the dictionary before using it 67 | 68 | if key in todo.keys(): 69 | value = todo[key] 70 | 71 | else: 72 | value = default 73 | 74 | # print(value) 75 | 76 | # .get(key, default) - return the value at the key if it exists or the default if it doesn't 77 | 78 | key = 'id' 79 | default = f"'{key} is not a valid key in the dictionary." 80 | 81 | value = todo.get(key, default) 82 | # print(value) # 'id' is not a valid key in the dictionary. 83 | 84 | # ------------------------------------------------------------------------- # 85 | 86 | # .update(new_dictionary) add the new_dictionary to the original 87 | 88 | 89 | todo.update({ 90 | 'id':1, 91 | 'user': 'JJ' 92 | }) 93 | 94 | # print(todo) {'title': 'Go grocery shopping', 'completed': True, 'id': 1, 'user': 'JJ'} 95 | # ------------------------------------- # 96 | 97 | # Display the todo item 98 | 99 | todo_display = f""" 100 | {todo['id']}. {todo['title']} 101 | Created by: {todo['user']} 102 | Completed: {todo['completed']}""" 103 | 104 | # print(todo_display) 105 | # ---------------------------------------- # 106 | # looping dictionaries 107 | # .keys(), .values(), .items() - access different parts of the a dictionary 108 | 109 | # print(todo.keys()) dict_keys(['title', 'completed', 'id', 'user']) 110 | 111 | 112 | # -------------------------------------------------------------------------- # 113 | 114 | # .keys() - access a dictionary's values 115 | 116 | # loop through keys 117 | 118 | for key in todo.keys(): 119 | # get the value at the current key 120 | value = todo[key] 121 | 122 | # print(f'{key}: {value}') 123 | 124 | # -------------------------------------------------------------------------- # 125 | 126 | # .values() - access a dictionary's values 127 | # print(todo.values()) # dict_values(['Go grocery shopping', True, 1, 'JJ']) 128 | 129 | ''' 130 | for value in todo.values(): 131 | print(value) 132 | ''' 133 | # ----------------------------------------------------------------------- # 134 | # loop through the key:value pairs (items) 135 | 136 | # tuple - unchangeable list, uses indices but cannot accept new values 137 | 138 | # print(todo.items()) # dict_items([('title', 'Go grocery shopping'), ('completed', True), ('id', 1), ('user', 'JJ')]) 139 | ''' 140 | for item in todo.items(): 141 | key = item[0] 142 | value = item[1] 143 | print(f'{key}: {value}') 144 | ''' 145 | 146 | 147 | # -------------------------------------------------------- # 148 | 149 | # 'in' to check if a key is in the dictionary 150 | 151 | # print('title' in todo.keys()) 152 | # print('completed' in todo) # .keys() is optional 153 | 154 | # -------------------------------------------------------- # 155 | 156 | # instead of multiple, individual todo item dictionaries, create a list of dictionaries instead 157 | 158 | todo_1 = {'title': 'Go grocery shopping', 'completed': False, 'id': 1} 159 | todo_2 = {'title': 'Water the garden', 'completed': True, 'id': 2} 160 | todo_3 = {'title': 'Master Python dictionaries', 'completed': False, 'id': 3} 161 | 162 | # list of dictionaries. List is organized vertically, dictionaries organized horizontally. 163 | 164 | todo_list = [ 165 | 166 | {'title': 'Go grocery shopping', 'completed': False, 'id': 1}, 167 | {'title': 'Water the garden', 'completed': True, 'id': 2}, 168 | {'title': 'Master Python dictionaries', 'completed': False, 'id': 3}, 169 | 170 | ] 171 | 172 | # list of dictionaries organized vertically 173 | todo_list = [ 174 | 175 | { 176 | 'title': 'Go grocery shopping', 177 | 'completed': False, 178 | 'id': 1 179 | }, 180 | { 181 | 'title': 'Water the garden', 182 | 'completed': True, 183 | 'id': 2 184 | }, 185 | { 186 | 'title': 'Master Python dictionaries', 187 | 'completed': False, 188 | 'id': 3 189 | } 190 | 191 | ] 192 | 193 | # pull out a single dictionary from the list using an index 194 | # print(todo_list[0]) # {'title': 'Go grocery shopping', 'completed': False, 'id': 1} 195 | 196 | # print(todo_list[0]['title']) # Go grocery shopping 197 | 198 | # loop through the todo_list 199 | 200 | for todo in todo_list: 201 | # if todo['completed'] == False 202 | if not todo['completed']: # same as line 201 203 | 204 | todo_display = f""" 205 | {todo['id']}. {todo['title']} 206 | Completed: {todo['completed']}""" 207 | 208 | # print(todo_display) 209 | 210 | 211 | # ------------------------------------------------------------ # 212 | 213 | # nested dictionaries 214 | 215 | fruit_prices = { 216 | 217 | 'apple': { 218 | 'green': 2.12, 219 | 'yellow': 3.13, 220 | 'red': { 221 | 'price': 4.14, 222 | 'inventory': 100 223 | } 224 | }, 225 | 'grape': 3.13 226 | } 227 | 228 | # print(fruit_prices['apple']) # {'green': 2.12, 'yellow': 3.13, 'red': {'price': 4.14, 'inventory': 100}} 229 | 230 | 231 | apple_prices = fruit_prices['apple'] 232 | 233 | # print(apple_prices['green']) # 2.12 234 | 235 | # print(fruit_prices['apple']['green']) # 2.12 236 | 237 | # print(fruit_prices['apple']['red']) # {'price': 4.14, 'inventory': 100} 238 | # print(fruit_prices['apple']['red']['price']) # 4.14 239 | -------------------------------------------------------------------------------- /units/unit1.md: -------------------------------------------------------------------------------- 1 | # Unit 1 - Review 2 | 3 | --- 4 | 5 | [Back to Syllabus](https://github.com/PdxCodeGuild/Programming102#top) 6 | 7 | ### Table of Contents 8 | 9 | - [Unit 1 - Review](#unit-1---review) 10 | - [Table of Contents](#table-of-contents) 11 | - [ Variables](#-variables) 12 | - [ DataTypes](#-datatypes) 13 | - [ Conditional Statements](#-conditional-statements) 14 | - [ For / While Loops](#-for--while-loops) 15 | - [while loops](#while-loops) 16 | - [for loops](#for-loops) 17 | - [ Troubleshooting](#-troubleshooting) 18 | - [ Common Error Messages](#-common-error-messages) 19 | - [Exercises](#exercises) 20 | - [Lab 1](#lab-1) 21 | 22 | --- 23 | 24 | ### Variables 25 | 26 | - Variables in python are used to reference data. They make our code more readable if used correctly. 27 | - Variables are declared when you give them a name and assign them a value `name = "Anthony"` 28 | - Keep in mind there are a few rules when choosing your variable name: 29 | - Variables names are case sensitive (name and NAME are different variables) 30 | - Must start with a letter or underscore 31 | - Can have numbers but can not start with one 32 | 33 | --- 34 | 35 | ### DataTypes 36 | 37 | | DataType | Description | Example | 38 | | -------- | ---------------------- | --------------------------------------------- | 39 | | String | Text Surrounded By "" | `string1 = "hello"` | 40 | | Integer | Whole Number | `int1 = 4` | 41 | | Float | Decimal Number | `float1 = 2.4` | 42 | | Boolean | True/False | `bool1 = True` | 43 | | List | Collection of Elements | `list1 = ["hello", "goodbye", 4, 2.4, False]` | 44 | 45 | --- 46 | 47 | ### Conditional Statements 48 | 49 | We can decide `if` we want code to run based on a true or false condtion. 50 | 51 | ```python 52 | num = 4 53 | if num > 0: 54 | print("Number is greater than zero") 55 | ``` 56 | 57 | We can also choose to run code if the previous condition was false, but the current condion is true. 58 | To do this we use `elif`: 59 | 60 | ```python 61 | num = 4 62 | if num > 0: 63 | print("Number is greater than zero") 64 | elif num == 0: 65 | print("The number is zero) 66 | ``` 67 | 68 | Finally we can use `else` to catch anything that was not caught by the previous condtions: 69 | 70 | ```python 71 | num = 4 72 | if num > 0: 73 | print("Number is greater than zero") 74 | elif num == 0: 75 | print("The number is zero") 76 | else: 77 | print("The number is less than zero") 78 | ``` 79 | 80 | --- 81 | 82 | ### For / While Loops 83 | 84 | Loops can be used to run a block of code more than once. Python has two kinds of loops, the `while` loop and the `for` loop. 85 | 86 | #### while loops 87 | 88 | `while` loops are similar to `if` statements. They run as long as the condition remains true. 89 | 90 | ```python 91 | num = 0 92 | while num < 5: 93 | print(num) 94 | num += 1 # Be sure to increment our counter, otherwise the condition would remain True forever 95 | ``` 96 | 97 | #### for loops 98 | 99 | `for` loops are slightly different. They are useful when iterating over a list: 100 | 101 | ```python 102 | colors = ["red", "blue", "green", "yello", "purple"] 103 | for color in colors: # color is a temporary variable name holding an element from colors 104 | print(color) 105 | ``` 106 | 107 | ### Troubleshooting 108 | 109 |  110 | 111 | ### Common Error Messages 112 | 113 | | Error | Cause | Example | 114 | | ------------------- | ------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------- | 115 | | AttributeError | Attribute reference or assignment fails | [AttributeError](https://repl.it/@dirtTastesGood/pythonattributeerrorexample) | 116 | | ImportError | `import` statement has troubles trying to load a module | [ImportError](https://repl.it/@dirtTastesGood/pythonimporterrorexample) | 117 | | ModuleNotFoundError | `import` statement has troubles trying to load a module | [ModuleNotFoundError](https://repl.it/@dirtTastesGood/pythonmodulenotfounderrorexample) | 118 | | IndexError | sequence index is out of range | [IndexError](https://repl.it/@dirtTastesGood/pythonindexerrorexample) | 119 | | KeyError | Referenced key is not in a dictionary | [KeyError](https://repl.it/@dirtTastesGood/pythonkeyerrorexample) | 120 | | KeyboardInterrupt | Using `ctrl + c` to exit Python program | [KeyboardInterrupt](https://repl.it/@dirtTastesGood/pythonkeyboardinterruptexample) | 121 | | NameError | Variable or function name doesn't exist | [NameError](https://repl.it/@dirtTastesGood/pythonnameerrorexample) | 122 | | SyntaxError | Many causes. Incorrect Python syntax. | [SyntaxError](https://repl.it/@dirtTastesGood/pythonsyntaxerrorexample) | 123 | | IndentationError | Indendation too far left or right | [IndentationError](https://repl.it/@dirtTastesGood/pythonindentationerrorexample) | 124 | | TypeError | operation or function is applied to an object of inappropriate type. | [TypeError](https://repl.it/@dirtTastesGood/pythontypeerrorexample) | 125 | | UnboundLocalError | Variable isn't defined within the function | [UnboundLocalError](https://repl.it/@dirtTastesGood/pythonunboundlocalerrorexample) | 126 | | ValueError | an operation or function receives an argument that has the right type but an inappropriate value | [ValueError](https://repl.it/@dirtTastesGood/pythonvalueerrorexample) | 127 | | ZeroDivisionError | Dividing by zero | [ZeroDivisionError](https://repl.it/@dirtTastesGood/pythonzerodivisionerrorexample) | 128 | 129 | --- 130 | 131 | ### [Exercises](https://github.com/PdxCodeGuild/Programming102/blob/master/practice/unit_1/) 132 | 133 | ### [Lab 1](https://github.com/PdxCodeGuild/Programming102/blob/master/labs/lab1.md) 134 | 135 | [Back to top](#top) 136 | --------------------------------------------------------------------------------