海龜繪圖


大佬原文,建議看原文,copy 過來是防止大佬刪了文章

 

https://www.cnblogs.com/bravestarrhu/p/8287261.html

python之繪制圖形庫turtle
關於繪制圖形庫turtle
# 畫布上,默認有一個坐標原點為畫布中心的坐標軸(0,0),默認"standard"模式坐標原點上有一只面朝x軸正方向小烏龜

一:海龜箭頭Turtle相關方法
#############################
#       1.繪制的運動          #
#############################
a).移動和繪制
# turtle.forward(distance) | turtle.fd(distance)
# 畫筆向繪制方向的當前方向移動distance(integer or float)的pixels距離,
# 例如:
 turtle.fd(150)
# turtle.backward(distance) | turtle.back(distance) | turtle.bk(distance)
# 畫筆向繪制方向的相反方向移動distance(integer or float)的pixels距離
# 例如:
 turtle.backward(200)
# turtle.right(angle) | turtle.rt(angle)
# 繪制方向向右旋轉angle度
# 例如:
turtle.rt(45)
# turtle.left(angle) | turtle.lt(angle)
# 繪制方向向左旋轉angle度
# 例如:
turtle.lt(45)
# turtle.setpos(x, y=None) | turtle.setposition(x, y=None) | turtle.goto(x, y=None)
# 移動到絕對位置,如果畫筆按下,就畫線
# 參數x(a number or a pair/vector of numbers)
# 參數y(a number or None)
# 如果y為None,x必須是a pair of coordinates or a Vec2D
# 例如:
turtle.setpos((20,80)) 
turtle.setposition(120,20) 
turtle.goto(60,30)
# turtle.setx(x)
# y縱向坐標不變,更改x橫向坐標,x(integer or float)
# 例如:
turtle.setx(15)
# turtle.sety(y)
# x橫向坐標不變,更改y縱向坐標,y(integer or float)
# 例如:
turtle.sety(15)
# turtle.seth(to_angle) | turtle.setheading(to_angle)
# 將方向設置成to_angle.to_angle(integer or float)to_angle的值在不同模式下含義如下
"standard"模式逆時針       "logo"模式順時針
    0 - east                0 - north
    90 - north              90 - east
    180 - west              180 - south
    270 - south             270 - west
如下圖“standard”模式時(默認0時表示x方向向右即向東);“logo”模式時(默認0時表示y方向向上即向北)
                    y“logo”時
            ^
                    |
                    |
                    |
                (0,0)——————> x“standard”時
# 例如:
# “standard”模式時角度為逆時針,所以90度表示向北;logo”模式時角度為順時針,所以90度表示向東
turtle.setheading(90)
# turtle.home()
# 將位置和方向恢復到初始狀態,位置初始坐標為(0,0),方向初始為("standard"模式為right向右即東,"logo"模式是up向上即北)
# 例如:
turtle.home()
# turtle.circle(radius, extent=None, steps=None)
# 按給定的半徑畫圓,當前位置為圓的初始端點
    Parameters:
        radius(a number,圓半徑,為正數則逆時針畫,為負數則順時針畫,方向隨着軌跡的變化而變化)
        extent(a number or None,一個角度,決定哪部分圓圈被繪制,不提供extent表示畫完整的圓)
        steps(an integer or None,指定半徑radius前提下,完成extent的角度時,分了幾步,如畫正5邊形時turtle.circle(40, None, 5))
# 例如:
復制代碼
        turtle.home()
        # 當前位置(0,0)開始逆時針畫半徑為30的圓
        turtle.circle(30)
        # 逆時針畫半徑為50的半圓
        turtle.circle(50, 180)
        # 方向值為180,“standard”模式時方向向左,“logo”模式方向向下
        print(turtle.heading())
        turtle.circle(-50, 180)
        print(turtle.heading())
        # 逆時針方向半徑為40畫五邊形(5步畫接近整圓的圖形)
        turtle.circle(40, None, 5)    
復制代碼
# turtle.dot(size=None, *color)
# 按給定直徑size畫圓點(None[未提供時取pensize+42*pensize中的最大值] 或 >= 1的整數),color圓點顏色
# 例如:
復制代碼
        turtle.home()
        # 當前畫筆大小為1
        print(turtle.pensize())
        # 未提供取最大直徑值為pensize+4 = 5
        turtle.dot()
        turtle.fd(50)
        # 以直徑為5畫藍色圓點
        turtle.dot(5, "blue")
        turtle.fd(50)
        # 以直徑為20畫紅色圓點
        turtle.dot(20, "red")
        turtle.fd(50)
        print(turtle.position())
        print(turtle.heading())
復制代碼
# turtle.stamp()和turtle.clearstamp(stamp_id)和turtle.clearstamps(n=None)
# turtle.stamp()是在當前位置拷貝一份此時箭頭的形狀,返回一個stamp_id(int型),
# turtle.clearstamp(stamp_id)用來刪除指定stamp_id的箭頭形狀
# turtle.clearstamps(n=None),n為None時表示刪除所有拷貝的箭頭形狀;為0不刪除;n > 0 表示刪除前n個,n < 0 表示刪除后n個
# 例如:
復制代碼
        # 畫筆顏色設成紅色
        turtle.color("red")
        num = 0
        while num < 5:
            # 當前位置拷貝一份箭頭形狀
            stamp_id = turtle.stamp()
            turtle.fd(50)
            num += 1
        # 改變畫筆顏色為黑
        turtle.color("black")
        # 刪除拷貝的箭頭形狀(此處id最后一次復制的stamp_id)
        turtle.clearstamp(stamp_id)
        # 刪除前1個
        turtle.clearstamps(1)
        # 刪除后1個
        turtle.clearstamps(-1)
        # 全部刪除
        turtle.clearstamps()
        # 不刪除
        # turtle.clearstamps(0)
復制代碼
# turtle.undo()
# (每調用一次就)撤銷最后的一次動作,需要撤銷所有可通過while turtle.undobufferentries(),turtle.undobufferentries()返回當前可撤銷次數
# 例如:
        # 一直撤銷最后一個動作直到不可撤銷
        while turtle.undobufferentries():
            # 撤銷最后的一次動作
            turtle.undo()
# turtle.speed(speed=None)
    Parameters:
        peed為0-10的整數(1-10越來越快,0表示最快,參數為小數會被自動置為整數)或如下內置的速度字符串,如果>10或小於0.5則被置為0;為>=0.5的小數時被置為四舍五入的值。speed未設置則返回當前速度
# 內置的速度字符串:
    “fastest”: 0
    “fast”: 10
    “normal”: 6
    “slow”: 3
    “slowest”: 1
# 例如:
復制代碼
        # 速度為0,表示速度最快
        turtle.speed(0)
        # <0.5速度會被置為0,表示速度最快
        turtle.speed(0.4)
        # >10速度會被置為0,表示速度最快
        turtle.speed(20)
        # 速度字符串fastest,表示速度最快
        turtle.speed("fastest")
        # 速度最慢
        turtle.speed("slowest")
        # 速度為9
        turtle.speed(9)
復制代碼
b).獲取(海龜)箭頭的狀態
# position() | pos()
# 返回(海龜)箭頭當前位置坐標
# 例如:
        turtle.pos()
# turtle.towards(x, y=None)
# 返回(海龜)箭頭當前位置指向(x,y)位置連線的向量的角度(取決於當前模式,“standard”/”world”默認方向向右(即東)逆時針開始;“logo”模式默認方向向上(即北)順時針開始)
    Parameters:
        x:x可以是一個number或一個pair/vector of numbers或一個turtle instance
        y:x是一個number,y就是一個number;否則y為None
# 例如:
復制代碼
        turtle.goto(20, 20)
        # 移動后,位置為(20,20),兩個向量分別是(20,20)點到(0, 0)點的向量和(20, 20)點到箭頭當前方向的向量("standard"模式默認向右,逆時針算角度,"logo"模式默認向上,順時針算角度)
        angle = turtle.towards(0, 0)
        print("兩向量角度:", angle)
        # turtle.towards((0, 0), None)
        angle = turtle.towards((0, 0))
        print("兩向量角度:", angle)
        # turtle箭頭當前位置與turtle1箭頭當前位置連線的向量到turtle箭頭當前位置與turtle當前方向連線的向量角度
        turtle1 = turtle.Turtle()
        turtle1.setpos(0, 0)
        angle = turtle.towards(turtle1)
        # "standard"模式逆時針算角度,所以towards()后的角度angle是225,不是135
        print("兩向量角度:", angle)
復制代碼
# turtle.xcor() 和 turtle.ycor()
# turtle.xcor()是返回(海龜)箭頭的x坐標,turtle.ycor()是返回(海龜)箭頭的y坐標
# 例如:
復制代碼
        turtle.lt(50)
        turtle.fd(100)
        # 打印箭頭當前坐標(64.28,76.60)
        print(turtle.pos())
        # 原數據64.27876096865394,保留5位后打印64.27876
        print(round(turtle.xcor(), 5))
        # 原數據76.60444431189781,保留5位后打印76.60444
        print(round(turtle.ycor(), 5))
復制代碼
# turtle.heading()
# 返回當前箭頭方向角度,取決於當前模式mode,“standard”模式時默認方向向右逆時針計算角度;“logo”模式默認方向向上,順時針計算角度
# 例如:
見turtle.circle中的例子

# turtle.distance(x, y=None)
# 返回當前(海龜)箭頭坐標與坐標(x,y)間距離或當前(海龜)箭頭坐標與另一個(海龜)箭頭坐標間距離
    Parameters:
        x:x可以是一個number或一個pair/vector of numbers或一個turtle instance
        y:x是一個number,y就是一個number;否則y為None
# 例如:
復制代碼
        turtle.home()
        # 距離為50
        print(turtle.distance(30,40))
        # 距離為50
        print(turtle.distance((30,40)))
        joe = turtle.Turtle()
        joe.setpos(30, 40)
        # 距離為50
        print(turtle.distance(joe))
復制代碼
# c).設置與測量
# turtle.degrees(fullcircle=360.0) 和 turtle.radians()
# turtle.degrees表示設置一個完整圓的“度數”。默認值為360度,參數fullcircle(number類型),如果是360度時的90度,假如改成整圓為400度則此時角度應該是90/360*400
# turtle.radians()表示將一個完整圓的“度數”設置成2π,如果是360度時的90度則此時角度應該是90/360*(2π)
# 例如:
復制代碼
        turtle.home()
        turtle.left(90)
        # 輸出(360份里的90份)90.0
        print(turtle.heading())
        # 將一個完整圓的“度數”從360度改成400度
        turtle.degrees(400.0)
        # 輸出(400份里的100份)100.0
        print(turtle.heading())
        # 將一個完整圓的“度數”設置成360度
        turtle.degrees(360)
        # 輸出(360份里的90份)90.0
        print(turtle.heading())
        turtle.radians()
        # 輸出(2π份里的1.5707963267948966份)1.5707963267948966
        print(turtle.heading())
復制代碼
#############################
#       2.畫筆控制           #
#############################
# a).畫筆繪制狀態
# 舊方法 turtle.penup() | turtle.up() | turtle.pu()
# 畫筆抬起,此時移動不會進行繪制操作
# 例如:
        turtle.pu()
# 舊方法 turtle.pendown() | turtle.down() | turtle.pd()
# 畫筆按下,此時移動會進行繪制操作
# 例如:
        turtle.pd()
# turtle.width(width=None) | turtle.pensize(width=None)
# 設置或返回線的粗細(width=None時表示返回,不為None表示設置),注意如果resizemode設置成"auto"並且繪制的是多邊形,則多邊形繪制時使用相同的線條粗細
# 例如:
        # 設置線條粗細為5
        turtle.pensize(5)
        # 返回線條粗細為5
        turtle.pensize()
# turtle.pen(pen=None, **pendict)
# 設置或返回畫筆字典中對應的畫筆屬性(一個鍵值對)
    Parameters:
        (pendict)畫筆字典鍵值對如下
            “fillcolor”: color-string or color-tuple
            “outline”: positive number
            “pencolor”: color-string or color-tuple
            “pendown”: True/False
            “pensize”: positive number
            “resizemode”: “auto” or “user” or “noresize”
            “shearfactor”: number
            “shown”: True/False
            “speed”: number in range 0..10
            “stretchfactor”: (positive number, positive number)
            “tilt”: number
# 例如:
復制代碼
        # 打印{'shown': True, 'pendown': True, 'pencolor': 'black', 'fillcolor': 'black', 'pensize': 1, 'speed': 3, 'resizemode': 'noresize', 'stretchfactor': (1.0, 1.0), 'shearfactor': 0.0, 'outline': 1, 'tilt': 0.0}
        print(turtle.pen())
        turtle.pen(fillcolor="black", pencolor="red", pensize=10)
        # 打印排序后的為 [('fillcolor', 'black'), ('outline', 1), ('pencolor', 'red'), ('pendown', True), ('pensize', 10), ('resizemode', 'noresize'), ('shearfactor', 0.0), ('shown', True), ('speed', 3), ('stretchfactor', (1.0, 1.0)), ('tilt', 0.0)]
        print(sorted(turtle.pen().items()))
        turtle.fd(100)
        penstate=turtle.pen()
        turtle.pen(penstate, fillcolor="green")
復制代碼
# turtle.isdown()
# 獲取畫筆是否按下,按下返回True,否則返回False
# 例如:
復制代碼
        turtle.pu()
        # 打印False
        print(turtle.isdown())
        turtle.pd()
        # 打印True
        print(turtle.isdown())
復制代碼
# b).畫筆顏色控制
# turtle.pencolor(*args)
# 設置或返回畫筆顏色(設置后海龜箭頭的外輪廓也是這個顏色)
# 例如:
復制代碼
        # 返回畫筆顏色
        turtle.pencolor()
        # pencolor(colorstring)語法設置畫筆顏色
        turtle.pencolor("red")
        turtle.fd(50)
        # pencolor(colorstring)語法設置畫筆顏色
        turtle.pencolor("#33cc8c")
        turtle.fd(50)
        # pencolor(r, g, b)或pencolor((r, g, b))語法設置畫筆顏色,取決於顏色模式,colormode顏色模式取值1.0或255,colormode為1.0時r,g,b取值范圍0-1.0小數;colormode為255時r,g,b取值范圍0-255的整數
        turtle.getscreen().colormode(1.0)
        # 打印顏色模式為1.0
        print(turtle.getscreen().colormode())
        turtle.pencolor(0.1, 0.2, 0)
        turtle.fd(50)
        turtle.getscreen().colormode(255)
        # 打印顏色模式為255
        print(turtle.getscreen().colormode())
        turtle.pencolor(30, 210, 180)
        turtle.fd(50)
復制代碼
# turtle.fillcolor(*args)
# 返回或設置畫筆填充顏色(設置后海龜箭頭內部填充也是這個顏色)
# 用法同turtle.pencolor(*args)方法
# 例如:
復制代碼
        print(turtle.fillcolor())
        screen = turtle.getscreen()
        # pencolor(colorstring)語法設置畫筆顏色
        turtle.fillcolor("red")
        turtle.fd(50)
        # fillcolor(colorstring)語法設置畫筆顏色
        turtle.fillcolor("#33cc8c")
        turtle.fd(50)
        # fillcolor(r, g, b)fillcolor((r, g, b))語法設置畫筆顏色,取決於顏色模式,colormode顏色模式取值1.0或255,colormode為1.0時r,g,b取值范圍0-1.0小數;colormode為255時r,g,b取值范圍0-255的整數
        screen.colormode(1.0)
        # 打印顏色模式為1.0
        print(screen.colormode())
        turtle.fillcolor(0.1, 0.2, 0)
        turtle.fd(50)
        screen.colormode(255)
        # 打印顏色模式為255
        print(screen.colormode())
        turtle.fillcolor(30, 210, 180)
        turtle.fd(50)
復制代碼
# turtle.color(*args)
# 設置或返回pencolor和fillcolor
# 例如:
復制代碼
        # 返回pencolor和fillcolor  ('black','black')
        print(turtle.color())
        # color(colorstring)或color((r,g,b))或color(r,g,b)將pencolor和fillcolor都設置成紅色
        turtle.color("red")
        # 返回pencolor和fillcolor  ('red','red')
        print(turtle.color())
        # color(colorstring1, colorstring2)或color((r1,g1,b1), (r2,g2,b2))分別設置pencolor和fillcolor
        turtle.color("red", "yellow")
        # 返回pencolor和fillcolor  ('red','yellow')
        print(turtle.color())
        turtle.color("#285078", "#a0c8f0")
        # 返回pencolor和fillcolor ((0.1568627450980392, 0.3137254901960784, 0.47058823529411764), (0.6274509803921569, 0.7843137254901961, 0.9411764705882353))
        print(turtle.color())
復制代碼
# c).填充
# turtle.filling()返回填充狀態(填充狀態則返回True,否則返回False)、開始填充圖形之前先調用turtle.begin_fill()、填充完圖形后調用turtle.end_fill()
# 例如:
復制代碼
        # 返回False
        print(turtle.filling())
        # 繪制shape之前先准備開始fill
        turtle.begin_fill()
        # 返回True
        print(turtle.filling())
        turtle.circle(20, None, 6)
        # 繪制完shape之后結束fill
        turtle.end_fill()
        # 返回False
        print(turtle.filling())
復制代碼
# d).更多的繪制控制,注意screen其實是TurtleScreen對象的實例,使用screen時要先通過screen = turtle.getscreen()得到
# turtle.reset() | turtle.resetscreen() | screen.reset() | screen.resetscreen()
# 清屏並將畫筆位置和方向恢復到初始狀態,保持畫筆形狀不變,即位置恢復到原點(0, 0)位置,"standard"/"world"模式方向也恢復到默認的向右,"logo"模式方向恢復到默認的向上
# 例如:
        turtle.reset()
# turtle.clear() | turtle.clearscreen() | screen.clear() | screen.clearscreen()
# 清屏並且畫筆形狀也恢復默認,保持畫筆位置和方向不變
# 例如:
        turtle.clear()
# turtle.write(arg, move=False, align="left", font=("Arial", 8, "normal"))
    Parameters:
        arg – object to be written to the TurtleScreen  待繪制的文本
        move – True/False   設置是否繪制
        align – one of the strings “left”, “center” or right”設置文本下方初始位置
        font – a triple (fontname, fontsize, fonttype) 設置字體
# 繪制文本
# 例如:
        # 繪制文本“Home = ”,move為True表示畫筆從文本下邊align所在位置一直繪制到文本右下方,默認False不繪制
        turtle.write("Home = ", True, align="center")
        turtle.write((0,0), True)
#############################
#       3.繪制狀態           #
#############################
# a).顯示/隱藏
# turtle.hideturtle() | turtle.ht()
# 隱藏畫筆(即海龜箭頭),此時只要畫筆是按下狀態,雖然隱藏了但是還是能繪制圖形的,復雜的快速繪圖時效果顯著
# 例如:
        turtle.hideturtle()
# turtle.showturtle() | turtle.st()
# 顯示畫筆(即海龜箭頭)
# 例如:
        turtle.showturtle()
# turtle.isvisible()
# 返回(海龜)畫筆當前是否是可見狀態,可見返回True,否則返回False
# 例如:
復制代碼
        turtle.hideturtle()
        # 返回False
        print(turtle.isvisible())
        turtle.showturtle()
        # 返回True
        print(turtle.isvisible())
復制代碼
# b).外觀
# turtle.shape(name=None)
    Parameters:
        name – 形狀名,必須在TurtleScreen的形狀字典中,如(粗大箭頭1)“arrow”,(海龜箭頭) “turtle”, (實心圓箭頭)“circle”, (實心方形箭頭)“square”, (粗大箭頭2)“triangle”, 默認的箭頭“classic”
# 設置或返回(海龜)畫筆箭頭形狀名
# 例如:
        # 打印 'classic'
        print(turtle.shape())
        turtle.shape("turtle")
        # 打印 'turtle'
        print(turtle.shape())
# turtle.resizemode(rmode=None)
    Parameters:
        rmode – “auto”, “user”, “noresize”,3選1,具體說明如下
            “auto”: 此模式下(海龜)畫筆箭頭隨 pensize變化而變化.
            “user”: 此模式下(海龜)畫筆箭頭大小取決於【通過shapesize()進行設置的】.stretchfactor和outlinewidth (outline)的值
            “noresize”:此模式下(海龜)畫筆箭頭大小不變
# 設置或返回(海龜)畫筆箭頭大小的縮放模式

# turtle.shapesize(stretch_wid=None, stretch_len=None, outline=None) | turtle.turtlesize(stretch_wid=None, stretch_len=None, outline=None)
    Parameters:
        stretch_wid – positive number 與當前箭頭方向的垂直方向上的拉伸值
        stretch_len – positive number 與當前箭頭方向上的拉伸值
        outline – positive number shape輪廓寬度值
# 返回或設置畫筆x/y方向拉伸值和(或)shape輪廓寬度,僅當resizemode為“user”模式時有效
# 例如:
復制代碼
        # 設置外輪廓顏色為red,填充色為black
        turtle.pen(pencolor="red", fillcolor="black")
        # 返回, (1.0, 1.0, 1)表示垂直方向縮放到原來為1倍,水平方向縮放到原來1倍,外輪廓寬度1
        print(turtle.shapesize())
        # 設置resizemode為"user"模式
        turtle.resizemode("user")
        # 表示垂直方向縮放到原來為5倍,水平方向縮放到原來5倍,外輪廓寬度12
        turtle.shapesize(5, 5, 12)
        # 返回, (5, 5, 12)
        print(turtle.shapesize())
        # 設置輪廓寬度為8
        turtle.shapesize(outline=8)
        # 返回,(5, 5, 8)
        print(turtle.shapesize())
復制代碼
# turtle.shearfactor(shear=None)
    Parameters:
        shear – number (optional)
# 設置或返回剪切因子,
# 例如:
復制代碼
        # 箭頭改成圓形
        turtle.shape("circle")
        # 垂直縮放到5倍,水平縮放到2倍
        turtle.shapesize(5, 2)
        print(turtle.shearfactor())
        # 創建另一個(海龜)箭頭,和原來的拉開距離
        tl = turtle.Turtle()
        tl.pu()
        tl.fd(100)
        tl.pd()
        tl.shape("circle")
        # 垂直縮放到5倍,水平縮放到2倍
        tl.shapesize(5, 2)
        # 設置shearfactor為0.5
        tl.shearfactor(0.5)
        print(tl.shearfactor())
復制代碼
# turtle.tilt(angle)
    Parameters:
        angle – a number  箭頭圖標在現有角度基礎上再旋轉的角度,比如當前為45度,此基礎45度變成90度
# 保持箭頭方向不變的前提下,旋轉箭頭形狀
# 例如:
復制代碼
        # 清屏並恢復原始坐標位置(0,0)恢復默認方向向右
        turtle.reset()
        # 改變箭頭形狀為圓形
        turtle.shape("circle")
        # 垂直縮放到5倍,水平縮放到2倍
        turtle.shapesize(5, 2)
        # 保持方向向右,圓形箭頭圖標旋轉45度
        turtle.tilt(45)
        # 畫線
        turtle.fd(100)
        # 拷貝一份箭頭形狀
        turtle.stamp()
        # 保持方向向右,圓形箭頭圖標旋轉45度
        turtle.tilt(45)
        # 畫線
        turtle.fd(100)
復制代碼
# turtle.tiltangle(angle=None)
    Parameters:
        angle – a number 忽略箭頭現在的旋轉角度,旋轉到指定的角度數,比如當前為45度,忽略此時角度45,直接旋轉到45度
# 獲取或設置(保持箭頭方向不變的前提下,)旋轉箭頭形狀的角度
# 例如:
復制代碼
        # 清屏並恢復原始坐標位置(0,0)恢復默認方向向右
        turtle.reset()
        # 改變箭頭形狀為圓形
        turtle.shape("circle")
        # 垂直縮放到5倍,水平縮放到2倍
        turtle.shapesize(5, 2)
        # 保持方向向右,圓形箭頭圖標旋轉45度
        turtle.tilt(45)
        # 畫線
        turtle.fd(100)
        # 拷貝一份箭頭形狀
        turtle.stamp()
        # 保持方向向右,忽略當前箭頭旋轉的角度,圓形箭頭圖標旋轉到45度
        turtle.tiltangle(45)
        # 返回角度45度
        print(turtle.tiltangle())
        # 畫線
        turtle.fd(100)
復制代碼
# turtle.shapetransform(t11=None, t12=None, t21=None, t22=None)
    Parameters:
        t11 – a number (optional)
        t12 – a number (optional)
        t21 – a number (optional)
        t12 – a number (optional)
# 返回或設置箭頭形狀的當前變換矩陣
# 例如:
復制代碼
        # 返回 (1.0, 0.0, 0.0, 1.0)
        print(turtle.shapetransform())
        turtle.shape("square")
        # 垂直方向縮放到4倍,水平縮放到2倍,正方形變長方形
        turtle.shapesize(4, 2)
        turtle.shearfactor(-0.5)
        print(turtle.shapetransform())
復制代碼
# turtle.get_shapepoly()
# 返回當前多邊形的坐標對,一般用來定義一個新形狀或作為一個復合形狀的一部分
# 例如:
        turtle.shape("square")
        turtle.shapetransform(4, -1, 0, 2)
        # 輸出 ((50, -20), (30, 20), (-50, 20), (-30, -20))
        print(turtle.get_shapepoly())
#############################
#       4.繪制使用的事件      #
#############################
# turtle.onclick(fun, btn=1, add=None)
    Parameters:
        fun – 一個有兩個參數x,y的函數,畫布上鼠標左鍵在當前海龜箭頭位置按下時將點擊的坐標作為參數,調用該方法
        num – 鼠標按鈕的數目,默認為1(鼠標左鍵)
        add – True或False.如果是True,將添加一個新的綁定;否則將替換前綁定
# 畫布上鼠標左鍵在當前海龜箭頭位置按下時綁定一個函數;如果函數為None,則移除存在的綁定
# 例如:
復制代碼
        def turn(x, y):
            turtle.lt(90)
            # 打印當前坐標
            print('x=', x, 'y=', y)
            # 打印當前方向
            print(turtle.heading())
            # 清除綁定關系
            turtle.onclick(None)
            # 再次綁定
            turtle.onclick(turn)
        # 綁定turn方法
        turtle.onclick(turn)
復制代碼
# turtle.onrelease(fun, btn=1, add=None)
    Parameters:
        fun – 一個有兩個參數x,y的函數,畫布上鼠標左鍵在當前海龜箭頭位置彈起時將點擊的坐標作為參數,調用該方法
        num – 鼠標按鈕的數目,默認為1(鼠標左鍵)
        add – True或False.如果是True,將添加一個新的綁定;否則將替換前綁定
# 畫布上鼠標左鍵在當前海龜箭頭位置彈起時綁定一個函數;如果函數為None,則移除存在的綁定
# 例如:
復制代碼
        def turn(x, y):
            turtle.lt(90)
            # 打印當前坐標
            print('x=', x, 'y=', y)
            print(turtle.heading())
            # 清除綁定關系
            turtle.onrelease(None)
            # 再次綁定
            turtle.onrelease(turn)
        # 綁定turn方法
        turtle.onrelease(turn)
復制代碼
# turtle.ondrag(fun, btn=1, add=None)
    Parameters:
            fun – 一個有兩個參數x,y的函數,畫布上鼠標左鍵在當前海龜箭頭位置按下並拖動時將點擊的坐標作為參數,調用該方法
            num – 鼠標按鈕的數目,默認為1(鼠標左鍵)
            add – True或False.如果是True,將添加一個新的綁定;否則將替換前綁定
# 畫布上鼠標左鍵在當前海龜箭頭位置按下並拖動時綁定一個函數;如果函數為None,則移除存在的綁定
# 例如:
復制代碼
        def move(x, y):
            # 海龜箭頭移動到當前拖動位置
            turtle.goto(x, y)
            # 清除綁定關系
            turtle.ondrag(None)
            # 再次綁定
            turtle.ondrag(move)
        # 綁定turn方法
        turtle.ondrag(move)
復制代碼
#############################
#       5.特殊的繪制方法      #
#############################
# turtle.begin_poly()、turtle.end_poly()和turtle.get_poly()配合使用
# turtle.begin_poly()表示開始記錄多邊形第一個頂點
# turtle.end_poly()表示結束記錄多邊形頂點
# turtle.get_poly()表示獲取最后記錄的多邊形
# 例如:
復制代碼
        turtle.home()
        # 開始記錄
        turtle.begin_poly()
        turtle.fd(100)
        turtle.lt(20)
        turtle.fd(30)
        turtle.lt(60)
        turtle.fd(50)
        # 結束記錄
        turtle.end_poly()
        # 返回記錄的多邊形
        p = turtle.get_poly()
        # ((0.00,0.00), (100.00,0.00), (128.19,10.26), (136.87,59.50))
        print(p)
        #  將“myFavouriteShape”Shape添加到TurtleScreen對象的shapelist中
        turtle.register_shape("myFavouriteShape", p)
        # 使用新添加的shape
        turtle.shape("myFavouriteShape")
復制代碼
# turtle.clone()
# 創建和返回具有相同位置、方向和海龜箭頭屬性的海龜的克隆
# 例如:
        mick = turtle.Turtle()
        joe = mick.clone()
# turtle.getturtle() | turtle.getpen()
# 返回當前海龜屏幕上第一個海龜對象本身
# 例如:
        pet = turtle.getturtle()
        pet.fd(50)
        print(pet)
# turtle.getscreen()
# 返回繪制着海龜的海龜屏幕對象,獲取該對象后就可以調用海龜屏幕對象的一些方法了
# 例如:
        # 獲取海龜屏幕TurtleScreen對象
        ts = turtle.getscreen()
        print(ts)
        # 調用海龜屏幕對象的bgcolor方法,設置背景顏色為粉紅色
        ts.bgcolor("pink")
# turtle.setundobuffer(size)
    Parameters:
        size – an integer【設置undo()可撤銷的最大次數】或None【禁用undo()撤銷功能】
# 設置或禁用撤銷功能, size為None表示禁用撤銷功能;否則設置多大,就可以通過調用undo()方法撤銷多少次
# 例如:
        turtle.setundobuffer(42)
# turtle.undobufferentries()
# 獲取當前剩余可撤銷次數
# 例如:
        while turtle.undobufferentries():   # 判斷是否可撤銷
            turtle.undo()                   # 執行撤銷操作
二:海龜屏幕(TurtleScreen/Screen)的相關方法
首先需要通過screen = turtle.getscreen()獲取到海龜屏幕TurtleScreen的對象並賦值給變量screen,下文中screen均表示該海龜屏幕TurtleScreen的對象
a)Window Control窗口控制
# screen.bgcolor(*args)
    Parameters:
        args – 一個顏色字符串或3個范圍是0-colormode的數字或三個元祖
# 設置或返回海龜屏幕TurtleScreen的背景色
# 例如:
復制代碼
           screen = turtle.getscreen()
           screen.bgcolor("orange")
           # 打印 'orange'
           print(screen.bgcolor())
           screen.bgcolor("#800080")
           # 打印(128.0, 0.0, 128.0)
           print(screen.bgcolor())
復制代碼
# screen.bgpic(picname=None)
    Parameters:
        picname – 一個gif的字符串名字或"nopic"字符串或None
            git圖片名:表示設置海龜屏幕TurtleScreen的背景圖像
            "nopic":表示刪除海龜屏幕TurtleScreen的背景圖像
            None:表示返回海龜屏幕TurtleScreen的背景圖像的名稱
# 設置/刪除背景圖片或返回當前的背景圖片名
# 例如:
復制代碼
        screen = turtle.getscreen()
        # 打印當前背景圖像名,打印結果為'nopic'
        print(screen.bgpic())
        # 設置背景圖像,landscape.gif需要提前放到該文件同級目錄
        screen.bgpic("landscape.gif")
        # 打印當前背景圖像名,打印結果為"landscape.gif"
        print(screen.bgpic())
        screen.bgpic('nopic')
        # 打印當前背景圖像名,打印結果為'nopic'
        print(screen.bgpic())
復制代碼
# screen.clear() | screen.clearscreen() 和 screen.reset() | screen.resetscreen()
# 例如:見【2.畫筆控制中->d).更多的繪制控制】中例子

# screen.screensize(canvwidth=None, canvheight=None, bg=None)
    Parameters:
        canvwidth – 畫布寬度(正整數,單位為像素)
        canvheight – 畫布高度(正整數,單位為像素)
        bg – 新的背景顏色(colorstring或顏色組)
# 如果沒給出參數,則返回當前的畫布大小(canvaswidth, canvasheight);否則表示調整畫布大小
# 例如:
復制代碼
        screen = turtle.getscreen()
        # 打印當前畫布大小,結果為(400, 300)
        print(screen.screensize())
        # 調整畫布大小,變大后出現了滾動條,可通過滑動滑塊查看畫布隱藏部分
        screen.screensize(2000, 1500)
        # 打印當前畫布大小,結果為(2000, 1500)
        print(screen.screensize())
復制代碼
# screen.setworldcoordinates(llx, lly, urx, ury)
    Parameters:
        llx – 畫布左下角x坐標(number型)
        lly – 畫布左下角y坐標(number型)
        urx – 畫布右上角x坐標(number型)
        ury – 畫布右上角y坐標(number型)
# 設置用戶自定義的坐標系統,如果必要的話需要切換到“world”模式,如果“world”模式已經是活動的,則會根據新的坐標重繪圖紙。
# 注意:在用戶自定義的坐標系統中,角度可能會出現扭曲
# 例如:
復制代碼
        screen = turtle.getscreen()
        # 獲取當前海龜模式,打印結果為 logo
        print(screen.mode())
        turtle.shape("turtle")
        # 清屏,位置方向恢復初始狀態,保持海龜箭頭形狀不變
        screen.reset()
        # 設置海龜模式為"world"模式,感覺設不設置"world"模式展現效果沒啥區別
        screen.mode("world")
        screen.setworldcoordinates(-50, -7.5, 50, 7.5)
        for _ in range(72):
            turtle.lt(10)
        for _ in range(8):
            turtle.lt(45);turtle.fd(2)
復制代碼
b)Animation Control動畫控制
# screen.delay(delay=None)
    Parameters:
        delay – 正整數
# 設置或返回繪圖延遲(單位:毫秒),繪圖延遲越長,動畫的速度越慢
# 例如:
復制代碼
        screen = turtle.getscreen()
        # 獲取繪圖延遲毫秒數,打印結果為10
        print(screen.delay())
        # 設置繪圖延遲
        screen.delay(5)
        # 獲取繪圖延遲毫秒數,打印結果為5
        print(screen.delay())
復制代碼
# screen.tracer(n=None, delay=None)
    Parameters:
        n – 非負整數
        delay – 非負整數,見screen.delay(delay=None)
# 打開或關閉海龜動畫,並設置繪制延遲
# 例如:
復制代碼
        screen = turtle.getscreen()
        screen.tracer(8, 25)
        dist = 2
        for i in range(200):
            turtle.fd(dist)
            turtle.rt(90)
            dist += 2
復制代碼
# screen.update()
# 更新海龜屏幕TurtleScreen對象,tracer關閉時使用

c)Using screen events - 海龜屏幕TurtleScreen的相關事件
# screen.listen(xdummy=None, ydummy=None)
# 為了收集關鍵事件,讓海龜屏幕TurtleScreen的對象獲取焦點

# screen.onkey(fun, key) | screen.onkeyrelease(fun, key)
    Parameters:
        fun – 一個無參函數或None
        key – 一個字符串鍵值: 普通按鍵 (例如:“a”) 或功能鍵 (例如:“space”)
# 鍵盤上key鍵key-release事件觸發時(即按下並抬起)綁定一個無參函數;如果第一個參數fun為None,則移除綁定的函數
# 注意:前提是海龜屏幕TurtleScreen對象需要通過screen.listen()方法獲取焦點了
# 例如:
復制代碼
        def f():
            turtle.fd(50)
            turtle.lt(60)
        screen = turtle.getscreen()
        # 點擊up鍵綁定f函數
        screen.onkey(f, "Up")
        # 屏幕獲取焦點
        screen.listen()
復制代碼
# screen.onkeypress(fun, key=None)
    Parameters:
        fun – 一個無參函數或None
        key – 一個字符串鍵值: 普通按鍵 (例如:“a”) 或功能鍵 (例如:“space”),key為None表示任何按鍵按下都會觸發
# 鍵盤上key鍵(如果key為None時表示任意按鍵)按下時即key-press事件觸發時綁定一個無參函數;如果第一個參數fun為None,則移除綁定的函數。
# 例如:
復制代碼
        def f():
                turtle.fd(50)
                turtle.lt(60)
            screen = turtle.getscreen()
            # 按下"Up"鍵時綁定f函數
            #screen.onkeypress(f, "Up")
            # 按下任意鍵時綁定f函數
            screen.onkeypress(f, None)
            screen.listen()
復制代碼
# screen.onclick(fun, btn=1, add=None) | screen.onscreenclick(fun, btn=1, add=None)
    Parameters:
        fun – 一個有兩個參數x,y的函數,畫布上鼠標左鍵按下時將點擊的坐標作為參數,調用該方法
        num – 鼠標按鈕的數目,默認為1(鼠標左鍵)
        add – True或False.如果是True,將添加一個新的綁定;否則將替換前綁定
# 畫布上鼠標左鍵在按下時綁定一個函數;如果函數為None,則移除存在的綁定
# 例如:
復制代碼
        screen = turtle.getscreen()
        def turn(x, y):
            turtle.lt(90)
            # 打印當前坐標
            print('x=', x, 'y=', y)
            print(turtle.heading())
            # 清除綁定關系
            screen.onclick(None)
            # 再次綁定
            screen.onclick(turn)
        # 綁定turn方法
        screen.onclick(turn)
復制代碼
# screen.ontimer(fun, t=0)
    Parameters:
        fun – 一個無參的函數
        t – 一個>=0的number
# 開啟一個計時器,t毫秒后調用函數fun
# 例如:點擊屏幕畫多邊形,再次點擊停止繪制
復制代碼
        # 定義全局變量
        running = False
        def demo1():
            screen = turtle.getscreen()
            def f():
                # 內部函數想修改或使用全局變量需要加global,否則認為是局部變量
                global running
                if running:
                    turtle.fd(100)
                    turtle.lt(45)
                # 開啟計時器,250毫秒后執行f函數
                screen.ontimer(f, 250)
            def change_status(x, y):
                # 內部函數想修改或使用全局變量需要加global,否則認為是局部變量
                global running
                # bool取反操作
                running = not running
            f()
            screen.onclick(change_status)
        def my_main():
            demo1()
            turtle.mainloop()
        if __name__ == '__main__':
            my_main()
復制代碼
# d)Input methods輸入相關方法
# screen.textinput(title, prompt)
    Parameters:
        title – 彈框標題(一個string字符串)
        prompt – 彈框提示(一個string字符串)
# 彈出一個輸入文本的彈出框,點擊Cancel取消按鈕則返回None,點擊Ok按鈕返回輸入的字符串
# 例如:
        screen = turtle.getscreen()
        # 彈出輸入文本的彈出框
        name = screen.textinput("歡迎框", "你的姓名是")
        if (name != None and name != ""):
            print(name, ",您好")
# screen.numinput(title, prompt, default=None, minval=None, maxval=None)
    Parameters:
        title – 彈框標題(一個string字符串)
        prompt – 彈框提示(一個string字符串)
        default – 默認值number類型 (可選)
        minval – 最小值number類型 (可選)
        maxval – 最大值number類型 (可選)
# 彈出一個輸入數字的彈出框,點擊Cancel取消按鈕則返回None,點擊Ok按鈕返回輸入的number
# 例如:
復制代碼
        screen = turtle.getscreen()
        # 彈出輸入數字的彈出框
        age = screen.numinput("身高", "請輸入您的身高(單位:米)", 0, 0, 2.5)
        # 判空容錯處理
        if age != None and age > 0:
            print("身高", age, "")
復制代碼
# e)Settings and special methods設置和特殊方法
# screen.mode(mode=None) | turtle.mode(mode=None)
    Parameters:
        mode – "standard""logo""world" 3選1,各海龜模式含義如下
                Mode            初始方向          角度方向
            "standard"          向右 (東)         逆時針方向
            "world"             向右 (東)         逆時針方向
            "logo"              向上(北)          順時針方向
# 設置或返回海龜模式,默認是"standard"標准模式."standard"模式是兼容舊版本;"logo"模式兼容大部分海龜圖形標志;"world"模式使用用戶自定義的“世界坐標”該模式下x/y的單位比不為1會出現扭曲
# 例如:見screen.setworldcoordinates(llx, lly, urx, ury)中例子

# screen.colormode(cmode=None) | turtle.colormode(cmode=None)
    Parameters:
        cmode – 1.0或255,二選一
# 返回或設置colormode的值為1.0或255,隨后調用turtle.fillcolor(*args)、turtle.pencolor(*args)、turtle.color(*args)等方法設置畫筆顏色時R,G,B三組顏色值范圍必須是0-colormode值之間的數,否則會報異常
# 例如:見turtle.fillcolor(*args)、turtle.pencolor(*args)、turtle.color(*args)中例子

# screen.getcanvas() | turtle.getcanvas()
# 返回海龜屏幕TurtleScreen的畫布對象實例
# 例如:
        screen = turtle.getscreen()
        screen.getcanvas()
# screen.getshapes() | turtle.getshapes()
# 獲取當前可用海龜形狀的名稱列表
# 例如:
        # 獲取當前可用海龜形狀的名稱列表,打印結果 ['arrow', 'blank', 'circle', 'classic', 'square', 'triangle', 'turtle']
        print(turtle.getscreen().getshapes())
# screen.register_shape(name, shape=None) | screen.addshape(name, shape=None) | turtle.register_shape(name, shape=None) | turtle.addshape(name, shape=None)
# 內存中添加注冊海龜圖形
# 例如:
復制代碼
        screen = turtle.getscreen()
        方法1:
        screen.register_shape("turtle.gif")
        方法2:
        screen.register_shape("triangle", ((5,-3), (0,5), (-5,-3)))
        方法3:shape_obj是一個shape對象見 【turtle.begin_poly()、turtle.end_poly()和turtle.get_poly()配合使用】中例子
        screen.register_shape("myFavouriteShape", shape_obj)
復制代碼
# screen.turtles() | turtle.turtles()
# 返回海龜屏幕TurtleScreen中所有的海龜箭頭對象列表
# 例如:
        for turtle in screen.turtles():
            turtle.color("red")
# screen.window_height() | turtle.window_height() 和 screen.window_width() | turtle.window_width()
# 返回海龜繪圖窗口的高/寬(單位:像素)
# 例如:
        # 獲取海龜繪圖窗口高度(單位:像素), 打印 576
        print(turtle.window_height())
        # 獲取海龜繪圖窗口寬度(單位:像素), 打印 683
        print(turtle.window_width())
# screen.bye() | turtle.bye()
# 關閉海龜圖形窗口
# 例如:
        turtle.bye()
# screen.exitonclick() | turtle.exitonclick()
# 運行后屏幕自動消失,調用這句后屏幕會保持,直到點擊屏幕才會關閉海龜圖形窗口
# 例如:
        turtle.exitonclick()
# screen.mainloop() | screen.done() | turtle.mainloop() | turtle.done()
# 運行后屏幕自動消失,調用這句后屏幕會保持,直到主動關閉當前窗口(點擊繪圖窗口右上角的關閉按鈕或程序調用screen.bye()或turtle.bye()函數),想使用的話必須作為圖形繪制程序的最后一條語句
# 例如:
        turtle.mainloop()
# screen.setup(width=_CFG["width"], height=_CFG["height"], startx=_CFG["leftright"], starty=_CFG["topbottom"])
# turtle.setup(width=_CFG["width"], height=_CFG["height"], startx=_CFG["leftright"], starty=_CFG["topbottom"])
    Parameters:
        width – 一個整數(單位:像素)或一個小數(表示百分比),默認是屏幕寬的50%
        height – 一個整數(單位:像素)或一個小數(表示百分比),默認是屏幕高的75%
        startx – 如果是正數,則從屏幕左邊緣開始向右(單位:像素) ;如果為負數則從屏幕右邊緣開始向左;如果為None則窗口水平居中
        starty – 如果是正數,則從屏幕頂部邊緣開始向下(單位:像素) ;如果為負數則從屏幕底部邊緣開始向上;如果為None則窗口垂直居中
# 設置默認展現的主窗口的大小和位置(寬或高比海龜繪圖窗口小時對應方向上會出現滾動條)。參數的默認值存儲在turtle.cfg配置文件中,如果需要可進行修改
# 例如:
        screen = turtle.getscreen()
        # 海龜繪圖窗口寬高分別為576和683,此時將默認展現的主窗口的大小設置成了576和100,垂直方向因為占不全會出現滾動條
        screen.setup(width=576, height=100, startx=0, starty=0)
        # screen.setup(width=0.75, height=0.5, startx=None, starty=None)
# screen.title(titlestring) | turtle.title(titlestring)
# 設置海龜窗口標題
# 例如:
        screen = turtle.getscreen()
        # 設置窗口標題
        screen.title("hello turtle")
# 補充
# 關於turtle、turtle.getturtle()、和turtle.Turtle()的理解
# 例如:
復制代碼
        # turtle含義: <module 'turtle' from 'C:\\python_soft\\Anaconda3\\lib\\turtle.py'>
        print("turtle含義:", turtle)
        turtle0 = turtle.getturtle()
        # turtle0含義: <turtle.Turtle object at 0x000001CCCAC75978>   認為turtle.getturtle()是獲取默認的第一個Turtle對象實例
        print("turtle0含義:", turtle0)
        turtle1 = turtle.Turtle()
        # turtle1含義: <turtle.Turtle object at 0x000001CCCAF97A20>  認為turtle.Turtle()是創建一個新的Turtle實例對象並返回該實例對象
        print("turtle1含義:", turtle1)
        turtle2 = turtle.getturtle()
        # turtle2含義: <turtle.Turtle object at 0x000001CCCAC75978>
        print("turtle2含義:", turtle2)
        turtle3 = turtle.Turtle()
        # turtle3含義: <turtle.Turtle object at 0x000001CCCAF97B00>
        print("turtle3含義:", turtle3)
復制代碼 

 自己實踐:

#畫一個五角星:

 

 

 五角星是上面的圖哪有的循序,我們寫代碼:

def   Five_pointedstar():
    '''這個方法主要是畫一個五角星'''
    # 第一步: 設置屬性 
    tur.pensize(4)   #線寬
    tur.color("red")  #顏色
    tur.setup(800,800)#畫布大小
    tur.speed(1)  # 速度
    #第二步 畫五角星
    tur.begin_fill() # 開始繪制    t.goto(-100,100) #  將畫筆移動到坐標為x,y的位置  如果需要填充,則需要加 tur .begin_fill() 填充完畢則tur.end_fill()
    tur.pu() #畫筆繪制狀態  ,畫筆抬起,此時移動不會進行繪制操作 # 這里發現,畫圖是從正中心點畫的,也就是上圖的五角星的右下角未起點,上圖的五號線,這與我想的不太一樣,然后我先把它重置中心點在繪畫,由於直接使用goto 畫筆會跟着繪畫,所以加上這一段話就不會了

tur.goto(-100,100)
tur.pd() #開始繪制
tur.fd(
100) 箭頭方向移動, # 發現海龜繪圖,移動只有一個要點 # 只指向箭頭方向(旋轉也是按照箭頭方向)
   tur.rt(144)  # rt 向左旋, lt 向右旋轉
# tur.lt(-144)
 #rt 上面144 怎么來的? 請看下圖
 
    tur.fd(100) # 同上fd()方法
 

 

上圖是 rt 

 

下圖是 lt:

 

 

 

 記住  旋轉(左旋轉,右旋轉,x方向是箭頭所指,的方向 ,這樣子,順着x方向也就是 右旋轉,逆着 x方向也就是 左旋轉)

 

 

 

 

 

 

 

 

 完整代碼:

 1 import  turtle  as tur
 2 
 3 def   Five_pointedstar():
 4     '''這個方法主要是畫一個五角星'''
 5     # 第一步: 設置屬性 
 6     tur.pensize(4)
 7     tur.color("red")
 8     tur.setup(800,800)
 9     tur.speed(1)
10     #第二步 畫五角星
11     tur.begin_fill() # 開始繪制    t.goto(-100,100) #  將畫筆移動到坐標為x,y的位置  如果需要填充,則需要加 tur .begin_fill() 填充完畢則tur.end_fill()
12     tur.pu()
13     tur.goto(-100,100)
14     tur.pd()
15     tur.fd(100)
16     tur.rt(144)  # rt 向左旋, lt 向右旋轉
17     tur.fd(100)
18 
19     tur.rt(144)
20     tur.fd(100)
21     tur.rt(144)
22     tur.fd(100)
23     tur.rt(144)
24     tur.fd(100)
25     tur.end_fill()
26     tur.done()

不填充的:

 1 import  turtle  as tur
 2 
 3 def   Five_pointedstar():
 4     '''這個方法主要是畫一個五角星'''
 5     # 第一步: 設置屬性 
 6     tur.pensize(4)
 7     tur.color("red")
 8     tur.setup(800,800)
 9     tur.speed(1)
10     #第二步 畫五角星
11     #tur.begin_fill() # 開始繪制    t.goto(-100,100) #  將畫筆移動到坐標為x,y的位置  如果需要填充,則需要加 tur .begin_fill() 填充完畢則tur.end_fill()
12     tur.pu()
13     tur.goto(-100,100)
14     tur.pd()
15     tur.fd(100)
16     tur.rt(144)  # rt 向左旋, lt 向右旋轉
17     tur.fd(100)
18 
19     tur.rt(144)
20     tur.fd(100)
21     tur.rt(144)
22     tur.fd(100)
23     tur.rt(144)
24     tur.fd(100)
25     #tur.end_fill()
26     tur.done()

 

  相信你也看見了, tur.rt(),tur,fd() 這里重復,我們可以用for

 1 import  turtle  as tur
 2 
 3 def   Five_pointedstar():
 4     '''這個方法主要是畫一個五角星'''
 5     # 第一步: 設置屬性 
 6     tur.pensize(4)
 7     tur.color("red")
 8     tur.setup(800,800)
 9     tur.speed(1)
10     #第二步 畫五角星
11     tur.begin_fill() # 開始繪制    t.goto(-100,100) #  將畫筆移動到坐標為x,y的位置  如果需要填充,則需要加 tur .begin_fill() 填充完畢則tur.end_fill()
12     tur.pu()
13     tur.goto(-100,100)
14     tur.pd()
15     for i in range(0,5):
16 
17         tur.fd(100)
18         tur.rt(144)  # rt 向左旋, lt 向右旋轉 
19     tur.end_fill()
20     tur.done()

 

你看,我的中國心!!! 

 

 

五星紅旗:

 

 1 def  five_Star_Red_Flag():
 2     # 第一步,設置相關屬性    
 3     tur.pensize(4)
 4     tur.color("red")
 5     tur.setup(600,500)
 6     tur.speed(2)
 7     #第二步,畫一個填充的長方形
 8     tur.begin_fill()
 9     tur.pu()
10     tur.goto(-100,100)
11     tur.pd()
12     for i in range(0,2): 
13         tur.fd(300)
14         tur.rt(90)
15         tur.fd(200)
16         tur.rt(90)
17     tur.end_fill()    
18     # 畫第一個大的五角星 
19 def  five_star_big():
20     # 第一步,設置相關屬性
21     tur.pensize(2)
22     tur.color("yellow","yellow") 
23     tur.pu()
24     tur.goto(-90,50)
25     tur.pd()
26     tur.begin_fill()
27     for i in range(0,5): 
28         tur.fd(60)
29         tur.lt(-144)
30     tur.speed(2)
31     tur.end_fill() 
32 def  five_star_small(x,y,xzjd):
33     #第一步 設置屬性
34     tur.pensize(1)
35     tur.color("yellow","yellow")
36     tur.lt(xzjd)
37     tur.pu()
38     tur.goto(x,y)
39     tur.pd()
40     tur.begin_fill()
41     for i in range(0,5): 
42         tur.fd(16)
43         tur.lt(-144)
44     tur.speed(1)
45     tur.end_fill()

調用:

if __name__ == "__main__":
    # five_Star_Red_Flag()
    # five_star_big()
    # five_star_small(-20,80,60)
    # five_star_small(-0,60,-40)
    # five_star_small(-2,40,-60)
    # five_star_small(-4,10,-70)    
    # tur.hideturtle()
    # tur.done()

使用類:

 1 class  Five_Star():
 2     
 3     def    five_s_flag(self):
 4         # 第一步,設置相關屬性    
 5         tur.pensize(4)
 6         tur.color("red")
 7         tur.setup(600,500)
 8         tur.speed(2)
 9         #第二步,畫一個填充的長方形
10         tur.begin_fill()
11         tur.pu()
12         tur.goto(-100,100)
13         tur.pd()
14         for i in range(0,2): 
15             tur.fd(300)
16             tur.rt(90)
17             tur.fd(200)
18             tur.rt(90)
19         tur.end_fill()    
20 
21     def five_star_big(self):
22         # 第一步,設置相關屬性
23         tur.pensize(2)
24         tur.color("yellow","yellow") 
25         tur.pu()
26         tur.goto(-90,50)
27         tur.pd()
28         tur.begin_fill()
29         for i in range(0,5): 
30             tur.fd(60)
31             tur.lt(-144)
32         tur.speed(2)
33         tur.end_fill() 
34 
35     def  five_star_small(self,x,y,xzjd):
36            #第一步 設置屬性
37         tur.pensize(1)
38         tur.color("yellow","yellow")
39         tur.lt(xzjd)
40         tur.pu()
41         tur.goto(x,y)
42         tur.pd()
43         tur.begin_fill()
44         for i in range(0,5): 
45             tur.fd(16)
46             tur.lt(-144)
47         tur.speed(1)
48         tur.end_fill()
49 
50     def  Main(self):           
51         tur.hideturtle()
52         tur.done()
53     
54 調用  
55 
56 if __name__ == "__main__":
57     fs=Five_Star()
58     
59     fs.five_s_flag()
60     fs.five_star_big()
61     fs.five_star_small(-20,80,60)
62     fs.five_star_small(-0,60,-40)
63     fs.five_star_small(-2,40,-60)
64     fs.five_star_small(-4,10,-70)   
65     fs.Main()
66  
67  

 


免責聲明!

本站轉載的文章為個人學習借鑒使用,本站對版權不負任何法律責任。如果侵犯了您的隱私權益,請聯系本站郵箱yoyou2525@163.com刪除。



 
粵ICP備18138465號   © 2018-2025 CODEPRJ.COM