Homework #3Due: Friday, October 18th at 4:00pm CST Table of ContentsHomework #3
Getting started Manual testing Completeness SNU Score
Code Quality
Submission The purpose of this assignment is to give you experience with conditionals, lists, and loops.
As in HW #2, many of the problems specify requirements related to the constructs that you are allowed to use inyour solutions. The purpose of these requirements isto ensure that you get practice with particularprogramming constructs.The grader who reviews your assignment will verify that your code follows these restrictions as part ofdetermining your code quality score.Please note that you will not need to define any new functions to complete these exercises.For all of the tasks, you may assume the parameters have the right types.
Getting started¶ o get started, you will need to pick up the materials for this assignment.
The first step is to navigate to your coursework directory:
$ cd ~/cmsc14100-aut-2024/cs141-coursework-GITHUB_USERNAME
Please recall that the
$
represents the prompt and is not included in the command. You also need to replace
GITHUB_USERNAME
with your GitHub user name.
Use
git status
to make sure that your local copy of your repository is in a clean state. The output should look
like this:
$ git status .
On branch main
Your branch is up to date with 'origin/main'.
If the output does not match, please review the relevant parts of the Introduction to Git (https://uchicago
cs.github.io/student-resource-guide/tutorials/git-intro.html) tutorial. If you run into trouble, please ask for help.
Once you have cleaned up and your repository is in a good state, run the following command:
$ git pull upstream main
This command will likely drop you into an unfamiliar editor window with text similar to the following:
Merge branch 'main' of github.com:uchicago-cmsc14100-aut-2024/coursework-upstream into main
# Please enter a commit message to explain why this merge is necessary,
# especially if it merges an updated upstream into a topic branch.
#
# Lines starting with '#' will be ignored, and an empty message aborts
# the commit.
If that happens, type
:q!
(that is, a colon, followed by the letter
q
, followed by the symbol
!
) and then hit
enter.
This command will pull the materials for this assignment into your local copy of your repository and will create a
commit.
You will find the files you need in the
hw3
directory. The file
README.md
contains a description of the files in the
directory. Please take a minute to review it before you start work on the assignment.
Manual testing¶
You should plan to test your code manually in
ipython3
.Run the following at the start of your IPython session to load your code and to set up autoreload so that
subsequent changes to the file will be automatically picked up:
$ ipython3
In [1]: %load_ext autoreload
In [2]: %autoreload 2
In [3]: import hw3
If you get an error saying that the
import
failed, make sure you are running
ipython3
from within your
hw3
directory.
Make sure you set-up autoreload every time you start-up
ipython3
.
Docstrings¶
After the first exercise, you will be required to write docstrings for the required functions.
A docstring should have:
a brief description of the purpose of the function,
an “Args” section that provides the name, type, and purpose of each input, and
a “Returns” section that provides the type of the return value and a brief description of the return value.
Here is how to write the types that you will use in this assignment, for:
an integer, use
(int)
as the type,
a boolean, use
(bool)
as the type,
a color tuple use
(Tuple[int, int, int])
,
a list of integers, use
(List[int])
, and
a list of color tuples, use
(List[Tuple[int, int, int]])
.
We recommend writing the required docstring before you write code for an exercise to solidify your
understanding of the purpose of the function, the arguments to the function (including their types), and the
return value for the function (including its type).
The grader who reviews your assignment will check your docstrings to ensure that you have included all the
required information as part of evaluating the quality of your code. Also, please keep in mind that the 80-
character limit on the length of lines applies to your docstrings as well as to your code.
Exercise 1¶
In Homework #2, you wrote a simple function,
is_grayscale
, to determine whether an RGB color represents a
grayscale color (that is, do the red, green, and blue channels of the color have the same value.)For this exercise, your task is to write
is_grayscale
again, this time using a different set of constructs than you
used in Homework #2. As a reminder,
is_grayscale
takes three integer values,
r
,
g
, and
b
, for the red,
green, and blue channels of a color and returns
True
, if all three channels have the same value and
False
,
otherwise.
You may assume that all three parameters hold integer values between 0 and 255 inclusive.
Here are some sample uses of this function:
In [2]: hw3.is_grayscale(255, 255, 255) # White
Out[2]: True
In [3]: hw3.is_grayscale(160, 32, 240) # Purple
Out[3]: False
In [4]: hw3.is_grayscale(0, 0, 255) # Blue
Out[4]: False
In [5]: hw3.is_grayscale(0, 0, 0) # Black
Out[5]: True
Requirements:
You may use conditional statements and the integer equality (
==
)/inequality (
!=
) operators in your solution
to this task.
You may not use logical operators (
and
,
or
, and
not
), nor may you use arithmetic operations (
+
,
-
, etc)
in your solution to this task.
Automated Tests
To run the automated tests for this exercise, run the following command at the Linux command-line:
$ py.test -xvk is_gray
We encourage you to open a second terminal window (connected to your assigned Linux server using SSH) for
running
py.test
. Also, remember to run the tests in your
hw3
directory.
Representing colors using tuples¶
In Exercise 1, we represented a color using three integer parameters. We can also represent a color using a
tuple with three integers that have values between 0 and 255 inclusive. Here are some sample colors:
In [6]: WHITE = (255, 255, 255)
In [7]: BLACK = (0, 0, 0)
In [8]: BLUE = (0, 0, 255)
In [9]: MEDIUM_GRAY = (127, 127, 127)
For the tasks that use color tuples, you may assume that the tuples are valid. That is, you can assume a tuple
for a color has three integers with values that range between 0 and 255 inclusive.
We can give names to the individual values in a tuple using Python’s tuple unpacking mechanism, which allows
programmers to specify multiple names, separated by commas, on the left side of an assignment statement andan expression that yields a tuple on the right side. Here are some example uses of this mechanism:
In [10]: r, g, b = (160, 32, 240) # Purple
In [11]: r
Out[11]: 160
In [12]: g
Out[12]: 32
In [13]: b
Out[13]: 240
In [14]: r, g, b = BLUE
In [15]: r
Out[15]: 0
In [16]: g
Out[16]: 0
In [17]: b
Out[17]: 255
Please note when you use tuple unpacking, the number of names on the left side of the assignment statement
must equal the number of values in the tuple that is the result of evaluating the right side of the assignment
statement. For example, if evaluating the expression on the right side of the assignment statement yields a
tuple of length three, then you need to have either one name on the left side of the assignment statement (for
the whole tuple) or three names (one per value in the tuple).
We encourage you use this mechanism when you need to work with the components/channels of a color.
Exercise 2¶
Complete the function,
is_black_or_white
, which takes a color tuple and returns
True
if the color is black (
(0,
0, 0)
) or white (
(255, 255, 255)
) and
False
, otherwise.
Here are some sample uses of
is_black_or_white
that use the color constants defined above:
In [20]: hw3.is_black_or_white(BLACK)
Out[20]: True
In [21]: hw3.is_black_or_white(WHITE)
Out[21]: True
In [22]: hw3.is_black_or_white(MEDIUM_GRAY)
Out[22]: False
In [23]: hw3.is_black_or_white(BLUE)
Out[23]: False
In [24]: hw3.is_black_or_white((160, 32, 240)) # Purple
Out[24]: False
Requirements:
You may use conditional statements, tuple unpacking, and integer equality/inequality operators for this task.
You may not use logical operators or equality/inequality on tuples in your solution for this task.
Automated TestsTo run the automated tests for this exercise, run the following command at the Linux command-line:
$ py.test -xvk is_black
Exercise 3¶
Complete the function
count_not_black_or_white
, which takes a list of color tuples, and returns a count of the
number of colors in the list that are neither black nor white.
Here are some sample uses of this function that use the color constants defined above:
In [25]: hw3.count_not_black_or_white([])
Out[25]: 0
In [26]: hw3.count_not_black_or_white([WHITE])
Out[26]: 0
In [27]: hw3.count_not_black_or_white([BLUE])
Out[27]: 1
In [31]: hw3.count_not_black_or_white([(160, 32, 240), (100, 52, 200), (0, 0, 0), (4, 30, 100)])
Out[31]: 3
Restrictions
You may not use logical operators or equality/inequality on tuples in your solution to this task.
Do not repeat the code for
black_or_white
in your solution. Use a function call instead.
See the Code Quality section for hints about how to chose the right looping construct.
Automated Tests
To run the automated tests for this exercise, run the following command at the Linux command-line:
$ py.test -xvk count
Short-circuiting¶
As we discussed in class, both the logical
and
and the logical
or
operators short-circuit. That is, Python stops
evaluating the expression as soon as the answer is known. For logical
and
, Python does not bother to evaluate
the second operand if the first operand evaluates to
False
. For logical
or
, Python does not bother to evaluate
the second operand if the first operand evaluates to
True
.
This concept extends to loops as well: a loop can short-circuit using
break
or a
return
to stop the computation
early.
A simple lab instrument¶
The next three problems concern the same simple lab instrument. During a given run, the instrument generates
a sequence of integer values. When the machine is working properly the values it generates will fall between
specified lower and upper bounds inclusive. The machine signals failures by generating values that fall outsidethe specified bounds; some failures yield values strictly less that the lower bound and some yield values that
are strictly greater than the upper bound.
If lower is 0 and upper is 10, then, for example:
0
is normal,
2
is normal,
10
is normal,
-5
signals a lower failure,
20
signals an upper failure.
In these tasks, you will be writing functions to determine whether failures occur and if so, whether a certain
failure (the first or the last) is less than the lower bound or greater than the upper bound.
We have defined the following constants to use as return values:
LOWER
signals that the failure of interest is less than the lower bound,
UPPER
signals that the failure of interest is greater than the upper bound, and
NEITHER
signals that no failure occurred.
Exercise 4¶
Exercises 4 and 5 require you to implement the same computation using different constructs. Implementing the
same computation twice will give you practice with different mechanisms and will help you see the relationship
between the two approaches.
Write a function
which_comes_first_break
that takes a list of integers generated by our instrument in the order
they were generated, the lower bound, and the upper bound and returns:
LOWER
, if at least one failure occurred and the first failure has a value strictly less than the lower bound,
UPPER
, if at least one failure occurred and the first failure has a value strictly greater than the upper bound,
NEITHER
, if no failures occurred.
As noted above, we have defined constants for
LOWER
,
UPPER
, and
NEITHER
for you to use as the return values
for your function.
Here are some sample uses of this function:
In [34]: hw3.which_comes_first_break([], -10, 10) # NEITHER
Out[34]: 0
In [35]: hw3.which_comes_first_break([-21], -20, 10) # LOWER
Out[35]: -1
In [36]: hw3.which_comes_first_break([11], -20, 10) # UPPER
Out[36]: 1
In [39]: hw3.which_comes_first_break([10, 20, 15, 0, -1, 1, 12, 13, 21], 0, 20) # LOWER
Out[39]: -1In [40]: hw3.which_comes_first_break([10, 20, 15, 0, -1, 1, 12, 13, 21], -1, 21) # NEITHER
Out[40]: 0
In [41]: hw3.which_comes_first_break([10, 20, 15, 0, -1, 1, 12, 13], 1, 19) # UPPER
Out[41]: 1
The first example returns
0
, which is the value of
NEITHER
, because there are no values in list and thus, no
failures in the list.
In the second example, the list contains one value and that value is less than the lower bound, and so the result
is
-1
, the value of
LOWER
.
In the third example, the list contains a one value and that value that is greater than the upper bound, and so
the result is
1
, the value of
UPPER
.
In the fourth example, the result is
LOWER
because the list contains failures (
-1
and
21
). Since the first failure
value (
-1
) is less than the value specified for the lower bound, the result is
LOWER
.
In the fifth example, the result is
NEITHER
because there are no failures: all the values fall between the lower
and upper bounds inclusive.
Finally, in the sixth example, the result is
UPPER
because the list contains failures (
20
,
0
, and
-1
) and the first
failure (
20
) is greater than the value specified for the upper bound.
Requirements:
Your function must stop looking values in the list as soon you find a failure value, that is, your function must
short-circuit.
For this exercise, you are required to use
break
to affect the short-circuiting.
See the Code Quality section for hints about how to chose the right looping construct.
Automated tests
To run the automated tests for this exercise, run the following command at the Linux command-line:
$ py.test -xvk first_break
Exercise 5¶
Your task is to complete the function
which_comes_first_return
, which implements the same computation as
which_comes_first_break
using a different method for accomplishing the short circuiting.
Requirements:
Your function must short-circuit.
For this exercise, you are required to use
return
to affect the short-circuiting.
See the Code Quality section for hints about how to chose the right looping construct.
Automated testsTo run the automated tests for this exercise, run the following command at the Linux command-line:
$ py.test -xvk first_return
Exercise 6¶
Write a function
which_comes_last
, which takes a list of integers generated by our instrument, the lower bound,
and the upper bound and returns:
LOWER
, if at least one failure occurred and the last failure was a value strictly less than the lower bound,
UPPER
, if at least one failure occurred and the last failure was a value strictly greater than the upper bound,
NEITHER
, if no failures occurred.
Here are some sample uses of this function:
In [43]: hw3.which_comes_last([], 0, 20) # NEITHER
Out[43]: 0
In [44]: hw3.which_comes_last([-1], 0, 20) # LOWER
Out[44]: -1
In [45]: hw3.which_comes_last([21], 0, 20) # UPPER
Out[45]: 1
In [54]: hw3.which_comes_last([10, 20, 15, 0, -1, 1, 12, 13, 21], 0, 20) # UPPER
Out[54]: 1
In [55]: hw3.which_comes_last([10, 20, 15, 0, -1, 1, 12, 13, 21], 0, 25) # LOWER
Out[55]: -1
In [56]: hw3.which_comes_last([10, 20, 15, 0, -1, 1, 12, 13, 21], -10, 25) # NEITHER
Out[56]: 0
Requirements:
See the Code Quality section for hints about how to chose the right looping construct.
Automated tests
To run the automated tests for this exercise, run the following command at the Linux command-line:
$ py.test -xvk last
Exercise 7¶
Complete the function
are_all_same
, which takes a list of integers and returns
True
if all the values in the list
are the same and
False
otherwise.
Here are some sample use of this function:
In [57]: hw3.are_all_same([])
Out[57]: True
In [58]: hw3.are_all_same([1])
Out[58]: TrueIn [59]: hw3.are_all_same([1, 1, 1, 1])
Out[59]: True
In [60]: hw3.are_all_same([1, 1, 1, 1, 2])
Out[60]: False
Requirements:
Your function must short-circuit. Note that converting the list to a set would violate this restriction.
Automated tests
To run the automated tests for this exercise, run the following command at the Linux command-line:
$ py.test -xvk same
Exercise 8¶
Complete the function
compute_final_score
, which takes a list of intermediate scores for a game, a lower
bound, an upper bound, and a bonus value and returns a final score. The intermediate scores, the bounds, and
the bonus value are all integers. The final score is the sum of the intermedi代 写CMSC Manual testing Completeness SNU Score ate scores plus, possibly, a bonusvalue. The bonus value is added to the final score if there are more intermediate scores with values strictlygreater than the upper bound than intermediate scores with values that are strictly less than the lower bound.For example, given the list:
Here are some sample uses of this function:
In [61]: hw3.compute_final_score([], 0, 10, 10)
Out[61]: 0
In [62]: hw3.compute_final_score([-21], -20, 20, 10)
Out[62]: -21
In [63]: hw3.compute_final_score([21], -20, 20, 10)
Out[63]: 31
In [64]: hw3.compute_final_score([-21, 21], -20, 20, 10)
Out[64]: 0
In [65]: hw3.compute_final_score([-21, 21, 22], -20, 20, 10)
Out[65]: 32
In [66]: hw3.compute_final_score([-21, 21, -22], -20, 20, 10)
Out[66]: -22
In [67]: hw3.compute_final_score([8, 10], 0, 10, 10)
Out[67]: 18
Requirements:
See the Code Quality section for hints about how to chose the right looping construct.Automated tests
To run the automated tests for this exercise, run the following command at the Linux command-line:
$ py.test -xvk final
Exercise 9¶
Complete the function
get_first_bw_idx
, which takes a list of color tuples, and returns the index of the first
element that is either black or white. The function should return
None
if neither black nor white occur in the list.
The return type for this function can be written as
(int | None)
.
Here are some sample uses of this function:
In [69]: hw3.get_first_bw_idx([]) is None
Out[69]: True
In [70]: hw3.get_first_bw_idx([WHITE])
Out[70]: 0
In [72]: hw3.get_first_bw_idx([BLUE, (0, 255, 0), BLUE, BLUE, BLACK, (255, 0, 0), MEDIUM_GRAY, WHITE, BLAC
K])
Out[72]: 4
Requirements:
Your function must short-circuit once it finds the first occurrence of black or white.
Your solution may not repeat the code for determining whether a color tuple is black or white.
Your solution may not use the list
in
operator or the list
index
method. (Please note that you may use the
required
in
keyword in a
for
loop.)
Your solution may not use the
range
or
len
functions.
See the Code Quality section for hints about how to chose the right looping construct.
Automated tests
To run the automated tests for this exercise, run the following command at the Linux command-line:
$ py.test -xvk idx
Grading¶
Recall that you will receive two S/N/U scores for this assignment: one for completeness and one for code
quality.
Completeness SNU Score¶
Your completeness score will be determined solely on the basis of the automated tests, which provide a
measure of how many of the tasks you have completed and the complexity of those tasks.Grade
Weighted test score
Satisfactory
at least 90%
Needs Improvement at least 50%
Unsatisfactory
less than 50%
For example, if your implementation has a weighted test score of 92%, you will earn a S (Satisfactory) score for
completeness.
To determine your weighted test score, run the following at the Linux command-line (within your
hw3
directory):
$ py.test -v
$ python3 grader.py
or you can run the one line version:
$ py.test -v; python3 grader.py
Code Quality¶
You are expected to adhere to the class Python Style Guide (https://uchicago-cs.github.io/student-resource
guide/style-guide/python.html#python-style-guide) . The guide covers many parts of Python that are not relevant
for this assignment.
Here are some common code quality mistakes that we will be targeting in this assignment. Remember to review
the code quality hints from HW #2 as well.
Requirements
Review your code to verify that you followed the requirements/restrictions listed with the questions.
Defined constants
Use the constants defined for
LOWER
,
UPPER
, etc instead of the associated integer value.
Conditionals
Do not include conditional branches that have no computational effect. Do not write:
# Not good
if <some boolean expression>:
x = x + 1
else:
x = x + 0
or this:
# Not good
if <some boolean expression>:
x = x + 1else:
pass
(Recall that we use angle brackets to signal a placeholder. For example,
<some boolean expression>
should be
replaced with an actual boolean expression.)
Write this code instead:
# Good
if <some boolean expression>:
x = x + 1
Similarly, do not use
pass
in the
if
branch:
# Not good
if <some boolean expression>:
pass
else:
x = x + 1
Write this code instead:
# Good
if not <some boolean expression>:
x = x + 1
Don’t use
continue
in this context either.
Choice of Loop
Make sure to choose the right loop style for your problem.
If you are working with the values in a list, write your code like this:
# Good
for val in lst:
<do something with val>
If you need to do a task that requires both the index and the value of a list element, write code like this:
# Great
for i, val in enumerate(lst):
<do something with i and val>
If you need to do a task that requires both the index and the value of a list element, code like this is usually
considered poor style in Python (even though it will feel normal to those of you with Java or C experience):
# Not good
for i in range(len(lst)):
val = lst[i]
<do something with i and val>
There is no reason to use a
while
loop for this assignment.
DocstringsMake sure you have provided a complete and accurate docstring for every function. A complete docstring
contains a brief description of the purpose of the function, a description of the each input (including its type) and
a description of the return value, including its type (assuming the function returns a value).
The two most common mistakes are not writing a docstring at all and writing a docstring that does not include
the types of the inputs or the type of the return value.
Overly long or complex code
Avoid writing code that has more cases than needed.
Avoid repeating code Reuse earlier functions when appropriate. Note that it is OK to use the same loop header multiple times, but not
the same loop body.While these are the main things we care about in this assignment, please remember that it is not possible for us
o give you an exhaustive list of every single thing that could affect your code quality score (and that thinking in
those terms is generally counterproductive to learning how to program; see our Mistakes are an essential part Gradescope will upload your files directly from your GitHub repository, so it is important that you remember to
commit and push your work!(If you have trouble with the link, you can find a link for Gradescope in the list of applications on the left side of
our Canvas site. Follow the link and then click on Homework #3.)Under “Repository”, make sure to select yourcmsc14100-aut-2024/cs141-coursework-GITHUB_USERNAMErepository.
Under “Branch”, selectmain.Make sure to check the results of the autograder on Gradescope. If your score is not what you expect, check tomake sure you pushed your work to the server! If you pushed your work to the server and the score is still notwhat you expect, check your code to look for problems that you might have introduced as part of your final codequality check.
标签：function,use,Completeness,testing,Manual,value,your,hw3,Out From： https://www.cnblogs.com/comp9313/p/18472027