Python turtle 模块，pendown() 实例源码

def draw(self):
        "draws the lsystem on the screen"
        stack = []
        tt.penup()
        tt.setpos(0, -200)
        tt.seth(90)
        tt.pendown()

        print "Drawing the lsystem ..."
        for i, codebit in enumerate(self.generation[-1]):

            if codebit in ['F', 'A', 'B']:
                tt.forward(self.length)
                print '[ FRWD ] ', codebit
            elif codebit == '+':
                tt.right(self.angle)
                print '[ RGHT ] ', codebit
            elif codebit == '-':
                tt.left(self.angle)
                print '[ LEFT ] ', codebit
            elif codebit == '[':
                stack.append((tt.pos(), tt.heading()))
                print '[ PUSH ] ', (tt.pos(), tt.heading())
            elif codebit == ']':
                position,heading = stack.pop()
                print '[ POP  ] ', (position, heading)
                tt.penup()
                tt.goto(position)
                tt.seth(heading)
                tt.pendown()
            else:
                print '[ NOP  ] ', codebit

            if self.save_every_frame:
                self.save(frame=i)

        print "Done drawing"
        print "Saving file as %s.jpg" % self.name,
        self.save()
        print "Done"

def draw_line(self, pos, horizontal=False, label=None,
                  color='gray90', label_color='gray35', **_):
        """Draw one horizontal or vertical line with optional color and label"""
        if pos is None:
            return
        if pos < self.zoom_area[0 + horizontal] or pos > self.zoom_area[2 + horizontal]:
            return
        turtle.penup()
        xscale = turtle.getscreen().xscale
        yscale = turtle.getscreen().yscale
        if label:
            font_family, font_size = self.font
            turtle.color(label_color)
            turtle.setposition(*self.label_pos(pos=pos, label=label, horizontal=horizontal))
            turtle.write(label, align='right' if horizontal else'center',
                         font=(font_family, font_size))
            turtle.setposition(-4 / xscale if horizontal else pos,
                               pos if horizontal else -4 / yscale)
            turtle.pendown()
        turtle.setposition(1 / xscale if horizontal else pos,
                           pos if horizontal else 1 / yscale)
        turtle.color(color)
        turtle.pendown()
        turtle.setposition(self.plot_area[2] if horizontal else pos,
                           pos if horizontal else self.plot_area[3])
        turtle.penup()

def plot_table(self, *gamma, colors=['red', 'green', 'blue'], draw_speed=16, scale_x=1):
        """Plot gamma table"""
        if len(gamma) == 1 and len(gamma[0]) == 3:
            gamma = gamma[0]
        if all(x == gamma[0] for x in gamma):
            gamma = gamma[:1]

        turtle.penup()
        turtle.tracer(0, 16)
        turtle.speed(0)
        turtle.color('black')
        for color, points_y in enumerate(gamma):
            if len(gamma) == len(colors):
                turtle.color(colors[color])
            elif len(colors) == 1:
                turtle.color(colors[0])
            for x, y in enumerate(points_y):
                trace = x and x % draw_speed == 0
                if trace:
                    turtle.tracer(1)
                turtle.setposition(x * scale_x, y)
                if trace:
                    turtle.tracer(0)
                if x == 0:
                    turtle.showturtle()
                    turtle.pendown()

            turtle.penup()
            turtle.hideturtle()
            turtle.update()

def Skip(step):
    turtle.penup()
    turtle.forward(step)
    turtle.pendown()

def zweig(laenge = 10, winkel=30, divisor=2):
    if laenge < 2:
        return
    turtle.forward(laenge)
    turtle.left(winkel)
    zweig(laenge//divisor, winkel, divisor)
    turtle.right(winkel*2)
    zweig(laenge//divisor, winkel, divisor)
    turtle.left(winkel)
    turtle.penup()
    turtle.forward(-laenge)
    turtle.pendown()

def draw_star(x, y, side):
    star_angle = 360.0/6
    left_angle = star_angle * 2
    tu.penup()
    tu.goto(x, y)
    tu.pendown()
    for i in range(6):
        tu.forward(side)
        tu.right(star_angle)
        tu.forward(side)
        tu.left(left_angle)

def tscheme_pendown():
    """Lower the pen, so that the turtle starts drawing."""
    _tscheme_prep()
    turtle.pendown()
    return okay

def tscheme_pendown():
    """Lower the pen, so that the turtle starts drawing."""
    _tscheme_prep()
    turtle.pendown()
    return okay

def tscheme_pendown():
    """Lower the pen, so that the turtle starts drawing."""
    _tscheme_prep()
    turtle.pendown()
    return okay

def draw_floor(floornum: int):
    global current_floor
    current_floor = floornum

    node_coords = utils.get_node_coords(utils.Direction.left) 

    if floornum == len(full_floors):
        rooms = []
        # All edges with rooms
        print('Showing everything')
        edges = chain.from_iterable(chain(((True, e) for e in edges[0]), ((False, e) for e in edges[1])) for _, edges in full_floors)
        # Edges with elevation changes
        #edges = set(chain.from_iterable((edge(v, n) for n in b.values() if set(['u', 'd']) & set(utils.get_graph().edgedata[edge(v, n)]['rooms'])) for v, b in enumerate(utils.get_graph().branches)))
        # All edges
        #...
    elif floornum >= 0 and floornum < len(full_floors):
        rooms, edges = full_floors[floornum]
        print(edges)
        edges = chain(((True, e) for e in edges[0]), ((False, e) for e in edges[1]))
        print(rooms)
    else:
        return

    turtle.showturtle()
    turtle.speed(0)
    turtle.clear()

    written_nodes = set()

    for edge_dir, (a, b) in edges:
        turtle.penup()
        x, y, _ = node_coords[a]
        turtle.goto(x / SHRINK + X_OFFSET, y / SHRINK + Y_OFFSET)
        if a not in written_nodes:
            turtle.write(a)
            written_nodes.add(a)

        turtle.pendown()

        if edge_dir:
            if edge_lengths[edge(a, b)] <= 0:
                turtle.pencolor('red')
            else:
                turtle.pencolor('black')
        else:
            if edge_lengths[edge(a, b)] <= 0:
                turtle.pencolor('blue')
            else:
                turtle.pencolor('green')

        x, y, _ = node_coords[b]
        turtle.goto(x / SHRINK + X_OFFSET, y / SHRINK + Y_OFFSET)
        turtle.pencolor('black')
        if b not in written_nodes:
            turtle.write(b)
            written_nodes.add(b)

    turtle.hideturtle()
    turtle.done()