This site uses cookies. Only cookies that are necessary for the site to
work or to remember your settings (like language) are used. This site does
not use any tracking cookies.
Learn more about our terms and conditions.
These exercises are starting to approach the territory of so-called real programs. In particular the new things we learned in the material removes the previous limitation of having to use fixed number for data handled by the program, and for how many times instructions are done in the code. Repetition opens up a whole world of possibilities, but also requires new patterns of thought. The course project exercises in this page are particularly challenging but at the same time they do provide rather concrete building blocks for the project.
Using loops and lists in problem solving. Solving even larger problems than before as we're released from the restrictions we had last time. Central concepts this time around are lists and loops. For the latter, both for and while loops will have their uses, and our hope is that these exercises will demonstrate the purpose of each. When it comes to lists, one important aspect is to learn how to design useful data structures.
At the end of the second material we had an idea about a program that converts measurements from US customary the-radius-of-dumbledores-robe-hem-after-extinguishing-a-fire type of units to sane SI system units. We just didn't have the capability to handle measurements en masse because we didn't know anything about lists. Well, now we know! Let's make a program where the user can input multiple measurements results, unit and everything, and the program converts them to the corresponding SI units. Because the program has been designed for processing measurement data, navigating in menus should be minimized - therefore all units should be converted automatically regardless of what quantity they are. We are going to ditch temperature though because it doesn't fit the same factor-unit pattern with the rest.
We have no idea how to handle files yet so the program itself is going to be just a temporary solution. Although, technically, we could use
terminal
input/output control to take measurements from a file and even save the results into a file...
At the end of the second material we had something along these lines and it worked for length:
The first problem to solve is: how to determine both the conversion factor and the target unit from the source unit? This could be done with a colossal
conditional structure
but ain't no one got the patience to maintain that. In the original example we took the factors from a
dictionary
. Nothing prevents us from using
data structures
as dictionary values - instead of just a factor we can therefore put a
tuple
that includes both conversion factor and target unit. At the same time we can add all units to the same dictionary.
We can get the conversion factor from this structure by casting the following spell: UNITS[unit][0], and the target unit with: UNITS[unit][1]. In other words we first find the tuple that corresponds with a
key
, and then from within the tuple the value we wanted with
index subscription
. Using this information, the above function can be changed into convert_to_si as follows:
defconvert_to_si(measurement):value=measurement["value"]unit=measurement["unit"]try:# first item in the tuple is the factorsi_value=value*UNITS[unit][0]exceptKeyError:measurement["invalid"]=Trueelse:# second item in the tuple is the new unitmeasurement["unit"]=UNITS[unit][1]measurement["value"]=si_value
This function still modifies an existing dictionary and therefore doesn't need to return anything. Next we need to actually get measurements from somewhere. Because we want to make a program that can eventually process actual data files, we'll make a function that creates a list of measurements by prompting them from the user. We could also do the conversion immediately after
input
but because manual input is not the ultimate goal of the program, calling the conversion function should not be placed into the input function. The input function is just a data source. Input is processed with split like we learned in the material.
defread_measurements():print("Input measured values and units separated with spaces. Leave empty to quit.")measurements=[]whileTrue:value_unit=input("Input measurement: ").strip()ifnotvalue_unit:returnmeasurementstry:value,unit=value_unit.split(" ")value=float(value)exceptValueError:print("Enter measurements in the specified format")else:measurements.append({"unit":unit,"value":value})
This function implements something that was skipped in the material: how to handle quitting the program when the input is splitted. This usually requires handling the input in two phases - first the entire input is taken into a variable which can show whether it's empty, and only after that we try to convert into a usable form. Conveniently both lines in the try
branch
produce ValueError if they go wrong, so we can get away with just one except statement. Valid measurements are appended to the measurements
list
as dictionaries that have the same structure as the previous example. These functions can be combined in the main function:
One interesting aspect with this solution is that the list that actually contains the measurements is never modified - only the dictionaries within it are changed. This shows quite nicely how
mutable
types work. We still need some way to show the results. Because this program is intended for bigger plans, printing should also be done in its own function.
Because the function itself doesn't do anything special, we've thrown in a trick that we didn't show in the material. It's possible to unpack the dictionary to act as format method
keyword arguments
. In other words the dictionary keys will become keywords, and they can be used as
placholders
in the format template. **measurement could be replaced with value=measurement["value"],units=measurement["unit"]. Of course if you use this trick you have to make sure the dictionary actually contains the keys to match the placholders.
As a final touch we add a call to this print function to the main function, and then we call the main function itself from the actual main program with a familiar structure:
UNITS={"in":(2.54,"cm"),"\"":(2.54,"cm"),"ft":(30.48,"cm"),"'":(30.48,"cm"),"yd":(0.9144,"m"),"mi":(1.609344,"km"),"oz":(28.349523125,"g"),"lb":(0.45359237,"kg"),"cp":(2.365882365,"dl"),"pt":(4.73176473,"dl"),"qt":(0.946352946,"l"),"gal":(3.785411784,"l")}defconvert_to_si(measurement):value=measurement["value"]unit=measurement["unit"]try:# first item in the tuple is the factorsi_value=value*UNITS[unit][0]exceptKeyError:measurement["invalid"]=Trueelse:# second item in the tuple is the new unitmeasurement["unit"]=UNITS[unit][1]measurement["value"]=si_valuedefread_measurements():print("Input measured values and units separated with spaces. Leave empty to quit.")measurements=[]whileTrue:value_unit=input("Input measurement: ").strip()ifnotvalue_unit:returnmeasurementstry:value,unit=value_unit.split(" ")value=float(value)exceptValueError:print("Enter measurements in the specified format")else:measurements.append({"unit":unit,"value":value})defprint_measurements(measurements):formeasurementinmeasurements:ifmeasurement.get("invalid"):print("Invalid measurement {value:.3f}{unit}".format(**measurement))else:print("{value:.3f}{unit}".format(**measurement))defmain():measurements=read_measurements()formeasurementinmeasurements:convert_to_si(measurement)print_measurements(measurements)try:main()exceptKeyboardInterrupt:print("Measurement processing interrupted")
As a bonus trick we'll show how you could enter a batch of measurements to the program, at least on the Linux command line. Let's say we have the following file of measurements. The empty line at the end is very important!
measurements.txt
23 in12.4 oz54 mi2.45 yd5.31 gal
This could be fed to our program like this:
/some/folder$ python3 converter.py < measurements.txt
Input measured values and units separated with spaces. Leave empty to quit.
Input measurement: Input measurement: Input measurement: Input measurement: Input measurement: Input measurement: 58.420 cm
351.534 g
86.905 km
2.240 m
20.101 l
The only eyesore here is how the input prompt is printed for each line in the file. But not to worry, in the next material we learn to read files properly with Python.
Loops allow programmers to unleash their artistic talents (or lack of). Loops can be used in combination with some simple arithmetics to draw shapes and lines that change based on a pattern. In this example we're drawing some pleasantly patterned spirals.
Learning goals: How to do a predetermined number of iterations with a
loop
. We also recall how to define
optional arguments
for functions.
Goal: Make a program that draws patterned spirals that have adjustable parameters: color, radius, radius growth and pen weight.
Function Specification:draw_spiral
Parameters
:
spiral's color (color string or three value tuple)
number of arcs (quarter circle) to draw (integer)
spiral's starting radius (integer)
radius growth (float)
pen weight (integer) -
default value
1
First thing to do in the function is to set the color and pen weight. Rest of the drawing commands are done inside a loop with a number of iterations equal to number of arcs. Each iteration draws a 90 degree arc after which the radius is incremented by radius growth. Note that the
loop variable
is not necessarily used for anything.
Main Program:
The main program should consist of the following lines:
These should draw the piece of art shown in the example.
List of Turtle Commands:
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 fillend_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) insidereset()# 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 drawingdown()# puts the pen back down setx(x)# sets the pen's x coordinate to the given valuesety(y)# sets the pen's y coordinate to the given valuecircle(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 leftpensize(w)# sets the pen's weight to w
In addition we're now going to use the first optional argument of the circle function:
circle(r,a)# draws an arc with radius r and sector angle a
A whole lot of unnecessary work goes into creating and maintaining prompt loops for all inputs in a program just to check whether the user's actually given numbers. Let's automate this process a bit by creating one function that can be used whenever an integer needs to be prompted in a program, and we need to check that the input really was an integer. The function we create in this exercise is a very handy tool, and we will use it in the other exercises as a base. We even recommend using it in the course project.
Learning goals: Making a
loop
that is repeated until the user gives a valid
input
. Writing a reusable function.
Goal: A function that prompts the user for an integer until it gets one. The function has customizable prompt and error messages that can be given as
arguments
.
Function Specification:prompt_input
Docstring
:
"""Prompts the user for an integer using the prompt parameter.If an invalid input is given, an error message is shown usingthe error message parameter. A valid input is returned as aninteger."""
Parameters
:
the input prompt message to display (string)
error message to display for invalid input (string)
Returns
:
The user's input as an integer (integer)
The function must present an input prompt with the given message until the user gives a valid integer. Whenever the user gives an invalid input, the error messages receives as the second parameter is printed, and the prompt is repeated. When the user's input is valid, it is returned as an integer. There's a particular example in the material you may find helpful.
Main Program:
In the main program we want to call the function twice with different arguments in order to show neatly it handles prompts using different messages. We've saved you the trouble of coming up with one by providing this code:
number=prompt_input("Give an integer: ","You did not give an integer")print(f"You gave the {number} integer! Good job!")moogles=prompt_input("How many moogles are in the Moogle Village? ","This is not a valid number of moogles!")print(f"There are {moogles} moogles in the village.")
Use Examples:
When the above main program is executed, you should get the something like this if your function woks correctly:
Give an integer: donkey
You did not give an integer
Give an integer: sixtynine kappa
You did not give an integer
Give an integer: 5
You gave the 5 integer! Good job!
How many moogles are in the Moogle Village? 7.5
This is not a valid number of moogles!
How many moogles are in the Moogle Village? 1
There are 1 moogles in the village
This is an exercise about prime numbers. That said. the more important part of this exercise is to use functions as tools and to reuse existing code. Both functions that will form the solution to this exercise could easily be taken out and used in another program without modifications. This is possible because well-designed tool functions don't do anything extra - they only do exactly what they promise, and return a value that can be used in further processing.
Learning goals: Using
loop variable
with the range function and ending a
loop
with return. Reusing and modifying an existing
function
.
Goal: A program that prompts the user for an integer and tells whether it's a prime.
Introduction:
You need the prompt_input function from the previous exercise. Copy it to your code file. You also need to slightly modify it.
Function Modification:prompt_input
Docstring
:
"""Prompts the user for an integer using the prompt parameter.If an invalid input is given, an error message is shown usingthe error message parameter. A valid input is returned as aninteger. Only accepts integers that are bigger than 1."""
Parameters
:
the input prompt message to display (string)
error message to display for invalid input (string)
Returns
:
the user' input as integer (integer)
In addition to what it did previously, the function must also repeat the prompt if the given integer is smaller than or equal to 1. The same error message is used in all error scenarios.
Function Specification:check_prime
Docstring:
Checkswhetheranintegerisaprimenumber.ReturnsFalseifthenumberisn't a prime; if it is a prime, returns True
Parameters:
number to check (integer)
Returns:
whether the number is a prime (
boolean
)
The function has to use some suitable method to determine whether the given number is a prime. You can investigate suitable methods with Google or Wikipedia!. You may find out that modulus (%) is a useful operator for this task. You may also find it useful to know that range accepts more than one
argument
. You can try stuff out in the
Python console
!
As the above specification should show, this function returns a value that indicates whether the number was a prime - it does not print the information!
Main Program:
The main program prompts the user for a number using the modified promp function. Then it uses the check function to determine whether the number was prime, and prints a statement based on the
return value
.
Use Examples:
Give an integer that's bigger than 1: 1
You had one job
Give an integer that's bigger than 1: four
You had one job
Give an integer that's bigger than 1: 9
This is not a prime
Give an integer that's bigger than 1: 7
This is a prime
Grids are usually represented as two-dimensional lists, i.e. as a list that contains other lists where each inner list corresponds to a row in the grid, and each item in the inner lists is one the content of one square or tile. In this exercise we'll take our first proper look at such lists, and particularly at what kinds of loops are required for iterating through them. We'll take a short break from sweeping mines, and instead head into the countryside to examine what kinds of animals can be found from the nearby fields... Even so, the princples here very much apply in the Minestomper course project.
Learning goals: Using nested
for loops
to iterate through 2-dimensional lists.
Goal: A program that examines all tiles in a field and tells what animals were there.
Introduction:
We're going to use a dictionary once again. The reason is that in the field lists, animals are marked with single characters, but we want to print their actual names in the output. The following dictionary connects the identifiers to the animals:
"""Explore a tile - if there is an animal, prints thelocation and name of the animal"""
Parameters
:
the character in the tile (
string
)
row number
column number
Information about the animal is printed if its identifier character is found from the dictionary. If it's not there, nothing is printed. The print is in the form "Tile (5, 6) contains donkey" where 5 is the x coordinate and 6 is the y coordinate. It's almost like we've seen this before... Note that y matches the row number, and x matches column number.
The checker reserves the rights to modify the given dictionary, which must be taken into account in your implementation.
2nd Function Specification:explore_field
Docstring:
"""This function explores an entire field by calling the explore_tilefunction for each tile in the field."""
Parameters:
2-dimensional list that represents a field
The function must go through all tiles is in the field. This is best done with for loops. Because we need each tile's coordinates for the explore_tile function, we need both the contents of rows and tiles along with their
indices
. Keep in mind that the outer index is used to select the rows, and therefore corresponds to the y coordinate.
Main Program:
Define an example field, and call the explore_field function. We've given you a field. We trust your ability to write a
Note that if you have gotten the coordinates mixed in both functions, you will get the correct print but your functions individually don't work correctly.
In this exercise you'll get to work on the process of creating a new list based on an existing one. This technique is typically needed e.g. when some formula needs to be applied to all values in a list. This might also be useful for the Spectral Matters course project.
Learning goals: Creating a new
list
by using
items
of an existing list.
Goal: A program that calculates intermediate points of a line between two endpoints.
Introduction:
The calculate_parameters function that was created in last time's exercises is needed again. Go grab it from your answer.
1st Function Specification:prompt_two_numbers
Docstring
:
"""Prompts two floats from the user, separated by a space. The promptis repeated until the user gives a valid input. Both numbers arereturned as floats."""
Parameters
:
prompt string (
string
)
Returns
:
x coordinate of the point (
float
)
y coordinate of the point (float)
Prompts the user to
input
two floats separated by a space, using the given prompt string. The prompt is repeated until the user gives a valid input. If there is an error, the function prints "Give two numbers separated by a space". When the input is valid, both numbers are returned as floats.
2nd Function Specification:determine_points
Docstring:
"""Produces a list of values that are the y values of a line withthe given slope and y intercept, from a list of x values."""
Parameters:
line slope (float)
line y intercept (float)
list of x values (list of floats)
Returns:
list of y values (list of floats)
The function must create a new list with the calculated y coordinate values.
Main Program:
The program prompts the user for two points aby using the brand new prompt_two_numbers function. You can see the
argument
string in the examples below. After prompting, the program prints a list of y coordinates that are calculated from a list of x coordinates and the line parameters.
The following list of x coordinates is used in testing the main program:
The checker will naturally test your functions with other lists as well. In order to get a print that matches the examples, you can use the loop shown below. It uses the end keyword argument of print to swap the newline at the end of each print to a single space. We can't use the join method here because the lists don't contain strings.
foryinline:print(f"{y:.4f}",end=" ")
Use Examples:
Input first point: donkey
Give two numbers separated by a space
Input first point: 0 0
Input second point: 1 1
Line y values are:
0.0000 0.2500 0.5000 0.7500 1.0000 1.2500 1.5000 1.7500 2.0000 2.2500 2.5000 2.7500 3.0000 3.2500 3.5000 3.7500 4.0000 4.2500 4.5000 4.7500 5.0000
Input first point: 0.0 1.0
Input second point: 0
Give two numbers separated by a space
Input second point: 1.0 0.0
Line y values are:
1.0000 0.7500 0.5000 0.2500 0.0000 -0.2500 -0.5000 -0.7500 -1.0000 -1.2500 -1.5000 -1.7500 -2.0000 -2.2500 -2.5000 -2.7500 -3.0000 -3.2500 -3.5000 -3.7500 -4.0000
Input first point: 0 0
Input second point: 2 1
Line y values are:
0.0000 0.1250 0.2500 0.3750 0.5000 0.6250 0.7500 0.8750 1.0000 1.1250 1.2500 1.3750 1.5000 1.6250 1.7500 1.8750 2.0000 2.1250 2.2500 2.3750 2.5000
Input first point: -5 5
Input second point: 0 0
Line y values are:
0.0000 -0.2500 -0.5000 -0.7500 -1.0000 -1.2500 -1.5000 -1.7500 -2.0000 -2.2500 -2.5000 -2.7500 -3.0000 -3.2500 -3.5000 -3.7500 -4.0000 -4.2500 -4.5000 -4.7500 -5.0000
Patterned placement of rectangles is a problem that can be encounterd in all kinds of places. Typically what's wanted is placement of rectangles that have a fixed interval between them, and that are within some margin from the borders of the area they are in. In this exercise we're practicing this by using this approach to filter characters from a table to find a secret code.
Learning goals: Calculating tile coordinates when their intervals and distance from borders is known. Reading values from a two-dimensional
list
.
Goal: Program that prompts for pattern parameters and prints out the secret code found with that pattern.
Introduction:
The main program will prompt for numbers. For this purpose you should bring in the function from A Prime Exercise. However, in this task 0 is a valid input, so change the function accordingly before using it.
1st Function Specification:get_coordinates
Docstring
:
"""Calculates coordinates for a grid figure where the size of each tile is 1.Returns a list of coordinates so that the first tile is in the given initialcoordinates, and the other ones are always a certain distance away from the previous one."""
Parameters
:
number of tiles horizontally
number of tiles vertically
x coordinate of the first tile
y coordinate of the first tile
tile interval horizontally
tile interval vertically
Returns
:
List of coordinates the tiles fall on, each represented by (x, y) tuple
Make a function that produces a list of coordinate pairs based on its parameters. Since we are placing a grid type pattern, the number of coordinate pairs sould be equal to the product of the first two arguments. E.g. if we want 3 tiles horizontally and 2 vertically, there will be a total of 6 pairs. When calculating the coordinates it's good to keep in mind that while we are calculating points, the tiles themselves have a size of 1 unit, and this affects the placement. If either interval is zero, the corresponding coordinates should not be the same but rather next to each other.
2nd Function Specification:find_characters
Docstring
:
"""Retrieves characters that fall under the list of given coordinates from the given grid. Coordinates are read from top to bottom and left to right. Retrieved characters are returned as a list.If at least one coordinate pair falls outside the grid, returns an empty list instead."""
Parameters:
list that contains strings, representing a character grid
list of coordinates to pick characters from
This function does two things. First it checks whether all of the coordinate pairs fit inside the field. If they do not, it prints an error message, and returns an empty list. Otherwise it should sort the list (default order) and then pick out the characters that are in the given coordinates. These are collected into a list and returned as the result. The first step can also be easier to implement if the coordinate list is sorted at the beginning.
Main Program:
The main program prompts the user for parameters for a grid pattern, and then fetches the secret code found by using those parameters. The search is done against a predefined 20x20 character grid. You can use the code below to define the grid, and display it to the user.
Code grid:
l H u V Z m m I X a Q J w M J k S L l w
K v C r l s h q W o M a s M v c z A h h
k n P A J t J p Q p k B t A B b k O h r
d J G O l e b s c g W I z m v D b j c U
z r M W d U a V O U e U L V O M i Z I o
A I h m c M T q t M V I H u g F P v f i
h m G L o L Y L p p y l u J l H n S Z i
K N a S V I a J z G B y Y V p d g Q F T
D B r j n r R S k n s E H i m O g A n F
W n F T X G F m o A F f J q l F P B a p
o c U H k m A l M a w Y k m y w s F P K
e k a R s o Q P q H w k F k a k t f W J
n B z k c f w R S f K u J Q y Y K w f l
H k R c e M H Y J D b v n h W R n P C n
E g r Q b I v d E I a q N m c g z P N b
l d d D L P i A s K r Y A P N N e w y T
l U s Z y j U M y w w c y g D j u j i D
O r f n D A o D D H U j K e D H R u Y M
T H x l x W c A T q B m B z u r j V F i
H s h F g a c c i A X N W K X T r B M n
Number of tiles horizontally: three
Please give a positive integer
Number of tiles horizontally: -3
Please give a positive integer
Number of tiles horizontally: 3
Number of tiles vertically: 4
X coordinate of the first tile: 4
Y coordinate of the first tile: 4
Space between tiles (horizontally): 5
Space between tiles (vertically): 1
The secret code is:
donkeyswings
Shocked Pikachu face.
Code grid:
l H u V Z m m I X a Q J w M J k S L l w
K v C r l s h q W o M a s M v c z A h h
k n P A J t J p Q p k B t A B b k O h r
d J G O l e b s c g W I z m v D b j c U
z r M W d U a V O U e U L V O M i Z I o
A I h m c M T q t M V I H u g F P v f i
h m G L o L Y L p p y l u J l H n S Z i
K N a S V I a J z G B y Y V p d g Q F T
D B r j n r R S k n s E H i m O g A n F
W n F T X G F m o A F f J q l F P B a p
o c U H k m A l M a w Y k m y w s F P K
e k a R s o Q P q H w k F k a k t f W J
n B z k c f w R S f K u J Q y Y K w f l
H k R c e M H Y J D b v n h W R n P C n
E g r Q b I v d E I a q N m c g z P N b
l d d D L P i A s K r Y A P N N e w y T
l U s Z y j U M y w w c y g D j u j i D
O r f n D A o D D H U j K e D H R u Y M
T H x l x W c A T q B m B z u r j V F i
H s h F g a c c i A X N W K X T r B M n
Number of tiles horizontally: 10
Number of tiles vertically: 4
X coordinate of the first tile: 5
Y coordinate of the first tile: 5
Space between tiles (horizontally): 3
Space between tiles (vertically): 2
The coordinates go outside the grid
Being part of the inner circle is cool. From a definition point of view it can be regarded as being inside a certain perimeter. This is something we can do with a program as well! It should also be helpful when slinging birds into the sky.
Learning goals: Calculating the distance between two points. Positioning a point from outside a circle to the perimeter of the circle without changing the angle in regards to the cenral point.
Goal: A program that finds the correct position for a point inside a circle or on its perimeter.
Introduction:
The Sinful Function task from the very first exercise has a function that can be useful in this exercise. Depending on what kind of solution you go for.
1st Function Specification:calculate_distance
Docstring
:
"""Calculates the distance between two points and returns it."""
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
:
Distane between the points (float)
Figuring out the formula to calculate the distance is part of the assignment.
2nd Function Specification:clamp_inside_circle
Parameters:
X coordinate of a point (float)
Y coordinate of a point (float)
X coordinate of a circle's center (float)
Y coordinate of a circle's center (float)
Radius of the circle (float)
Returns:
Clamped x coordinate for the point (float)
Clamped y coordinate for the point (float)
First the function needs to find out whether the given point is already inside the circle. If it is, its coordinates are simple returned as they are. However, if the point is outside the circle, it needs to be "pulled" to the circle's perimeter. In doing so, the angle from the circle's center must be maintained while the distance is set exactly to the circle's radius.
Main Program:
The following circle will be used in testing:
center_x=10center_y=20radius=100
Write a main program that prompts the user for a point with two inputs that accept floats. The program will then fit the point inside the above circle and print the final coordinates. You can find examples below.
Examples:
The point will be clamped within 100 radius from the point (10, 20)
Input x coordinate: -140
Input y coordinate: -40
Coordinates within the circle: (-82.85, -17.14)
The point will be clamped within 100 radius from the point (10, 20)
Input x coordinate: 50.0
Input y coordinate: 80.0
Coordinates within the circle: (50.00, 80.00)
The point will be clamped within 100 radius from the point (10, 20)
Input x coordinate: 30
Input y coordinate: -30
Coordinates within the circle: (30.00, -30.00)
The point will be clamped within 100 radius from the point (10, 20)
Input x coordinate: 40.0
Input y coordinate: -110.0
Coordinates within the circle: (32.49, -77.44)
The point will be clamped within 100 radius from the point (10, 20)
Input x coordinate: -50
Input y coordinate: 40
Coordinates within the circle: (-50.00, 40.00)
You can also see these examples visualized in the image below.
The followers of the path of the Minestomper will find mastering the secrets of this exercise useful. Your task is to assist a brave hero in counting the amount of ninjas surrounding them. In order to attain the rank of apprentice in the Minestomper skill tree, you'll get to implement this function that could also be used for counting mines...
Learning goals: Handling surrounding cells in a 2-dimensional
list
and counting certain characters from them.
Goal: A program that counts the number of ninjas surrounding a tile.
Function Specification:count_ ninjas
Doctstring
:
"""Counts the ninjas surrounding one tile in the given room andreturns the result. The function assumes the selected tile doesnot have a ninja in it - if it does, it counts that one as well."""
Parameters
:
x coordinate of the selected tile (integer)
y coordinate of the selected tile (integer)
a data structure representing a room (list that contains lists that contain single character strings)
Returns
:
number of ninjas (integer)
There are at most 8 surrounding tiles - diagonals are counted. You always need to make sure you're not trying to count ninjas from out of bounds (nor should you count ones from opposite walls if the index goes negative). Those desiring to become master minestompers should implement the counting with
loops
.
The function must work with rooms of any size. This means that you have to measure the boundaries inside the function from the list structure that represents a room (using the len function).
The program needs to print the room, prompt the user for coordinates, and then output the number of ninjas surrounding those coordinates. You can use the following code snippet to print the room.
- - - - -
| N |
| N N N N |
| N N |
| N N N |
| |
| |
- - - - -
Input x coordinate: 1
Input y coordinate: 2
The tile is surrounded by 8 ninjas
}}}
{{{
- - - - -
| N |
| N N N N |
| N N |
| N N N |
| |
| |
- - - - -
Input x coordinate: 4
Input y coordinate: 0
The tile is surrounded by 1 ninjas
This exercise should be helpful in dealing with Spectral Matters. This is a relatively common problem where we have two lists with data - one contains measurement points, and the other the corresponding measured values - and we want to select a matching slice from both of them. In order to succeed, a reverse index lookup is needed - you need to figure out the indices of measurement points.
Learning goals: Finding
indices
from
lists
with boundary values that are not among the list's
items
.
Goal: A program that finds the desired slice from a list of measurement points, and the corresponding slice from the measured values list.
Introduction:
The prompt_two_numbers function from the previous exercise can be used in this one as well. This time we're not prompting for a coordinate pair, but rather two points from the same axis. But hey, it doesn't matter because we can just change the prompt thanks to making the function flexible enough. No need to modify this function.
Function Specification:find_indices
Docstring:
"""Finds two endpoints from a list of numerical data so that the resultingthe values between the selected indices are between the given minimum and maximum boundaries. Returns the two indices."""
Parameters
:
measurement point series (list of floats)
selected minimum boundary (float)
selected maximum boundary (float)
Returns:
starting index for the selection (integer)
end index for the selection (integer)
The function must find the index for the first
item
that's bigger than (or equal to) the minimum boundary - this is the start index. It also needs to find the first item that's bigger than the maximum - the index of this item is the end index. In accordance with how
slicing
works in Python, the end index is the first index that will not be included. If the maximum is bigger than the last item in the list, use the list's length for the end index. If both are bigger, return the list's length for both.
Main Program:
The main program needs two lists: first list contains the measurement points, and second list contains measured values. The lists are shown below.
You should use the prompt_two_numbers function to get the minimum and maximum boundaries from the user, and then print the corresponding slice of measurement values.
Use Examples:
Give two measurement points separated by space: harry
Give two numbers separated by a space
Give two measurement points separated by space: 11
Give two numbers separated by a space
Give two measurement points separated by space: 11 13
Measured values in the selected range:
[85.115, 81.337, 65.852, 127.676, 10.409, 131.279, 32.595, 89.49, 40.263, 32.712, 114.974, 7.967, 131.166, 124.827, 172.936, 145.234, 156.433]
Give two measurement points separated by space: 10.606 11.936
Measured values in the selected range:
[162.399, 25.643, 181.571, 151.84, 147.307, 85.115, 81.337, 65.852, 127.676, 10.409, 131.279]
This is a combination task that continues from where the two previous cutting tasks left off. There will be a healthy chunk of code but a lot of it can be taken from previous tasks. The main course of this task is to create rectangles from a set of parameters, something that will be quite crucial in the project itself...
Learning goals: Combining functions into a larger whole. Creating a new [!term=List]list[!term!] based on the values in another list.
Goal: A program that prompts for parameters to use in creating a set of rectangles, and finally prints the positions of these rectangles in an inverted coordinate system.
Introduction:
Bring your convert_representaton function from the cutting task in exercise 2. This task also involves ultimately presenting rectangles in a flipped coordinate system, so you will need it. You should also grab the number prompting function, and the get_coordinates function from the previous task. The latter will be modified a bit.
When this task description talks about a parameter dictionary, it means a dictionary that has the following keys:
columns - number of rectangles horizontally
rows - number of rectangles vertically
width - width of one rectangle
height - height of one rectangle
x-initial - x coordinate of the first (top left) rectangle
y-initial - y coordinate of the first (top left) rectangle
x-spacing - space between rectangles horizontally
y-spacing - space between rectangles vertically
image-height - the y value to be used in flipping the coordinates
All values are integers.
Function Modification: get_coordinates
Doctstring
:
"""Calculates coordinates for a set of rectangles based on given parameters.Returns a list of coordinates so that the first rectangle is at the giveninitial coordinates, and the following rectangles are spaced the given distance away from previous one."""
Parameters
:
dictionary that contains the deployment parameters (see above).
Returns
:
List of coordinates the for the top left corner of each rectangle.
This function will be modified so that it includes the width and height of rectangles into its calculations (whereas previously both of these were assumed to be 1). As this would lead into the number of parameters going as high as eight, it's also better to instead pass all of the parametrs bundled up into one dictionary. Besides these changes the function should work the same: it returns a list of coordinate pairs, each of which is the top left corner of one rectangle.
Function Specification: create_rects
Doctstring
:
"""Calculates positions for rectangles based on given parameters. The parameters in the dictionary are interpreted as being definedin a coordinate system where the origin is at the top left corner.The function returns the edge coordinates of each rectangle, presentedin a coordinate system where the origin is at the bottom left corner."""
Parameters:
dictionary that contains the deployment parameters (see above).
Returns:
List that contains the coordinates of each edge of each rectangle, in inverted coordinate system
This function uses the modifed get_coordinates function and the convert_representaton function from earlier to create a list of rectangles based on its received parameters. It's largely similar to the previous task but instead of having a tangible grid, the rectangles are simply defined as coordinates. Each pair of coordinates is turned into a rectangle dicionary similar to what was used in exercise 2 by giving it width and height. Then the convert_representaton function is used ot turn each of these rectangle dictionaries into the desired representation format. These are piled into a list, that is returned at the end.
Main Program:
The main program consists of multiple prompts because all 8 parameters for the rectangle delpoyment need to be inquired from the user. The height of the (currently imaginary) image also needs to be prompted as it is needed when flipping the coordinates. You will have an easier time if you use the prompt function from the previous task to get the inputs, and save the values directly into dictionary keys. After all the prompts, the program prints the edge coordinates of each rectangle on their own line.
'Example:
Number of rectangles (horizontal): 3
Number of rectangles (vertical): 2
Rectangle width: 50
Rectangle height: ten
Please give a positive integer
Rectangle height: -10
Please give a positive integer
Rectangle height: 10
X coordinate of the first rectangle: 40
Y coordinate of the first rectangle: 60
Rectangle spacing (horizontal): 15
Rectangle spacing (vertical): 20
Image height for coordinate flipping: 400
Rectangles created:
(40, 90, 330, 340)
(105, 155, 330, 340)
(170, 220, 330, 340)
(40, 90, 300, 310)
(105, 155, 300, 310)
(170, 220, 300, 310)
In this assignment we are getting started on comparing coordinates of objects in 2D space. The collision model used in this assignment is based on circles. In other words the "hitbox" of each object is determined by a central point and radius. The other classic way would be actual hitboxes, where collision is based on rectangular areas.
Learning goals: Comparison of coordinates, iterating objects from a list
Goal: A program which can detect a collision between two objects.
1st Function Specification:prompt_two_numbers
Docstring
:
"""Gets user input for two integers, using first parameter as input prompt andsecond parameter as error message. Valid input is returned as two integers."""
Parameters
:
prompt (string)
error message (string)
Returns
:
x coordinate (integer)
y coordinate (integer)
Prompt
user for two integers using the prompt message given as function parameter. Prompt is repeated until user inputs two valid integers separated by a space. If an error occurs, the error message given as second parameter is printed. After receiving valid input, the numbers are returned as integers.
2nd Function Specification:check_collision
Docstring:
"""Calculates the distance between two objects and returns True if the objects hiteach other, False if they do not."""
Parameters:
object_1 (
dictionary
)
object_2 (dictionary)
Returns:
Boolean value
which is True if the objects hit each other, False otherwise.
Dictionary objects, given as parameters, have the following keys:
"x": Object's x coordinate (integer)
"y": Object's y coordinate (integer)
"r": Circular object's radius (integer)
Function determines if two circular objects collide in their given coordinates. Function must return a boolean value determing whether two objects were on top of another at certain point. Remember to use objects' radius in your collision check.
Main Program:
Make a program that prompts the user for two points in x y format using prompt_two_numbers function. Prompt given as
argument
can be found in the examples below. Use the literal value 1 for radius. After prompting the user, the program prints out whether there was a hit to any of the targets defined at the beginning of the main program.
You can use the following list of targets in your main program:
Please note that the main program should print only once if a target was hit, even if there are multiple targets.
Examples:
Write two integers in "x y" format: 1 2
The shot missed :(
Write two integers in "x y" format: 1
The input was not given as two integers
Write two integers in "x y" format: one two
The input was not given as two integers
Write two integers in "x y" format: 1 2 3
The input was not given as two integers
Write two integers in "x y" format: 10 9
The shot hit a target!
Hints
Messages
Give feedback on this content
Comments about these exercises
?
Description
Examples
Absolute path is an operating system term that refers to the full "address" of a file or folder. Absolute path is written starting from the disk root. When absolute path is used, the current directory does not matter. Absolute paths are usually avoided in code - especially in applications that are meant to be shared. Another user is very unlikely to have the exact same folder structure as the application's developer. In particular if an absolute path refers to the user's home folder, it is very likely not going to be the same for another user.
Absolute path to the downloads folder in windows is typically something like this:
C:\Users\donkey\Downloads\
and in Unix based systems:
/home/donkey/Downloads
Ajonaikaisesta (engl. run time) puhuttaessa määreenä on se aikaväli, kun ohjelma on käynnissä. Esimerkiksi Pythonissa virheet (syntaksivirheitä lukuun ottamatta) tarkastetaan ajonaikaisesti. Ohjelma saattaa siis olla käynnissä ja toimia tiettyyn pisteeseen saakka, kunnes törmätään käsittelemättömään poikkeukseen – ajonaikaiseen virheeseen (engl. run time error).
Description
Esimerkit
Alustamisella (engl. initialize) tarkoitetaan yleisesti jonkin arvon asettamista muuttujalle muuttujan luonnin yhteydessä. Pythonissa ei ole mahdollista luoda muuttujaa, jolla ei ole myös jotain arvoa. Niinpä tyypillisesti käytetäänkin sanamuotoa ”muuttuja alustetaan arvolla x”, millä tarkoitetaan sitä, että muuttuja, joka luodaan, saa luomisen yhteydessä (eikä vasta joskus myöhemmin) arvon x.
Alustaminen on ihan tavallinen muuttujaan sijoitus:
nimi="Tomomi"
Yleisemmin alustamisesta puhutaan, kun halutaan alustaa esim. tyhjä lista sitä varten, että sinne myöhemmin lisätään alkioita:
Yllä kuvatun toiminallisuuden toteuttaminen ilman, että lista alustetaan ennen silmukkaa, olisi hyvin hankalaa.
Description
Esimerkit
Argumentti (engl. argument) on funktiokutsussa käytettävä arvo, joka välitetään kutsuttavalle funktiolle. Funktiokutsun alkaessa argumentit sijoitetaan parametreiksi kutsuttuihin muuttujiin, joiden kautta arvoihin pääsee funktion sisällä käsiksi.
Alla funktiokutsu, jossa on kaksi argumenttia: muuttuja tulos sekä lukuarvo 2
round(tulos,2)
Round-funktion helpin avulla voimme nähdä, että nämä arvot sijoittuvat parametreihin number ja ndigits (joista jälkimmäinen on valinnainen)
Arvo (engl. value) on konkreettista, tietokoneen muistissa sijaitsevaa tietoa, jota käytetään ohjelman suorituksen aikana. Arvoilla on tyyppi ja sisältö; esimerkiksi numero 5 on tyypiltään kokonaisluku, jonka sisältö on 5. Useimmiten arvot liitetään muuttujiin, mutta myös operaatioiden ja funktiokutsujen paluuarvot sekä koodissa sellaisenaan esiintyvät arvot ovat arvoja. Käytännössä siis kaikkea konkreettista mitä ohjelma käsittelee voidaan kutsua arvoiksi.
Assignment is related to variables and values. A typical figure of speech is "assigning to a variable" which means giving a certain value to a variable (e.g. x = 5). More specifically, in Python, assignment to a variable means creating a connection between the name and value of the variable - the variable is a way to find the value.
Similar expressions that can be used to mean the same thing are: "saving to a variable", "storing to a variable", "referring to a variable", "stuffing a value into a variable"... etc.
Assignment operator i.e. the = character is used for variable assignment. When using the operator, the target variable must always be on the left side and the value (or statement that produces the value) on the right side.
Attribute is a value that belong to an object, sometimes also called property. It's a name that belongs to the object's internal namespace and it can be accessed through the object: timestamp.tm_hour would read the hours from a timestamp.
Avainsanat (engl. keyword) ovat ohjelmointikielessä kielen käyttöön varattuja sanoja, joilla on erityinen merkitys. Hyvät tekstieditorit tyypillisesti merkitsevät avainsanat muista nimistä eroavalla tavalla (esimerkiksi lihavoinnilla tai tietyllä värillä). Avainsanat ovat yleensä suojattuja, eli samannimisiä muuttujia ei voi luoda. Yleisiä avainsanoja Pythonissa ovat esimerkiksi funktioihin liittyvät def ja return. Avainsanat ovat siis osa ohjelmointikielen kielioppia.
Boolean is the most simple data type in programming languages because it has only two values: true (True in Python) and false (False in Python). Things like comparison operators return booleans, and they are often used in conditional statements and while loops. In Python all values are equivalent to one of the boolean values. Generally all so called empty values (0, "", None etc.) are equal to False while the rest are equal to True.
Boolean operator refers to Boolean algebra which deals in values of truthfulness. These operations include and, not, and or - all familiar from conditional statements. Out of these and is True if and only if both operands are True; or is True if at least one operand is True; and not is True is its sole operand is False.
We are cutting a few corners when saying that and and or return boolean values. Full disclosure: and returns either the first operand that equals False, or - if both equal True - the latter operand; whereas or return the first operand that equals True, or - if both equal False - the latter operand. You can inspect this behavior in the Python console. For the purposes of this course this makes no difference because we're mostly using the results of comparison operators are only used in conditional statements that don't care if a value is actually True/False or just one that is equivalent to one of them.
You don't actually have to limit yourself to using these operators in conditional statements:
Branch is an execution path in the program that is mutually exclusive with other branches in the same control structure. For example in a conditional structure each if, elif and else define their own branches and only of them is executed.
Bug is an error in the program's source code. As the result of a bug the program either doesn't start at all, crashes during execution, doesn't work correctly in some situations, or can even cause severe security issues. Careful programming and testing - including rare edge cases - reduces the probability of bugs. Tracking down the part of code that causes a bug and fixing it is called debugging.
Buitin functions are function that are included in the Python core. They can always be used without importing any modules or libraries.
Callback is a common mechanism, especially in modern programming, where another part of the program - often made by someone else - is given a function it is to call during its execution. If a normal function call is like a phone call, a callback is a like a call request. If a part of the program uses a callback, it usually described what kind of a function it accepts - especially what parameters the function can/must have and what kind of a value it should return.
Where UNIX-based systems produce \n characters (newline) to indicate line breaks, Windows uses \r\n where the r is a carriage return character. It's a remnant from mechanical typewriters, and indicates the procedure of physically moving the typewriter head to the beginning of the line. In general this is just something that's good to know - Python treats both line breaks quite nicely.
Code block or block is a term used for liens of codes that belong to the same context. A block is formed of lines that have the same indentation level (although a block can also contain other blocks). Typical blocks are the executable parts of conditional structures i.e. the indented code lines that follow a condition. A block ends when a line with less indentation than ones belonging to the block is encountered.
Code file is a text file that contains executable code. A Python code file can be ran from the terminal by typing python code.py where code.py is the file's name. When you run a code file the return values of individual lines are not shown unless they have been specfically rpinted.
Command line argument or parameter is a name used for additional information that is passed to a terminal program when it's started. Command line arguments are typically separated by spaces. E.g. in python code.py, code.py is actually a command line argument. Command line arguments can be accessed in Python from the sys module's argv variable.
The last terminal incarnation of the example program in the material was done like this
python collection.py collection.json copy.json
Inside the program the arguments were read with this function:
Comparison operators are used for comparing values to one another. They are familiar from mathematics and can be used to compare size. Comparison operators return a boolean value, True or False, depending on the result of the comparison. Comparison operators are: <, <=, >, >=, == and !=
Comparison values are used e.g. in sorting lists. A comparison value is a value derived from a list item that is used instead of the item itself in sorting. For instance, if a list contains lists, a comparison value can be an item taken from a certain index of each inner list. It can also be a more complex derivative such as the sum of items or their mean value.
Description
Examples
Condition is used in this course to refer to the part of conditional statements and while loops that defines when the statement is true. Anything between the keyword that starts the stamement and the colon that ends it is basically its condition.
Conditional statement is a line of code that defines a single condition, followed by an indented code block which defines what should be done if the condition is true. Conditional statements include if and elif statements, the latter of which cannot be present without the former. Conditional statements that are linked together form conditional structures. A conditional statement must always end with a colon and it must be followed with at least one indented code line.
Conditional structure is a structure that consists of one or more conditional statements that branches program execution. Most of them have at least two branches: if and else. Between the two there can also be an indefinite number of branches under elif statements. It is also possible to have nothing but a single if statement in a structure. Each branch in a conditional structure has at least some code that defines what the program does in a situation falling under a condition.
As a whole a conditional structure is interpreted by checking the truthfulness of the first branch (if). If it evaluates to True, program execution continues to the code block inside the statement after which execution skips the rest of the structure. If it evaluates to False, other branches will be evaluated in sequence until one of them is True, or if none of them are, the else branch is executed.
Constant is a named literal value. They are used especially when the same literal value is used repeatedly in a program. Named constants are also just in general more practical in code than seemingly arbitrary literal values because its meaning can be derived from its name. Likewise if the value needs to be changed it is much easier if you only need to change it in one place (where it's defined). Python doesn't actually have a way to define "real" constants - they are simply variables. The difference is implied by writing constant names in full upper case. E.g THE_ANSWER=42.
In this game related example the height and width of a map are defined as constants. Using the numbers 800 and 400 in code would make it less clear what they are. In addition if these values are needed elsewhere in the program, they only need to be changed here:
Control structure is a common name for different programming structures that control the program flow in some way. Within this course this includes conditional structures, loops and exception handling.
Data (engl. data) on ohjelmoinnin asiayhteydessä mitä vaan tietoa, joka ei kuitenkaan yleisesti kata itse ohjelmakoodia. Yleensä datasta puhuttaessa tarkoitetaan yksittäisiä literaaliarvoja, muuttujien sisältämää tietoa tai jostain tietolähteestä (kuten tiedostosta tai verkko-osoitteesta) luettua tai sinne kirjoitettua tietoa. Nyrkkisääntönä voi kuitenkin pitää sitä, että koodi ja data ovat eri asioita, ja koodi käsittelee dataa. (Joissain yhteyksissä koodikin lasketaan dataksi, mutta näihin ei tällä kurssilla syvennytä.)
Data format is the "syntax" of a data file, and it defines how data has been saved to the file. Data format also defines what kind of data can be stored in the file. The basic idea of each data format is to enable the saving of data structures in a program in some format that also makes it possible to load them back in later. A data format can be based on some existing standard (e.g. JSON) but ultimately it's the programmer's responsibility to choose what data is relevant for the program and how to best represent it.
Data structure is a common name for collections that contain multiple values. The purpose of a data structure is to store data that consists of more than one value. There are various ways to make a data structure and each of them convenient means for adding, removing and modifying values. Data structures implement a way to bundle data together. Generally the difficult details involved have been hidden from the programmer.
Choosing data structures that serve the purposes of your program and are easy to handle in your code is essential. The most common structures in Python are list, tuple and dictionary. Another convenient structure is set which doesn't contain duplicate values. In addition to built-in structures, more can be found from the collections module.
On later courses you'll also become familiar with other important structures like trees and graphs.
Debugging is the process of hunting down and fixing programming errors i.e. bugs. There are many ways to track down bugs. One of the more common ones in Python is the error message it shows when a program crashes. Another common method to find errors is the use of debug prints. This means putting additional print function calls in the code temporarily to either see how far the code gets or what kinds of values variables have. Debugging is such an important part of programming that there are even specific debugging tools that have been developed. We don't use them on this course however.
Default value is a value that can be defined for a function parameter. It will be used for that parameter's value if its corresponding argument has not been given in a function call. E.g. in defprompt_length(question,maximum=10): function definition, the maximum parameter has been made optional by giving it the default value of 10.
Dictionary is a data structure that assigns keys (usually strings) to its values. The advantage of using dictionaries is that descriptively named keys make code that handles the data structure much easier to read. Starting from Python 3.7 dictionary keys and values are guaranteed to be in the order they were added.
Example dictionary definition:
Esimerkki sanakirjan määrittelystä:
Updating values and creating new key-value pairs is also done with square braces:
In[1]:course={...:"name":"Elementary Programming",...:"feedback":5...:}In[2]:course["feedback"]=1In[3]:course["comment"]="Can't deal with this sober"In[4]:courseOut[4]:{'name':'Elementary Programming','feedback':1,'comment':"Can't deal with this sober"}
In Python docstring is a comment-like entity but it has a special meaning. A docstring is usually delimited with triple quotes (i.e. '''document''' or """document""". If a docstring is placed immediately below a function's def statement (indented!), it becomes the function's documentation that is shown with the help function. Likewise a docstring placed at the very beginning of a code file becomes the module's documentation. A good doctstring describes what a function does, and explains its parameters and return values.
Docstrings should not be used as comments! Outside of the aforementioned places, commenting should be done with actual comments (lines starting with #).
Epätosi (engl. false) on toinen kahdesta mahdollisesta totuusarvosta ja toisen, eli toden, vastakohta. Sitä voidaan pitää lopputuloksena loogisissa ja vertailuoperaatorioissa, jotka eivät pidä paikkansa. Esimerkiksi vertailuoperaatio 5<4 ei pidä paikkansa, joten kyseinen operaatio evaluoituu epätodeksi. Pythonissa epätotta merkitään avainsanalla False.
Description
Examples
Error message is the Python interpreter's way of informing about an exception in a program. The error message contains information about where in the program the exception happened, which line caused the exception, the exception's type (e.g. SyntaxError) and a short verbal description. Error messages are your best friends and reading them is a very integral programming skill. Don't be afraid of them, they are only there to help you find out what's wrong in the code!
File "unitvector.py", line 1defcalculate_unit_vector(x0,y0,x1,y1)^SyntaxError: invalid syntax
For example this error message is here to inform about a syntax error in code file unitvector.py on its very first line. The syntax error in this case would mean that a colon was missing from the end of the function definition.
Escape in programming terms means interpreting a character in an exceptional way. For instance "n" is just the letter n but "\n" is a newline character. In this example the backslash character \ causes the normal interpretation of the n character to be escaped and replaced by another interpretation. The backslash functions as an escape character. One typical use is including " in a string that's delimited with ": "donkey ear interval is 14\""
Evaluointi (engl. evaluation) tarkoittaa lausekkeen tai muuttujan arvon lopputuloksen määrittämistä. Suoritettaessa lauseet evaluoituvat joksikin tietyksi arvoksi.
Event is a programming cocept that is generally used in the context of interactive applications that run in real time. These applications usually have a main loop that monitors for events. Events include: user clicks with the mouse, user presses a key, a certain amount of time has passed etc. Handler functions can be attached to events, and they will be called whenever the event is detected. This makes programming of interactive programs much easier because there's no need to worry about how actions on the screen are detected when implementing the application itself.
Exception is a scenario in programming where the program cannot proceed as instructed. Exceptions have a type (e.g. TypeError) that can be used in handling the exception within the program. Type can also be useful when trying to solve the issue if it is not intended. In most cases exceptions also come with a message that gives more details about what caused the issue. In Python exceptions are handled with try-except structures.
The exception message given by the interpreter is usually something like this
This program calculates the volume and area of a ball when its circumference is known
Input ball circumference: 23
Traceback (most recent call last):
File "ball.py", line 14, in
radius = calculate_radius(circumference)
File "ball.py", line 10, in calculate_radius
return circumference / (PI * 2)
TypeError: unsupported operand type(s) for /: 'str' and 'float'
Where the last line tells which type of exception happened, and potentially additional information about the problem.
Exception is the base class of most common exceptions. We also call it the Pokémon exception because if you use it in a try-except structure it will catch all the exceptions. In most cases this is not a good thing. It makes interpreting problem situations more difficult for both the user, and you, the developer. The latter is due to the fact that it will also catch any mistakes you made in your code, and you won't get any useful information when the program isn't behaving correctly.
Execution or running means going through a program or code snippet so that the instructions written within are carried out by the computer. Python interpreter executes code one statement at a time. While this is ongoing the program is "running". Execution ends when there is no more code to run, there's an unrecoverable error or when the program ends itself.
File extension is the part of the file's name that is on the right side of the last period in the name. They are commonly used for indicating file types. Image files for instance often have .png or .jpg as their extension. Python code files usually have .py at the end (e.g. donkeyswings.py).
File handle is a special object that Python uses to refer to an opened file. Most important note is that the handle is not the same as the file's contents - the handle can be used to read the contents, or write to the file. A file handle is obtained with the open function with the file's location (path) and the opening as arguments. E.g. withopen("donkey.txt","r")assomefile: opens donkey.txt inside a with statement (where files usually should be opened), with somefile as the file handle.
Filename is the name of a file that consists of the file's actual name and a file extension. For instance, donkeyswings.py is a complete filename where the given name is donkeyswings and the extension is .py.
Inside code, filenames are always strings.
Description
Conversions
Floating point number or float is an approximation for decimal numbers used by computers. Computers can't handle real decimal numbers due to their architecture, and that leaves us with floats. Floats can occasionally cause rounding errors - something to keep in mind. Python has a module for handling decimal numbers more accurately, called decimal.
Any integer or string that represents a float can be converted to a float with the float function:
The format method of strings is a powerful way in Python to insert values of variables into text that is either printed or saved to a file. Formatting works by defining placeholders in strings (e.g. {:.2f}) for marking spots where the format method arguments will be placed. Example: "Interval between donkey's ears is {:.2f}".format(measurement).
Note: format is an older way for general string formatting. Using f strings is a more modern way. However, there are still uses for the good old format method too.
In[1]:print("Hi, your name is {} and in your previous life you were a {}.".format("norusu-kun","walrus")Hi,yournameisnorusu-kunandinyourpreviouslifeyouwereawalrus.
Using indices in choosing the parameters. Typically useful when the same argument is used multiple times in the template string.
In[1]:print("Apples {1}{0} and bananas {2}{0}, {3}{0} in total.".format("kg",2,3,5)Apples2kgandbananas3kg,5kgintotal
It's even clearer when you use named placeholders
In[1]:print("Apples {apples}{unit} and bananas {bananas}{unit}, {total}{unit} in total.".format(...:apples=2,bananas=3,total=5,unit="kg")Apples2kgandbananas3kg,5kgintotal
Function is an independent part of a program that consists of the defining line (with the def statement) and the lines of code that defines the function's behavior. Functions are used to clarify program structure and to reduce redundancy. Functions communicate with each other and the main program through their parameters and return values. Variables (including parameters) defined inside a function cannot be accessed from outside the function. Likewise functions should not read values outside of their own scope.
Below is an example of a function that's typical for a game character moving within a closed region. The boundaries of the region have been defined as constants.
WIDTH=800HEIGHT=400defcalculate_new_position(x,y,x_direction,y_direction,speed):""" Calculates the position of a character based on its current position, directional vector and speed. The character cannot move out of bounds. Returns the character's new position. """x=max(0,min(x+x_direction*speed,WIDTH))y=max(0,min(y+y_direction*speed,HEIGHT))returnx,y
The statements used inside the function are complex enough that it's better to separate them from the rest of the code. In the rest of the code a character's position would be update by calling this function:
Function call is a procedure where the program's execution "jumps" to another location in the code - to the beginning of the function that is being called. When a function is called it is given a varying number of arguments - values that are assigned to parameters defined in corresponding positions in the function definition. A function's execution ends when a return statement is encountered or there are no more lines inside the function's code to execute. When this happens, the program's execution returns to the line where the function was called, and the function call itself is "replaced" by the function's return value.
In short function calls allow one part of the program to utilize another part - e.g. the main program can use a function, or a function can use another function.
The code snippet displayable_result=round(15.234589,2) has a function call where the round function is called with two arguments: 15.234589 and 2. After exiting, the function call is replaced by its return value, 15.23. Therefore the variable will ultimately be assigned the value 15.23.
Functions are defined with the def statement which specifies the name of the function and the names its parameters. Choosing these is an essential part of writing generally useful functions. The name should describe what the function does accurately but shortly. Parameter names should be chosen so that it's easy to deduce what kinds of values they will take as arguments. The function's code is indented inside the def statement as its own block. A function code can - and often does - include multiple lines. It can also include further indentations (like control structures).
WIDTH=800HEIGHT=400defcalculate_new_position(x,y,x_direction,y_direction,speed):""" Calculates the position of a character based on its current position, directional vector and speed. The character cannot move out of bounds. Returns the character's new position. """x=max(0,min(x+x_direction*speed,WIDTH))y=max(0,min(y+y_direction*speed,HEIGHT))returnx,y
Generator is a special type of object that works like a list in, for example, a for loop. However, it's not a series of values in memory like a list would be, but a special function that produces values in a lazy way, yielding a new one whenever it is called. Because of this it's not possible to show the "contents" of a generator, and it's not subscribable with indices. Generators are not included in beginner level courses.
fori,animalinenumerate(animals):
Although we don't use generators on the course, the enumerate object works like a generator. However, Python's documentation uses the separate "enumerate object" name for it.
Description
Esimerkit
Tilasanakirjat
Globaali muuttuja (engl. global variable) on pääohjelman tasolla esitelty muuttuja, jota muokataan suoraan funktiossa tuomatta sitä funktion nimiavaruuteen parametrin kautta. Globaalien muuttujien käyttö on huonoa ohjelmointityyliä, ja niiden sijaan tietoa kuuluisikin kuljettaa funktioille argumentteina ja ottaa funktiolta vastaan paluuarvoina muutettuja arvoja. Näin tekemällä välttää niin kutsutun globaalin tilan, joka huonontaa koodin ymmärrettävyyttä.
Pythonissa kaikki pääohjelmatason muuttujat ovat globaalsti luettavissa. Jotta muuttujaan voidaan sijoittaa globaalisti, se täytyy erikseen määritellä globaaliksi ennen muokkausta:
inventaario-listaa ei tarvitse erikseen merkitä globaaliksi, koska siihen ei kirjoiteta. Sen sijaan jos rivi globaln jätetään pois, tuloksena on UnboundLocalError.
Joskus on tarpeen jakaa ohjelman sisällä tietoa globaalisti. Tällä kurssilla tästä esimerkkinä on ohjelman tilan välittäminen käsittelijäfunktioille. Globaalien muuttujien sijaan ohjelmalle voidaan rakentaa tilasanakirja, jossa sijaitsevat kaikki arvot, joita tarvitaan käsittelijäfunktioiden sisällä:
Näin toimittaessa globaalisti käytetään vain yhtä muuttujaa usean sijaan. Lisäksi sanakirjan esittely ohjelman alussa kertoo kätevästi, mitkä tiedot ovat osa ohjelman tilaa.
Global scope encompasses all names (variables, functions etc.) that have been defined on the main program level. All names that belong to the global scope can be accessed from anywhere in the program code. However they can only be assigned new values in the main program level. In general functions should only use constants and other functions from the global scope. Main program variables should always be passed to functions through parameters.
A handler function is a function that has been connected to an event so that when the event occurs, the function is called. This often means that the handler is not called from within the same code file or module it was defined in, and instead it works as a callback. Handlers are often related to user interface and game libraries where the program's main loop is running inside the library and monitors events. In this scenario handlers are the actual application's means of implementing their functionality through events. Because the application's writer cannot influence how handlers are called, handler parameters and return values must match the requirements set by the library.
Hypystä (engl. jump) puhuttaessa tarkoitetaan ohjausrakenteen aiheuttamaa siirtymistä, jonka jälkeen ohjelman suoritus jatkuukin jostain muualta kuin seuraavalta koodiriviltä.
matka=10ifmatka>=50:# Ehtolause on epätosi, joten…print("Vielä on pitkä matka.")# …ohjelman suoritus hyppää tänne.
Description
Naming Conventions
Variables, functions, constants, modules and all kinds of things each have their own 'identifier - the part of the source code that's been assigned to mean that one particular thing. For instace if a programmer defines a variable width with the value 15 the name width can later be used to retrieve the variable's value. So the identifier can be thought of as a contract between the programmer and the Python interpreter about the meaning of a certain word in the code. Identifiers always belong to a namespace.
Naming conventions define what kinds of identifiers can be given to things in the code. In most programming languages acceptable identifiers consist of lower and upper case letters, numbers and underscores. In addition identifiers should be descriptive of the things they represent. E.g. a good name for an object's width would be width whereas a would be bad. Languages also often have style guides about how identifiers should be written.
Indented code lines have blank characters in front of them, either spaces or tabs. The role of indentation in general is to organize code and improve its readability. However in Python indentation is also used as the syntax for separating code blocks from each other - all lines with the same indentation level belong to the same block. On this course we prefer spaces, and the width of one indentation level is 4 spaces. All reasonable text editors can be configured to insert spaces instead of the tab character when the tab key is pressed.
Description
Example
Index is an integer value that denotes the position of an item in an ordered collection (list, tuple, but also string!). Indices start from zero which makes the last index (collection length - 1). Index can also be thought of as distance from the beginning of the colection. Python supports negative indices where -1 points to the last item, -2 to second to last etc. Using an index to get an item from a collection is called subscription.
When the index of a data structure, e.g. list, is used the act itself is called (index) subscription. The subscription is denoted with square braces, e.g. grades[0]. Subscription returns an item. Subscription outside the list causes an IndexError exception, and it's good to keep in mind that the last index of a list is its length - 1 (because indexing starts from zero). Index can also be negative - in this case counting starts from the end so that -1 is the last item of the list.
An infinite loop is a loop that does not have an end condition - the code inside it gets repeated "infinitely". Infinite loops do have uses in programming but they can also be caused unintentionally by a bug in the code. In Python infinite loops are usually "achieved" only by while loops.
whileTrue:# Code that's repeated infinitely
The normal way to build an infinite loop (on purpose) in Python is to make a while loop that has True as its condition.
Typically a loop like this contains some kind of mechanism that can be used to eventually exit it. Most commonly there's a branch with either break or return somewhere inside.
Input when used within the context of this course is a text-based command or answer to a question that's been requested from the program's user. It is prompted with the input function and will always be a string. When a program prompts for input the entire program stops until the user has given their input.
Interface in general refers to a connection between two things, and in programming it particularly means the way in which two parts of a program are connected to each other. For instance we can talk about the interface of a function which refers to the way in which the function accepts information as parameters and returns information as its return value. Likewise libraries typically have an API (Application Programming Interface) that tells how the library's features are used. Humans are also connected to programs through interfaces, specifically user interfaces.
A function's interface is defined by its def and return statements
This function's incoming interface is that it needs to be given a single argument - a ball's circumference as a number. Its outgoing interface is that it return two values: the ball's area and its volume.
Description
Examples
Item or element is an individual value contained within a data structure. The term is most commonly used in the context of lists. In this context, items also have a position, index, that denotes its distance from the beginning of the list. Therefore the index of the first item in a list is 0.
On the following line
animals=["donkey","dog","moose"]
the values "donkey", "dog" and "moose" are items in the animals list. Furthermore
Iteration is a concept related to loops. One iteration of a loop means executing the code inside the loop once.
Description
Examples
Key acts as an index for a dictionary. It can be used to look up a value from the dictionary. Each key corresponds to exactly one value. Keys are typically strings, but they can also be any immutable types like numbers or tuples.
Keyword argument (kwarg) is used in function and method calls to assign arguments directly to parameter names. This is very often used with the format method: "Hello {name}".format(name="Hagrid"). Another common use case is with functions that have a whole lot of optional arguments and only some of them need to be given. Using keyword arguments can also make the code generally more readable, especially for arguments that are either True or False.
Kirjasto (engl. library) tai moduuli (engl. module) (kuten niitä Pythonissa virallisesti kutsutaan) on valmiiksi kirjoitettua koodia, jolla on oma rajattu tarkoituksensa. Tyypillisesti kirjasto sisältää ainakin nipun aihepiiriinsä kuuluvia funktioita, mutta voi sisältää muutakin (esim. luokkia tai vakioita). Esimerkiksi Turtle on kirjasto, jonka tarkoitus on tarjota helposti käytettäviä piirtofunktioita.
Kommentti (engl. comment) on kooditiedostossa olevaa tekstiä, joka ohitetaan kun koodia suoritetaan. Kussakin kielessä on oma tapansa sille miten rivi merkitään kommentiksi. Pythonissa se on #- eli risuaitamerkki (engl. hash character), jonka jälkeen riviltä löytyvän tekstin Python-tulkki ohittaa kokonaan. Kommenteilla voi selventää koodin lukijalle (tai itselleen) mitä koodissa tapahtuu. Yleensä kommentit on hyvä laittaa omille riveilleen kommentoitavan koodin yläpuolelle.
Ohjelman ja sen funktioiden toiminta kuvataan yleensä mieluiten dokumenttimerkkijonossa. Kommentteja käytetään enemmänkin välihuomioiden tekemiseen.
Toinen tapa käyttää kommentteja on tilapäisesti kommentoida rivejä pois esimerkiksi vaihtoehtoisen koodin testaamiseksi. Tällöin aiempaa koodia ei tarvitse poistaa – kätevää, jos myöhemmin osoittautuu, että sitä tarvitaan sittenkin.
Alla on pätkä piiristo-moduulin yhdestä funktiosta (loput voit katsoa moduulin koodista)
def_piirra_pariton_rinnankytkenta(piiri,komponentit,pituusyksikko):""" Piirtää rinnankytkennän, jossa on pariton määrä komponentteja. Kytkentä piirretään piirtokursorin nykyiseen sijaintiin, ja piirron päätteeks kursorin sijainti päivitetään. ... """# Jaetaan komponentit kahteen puoliskoon ja keskikomponenttiinkeski=len(komponentit)//2vasen=komponentit[:keski]oikea=komponentit[keski+1:]piiri.add(e.DOT)# tallennetaan keskilinjan sijaintipiiri.push()# piirretään vasemman puolen komponentitfori,kompinenumerate(vasen[::-1]):piiri.add(e.LINE,d="left",l=1)# ...
Huomaa miten funktion toiminta on kuvattu dokumenttimerkkijonossa, ja miten kommenteilla on kerrottu mitä missäkin vaiheessa tehdään.
Ohjelman käyttämät arvot ovat kovakoodattuja (engl. hard coded) silloin, kun ne esiintyvät literaaliarvoina – eli semmoisenaan – ohjelman lähdekoodissa sen sijaan, että ne selvitettäisiin ajonaikaisesti esimerkiksi kysymällä käyttäjältä tai lukemalla tiedostosta.
Käyttöliittymäelementti (engl. UI element, widget) on jokin (yleensä graafiselle) käyttöliittymälle ominainen komponentti, jonka kautta käyttäjän vuorovaikutus ohjelman kanssa on mahdollista. Tällaisia ovat esimerkiksi napit, valikot, liukusäätimet ynnä muut.
Lause (engl. statement) on ohjelmointikielessä nimitys yksittäiselle suoritettavalle asialle, joka on yleensä yksi koodirivi.
Lauseke (engl. expression) tarkoittaa ohjelmoinnissa evaluoitavaa yksikköä. Esimerkiksi 5+5 ja "aasi"!="apina" ovat lausekkeita, jotka evaluoituvat arvoiksi 10 ja True. Lauseke yksin ei muuta ohjelman tilaa mitenkään, ellei sillä ole sivuvaikutuksia. Sen sijaan lauseke vaikuttaa osana lausetta.
Description
Examples
List is an ordered collection of values, and in Python it's a true swiss army knife. A list can contain values of any types, and its size is not limited.
Values inside a list are called items or elements. Each item has its own designated spot inside the list, called index. Indices start from zero! In addition, list is a mutable type. The third material contains a lot of information about lists.
A list can also contain other lists. Such a construct can also be called a two-dimensional list. Of course it's possible to have more than two levels of nested lists, which increases the number of dimensions. These would be called multidimensional lists.
Literal (literal value) is a generic name for any values that are present in the code as such. I.e. the value is not assigned to a variable but has been written into the code itself. For instance in the statements x=5 and print("donkey"), 5 and "donkey" respectively are literals. The term is used primarily for simple types: numbers, boolean values and strings.
Local variable is a variable that has been defined inside a limited scope, typically - and especially on this course - inside a function (including function parameters). A local variable cannot be accessed from the outside. In addition it gets destroyed when the scope it belongs in stops being relevant - usually when a function call ends.
Loop is a control structure that repeats the instructions contained within it either a certain number of times or until some condition is no longer met. Loops can be used to return program execution to a previous point, and they can also be used for processing large number of values. Python has two kinds of loops: for and while.
Loop Variable is a variable that's introduced in for loop declaration. This variable will receive each value in the sequence (e.g. list) that is being iterated over in the loop. Its value changes on each iteration. A simple example from the material: foranimalinanimals: where animal is the loop variable. If the sequence contains tuples (or lists), a for loop can also have multiple loop variables: forstudent,gradeingrading:. Loop variables are not inside their own scope and must therefore be distinct from other names inside the same function's scope.
Main program is the part of the code where the real execution of the program starts. As a rule of thumb any statements and control structures that are attached to the left boundary are part of the main program. Main program is usually at the very end of a code file and usually inside if__name__=="__main__": statement. However do not use this statement in the earlier exercises because then the checker cannot execute your program's main program.
Merkillä (engl. character) tarkoitetaan ohjelmoinnissa yksittäistä datana esiintyvää kirjainta, numeroa, välimerkkiä tai muuta vastaavaa symbolia. Pythonissa merkki edustaa pienintä merkkijonon yksittäistä palasta.
Description
Esimerkit
Merkkijono (engl. string) on tietotyyppi, joka sisältää tekstiä. Sitä käytetään erityisesti käyttäjän kanssa viestimiseen. Merkkijonojen sisältöä voidaan myös tallentaa tiedostoihin. Pythonissa merkkijono merkitään lainaus- tai heittomerkillä (esimerkiksi "aasi" tai 'aasi'). Suosimme ensimmäistä. Merkkijono voidaan merkitä myös kolmella merkillä jolloin se voi olla monirivinen – tätä käytetään erityisesti dokumenttimerkkijonojen (docstring) kanssa. Merkkijono on muuntumaton tietotyyppi – kaikki, mikä näennäisesti muokkaa merkkijonoa, tosiasiassa luo (ja palauttaa) siitä muutetun kopion.
Merkkijonon määrittely:
nimi="kapteeni mursuviiksi"nimi='norusu-kun'
monirivisen merkkijonon määrittely:
vitsi="""Nalle Puh oli palailemassa koodaus-allnighterista. Puolivälissä matkaa hän huomasi olevansa Ihaan pihalla."""
Method is a function that belongs to an object, i.e. it's one of the object's attributes. Methods are often used by objects to change their own state somehow, or derive another value from themselves. When a method is called it is prefixed with the object that ownds it: choice.lower(). Methods are occasionally called "member functions" as well.
Method Call is a similar process to function calls. As a significant different the target object is defined by prefixing method name with it whereas it would be given as an argument in a function call. In a typical method call an object operates on itself. For instance word.upper() is a method call that operates on the object referred to by the word variable.
Module is basically any Python code file. Although more commonly module is used as a synonym for library. Typically a module contains functions and potentially other (like constants and classes) things that are connected to a certain domain or use case. Large programs are also often split into modules so that each module focuses on one aspect of the program.
Python objects can be divided into two types: mutable and immutable. Mutable objects can have their values changed during program execution e.g. as the result as a method call. The most common example of a mutable object is a list: hogwarts.append("Hufflepuff") changes a list named hogwarts by adding a new value to it. Any references to this list later in the program will access the contents that now include "Hufflepuff".
Pythonissa objektit erotellaan muuntuviin ja muuntumattomiin. Muuntumaton (engl. immutable) arvo on sellainen, jonka sisältö ei voi muuttua - kaikki operaatiot jotka näennäisesti muuttavat arvoa tosiasiassa luovat siitä uuden kopion, joka yleensä sijaitsee uudessa muistipaikassa. Esimerkiksi merkkijonot ovat tyypillinen muuntumaton tyyppi Pythonissa. Siksi merkkijonojen kanssa näkee yleensä jotain tällaista: valinta=valinta.lower()
Muuntumattomuus tarkoittaa pääasiassa sitä, että kaikki operaatiot palauttavat kopion:
Ohjelmointikielissä on oleellista ymmärtää määrittelyn (engl. definition) ero suorittamiseen. Määrittelemällä luodaan kuvauksia funktioista, muuttujista ja erilaisista tietorakenteista – tavallaan siis kerrotaan ohjelmointikieltä käyttäen, minkälainen jokin edellä mainituista asioista on, tai mitä sen kuuluisi tehdä. Pythonissa määrittelyn ja suorittamisen ero on helpoin ymmärtää funktioiden avulla. Funktiomäärittelyssä funktio vasta luodaan – ikään kuin tehtaalla koottu laite. Funktiota varsinaisesti käytetään – eli sen toiminnallisuus hyödynnetään funktiota varten määriteltyä koodia ajamalla – vasta funktiokutsun yhteydessä. Samaa vertausta käyttäen funktiokutsu vastaa siis sitä hetkeä, kun tehtaalta saapunut laite käynnistetään.
Nimikonflikti syntyy, jos useammalle kuin yhdelle arvolle koitetaan antaa sama nimi. Tällöin tapahtuu niin, että tuoreempi sijoitus jåä voimaan. Tästä seuraa yleensä ohjelman kaatavia virheitä, koska usein arvot ovat eri tyyppiä. Voi jopa käydä niin, että epämääräisesti nimetyn funktion päälle tallennetaan vahingossa saman niminen muuttuja.
Namespace is a group of names (variables, functions, constants etc.) that belong to the same context. For example the names inside a function (inside the function definition code block) form their own namespace: names inside the function are only accessible from within. There's also a global namespace which is the main program's namespace. Using normal import in a program creates a new namespace within that program that is accessible through the module's imported name - the names inside the module form their own namespace. See also: Scope.
Newline (line break, end of line, EOL), the "\n" character is a character that, when printed or written to a file produced a line break. If a string is inspected without printing it e.g. in the console, all line breaks are shown as "\n" characters.
Description
Esimerkit
Nimeämätön vakio tai taikaluku (engl. magic number) on koodissa esiintyvä literaaliarvo, jota ei selitetä millään tavalla. Hyvään ohjelmointityyliin kuuluu taikalukujen välttäminen. Oikea – itsedokumentoiva – tapa on nimetä koodissa esiintyvät vakiot muuttujiin, jolloin niiden muuttaminen onnistuu tarpeen tullen yhdestä paikasta yhdellä muutoksella, ja koodin lukijan on helpompi ymmärtää koodia.
Ykkösmateriaalissa esiintyvässä tehtävässä 0.8 on taikaluku:
koko=40*0.8nopeus=10*0.8kantama=200*0.8
Ratkaisuksi tarjotaan vakion esittelyä
SKAALAUS=0.8
huomaa miten se, että vakiolle annetaan nimi, kertoo heti enemmän siitä mikä tämä mystinen 0.8 ylipäätään on.
Näppäimistökeskeytyksellä (engl. keyboard interruption) voi pakottaa jumiin jääneen ohjelman sammumaan. Sen saa aikaan painamalla Ctrl+C sen terminaalin ollessa auki, jossa ohjelma pyörii. Pythonissa näppäimistökeskeytyksen saa käsiteltyä kaappaamalla KeyboardInterrupt-poikkeuksen try-except-rakenteella.
Keskeytykset ovat oleellinen asiasisältö Laiteläheinen ohjelmointi - ja Käyttöjärjestelmät-kursseilla. Näppäimistökeskeytys on itse asiassa tietty UNIX-signaali nimeltä SIGINT, joka on mahdollista lähettää prosessille ”ilman käsiä”:
Laitetaan ikisilmukka pyörimään terminaalissa avattuun Python-tulkkiin.
>>> whileTrue:... pass...
Avataan toinen terminaali, selvitetään Python-tulkin prosessin numero ja lähetetään signaali:
Objekti (engl. object), joskus myös olio, on Pythonissa yleistä terminologiaa. Kutsumme objekteja pääasiassa arvoiksi alkeiskurssilla, mutta Pythonissa kaikkea voi käsitellä objekteina. Tämä tarkoittaa, että mihin tahansa voidaan viitata muuttujilla (esimerkiksi funktion voi sijoittaa muuttujaan). Tämän kurssin puitteissa objekti-termiä käytetään sellaisista arvoista joilla on metodeja.
Objektit nousevat merkittävämpään rooliin alkeista eteenpäin, erityisesti koodissa jossa käytetään luokkia.
Ohjelmointityyli (engl. programming style) on joukko ohjeita tai tapoja, joita ohjelmoija noudattaa koodia kirjoittaessaan. Näihin tapoihin lasketaan muun muassa sisennyksen syvyys, muuttujien ja funktioiden nimeämiskäytännöt, välilyöntien käyttö lauseissa sekä monet muut tyyliseikat. Ohjelmointityylejä on useita erilaisia, ja tällä kurssilla opetetaan noudattamaan tiettyjä tyyliin liittyviä sääntöjä.
Ominaisuus (attribute) liittyy objekteihin siten, että objekteilla voidaan sanoa olevan ominaisuuksia. Tällä kurssilla useimmat näistä ominaisuuksista ovat metodeja, mutta ne voivat olla myös arvoja. Objektin ominaisuutta käsitellään notaatiolla, jossa objektin nimen ja ominaisuuden nimen väliin tulee piste, esim: valinta.lower()-metodikutsussa valinta on objekti ja lower on ominaisuus.
Opening mode is used for telling Python (and the operating system) how to open a file. A file can be opened for reading or writing. By default, if opening mode is not given, a file will be opened in reading mode "r". There are two writing modes:
"w", write, which overwrites anything that may have been in the file previously with the new content.
"a", append, which writes the contents to the end of an existing file instead
Both writing modes create the file if it did not exist previously.
Operand is the fancy name used in mathematics and programming for values that are used in an operation. E.g. 5 + 8 is an addition operation and its operands are 5 and 8. Operands can be thought of as the subjects of operations.
Operation is a term used for anything carried out by an operator in the code. Mathematical operations are typical examples. An operation consists of an operator and one or two operands. For instance 5 + 5 is an operation.
Operator is a name for symbols that define an operation in mathematics and programming. Operators always appear with at least one operand, but often two. An example of an operator would be + symbol which denotes an addition operation.
An argument in a function call is an optional argument if its corresponding parameter has been given a default value. This means that it's possible to call the function without giving that argument. If there are multiple optional arguments for a function, they are often given using keyword arguments.
Parameter is a variable defined along with a function. They are variables that are assigned values from arguments when the function is called. In other words when values are transferred in a function call, they are called parameters from the function's point of view. E.g. in defprompt_input(question,error_msg):question and error_msg would be parameters. Parameters can also have a default value that will be used as its value if the matching argument is not given in a function call - this makes the argument optional.
Parametrization means expanding the use cases of a process by turning some of its values into variables. This way the same process can be repeated for multiple sets of values with different results. Mathematical functions are one kind of parametrization: all points represented by the function are produced by changing the value of a variable (e.g. x). In programming parametrization is quite concrete because usually a procedure is turned into a function. The function's parameters then define which values are not fixed and the function will behave differently with different parameters.
Description
Examples
Path is the location of a file or folder on the hard drive. A path can be absolute or relative. Absolute path includes every folder from the target all the to the root (e.g. in Windows the root is the drive letter, like C:) whereas relative only includes folders up to the active folder (i.e. the folder where the program was started in). Path is usually presented in programming languages as a string, and path parts are separated with slashes /. When forming path inside code, it's best to use the join function from the os.path module.
An absolute path in Windows (note: Windows uses backslash, but Python also accepts slash)
Relative path when the program has been run in the Documents folder of the Windows example:
Programming/donkeygotchi.py
Description
Additional formatting
Placeholder is by general definition a way to mark a spot that will be replaced by something else later. In this course they are primarily used with string formatting. A placeholder within an formatting string is marked with curly braces (f"Hi {name}"). Placeholders in strings can also contain additional formatting specifiers like setting the number of decimals to show (f"Donkeys have {average:.2f} legs on average"). When a placeholder is resolved, it is replaced by the value of the variable or statement inside the curly braces.
Format specification in placeholders can also be used to add leading zeros
In[1]:print(f"Serial number {12:04}")Serialnumber0012
or set the number of decimals shown:
In[1]:importmathIn[2]:print(f"Approx. value of pi: {math.pi:.4f}")Approx.valueofpi:3.1416
Poikkeusten käsittely (engl. exception handling) on ohjelmointikieleen sisäänrakennettu keino ohjelmoijalle reagoida poikkeuksiin. Pythonissa poikkeusten käsittely onnistuu try-except-rakenteella, jossa sekä try: että except: aloittavat omat lohkonsa; try-lohkon alle kirjoitetaan se koodi, joka mahdollisesti aiheuttaa jonkun tietyn poikkeuksen ja except-lohkon alle taas se koodi, joka suoritetaan siinä tapauksessa, että kyseinen poikkeus tapahtuu. Joissain muissa ohjelmointikielissä except-avainsanan sijaan käytetään avainsanaa catch, minkä takia yleisesti puhutaan poikkeusten kiinni ottamisesta.
Python mahdollistaa vielä joustavamman poikkeusten käsittelyn try-except-rakenteen else- ja finally-lohkoilla. Yhteenvetona:
try-lohkon koodia suoritetaan siihen saakka, kunnes se loppuu, tai kun try-lohkon koodi aiheuttaa poikkeuksen.
except-lohkon koodi suoritetaan ainoastaan, jos try-lohkon koodissa törmätään except-lohkolle määriteltyyn poikkeukseen.
else-lohko suoritetaan vain siinä tapauksessa, että try-lohko suoritettiin onnistuneesti ilman poikkeuksia.
finally-lohko suoritetaan lopuksi aina riippumatta siitä, onnistuiko try-lohkon koodi vai aiheuttiko se poikkeuksen.
Precedence, of math fame, defines in which order various operations in a statement are resolved.
result=10+2*(2+3)
The result of this statement is 20 because the sum of 2 and 3 is resolved first, followed by multiplying the result by 2, and finally adding the multiplication result to 10. In this example the highest precedence is held by the operation in braces, followed by multiplication, and then finally addition.
Precedence defines the execution order of instructions or operations on a line of code. Operations of different type have different precedence in execution order. These can be found from the link below. Operations with same precedence are executed from left to right. Like in mathematics, the order can be changed by using parentheses.
Printing is somewhat different in programming context - although not really that far removed - from combining paper and ink to pages. In context of computer programs it usually means producing text on the screen, especially to a terminal. Python has a function for this purpose: print(...) that prints its argument(s) to the terminal.
Printing without newline (shown in default console where the difference is more apparent)
>>> print("donkey",end="")donkey>>>
Printing multiple values in one line using separator other than space:
Programming problem is the goal of a programming task. It is therefore some sort of a need that has been recognized and a program is coded to fulfill that need. The need can be e.g. automatization of a task, creating a web site or just making a fun game.
Description
Examples
Interactive Python interpreter or Python console as we like to call it is a program that executes Python code lines as they are written into it. It shows the return value of the line if any exists (e.g. the result of a mathematical operation). On this course we use IPython instead of the vanilla Python console. After installation you can start IPython by typing ipython to the terminal.
You know that you have successfully started IPython if you see something like this:
Python 3.7.0 (default, May 7 2019, 09:44:49)
Type 'copyright', 'credits' or 'license' for more information
IPython 6.5.0 -- An enhanced Interactive Python. Type '?' for help.
In [1]:
On the contrary if you something like below, you are in the vanilla Python console:
Python 3.7.0 (default, May 7 2019, 09:44:49)
[GCC 5.4.0 20160609] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>
Python interpretetr is a program that transforms Python code into instructions to the computer's processor. It's responsible for executing both code files and individual lines in the Python console. The word can also be used to mean Python console though, so be careful.
Description
Examples
Recursion is a common programming term that refers to a function calling itself. Recursion is a function-based way to create repetition in the code where the function gives itself new arguments and handles its own return values. Recursion is handy e.g. when navigating tree-like structures - one "branch" is handled at a time, and then recursion is used to handle branches branching out from that branch, and so on. Recursion is not very widely used in Python. One reason is the recursion depth limit which restricts how many times a function can call itself.
Referring is the method in which a variable is connected to its value. The target of the reference is the computer's memory and the variable itself - under the hood - contains an address where from memory the value can be found.
Relative path is an operating system concept that indicates the path to a file or folder from the current folder. Relative paths do not care what kind of a garden maze of folders exists between the disk drive root and the current path. For this reason relative paths are usually used to refer to a program's own sub folders. This allows the program to be moved to another location without updating any paths in the code.
Description
Examples
Return is a process that happens when a function's execution ends. Typically the value(s) returned by the function are defined inside the function with a return statement. In the code that calls the function, the return value will replace the function call and can therefore be assigned to a variable or passed on to another function.
In the example below the value of the distance variable is returned
Return value is the value (or values) that a function returns when its execution ends - the function's result. Functions in Python can have multiple return values. When reading code you can regard return value as something that will replace the function call when the function execution has ended. A return value is defined inside a function with the return statement. E.g. in returnTrue there is one return value: the literal boolean value True.
Sapluuna (engl. template) on muotti esimerkiksi tekstille, joka käyttäjälle halutaan näyttää, mutta joka ei semmoisenaan ole vielä valmis. Sapluunasta siis puuttuu tietoa, joka on tarkoitus saada sapluunan paikanpitimien tilalle.
Kurssilla yleisin sapluuna on merkkijono, jossa on paikanpitimiä format-metodia varten.
Description
Examples
Scope is a concept related to the visibility of names (variable, function etc.) in certain parts of the program. For instance within a function block any names defined inside the function can be used because they belong to the same scope. Other functions cannot access these names because they belong to a different scope. Names in the global (main program) scope can be accessed from anywhere in the code.
In this example x is in the global scope and therefore its value can be accessed inside the function. Meanwhile variable is only accessible in the function's scope which means that while it's possible to define another_variable that depends on it inside the same function. However, because it's only within that function's scope, the print call in the main program will cause a NameError
Separator is a term related to strings and text files. It means a specific character that is meant for indicating a split inside a string when it is read into the program. For instance, if a string contains values that will be parsed into a list, the separator is the character than indicates where one part ends and the next one begins. The split method is often used in these situations - the method can use a specific separator to split a string into a list.
The example file in the first exercise of 4. exercises
A sequence is any value in Python that is a series of things - for instance, string, list and tuple are all sequences.
Description
Examples
Slicing is the act of taking a new sub-sequence out from an existing sequence (usually list, but sometimes also string). The result of slicing is a value with the same type that's a copy of the selected part in the original sequence. The selection is done by choosing start and end indices. Both are optional. A slice is written as follows: page=collection[5:10] - this would make a slice including indices 5...9. The number on the right side of the colon in a slice is the first index that is not included in the result!
Slicing never causes an IndexError.
In[1]:doggos=["doggo","woofer","doge","floofer","pupper"]In[2]:doggos[:2]Out[2]:['doggo','woofer']In[3]:doggos[2:3]Out[3]:['doge']In[4]:doggos[3:]Out[4]:['floofer','pupper']In[5]:doggos[2:-1]Out[5]:['doge','floofer']In[6]:doggos[4:10]# note going outside the listOut[6]:['pupper]
Slices can also have a third parameter which can be used for skipping over items, or even make a reversal for the list:
Solution model is an abstract construct developed by a programmer regarding how the solution to a programming problem works. It's not code yet, but it should be explicit and dividable into distinctive steps so that it can be turned into a program. Solution models can be sketched inside one's mind, by using paper and by trying this out in the Python console.
Source code or code means text that has been written with a programming language.
State, as the name suggets, referes to the program's current state. In practice state covers everything belonging to the program's state space like variable values, data in files, and where the code execution is currently at. A guaranteed way to make spaghetti code that's beyond repair is to use the global state - a crime that's perpetrated by functions that use global variables.
Later, on courses that go more formally into programming concepts, you'll learn of things like state machines, as well as stateless and stateful programs.
Description
Examples
Stub function is a function that's been defined properly with all the parameters etc. but has no content in it. They are typically put into the program code when planning its overall structure. Doing so allows the functions to be called elsewhere in the code while the function isn't fully implemented yet. The contents of a stub function usually come down to just pass, an informative print, or returning some placeholder default value. In larger projects stub functions sometimes are set to raise a NotImplementedError exception which makes it easy to locate the function that's not ready yet.
Below is an example of a stub function that already has proper parameters, and returns a value of the correct type
defchoose_values(data,start,end):return[]
This function can be called in the program and its return value used without causing exceptions - it just doesn't really do anything.
Syntax is the grammar of code. It defines what kind of text counts as valid Python. If code doesn't conform to the correct syntax, it cannot be executed. Syntax also informs a programmer about the correct formatting for each stement in the programming language.
Syntax error is an exception that happens when the Python interpreter inspects a code file before executing it and notices something broken in there, i.e. code that is written incorrectly. A code with syntax errors is not run at all.
One common syntax error is unbalanced parentheses. This results in a strange error message in the sense that Python reports the next line as the cause of the error. Remember to check previous lines as well when you receive strange syntax errors!
Takaisinkutsu (engl. callback) on yleinen ohjelmoinnissa käytetty menetelmä, jossa funktio ottaa parametrin kautta vastaan funktion kutsuttavakseen heti (synkroniset takaisinkutsut) tai joskus tulevaisuudessa (asynkroniset takaisinkutsut). Nimensä menetelmä on saanut soittopyynnöstä: kutsuttavaa funktiota, jolle jokin funktio välitetään argumenttina, ”pyydetään” kutsumaan tätä annettua funktiota. Pythonissa listojen sort()-metodin key-parametri on esimerkki callback-funktioiden käytöstä. Usein käyttöliittymiä toteutettaessa käyttöliittymäelementteihin kytketään callback-funktioita.
Terminal, command line, command prompt and shell' are different names to the text based interace of an operating system. It is used for text-based operating system commands and for running terminal programs. On this course we mostly move around with cd (change directory) and use ipython command to run code files and start the Python console.
In Windows you can open the terminal by typing cmd to the start menu search
In Mac OS X you can start the terminal by typing terminal to Finder
In Linux you can open the terminal from the desktop by pressing Ctrl + Alt + T or by typing terminal to the search
Testaamalla eli kokeilemalla (engl. test) selvitetään, toimivatko hartaasti näppäillyt koodirivit halutulla tavalla. Testejä suorittamalla siis etsitään koodista mahdollisia ohjelmointivirheitä. Ohjelmien testaaminen on jopa niin olennaista, että joidenkin alan työntekijöiden tehtävänä on ainoastaan automatisoitujen testien ohjelmointi. Lovelace-järjestelmän tarkistimet testaavat järjestelmään lähetetyt koodit.
Generally text file is any file that can be read with a text editor. In this course's context we use text file to refer to files that are handled as text inside Python. We do this to separate them from code files that are run with Python. Text files are used in this course to store data between runs of the program.
Tosi (engl. true) on toinen kahdesta mahdollisesta totuusarvosta ja toisen, eli epätoden, vastakohta. Sitä voidaan pitää lopputuloksena loogisissa ja vertailuoperaatorioissa, jotka pitävät paikkansa. Esimerkiksi vertailuoperaatio 5>4 pitää paikkansa, joten kyseinen operaatio evaluoituu todeksi. Pythonissa totta merkitään avainsanalla True.
Description
Esimerkit
Traceback is the process of tracing an error back to its source. When an exception occurs the Python interpreter prints an error message that includes a traceback. It's presented as a stack of function calls where the last one is the funtion where the exception occurred. They are also called stacktrace for this reason. For example if the main program calls the funcion f which in turn calls function g where the exception occurs, the stack would be main program → f → g.
Alla traceback, joka syntyy jos käyttäjän virheellistä syötettä ei käsiteltäisi oikein kokoelma-ohjelmassa:
Kappaleiden lukumäärä: 0.5
Traceback (most recent call last):
File "kokoelma.py", line 238, in
lisaa(kokoelma)
File "kokoelma.py", line 154, in lisaa
n = kysy_luku("Kappaleiden lukumäärä: ")
File "kokoelma.py", line 44, in kysy_luku
luku = int(input(kysymys))
ValueError: invalid literal for int() with base 10: '0.5'
Huomaa, että virheen aiheuttanut rivi on alimpana, ja sen yläpuolella siihen pääohjelmasta johtaneet funktiokutsut.
Tuple is a co-called frozen list. It's an ordered collection of values like a list but it's an immutable object. A tuple can't be changed. They can only be created, and read. Usually a tuple is delimited with normal braces: "#!python3 (1, 2, 3) but actually this is a tuple even without them: 1,2,3.
Unlike lists, tuples can be used as dictionary keys.
You can use the tuple function to freeze a list into a tuple:
Type conversion (also type casting and type coercion) means changing the type of a variable or literal value to another one. In Python this is commonly done when a number is requested from the user and it is returned as a string. In practice this can be done with e.g. int("123") or float("3.14"). In some cases Python performs type conversion automatically, usually when mathing with floats and integers.
Below are some common type conversions
In[1]:int(input("Give an integer: ))Giveaninteger:4Out[1]:4In[2]:float(4)Out[2]:4.0In[3]:float("1e3")Out[3]:1000.0In[4]:str(5.0)Out[4]:'5.0'In[5]:int(2.7)Out[5]:2In[6]:tuple([1,2,3])Out[6]:(1,2,3)
Tyylisäännöt ovat kokoelma suosituksia, joiden mukaan koodia tulisi kirjoittaa. Kullakin kielellä on yleensä omansa. Tyylisääntöjen rikkominen ei varsinaisesti riko ohjelmaa, mutta tyylisääntöjen mukainen koodi on miellyttävämpää lukea ja usein tästä johtuen myös helpompi korjata. Tällä kurssilla seurataan Pythonin virallista tyylistandardia erityisesti tekstikenttätehtävissä. Myös tiedostotehtävissä on koodin laadun tarkistus, jossa käytetään PyLint-ohjelmaa.
Tyyppi (engl. type) on arvon ominaisuus – jokainen arvo edustaa aina jotain tiettyä tyyppiä. Tyypin tarkoitus on siis kertoa, minkälaisesta arvosta on kyse. Käytännössä tästä seuraa myös se, mitä operaatioita arvoilla voi tehdä, ja mitä metodeja niiltä löytyy. Funktiot on myös miltei aina toteutettu siten, että niille syötettävien argumenttien täytyy olla tietyntyyppisiä, jotta funktio voisi toimia. Tyypit ovat yksi ohjelmoinnin keskeisimmistä käsitteistä.
Pythonissa arvojen sopiminen koodista löytyviin operaatioihin tarkistetaan tilannekohtaisesti näiden arvon ominaisuuksien perusteella – ei siis suoraan itse tyyppiä tarkastamalla. Esimerkiksi useimmissa tapauksissa kokonaisluku ja liukuluku kelpaavat molemmat, mutta on myös tapauksia, joissa näin ei ole (esimerkiksi merkkijonoa ei voi kertoa liukuluvulla).
Tällä kurssilla tyypillisiä tyyppejä ovat kokonaisluku (int), liukuluku (float), merkkijono (str), lista (list), totuusarvo (bool) ja monikko (tuple). Myös funktioilla on oma tyyppinsä!
Arvon tyypin voi saada esiin type-funktiolla:
>>> type(3+3j)<class 'complex'>
jos halutaan tarkistaa onko arvo jotain tyyppiä (kuten tarkistimissa tehdään säännöllisesti), tähän käytetään yleensä isinstance-funktiota. Sille voidaan antaa myös useita tyyppejä monikkona yhden sijaan.
User Interface (UI) is the interface between a program and its user (typically human). In a simple text based UI input function calls are used to prompt things from the user and print calls can be used to display instructions and results.
Many programs intended for end users (consumers) typically offer a graphical user interface (GUI). These typically involve icons, popup menus and other elements that can be poked with by mouse or touch screen. On this course we will take a very shallow stab at graphical user interfaces in the final project.
A simplified way to describe variable is to think of it as an information storage - it contains something. This expression is often used in speech even though it's not entirely accurate. The more accurate description is that a Python variable is a reference to a value. It's a connection between the variable's human-readable name and a value that's stored in the computer's memory. So the variable in fact doesn't contain the value, it just contains information about where it is.
The break keyword is a special instruction that is used in loops. It interrupts the loop's execution immediately, and code execution continues from the first line after the loop. If the loop had an else branch, it is not entered.
whileTrue:value=input("Give a donkey's tail length (leave empty to quit): ")ifnotvalue:break
continue is the other keyword related to loops (the first one being break). Unlike break which interrupts the entire loop, continue only interrupts the current iteration - execution continues from the next iteration. Note that this keyword is only needed in situations where part of the iteration is to be skipped. There's no need to put continue to the end of the loop iteration.
One common use case is in a loop that processes a list and for some reason or another needs to skip certain values:
forvalueinresults:ifvalue==0:continue# do something to the value
Note: the above is equal to
forvalueinresults:ifvalue!=0:# do something to the value
Usually continue is only used when the processing is complex, and the latter solution would introduce too many nested structures to the code.
Description
Examples
enumerate is builtin function that produces a generator-like object in Python. Its primary use is in for loops when the code needs to access the items' indices in addition to the items themselves. The enumerate object produces tuples where the first item is the original item's index and the second item is the original item itself. Use example: fori,characterinenumerate(moomin_valley):.
Enumeration is usually used in for loops when both the index and the item are needed:
f(ormat) string is a special string that is used for inserting values from variables or simple clauses inside a piece of text. This is also called string interpolation in programming terminology. This kind of a string is marked by prefixing it with a lowercase f. You can include placeholders inside the string by using curly braces, and writing variable names or clauses inside them.
Example: f"Interval between donkey's ears is {measurement:.2f} inches" (assuming that a variable named measurement has been definied previously)
In Python for is one of the two loop types. It's designated for iterating through data structures. It is used especially with lists. In general, for loops are used when it's possible to determine in advance how many iterations the loop must do. In addition to iterating through structures, for loop is therefore used for doing a certain number of iterations (e.g. 10 iterations). For loop declarion looks like foritemincollection: where item would be the name of the loop variable, and collection would be the data structure that is being iterated over.
In Python modules are "activated" by import statements. In normal use (e.g. importmath) the statement makes a new namespace accessible through the module name. Functions from the imported module can be accessed through its name. It's also possible to directly import some specific names from a module with a from-import statement: frommathimportceil. Modules can also be renamed on import: importmathasm.
Silmukoista while pohjautuu toistoon ehdon tarkastelun kautta - silmukan sisällä olevaa koodilohkoa suoritetaan niin kauan kuin silmukalle annettu ehto on tosi. Ehto määritetään samalla tavalla kuin ehtolauseissa, esim: while summa < 21. While-silmukat soveltuvat parhaiten sellaisiin tilanteisiin, joissa ei voida etukäteen selvittää montako toistoa tarvitaan - erityisesti syötteiden kysyminen käyttäjältä on tällainen tilanne.
Tyypillinen while-silmukka:
summa=0whilesumma<21:summa+=random.randint(1,10)
toisenlainen tyypillinen while-silmukka, joka on ikuinen
In Python with is a somewhat exception keyword in that it's not a control flow structure or definition of a new thing. On this course it's primarily used when opening files, e.g. withopen("donkey.txt")assomefile:. All read or write operations on the file are carried out inside the with statement. When the with statement ends, Python automatically takes care of closing files opened in the with statement.
withopen("results.txt")asresults:# the file is now open, and we can read its contentsresult_rows=results.readlines()# the file is now closed, but we can still access the contents# because they were saved to program memory earlierforrowinresult_rows:print(", ".join(row))# however we can no longer do anything with file handle in results variableresults.read()