Skip to content

Instantly share code, notes, and snippets.

@renyuanL

renyuanL/tc_bytedesign.py

Last active August 29, 2015 14:14
Show Gist options
  • Save renyuanL/72d4ea891fb6ba148cde to your computer and use it in GitHub Desktop.
Save renyuanL/72d4ea891fb6ba148cde to your computer and use it in GitHub Desktop.
Download ZIP
a set of 18 Python Turtle Graphic Programs in Traditional Chinese
Raw
tc_bytedesign.py
#!/usr/bin/env python3
'''龜例如套房：
        tdemo_bytedesign.py
改編自例子套房為例
對PythonCard的烏龜圖形。
它是基於在BYTE雜誌上的一篇文章
問題解決標誌：使用海龜
圖形重繪設計
1982年11月，頁。 118 - 134
-------------------------------------------
由於該語句
t.delay （0）
在線152 ，這台動畫延遲
為0 ，這個動畫運行在“每行線”
模式盡可能快。=== 以上由 Google 翻譯，請協助改善 ===
'''
import math
from turtle_tc import *; from turtle_tc import 龜類, 主迴圈
from time import clock
# 包裝任何額外的繪圖程序
# 這需要了解對方
class 設計師類(龜類):
def 設計(我, 家的位置, 比例尺度):
我.提筆()
for i in 範圍(5):
我.前進(64.65 * 比例尺度)
我.下筆()
我.輪子(我.位置(), 比例尺度)
我.提筆()
我.後退(64.65 * 比例尺度)
我.右轉(72)
我.提筆()
我.前往(家的位置)
我.右轉(36)
我.前進(24.5 * 比例尺度)
我.右轉(198)
我.下筆()
我.中央塊(46 * 比例尺度, 143.4, 比例尺度)
我.取幕().追蹤(真)
def 輪子(我, 開始位置, 比例尺度):
我.右轉(54)
for i in 範圍(4):
我.五之塊(開始位置, 比例尺度)
我.下筆()
我.左轉(36)
for i in 範圍(5):
我.三之塊(開始位置, 比例尺度)
我.左轉(36)
for i in 範圍(5):
我.下筆()
我.右轉(72)
我.前進(28 * 比例尺度)
我.提筆()
我.後退(28 * 比例尺度)
我.左轉(54)
我.取幕().更新()
def 三之塊(我, 開始位置, 比例尺度):
舊頭向 = 我.頭向()
我.下筆()
我.後退(2.5 * 比例尺度)
我.右三邊形(31.5 * 比例尺度, 比例尺度)
我.提筆()
我.前往(開始位置)
我.設頭向(舊頭向)
我.下筆()
我.後退(2.5 * 比例尺度)
我.左三邊形(31.5 * 比例尺度, 比例尺度)
我.提筆()
我.前往(開始位置)
我.設頭向(舊頭向)
我.左轉(72)
我.取幕().更新()
def 五之塊(我, 開始位置, 比例尺度):
舊頭向 = 我.頭向()
我.提筆()
我.前進(29 * 比例尺度)
我.下筆()
for i in 範圍(5):
我.前進(18 * 比例尺度)
我.右轉(72)
我.右五邊形(18 * 比例尺度, 75, 比例尺度)
我.提筆()
我.前往(開始位置)
我.設頭向(舊頭向)
我.前進(29 * 比例尺度)
我.下筆()
for i in 範圍(5):
我.前進(18 * 比例尺度)
我.右轉(72)
我.左五邊形(18 * 比例尺度, 75, 比例尺度)
我.提筆()
我.前往(開始位置)
我.設頭向(舊頭向)
我.左轉(72)
我.取幕().更新()
def 左五邊形(我, 邊, 角度, 比例尺度):
if 邊 < (2 * 比例尺度): return
我.前進(邊)
我.左轉(角度)
我.左五邊形(邊 - (.38 * 比例尺度), 角度, 比例尺度)
def 右五邊形(我, 邊, 角度, 比例尺度):
if 邊 < (2 * 比例尺度): return
我.前進(邊)
我.右轉(角度)
我.右五邊形(邊 - (.38 * 比例尺度), 角度, 比例尺度)
def 右三邊形(我, 邊, 比例尺度):
if 邊 < (4 * 比例尺度): return
我.前進(邊)
我.右轉(111)
我.前進(邊 / 1.78)
我.右轉(111)
我.前進(邊 / 1.3)
我.右轉(146)
我.右三邊形(邊 * .75, 比例尺度)
def 左三邊形(我, 邊, 比例尺度):
if 邊 < (4 * 比例尺度): return
我.前進(邊)
我.左轉(111)
我.前進(邊 / 1.78)
我.左轉(111)
我.前進(邊 / 1.3)
我.左轉(146)
我.左三邊形(邊 * .75, 比例尺度)
def 中央塊(我, s, a, 比例尺度):
我.前進(s); 我.左轉(a)
if s < (7.5 * 比例尺度):
return
我.中央塊(s - (1.2 * 比例尺度), a, 比例尺度)
def 主函數():
t = 設計師類()
t.速度(0)
t.藏龜()
t.取幕().延遲(0)
t.取幕().追蹤(0)
at = clock()
t.設計(t.位置(), 2)
et = clock()
return "執行時間: %.2f 秒。" % (et-at)
if __name__ == '__main__':
訊息 = 主函數()
印(訊息)
主迴圈()
# Above: "tc_bytedesign.py", by Renyuan Lyu (呂仁園), 2015-01-27
# Original: "bytedesign.py", by Gregor Lingl.
Raw
tc_chaos.py
# 文件： tdemo_chaos.py
# 作者：格雷戈爾Lingl
# 日期： 2009-06-24
# 混亂的示範
from turtle_tc import *
N = 80
def f(x):
return 3.9*x*(1-x)
def g(x):
return 3.9*(x-x**2)
def h(x):
return 3.9*x-3.9*x*x
def 跳至(x, y):
提筆(); 前往(x,y)
def 直線(x1, y1, x2, y2):
跳至(x1, y1)
下筆()
前往(x2, y2)
def 座標系統():
直線(-1, 0, N+1, 0)
直線(0, -0.1, 0, 1.1)
def 畫(函數, 開始, 顏色):
筆色(顏色)
x = 開始
跳至(0, x)
下筆()
點(5)
for i in 範圍(N):
x=函數(x)
前往(i+1,x)
點(5)
def 主函數():
重設()
設座標系統(-1.0,-0.1, N+1, 1.1)
速度(0)
藏龜()
座標系統()
畫(f, 0.35, 藍)
畫(g, 0.35, 綠)
畫(h, 0.35, 紅)
# 現在放大：
for s in 範圍(100):
設座標系統(0.5*s,-0.1, N+1, 1.1)
return "Done!"
if __name__ == "__main__":
主函數()
主迴圈()
# Above: "tc_chaos.py", by Renyuan Lyu (呂仁園), 2015-01-27
# Original: "chaos.py", by Gregor Lingl.
Raw
tc_clock.py
#!/usr/bin/env python3
# - * - 編碼： CP1252 - * -
'''龜例如套房：
             tdemo_clock.py
增強的時鐘程序，顯示日期
和時間
  ------------------------------------
   按STOP退出程序！
  ------------------------------------=== 以上由 Google 翻譯，請協助改善 ===
'''
from turtle_tc import *
from datetime import datetime
def 跳(距離, 角度=0):
提筆()
右轉(角度)
前進(距離)
左轉(角度)
下筆()
def 指針(長度, 尺寸大小):
前進(長度*1.15)
右轉(90)
前進(尺寸大小/2.0)
左轉(120)
前進(尺寸大小)
左轉(120)
前進(尺寸大小)
左轉(120)
前進(尺寸大小/2.0)
def 作指針形狀(名, 長度, 尺寸大小):
重設()
跳(-長度*0.15)
開始多邊形()
指針(長度, 尺寸大小)
結束多邊形()
指針形式 = 取多邊形()
登記形狀(名, 指針形式)
def 鐘面(半徑):
重設()
筆粗(7)
for i in 範圍(60):
跳(半徑)
if i % 5 == 0:
前進(25)
跳(-半徑-25)
else:
點(3)
跳(-半徑)
右轉(6)
def 設立():
global 秒針, 分針, 時針, 寫手
模式(角度從北開始順時針)
作指針形狀("秒針", 125, 25)
作指針形狀("分針", 130, 25)
作指針形狀("時針", 90, 25)
鐘面(160)
秒針 = 龜類()
秒針.形狀("秒針")
秒針.顏色("gray20", "gray80")
分針 = 龜類()
分針.形狀("分針")
分針.顏色("blue1", "red1")
時針 = 龜類()
時針.形狀("時針")
時針.顏色("blue3", "red3")
for 指針 in 秒針, 分針, 時針:
指針.重設大小模式("user")
指針.形狀大小(1, 1, 3)
指針.速度(0)
藏龜()
寫手 = 龜類()
# writer.mode （ “標誌” ）
寫手.藏龜()
寫手.提筆()
寫手.後退(85)
def 星期標籤(t):
星期標籤 = ["拜一", "拜二", "拜三",
"拜四", "拜五", "拜六", "拜日"]
return 星期標籤[t.weekday()]
def 年月日期(z):
monat = ["一月", "二月", "三月", "四月", "五月", "六月",
"七月", "八月", "九月", "十月", "十一月", "十二月"]
j = z.year
m = monat[z.month - 1]
t = z.day
return "%s %d %d" % (m, t, j)
def 滴答():
t = datetime.today()
秒數 = t.second + t.microsecond*0.000001
minute = t.minute + 秒數/60.0
時數 = t.hour + minute/60.0
try:
追蹤(假) # 終結者可以發生在這裡
寫手.清除()
寫手.回家()
寫手.前進(65)
寫手.寫(星期標籤(t),
align="center", font=("Courier", 14, "bold"))
寫手.後退(150)
寫手.寫(年月日期(t),
align="center", font=("Courier", 14, "bold"))
寫手.前進(85)
追蹤(真)
秒針.設頭向(6*秒數) # 或點擊這裡
分針.設頭向(6*minute)
時針.設頭向(30*時數)
追蹤(真)
在計時後(滴答, 100)
except Terminator:
pass # turtledemo用戶按STOP
def 主函數():
追蹤(假)
設立()
追蹤(真)
滴答()
return "EVENTLOOP"
if __name__ == "__main__":
模式(角度從北開始順時針)
訊息 = 主函數()
印(訊息)
主迴圈()
# Above: "tc_clock.py", by Renyuan Lyu (呂仁園), 2015-01-27
# Original: "clock.py", by Gregor Lingl.
Raw
tc_colormixer.py
# COLORMIX
from turtle_tc import *; from turtle_tc import 幕類, 龜類, 主迴圈
class 顏色龜類(龜類):
def __init__(我, x, y):
龜類.__init__(我)
我.形狀(龜形)
我.重設大小模式("user")
我.形狀大小(3,3,5)
我.筆粗(10)
我._color = [0,0,0]
我.x = x
我._color[x] = y
我.顏色(我._color)
我.速度(0)
我.左轉(90)
我.提筆()
我.前往(x,0)
我.下筆()
我.設y座標(1)
我.提筆()
我.設y座標(y)
我.筆色("gray25")
我.在拖曳時(我.平移)
def 平移(我, x, y):
我.設y座標(max(0,min(y,1)))
我._color[我.x] = 我.y座標()
我.填色(我._color)
設背景的顏色()
def 設背景的顏色():
幕.背景色(red.y座標(), green.y座標(), blue.y座標())
def 主函數():
global 幕, red, green, blue
幕 = 幕類()
幕.延遲(0)
幕.設座標系統(-1, -0.3, 3, 1.3)
red = 顏色龜類(0, .5)
green = 顏色龜類(1, .5)
blue = 顏色龜類(2, .5)
設背景的顏色()
寫手 = 龜類()
寫手.藏龜()
寫手.提筆()
寫手.前往(1,1.15)
寫手.寫("DRAG!",align="center",font=("Arial",30,("bold","italic")))
return "EVENTLOOP"
if __name__ == "__main__":
訊息 = 主函數()
印(訊息)
主迴圈()
# Above: "tc_colormixer.py", by Renyuan Lyu (呂仁園), 2015-01-27
# Original: "colormixer.py", by Gregor Lingl.
Raw
tc_forest.py
#!/usr/bin/env python3
'''turtlegraphics ，例如套房：
             tdemo_forest.py
顯示3廣度優先樹一個'森林'
一個類似於在樹中。
為了進一步說明，見tree.py
這個例子是一個“廣度first'重寫的
徽標計劃寫的埃里希Neuwirth的。見
http://homepage.univie.ac.at/erich.neuwirth/=== 以上由 Google 翻譯，請協助改善 ===
'''
from turtle_tc import *; from turtle_tc import 龜類, 色模式, 追蹤, 主迴圈
from random import randrange
from time import clock
def 隨機符號(n):
return randrange(-n,n+1)
def 隨機化( 分支列表, 角度距離, 邊距離 ):
return [ (角度+隨機符號(角度距離),
尺寸因子*1.01**隨機符號(邊距離))
for 角度, 尺寸因子 in 分支列表 ]
def 隨機前進( t, 距離, 部分, 角度距離 ):
for i in 範圍(部分):
t.左轉(隨機符號(角度距離))
t.前進( (1.0 * 距離)/部分 )
def 樹(t列表, 尺寸, 水平, 寬度因子, 分支列表們, 角度距離=10, 邊距離=5):
# 海龜使用的列表和分支列出清單
# 每個龜之一！
if 水平 > 0:
列表 = []
brs = []
for t, 分支列表 in list(zip(t列表,分支列表們)):
t.筆粗( 尺寸 * 寬度因子 )
t.筆色( 255 - (180 - 11 * 水平 + 隨機符號(15)),
180 - 11 * 水平 + 隨機符號(15),
0 )
t.下筆()
隨機前進(t, 尺寸, 水平, 角度距離 )
yield 1
for 角度, 尺寸因子 in 分支列表:
t.左轉(角度)
列表.append(t.複製())
brs.append(隨機化(分支列表, 角度距離, 邊距離))
t.右轉(角度)
for x in 樹(列表, 尺寸*尺寸因子, 水平-1, 寬度因子, brs,
角度距離, 邊距離):
yield 無
def 開始(t,x,y):
色模式(255)
t.重設()
t.速度(0)
t.藏龜()
t.左轉(90)
t.提筆()
t.設位置(x,y)
t.下筆()
def 做它1(水平, 筆):
筆.藏龜()
開始(筆, 20, -208)
t = 樹( [筆], 80, 水平, 0.1, [[ (45,0.69), (0,0.65), (-45,0.71) ]] )
return t
def 做它2(水平, 筆):
筆.藏龜()
開始(筆, -135, -130)
t = 樹( [筆], 120, 水平, 0.1, [[ (45,0.69), (-45,0.71) ]] )
return t
def 做它3(水平, 筆):
筆.藏龜()
開始(筆, 190, -90)
t = 樹( [筆], 100, 水平, 0.1, [[ (45,0.7), (0,0.72), (-45,0.65) ]] )
return t
# 這裡有3棵樹發電機：
def 主函數():
p = 龜類()
p.藏龜()
追蹤(75,0)
u = 做它1(6, 龜類(undobuffersize=1))
s = 做它2(7, 龜類(undobuffersize=1))
t = 做它3(5, 龜類(undobuffersize=1))
a = clock()
while 真:
做完了 = 0
for b in u,s,t:
try:
b.__next__()
except:
做完了 += 1
if 做完了 == 3:
break
追蹤(1,10)
b = clock()
return "執行時間: %.2f 秒。" % (b-a)
if __name__ == '__main__':
主函數()
主迴圈()
# Above: "tc_forest.py", by Renyuan Lyu (呂仁園), 2015-01-27
# Original: "forest.py", by Gregor Lingl.
Raw
tc_fractalcurves.py
#!/usr/bin/env python3
'''龜例如套房：
        tdemo_fractalCurves.py
這個程序繪製了兩個分形曲線設計：
（ 1 ）希爾伯特曲線（在一個盒子）
（ 2 ）對科赫 - 曲線的組合。
該CurvesTurtle類和分形曲線 -
方法是從PythonCard示例取
腳本烏龜圖形。=== 以上由 Google 翻譯，請協助改善 ===
'''
from turtle_tc import *
from time import sleep, clock
class 曲線龜類(筆類):
# 例如源自
# 龜幾何：計算機作為媒介的探索數學
# 由哈羅德·阿貝爾森和Andrea diSessa
# 頁。 96-98
def hilbert(我, 尺寸, 水平, 對等性):
if 水平 == 0:
return
# 旋轉並繪製第一subcurve具有相反奇偶性，以大曲線
我.左轉(對等性 * 90)
我.hilbert(尺寸, 水平 - 1, -對等性)
# 接口和借鑒第二subcurve具有相同的奇偶大曲線
我.前進(尺寸)
我.右轉(對等性 * 90)
我.hilbert(尺寸, 水平 - 1, 對等性)
# 第三subcurve
我.前進(尺寸)
我.hilbert(尺寸, 水平 - 1, 對等性)
# 第四subcurve
我.右轉(對等性 * 90)
我.前進(尺寸)
我.hilbert(尺寸, 水平 - 1, -對等性)
# 最後又需要作出烏龜
# 最終朝外從大廣場
我.左轉(對等性 * 90)
# 可視化建模與標誌：一種結構方法見此
# 由詹姆斯·克萊森
# 科赫曲線，黑爾格·馮·科赫後誰介紹這個幾何圖形在1904年
# 頁。 146
def 碎形多邊形(我, n, 弳度, lev, dir):
import math
# 如果DIR = 1向外轉
# 如果DIR = -1向內轉
邊緣 = 2 * 弳度 * math.sin(math.pi / n)
我.提筆()
我.前進(弳度)
我.下筆()
我.右轉(180 - (90 * (n - 2) / n))
for i in 範圍(n):
我.碎形(邊緣, lev, dir)
我.右轉(360 / n)
我.左轉(180 - (90 * (n - 2) / n))
我.提筆()
我.後退(弳度)
我.下筆()
# 頁。 146
def 碎形(我, 距離, 深度, dir):
if 深度 < 1:
我.前進(距離)
return
我.碎形(距離 / 3, 深度 - 1, dir)
我.左轉(60 * dir)
我.碎形(距離 / 3, 深度 - 1, dir)
我.右轉(120 * dir)
我.碎形(距離 / 3, 深度 - 1, dir)
我.左轉(60 * dir)
我.碎形(距離 / 3, 深度 - 1, dir)
def 主函數():
ft = 曲線龜類()
ft.重設()
ft.速度(0)
ft.藏龜()
ft.取幕().追蹤(1,0)
ft.提筆()
尺寸 = 6
ft.設位置(-33*尺寸, -32*尺寸)
ft.下筆()
ta=clock()
ft.填色(紅)
ft.開始填()
ft.前進(尺寸)
ft.hilbert(尺寸, 6, 1)
# 框架
ft.前進(尺寸)
for i in 範圍(3):
ft.左轉(90)
ft.前進(尺寸*(64+i%2))
ft.提筆()
for i in 範圍(2):
ft.前進(尺寸)
ft.右轉(90)
ft.下筆()
for i in 範圍(4):
ft.前進(尺寸*(66+i%2))
ft.右轉(90)
ft.結束填()
tb=clock()
res = "Hilbert: %.2fsec. " % (tb-ta)
sleep(3)
ft.重設()
ft.速度(0)
ft.藏龜()
ft.取幕().追蹤(1,0)
ta=clock()
ft.顏色(黑, 藍)
ft.開始填()
ft.碎形多邊形(3, 250, 4, 1)
ft.結束填()
ft.開始填()
ft.顏色(紅)
ft.碎形多邊形(3, 200, 4, -1)
ft.結束填()
tb=clock()
res += "Koch: %.2fsec." % (tb-ta)
return res
if __name__ == '__main__':
訊息 = 主函數()
印(訊息)
主迴圈()
# Above: "tc_fractalcurves.py", by Renyuan Lyu (呂仁園), 2015-01-27
# Original: "fractalcurves.py", by Gregor Lingl.
Raw
tc_lindenmayer.py
#!/usr/bin/env python3
'''龜例如套房：
        xtx_lindenmayer_indian.py
每天早晨女性在泰米爾納德邦，南
印度，地點的設計，通過利用水稻創建
麵粉和稱為鵬遠上的閾值
他們的家園。
這些可以通過Lindenmayer系統進行描述，
它可以很容易地與龜實施
圖形和Python 。
兩個例子如下所示：
（ 1）合肥鵬遠蛇
克里希納（ 2 ）腳鐲
摘自瑪西婭Ascher的：數學
在其他地方，思想的探索跨
文化=== 以上由 Google 翻譯，請協助改善 ===
'''
#
# 迷你Lindenmayer工具
#
from turtle_tc import *
def replace( 序列, 取代規則們, n ):
for i in 範圍(n):
新序列 = ""
for 元素 in 序列:
新序列 = 新序列 + 取代規則們.get(元素,元素)
序列 = 新序列
return 序列
def 畫( 指令們, 規則們 ):
for b in 指令們:
try:
規則們[b]()
except TypeError:
try:
畫(規則們[b], 規則們)
except:
pass
def 主函數():
#
# 例1 ：蛇合肥鵬遠
#
def r():
右轉(45)
def l():
左轉(45)
def f():
前進(7.5)
蛇規則 = {"-":r, "+":l, "f":f, "b":"f+f+f--f--f+f+f"}
蛇取代規則們 = {"b": "b+f+b--f--b+f+b"}
蛇開始 = "b--f--b--f"
正在畫 = replace(蛇開始, 蛇取代規則們, 3)
重設()
速度(3)
追蹤(1,0)
藏龜()
提筆()
後退(195)
下筆()
畫(正在畫, 蛇規則)
from time import sleep
sleep(3)
#
# 例2 ：克里希納腳鍊
#
def A():
顏色(紅)
畫圓(10,90)
def B():
from math import sqrt
顏色(黑)
l = 5/sqrt(2)
前進(l)
畫圓(l, 270)
前進(l)
def F():
顏色(綠)
前進(10)
克里希納規則們 = {"a":A, "b":B, "f":F}
克里希納取代規則們 = {"a" : "afbfa", "b" : "afbfbfbfa" }
克里希納開始 = "fbfbfbfb"
重設()
速度(0)
追蹤(3,0)
藏龜()
左轉(45)
正在畫 = replace(克里希納開始, 克里希納取代規則們, 3)
畫(正在畫, 克里希納規則們)
追蹤(1)
return "Done!"
if __name__=='__main__':
訊息 = 主函數()
印(訊息)
主迴圈()
# Above: "tc_lindenmayer.py", by Renyuan Lyu (呂仁園), 2015-01-27
# Original: "lindenmayer.py", by Gregor Lingl.
Raw
tc_minimal_hanoi.py
#!/usr/bin/env python3
'''龜例如套房：
         tdemo_minimal_hanoi.py
動畫一個最小的“河內塔” ：
塔的6碟從轉移
左到右的PEG 。
恕我直言，一個很優雅而簡潔
使用塔類，其中實現
從內置類型列表中導出。
光盤是龜與形“廣場” ，但
通過shapesize延伸到矩形（ ）
 ---------------------------------------
       要退出，請按STOP按鈕
 ---------------------------------------=== 以上由 Google 翻譯，請協助改善 ===
'''
from turtle_tc import *
class 盤類(龜類):
def __init__(我, n):
龜類.__init__(我, shape=方形, visible=假)
我.提筆()
我.形狀大小(1.5, n*1.5, 2) # 廣場 - >矩形
我.填色(n/6., 0, 1-n/6.)
我.顯龜()
class 塔類(list):
"Hanoi tower, a subclass of built-in type list"
def __init__(我, x):
"create an empty tower. x is x-position of peg"
我.x = x
def push(我, d):
d.設x座標(我.x)
d.設y座標(-150+34*len(我))
我.append(d)
def pop(我):
d = list.pop(我)
d.設y座標(150)
return d
def 河內(n, 從_, 伴隨_, 去_):
if n > 0:
河內(n-1, 從_, 去_, 伴隨_)
去_.push(從_.pop())
河內(n-1, 伴隨_, 從_, 去_)
def 玩():
在按鍵時(無,空白鍵)
清除()
try:
河內(6, t1, t2, t3)
寫("press STOP button to exit",
align="center", font=("Courier", 16, "bold"))
except Terminator:
pass # turtledemo用戶按STOP
def 主函數():
global t1, t2, t3
藏龜(); 提筆(); 前往(0, -225) # 作家龜
t1 = 塔類(-250)
t2 = 塔類(0)
t3 = 塔類(250)
# 使塔的6碟
for i in 範圍(6,0,-1):
t1.push(盤類(i))
# 準備spartanic用戶界面; - ）
寫("press spacebar to start game",
align="center", font=("Courier", 16, "bold"))
在按鍵時(玩, 空白鍵)
聽()
return "EVENTLOOP"
if __name__=="__main__":
訊息 = 主函數()
印(訊息)
主迴圈()
# Above: "tc_minimal_hanoi.py", by Renyuan Lyu (呂仁園), 2015-01-27
# Original: "minimal_hanoi.py", by Gregor Lingl.
Raw
tc_nim.py
'''龜例如套房：
            tdemo_nim.py
玩NIM對計算機。播放器
誰需要最後一棒是贏家。
實現了模型 - 視圖 - 控制器
設計模式。=== 以上由 Google 翻譯，請協助改善 ===
'''
import turtle_tc as turtle; from turtle_tc import *
import random
import time
幕寬常數 = 640
幕高常數 = 480
最小棒子數常數 = 7
最大棒子數常數 = 31
垂直單位常數 = 幕高常數 // 12
水平單位常數 = 幕寬常數 // ((最大棒子數常數 // 5) * 11 + (最大棒子數常數 % 5) * 2)
S顏色常數 = (63, 63, 31)
H顏色常數 = (255, 204, 204)
顏色常數 = (204, 204, 255)
def 隨機列():
return random.randint(最小棒子數常數, 最大棒子數常數)
def 電腦揀棒子(狀態):
互斥或 = 狀態[0] ^ 狀態[1] ^ 狀態[2]
if 互斥或 == 0:
return 隨機移動(狀態)
for z in 範圍(3):
s = 狀態[z] ^ 互斥或
if s <= 狀態[z]:
移動 = (z, s)
return 移動
def 隨機移動(狀態):
m = max(狀態)
while 真:
z = random.randint(0,2)
if 狀態[z] > (m > 1):
break
rand = random.randint(m > 1, 狀態[z]-1)
return z, rand
class 捻遊戲模型類(object):
def __init__(我, 遊戲):
我.遊戲 = 遊戲
def 設立(我):
if 我.遊戲.狀態 not in [捻遊戲類.被創造狀態, 捻遊戲類.遊戲結束狀態]:
return
我.棒子們 = [隨機列(), 隨機列(), 隨機列()]
我.玩家 = 0
我.贏家 = 無
我.遊戲.視圖.設立()
我.遊戲.狀態 = 捻遊戲類.正在跑狀態
def 移動(我, 列, 行):
最大分裂數 = 我.棒子們[列]
我.棒子們[列] = 行
我.遊戲.視圖.通知移動(列, 行, 最大分裂數, 我.玩家)
if 我.遊戲結束():
我.遊戲.狀態 = 捻遊戲類.遊戲結束狀態
我.贏家 = 我.玩家
我.遊戲.視圖.通知結束()
elif 我.玩家 == 0:
我.玩家 = 1
列, 行 = 電腦揀棒子(我.棒子們)
我.移動(列, 行)
我.玩家 = 0
def 遊戲結束(我):
return 我.棒子們 == [0, 0, 0]
def 通知移動(我, 列, 行):
if 我.棒子們[列] <= 行:
return
我.移動(列, 行)
class 棒子類(turtle.龜類):
def __init__(我, 列, 行, 遊戲):
turtle.龜類.__init__(我, visible=假)
我.列 = 列
我.行 = 行
我.遊戲 = 遊戲
x, y = 我.座標們(列, 行)
我.形狀(方形)
我.形狀大小(垂直單位常數/10.0, 水平單位常數/20.0)
我.速度(0)
我.提筆()
我.前往(x,y)
我.顏色(白)
我.顯龜()
def 座標們(我, 列, 行):
包裹, 餘數 = divmod(行, 5)
x = (3 + 11 * 包裹 + 2 * 餘數) * 水平單位常數
y = (2 + 3 * 列) * 垂直單位常數
return x - 幕寬常數 // 2 + 水平單位常數 // 2, 幕高常數 // 2 - y - 垂直單位常數 // 2
def 令移動(我, x, y):
if 我.遊戲.狀態 != 捻遊戲類.正在跑狀態:
return
我.遊戲.控制者.通知移動(我.列, 我.行)
class 捻遊戲視圖類(object):
def __init__(我, 遊戲):
我.遊戲 = 遊戲
我.幕 = 遊戲.幕
我.模型 = 遊戲.模型
我.幕.色模式(255)
我.幕.追蹤(假)
我.幕.背景色((240, 240, 255))
我.寫手 = turtle.龜類(visible=假)
我.寫手.提筆()
我.寫手.速度(0)
我.棒子們 = {}
for 列 in 範圍(3):
for 行 in 範圍(最大棒子數常數):
我.棒子們[(列, 行)] = 棒子類(列, 行, 遊戲)
我.display("... a moment please ...")
我.幕.追蹤(真)
def display(我, 訊息1, 訊息2=無):
我.幕.追蹤(假)
我.寫手.清除()
if 訊息2 is not 無:
我.寫手.前往(0, - 幕高常數 // 2 + 48)
我.寫手.筆色(紅)
我.寫手.寫(訊息2, align="center", font=("Courier",18,"bold"))
我.寫手.前往(0, - 幕高常數 // 2 + 20)
我.寫手.筆色(黑)
我.寫手.寫(訊息1, align="center", font=("Courier",14,"bold"))
我.幕.追蹤(真)
def 設立(我):
我.幕.追蹤(假)
for 列 in 範圍(3):
for 行 in 範圍(我.模型.棒子們[列]):
我.棒子們[(列, 行)].顏色(S顏色常數)
for 列 in 範圍(3):
for 行 in 範圍(我.模型.棒子們[列], 最大棒子數常數):
我.棒子們[(列, 行)].顏色(白)
我.display("輪到你！點擊一根棒子來移走它及其右邊的棒子")
我.幕.追蹤(真)
def 通知移動(我, 列, 行, 最大分裂數, 玩家):
if 玩家 == 0:
色彩 = H顏色常數
for s in 範圍(行, 最大分裂數):
我.棒子們[(列, s)].顏色(色彩)
else:
我.display(" ... thinking ... ")
time.sleep(0.5)
我.display(" ... thinking ... aaah ...")
色彩 = 顏色常數
for s in 範圍(最大分裂數-1, 行-1, -1):
time.sleep(0.2)
我.棒子們[(列, s)].顏色(色彩)
我.display("輪到你！點擊一根棒子來移走它及其右邊的棒子")
def 通知結束(我):
if 我.遊戲.模型.贏家 == 0:
訊息2 = "恭喜，你贏了！"
else:
訊息2 = "歹勢，電腦贏了！"
我.display("To play again press space bar. To leave press ESC.", 訊息2)
def 清除(我):
if 我.遊戲.狀態 == 捻遊戲類.遊戲結束狀態:
我.幕.清除()
class 捻遊戲控制者類(object):
def __init__(我, 遊戲):
我.遊戲 = 遊戲
我.棒子們 = 遊戲.視圖.棒子們
我.繁忙狀態 = 假
for 棒子 in 我.棒子們.values():
棒子.在點擊時(棒子.令移動)
我.遊戲.幕.在按鍵時(我.遊戲.模型.設立, 空白鍵)
我.遊戲.幕.在按鍵時(我.遊戲.視圖.清除, 脫離鍵)
我.遊戲.視圖.display("Press space bar to start game")
我.遊戲.幕.聽()
def 通知移動(我, 列, 行):
if 我.繁忙狀態:
return
我.繁忙狀態 = 真
我.遊戲.模型.通知移動(列, 行)
我.繁忙狀態 = 假
class 捻遊戲類(object):
被創造狀態 = 0
正在跑狀態 = 1
遊戲結束狀態 = 2
def __init__(我, 幕):
我.狀態 = 捻遊戲類.被創造狀態
我.幕 = 幕
我.模型 = 捻遊戲模型類(我)
我.視圖 = 捻遊戲視圖類(我)
我.控制者 = 捻遊戲控制者類(我)
def 主函數():
主螢幕 = turtle.幕類()
主螢幕.模式("standard")
主螢幕.設立(幕寬常數, 幕高常數)
nim = 捻遊戲類(主螢幕)
return "EVENTLOOP"
if __name__ == "__main__":
主函數()
turtle.主迴圈()
# Above: "tc_nim.py", by Renyuan Lyu (呂仁園), 2015-01-27
# Original: "nim.py", by Gregor Lingl.
Raw
tc_paint.py
#!/usr/bin/env python3
'''龜例如套房：
            tdemo_paint.py
一個簡單的事件驅動的畫圖程序
- 鼠標左鍵移動龜
- 鼠標中鍵的顏色變化
- 鼠標右鍵toogles betweem筆了
（沒有引出的烏龜移動時）和
下筆（行繪製） 。如果筆了如下
至少兩個落筆移動時，多邊形是
包括起點被充滿。
 -------------------------------------------
 點擊進入畫布玩
 使用三個鼠標鍵。
 -------------------------------------------
          要退出，請按STOP按鈕
 -------------------------------------------=== 以上由 Google 翻譯，請協助改善 ===
'''
from turtle_tc import *
def 切換上下(x=0, y=0):
if 筆()["pendown"]:
結束填()
提筆()
else:
下筆()
開始填()
def 改變顏色(x=0, y=0):
global 顏色們
顏色們 = 顏色們[1:]+顏色們[:1]
顏色(顏色們[0])
def 主函數():
global 顏色們
形狀("circle")
重設大小模式("user")
形狀大小(.5)
筆寬(3)
顏色們=[紅, 綠, 藍, 黃]
顏色(顏色們[0])
切換上下()
在點擊幕時(前往,1)
在點擊幕時(改變顏色,2)
在點擊幕時(切換上下,3)
return "EVENTLOOP"
if __name__ == "__main__":
訊息 = 主函數()
印(訊息)
主迴圈()
# Above: "tc_paint.py", by Renyuan Lyu (呂仁園), 2015-01-27
# Original: "paint.py", by Gregor Lingl.
Raw
tc_peace.py
#!/usr/bin/env python3
'''龜例如套房：
              tdemo_peace.py
適合作為初學者的一個簡單的繪圖
編程實例。除了
peacecolors分配和循環，
它僅使用龜命令。=== 以上由 Google 翻譯，請協助改善 ===
'''
from turtle_tc import *
def 主函數():
和平顏色們 = ("red3", 橙, 黃,
"seagreen4", "orchid4",
"royalblue1", "dodgerblue4")
重設()
幕類()
提筆()
前往(-320,-195)
筆寬(70)
for p顏色 in 和平顏色們:
顏色(p顏色)
下筆()
前進(640)
提筆()
後退(640)
左轉(90)
前進(66)
右轉(90)
筆寬(25)
顏色(白)
前往(0,-170)
下筆()
畫圓(170)
左轉(90)
前進(340)
提筆()
左轉(180)
前進(170)
右轉(45)
下筆()
前進(170)
提筆()
後退(170)
左轉(90)
下筆()
前進(170)
提筆()
前往(0,300) # 消失，如果hideturtle （ ）不可用; - ）
return "Done!"
if __name__ == "__main__":
主函數()
主迴圈()
# Above: "tc_peace.py", by Renyuan Lyu (呂仁園), 2015-01-27
# Original: "peace.py", by Gregor Lingl.
Raw
tc_penrose.py
#!/usr/bin/env python3
'''xturtle ，例如套房：
          xtx_kites_and_darts.py
構造兩個非週期性彭羅斯，平鋪，
由風箏和飛鏢，該方法
通脹的六個步驟。
出發點是圖案“太陽”
包括五個風箏和“明星”
由五個飛鏢。
欲了解更多信息，請參閱：
 http://en.wikipedia.org/wiki/Penrose_tiling
 -------------------------------------------=== 以上由 Google 翻譯，請協助改善 ===
'''
from turtle_tc import *
from math import cos, pi
from time import clock, sleep
f = (5**0.5-1)/2.0 # （ SQRT（ 5）-1 ）/ 2 - 黃金比例
d = 2 * cos(3*pi/10)
def 風箏(l):
fl = f * l
左轉(36)
前進(l)
右轉(108)
前進(fl)
右轉(36)
前進(fl)
右轉(108)
前進(l)
右轉(144)
def 飛鏢(l):
fl = f * l
左轉(36)
前進(l)
右轉(144)
前進(fl)
左轉(36)
前進(fl)
右轉(144)
前進(l)
右轉(144)
def 膨脹風箏(l, n):
if n == 0:
px, py = 位置()
h, x, y = int(頭向()), round(px,3), round(py,3)
瓦片字典[(h,x,y)] = 真
return
fl = f * l
左轉(36)
膨脹飛鏢(fl, n-1)
前進(l)
右轉(144)
膨脹風箏(fl, n-1)
左轉(18)
前進(l*d)
右轉(162)
膨脹風箏(fl, n-1)
左轉(36)
前進(l)
右轉(180)
膨脹飛鏢(fl, n-1)
左轉(36)
def 膨脹飛鏢(l, n):
if n == 0:
px, py = 位置()
h, x, y = int(頭向()), round(px,3), round(py,3)
瓦片字典[(h,x,y)] = 假
return
fl = f * l
膨脹風箏(fl, n-1)
左轉(36)
前進(l)
右轉(180)
膨脹飛鏢(fl, n-1)
左轉(54)
前進(l*d)
右轉(126)
膨脹飛鏢(fl, n-1)
前進(l)
右轉(144)
def 畫(l, n, th=2):
清除()
l = l * f**n
形狀大小(l/100.0, l/100.0, th)
for k in 瓦片字典:
h, x, y = k
設位置(x, y)
設頭向(h)
if 瓦片字典[k]:
形狀("風箏")
顏色(黑, (0, 0.75, 0))
else:
形狀("飛鏢")
顏色(黑, (0.75, 0, 0))
蓋章()
def 日(l, n):
for i in 範圍(5):
膨脹風箏(l, n)
左轉(72)
def 星(l,n):
for i in 範圍(5):
膨脹飛鏢(l, n)
左轉(72)
def 製造形狀們():
追蹤(0)
開始多邊形()
風箏(100)
結束多邊形()
登記形狀("風箏", 取多邊形())
開始多邊形()
飛鏢(100)
結束多邊形()
登記形狀("飛鏢", 取多邊形())
追蹤(1)
def 開始():
重設()
藏龜()
提筆()
製造形狀們()
重設大小模式("user")
def 測試(l=200, n=4, 函數=日, 開始位置=(0,0), th=2):
global 瓦片字典
前往(開始位置)
設頭向(0)
瓦片字典 = {}
a = clock()
追蹤(0)
函數(l, n)
b = clock()
畫(l, n, th)
追蹤(1)
c = clock()
印("Calculation: %7.4f s" % (b - a))
印("Drawing: %7.4f s" % (c - b))
印("Together: %7.4f s" % (c - a))
nk = len([x for x in 瓦片字典 if 瓦片字典[x]])
nd = len([x for x in 瓦片字典 if not 瓦片字典[x]])
印("%d kites and %d darts = %d pieces." % (nk, nd, nk+nd))
def 展示(函數=日):
開始()
for i in 範圍(8):
a = clock()
測試(300, i, 函數)
b = clock()
t = b - a
if t < 2:
sleep(2 - t)
def 主函數():
# 標題（“彭羅斯瓦片風箏和飛鏢。 ” ）
模式(角度從北開始順時針)
背景色(0.3, 0.3, 0)
展示(日)
sleep(2)
展示(星)
筆色(黑)
前往(0,-200)
筆色(0.7,0.7,1)
寫("Please wait...",
align="center", font=('Arial Black', 36, 'bold'))
測試(600, 8, 開始位置=(70, 117))
return "Done"
if __name__ == "__main__":
訊息 = 主函數()
主迴圈()
# Above: "tc_penrose.py", by Renyuan Lyu (呂仁園), 2015-01-27
# Original: "penrose.py", by Gregor Lingl.
Raw
tc_planet_and_moon.py
#!/usr/bin/env python3
'''龜例如套房：
        tdemo_planets_and_moon.py
使用重力系統仿真
從費曼-講座近似方法，
p.9-8 ，使用turtlegraphics 。
例如：沉重的中央機構，光的星球，
很輕的月亮！
地球上有一個圓形的軌道，月球穩定
軌道圍繞地球。
您可以暫時保持運動通過
按下鼠標左鍵與
鼠標移到畫布的滾動條。=== 以上由 Google 翻譯，請協助改善 ===
'''
from turtle_tc import *; from turtle_tc import 形狀類, 龜類, 主迴圈, 二維向量類 as 向量類
from time import sleep
G常數 = 8
class 重力系統類(object):
def __init__(我):
我.行星們 = []
我.t = 0
我.dt = 0.01
def 起始化(我):
for p in 我.行星們:
p.起始化()
def 開始(我):
for i in 範圍(10000):
我.t += 我.dt
for p in 我.行星們:
p.步進()
class 星類(龜類):
def __init__(我, m, x, v, 重力系統, 形狀):
龜類.__init__(我, shape=形狀)
我.提筆()
我.m = m
我.設位置(x)
我.v = v
重力系統.行星們.append(我)
我.重力系統 = 重力系統
我.重設大小模式("user")
我.下筆()
def 起始化(我):
dt = 我.重力系統.dt
我.a = 我.加速度()
我.v = 我.v + 0.5*dt*我.a
def 加速度(我):
a = 向量類(0,0)
for 行星 in 我.重力系統.行星們:
if 行星 != 我:
v = 行星.位置()-我.位置()
a += (G常數*行星.m/abs(v)**3)*v
return a
def 步進(我):
dt = 我.重力系統.dt
我.設位置(我.位置() + dt*我.v)
if 我.重力系統.行星們.index(我) != 0:
我.設頭向(我.朝向(我.重力系統.行星們[0]))
我.a = 我.加速度()
我.v = 我.v + dt*我.a
# 創建複合黃/藍turtleshape行星
def 主函數():
s = 龜類()
s.重設()
s.取幕().追蹤(0,0)
s.藏龜()
s.提筆()
s.前進(6)
s.左轉(90)
s.開始多邊形()
s.畫圓(6, 180)
s.結束多邊形()
m1 = s.取多邊形()
s.開始多邊形()
s.畫圓(6,180)
s.結束多邊形()
m2 = s.取多邊形()
行星形狀 = 形狀類("compound")
行星形狀.加成員(m1,橙)
行星形狀.加成員(m2,藍)
s.取幕().登記形狀("planet", 行星形狀)
s.取幕().追蹤(1,0)
# 設置重力系統
gs = 重力系統類()
日 = 星類(1000000, 向量類(0,0), 向量類(0,-2.5), gs, "circle")
日.顏色(黃)
日.形狀大小(1.8)
日.提筆()
地球 = 星類(12500, 向量類(210,0), 向量類(0,195), gs, "planet")
地球.筆色(綠)
地球.形狀大小(0.8)
月球 = 星類(1, 向量類(220,0), 向量類(0,295), gs, "planet")
月球.筆色(藍)
月球.形狀大小(0.5)
gs.起始化()
gs.開始()
return "Done!"
if __name__ == '__main__':
主函數()
主迴圈()
# Above: "tc_planet_and_moon.py", by Renyuan Lyu (呂仁園), 2015-01-27
# Original: "planet_and_moon.py", by Gregor Lingl.
Raw
tc_round_dance.py
'''龜例如套房：
         tdemo_round_dance.py
（需要烏龜模塊1.1版本
自帶的Python 3.1 ）
跳舞龜有複合形狀
由一系列的三角形
減小尺寸。
海龜沿著遊行一圈旋轉時
兩兩方向相反，與一個
例外。是否對稱，違反
增強例子的吸引力？
按任意鍵停止動畫。
技術上：演示使用的化合物
形狀，形狀的變換以及
克隆海龜。動畫是
通過更新控制（ ） 。=== 以上由 Google 翻譯，請協助改善 ===
'''
from turtle_tc import *
def 停止():
global 正在跑
正在跑 = 假
def 主函數():
global 正在跑
清除幕()
背景色("gray10")
追蹤(假)
形狀("triangle")
f = 0.793402
φ = 9.064678
s = 5
c = 1
# 創建複合形狀
sh = 形狀類("compound")
for i in 範圍(10):
形狀大小(s)
p =取形狀多邊形()
s *= f
c *= f
傾斜(-φ)
sh.加成員(p, (c, 0.25, 1-c), 黑)
登記形狀("multitri", sh)
# 創建舞者
形狀大小(1)
形狀("multitri")
提筆()
設位置(0, -200)
舞者們 = []
for i in 範圍(180):
前進(7)
傾斜(-4)
左轉(2)
更新()
if i % 12 == 0:
舞者們.append(複製())
回家()
# 舞蹈
正在跑 = 真
在按著鍵時(停止)
聽()
cs = 1
while 正在跑:
ta = -4
for 舞者 in 舞者們:
舞者.前進(7)
舞者.左轉(2)
舞者.傾斜(ta)
ta = -4 if ta > 0 else 2
if cs < 180:
右轉(4)
形狀大小(cs)
cs *= 1.005
更新()
return "DONE!"
if __name__=='__main__':
印(主函數())
主迴圈()
# Above: "tc_round_dance.py", by Renyuan Lyu (呂仁園), 2015-01-27
# Original: "round_dance.py", by Gregor Lingl.
Raw
tc_tree.py
#!/usr/bin/env python3
'''龜例如套房：
             tdemo_tree.py
顯示“廣度優先樹” - 對比
以經典的標誌樹繪圖程序，
其中使用一個深度優先算法。
用途：
（1）一個樹生成器，其中該圖是
準的副作用，而發電機
總是產生無。
（ 2 ）龜克隆：在每個分支點
當前筆被克隆。那麼到底
有1024海龜。=== 以上由 Google 翻譯，請協助改善 ===
'''
from turtle_tc import *; from turtle_tc import 龜類, 主迴圈
from time import clock
def 樹(p列表, l, a, f):
'''plist中是筆名單
    l為分支長度
    一個是半2分支之間的角度
    f是由哪個分支被縮短因子
    從一級到的水平。=== 以上由 Google 翻譯，請協助改善 ===
'''
if l > 3:
列表 = []
for p in p列表:
p.前進(l)
q = p.複製()
p.左轉(a)
q.右轉(a)
列表.append(p)
列表.append(q)
for x in 樹(列表, l*f, a, f):
yield 無
def 製造樹():
p = 龜類()
p.設回復暫存區(無)
p.藏龜()
p.速度(0)
p.取幕().追蹤(30,0)
p.左轉(90)
p.提筆()
p.前進(-210)
p.下筆()
t = 樹([p], 200, 65, 0.6375)
for x in t:
pass
印(len(p.取幕().龜群()))
def 主函數():
a=clock()
製造樹()
b=clock()
return "done: %.2f sec." % (b-a)
if __name__ == "__main__":
訊息 = 主函數()
印(訊息)
主迴圈()
# Above: "tc_tree.py", by Renyuan Lyu (呂仁園), 2015-01-27
# Original: "tree.py", by Gregor Lingl.
Raw
tc_two_canvases.py
'''turtledemo.two_canvases
使用TurtleScreen和RawTurtle繪製兩個
鮮明的畫布在一個單獨的窗口。該
新窗口必須單獨關閉
除了按STOP按鈕。=== 以上由 Google 翻譯，請協助改善 ===
'''
from turtle_tc import *; from turtle_tc import 龜幕類, 原龜類, TK
def 主函數():
根 = TK.Tk()
畫布1 = TK.Canvas(根, width=300, height=200, bg="#ddffff")
畫布2 = TK.Canvas(根, width=300, height=200, bg="#ffeeee")
畫布1.pack()
畫布2.pack()
s1 = 龜幕類(畫布1)
s1.背景色(0.85, 0.85, 1)
s2 = 龜幕類(畫布2)
s2.背景色(1, 0.85, 0.85)
p = 原龜類(s1)
q = 原龜類(s2)
p.顏色(紅, (1, 0.85, 0.85))
p.筆寬(3)
q.顏色(藍, (0.85, 0.85, 1))
q.筆寬(3)
for t in p,q:
t.形狀(龜形)
t.左轉(36)
q.左轉(180)
for t in p, q:
t.開始填()
for i in 範圍(5):
for t in p, q:
t.前進(50)
t.左轉(72)
for t in p,q:
t.結束填()
t.左轉(54)
t.提筆()
t.後退(50)
return "EVENTLOOP"
if __name__ == '__main__':
主函數()
TK.mainloop() # 保持窗口打開，直到用戶關閉
# Above: "tc_two_canvases.py", by Renyuan Lyu (呂仁園), 2015-01-27
# Original: "two_canvases.py", by Gregor Lingl.
Raw
tc_wikipedia.py
'''龜例如套房：
          tdemo_wikipedia3.py
本實施例是
靈感在龜維基百科文章
圖形。 （參見例如wikipedia1的網址）
首先，我們創建（ NE- 1 ） （即在這35
例如）複製我們的第一個烏龜P的。
然後，我們讓他們在履行自己的步驟
平行。
其次是一個完整的撤消（ ） 。=== 以上由 Google 翻譯，請協助改善 ===
'''
from turtle_tc import *; from turtle_tc import 幕類, 龜類, 主迴圈
from time import clock, sleep
def mn_eck(p, ne,sz):
龜列表 = [p]
# 創建NE -1的其他海龜
for i in 範圍(1,ne):
q = p.複製()
q.右轉(360.0/ne)
龜列表.append(q)
p = q
for i in 範圍(ne):
c = abs(ne/2.0-i)/(ne*.7)
# 讓那些NE海龜做了一步
# 並行：
for t in 龜列表:
t.右轉(360./ne)
t.筆色(1-c,0,c)
t.前進(sz)
def 主函數():
s = 幕類()
s.背景色(黑)
p=龜類()
p.速度(0)
p.藏龜()
p.筆色(紅)
p.筆粗(3)
s.追蹤(36,0)
at = clock()
mn_eck(p, 36, 19)
et = clock()
z1 = et-at
sleep(1)
at = clock()
while any([t.回復暫存區的個數() for t in s.龜群()]):
for t in s.龜群():
t.回復()
et = clock()
return "runtime: %.3f sec" % (z1+et-at)
if __name__ == '__main__':
訊息 = 主函數()
印(訊息)
主迴圈()
# Above: "tc_wikipedia.py", by Renyuan Lyu (呂仁園), 2015-01-27
# Original: "wikipedia.py", by Gregor Lingl.
Raw
tc_yinyang.py
#!/usr/bin/env python3
'''龜例如套房：
            tdemo_yinyang.py
另一種繪畫適合作為初學者的
編程實例。
小圓圈的圓形畫
命令。=== 以上由 Google 翻譯，請協助改善 ===
'''
from turtle_tc import *
def 陰(半徑, 顏色1, 顏色2):
筆寬(3)
顏色(黑, 顏色1)
開始填()
畫圓(半徑/2., 180)
畫圓(半徑, 180)
左轉(180)
畫圓(-半徑/2., 180)
結束填()
左轉(90)
提筆()
前進(半徑*0.35)
右轉(90)
下筆()
顏色(顏色1, 顏色2)
開始填()
畫圓(半徑*0.15)
結束填()
左轉(90)
提筆()
後退(半徑*0.35)
下筆()
左轉(90)
def 主函數():
重設()
陰(200, 黑, 白)
陰(200, 白, 黑)
藏龜()
return "Done!"
if __name__ == '__main__':
主函數()
主迴圈()
# Above: "tc_yinyang.py", by Renyuan Lyu (呂仁園), 2015-01-27
# Original: "yinyang.py", by Gregor Lingl.
Raw
turtle_docstringdict_tc.py
'''
turtle_docstringdict_tc.py
a doc file for turtle_tc.py
'''
#
# Translated automatically by Google Tranlator,
# Modified partially by Renyuan Lyu, in Taoyuan, Taiwan.
#
# renyuan.lyu@gmail.com
# http://google.com/+RenyuanLyu
#
docsdict = {
'Turtle.back':
'''後退 一段距離。
別名: 後退 | back | backward | bk
參數:
距離, distance -- 一個數字
龜向後移動一段距離，方向為目前龜頭的反方向。
不改變目前龜頭的方向。
示例(物件名為「小龜」的實例):
>>> 小龜.位置() # 位置 = position
(0.00,0.00)
>>> 小龜.後退(30) # 後退 = backward
>>> 小龜.位置()
(-30.00,0.00)
''',
'Turtle.begin_fill':
'''開始填色，在一塊形狀要被填色之前呼叫。
沒有參數。
示例(物件名為「小龜」的實例):
>>> 小龜.顏色(黑,紅)
>>> 小龜.開始填色()
>>> 小龜.畫圓(60)
>>> 小龜.結束填色()
''',
'Turtle.begin_poly':
'''開始紀錄多邊形的頂點。
沒有參數。
開始錄製多邊形的頂點。當前龜的位置
是多邊形的第一點。
示例(物件名為「小龜」的實例):
>>> 小龜.開始多邊形()
''',
'Turtle.circle':
'''畫圓，給定半徑。
參數:
半徑 - 一個數字
圓弧角度(可選) - 一個數字
步數(可選) - 一個整數
繪製給定半徑的圓。該中心是左側橈單位
烏龜的;程度 - 角 - 決定了哪一部分
圓畫。如果情況沒有給出,繪製整個圓。
如果範圍是不完整的圓,弧的一個端點是
當前筆位置。繪製圓弧逆時針方​​向
如果半徑為正,否則在順時針方向轉動。最後
烏龜的方向由程度的量改變。
由於圓是由一個內接正多邊形逼近,
步確定步驟,使用的數量。如果沒有給出,
它會自動計算。也許用於繪製常規
多邊形。
呼叫:圓(半徑)#完整的圓
- 或:圓(半徑,圓弧角度)#弧
- 或:圓(半徑,圓弧角度,步數)
- 或:圓(半徑,步數= 6)#6邊形
示例(物件名為「小龜」的實例):
>>> 小龜.畫圓(50)
>>> 小龜.畫圓(120,180) # 180度 代表 半圓
''',
'Turtle.clear':
'''清除 龜在螢幕上所畫的圖， 不移動龜。
沒有參數。
從螢幕中刪除龜所畫的圖。不要移動龜。
龜的位置和狀態以及其他的圖，
不會受到影響。
示例(物件名為「小龜」的實例):
>>> 小龜.清除()
''',
'Turtle.clearstamp':
'''清除蓋章 根據指定的編號
參數:
stampid - 一個整數,必須是曾經回傳的蓋章的編號。
示例(物件名為「小龜」的實例):
>>> 小龜.顏色(藍)
>>> 一個章= 小龜.蓋章()
>>> 小龜.前進(50)
>>> 小龜.清除蓋章(一個章)
''',
'Turtle.clearstamps':
'''清除蓋章群，所有的或前後 n 個 小龜的蓋章。
可選參數:
北 - 一個整數
if n is None, 清除全部,
elif n > 0 清除前n個,
elif n < 0 清除後n個。
示例(物件名為「小龜」的實例):
>>>for i in 範圍(8):
... 小龜.蓋章(); 小龜.前進(30)
...
>>> 小龜.清除蓋章群(2)
>>> 小龜.清除蓋章群(-2)
>>> 小龜.清除蓋章群()
''',
'Turtle.clone':
'''複製另一隻 龜。
沒有參數。
創建並回傳龜的複製品,有相同位置、標題
和屬性。
示例(物件名為「米克龜」的實例):
米克龜= 龜類()
喬伊龜= 米克龜.複製()
''',
'Turtle.color':
'''回傳或設定 顏色 並且 填色。
參數:
多種輸入格式是允許的。
它們用 0, 1, 2, 或3個參數, 如下所示:
顏色()
回傳當前的「筆色」和當前的「填色」
成為一對顏色字串作為回傳值
與 筆色() 和 填色() 2個函數的傳回值一樣。
顏色(colorstring),顏色((r,g,b)),顏色(r,g,b)
輸入筆色, 或同時輸入 筆色與填色,
為給定值。
顏色(colorstring1,colorstring2)
顏色((R1,G1,B1),(R2,G2,B2))
相當於筆色(colorstring1)和填色(colorstring2)
並且類似地,如果使用其他顏色的格式也一樣。
如果龜形是一個多邊形,輪廓和多邊形的內部
以新設置的顏色來繪製。
如需更多信息請參見: 筆色, 填色
示例(物件名為「小龜」的實例):
>>> 小龜.顏色(紅,綠)
>>> 小龜.顏色()
('red',"green")
>>> 顏色模式(255)
>>>顏色((40,80,120),(160,200,240))
>>>顏色()
('#285078','#a0c8f0')
''',
'Turtle.degrees':
'''設 角的度量單位為 「度數」。
可選參數:
fullcircle - 一個數字
設定角度測量單位,即設定數
'度'為一個完整的圓。Dafault值
為 360 度。
示例(物件名為「小龜」的實例):
>>> 小龜.左轉(90)
>>> 小龜.頭向()
90
可改變角的度量單位 為 grad ( 也稱作 gon, grade, 或 gradian)，
定義為「直角」定為 100 grads，所以全圓定為 400 grads。
>>> 小龜.角度(400.0)
>>> 小龜.頭向()
100
''',
'Turtle.distance':
'''回傳 從 本身位置 到 座標 x, y 的距離。
參數:
x - 一個數字或數字的一對/矢量或烏龜實例
Ÿ - 一些無無
呼叫: 距離(x,y) # 兩個坐標
- 或: 距離((x,y)) # 一對(元組)
- 或: 距離(vec) # 與 pos() 的回傳值一樣
- 或: 距離(mypen) # 其中 mypen 是另一個龜
示例(物件名為「小龜」的實例):
>>> 小龜.位置()
(0.00,0.00)
>>> 小龜.距離(30,40)
50.0
>>> 筆= 龜類()
>>> 筆.前進(77)
>>> 小龜.距離(筆)
77.0
''',
'Turtle.dot':
'''畫點，可指定直徑大小及顏色。
可選參數:
尺寸 - 一個整數 >= 1(如果有的話)
顏色 - 一個 colorstring 或 顏色的數字元組(r,g,b)
畫一個圓點, 使用給定的直徑大小及顏色。
如果直徑大小沒有給定, 就用 pensize +4 和 2 * pensize 中較大的值。
示例(物件名為「小龜」的實例):
>>> 小龜.畫點()
>>> 小龜.前進(50); 小龜.畫點(20,藍); 小龜.前進(50)
''',
'Turtle.down':
'''下筆 - 移動時畫圖。
別名: 下筆 | pendown | pd | down
沒有參數。
示例(物件名為「小龜」的實例):
>>> 小龜.下筆()
''',
'Turtle.end_fill':
'''結束填色，在呼叫過 開始填色() 後，呼叫本函數會把整個形狀填滿顏色。
沒有參數。
示例(物件名為「小龜」的實例):
>>> 小龜.顏色("黑","紅")
>>> 小龜.開始多邊形()
>>> 小龜.circle(60)
>>> 小龜.end_fill()
''',
'Turtle.end_poly':
'''停止記錄多邊形的頂點。
沒有參數。
停止記錄多邊形的頂點。當前龜位置為多邊形
最後一點。它將與第一點相連接。
示例(物件名為「小龜」的實例):
>>> 小龜.結束多邊形()
''',
'Turtle.fillcolor':
'''回傳或設定 填色。
參數:
四個輸入格式是允許的:
- 填色()
回傳當前的填色之顏色字串,
可能是十六進制數字格式(見示例)。
可以作為輸入到另一個 顏色/ 筆色/填色 函數的呼叫。
- 填色(colorstring)
colorstring 是一個 Tk 顏色字串,如 "紅色" 或 "黃色"
- 填色((r,g,b))
一個(r,g,b)顏色元組,
其中，每個 r,g,b 值的範圍在 0 .. colormode,
其中，colormode 是 1.0 或 255
- 填色(r,g,b)
如果 龜形 是多邊形, 該多邊形的內部用
新設定的顏色來填充。
示例(物件名為「小龜」的實例):
>>> 小龜.fillcolor('紫')
>>>山坳= 小龜.筆色()
>>> 小龜.fillcolor(COL)
>>> 小龜.fillcolor(0,0.5,0)
''',
'Turtle.filling':
'''測試是否正在填色。。
沒有參數。
示例(物件名為「小龜」的實例):
>>> 小龜.開始多邊形()
>>>if 小龜.正在填色():
... 小龜.筆大小(5)
... else:
... 小龜.筆大小(3)
''',
'Turtle.forward':
'''龜前進指定的距離。
別名: 前進 | forward | fd
參數:
距離, distance - 一個數字(整數或浮點數)
龜前進指定的距離, 往龜的頭之方向。
示例(物件名為「小龜」的實例):
>>> from turtle_tc import *
>>> 小龜= 龜類()
>>> 小龜.位置()
(0.00,0.00)
>>> 小龜.前進(25)
>>> 小龜.位置()
(25.00,0.00)
>>> 小龜.前進(-75)
>>> 小龜.位置()
(-50.00,0.00)
''',
'Turtle.get_poly':
'''回傳最近記錄的多邊形。
沒有參數。
示例(物件名為「小龜」的實例):
>>> p = 小龜.get_poly()
>>> 小龜.register_shape("myFavouriteShape", p)
''',
'Turtle.get_shapepoly':
'''回傳當前 多邊形 形狀 的 坐標 元組。
沒有參數。
示例(物件名為「小龜」的實例):
>>> 小龜.shape("正方形")
>>> 小龜.shapetransform(4,-1,0,2)
>>> 小龜.get_shapepoly()
((50,-20),(30,20),(-50,20),(-30,-20))
''',
'Turtle.getpen':
'''回傳 龜 物件。
沒有參數。
只有合理的使用:作為一個函數來回傳'匿名龜":
例如:
>>>寵物= getturtle()
>>>寵物.fd(50)
>>>寵物
<turtle.Turtle object at 0x0187D810>
>>>龜群()
[<turtle.Turtle object at 0x0187D810>]
''',
'Turtle.getscreen':
'''回傳 龜螢幕 物件, 龜就是在這上面畫圖。
沒有參數。
回傳 TurtleScreen 物件, 龜就是在這上面畫圖。
所以 TurtleScreen-方法 可以 被該物件呼叫。
示例(物件名為「小龜」的實例):
>>> 小龜的螢幕 = 小龜.getscreen()
>>> 小龜的螢幕
<turtle.TurtleScreen object at 0x0106B770>
>>> 小龜的螢幕.bgcolor("粉紅色")
''',
'Turtle.getturtle':
'''回傳 龜物件 本身。
沒有參數。
只有合理的使用: 作為一個函數來回傳 '匿名龜':
例如:
>>>寵物= getturtle()
>>>寵物.fd(50)
>>>寵物
<turtle.Turtle object at 0x0187D810>
>>>龜群()
[<turtle.Turtle object at 0x0187D810>]
''',
'Turtle.goto':
'''龜前往一個絕對位置。
別名: 前往 | setpos | setposition | goto:
參數:
x -- 一個數字 或 一對數字/向量
y -- 一個數字 或 無
呼叫: 前往(x,y) # 兩個坐標值
- 或: 前往((x,y)) # 一個元組
- 或: 前往(vec) # 與 pos() 回傳一樣。
龜移動到一個絕對位置。如果筆是下筆狀態,
將畫出一條線。龜頭的方向不會改變。
示例(物件名為「小龜」的實例):
>>> 位置 = 小龜.pos()
>>> 位置
(0.00,0.00)
>>> 小龜.setpos(60,30)
>>> 小龜.pos()
(60.00,30.00)
>>> 小龜.setpos((20,80))
>>> 小龜.pos()
(20.00,80.00)
>>> 小龜.setpos(TP)
>>> 小龜.pos()
(0.00,0.00)
''',
'Turtle.heading':
'''回傳當前龜頭的方向。
沒有參數。
示例(物件名為「小龜」的實例):
>>> 小龜.左轉(67)
>>> 小龜.頭向()
67.0
''',
'Turtle.hideturtle':
'''藏龜，把龜隱藏起來。
別名: 藏龜 | 藏 | hideturtle | ht
沒有參數。
當你在畫複雜的圖時，
這樣做是一個好主意，
因為隱藏龜會加快畫圖速度。
示例(物件名為「小龜」的實例):
>>> 小龜.藏()
''',
'Turtle.home':
'''回家，讓龜回到原點 - 坐標(0,0)。
沒有參數。
讓龜回到原點 - 坐標(0,0), 並設其龜頭方向
為初始狀態。
示例(物件名為「小龜」的實例):
>>> 小龜.回家()
''',
'Turtle.isdown':
'''測試是否為下筆狀態。傳回真假值(True/False)。
沒有參數。
示例(物件名為「小龜」的實例):
>>> 小龜.提筆()
>>> 小龜.isdown()
True
>>> 小龜.下筆()
>>> 小龜.isdown()
False
''',
'Turtle.isvisible':
'''測試是否為可見狀態。傳回真假值(True/False)。
沒有參數。
示例(物件名為「小龜」的實例):
>>> 小龜.hideturtle()
>>>小龜.isvisible()
False
''',
'Turtle.left':
'''龜左轉一個角度。
別名: 左轉 | left | lt
參數:
角度 - 一個數字(整數或浮點數)
龜左轉一個角度。(單位預設為「度數」(0~360),
但可以藉由設定 degrees() and radians() 來改變設置。)
角方向取決於初始模式。(請參閱...。)
示例(物件名為「小龜」的實例):
>>> 小龜.heading()
22.0
>>> 小龜.left(45)
>>> 小龜.heading()
67.0
''',
'Turtle.onclick':
'''針對 此龜在畫布上， 連結 點擊鼠鍵的事件 (mouse-click event) 到一個函數。
參數:
函數名 -- 有 2 個參數的函數之名稱,
該 2 個參數 代表 鼠鍵 點擊之位置的座標。
鼠鍵號碼 -- 1,2,3 代表 左、中、右鍵，預設為 1 (滑鼠左鍵)。
是否加 -- True或False。如果為True,新的連結將被加上, 否則
它將取消之前的連結。
舉例：針對「匿名龜」, 即較簡單的程序(procedural)的方式 (非物件導向型):
>>>def 轉彎(x,y):
... left(360)
...
>>>onclick(轉彎) # 現在 點擊事件 與 轉彎 函數 連結在一起。
>>>onclick(None) # 事件連結將被刪除
''',
'Turtle.ondrag':
'''針對 此龜在畫布上， 連結 移動滑鼠的事件 (mouse-move event) 到一個函數。
參數:
函數名 -- 有 2 個參數的函數之名稱,
該 2 個參數 代表 鼠鍵 點擊之位置的座標。
鼠鍵號碼 -- 1,2,3 代表 左、中、右鍵，預設為 1 (滑鼠左鍵)。
針對龜所作的滑鼠移動事件, 每一個事件序列前面都有一個
點擊鼠鍵的事件。
示例(物件名為「小龜」的實例):
>>> 小龜.ondrag(小龜.goto)
隨後的滑鼠點擊並拖拉會 在螢幕上 移動 龜
從而產生 handdrawings
(如果目前是處於下筆狀態的話 )。
''',
'Turtle.onrelease':
'''針對 此龜在畫布上， 連結 放開鼠鍵的事件 (mouse-button-release event) 到一個函數。
參數:
函數名 -- 有 2 個參數的函數之名稱,
該 2 個參數 代表 鼠鍵 點擊之位置的座標。
鼠鍵號碼 -- 1,2,3 代表 左、中、右鍵，預設為 1 (滑鼠左鍵)。
示例(物件名 為 喬伊龜 的 我的龜類 實例):
>>>class 我的龜類(龜類):
... def 發光(自己,x,y):
... 自己.填色("red")
... def 不發光(自己,x,y):
... 自己.填色("")
...
>>> 喬伊龜 = 我的龜類()
>>> 喬伊龜.onclick(喬伊龜.發光)
>>> 喬伊龜.onrelease(喬伊龜.不發光)
點擊 喬伊龜 讓它變成紅色, 不點擊 則把它給
變成透明的。
''',
################ ry @ 2014/03/14, 09:25 pm
'Turtle.pen':
'''回傳或設置筆的屬性。
參數:
筆 - 一個 Python 字典 資料型態，記錄著一些下面列出的關鍵字。
**筆字典 - 一個或多個 關鍵字=參數 的參數。
記錄著一些下面列出的關鍵字。
回傳或設置畫筆的屬性,在"筆字典"
用下面的 關鍵字/值 配對:
"shown" : True/False
"pendown" : True/False
"筆色" : color-string or color-tuple
"fillcolor" : color-string or color-tuple
"pensize" : positive number
"speed" : number in range 0..10
"resizemode" : "auto" or "user" or "noresize"
"stretchfactor": (positive number, positive number)
"剪切因子": number
"outline" : positive number
"tilt" : number
這本詞典可以作為參數進行後續
筆()調用來恢復以前的筆狀態。而且一個
以上這些屬性可以被設置為關鍵字參數。
這可以用來在一個語句中設置幾筆的屬性。
示例(物件名為「小龜」的實例):
>>> 小龜.pen(fillcolor="black", 筆色="red", pensize=10)
>>> 小龜.pen()
{'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
'筆色': 'red', 'pendown': True, 'fillcolor': 'black',
'stretchfactor': (1,1), 'speed': 3, '剪切因子': 0.0}
>>> penstate=小龜.pen()
>>> 小龜.顏色("yellow","")
>>> 小龜.提筆()
>>> 小龜.pen()
{'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
'筆色': 'yellow', 'pendown': False, 'fillcolor': '',
'stretchfactor': (1,1), 'speed': 3, '剪切因子': 0.0}
>>> p.pen(penstate, fillcolor="green")
>>> p.pen()
{'pensize': 10, 'shown': True, 'resizemode': 'auto', 'outline': 1,
'筆色': 'red', 'pendown': True, 'fillcolor': 'green',
'stretchfactor': (1,1), 'speed': 3, '剪切因子': 0.0}
''',
'Turtle.pencolor':
'''回傳或設 筆色。
參數:
四個輸入格式是允許的:
- 筆色()
回傳當前筆色顏色規範字符串,
可能在十六進制數字格式(見示例)。
可以作為輸入到另一個顏色/ 筆色 /填充顏色的呼叫。
- 筆色(colorstring)
s是一個Tk顏色規範字符串,如"紅色"或"黃色"
- 筆色((R,G,B))
* R,G,和B,它們代表,一個RGB彩色的元組*,
並且每個R,G,B的範圍在0 .. colormode,
其中colormode是1.0或255
- 筆色(R,G,B)
的r,g,和b表示RGB顏色和各r的,g和b
的範圍是0 .. colormode
如果龜形是多邊形,該多邊形的輪廓繪製
與新設置的筆色。
示例(物件名為「小龜」的實例):
>>> 小龜.筆色('棕色')
>>> TUP =(0.2,0.8,0.55)
>>> 小龜.筆色(TUP)
>>> 小龜.筆色()
'#33cc8c"
''',
'Turtle.pendown':
'''下筆 - 移動時繪製。
別名:落筆| PD |跌
沒有參數。
示例(物件名為「小龜」的實例):
>>> 小龜.下筆()
''',
'Turtle.pensize':
'''設置或回傳線條的粗細。
別名:pensize |寬度
參數:
寬度 - 正數
設置線的粗細與寬度或退貨。如果resizemode設置
"自動"和龜形是一個多邊形,該多邊形的繪製
相同的線的粗細。如果沒有給出參數,電流pensize
回傳。
示例(物件名為「小龜」的實例):
>>> 小龜.筆大小()
1
>>> 小龜.筆大小(10) #從現在開始以寬度為10線繪製
''',
'Turtle.penup':
'''提筆 -- 移動時無畫線。
別名:抬筆| PU |起來
沒有參數
示例(物件名為「小龜」的實例):
>>> 小龜.提筆()
''',
'Turtle.position':
''' 回傳 龜的當前位置(X,Y),資料型態是Vec2D向量。
別名:POS |位置
沒有參數。
示例(物件名為「小龜」的實例):
>>> 小龜.pos()
(0.00,240.00)
''',
'Turtle.radians':
'''設置角度測量單位為弧度(單位圓的弧長)。
沒有參數。
示例(物件名為「小龜」的實例):
>>> 小龜.heading()
90
>>> 小龜.radians()
>>> 小龜.heading()
1.5707963267948966
''',
'Turtle.reset':
'''重設，刪除龜的圖和恢復其預設值。
沒有參數。
從螢幕中刪除龜的圖紙,重新置中龜
並設置變量的缺省值。
示例(物件名為「小龜」的實例):
>>> 小龜.position()
(0.00,-22.00)
>>> 小龜.heading()
100.0
>>> 小龜.reset()
>>> 小龜.position()
(0.00,0.00)
>>> 小龜.heading()
0.0
''',
'Turtle.resizemode':
''' 重設大小模式: "auto", "user", "noresize"
(可選)參數:
RMODE - 的琴弦"自動"之一,"用戶","NORESIZE"
不同resizemodes具有以下效果:
- "自動"適應龜的外觀
對應於pensize的值。
- "用戶"適應龜根據外觀
的stretchFactor和outlinewidth(輪廓)的值,
這是由shapesize()設置
- "NORESIZE"沒有適應龜的外觀發生。
如果沒有給出參數,回傳當前resizemode。
resizemode("用戶")被調用帶參數調用shapesize的。
示例(物件名為「小龜」的實例):
>>> 小龜.resizemode("noresize")
>>> 小龜.resizemode()
"noresize"
''',
'Turtle.right':
'''右轉，一個角度。
別名:右| RT
參數:
角度 - 一個數字(整數或浮點數)
龜轉向右角度單位。(單位是默認度,
但可以通過度()和弧度()函數來設置。)
角方向取決於模式。(請參閱本。)
示例(物件名為「小龜」的實例):
>>> 小龜.heading()
22.0
>>> 小龜.right(45)
>>> 小龜.heading()
337.0
''',
'Turtle.setheading':
'''設龜頭的方向。
別名: setheading |賽斯
參數:
to_angle - 一個數字(整數或浮點數)
將龜to_angle的方向。
這裡有度數一些常見的方向:
標準模式 logo模式:
----------------|------------
0 - 東 | 北
90 - 北 | 東
180 - 西 | 南
270 - 南 | 西
示例(物件名為「小龜」的實例):
>>> 小龜.setheading(90)
>>> 小龜.heading()
90
''',
'Turtle.settiltangle':
'''旋轉龜形到指定的方向
參數:角度 - 數字
旋轉龜形指向的角度所指定的方向,
不管其目前的傾斜角度。不要更改龜的
標題(運動方向)。
示例(物件名為「小龜」的實例):
>>> 小龜.shape("turtle")
>>> 小龜.shapesize(5,2)
>>> 小龜.settiltangle(45)
>>> 蓋章()
>>> 小龜.fd(50)
>>> 小龜.settiltangle(-45)
>>> 蓋章()
>>> 小龜.fd(50)
''',
'Turtle.setundobuffer':
'''設置或禁用回復暫存區。
參數:
尺寸 - 一個整數或無
如果尺寸是整數給定大小的空白回復暫存區安裝。
尺寸給出了龜的行動可撤消的最大數目
使用undo()函數。
如果大小是無,無回復暫存區存在。
示例(物件名為「小龜」的實例):
>>> 小龜.set回復暫存區(42)
''',
'Turtle.setx':
'''設置龜的 x 坐標
參數:
x - 一個數字(整數或浮點數)
將龜的第一個坐標為x,離開第二個坐標
不變。
示例(物件名為「小龜」的實例):
>>> 小龜.position()
(0.00,240.00)
>>> 小龜.setx(10)
>>> 小龜.position()
(10.00,240.00)
''',
'Turtle.sety':
'''設置龜的 y 坐標
參數:
Ÿ - 一個數字(整數或浮點數)
將龜的第一個坐標為x,第二個坐標遺骸
不變。
示例(物件名為「小龜」的實例):
>>> 小龜.position()
(0.00,40.00)
>>> 小龜.sety(-10)
>>> 小龜.position()
(0.00,-10.00)
''',
'Turtle.shape':
'''設置龜形狀，指定形狀名稱 或 回傳當前形狀名稱。
可選參數:
名稱 - 一個字符串,它是一個有效的shapename
設置烏龜形狀塑造與給定的名稱,或者,如果名字沒有給出,
回傳當前形狀的名稱。
形狀與名必須存在於TurtleScreen的形狀字典。
目前有下列多邊形形狀:
'arrow', 'turtle', 'circle', 'square', 'triangle', 'classic'.
要了解如何處理形狀看螢幕方法 register_shape。
示例(物件名為「小龜」的實例):
>>> 小龜.shape()
'arrow'
>>> 小龜.shape('turtle')
>>> 小龜.shape()
'turtle'
''',
'Turtle.shapesize':
'''設置/回傳龜的 展延因子 /輪廓。設置 重設大小模式 為"user"。
可選參數:
stretch_wid:正數
stretch_len:正數
概述:正數
回傳或設置畫筆的屬性的x / y-展延因子和/或輪廓。
設置resizemode為"用戶"。
當且僅當resizemode被設置為"用戶",龜將被顯示
根據其展延因子拉伸:
stretch_wid是的stretchFactor垂直方向
stretch_len是的stretchFactor在龜定向方向。
綱要確定的形狀輪廓的寬度。
示例(物件名為「小龜」的實例):
>>> 小龜.resizemode("user")
>>> 小龜.shapesize(5,5,12)
>>> 小龜.shapesize(outline=8)
''',
'Turtle.shapetransform':
'''設置或回傳龜形狀的當前變換矩陣。
可選參數: t11, t12, t21, t22 -- 數字。
如果沒有適合的矩陣元素被給定的,則回傳該變換
矩陣。
否則設置給定的元素,改造龜形
根據矩陣組成的第一行T11,T12和
第二行T21,22。
根據修改的stretchFactor,剪切因子和tiltangle
給定矩陣。
示例(物件名為「小龜」的實例):
>>> 小龜.shape("square")
>>> 小龜.shapesize(4,2)
>>> 小龜.shearfactor(-0.5)
>>> 小龜.shapetransform()
(4.0,-1.0,-0.0,2.0)
''',
'Turtle.shearfactor':
'''設置或回傳當前剪切因子。
可選參數:剪切 - 號,切線剪切角的
根據給定的剪切因子剪切剪切龜形,
這是剪切角的正切值。不要更改
龜的標題(移動方向)。
如果剪切沒有給出:回傳當前剪切因子,即
剪切角的正切值,通過該線平行於
標題烏龜被剪切。
示例(物件名為「小龜」的實例):
>>> 小龜.shape("circle")
>>> 小龜.shapesize(5,2)
>>> 小龜.shearfactor(0.5)
>>> 小龜.shearfactor()
>>> 0.5
''',
'Turtle.showturtle':
'''顯龜，讓烏龜可見。
別名:showturtle | ST
沒有參數。
示例(物件名為「小龜」的實例):
>>> 小龜.hideturtle()
>>> 小龜.showturtle()
''',
'Turtle.speed':
'''回傳或設置龜的速度。
可選參數:
速度 - 範圍為0 .. 10或speedstring一個整數(見下文)
範圍為0 .. 10集烏龜的速度為整數值。
如果沒有給出參數:回傳當前速度。
若輸入大於10的一些大於或小於0.5時,
速度被設定為0。
Speed​​strings被映射到speedvalues​​以下面的方式:
'fastest' : 0
'fast' : 10
'normal' : 6
'slow' : 3
'slowest' : 1
速度從1至10的強制執行越來越快的動畫
畫線和龜轉折點。
注意:
速度= 0:*沒有*動畫發生。前進/後退,使龜跳
同樣地左/右使烏龜變成瞬間。
示例(物件名為「小龜」的實例):
>>> 小龜.speed(3)
''',
'Turtle.stamp':
'''蓋章，印記龜形的副本到畫布上,並回傳其 id 編號。
沒有參數。
郵票烏龜形狀的副本到畫布上的電流
龜位置。回傳stamp_id該郵票,它可以是
用於通過調用clearstamp將其刪除(stamp_id)。
示例(物件名為「小龜」的實例):
>>> 小龜.顏色("藍")
>>> 小龜.stamp()
13
>>> 小龜.fd(50)
''',
'Turtle.tilt':
'''傾斜形狀，一個角度。
參數:
角度 - 一個數字
通過角從目前的傾斜角度旋轉龜形,
但是不改變龜的前進方向。
示例(物件名為「小龜」的實例):
>>> 小龜.shape(""circle"")
>>> 小龜.shapesize(5,2)
>>> 小龜.tilt(30)
>>> 小龜.fd(50)
>>> 小龜.tilt(30)
>>> 小龜.fd(50)
''',
'Turtle.tiltangle':
'''設置或回傳當前的傾斜角度。
可選參數:角度 - 數字
旋轉龜形指向的角度所指定的方向,
不管其目前的傾斜角度。不要更改龜的
標題(運動方向)。
如果角度沒有給出:回傳當前的傾斜角度,即角
該龜形的方位的標題之間
龜(其運動方向)。
Python 3.1 不贊成使用
示例(物件名為「小龜」的實例):
>>> 小龜.shape("圓")
>>> 小龜.shapesize(5,2)
>>> 小龜.tilt(45)
>>> 小龜.tiltangle()
''',
'Turtle.towards':
'''計算並回傳 龜頭朝向 點(x,y) 的角度，亦即從龜的位置 到點(X,Y) 的線 的角度 (角度的度量是以東或北為起點)。
參數:
x - 一個數字或數字的一對/矢量或烏龜實例
Ÿ - 一些無無
呼叫:towards(X,Y) #兩個坐標
- 或:towards((X,Y)) #一對(元組)
- 或:towards(VEC) #例如,作為回傳()
- 或:towards(mypen) #,其中mypen是另一個龜
回傳的角度,該行從龜位置到位置之間
由x,y和龜的開始方向指定。(取決於
模式 - "標準"或"logo")
示例(物件名為「小龜」的實例):
>>> 小龜.pos()
(10.00,10.00)
>>> 小龜.towards(0,0)
225.0
''',
'Turtle.undo':
'''撤消(重複),最近的動作。
沒有參數。
撤消(重複),最後龜行動。
可撤消動作的數量是根據大小來決定
該回復暫存區。
示例(物件名為「小龜」的實例):
>>>for i in range(4):
... 小龜.fd(50); 小龜.lt(80)
...
>>>for i in range(8):
... 小龜.undo()
...
''',
'Turtle.undobufferentries':
'''回傳的條目數在回復暫存區。
沒有參數。
示例(物件名為「小龜」的實例):
>>>while undobufferentries():
... undo()
''',
'Turtle.write':
'''在當前位置 寫字。
參數:
精氨酸 - 信息,它被寫入到TurtleScreen
移動(可選) - 真/假
對齊(可選) - 在字符串中的一個"左","中心"或右"
字體(可選) - 三(字體名,字號,fonttype)
寫文字 - arg的字符串表示形式 - 在當前
根據對準龜位置("左","中心"或右")
並用給定的字體。
如果此舉是真,筆移動到右下角
的文字。默認情況下,此舉為False。
示例(物件名為「小龜」的實例):
>>> 小龜.write('首頁=', True, align="center")
>>> 小龜.write((0,0),True)
''',
'Turtle.xcor':
'''回傳龜的x坐標。
沒有參數。
示例(物件名為「小龜」的實例):
>>>重設()
>>>小龜.left(60)
>>>小龜.forward(100)
>>>小龜.xcor()
50.0
''',
'Turtle.ycor':
'''回傳龜的y坐標
---
沒有參數。
示例(物件名為「小龜」的實例):
>>>重設()
>>>小龜.left(60)
>>>小龜.forward(100)
>>>小龜.ycor()
86.6025403784
''',
### by renyuan, 2014/03/15
'_Screen.bgcolor':
'''背景色，設置或回傳 TurtleScreen 中的 backgroundColor。
參數(如果有):顏色字符串或三個數字
在範圍0 .. colormode或一個三元組這樣的數字。
示例(物件名為「螢幕」的實例):
>>> 螢幕.bgcolor("橙色")
>>> 螢幕.bgcolor()
"橙色"
>>> 螢幕.bgcolor(0.5,0,0.5)
>>> 螢幕.bgcolor()
'#800080'
''',
'_Screen.bgpic':
'''背景圖，設置或回傳背景圖片。
可選參數:
picname - 一個GIF文件或"nopic"的字符串,名稱。
如果picname是一個文件名,設置相應的圖片作為背景。
如果picname是"nopic",刪除將backgroundImage,如果存在的話。
如果picname是無,回傳當前和backgroundImage的文件名。
示例(物件名為「螢幕」的實例):
>>> 螢幕.bgpic()
"nopic"
>>> 螢幕.bgpic("landscape.gif")
>>> 螢幕.bgpic()
"landscape.gif"
''',
'_Screen.bye':
'''關閉 turtlegraphics 視窗。
示例(物件名為「螢幕」的實例):
>>> 螢幕.bye()
''',
'_Screen.clearscreen':
'''清除螢幕，從 TurtleScreen 刪除所有圖和龜。
沒有參數。
復位空TurtleScreen到其初始狀態:白色背景,
沒有將backgroundImage,沒有eventbindings和跟踪。
示例(物件名為「螢幕」的實例):
>>> 螢幕.clear()
注意:這個方法不作函數使用。
''',
'_Screen.colormode':
'''回傳 colormode 或將其設置為 1.0 或 255。
可選參數:
CMODE - 值 1.0 或 255 之一
r, g, b colortriples的B值必須在範圍0 .. CMODE。
示例(物件名為「螢幕」的實例):
>>> 螢幕.colormode()
1.0
>>> 螢幕.colormode(255)
>>> 筆色(240,160,80)
''',
'_Screen.delay':
'''回傳或設置畫面更新的延遲時間 以毫秒為單位。
可選參數:
延遲 - 正整數
示例(物件名為「螢幕」的實例):
>>> 螢幕.delay(15)
>>> 螢幕.delay()
15
''',
'_Screen.exitonclick':
'''在點擊時離開。 進入到主​​迴圈, 直到鼠標點擊, 關閉視窗, 優雅地離開。。
沒有參數。
綁定再見()方法來點擊鼠標就TurtleScreen。
如果"using_IDLE" - 在配置詞典值為False
(默認值),進入主循環。
如果空閒與-n開關(無子)時,該值應為
設置為True 小龜.cfg。在這種情況下,空閒的主循環
活躍也為客戶端腳本。
這是絲網類的方法和沒有可用的
TurtleScreen實例。
示例(物件名為「螢幕」的實例):
>>> 螢幕.exitonclick()
''',
'_Screen.getcanvas':
'''回傳一個 畫布 物件 在這個 TurtleScreen 之上。
沒有參數。
示例(物件名為「螢幕」的實例):
>>> 畫布 = 螢幕.getcanvas()
>>>畫布
<小龜.ScrolledCanvas instance at 0x010742D8>
''',
'_Screen.getshapes':
'''取形狀列表，回傳所有當前可用的龜形狀的名稱列表。
沒有參數。
示例(物件名為「螢幕」的實例):
>>> 螢幕.getshapes()
['arrow', 'blank', 'circle', ... , 'turtle']
''',
'_Screen.listen':
'''聽，設置聚焦於 TurtleScreen 之上(為了收集鍵盤事件)
沒有參數。
偽參數是為了提供
要能夠通過聽取的onclick方法。
示例(物件名為「螢幕」的實例):
>>> 螢幕.listen()
''',
'_Screen.mainloop':
'''進入主迴圈，啟動事件循環 - 呼叫 Tkinter的主迴圈函數。
沒有參數。
必須是龜畫圖程式的最後一條語句。
不得使用於程式是在IDLE 內部 -n 模式(無子程式 )下運行，
亦即互動模式的龜畫圖程式。
示例(物件名為「螢幕」的實例):
>>> 螢幕.mainloop()
''',
'_Screen.mode':
'''設置龜模式('standard', 'logo' or 'world'),並執行重設。
可選參數:
模式 - 在3 個字串('standard', 'logo' or 'world')選一個。
模式,"標準"是小龜.py兼容。
模式'標誌'是最標誌 - 龜背顯卡兼容。
模式'世界'使用用戶自定義"worldcoordinates"。*注意*:在
這種模式的角度看來,如果x / y的單位比不等於1扭曲。
如果模式沒有給出,回傳當前的模式。
模式初始龜標題正角
------------ | ------------------------- | ----------- --------
"標準"向右(東)逆時針
'標識'向上(北)順時針
示例:
>>>模式('logo') # 重設龜頭向北
>>>模式()
'logo'
''',
'_Screen.numinput':
'''彈出一個對話窗口, 可以 輸入 一個數字。
參數:
title: 是對話框窗口的標題,
prompt: 提示語， 主要是描述什麼數字信息輸入文本。
default: 預設值
minval: 最小值
maxval: 最大值
數字輸入必須在範圍MINVAL .. MAXVAL,如果這些是
給出。如果沒有,有一絲簽發,對話框將保持打開的校正。回傳數字的輸入。
如果取消該對話框,回傳None。
示例(物件名為「螢幕」的實例):
>>> 螢幕.numinput("撲克","你的賭注:",1000,minval=10, maxval=10000)
''',
'_Screen.onkey':
'''在按鍵時，連結函數 於 鍵盤鍵鬆開事件。
參數:
函數 - 不帶參數的函數
鍵盤鍵 - 一個字串: 文字鍵(如"a")或 符號鍵(如"空白")
為了能夠收集鍵盤鍵事件 TurtleScreen
必須取得聚焦。(參考 聽 函數。)
示例(物件名為「螢幕」的實例):
>>> def f():
... fd(50)
... lt(60)
...
>>> 螢幕.onkey(f, 向上鍵)
>>> 螢幕.listen()
上面這段程式碼，讓使用者可以重複按向上鍵，
來畫出一個六邊形。
''',
'_Screen.onkeypress':
'''在按下鍵時，連結函數 於 單一鍵盤鍵按下事件。如果有指定鍵的話；
或任何按鍵事件,如果沒有指定鍵的話。
參數:
函數 - 不帶參數的函數
鍵盤鍵 - 一個字串: 文字鍵(如"a")或 符號鍵(如"空白")
為了能夠收集鍵盤鍵事件 TurtleScreen
必須取得聚焦。(參考 聽 函數。)
示例(物件名為「螢幕」的實例):
>>> def f():
... fd(50)
... lt(60)
...
>>> 螢幕.onkeypress(f, 向上鍵)
>>> 螢幕.listen()
上面這段程式碼，讓使用者可以重複按向上鍵，
來畫出一個六邊形。
''',
'_Screen.onkeyrelease':
'''在按鍵時，連結函數 於 鍵盤鍵鬆開事件。
參數:
函數 - 不帶參數的函數
鍵盤鍵 - 一個字串: 文字鍵(如"a")或 符號鍵(如"空白")
為了能夠收集鍵盤鍵事件 TurtleScreen
必須取得聚焦。(參考 聽 函數。)
示例(物件名為「螢幕」的實例):
>>> def f():
... fd(50)
... lt(60)
...
>>> 螢幕.onkeyrelease(f, 向上鍵)
>>> 螢幕.listen()
上面這段程式碼，讓使用者可以重複按向上鍵，
來畫出一個六邊形。
''',
'_Screen.onscreenclick':
'''在螢幕點擊時，連結函數 於 畫布上的 點擊鼠標的事件。
參數:
函數 - 有兩個參數 x , y
代表滑鼠點擊在畫布上的點坐標。
鼠鍵號碼 - 預設為1的數，1,2,3分別代表左、中、右
舉例(名為「螢幕」的 TurtleScreen 的實例)
>>> 螢幕.onclick(goto)
>>>#隨後點擊進入TurtleScreen會
>>>#使龜移動到點擊點。
>>> 螢幕.onclick(None) # 解除連結
''',
'_Screen.ontimer':
'''設定計時器, t 毫秒後，就呼叫函數。
參數:
函數 - 不帶參數的函數。
t - 一個數 > = 0
示例(物件名為「螢幕」的實例):
>>> 正在執行 = True
>>> def f():
... if 正在執行:
... fd(50)
... lt(60)
... 螢幕.ontimer(f, 250)
...
>>> f() # makes the turtle marching around
>>> 正在執行 = False
''',
'_Screen.register_shape':
'''添加一個龜形狀 TurtleScreen 的 形狀列表。
參數:
(1)名稱是一個GIF文件的檔案名而形狀是None。
安裝相應的圖像形狀。
！轉彎時,圖像的形狀不會旋轉,
！所以他們不會顯示龜的頭！
(2)名稱是一個任意的字串和形狀是一個元組(tuple)
的坐標對子。設定相應的
多邊形
(3)名稱是一個任意的字符串,形狀是
(複合的)Shape 物件。設定相應的
複合形狀。
使用形狀,你必須發出 形狀(shapename) 這個指令。
呼叫:register_shape("小龜.gif")
- 或者:register_shape("tri",((0,0),(10,10),(-10,10)))
示例(物件名為「螢幕」的實例):
>>> 螢幕.register_shape("三角形",((5,-3),(0,5),(-5,-3)))
''',
'_Screen.resetscreen':
'''重設螢幕上的所有龜為其初始狀態。
沒有參數。
示例(物件名為「螢幕」的實例):
>>> 螢幕.reset()
''',
'_Screen.screensize':
'''重設畫布大小。
可選參數:
canvwidth - 正整數,畫布以像素為單位的新寬度
canvheight - 正整數,畫布以像素為單位的新高度
bg - colorstring或顏色元組,新的backgroundColor
如果沒有指定參數,回傳目前的值(canvaswidth,canvasheight)
不要改變繪圖窗口。觀察的隱蔽部位
在畫布上使用滾動條。(可以使可見的部分
的圖紙,這是在畫布前外！)
示例(物件名為「小龜」的實例):
>>> 小龜.screensize(2000,1500)
>>>#例如,要尋找一個犯錯而逃脫的龜;-)
''',
'_Screen.setup':
'''設主視窗的大小和位置。
參數:
寬: 若為整數就是以像素為單位，若為浮動數則是在螢幕的百分比。
預設為值是螢幕的50%。
高:若為整數就是以像素為單位，若為浮動數則是在螢幕的百分比。
預設為值是螢幕的75%。
startx: 如為正數,從左邊螢幕的邊緣開始算位置
如為負數,從右邊螢幕的邊緣開始算位置
預設情況下,startx = None 是水平居中。
starty: 如為正數,從上邊螢幕的邊緣開始算位置
如為負數,從下邊螢幕的邊緣開始算位置
預設情況下,starty = None 是垂直居中。
示例(物件名為「螢幕」的實例):
>>> 螢幕.setup(width=200, height=200, startx=0, starty=0)
設主視窗，寬高為 200×200 像素,在螢幕的左上角
>>> 螢幕.setup(width=.75, height=0.5, startx=None, starty=None)
設主視窗的寬高為螢幕寬高的75%及50%
''',
'_Screen.setworldcoordinates':
'''設坐標系，設置一個使用者定義的坐標系。
參數:
llx -- 畫布的左下角x坐標
lly -- 畫布的左下角y坐標
urx -- 畫布的右上角x坐標
ury -- 畫布的右上角y坐標
設置用戶coodinat系統,並在必要時切換到'world'模式。
這將執行一個螢幕.reset。如果'world'模式已經啟動,
所有圖都會根據新的坐標系重畫。
但要注意:在使用者定義的坐標系中，角度可能會出現
扭曲。(見Screen.mode())
示例(物件名為「螢幕」的實例):
>>> 螢幕.setworldcoordinates(-10, -0.5, 50, 1.5)
>>> for _ in range(36):
... left(10)
... forward(0.5)
''',
'_Screen.textinput':
'''文字輸入，彈出一個對話窗, 可讓使用者輸入一個字串。
參數:
標題：是對話框視窗的標題,
提示：主要是描述什麼信息輸入文本。
回傳：輸入字串
如果取消該對話框, 回傳 None。
示例(物件名為「螢幕」的實例):
>>> 螢幕.textinput("NIM","第一個球員的名字:")
''',
'_Screen.title':
'''標題，設置龜視窗的標題
參數:
titlestring - 一個字串,出現在龜視窗的標題欄
這是螢幕類的方法。不適用於 TurtleScreen-
物件。
示例(物件名為「螢幕」的實例):
>>> 螢幕.title("歡迎來到龜動物園！")
''',
'_Screen.tracer':
'''追蹤器，開/關 龜動畫 並設置更新畫面的延遲時間。
可選參數:
n - 非負整數
延遲 - 非負整數
如果 n 有被指定的,只執行每n次定期螢幕更新。
(可用於加速複雜圖形的繪製。)
第二個參數設置延遲值(見 RawTurtle.delay() )
示例(物件名為「螢幕」的實例):
>>>螢幕.tracer(8,25)
>>>距離= 2
>>>for i in range(200):
... fd(距離)
... rt(90)
... 距離 += 2
''',
'_Screen.turtles':
'''龜列表，回傳螢幕上龜列表。
示例(物件名為「螢幕」的實例):
>>> 螢幕.turtles()
[<turtle.Turtle object at 0x00E11FB0>]
''',
'_Screen.update':
'''執行 TurtleScreen 更新。
''',
'_Screen.window_height':
'''視窗高，回傳龜視窗的高度。
示例(物件名為「螢幕」的實例):
>>> 螢幕.window_height()
480
''',
'_Screen.window_width':
'''視窗寬，回傳龜視窗的寬度。
示例(物件名為「螢幕」的實例):
>>> 螢幕.window_width()
640
'''
}
# ver01, by Renyuan, 2014/03/16 01:49 am
Raw
turtle_tc.py
'''
turtle_tc_2015.py --> turtle_tc.py
Renyuan Lyu
2014/05/25,
last updated:
2014/12/24,
2015/01/18
renyuan.lyu@gmail.com
google.com/+RenyuanLyu
Inspired by the MIT Scratch project,
a program language capable of supporting programmers' native language ,
will allow more people ( particularly non-English-speaking kids ) able to write the program more fluently.
Starting from Python version 3.0 , names of variables, functions, and classes are encoded in utf-8 ,
that is to say, programmers can write programs in their mother languages.
I think this will be a key point to make Python overspread even broader and broader.
As long as we can get into many python's modules, provide a set of name aliases for each class, method, and import global variables, then kids or naive people can also write their own programs. Kids include those from K to 12 in non-English-speaking countries, who are not fluent nor possess enough vocabulary in English.
This program/module implementing the idea is one of the few first tries,
it is an appendix to the Python built-in modules turtle.py,
which is majorly a bunch of traditional Chinese alias of English name.
This file is named as turtle_tc.py, to emphasize it is majorly in traditional Chinese.
Similar modification can be made to make it suitable in any non-English language.
This file can be run by itself,
it can also be put in the path of Python library,
and be imported by the other application of turtle programs
To use Chinese names could not only make the program more readable for local Chinese speaking programmers,
it could also make the program more compact, dense and beautiful.
Renyuan Lyu
2014/05/24
renyuan.lyu@gmail.com
google.com/+RenyuanLyu
turtle_tc_01.py
開始超朝向自動翻譯方向前進。
先做出中英對照表。
2014/04/19
============================
用 Python 3，學中文程式設計。
============================
繁體中文龜
----------
使用這個模組，可以讓你使用繁體中文來控制龜畫圖。
作者：呂仁園。
-------------
受了 MIT Scratch project 的啟發，
讓 programming language 能夠以程式員的母語來表達，
將是讓更多人(特別是非英語為母語的小孩)能夠來寫程式的一個關鍵要素。
Python 3.0 以後， 變數、函數、
以及物類、方法、屬性等名稱都使用 Utf-8 編碼，
允許 程式員 運用 其母語來寫作程式，
只要我們鑽進眾多模組內部，為每個物類的函數名稱給個母語別名，
再把相應的 doc 文件說明也轉成母語，
這個基本工程將建立起母語寫作程式的基礎環境，
程式教育就有可能向下紮根，到達高中，甚至是國中的階段。
本程式模組就是在這個想法之下的首次嘗試，
我們把 Python 中， 一個頗負盛名的模組，turtle.py，
為其提供一個繁體中文 (traditional Chinese) 的附加模組，
命名為 turtle_tc.py，
使用者只要把本程式模組放在 python 環境下，模組的搜尋路徑內，
一般為當前程式碼的目錄 (current dir)或是 C:/Python3.x/Lib/，
那麼，你就可以用
import turtle_tc
來取代
import turtle
進而，運用中文來寫基於 龜 的作圖程式，就成為可能。
last updated: 2014/12/24, 2015/01/21
'''
#
# The following are imported in turtle.py originally
# they will not be imported automatically using
#
# from turtle import *
#
# so we need include them here
#
import tkinter as TK
import types
import math
import time
import inspect
import sys
from os.path import isfile, split, join
from copy import deepcopy
from tkinter import simpledialog
# ############################################
import random
from turtle import *
from turtle import _CFG, _Screen, _Root, TK, _TurtleImage, Tbuffer, TurtleGraphicsError
from turtle import TurtleScreenBase, TurtleScreen, TNavigator, TPen, RawTurtle, Canvas #, Turtle, Screen
import inspect as ip
import random as rd
'''
隨機數= rd.random
隨機整數= rd.randint
時間= time.time
睡= time.sleep
'''
from turtle_tc_alias import * ## 把所有別名列表都移出去了
classBeChanged= [
'Vec2D',
'Shape',
'TurtleScreenBase',
'TurtleScreen',
'TNavigator',
'TPen',
'RawTurtle',
'_Screen',
'Screen', # this is a little bit strange, Screen is a function
'Turtle'
]
#
# 印出 物類內 別名表，可供 程式員 參考，以及作為 自動翻譯 的依據
#
def 印出物類內別名表():
global classBeChanged
for y in classBeChanged:
cList= 'cList'+y
ec= eval(cList)
print('\n'+'-'*20)
print('class ', y)
print('-'*20+'\n')
for x in ec:
print(x)
print('='*60+'\n')
#印出物類內別名表()
aClassL=[]
bClassL=[]
cClassL=[]
for y in classBeChanged: #= 'TurtleScreenBase'
ey= eval(y)
aClass= ip.getsource(ey)
aClassL+= [aClass]
#classTurtleScreenBase=''
cList= 'cList'+y
ec= eval(cList)
#bClassL=[]
for x in ec[1:]:
for n in range(1,len(x)):
bClass= ' '*4 + x[n] +'= ' + x[0] +'\n'
#
# 物類 內， 有 4 個空白
#
aClass+= bClass
bClassL+= [bClass]
x= ec[0]
#cClassL=[]
for n in range(1,len(x)):
cClass= x[n] +'= ' + x[0] +'\n'
#
# 物類 外， 無 4 個空白。
#
aClass+= cClass
cClassL+= [cClass]
#print(aClass)
exec(aClass)
#
# 這一行是「別名」的關鍵語句
#
#'''
別名表 = 字串別名表 + 函數別名表
aCmd=''
for e in 別名表:
#exec(e[1] + '=' + e[0] )
for n in range(1,len(e)):
aCmd += e[n] + '='+ e[0] + '\n'
#print(aCmd)
exec(aCmd)
X=[]
for y in 總別名表:
for x in y:
X += [x]
中英對照表= sorted(X)
def 印中英對照表():
print('-'*20)
print('中英對照表')
print('-'*20)
for i,x in enumerate(中英對照表):
print(i,x)
if __name__=='__main__':
印中英對照表()
#
#
#
#'''
#
# 設法來寫 help ...
#
def read_docstrings(lang=''):
"""Read in docstrings from lang-specific docstring dictionary.
Transfer docstrings, translated to lang, from a dictionary-file
to the methods of classes Screen and Turtle and - in revised form -
to the corresponding functions.
"""
#modname = "turtle_docstringdict_%(language)s" % {'language':lang.lower()}
modname = "turtle_docstringdict_tc"
#
# turtle_docstringdict_tc.py
#
# 這是繁體中文說明文件，還在翻譯當中，先有個版本來寫程式。
# 2014/03/22
#
bMsg= '''這是繁體中文說明文件，
還在翻譯當中，尚未完成，先行請您試閱並包容錯誤，
一切仍以英文說明為主。 2014/03/22
'''
aMsg='中文說明'
try:
module = __import__(modname)
except:
print('%s.py 不存在， 略過！ turtle_tc 還是可用，只是沒有中文求助功能！'%modname)
return
docsdict = module.docsdict
i= 0
for key in docsdict:
try:
#eval(key).im_func.__doc__ = docsdict[key] # 這行本來就 被原作者 mark 掉。
#
# 原作者用這行。
#
#eval(key).__doc__ = docsdict[key] # original version
#
# 我把它改成如下。
#
#eval(key).__doc__ += '\n\n'+ docsdict[key] # renyuan make it += from =
eval(key).__doc__ = '『%04d '%(i)+ aMsg + '』\n'+ docsdict[key] + '\n\n' + eval(key).__doc__ # 出現次序調一下。
#
# 從原始 turtle.py 挖出這行程式碼，很珍貴。把 = 改成 += 就可把中文 help 黏進去
#
i+= 1
except:
print('''%s 說明文件輸入有誤，請檢查： %s
'''% (modname, key))
#'''
讀入繁體中文說明文件= read_docstrings
try:
讀入繁體中文說明文件()
except:
print('想要 讀入繁體中文說明文件()，但是 %s.py 不存在，先略過。'%modname)
#'''
'''
for methodname in _tg_screen_functions:
pl1, pl2 = getmethparlist(eval('_Screen.' + methodname))
if pl1 == "":
print(">>>>>>", pl1, pl2)
continue
defstr = ("def %(key)s%(pl1)s: return _getscreen().%(key)s%(pl2)s" %
{'key':methodname, 'pl1':pl1, 'pl2':pl2})
exec(defstr)
eval(methodname).__doc__ = _screen_docrevise(eval('_Screen.'+methodname).__doc__)
'''
#
# 把類別內 函數 釋放到 類別外
#
#
# 從 turtle.py 學來的，還沒消化。
#
#
# 主要是把 物類內函數 的 (self, ...) 變成 (...)
#
from turtle import __all__
__tcAll__= __all__[:]
from turtle import getmethparlist #, _getpen, _getscreen, _turtle_docrevise, _screen_docrevise #, _Screen, Turtle
'''
_龜= 龜類()
_幕= 幕類()
'''
def _取筆():
"""Create the 'anonymous' turtle if not already present."""
if 龜類._pen is None:
龜類._pen= 龜類()
return 龜類._pen
def _取幕():
"""Create a TurtleScreen if not already present."""
if 龜類._screen is None:
龜類._screen = _幕類() ###### 會不會就是這行搞鬼？？ 有無底線之分！
return 龜類._screen
memberOfTurtle= ip.getmembers(龜類)
memberOfScreen= ip.getmembers(_幕類)
methodPutToMain=[]
cmdString=''
for mem in memberOfTurtle:
m, mid= mem
methodname= m
#
# 暴力 debug
#
if methodname == 'screens':
continue
if ord(m[0])>= ord('a'): #128: # 這一行是為了 僅要 中文 部分，英文部分原作者已經有，不需我多寫。
'''
cmd= m + '= ' + 'Turtle.' + m + '\n'
cmdString += cmd
'''
methodPutToMain += [m]
try:
pl1, pl2 = getmethparlist(eval('龜類.' + methodname))
if pl1 == "":
print(">>>>>>", pl1, pl2)
continue
defstr = ("def %(key)s%(pl1)s: return _取筆().%(key)s%(pl2)s" %
{'key':methodname, 'pl1':pl1, 'pl2':pl2})
cmdString += defstr +'\n\n'
exec(defstr)
eval(methodname).__doc__ = eval('龜類.'+methodname).__doc__ # _turtle_docrevise(eval('龜類.'+methodname).__doc__)
except:
print('龜類.' + methodname +' No put to main')
for mem in memberOfScreen:
m, mid= mem
methodname= m
#
# 暴力 debug
#
if methodname == 'screens':
continue
if ord(m[0])>= ord('a'): #128:
'''
cmd= m + '= ' + 'Turtle.' + m + '\n'
cmdString += cmd
'''
methodPutToMain += [m]
try:
pl1, pl2 = getmethparlist(eval('_幕類.' + methodname))
if pl1 == "":
print(">>>>>>", pl1, pl2)
continue
defstr = ("def %(key)s%(pl1)s: return _取幕().%(key)s%(pl2)s" %
{'key':methodname, 'pl1':pl1, 'pl2':pl2})
cmdString += defstr +'\n\n'
exec(defstr)
eval(methodname).__doc__ = eval('_幕類.'+methodname).__doc__# _screen_docrevise(eval('_幕類.'+methodname).__doc__)
except:
print('_幕類.' + methodname +' No put to main')
#print(cmdString)
#exec(cmdString)
__tcAll__ += methodPutToMain
#from turtle import _CFG, _Screen, _Root, TK, _TurtleImage, Tbuffer, TurtleGraphicsError
#from turtle import TurtleScreenBase, TurtleScreen, TNavigator, TPen, RawTurtle, Canvas #, Turtle, Screen
__tcAll__ += ['龜幕基類', '龜幕類','龜行類','龜筆類','原生龜類', 'TK'] # 2014/12/30, 處理 two_canvases_tc.py 時遇到！
for x in 別名表:
for y in x[1:]:
__tcAll__ += [y]
__tcAll__ += ['中英對照表']
__all__= __tcAll__[:]
#
# 用上面這幾行 (__tcAll__[:] 的功勞)
# 抵抗了 與 turtle.__all__ 的糾纏,
# 原先 是 __all__ 來自 turtle, 然後 一路 += ，
# 那樣是錯的，
# 因為 turtle_tc.__all__ 就與 turtle.__all__ 糾纏不清了。
# 2015/01/18
#
#'''
def 印可用的詞彙別名表():
print('-'*10)
print('可用的詞彙別名表 (中英對照表)')
print('-'*10)
print('__all__= ',sorted(__all__))
if __name__=='__main__':
印可用的詞彙別名表()
#'''
#
# 模組到此結束。以下為測試。
#
#################################################################
def 陰陽太極圖():
def 陰(半徑, 顏色1, 顏色2):
筆寬(3); 顏色(黑, 顏色1)
開始填();
畫圓(半徑/2., 180); 畫圓(半徑, 180); 左轉(180); 畫圓(-半徑/2., 180);
結束填()
左轉(90); 提筆(); 前進(半徑*0.35); 右轉(90); 下筆(); 顏色(顏色1, 顏色2)
開始填(); 畫圓(半徑*0.15); 結束填()
左轉(90); 提筆(); 後退(半徑*0.35); 下筆(); 左轉(90);
陰(100, 黑, 白)
陰(100, 白, 黑)
class 陰陽龜類(龜類):
def __init__(我, 位置= (0,0)):
龜類.__init__(我)
我.提筆()
我.前往(位置)
我.下筆()
我.陰(100, 黑, 白)
我.陰(100, 白, 黑)
def 陰(我, 半徑, 顏色1, 顏色2):
我.筆寬(3); 我.顏色(黑, 顏色1)
我.開始填();
我.畫圓(半徑/2., 180); 我.畫圓(半徑, 180); 我.左轉(180); 我.畫圓(-半徑/2., 180);
我.結束填()
我.左轉(90); 我.提筆(); 我.前進(半徑*0.35); 我.右轉(90); 我.下筆(); 我.顏色(顏色1, 顏色2)
我.開始填(); 我.畫圓(半徑*0.15); 我.結束填()
我.左轉(90); 我.提筆(); 我.後退(半徑*0.35); 我.下筆(); 我.左轉(90);
if __name__ == '__main__':
# 程序型
陰陽太極圖()
# 物件導向
龜1= 陰陽龜類((200,200))
'''
龜2= 陰陽龜類((-200,+200))
龜3= 陰陽龜類((-200,-200))
龜4= 陰陽龜類((+200,-200))
'''
Raw
turtle_tc_alias.py
'''
turtle_tc_alias.py
2015/01/21
'''
#
# 物類內別名，(Inside-class alias)
#
cListTurtleScreenBase=[
('TurtleScreenBase', '龜幕基類', '烏龜螢幕地基類'),
('mainloop' , '主迴圈', '進入主迴圈', '做完了', '點擊X結束', '等待閉幕', '閉幕'),
('numinput' , '輸入數字'),
('textinput' , '輸入文字'),
]
cListTurtleScreen=[
('TurtleScreen', '龜幕類', '烏龜螢幕類'),
('addshape', '加形狀'),
('bgcolor', '背景色'),
('bgpic', '背景圖'),
#('clear', '清除'), # 這個會和 turtle 中 的 clear 衝突！！ 2015/01/13
('clearscreen', '清除幕'),
('colormode', '色模式'),
('delay', '延遲'),
('getcanvas', '取畫布'),
('getshapes', '取形', '取形狀'),
('listen', '聽', '聽鍵盤'),
('mode', '模式'),
('onclick', '在點擊時','在點擊龜時'),
('onclick', '在滑鼠鍵點擊時'),
('onkey', '在按鍵時', '在按鍵鬆開時'),
('onkeypress', '在按著鍵時', '在按下鍵時'),
('onkeyrelease', '在按鍵鬆開時'),
('onscreenclick', '在點擊幕時', '在幕點擊時', '在滑鼠鍵點擊幕時' ),
('ontimer', '在計時後', '在計時器若干毫秒之後'),
('register_shape', '登記形狀','註冊形狀'),
('reset', '重設', '重設所有龜'),
('resetscreen', '重設幕'),
('screensize', '幕大小', '重設幕寬高', '重設幕大小'),
('setworldcoordinates', '設座標系統', '座標系統'),
('tracer', '追蹤','追蹤更新畫面', '追蹤器'),
('turtles', '龜群', '取龜列表', '龜列表'),
('update', '更新', '更新畫面'),
('window_height', '取幕高', '幕高','窗高'),
('window_width', '取幕寬', '幕寬','窗寬')
]
cListTNavigator= [
('TNavigator', '龜行類', '烏龜航行類'),
('reset', '重設'),
('forward', '前進'),
('back', '後退'),
('right', '右轉'),
('left', '左轉'),
('pos', '位置'),
('goto', '前往', '設位置', '去到'),
('setheading', '設頭向'),
('home', '回家'),
('circle', '畫圓', '圓'),
('speed', '速度'),
('degrees', '角度','設角為度', '設圓為360度', '設角的單位為角度'),
('radians', '弳度', '弧度' ,'半徑數', '設角為弧', '設角的單位為半徑數', '設圓為2pi弧'),
('xcor', 'x座標','座標x'),
('ycor', 'y座標','座標y'),
('setx', '設x座標','設座標x'),
('sety', '設y座標','設座標y'),
('distance', '距離'),
('heading', '頭向'),
('towards', '朝向', '朝向xy' ),
('setpos', '設位置'),
('setposition', '設位置'),
('fd', '前進'), #= forward # 以下是漏網之魚，2015/01/10
('bk', '後退'), #= back
('backward', '後退'), # = back
('rt', '右轉'), #= right
('lt', '左轉'), #= left
('position', '位置'), #= pos
('seth', '設頭向') # = setheading
]
cListTPen= [
('TPen', '龜筆類', '烏龜畫筆類'),
('pensize', '筆粗', '筆粗細', '筆大小'),
('width', '筆寬', '寬'),
('penup', '提筆'),
('pendown', '下筆'),
('showturtle', '顯龜','顯示','顯'),
('hideturtle', '藏龜','隱藏','藏'),
('color', '顏色'),
('pencolor', '筆色'),
('speed', '速度'),
('pen', '筆', '筆屬性'),
('fillcolor', '填色'),
('isdown', '下筆嗎', '是否下筆', '下筆狀態'),
('isvisible', '顯龜嗎', '是否可見', '可見狀態'),
('pendown', '下筆'),
('fillcolor', '填色'),
('penup', '提筆'),
('resizemode', '重設大小模式', '設成可伸縮模式'),
('up', '提筆'), #= penup # 漏網之魚， 2015/01/10
('pu', '提筆'), #= penup
('pd', '下筆'), #= pendown
('down', '下筆'), #= pendown
('st', '顯龜','顯示','顯'), #= showturtle
('ht', '藏龜','隱藏','藏') #= hideturtle
]
cListRawTurtle=[
('RawTurtle', '原龜類', '粗龜類', '原生龜類'),
('shapesize', '形狀大小', '大小', '龜大小'),
('shape', '形狀', '形'),
('write', '寫'),
('begin_fill', '開始填', '開始填色'),
('end_fill', '結束填', '結束填色'),
('begin_poly', '開始多邊形'),
('clear', '清除'),
('clearstamp', '清除蓋章'),
('clearstamps', '清除蓋章群'),
('clone', '複製'),
('dot', '點', '畫點'),
('end_poly', '結束多邊形'),
('filling', '是否正在填色', '正在填色', '填色狀態'),
('get_poly', '取多邊形'),
('get_shapepoly', '取形狀多邊形'),
('getpen', '取筆'),
('getscreen', '取幕'),
('getturtle', '取龜'),
('onclick', '在點擊時', '在滑鼠點擊龜時'),
('ondrag', '在拖曳時', '在滑鼠拖曳龜時'),
('onrelease', '在鬆開時', '在滑鼠鬆開龜時', '在釋放時', '在滑鼠釋放龜時'),
('reset', '重設'),
#('screens', '幕群', '幕列表'),
('settiltangle', '設傾角', '設傾斜角度'),
('setundobuffer', '設回復暫存區'),
('shapetransform', '形狀轉換'),
('shearfactor', '扭曲因子', '設取扭曲因子'),
('stamp', '蓋章', '蓋印', '戳印'),
('tilt', '傾斜'),
('tiltangle', '傾斜角度'),
('turtlesize', '龜大小'), # 是否為 shapesize 的別名。
('undo', '回復'),
('undobufferentries', '回復暫存區的個數', '回復暫存區的長度', '取回復暫存區的長度' ),
('write', '寫')
]
cList_Screen= [
('_Screen', '_幕類','_螢幕類'),
('setup', '設立'),
('title', '設標題', '標題'),
('bye', '再見'),
('exitonclick', '在點擊時離開', '離開在點擊時')
]
cListTurtle=[
('Turtle', '龜類', '烏龜類','生一隻龜'),
#('None', '無')
]
cListScreen=[
('Screen', '幕類', '螢幕類', '開幕'),
#('None', '無')
]
cListShape=[
('Shape','形狀類'),
('addcomponent', '加成員')
]
cListVec2D=[
('Vec2D', '二維向量類'),
('rotate', '旋轉')
]
#
# 全區別名，(global alias)
#
字串別名表= [
('"Delete"', '清除鍵'),
('"Down"', '向下鍵'),
('"Home"', '回家鍵'),
('"Left"', '向左鍵'),
('"Right"', '向右鍵'),
('"Up"', '向上鍵'),
('"space"', '空白鍵'),
('"Escape"', '脫離鍵'),
('"black"', '黑','黑色'),
('"blue"', '藍','藍色'),
('"cyan"', '青','青色'),
('"gray"', '灰','灰色'),
('"green"', '綠','綠色'),
('"magenta"', '紫','紫色'),
('"orange"', '橙','橙色'),
('"red"', '紅','紅色'),
('"white"', '白','白色'),
('"yellow"', '黃','黃色'),
('"turtle"', '龜形','烏龜形狀'),
('"square"', '方形'),
('"logo"', '角度從北開始順時針')
]
#
# 常用的就把它加在這裡
#
函數別名表= [
('None', '無'),
('True', '真'),
('False', '假'),
('print', '印'),
('range', '範圍'),
('random.random', '隨機數', '亂數'),
('random.choice', '隨機選', '亂選'),
('random.randint', '隨機整數', '亂整數'),
('random.sample', '隨機取樣', '亂取樣'),
#("['red','orange','yellow','green','cyan','blue','magenta']", '彩虹', '彩虹色群'),
('time.ctime', '看時間', '取時間'),
('time.sleep', '睡', '等時間'),
('time.time', '時間'),
('Pen', '筆類'), #2015/01/03
('RawPen', '原生筆類'),
('RawTurtle', '原生龜類'),
('ScrolledCanvas', '可捲畫布類'),
('Shape', '形狀類'),
('TurtleScreen', '龜幕類'),
('Vec2D', '二維向量類', '向量2D類'),
('Turtle', '龜類', '生龜','生一隻龜', 'Pen', '筆類'), # 2015/01/03 # Pen 與 Turtle 需產生連結。
('Screen', '幕類', '開幕')
]
總別名表=[
cListShape,
cListVec2D,
cListTurtleScreenBase,
cListTurtleScreen,
cListTNavigator,
cListTPen,
cListRawTurtle,
cList_Screen,
cListTurtle,
cListScreen,
字串別名表,
函數別名表
]
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment