2. Exercises: Unconditional String of Exceptions¶
In this exercise we can finally make programs that are a bit more than simple calculation automatons. Execution can differ more drastically between runs of the same program because now the user has more options for interacting with the program. Compared to the last exercises these ones should be quite a bit more challenging when more different situations are entered into the equation. The last set of exercises also give your very first introduction to sub problems of the final project topics. They can be used as a very rough approximation what kinds of things will be encountered in the project.
Learning Goals¶
After these exercises you can make programs that branch based on the user's choices. You can also inform users about invalid
inputs
and your programs can produce pleasant output. The exercises focus around three key concepts from the material: strings
, exception
handling, and conditional structures
. Dictionaries
are also used. Each task also has some program design to it - it's hard to avoid doing that after all.Example¶
Problem Definition¶
Make a program that prompts for two integers, and figures out whether one of them is the other one's factor. Users are notified about invalid inputs. Below are some examples of how the program should look like to the user:
{{{
Input first number: 5
Input second number: 10
5 is a factor of 10.
Input first number: 9 Input second number: -3 -3 is a factor of 9.
Input first number: 7 Input second number: 4 Neither of the numbers is the other's factor.
Input first number: 2 Input second number: -2 2 is a factor of -2.
Input first number: 0 Input second number: 3 3 is a factor of 0.
Input first number: 0 Input second number: 0 0 is a factor of 0.
Input first number: aasi This doesn't look like a number
Input first number: 0 Input second number: aasi This doesn't look like a number
Solution¶
Let's start with the easy part: prompting the numbers. We should already know how to do this from the last exercises:
number_1 = int(input("Input first number: "))
number_2 = int(input("Input second number: "))
The testing can be done with modulo. If the remainder is zero, the divider is the dividee's factor.
Let's think about how this program would branch. There are two possible prints: either one of the numbers is the other one's factor, or neither is. This could hint at there being two
branches
like seen below. At this stage we'll just use pass inside the branch for each conditional statement
. if number_1 % number_2 == 0 or number_2 % number_1 == 0:
pass
else:
pass
This results in an immediate problem: which one was the factor of the other? The conditional statement we devised doesn't give us that information. We'd need another test inside this branch to figure out which was which. We could do that by checking which number is smaller since a bigger number can't be the factor of a smaller number. We're not doing that though because it makes things unnecessarily complicated. Instead we split this branch into two branches:
if number_1 % number_2 == 0:
pass
elif number_2 % number_1 == 0:
pass
else:
pass
With this we know that when in the first branch, number_2 was a factor of number_1, and likewise in the second branch we know it's the other way around. We can now replace the placeholder pass commands with prints. We do this by copying the text from the given examples and replacing numbers with
placeholders
. Notice the changing order of arguments
between branches.if number_1 % number_2 == 0:
print(f"{number_2} is a factor of {number_1}.")
elif number_2 % number_1 == 0:
print(f"{number_1} is a factor of {number_2}.")
else:
print("Neither of the numbers is the other's factor.")
Let's combine this with the input prompts we wrote earlier and try it out:
Input first number: 4 Input second number: 0 --------------------------------------------------------------------------- ZeroDivisionError Traceback (most recent call last) /media/sf_virtualshare/OA/code/H2/factor.py in1 number_1 = int(input("Input first number: ")) 2 number_2 = int(input("Input second number: ")) ----> 3 if number_1 % number_2 == 0: 4 print(f"{number_2} is a factor of {number_1}.") 5 elif number_2 % number_1 == 0: ZeroDivisionError: integer division or modulo by zero
Oh yeah, zero might be a problem since we're doing division with the numbers. We know that all numbers are factors of zero and zero is a factor of itself. In other words, if one of the numbers is zero, the other number will always be its factor. This time we're wiser and don't even try to put this inside one
branch
. Instead, we'll add two. This time it is also extremely important to consider the placement of these new branches. If the user inputs
zero, code execution cannot be allowed to reach any conditional statements
that contain division. This can be achieved by putting the new branches before the old ones. This works because only the first branch with a fulfilled condition
is executed - everything after it in the same conditional structure
is skipped. With this addition we have:number_1 = int(input("Input first number: "))
number_2 = int(input("Input second number: "))
if number_1 == 0:
print(f"{number_2} is a factor of {number_1}.")
elif number_2 == 0:
print(f"{number_1} is a factor of {number_2}.")
elif number_1 % number_2 == 0:
print(f"{number_2} is a factor of {number_1}.")
elif number_2 % number_1 == 0:
print(f"{number_1} is a factor of {number_2}.")
else:
print("Neither of the numbers is the other's factor.")
Let's try again:
Input first number: 4 Input second number: 0 4 is a factor of 0.
We're now golden. At least as long as the user actually
inputs
integers. We still need to handle invalid inputs. This can be done with a try-except structure that catches the ValueError exception
- like we did in the material.try:
number_1 = int(input("Input first number: "))
number_2 = int(input("Input second number: "))
except ValueError:
print("This doesn't look like a number")
This is fine, sort of, except if we actually put it as-is in the beginning of the program, we achieve new problems:
Input first number: donkey This doesn't look like a number --------------------------------------------------------------------------- NameError Traceback (most recent call last) /media/sf_virtualshare/OA/code/H2/factor.py in4 except ValueError: 5 print("This doesn't look like a number") ----> 6 if number_1 == 0: 7 print(f"{number_2} is a factor of {number_1}.") 8 elif number_2 == 0: NameError: name 'number_1' is not defined
If you look carefully you can see that the notification was printed like we wanted. Unfortunately the program still crashed. The culprit is the NameError caused by line 6 in the code. We really got our work cut out for us... The crux of the problem is that the execution of line 2 is interrupted immediately when the int function fails. This means that number_1 was never defined. Obviously there's little point in going through the conditional structure if we don't have two numbers to compare. The correct behavior would be to skip rest of the program if there is an exception in the input part. We can achieve this by adding an else branch to our try structure and pushing the rest of the code inside it:
try:
number_1 = int(input("Input first number: "))
number_2 = int(input("Input second number: "))
except ValueError:
print("This doesn't look like a number")
else:
if number_1 == 0:
print(f"{number_2} is a factor of {number_1}.")
elif number_2 == 0:
print(f"{number_1} is a factor of {number_2}.")
elif number_1 % number_2 == 0:
print(f"{number_2} is a factor of {number_1}.")
elif number_2 % number_1 == 0:
print(f"{number_1} is a factor of {number_2}.")
else:
print("Neither of the numbers is the other's factor.")
Understanding the above construct is of extreme importance for completing exercises in this page. Study it to your heart's content. Now the program works:
Input first number: donkey This doesn't look like a number
Closing Programs¶
This exercise contains tasks that will ask you to stop the program execution when an error is detected. This means that notifying the user about their error should be the last executable line in that particular branch in the program. The structure of the program has to be designed in a way that every error notification happens inside a control structure in such a way that there will be nothing left to execute after it. If you try to google how to exit a Python program, you can easily find answers using the quit and exit functions. However, these cannot be used for two reasons.
The first reason is related to learning: one major goal of this exercise is to learn to control the flow of the program with control structures - without shortcuts. Shortcuts can be used when the fundamentals of program flow control have been learned. The other reason is technical: these functions will shut down the entire Python process. The checkers work by importing the returned program as part of themselves to run it and call its functions. Therefore, these forbidden functions will not only close the returned program, they will also close the checker. As a result you will get the dreaded "The checking program was unable to finish" error.
General Exercises¶
All these exercises are mandatory parts of the course.
Warmup Exercise¶
Political Squares¶
Sometimes screen geometry requires knowing an object's position in relation to another object or an axis. For instance if we want a creature that moves towards the nearest edge, we first need to find out which direction the closest edge is to. In this exercise you'll get to implement a simple conditional statement that is used for drawing politically oriented squares. Their color depends on their position: red for left, blue for right.
Learning goals: [!hint-poliittiset-neliöt-if!]Controlling program flow with[!hint!] a
conditional structure
. Recognizing halves of a coordinate system.Goal: A program that draws squares with colors that depend on their x coordinates
Introduction:
Just like the previous warmup exercise, we've once again given you a template for your code. All code must once again be written inside the function.
Function Specification:
draw_square- Parameters:
- side length (integer)
- starting point x coordinate (integer)
- starting point y coordinate (integer)
The function draws one square with a fill color that depends on its starting x coordinate being negative or positive For negative x coordinate
value
you must use "red" and for positive you must use "blue".Main Program:
The code in the given template's
main program
should draw the squares shown in the picture if the function has been implemented correctly. Note: the way you turn when drawing a square affects their placement - your result may not be exactly the same as this picture (these have been drawn by turning right)!
List of Turtle Commands:
No new commands in this one, but all commands are listed here for convenience. You won't need all of them.
forward(x) # makes the turtle move forward x pixels, e.g. forward(42)
left(a) # makes a left turn of a degrees, where a is an integer, e.g.. left(40)
right(a) # makes a right turn of a degrees, where a is an integer, e.g.. right(40)
color(c) # sets color. c is a color value. In this exercise, you can use basic values such as "red", "yellow", "blue", e.g. color("red")
begin_fill() # begins a fill; any lines drawn after this are treated as boundaries for the fill
end_fill() # stops a fill; this command indicates that we're happy with our boundaries, and it's ok to pour the selected color (by the color command) inside
reset() # if you make a mistake, you can use this command to clear everything and return the Turtle to its origin.
up() # lifts the pen up so that it can be moved without drawing
down() # puts the pen back down
setx(x) # sets the pen's x coordinate to the given value
sety(y) # sets the pen's y coordinate to the given value
circle(r) # draws a circle with radius r; this happens by moving the pen a full 360 degree circle from its current position constantly steering to the left
Give feedback on this content
Was this task useful for learning?
Comments about the task?
Main Exercises¶
Speed Policing¶
Much like any other public organization, the police is having some IT problems. In their desperation, they've approached you with an offer that you cannot refuse: your task is to make a program for calculating the speed of a car, when given distance traveled and time frame. You promptly set forth to implement your herculean task.
Learning goals: Using
placeholders
to insert results and other numbers into strings
. Goal: A program that prompts for travel distance and time traveled, and prints the corresponding speed in a neat little output.
Main Program Specification:
The program prompts for two
floats
. The police's ability to input numbers via keyboard has severely deteriorated due to excessive smartphone use so it's best for everyone that we give nice notifications about invalid inputs
. In case the police accidentally inputs proper floats, the program should print the given numbers and the calculated speed as kilometers per hour. As you can see from the examples, all numbers must be printed with 2 decimal precision. You need to use f strings to achieve this. Using the round function will only leave you biting dust.If you get style warnings about long lines, you can split a long string into multiple lines simply by partitioning it like this. The f prefix needs to be added to all parts that contain placeholders.
print(
"This do be a really really really long line of text "
"and if you also want to add placeholders it's gonna get even longer..."
)
You can get an example for exception handling from the the example in this exercise page. This example can be applied here quite directly.
Use Example:
Input distance traveled (m): 50.0 Input elapse time (s): 3.0 The speed of a car traveling 50.00 meters in 3.00 seconds is 60.00 km/h.
Input distance traveled (m): 50.0m You need less donuts, and more number inputting.
Input distance traveled (m): 50.0 Input elapse time (s): minute You need less donuts, and more number inputting.
Give feedback on this content
Was this task useful for learning?
Comments about the task?
Tailored Hexes¶
The raw contents of a computer's memory is often presented with hexadecimal numbers, i.e. base 16 numbers where the letters a to f stand for 10 to 15. It's also typical to include leading zeros to show how many bits are stored in memory. One hex digit is 4 bits. This is convenient because the memory slot sizes are always powers of 2, and the smallest possible is 8 bits - i.e. 2 hex digits. This means the size of the memory slot is always easily seen from the number of hex digits. In this exercise we're transforming integers to hexes with the desired amount of leading zeros.
Learning goals: Finding and using more than one
string
method
to achieve the desired string.Goal: A program that transforms an integer into a hexadecimal number with leading zeros
Introduction:
You can transform a number into a string representation of a hexadecimal number with the hex
function
:In [1]: hex(452)
Out[1]: '0x1c4'
The "0x" is a commonly used prefix to denote a hexadecimal number. It's especially important for numbers that don't happen to contain the the a-f digits.
Function Specification:
format_hex- Parameters:
- the integer to convert
- number of bits to represent
- Returns:
- string representation of the desired hex
The function must convert the number to a hexadecimal representation and then format it to contain the desired amount of hex digits. Because one hex digit is four bits, the desired length can be achieved with integer division. For the result of this function, we don't want the "0x" prefix. It would mess with the leading zeros anyway, so it needs to be removed.
So you have two things to do: remove the prefix and then add leading zeros. Both feats can be achieved with string methods - several of them in fact. The order of doing these is worth considering as well. If the number happens to be too big to be represented with the desired number of bits, just ignore the limitation. The bit count should only be used as a minimum this time. Remember to return the result!
You can test string methods and the execution order in the
Python console
which makes it a lot easier to see what each method returns. In the console you can retrieve the latest result with the _ character. For instance if you'd type this character to the console after the given example, it would give you "0x1c4".Using integer division is recommended, and best achieved with the //
operator
. Main Program:
Make a main program that prompts the user for an integer and the amount of bits to use in the representation. If either of the inputs is not an integer, the program gives an error message and doesn't resume. In other words just like the previous exercise, except the numbers are converted to integers instead of floats. After receiving two integers the main program
calls
the function you just implemented and prints its return value
. The examples below show you the strings for using in prompts and output. Use Examples:
Give an integer: 5 Give hexadecimal length (number of bits): 16 0005
Give an integer: 349798384653 Give hexadecimal length (number of bits): 64 00000051719bc40d
Give an integer: 255 Give hexadecimal length (number of bits): 8 ff
Give an integer: donkey Integer please
Give an integer: 252 Give hexadecimal length (number of bits): 2.5 Integer please
And finally a sample that shows what should happen when the number of bits is too small (i.e. nothing special):
Give an integer: 4892 Give hexadecimal length (number of bits): 4 131c
Give feedback on this content
Was this task useful for learning?
Comments about the task?
The Calcunator¶
In this exercise you get to program a traditional calculator. It's not the most exciting apparatus in existence but teaches a lot of useful things about processing inputs and program structure.
Learning goals: Using nested
control structures
in a way that all branches
work as intended. Checking user inputs with exception
handling.Goal: A calculator that prompts from an operation and its operands.
Main Program Specification:
The user selects an whether they want to do addition, subtraction, multiplication or division by
inputting
an operator
. If the user tries to input something else, the program throws them out after printing "Selected operation doesn't exist". After the operator is properly selected, the program prompts for two numbers and prints the operation's result. Unless, of course, the user inputs something else than numbers. In that case they're once again thrown out with the message "I don't think this is a number". Likewise if the user tries to divide with zero, the program gives them an error message "This program can't reach infinity". The program must calculate with floats
. In this task it is particularly important to keep in mind what was told about quitting programs at the beginning of the exercise material. Do not use the quit or exit functions!
Use Examples:
Choose operation (+, -, *, /): + Give 1st number: 12.8 Give 2nd number: no i wont I don't think this is a number
Choose operation (+, -, *, /): + Give 1st number: aasisvengaa I don't think this is a number
Choose operation (+, -, *, /): ^ Selected operation doesn't exist
Choose operation (+, -, *, /): * Give 1st number: 12 Give 2nd number: 5 Result: 60
Choose operation (+, -, *, /): / Give 1st number: 52.65 Give 2nd number: 0 This program can't reach infinity
Give feedback on this content
Was this task useful for learning?
Comments about the task?
Course Project Exercises¶
You only need to do one of these exercises. Each of them is related to one of the course project topics. Choose the one that is in line with your chosen topic. These tasks are not required for minimal course completion.
Mine Assignment: Living on the Edge¶
The purpose of this assignment is to give you your first vector of attack for the Minestomper course project. It teaches you some basic truths about how a 2 dimensional grid works in program code. In addition you learn some useful programming concepts, in particular how to use dictionaries to store messages. Having messages in dictionries is commonly used in programs, like in the checkers in this course.
Learning goals: Comparing numbers in
conditional structures
. You will also learn that the last index of an N length series is not N if the indexing starts from 0. Other topics include: drafting a solution on paper, and how to use data values inside the program while leaving long strings
for output purposes only.Goal: A program that prompts for field dimensions and tile coordinates, and gives information about the tile's position in the field.
Introduction:
We'll start by creating a
dictionary
that contains messages for each position category. You need to have this in your code with this exact name.MESSAGES = {
"outside": "The tile is outside the field.",
"corner": "The tile is in the corner of the field.",
"edge": "The tile is on the edge of the field.",
"middle": "The tile is in the middle of the field."
}
1st function specification:
position_in_field- Parameters:
- tile x coordinate (integer)
- tile y coordinate (integer)
- field width (integer)
- field height (integer)
- Returns:
- a keyword associated with the position (string)
This function returns one of the aforementioned dictionary's
keys
depending on where the tile denoted by x and y coordinates is on the field (defined by width and height given as parameters). The function must examine whether the tile is outside the field, in a corner, or on the edge. If it's none of these, it's in the middle. To retiterate, the function returns one of the dictionary's keys, e.g. if the tile is outside, the return statement should be return "outside".Note: The origin of the field coordinates is (0, 0). Look at the examples carefully to see how this affects the results. Also, bear in mind that each pair of coordinates is a tile. Draw a field on paper and write numbers along each edge - this way you can easily see how coordinates relate to positions in the field.
2nd function specification:
print_position- Parameters:
- a keyword that denotes the position (string)
This function prints the tile's position in human-readable form. In other words it says whether the tile is outside, in the corner, on the edge or in the middle. The printout must be retrieved from the dictionary using the function's
parameter
as a key
. This function should actually be just one line of code if you recall that variables
can be used as dictionary keys. Oh and please take the instruction about printing from the dictionary seriously - the checker will change the messages between tests.This function is not allowed to call the previous function!
Main Program:
Implement a program that prompts the user for field width and height, and after these, horizontal and vertical coordinates (i.e. x and y). However if the field size is too small it gives an error message (see examples below) and stops execution immediately (like in the calcunator earlier). After prompting for coordinates, the program prints a message indicating the chosen tile's location in the field. This is best achieved with the functions you just implemented: the first one returns the location keyword, and the second one prints the corresponding message.
All
strings
for prompts and prints can be found in the examples below.Use Examples:
Input field width: 0 Input field height: 0 You can't fit a single tile on a field that small!
Input field width: -6 Input field height: 999 You can't fit a single tile on a field that small!
Input field width: 1 Input field height: 1 Input x coordinate: 0 Input y coordinate: 0 The tile is in the corner of the field.
Input field width: 5 Input field height: 8 Input x coordinate: 4 Input y coordinate: 3 The tile is on the edge of the field.
Input field width: 13 Input field height: 7 Input x coordinate: 2 Input y coordinate: 2 The tile is in the middle of the field.
Input field width: 4 Input field height: 4 Input x coordinate: 4 Input y coordinate: 4 The tile is outside the field.
Give feedback on this content
Was this task useful for learning?
Comments about the task?
Spectral Assignment: Angular Code¶
The solution to this exercise might come in handy in the Spectral Matters course project. You are tasked with writing a program that calculates and prints the equation of a line, with all edge cases covered.
Learning goals: Comparing numbers in
conditional structures
. Controlling program flow to make correct statements about the results. Calculating the equation of a line.Goal: Program that calculates the equation of a line and prints it.
Function specification:
calculate_parameters- Parameters:
- x coordinate of the first point (float)
- y coordinate of the first point (float)
- x coordinate of the second point (float)
- y coordinate of the second point (float)
- Returns:
- line's slope (float)
- line's y intercept (float)
Use the following equations for the slope and the y intercept:
m = \dfrac{y_2-y_1}{x_2-x_1}
and
b = \dfrac{x_2 \cdot y_1 - x_1 \cdot y_2}{x_2 - x_1}
Main Program
Specification:We want the program to take two points as
inputs
from the user, and let them know the equation for the line that goes through those points if it's possible to calculate one. In addition the program should recognize two special cases: the user inputting the same point twice, and the user inputting a vertical line. To keep this at least a bit simple, user inputs are not checked this time. The program does have to handle floats
though, and also print them neatly rounded to three decimal precision. The best way to go about implementing the program is to use nested try and if structures. The easiest way to know whether it's possible to calculate the equation is to call the function inside a try
branch
. It gives some exception
if it can't do its calculations. There is also a small catch regarding negative intercept: you must print the minus sign as an operator in the equation - you can't blindly throw the intercept into a format! It should also be completely left out if it's zero.As usual, you can see the
strings
from the examples below.Use Examples:
Input x coordinate of the first point: 0 Input y coordinate of the first point: 0 Input x coordinate of the second point: 0 Input y coordinate of the second point: 0 Sorry to break it to you but these points are the same.
Input x coordinate of the first point: -1 Input y coordinate of the first point: 100 Input x coordinate of the second point: -1 Input y coordinate of the second point: -100 The line is vertical, it doesn't have an equation.
Input x coordinate of the first point: 2 Input y coordinate of the first point: 3.1 Input x coordinate of the second point: 6.7 Input y coordinate of the second point: 8.51 Line equation: y = 1.151x + 0.798
Input x coordinate of the first point: -8 Input y coordinate of the first point: 4.5 Input x coordinate of the second point: -5 Input y coordinate of the second point: 4.5 Line equation: y = 0.000x + 4.500
Input x coordinate of the first point: 3.141457 Input y coordinate of the first point: -6.12433 Input x coordinate of the second point: 0 Input y coordinate of the second point: 50 Line equation: y = -17.866x + 50.000
Input x coordinate of the first point: 5.76 Input y coordinate of the first point: 4.6 Input x coordinate of the second point: 2 Input y coordinate of the second point: -5 Line equation: y = 2.553x - 10.106
Input x coordinate of the first point: 2 Input y coordinate of the first point: 2 Input x coordinate of the second point: 4 Input y coordinate of the second point: 4 Line equation: y = 1.000x
Give feedback on this content
Was this task useful for learning?
Comments about the task?
Cutting Assignment: A Box Between Two Worlds¶
As there is not universal agreement in how to represent certain things, you can sometimes run into a situation where different tools have different presentations for the same thing. In this task we're looking at a single box from two different perspectives. This problem relates particularly to the image cutting project work as one of the tools we use there uses a coordinate system where the origin as at the bottom left corner while another has the origin at the top left. That, and they also have a different way to represent a rectangle.
Learning goals: Reading and updating contents of a dictionary. Coordinate system reversion.
Goal: A program where the user can move existing boxes and see where they end up in a reversed coordinate system.
In order to test the functions you can define a couple of boxes in your program.
box_1 = {
"x": 0,
"y": 0,
"width": 50,
"height": 20,
}
box_2 = {
"x": 10,
"y": 20,
"width": 40,
"height": 30,
}
1st function specification:
move_box- Parameters:
- dictionary that describes a box
This function informs the user about the current location of the box (in coordinate system A terms), and prompts for changes to its position (x and y coordinates). It will then update the dictionary by the changed amount. This function should not return anything as it updates an existing dictionary.
2nd function specification:
convert_representation- Parameters:
- dictionary that describes a box
- the height of the area that contains the box (integer)
- Returns:
- x coordinate of the box's left edge
- x coordinate of the box's right edge
- y coordinate of the box's top edge
- y coordinate of the box's bottom edge
The diagram below shows the same box in two different coordinate systems, with two different representations. The origin of coordinate system A is in the bottom left corner and y axis values grow upward. This coordinate system is often used in mathematics, based on the notion that number growing means up. The box is represented in the same way as in the dictionaries by specifying its bottom left coordinates, its width, and its height.
The origin in coordinate system B is in the top left corner, and y axis values grow downward. This coordinate system is commonly used by computer programs, and is based on the order in which humans would read text from the screen. In addition to different origin, the box is now defined by the x coordinates of its left and right edges, and the y coordinates of its top and bottom edges. Both images also include a maximum value for y, 160. This number acts as a reference value that is needed in order to have the box be in the same place visually.
The purpose of this function is to take a box represented in coordinate system A, and return the values in coordinate system B that would place the box in the same spot between the y axis and the maximum y value.
Main Program:
Make a main program that calls both functions for each box. For each box the program should print the coordinate system B coordinates returned by the second function.
Example:
Input maximum value of y: 600
50x20 box is at coordinates (0, 0)
Change x by: 30
Change y by: 70
Box edges in reversed coordinates
(30, 80, 510, 530)
40x30 box is at coordinates (10, 20)
Change x by: 110
Change y by: -10
Box edges in reversed coordinates
(120, 160, 560, 590)
Duck Assignment: Motion Control¶
In the last exercises we made a function that converts polar coordinates to cartesian coordinates. We also said that this is done frequently with objects that move on the screen. This time we're getting a bit closer to practice. This exercise is about updating the position of a moving object on an (x, y) plane, based on its heading and velocity. A convenient way to describe an object with multiple properties is to use a dictionary. While this exercise doesn't particularly qualify as a game yet, it makes you implement a mechanism that is repeated frequently enough.
Learning goals: Reading and updating the contents of a
dictionary
. Using functions
with mutable
objects.Goal: Bunch of functions that prompt the user for heading and velocity and update the position of an object based on them.
Introduction:
Fetch your solution for A Sinful Function from the previous set of exercises, and copy the
convert_to_xy function from it. You should not change this function! You should also create a couple of dictionaries in your main program
so that you can test your functions. These contain the key
-value
pairs required by the functions.char_1 = {
"x": 0,
"y": 0,
"heading": 0,
"speed": 0
}
char_2 = {
"x": 50,
"y": 50,
"heading": 0,
"speed": 0
}
1st function specification:
prompt_move- Parameters:
- dictionary with the above key-value pairs
This function prints a character's position and then prompts the user to
input
heading as degrees and speed (as arbitrary units). The strings
to be used in printing and prompting can be found from the use examples at the end. Both inputs are taken as floats and assigned as values for the corresponding keys in the dictionary. Please note that the function returns nothing. It doesn't need to because it modifies a mutable
object. Also, remember to use the function's parameter when accessing the dictionary.2nd function specification:
update_position- Parameters:
- dictionary with the above key-value pairs
This function calculates a new position for a character based on the heading and speed found from a dictionary. These two values can actually be interpreted as polar coordinates. Gee, was there a function to convert this into how much the cartesian coordinates change...? It may have been that such a function takes the angle as radians, and the dictionary has it as degrees. Rumor has it that the math module can help with that.
Please note that when the function is tested, the character's starting point won't always be (0, 0). Your function needs to, well, function, even when the character starts from another point. Because we calculated the change of coordinates from the heading and speed, the change of each coordinate needs to be added to the position values in the character dictionary (i.e. you need to replace them with updated values).This function also modifies a mutable object, so it should not return anything.
Main Program
Make a main program that prompts moves from two players, both of whom have their own character on the playing field. It prints whose turn it is, and then calls both functions to process that player's character dictionary. Finally it prints the new position of the character, as shown in the examples. The process is repeated for the second player. By doing this you can make sure that your functions work properly when given different dictionaries.
Use Examples:
Player 1's turn Character is currently at (0, 0) Give heading as degrees: 180 Give speed: 10 New position: (-10, 0) Player 2's turn Character is currently at (50, 50) Give heading as degrees: 45 Give speed: 5 New position: (54, 54)
Player 1's turn Character is currently at (0, 0) Give heading as degrees: 30 Give speed: -4 New position: (-3, -2) Player 2's turn Character is currently at (50, 50) Give heading as degrees: 210 Give speed: 4 New position: (47, 48)
Give feedback on this content
Was this task useful for learning?
Comments about the task?
Give feedback on this content
Comments about these exercises