Lab 2: Python Functions, and Testing
Lab 2: Python Functions, and Testing
If you find typos or problems with the lab instructions, please let us know.
The main purpose of this lab is to practice the basics of Python.
You will work with your pair partner on the same code. Repl.it enables this through shared repls. When one person types in a shared repl, this is visible to the other person immediately. As such, you don't each have your own document. Instead, you jointly work on a single document (this is similar to what you can do with google docs, for example).
Follow the driver-navigator model and switch roles frequently.
The most important thing we want you to get out of this lab is the ability to …
create a solution to a Python problem
iterate until your solution produces the correct behavior on a wide range on inputs
keep every step of that development process in a GitHub repo
For this lab, you will be working directly with your pair partner, creating code together. This is possible in Repl.it by using a shared repl.
The procedure to do this is explained under: Creating a Shared Repl
After you followed this procedure, you should now have a shared repl, named spis22-lab02-Alex-Chris (but with your first names instead of Alex and Chris, in the order listed under Pair Name on the pair-partner list), that is linked to a shared repo on GitHub.
In the file main.py in your repl, paste the Python code below. Only one of you should do this , and the code will automatically appear for the other partner in their browser as well.
# The goal of this program is to practice Python constructs
def sumTwo(a,b):
c = a + b
return c
x = sumTwo(3,5)
print(x)
Have a look at the code. It consists of a function that returns the sum of two input arguments; this function is called and the result is printed. This should make sense to you based on what you’ve learned about Python so far. Now let’s run the program. Is your output what you expect?
Next, push the code to GitHub. Again, only one of you should do this.
Do both of you see this commit in the commit history in Repl.it? You may need to refresh the page.
Do both of you see this commit on GitHub?
We will be using this workflow throughout SPIS. Make sure it all makes sense and don't hesitate to ask questions.
Now that you have gone through the workflow, it is time to do some more coding. Remember to switch between who is the driver and who is the navigator frequently.
In the repl you created above, add a new function: getNumber, as shown below (you keep all the other text that you already have in this file; just add this new function at the top).
def getNumber():
symbols = input("Enter a digit: ")
number = int(symbols)
return number
Let’s go over this code together. The first line inside getNumber() uses the built-in Python function input() to ask the user to type in something. This could be a single symbol (e.g., ‘a’), a word (e.g., ‘apple’) or even an entire novel. You can keep typing until you hit the Return/Enter key. We will assume the user only types in a single decimal digit (so one of ‘0’,’1’, … ‘9’), as this is what we asked the user to do (in the text that is between “ “ in the input-function).
However, Python interprets whatever is returned by the input-function as a string. A string is basically a collection of symbols. Since we only entered a single character (‘0’, ‘1’, .. ‘9’), this string would be a single symbol. The int()-function is used to convert this symbol to a corresponding number (if this is possible). For example, the symbol (letter) ‘1’ gets converted to the number 1. Why is this necessary? Well, even though they look the same to us, a computer needs to know whether you are talking about a symbol or a number, as it treats those differently. For example, it can multiply the number 1 by two, but what would it even mean to multiply the symbol ‘1’ by two? This is why we had to use the int-function to convert from a symbol to a number. Finally, now that we have a number, it is returned by the function.
Now, your task is to modify the getNumber function. It should repeatedly ask the user to enter a single digit, instead of only once. This means that you probably want to put the bit of code that asks for a user input in some kind of loop (remember while from lecture?) The number that is returned at the end of the function should be the combination of these individual digits. For example if the user enters 4, then 7, then 0 and then 9, the function should return the number 4709. You may wonder, if we are putting the user input inside a loop, how do we know when to stop? We will assume that as soon as the user answers with a number that is negative, you can stop asking (and ignore this negative number). So in the example above, the user would really enter 4, then 7, then 0, then 9 and then -1 (or any other number).
When you think you have your function, or even part of it, written, you should also test it. To do this, call the function in your code. This is similar how we called sumTwo. Test your function thoroughly to convince yourself it works correctly. Once this is done, you are ready to push your changes to GitHub.
You are going to add one more function to our repl, called sumDigits. This function should take a single parameter, which is a multi-digit number. The result it returns is the sum of the digits of this number. For example sumDigits(236) should return 11.
def sumDigits(x):
# You will need to complete this function
return sum
Complete the code for this function. Two useful operations here are % (modulo; which returns the remainder of a division) and // (integer division; which divides the number and rounds it to the nearest integer). For example, 11//2 is 5 and 11%2 is 1.
Now you need to come up with an algorithm that lets you extract each individual digit from a number, so you can add these together. We will give you some hints, but it’s good to try and figure out the algorithm without them. Brainstorm with your partner. Don’t think about it on your own and then explain to the other person. Just start talking … let the ideas flow and see if you can really think together. This is a good exercise to get you in the habit to do this throughout your pair programming exercises. If one partner already knows the answer (maybe you’ve seen it somewhere before), don’t simply tell the other person. Let them figure it out gradually.
After you’ve really thought about it and you need some help, here are some hints. First, think about how you can use division and/or modulo to get the least significant (i.e., right-most) digit of a number. So, how can you extract 6 from 236? It is helpful to consider that our number system uses base 10 (hence the name “decimal”). Once you have that, how can you get the number that would result from chopping of the least significant digit? So, how can you get 23 from 236? If you are able to do this, how can you get the next digit? Is there a repeating pattern here? This would suggest once again … a loop.
Once you have figured out the answer, test your function for a few different values to convince yourself it works correctly. When you are done and your code works correctly, push the updated file to GitHub (as we did for the previous function you added). Verify on GitHub that indeed all your updates got pushed online.
For this part, we are going to explore a bit more how you can approach testing your Python code … and give you a few more open ended coding challenges. Remember to switch driver-navigator roles frequently.
Add this function to your repl. It uses the the gender wage gap in the United States to calculate a woman’s wage based on the corresponding male wage.
def convertWageMtoW(mWage):
wageGap = 0.182
ratio = 1 - wageGap
return mWage * ratio
The wage gap is defined as the difference between a man’s salary and a woman’s salary, expressed as a percentage of a man’s salary. In the United States the wage gap is 18.2%. To calculate a woman’s salary, given a man’s salary using the wage gap we can multiply the man’s salary by 1-wageGap. You can learn more about the wage gap and see more data here.
To verify our code is correct, we need to test it, as we did before. More formally, this means that we need to define test cases. A test case is a combination of an input and the expected output. The first step to testing is to define these input-output pairs. We can use a calculator to do this, for example:
men’s wage of 100 should output 81.8
men’s wage of 76.2 should output 62.3316
men’s wage of 0 should output 0.0
It’s good to try a range of inputs that are qualitatively different. Notice in the test cases above, we have selected one non-zero integer input, one decimal number and the number 0.
Add code to the program to verify these cases, and make sure the output is as you expect. If the cases do not give you the correct expected output, figure out what is wrong.
Now add two more test cases of your own.
When doing this testing, you might find that your implementation returns values that are almost correct, e.g. 0.000000000000000000001 for 0.0 or something similar. This is due to imprecision in the way Python represents floating point numbers and is completely normal. You should consider your results correct if they “very close” to the expected results.
What’s next? Push the changes up to GitHub.
Now, extend the functionality of your wageCalculator function so that:
It takes at least one additional parameter
It uses an if-statement (or if-else statement, or if-elif-else statement, etc) in its functionality
You can use the data on this page, or any other data you find on the web in your functions.
Exactly what your extended function does is up to you and your partner, but it should still be focused on calculating salaries based on the gender wage gap. Here are some ideas for extensions, but feel free to come up with your own:
Add race/ethnicity information to the calculator. For example, the calculator might take an additional parameter, which is race, and calculate the salary of a woman of that race, assuming the wage input is for a man of that same race (or alternatively the wage of a white man).
Add a country parameter, and calculate salaries differently based on wage gaps in different countries.
In a comment above your modified function, make sure you describe what it does. Include a description of what each parameter means, and what is returned.
Come up with several test cases. If any of your test cases fail, fix your code so that they pass. Make sure you test enough cases so that you are confident your code works in all cases. For example, if you take a country name as one of your parameters, what happens if the user enters a country your code does not know about? Does it behave as you expect?
If you get part-way done, and some of your tests pass, but not others, or you are in the middle of working when it is time for a break, that is STILL a good time to do a commit to GitHub. Add the letters “WIP” to the start of your commit message so you know that this is not a finished product. “WIP” stands for “Work in Progress”.
When your code is finished, it passes all your test cases and you have pushed your final version to GitHub, congratulations! You are done with this lab, but consider some of the additional challenges below …
Even though you have just started learning Python, you already have all the knowledge required to implement a fun little game you are probably familiar with. The goal of the game is to guess a word or phrase, by asking if a letter appears in it. You win by guessing all the letters before you made 7 mistakes (i.e., asked for a letter that did not appear). You can try out a version of this game here.
You can be creative in how you implement this game. The code below shows a few useful constructs. Note that the [] operation lets you extract individual characters from a string. Note that the indexing starts at 0 (this means the first letter is at position 0, the second one at position 1, etc.). Play around with this to figure out what it does.
a = "hello"
b = a[0] # Get the 0th letter in a, in this case "h"
c = len(a) # This gives the number of letter (length) of a
You can also make the game flexible, where the number of mistakes allowed is a parameter.
If you still have time, you can explore unit testing with pytest (as illustrated in the 08.04 FOCS lecture) which is a more formal testing strategy. You can also extend your code in some other way, read more about the wage gap, or anything else related to this lab! Or do some more picobot …