练习4-2

写一组合适的通用函数，用来画出下图所示的花朵图案。

这个是搬运过来的，代码如下：

from swampy.TurtleWorld import *

from math import *

def polyline(t,n,length,angle):

for i in range(n):

fd(t,length)

lt(t,angle)

def arc(t,r,angle):

arc_length = 2 * pi * r * abs(angle) /360

n = int(arc_length/4) + 1

step_length = arc_length / n

step_angle = float(angle) / n

lt(t,step_angle/2)

polyline(t,n,step_length,step_angle)

rt(t,step_angle/2)

def petal(t,r,angle):

for i in range(2):

arc(t,r,angle)

lt(t,180-angle)

def flower(t,n,r,angle):

for i in range(n):

petal(t,r,angle)

lt(t,360.0/n)

def move(t,length):

pu(t)

fd(t,length)

pd(t)

world = TurtleWorld()

bob = Turtle()

bob.delay = 0.01

move(bob,-100)

flower(bob,7,60.0,60.0)

move(bob,100)

flower(bob,10,40.0,80.0)

move(bob,100)

flower(bob,20,140.0,20.0)

die(bob)

world.canvas.dump()

wait_for_user()                  运行结果如下图所示：

由于对画图不是很感兴趣，感觉实习以后用不着，没花心思做，下面的代码还是搬运来的。

4-3 写一组合适的通用函数，用来画出下图所示的图形。

代码如下：

from math import *

from swampy.TurtleWorld import *

def draw_pie(t,n,r):

polypie(t,n,r)

pu(t)

fd(t,r*2+10)

pd(t)

def polypie(t,n,r):

angle = 360.0/n

for i in range(n):

isosceles(t,r,angle/2)

lt(t,angle)

def isosceles(t,r,angle):

y = r*sin(angle*pi/180)

rt(t,angle)

fd(t,r)

lt(t,90+angle)

fd(t,2*y)

lt(t,90+angle)

fd(t,r)

lt(t,180-angle)

world = TurtleWorld()

bob = Turtle()

bob.delay = 0

pu(bob)

bk(bob,130)

pd(bob)

size = 40

draw_pie(bob,5,size)

draw_pie(bob,6,size)

draw_pie(bob,7,size)

draw_pie(bob,8,size)

die(bob)

world.canvas.dump()

wait_for_user()                运行结果如下：

4-4 字母表中的字母可以使用一些基本元素来构成。如横线，竖线以及一些曲线。设计一个字体，可以使用最少的基本元素画出来，并编写函数来画出字母表中的所有的字母。

你应当给每个字母单独写一个函数，名为 draw_a,draw_b 等，并把这些函数放到letters.py文件中。可以从http://thinkpython.com/code/typewriter.py下载一个“乌龟打字机”来帮助测试你的代码。

letters.py代码如下 ：

from swampy.TurtleWorld import *

from polygon import *

#level 0 primitives are provided by World.py

#They include fd,bk,lt,rt,pu and pd

#level 1 primitives are simple combinations of level 0 primitives

#They have no pre-or post-conditions

def fdlt(t,n,angle = 90):

"""forward and left"""

fd(t,n)

lt(t,angle)

def fdbk(t,n):

"""forward and back,ending at the original position"""

fd(t,n)

bk(t,n)

def skip(t,n):

"""lift the open and move"""

pu(t)

fd(t,n)

pd(t)

def stump(t,n,angle=90):

"""make a vertical line and leave the turtle at the top

facing right

"""

lt(t)

fd(t,n)

rt(t,angle)

def hollow(t,n):

"""move the turtle vertically and leave it at the top,

facing right"""

lt(t)

skip(t,n)

rt(t)

#level 2 primitives use primitives from level0 and 1

#to draw posts(vertical elements) and beams(horizontal elements)

#level 2 primitives always return the turtle to the original

#location and direction

def post(t,n):

"""make a vertical line and return to the original position"""

lt(t)

fdbk(t,n)

rt(t)

def beam(t,n,height):

"""make a horizontal line at the given height and return """

hollow (t,n*height)

fdbk(t,n)

hollow(t,-n*height)

def hangman(t,n,height):

"""make a vertical line to the given height and a horizontal line

at the given height and then return .

This is efficient to implement,and turns out to be useful,but

it is not so semantically clean."""

stump(t,n*height)

fdbk(t,n)

lt(t)

bk(t,n*height)

rt(t)

def diagonal(t,x,y):

"""make a diagonal line to the given x,y offsets and return"""

from math import atan2,sqrt,pi

angle = atan2(y,x)*180/pi

dist = sqrt(x**2+y**2)

lt(t,angle)

fdbk(t,dist)

rt(t,angle)

def vshape(t,n,height):

diagonal(t,-n/2,height*n)

diagonal(t,n/2,height*n)

def bump(t,n,height):

"""make a bump with radius n at height*n """

stump(t,n*height)

arc(t,n/2.0,180)

lt(t)

fdlt(t,n*height+n)

"""

The letter-drawing functions all have the precondtion

that the turtle is in the lower-left corner of the letter,

and postcondition that the turtle is in the lower-right

corner,facing in the direction it started in.

They all take a turtle as the first argument and a size(n)

as the second.Most letters are(n) units wide and(2n) units high

"""

def draw_a(t,n):

diagonal(t,n/2,2*n)

beam(t,n,1)

skip(t,n)

diagonal(t,-n/2,2*n)

def draw_b(t,n):

bump(t,n,1)

bump(t,n,0)

skip(t,n/2)

def draw_c(t,n):

hangman(t,n/2)

fd(t,n)

def draw_d(t,n):

bump(t,2*n,0)

skip(t,n)

def draw_ef(t,n):

hangman(t,n,2)

hangman(t,n,1)

def draw_e(t,n):

draw_ef(t,n)

fd(t,n)

def draw_f(t,n):

draw_ef(t,n)

skip(t,n)

def draw_g(t,n):

hangman(t,n,2)

fd(t,n/2)

beam(t,n/2,2)

fd(t,n/2)

post(t,n)

def draw_h(t,n):

post(t,2*n)

hangman(t,n,1)

skip(t,n)

post(t,2*n)

def draw_i(t,n):

beam(t,n/2)

fd(t,n/2)

post(t,2*n)

fd(t,n/2)

def draw_j(t,n):

beam(t,n,2)

arc(t,n/2,90)

fd(t,3*n/2)

skip(t,-2*n)

rt(t)

skip(t,n/2)

def draw_k(t,n):

post(t,2*n)

stump(t,n,180)

vshape(t,2*n,0.5)

fdlt(t,n)

skip(t,n)

def draw_l(t,n):

post(t,2*n)

fd(t,n)

def draw_n(t,n):

post(t,2*n)

skip(t,n)

diagonal(t,-n,2*n)

post(t,2*n)

def draw_m(t,n):

post(t,2*n)

draw_v(t,n)

post(t,2*n)

def draw_o(t,n):

skip(t,n)

circle(t,n)

skip(t,n)

def draw_p(t,n):

bump(t,n,1)

skip(t,n/2)

def draw_q(t,n):

draw_o(t,n)

diagonal(t,-n/2,n)

def draw_r(t,n):

draw_p(t,n)

diagonal(t,-n/2,n)

def draw_s(t,n):

fd(t,n/2)

arc(t,n/2,180)

arc(t,n/2,-180)

fdlt(t,n/2,-90)

skip(t,2*n)

lt(t)

def draw_t(t,n):

beam(t,n,2)

skip(t,n/2)

post(t,2*n)

skip(t,n/2)

def draw_u(t,n):

post(t,2*n)

fd(t,n)

post(t,2*n)

def draw_v(t,n):

skip(t,n/2)

vshape(t,n,2)

skip(t,n/2)

def draw_w(t,n):

draw_v(t,n)

draw_v(t,n)

def draw_x(t,n):

diagonal(t,n,2*n)

skip(t,n)

diagonal(t,-n,2*n)

def draw_y(t,n):

skip(t,n/2)

stump(t,n)

vshape(t,n,1)

rt(t)

fdlt(t,n)

skip(t,n/2)

def draw_z(t,n):

beam(t,n,2)

diagonal(t,n,2*n)

fd(t,n)

def draw_(t,n):

#draw a space

skip(t,n)

if _name_ == '_main_':

world = TurtleWorld()

#create and position the turtle

size = 20

bob = Turtle()

bob.delay = 0.01

for f in [draw_h,draw_e,draw_l,draw_o]:

f(bob,size)

skip(bob,size)

wait_for_user()