辅导CS1留学生、讲解Python编程设计、Python语言辅导、讲解Etsy shop 辅导留学生 Statistics统计、回归、迭代|解析
- 首页 >> OS编程 7Task 3: Quilts
In this problem, having a partner is optional, but is strongly recommended.
The CS1 Etsy shop wants to expand the items offered on their site. Quilts would be an
item that could generate a lot of revenue. Below is an example of one of the CS1 Etsy
quilt designs, which we will call winter quilt.Another example is the following, which we will call the autumn quilt:
You and several other CS1 students have been hired as interns at the CS1 Etsy shop to
help design quilts. Your project is to use pictures to generate the quilt designs shown
above. You'll notice that the quilts are the same except for the color scheme.These quilts are just two sample of the quilt design. In your code, you will write functions
that will take color parameters, and therefore can generate lots of different quilts, in the
same pattern as above, but with color variation.
The picture.py module, which contains picture functions you have learned about in
Lecture 05 and Lab 04, is provided in the ps04 folder. You may use the functions
defined in that module to help create your quilts. All the functions that you will define for
this problem will be in a file that you will create called ps04Quilt.py.
Your goal is to write a quilt function that takes several color parameters and returns a
picture corresponding to the quilt shown above when quilt is invoked with appropriate
colors. This picture is ultimately generated by combining primitive pictures created by
the following two functions that you have already seen in class. They can be found in
the picture.py file:
patch (c):
"""Returns a rectangular patch of color c with a
black border that fills a given picture frame.
"""
triangles(c1,c2):
"""Returns a picture that consists of two triangles filling the
given picture frame: a black-bordered triangle of color c1
in the lower left corner of the frame; and a black-bordered
triangle of color c2 in the upper right corner of the frame.
"""
For example, below are the pictures generated by some sample invocations of these
functions:
patch('red') triangles('red', 'blue')Divide, Conquer, and Glue
The key to solving the problem of defining the quilt function is to note that the picture
it returns can be decomposed into smaller pictures that are used more than once in the
larger picture. For example, by wishful thinking we can image that the upper right
quadrant is a picture returned by a function we'll call block:
block('navy', 'lightskyblue', 'darkseagreen', 'papayawhip', 'plum', 'orchid')
The block is clearly decomposable into subquadrants of two kinds, which we've
dubbed rose and diamond. Here are two roses:rose('darkseagreen','papayawhip) rose('navy','lightskyblue')
Here are two examples of the pattern we called diamond:
diamond('plum',
'orchid','darkseagreen')
diamond('navy',
'lightskyblue','darkseagreen')Implement each of these, then combine these subproblem solutions to solve the whole
quilt. How to solve these? Each of these patterns can be broken down into quadrants
and those subproblems solved and combined with operations like rotation to solve the
pattern.
This is an excellent illustration of the divide, conquer, and glue problem solving strategy
we will use throughout this course:
1. Divide the problem into subproblems. Here, the whole quilt problem can be
solved if we can solve the problem of generating the pictures in the different
quadrants and sub-quadrants.
2. Conquer the subproblems by solving them. In this case, you'll want to solve
subproblems like rose and diamond that will help solve the whole problem.
3. Glue the solutions to the subproblems together to form the solution to the whole
problem. Here, we combine four rotated versions of the picture returned by block
to construct the picture returned by quilt.
But how do we solve the problems of defining the rose and diamond functions? By
applying the divide, conquer, and glue strategy again! Of course, all of these functions
will take appropriate color parameters.
Continue this way, decomposing each problem into smaller subproblems, until you
reach problems that can be solved using our primitives (e.g., patch and triangles).
For an example of this sort of decomposition, see the quilt example from Lecture 05.
Starting the Assignment
Begin by creating a file named ps04Quilt.py. As usual, your file must start with
comments at the top, identifying the author(s), username(s), problem set and task
number, filename, and date. Follow this format:# Your name:
# Your username:
# Your partner's name (if applicable):
# Your partner's username (if applicable):
# CS111 PSO4, Task 3
# ps04Quilt.py
# Submitted:
Remember to include the line:
from picture import *
at the top of your file, so that all of the functions in the picture.py file are available to
you.
Then use incremental programming to make progress on your quilt. That is, make
approximations to your quilt picture or parts of your quilt picture and use displayPic
to display these pictures along the way.
You can work in one of two directions:
1. In the bottom-up strategy, you start with smaller helper functions, like those
defined in the Helper Functions section below, and build up pictures of
increasing complexity, including rose and diamond, until you have correctly
defined the full quilt picture.
2. In the top-down strategy, you start by defining the quilt function in terms of the
block function or the rose and diamond functions. But those are complicated,
so you might put off the diamond subproblem while you work on the rose
subproblem. So for testing purposes, you instead provide a so-called stub
picture for the diamond function. For example, as a very crude approximation,
you might define an initial version of the diamond function that returns the result
of calling triangles on two of its parameters. You can then test quilt with this
approximation. Then you continue the top-down descent by defininginitially-crude-approximations for functions that return the quadrants of the block
picture. You continue this top down process until you reach pictures that are
correctly implemented by patch and triangles, at which point you now have
the correct quilt function rather than just an approximation.
Colors and Parameters
There are exactly six colors used in the Winter quilt and a different six colors in the
Autumn quilt. All of the colors for the Winter quilt are listed in the examples above. The
Autumn quilt uses the colors in the following examples:
rose('red','gold')
rose('darkred','coral')
diamond('darkred','coral','red')
diamond('darkorange','bisque','red')
Your top-level quilt function will take six colors as arguments and return the
appropriate quilt. You get to choose the order of the six color parameters.
However, you must define zero-argument functions winterQuilt and autumnQuilt
that return the result of calling the quilt function on six appropriate color arguments.
def winterQuilt():
'''Returns the first quilt with the blue-green-purple theme'''
return quilt( ... six color arguments go here ... )
def autumnQuilt():
'''Returns the second with the red-orange-yellow theme'''
return quilt( ... six color arguments go here ... )
The quilt pictures returned by these functions should match the ones depicted at the
beginning of this task. Codder will test the results of these two functions.
Note: Ideally, color parameters should have meaningful names, but with functions like
quilt and block that take lots of (six) color parameters, it's challenging to design
such names. In our solution, the main quilt function takes six parameters, which wenamed c1, c2, ... c6. Then in the various subfunctions, which take fewer colors,
we didn't want to use the same numbers, because it might be confusing. If we think of
c1 as navy for example, we don't want to use c1 in another function where it might
mean plum. So some functions have arguments named cx, cy and cz. Of course,
Python doesn't care what we call our parameters, and we can use the same parameter
names in several different functions. But remember that programs are written for
humans to read and only incidentally for computers to execute. Even reading our own
code, we want to keep names clear in our minds.
Helper Functions
As we have seen, a general principle of computer science is Don't Repeat Yourself
(DRY), which means you should avoid writing the same pattern of code more than once.
If you find yourself writing the same or similar code more than once in your program,
you should write functions that capture the patterns of the repeated code and invoke the
functions instead.
The divide, conquer, and glue process of defining quilt naturally exposes the need for
numerous auxiliary functions. Above, we have seen the block, rose, and diamond
functions, which you must define. As part of working on this task, you must also define
and use the following helper functions:
def bandana(c1, c2):
"""Returns a 2x2 picture with solid c1-colored patches in the lower left
and upper right quadrants, and triangles(c1, c2) in the upper left
and lower right quadrants."""
def lowerLeft(p):
"""Returns a picture which divides the picture space into four
quadrants and places the given picture in the lower left quadrant.
Nothing is in the other quadrants."""
def lowerLeftNest(p1, p2):
"""Returns a picture in which picture p2 is placed in the the lower left
quadrant of picture p1."""def lowerLeftNestSelf4(p):
"""Returns a picture that has four copies of picture p: one full size one,
and three successively smaller versions descending in the
lower left quadrant."""
Here is an example invocation of bandana:
bandana('red', 'blue')
Note that the lowerLeft, lowerLeftNest, and lowerLeftNestSelf4 functions
take pictures as arguments, not colors. To illustrate these helper functions, suppose that
pictures picP1 and picP2 are defined as:
picP1 picP2
Then here are examples of calling the lowerLeft, lowerLeftNest, and
lowerLeftNestSelf4 functions with these pictures:lowerLeft(picP1) lowerLeftNest(picP1,
picP2)
lowerLeftNestSelf4(picP2)
Notes:
● In this problem, you should not use any conditional statements.
● In this problem, you should use functions from PictureWorld (like fourPics,
rotations, and clockwise90). You should not directly create any
cs1graphics objects (such as layers), nor should you use any cs1graphics
methods (such as .clone, .rotate, .scale, and .moveTo).
● You must define the following functions in your program: bandana,
lowerLeft, lowerLeftNest, lowerLeftNestSelf4, rose,
diamond, block, quilt, winterQuilt, autumnQuilt. Additionally,
you should define one or more other functions that help you abstract over other
patterns.
● You can use lowerLeftNestSelf4 in conjunction with triangles to create
one of the patterns that appears in the quilt:lowerLeftNestSelf4(triangles('darkslateblue', 'navy'))
● Stepping back, your high-level goal in this problem is not only to generate the
correct quilt picture, but to do so in a way that takes advantage of the power of
abstraction to eliminate unnecessary repeated patterns in your code to make it
as simple and elegant as possible. You want solution code that has the same
level of abstraction and elegance as the code in Lecture 05 quilt.
Testing
As you implement the above required helper functions and your own helper functions,
you'll want to test them! You should put the following testing code at the end of
ps04Quilt.py:
# ------------------------- Testing -----------------------
if __name__ == "__main__":
'''All code that displays pictures or prints output should be nested
within this special "main" header at the end of ps04Quilt.py
'''
closeAllPics() # Use this to close all previously created pictures.
# Uncomment particular lines below to test your code.
# Add more test cases for functions that you define!
#displayPic(bandana('red', 'blue'))
#displayPic(lowerLeft(triangles('red', 'blue')))
#displayPic(lowerLeftNest(patch('red'), triangles('red', 'blue')))#displayPic(lowerLeftNestSelf4(triangles('navy', 'lightskyblue')))
## Roses
#displayPic(rose('navy', 'lightskyblue'))
#displayPic(rose('darkseagreen', 'papayawhip'))
#displayPic(rose('red','gold'))
#displayPic(rose('darkred','coral'))
## Diamonds
#displayPic(diamond('plum', 'orchid', 'darkseagreen'))
#displayPic(diamond('navy', 'lightskyblue', 'darkseagreen'))
#displayPic(diamond('darkred','coral','red'))
#displayPic(diamond('darkorange','bisque','red'))
## Blocks
#displayPic(block('navy', 'lightskyblue', 'darkseagreen',
# 'papayawhip', 'plum', 'orchid'))
## Quilts
#displayPic(winterQuilt())
#displayPic(autumnQuilt())
# Extra invocations to displayPic to fix picture glitch
# (a simple picture is sometimes needed to have previous pictures display)
displayPic(patch('red'))
displayPic(patch('blue'))
Recall that in order to see your pictures, you'll need to to invoke displayPic with an
argument which corresponds to the picture you want to display. As indicated in the
above code, you should put all invocations of displayPic at the very end of
ps04Quilt.py indented within the special header if __name__ == "__main__":
Notes:
● There is a glitch that sometimes happens with pictures as follows: a complex
picture may not display unless one or two simple pictures are displayed
afterwards. To play it safe, it is wise to always display two simple pictures after a
complex one, like this:
displayPic(complex picture here) # this is the one you want to see
displayPic(patch('red')) # 1st simple picture here
displayPic(patch('blue')) # 2nd simple picture here● The closeAllPics() function call closes all previously created pictures. The
above testing code calls this first so you will only see the pictures from clicking
the Run button, and not pictures from previous Runs.
Completing the Assignment
You should define all the helper functions specified above. In addition to that, you
should define other functions that capture other patterns that appear in the quilt. It is
also helpful to define local variables within your functions to give names to pictures that
you generate as part of your solution.
Each of your functions should be short: no more than a few statements long (say 7 or
8). If you find yourself defining a longer function, consider how you can break it up into
smaller parts (preferably in a way that permits one or more of the smaller functions to be
used multiple times).
Both Quilts
Remember that your quilt function takes six colors as arguments, so you will be able to
create both the winter and autumn quilts with the same function, just supplying different
sets of colors.
In this problem, having a partner is optional, but is strongly recommended.
The CS1 Etsy shop wants to expand the items offered on their site. Quilts would be an
item that could generate a lot of revenue. Below is an example of one of the CS1 Etsy
quilt designs, which we will call winter quilt.Another example is the following, which we will call the autumn quilt:
You and several other CS1 students have been hired as interns at the CS1 Etsy shop to
help design quilts. Your project is to use pictures to generate the quilt designs shown
above. You'll notice that the quilts are the same except for the color scheme.These quilts are just two sample of the quilt design. In your code, you will write functions
that will take color parameters, and therefore can generate lots of different quilts, in the
same pattern as above, but with color variation.
The picture.py module, which contains picture functions you have learned about in
Lecture 05 and Lab 04, is provided in the ps04 folder. You may use the functions
defined in that module to help create your quilts. All the functions that you will define for
this problem will be in a file that you will create called ps04Quilt.py.
Your goal is to write a quilt function that takes several color parameters and returns a
picture corresponding to the quilt shown above when quilt is invoked with appropriate
colors. This picture is ultimately generated by combining primitive pictures created by
the following two functions that you have already seen in class. They can be found in
the picture.py file:
patch (c):
"""Returns a rectangular patch of color c with a
black border that fills a given picture frame.
"""
triangles(c1,c2):
"""Returns a picture that consists of two triangles filling the
given picture frame: a black-bordered triangle of color c1
in the lower left corner of the frame; and a black-bordered
triangle of color c2 in the upper right corner of the frame.
"""
For example, below are the pictures generated by some sample invocations of these
functions:
patch('red') triangles('red', 'blue')Divide, Conquer, and Glue
The key to solving the problem of defining the quilt function is to note that the picture
it returns can be decomposed into smaller pictures that are used more than once in the
larger picture. For example, by wishful thinking we can image that the upper right
quadrant is a picture returned by a function we'll call block:
block('navy', 'lightskyblue', 'darkseagreen', 'papayawhip', 'plum', 'orchid')
The block is clearly decomposable into subquadrants of two kinds, which we've
dubbed rose and diamond. Here are two roses:rose('darkseagreen','papayawhip) rose('navy','lightskyblue')
Here are two examples of the pattern we called diamond:
diamond('plum',
'orchid','darkseagreen')
diamond('navy',
'lightskyblue','darkseagreen')Implement each of these, then combine these subproblem solutions to solve the whole
quilt. How to solve these? Each of these patterns can be broken down into quadrants
and those subproblems solved and combined with operations like rotation to solve the
pattern.
This is an excellent illustration of the divide, conquer, and glue problem solving strategy
we will use throughout this course:
1. Divide the problem into subproblems. Here, the whole quilt problem can be
solved if we can solve the problem of generating the pictures in the different
quadrants and sub-quadrants.
2. Conquer the subproblems by solving them. In this case, you'll want to solve
subproblems like rose and diamond that will help solve the whole problem.
3. Glue the solutions to the subproblems together to form the solution to the whole
problem. Here, we combine four rotated versions of the picture returned by block
to construct the picture returned by quilt.
But how do we solve the problems of defining the rose and diamond functions? By
applying the divide, conquer, and glue strategy again! Of course, all of these functions
will take appropriate color parameters.
Continue this way, decomposing each problem into smaller subproblems, until you
reach problems that can be solved using our primitives (e.g., patch and triangles).
For an example of this sort of decomposition, see the quilt example from Lecture 05.
Starting the Assignment
Begin by creating a file named ps04Quilt.py. As usual, your file must start with
comments at the top, identifying the author(s), username(s), problem set and task
number, filename, and date. Follow this format:# Your name:
# Your username:
# Your partner's name (if applicable):
# Your partner's username (if applicable):
# CS111 PSO4, Task 3
# ps04Quilt.py
# Submitted:
Remember to include the line:
from picture import *
at the top of your file, so that all of the functions in the picture.py file are available to
you.
Then use incremental programming to make progress on your quilt. That is, make
approximations to your quilt picture or parts of your quilt picture and use displayPic
to display these pictures along the way.
You can work in one of two directions:
1. In the bottom-up strategy, you start with smaller helper functions, like those
defined in the Helper Functions section below, and build up pictures of
increasing complexity, including rose and diamond, until you have correctly
defined the full quilt picture.
2. In the top-down strategy, you start by defining the quilt function in terms of the
block function or the rose and diamond functions. But those are complicated,
so you might put off the diamond subproblem while you work on the rose
subproblem. So for testing purposes, you instead provide a so-called stub
picture for the diamond function. For example, as a very crude approximation,
you might define an initial version of the diamond function that returns the result
of calling triangles on two of its parameters. You can then test quilt with this
approximation. Then you continue the top-down descent by defininginitially-crude-approximations for functions that return the quadrants of the block
picture. You continue this top down process until you reach pictures that are
correctly implemented by patch and triangles, at which point you now have
the correct quilt function rather than just an approximation.
Colors and Parameters
There are exactly six colors used in the Winter quilt and a different six colors in the
Autumn quilt. All of the colors for the Winter quilt are listed in the examples above. The
Autumn quilt uses the colors in the following examples:
rose('red','gold')
rose('darkred','coral')
diamond('darkred','coral','red')
diamond('darkorange','bisque','red')
Your top-level quilt function will take six colors as arguments and return the
appropriate quilt. You get to choose the order of the six color parameters.
However, you must define zero-argument functions winterQuilt and autumnQuilt
that return the result of calling the quilt function on six appropriate color arguments.
def winterQuilt():
'''Returns the first quilt with the blue-green-purple theme'''
return quilt( ... six color arguments go here ... )
def autumnQuilt():
'''Returns the second with the red-orange-yellow theme'''
return quilt( ... six color arguments go here ... )
The quilt pictures returned by these functions should match the ones depicted at the
beginning of this task. Codder will test the results of these two functions.
Note: Ideally, color parameters should have meaningful names, but with functions like
quilt and block that take lots of (six) color parameters, it's challenging to design
such names. In our solution, the main quilt function takes six parameters, which wenamed c1, c2, ... c6. Then in the various subfunctions, which take fewer colors,
we didn't want to use the same numbers, because it might be confusing. If we think of
c1 as navy for example, we don't want to use c1 in another function where it might
mean plum. So some functions have arguments named cx, cy and cz. Of course,
Python doesn't care what we call our parameters, and we can use the same parameter
names in several different functions. But remember that programs are written for
humans to read and only incidentally for computers to execute. Even reading our own
code, we want to keep names clear in our minds.
Helper Functions
As we have seen, a general principle of computer science is Don't Repeat Yourself
(DRY), which means you should avoid writing the same pattern of code more than once.
If you find yourself writing the same or similar code more than once in your program,
you should write functions that capture the patterns of the repeated code and invoke the
functions instead.
The divide, conquer, and glue process of defining quilt naturally exposes the need for
numerous auxiliary functions. Above, we have seen the block, rose, and diamond
functions, which you must define. As part of working on this task, you must also define
and use the following helper functions:
def bandana(c1, c2):
"""Returns a 2x2 picture with solid c1-colored patches in the lower left
and upper right quadrants, and triangles(c1, c2) in the upper left
and lower right quadrants."""
def lowerLeft(p):
"""Returns a picture which divides the picture space into four
quadrants and places the given picture in the lower left quadrant.
Nothing is in the other quadrants."""
def lowerLeftNest(p1, p2):
"""Returns a picture in which picture p2 is placed in the the lower left
quadrant of picture p1."""def lowerLeftNestSelf4(p):
"""Returns a picture that has four copies of picture p: one full size one,
and three successively smaller versions descending in the
lower left quadrant."""
Here is an example invocation of bandana:
bandana('red', 'blue')
Note that the lowerLeft, lowerLeftNest, and lowerLeftNestSelf4 functions
take pictures as arguments, not colors. To illustrate these helper functions, suppose that
pictures picP1 and picP2 are defined as:
picP1 picP2
Then here are examples of calling the lowerLeft, lowerLeftNest, and
lowerLeftNestSelf4 functions with these pictures:lowerLeft(picP1) lowerLeftNest(picP1,
picP2)
lowerLeftNestSelf4(picP2)
Notes:
● In this problem, you should not use any conditional statements.
● In this problem, you should use functions from PictureWorld (like fourPics,
rotations, and clockwise90). You should not directly create any
cs1graphics objects (such as layers), nor should you use any cs1graphics
methods (such as .clone, .rotate, .scale, and .moveTo).
● You must define the following functions in your program: bandana,
lowerLeft, lowerLeftNest, lowerLeftNestSelf4, rose,
diamond, block, quilt, winterQuilt, autumnQuilt. Additionally,
you should define one or more other functions that help you abstract over other
patterns.
● You can use lowerLeftNestSelf4 in conjunction with triangles to create
one of the patterns that appears in the quilt:lowerLeftNestSelf4(triangles('darkslateblue', 'navy'))
● Stepping back, your high-level goal in this problem is not only to generate the
correct quilt picture, but to do so in a way that takes advantage of the power of
abstraction to eliminate unnecessary repeated patterns in your code to make it
as simple and elegant as possible. You want solution code that has the same
level of abstraction and elegance as the code in Lecture 05 quilt.
Testing
As you implement the above required helper functions and your own helper functions,
you'll want to test them! You should put the following testing code at the end of
ps04Quilt.py:
# ------------------------- Testing -----------------------
if __name__ == "__main__":
'''All code that displays pictures or prints output should be nested
within this special "main" header at the end of ps04Quilt.py
'''
closeAllPics() # Use this to close all previously created pictures.
# Uncomment particular lines below to test your code.
# Add more test cases for functions that you define!
#displayPic(bandana('red', 'blue'))
#displayPic(lowerLeft(triangles('red', 'blue')))
#displayPic(lowerLeftNest(patch('red'), triangles('red', 'blue')))#displayPic(lowerLeftNestSelf4(triangles('navy', 'lightskyblue')))
## Roses
#displayPic(rose('navy', 'lightskyblue'))
#displayPic(rose('darkseagreen', 'papayawhip'))
#displayPic(rose('red','gold'))
#displayPic(rose('darkred','coral'))
## Diamonds
#displayPic(diamond('plum', 'orchid', 'darkseagreen'))
#displayPic(diamond('navy', 'lightskyblue', 'darkseagreen'))
#displayPic(diamond('darkred','coral','red'))
#displayPic(diamond('darkorange','bisque','red'))
## Blocks
#displayPic(block('navy', 'lightskyblue', 'darkseagreen',
# 'papayawhip', 'plum', 'orchid'))
## Quilts
#displayPic(winterQuilt())
#displayPic(autumnQuilt())
# Extra invocations to displayPic to fix picture glitch
# (a simple picture is sometimes needed to have previous pictures display)
displayPic(patch('red'))
displayPic(patch('blue'))
Recall that in order to see your pictures, you'll need to to invoke displayPic with an
argument which corresponds to the picture you want to display. As indicated in the
above code, you should put all invocations of displayPic at the very end of
ps04Quilt.py indented within the special header if __name__ == "__main__":
Notes:
● There is a glitch that sometimes happens with pictures as follows: a complex
picture may not display unless one or two simple pictures are displayed
afterwards. To play it safe, it is wise to always display two simple pictures after a
complex one, like this:
displayPic(complex picture here) # this is the one you want to see
displayPic(patch('red')) # 1st simple picture here
displayPic(patch('blue')) # 2nd simple picture here● The closeAllPics() function call closes all previously created pictures. The
above testing code calls this first so you will only see the pictures from clicking
the Run button, and not pictures from previous Runs.
Completing the Assignment
You should define all the helper functions specified above. In addition to that, you
should define other functions that capture other patterns that appear in the quilt. It is
also helpful to define local variables within your functions to give names to pictures that
you generate as part of your solution.
Each of your functions should be short: no more than a few statements long (say 7 or
8). If you find yourself defining a longer function, consider how you can break it up into
smaller parts (preferably in a way that permits one or more of the smaller functions to be
used multiple times).
Both Quilts
Remember that your quilt function takes six colors as arguments, so you will be able to
create both the winter and autumn quilts with the same function, just supplying different
sets of colors.