Python Turtle.shape方法代码示例

# 需要导入模块: from turtle import Turtle [as 别名]
# 或者: from turtle.Turtle import shape [as 别名]
def main():
	# creating a window
	window = Screen()
	# window.bgcolor("orange")

	remo = Turtle()
	remo.shape("turtle")
	remo.color("green")
	remo.speed(50)

	for i in range(36):
		remo.circle(100)
		remo.left(10)

	remo.color("red")

	for i in range(36):
		remo.circle(80)
		remo.left(10)

	remo.color("yellow")

	for i in range(36):
		remo.circle(60)
		remo.left(10)


	window.exitonclick()

# 需要导入模块: from turtle import Turtle [as 别名]
# 或者: from turtle.Turtle import shape [as 别名]
class Lampe():
	lyser = False
	turtle = None


	def lag_skilpadde(self):
		""" Lager en egen skilpadde for denne lamen."""
		self.turtle = Turtle()
		self.turtle.penup()
		self.turtle.hideturtle()

		# Gult lys når vi lyser.
		self.turtle.shape('circle')
		self.turtle.color('yellow')
		self.turtle.shapesize(5)



	def slaa_paa(self):
		self.lyser = True
		self.turtle.showturtle()


	def slaa_av(self):
		self.lyser = False
		self.turtle.hideturtle()

# 需要导入模块: from turtle import Turtle [as 别名]
# 或者: from turtle.Turtle import shape [as 别名]
def add_turtle(name):
    t = Turtle()
    t.speed('fast')
    #t.penup()
    t.shape(turtle_shapes[len(turtles) % len(turtle_shapes)])
    turtles[name] = t
    t.setheading(90)  # Point up
    return t

# 需要导入模块: from turtle import Turtle [as 别名]
# 或者: from turtle.Turtle import shape [as 别名]
 def placeTurtle(self,x,y):
     newT = Turtle()
     newTscreen = newT.getscreen()
     newTscreen.tracer(0)
     newT.up()
     newT.goto(x,y)
     newT.shape('turtle')
     newT.setheading(random.randint(1,359))
     newTscreen.tracer(1)
     self.numTurtles = self.numTurtles + 1
     self.turtleList.append(newT)
     if self.numTurtles >= self.maxTurtles:
         self.bigTscreen.onclick(None)

# 需要导入模块: from turtle import Turtle [as 别名]
# 或者: from turtle.Turtle import shape [as 别名]
def draw_art():
    window = Screen()
    window.bgcolor('cyan')
    angie = Turtle()
    angie.shape('turtle')
    angie.color('blue')
    angie.speed(2000)

  #  angie.left(105)
    for j in range(80):
        angie.right(5)
        draw_rhombus(angie, 100)

    angie.left(90)
    angie.forward(300)

    # Close window
    window.exitonclick()

# 需要导入模块: from turtle import Turtle [as 别名]
# 或者: from turtle.Turtle import shape [as 别名]
class TurtlePlace:
    def __init__(self,maxTurtles,hWall=200,vWall=200):
        self.bigT = Turtle()
        self.bigTscreen = self.bigT.getscreen()
        self.bigT.shape('turtle')
        self.turtleList = []
        self.bigTscreen.onclick(self.placeTurtle)
        self.bigT.hideturtle()
        self.numTurtles = 0
        self.maxTurtles = maxTurtles
        self.hWall = hWall
        self.vWall = vWall
        self.drawField(hWall,vWall)
        mainloop()

    def placeTurtle(self,x,y):
        newT = AnimatedTurtle(self.hWall,self.vWall)
        newTscreen = newT.getscreen()
        newTscreen.tracer(0)
        newT.up()
        newT.goto(x,y)
        newT.shape('turtle')
        newT.setheading(random.randint(1,359))
        newTscreen.tracer(1)
        self.numTurtles = self.numTurtles + 1
        self.turtleList.append(newT)
        if self.numTurtles >= self.maxTurtles:
            self.bigTscreen.onclick(None)

    def drawField(self,hWall,vWall):
        self.bigTscreen.tracer(0)
        self.bigT.up()
        self.bigT.goto(-hWall,-vWall)
        self.bigT.down()
        for i in range(4):
            self.bigT.forward(2*hWall)
            self.bigT.left(90)
        self.bigTscreen.tracer(1)

# 需要导入模块: from turtle import Turtle [as 别名]
# 或者: from turtle.Turtle import shape [as 别名]
#!/usr/bin/python
# coding: utf-8

from turtle import Screen
from turtle import Turtle

s = Screen()
s.bgcolor('black')

ikea_lys = Turtle()
bestemors_lys = Turtle()

ikea_lys.shape('circle')
ikea_lys.color('black')
ikea_lys.shapesize(3)
bestemors_lys.shape('circle')
bestemors_lys.color('black')
bestemors_lys.shapesize(3)

class Lampe():
	lyser = False
	turtle = None


	def lag_skilpadde(self):
		""" Lager en egen skilpadde for denne lamen."""
		self.turtle = Turtle()
		self.turtle.penup()
		self.turtle.hideturtle()

		# Gult lys når vi lyser.

# 需要导入模块: from turtle import Turtle [as 别名]
# 或者: from turtle.Turtle import shape [as 别名]
class ParsonTurtle(Turtle):
  def __init__(self):
    self._turtle = Turtle()
    self._turtle.shape('turtle')
    self._commands = []

  def forward(self, dist, log=True):
    self._turtle.forward(dist)
    if log:
      self._commands.append("fwd" + str(dist))
  def fd(self, dist, log=True):
    return self.forward(dist, log=log)


  def backward(self, dist, log=True):
    self._turtle.backward(dist)
    if log:
      self._commands.append("bwd" + str(dist))
  def back(self, dist, log=True):
    return self.backward(dist, log=log)
  def bk(self, dist, log=True):
    return self.backward(dist, log=log)

  def left(self, angle, log=True):
    self._turtle.left(angle)
    if log:
      self._commands.append("lt" + str(angle))
  def lt(self, angle, log=True):
    return self.left(angle, log=log)

  def right(self, angle, log=True):
    self._turtle.right(angle)
    if log:
      self._commands.append("rt" + str(angle))
  def rt(self, angle, log=True):
    return self.right(angle, log=log)

  def goto(self, nx, ny, log=True):
    self._turtle.goto(nx, ny)
    if log:
      self._commands.append("gt" + str(nx) + "-" + str(ny))

  def setposition(self, nx, ny, log=True):
    self._turtle.setposition(nx, ny)
    if log:
      self._commands.append("setpos" + str(nx) + "-" + str(ny))
  def setpos(self, nx, ny, log=True):
    return self.setposition(nx, ny, log=log)

  def setx(self, nx, log=True):
    self._turtle.setx(nx)
    if log:
      self._commands.append("setx" + str(nx))

  def sety(self, ny, log=True):
    self._turtle.sety(ny)
    if log:
      self._commands.append("sety" + str(ny))

  def dot(self, size, color, log=True):
    self._turtle.dot(size, color)
    if log:
      self._commands.append("dot" + str(size) + "-" + str(color))

  def circle(self, radius, extent, log=True):
    self._turtle.circle(radius, extent)
    if log:
      self._commands.append("circle" + str(radius) + "-" + str(extent))

  def up(self, log=True):
    self._turtle.up()
    if log:
      self._commands.append("up")
  def penup(self, log=True):
    return self.up(log=log)
  def pu(self, log=True):
    return self.up(log=log)

  def down(self, log=True):
    self._turtle.down()
    if log:
      self._commands.append("down")
  def pendown(self, log=True):
    return self.down(log=log)
  def pd(self, log=True):
    return self.down(log=log)

  def speed(self, spd):
    self._turtle.speed(spd)

  def _logColorChange(self, command, color, green, blue):
    if blue is not None:
      self._commands.append("%s(%d, %d, %d)"%(command, color, green, blue))
    else:
      self._commands.append("%s(%s)"%(command, color))

  def pencolor(self, color, green=None, blue=None, log=True):
    if blue is not None:
      self._turtle.pencolor(color, green, blue)
    else:
#.........这里部分代码省略.........

# 需要导入模块: from turtle import Turtle [as 别名]
# 或者: from turtle.Turtle import shape [as 别名]
class Material(object):
    def __init__(self):
        self.gods_hand = Turtle()
        self.gods_hand.hideturtle()
        self.gods_hand.speed(0)
        
    def draw_line(self):
        self.gods_hand.penup()
        self.gods_hand.tracer(0, 0)
        self.gods_hand.goto(100, 100)
        self.gods_hand.pendown()
        self.gods_hand.fill(True)
        self.gods_hand.setheading(0)
        self.gods_hand.forward(50)
        self.gods_hand.setheading(90)
        self.gods_hand.forward(50)
        self.gods_hand.setheading(180)
        self.gods_hand.forward(50)
        self.gods_hand.setheading(270)
        self.gods_hand.forward(50)
        self.gods_hand.fill(False)
        self.gods_hand.penup()
        self.gods_hand.goto(120, 120)
        self.gods_hand.pendown()
        self.gods_hand.pencolor("Blue")
        self.gods_hand.fillcolor("Blue")
        self.gods_hand.fill(True)
        self.gods_hand.setheading(0)
        self.gods_hand.forward(10)
        self.gods_hand.setheading(90)
        self.gods_hand.forward(10)
        self.gods_hand.setheading(180)
        self.gods_hand.forward(10)
        self.gods_hand.setheading(270)
        self.gods_hand.forward(10)
        
        self.gods_hand.fill(False)
        self.gods_hand.penup()
        self.gods_hand.tracer(1, 1)
        
    def build_box(self, pos_x, pos_y, length_x, length_y, do_fill, color):
        pos_x, pos_y = coordinate_converter((pos_x, pos_y))
        
        self.gods_hand.tracer(0, 0)
        
        self.gods_hand.penup()
        self.gods_hand.goto(pos_x, pos_y)
        self.gods_hand.pendown()
        
        if do_fill:
            self.gods_hand.fill(True)
            
        self.gods_hand.color(color)
            
        for x in range(4, 0, -1):
            heading = x * 90
            self.gods_hand.setheading(heading)    
            self.gods_hand.forward(length_x)
        
        if do_fill:
            self.gods_hand.fill(False)
        
        self.gods_hand.tracer(1, 1)
                 
    def draw_human(self, pos_x, pos_y):
        self.gods_hand.tracer(0, 0)
        self.gods_hand.penup()
        self.gods_hand.goto(pos_x, pos_y)
        self.gods_hand.color("blue")
        self.gods_hand.shape("circle")
        self.gods_hand.shapesize(0, 0, 5)
        stampid = self.gods_hand.stamp()
        self.gods_hand.color("black")
        self.gods_hand.tracer(1, 1)
        return stampid
        
    def erase_human(self, stampid):
        self.gods_hand.clearstamp(stampid)

# 需要导入模块: from turtle import Turtle [as 别名]
# 或者: from turtle.Turtle import shape [as 别名]
class Drawing():

    def __init__(self):
        """
        This drawing class is for practicing drawing simple or even geometrical 
        pictures with turtle module.
        Let's apply this method with easy examples.
        gb = turtle.Turtle() ; gb.rigth, left, forward, backward, circle, shape, 
        shapesize, penup, pendown, home, clear
        You can get a lot of detail information by googling 'python turtle'.
        """
        self.gb = Turtle()
        self.gb.shape('turtle')
        self.gb.speed(6)
        #self.screen = self.gb.getscreen()
        #w = 150
        #self.screen.setworldcoordinates(-w,-w,w,w)
        print 'A cute turtle is ready to draw!'
    def swirl(self,shape='turtle',speed=0):
        self.gb.shape(shape)
        self.gb.speed(speed)
        self.gb.color('black')
        for i in range(500):
            self.gb.forward(i)
            self.gb.right(98)

    def color_swirl(self,shape='turtle',speed=0):
        self.gb.shape(shape)
        self.gb.speed(speed)
        for i in range(500):
            color = colorsys.hsv_to_rgb(i/1000.0,1.0,1.0)
            self.gb.color(color)
            self.gb.forward(i)
            self.gb.right(98)

    def zigzag(self,shape='turtle',speed=0):
        self.gb.shape(shape)
        self.gb.speed(speed)
        for i in range(180):
            self.gb.forward(100)
            self.gb.right(30)
            self.gb.forward(20)
            self.gb.left(60)
            self.gb.forward(50)
            self.gb.right(30)
            self.gb.penup()
            self.gb.setposition(0,0)
            self.gb.pendown()
            self.gb.right(2)
            
    def square(self,shape='turtle',speed=0):
        self.gb.shape(shape)
        self.gb.speed(speed)
        for i in range(400):
            self.gb.forward(i)
            self.gb.left(90.5)

    def gohome(self):
        wiggle = [30,30,30,30]
        self.gb.shape('turtle')
        self.gb.speed(6)
        self.gb.clear()
        self.gb.penup()
        for tick in wiggle:
            self.gb.right(tick)
            self.gb.left(tick)
        self.gb.home()
        self.gb.clear()
        self.gb.pendown()
        self.gb.color('black')

# 需要导入模块: from turtle import Turtle [as 别名]
# 或者: from turtle.Turtle import shape [as 别名]
            games. Bear in mind that the simplicity of the turtle library hurts its performance
             considerabily. Therefore is is seen as a stepping stone to other more powerful low-level
              libraries such as openGl, Vulkan and DirectX12
    -------------------------------------- Jonas -------------------- """

from turtle import Turtle, Screen

# --- Create objects---
screen = Screen()
tut1 = Turtle()
tut2 = Turtle()

# --- INIT turtles ---
tut1.speed(1)
tut1.penup()
tut1.shape("circle")
tut1.shapesize(5)
tut1.color("red")

tut2.speed(1)
tut2.penup()
tut2.shape("square")
tut2.shapesize(5)
tut2.color("blue")

# --- ACTION ---
tut1.forward(100)
tut2.backward(100)

screen.mainloop()

# 需要导入模块: from turtle import Turtle [as 别名]
# 或者: from turtle.Turtle import shape [as 别名]
# Turtle Docs: https://docs.python.org/2.7/library/turtle.html
from turtle import Turtle, Screen

# Create two objects: a Turtle with the name cursor and a Screen called window
cursor = Turtle()
window = Screen()

# Set the window background color to black
window.bgcolor("black")

# Make the cursor ink white, the width of the pen 3, the shape a turtle, and 
# move at moderate speed
cursor.color("white")
cursor.width(3)
cursor.shape("turtle") # or "circle", "classic", etc.
cursor.speed(5) # 1 - 10


# Draw a square of side length 100 starting from the home position
cursor.home()
for i in range(4):
	print cursor.position()
	cursor.forward(100)
	cursor.right(90)
print cursor.position()

# Move the turtle to (0, 100) without drawing anything,
# then draw a pentagon
cursor.penup()
cursor.sety(100)
print cursor.position()

# 需要导入模块: from turtle import Turtle [as 别名]
# 或者: from turtle.Turtle import shape [as 别名]
	def setup():
		t = Turtle()
		t.reset
		t.shape("circle")
		t.delay(100)

# 需要导入模块: from turtle import Turtle [as 别名]
# 或者: from turtle.Turtle import shape [as 别名]
__author__ = 'dmytrol'
from turtle import Screen, Turtle
import math
import random

screen = Screen()
screen.bgcolor(0.9, 0.9, 0.5)

jack = Turtle()
jack.shape("turtle")


def draw_triangle(k):
    jack.color(random.random(), random.random(), random.random())
    h = math.sqrt(k * k + k * k)
    jack.begin_fill()
    jack.right(45)
    jack.forward(h)
    jack.right(135)
    jack.forward(k * 2)
    jack.right(135)
    jack.forward(h)
    jack.penup()
    jack.goto(0, 0)
    jack.right(45)
    jack.end_fill()
    screen.listen()


def draw_pine_tree():
    d = int(screen.textinput("Attention, please!",