python-学习实例

实例一：温度转换

首次学习写python,写了一个温度转换的一段小代码，对其中遇到的问题做个记录

• 将代码写入记事本中，后改为.py的格式来运行发现运行窗口一闪而过
  原因有：

1. 有错误代码
2. 代码中含有中文字符
3. 代码格式不正确
4. 可在 末行加入input(),等待输入直到按enter键。
5. 需要在代码首行中加入import os，末行再加入os.system("pause")

代码如下：

#Temple.py
import os
TempStr=input("please enter a temperature value with symbols")
if TempStr[-1] in ['F','f']:
    C=(eval(TempStr[0:-1])-32)/1.8
    print("The converted temperature is {:.2f}C".format(C))
elif TempStr[-1] in ['C','c']:
    F=1.8*eval(TempStr[0:-1])+32
    print("The converted temperature is {:.2f}F".format(F))
else:
    print("Input format error")
os.system("pause")

运行结果如下

第二次小练习，获得用户输入的一个正整数输入，输出该数字对应的中文字符表示。‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬
0到9对应的中文字符分别是：零一二三四五六七八九‪‬‪‬‪‬‪‬‪‬‮‬‪‬‭‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‭‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‫‬‪‬‪‬‪‬‪‬‪‬‪‬‮‬‪‬‮‬

代码如下

template = "零一二三四五六七八九"
s = input()
for c in s:#此处c相当于i，做循环计数
    print(template[eval(c)], end="")#取c所代表的数字下标对应字符
    #print()中增加end=""参数表示输出后不增加换行，多个print()可以连续输出。

实例二：蟒蛇的绘制

蟒蛇的绘制

实例三：天天向上的力量

具体实例，共四个问题
问题1：一年365天，每天进步千分之一，累计进步多少，若是该为退步又是多少？
问题2：365天，每天进步千分之五或1%,累计进步多少呢，若是退步呢？
问题3：工作日的力量，365天，一周五个工作日，每天进步1%，一周两个休息日，每天退步1%结果
问题4：工作日要努力到什么程度，才能与每天努力1%一样

#问题1，365天，每天进步千分之一和每天退步千分之一的结果。
dayup=pow(1.001,365)#表示天天进步一点的结果
daydown=pow(0.999,365)#表示天天退步一点的结果
print("向上:{:.2f},向下:{:.2f}".format(dayup,daydown))#结果为原来的1.44倍和原来的0.69倍
print("*********************************")
#问题2
#365天每天进步千分之五或每天退步千分之一的累计结果，1.005^365与1.01^365
#365天每天退步千分之五或每天进步步千分之一的累计剩下多少，0.995^365与0.99^365
dayfactor=0.005#后可修改参数为0.01
dayup2=pow(1+dayfactor,365)
daydown2=pow(1-dayfactor,365)
print("向上:{:.2f},向下:{:.2f}".format(dayup2,daydown2))
print("*********************************")
#问题3
#365天，一周5个工作日，每天进步1%,一周两个休息日每天退步1%,可以进行模拟循环
dayup3=1.0
dayfactor3=0.01
for i in range(365):#可进行模运算，一周七天，模7尾数为6或0则认为在周末退步
    if i%7 in[6,0]:
        dayup3=dayup3*(1-dayfactor3)
    else:
        dayup3=dayup3*(1+dayfactor3)
print("工作日的力量:{:.2f}".format(dayup3))
print("*********************************")
#问题4：工作日模式要努力到什么水平，才能与每天努力1%一样，假设B是工作日模式，A是每天进步模式最终结果为37.78
#可以让计算机进行试错测试def...while...，看B究竟要怎样才能赶上B
def dayup4(df):#函数的写法df为参数仅是占位符，用df来表示dayfactor的简写,def保留字用于定义函数
    dayup4=1
    for i in range(365):#可进行模运算，一周七天，模7尾数为6或0则认为在周末退步
        if i%7 in[6,0]:
            dayup4=dayup4*(1-0.01)
        else:
            dayup4=dayup4*(1+df)
    return dayup4
dayfactor4=0.01
while dayup4(dayfactor4)<37.78:
      dayfactor4+=0.001
print("工作日的努力参数是：{:.3f}".format(dayfactor4))

运行结果如下图

实例四：文本进度条

采用字符串方式打印可以动态变换的文本进度条
需要能在一行中逐渐变换
采用sleep()模拟一个持续的进度

文本进度条简单框架如下

import time
scale =10#文本进度条的大概宽度
print("------执行开始------")
for i in range(scale+1):#定义一个休眠时间,每此循环都打印当前一个进度条状态
    a='*'*i#星号被复制i次
    b='.'*(scale-i)#进度条剩余部分用.表示
    c=(i/scale)*100#输出当前进度条和进度相关的百分比
    print("{:^3.0f}%[{}->{}]".format(c,a,b))
    time.sleep(0.1)
print("-------- 执行结束-------")

效果图如下

文本进度条单行动态刷新

刷新的本质是：用后打印的字符覆盖之前的字符
不能换行，print()需要被控制
要能回退，打印后光标回退到之前的位置\r

import time
for i in range(101):#0%到100%的状态
    print("\r{:3}%".format(i),end="")#打印字符串之前光标退回到当前行行首
    time.sleep(0.1)#不能在IDLE环境中直接运行

完整效果的单行动态刷新的文本进度条

import time
scale=50
print("执行开始".center(scale//2,"-"))
start=time.perf_counter()#计时效果
for i in range(scale+1):
    a='*'*i
    b='.'*(scale-i)
    c=(i/scale)*100
    dur=time.perf_counter()-start#记录每次需要打印文本进度条所消耗的时间
    print("\r{:^3.0f}%[{}->{}]{:.2f}s".format(c,a,b,dur),end="")
    time.sleep(0.1)
print("\n"+"执行结果".center(scale//2,'-'))

效果如下图

• 也可以使用文本进度条的不同设计函数来设计进度条的增加趋势，一般开始慢一些后面快一些效果较好。

实例五：身体指数BMI

身体质量指数BMI实例
BMI=体重（kg）/身高²(m²),两个输入，两个输出（国际标准和国内标准）

height,weight=eval(input("请输入身高（米）和体重\(公斤)[逗号隔开]："))
bmi=weight/pow(height,2)
print("BMI 数值为：{:.2f}".format(bmi))
who,nat="",""
if bmi<18.5:
    who,nat="偏瘦","偏瘦"
elif 18.5<=bmi<24:
    who,nat="正常","正常"
elif 24<=bmi<25:
    who,nat="正常","偏胖"
elif 25<=bmi<28:
    who,nat="偏胖","偏胖"
elif 28<=bmi<30:
    who,nat="偏胖","肥胖"
else:
    who,nat="肥胖","肥胖"
print("BMI 指标为：国际'{0}'，国内'{1}'".format(who,nat))

实例六: 圆周率的计算实例

分为公式法和蒙特卡洛方法（撒点模拟计算）
公式如下
$$\pi =\sum _{k=0}^n[\frac{1}{16^k}(\frac{4}{8k+1}-\frac{2}{8k+4}-\frac{1}{8k+5}-\frac{1}{8k+6})]$$

公式法

#公式法
pi=0
N=100
for k in range(N):
    pi+=1/pow(16,k)*(\ #为避免一行代码太长，可读性差，可以使用\来换行写，
    #这与写在一行功能相同
    4/(8*k+1)-2/(8*k+4)-\
    1/(8*k+5)-1/(8*k+6))
    print("圆周率的值是：{}".format(pi))

蒙特卡洛方法

#蒙特卡洛方法
from random import random
from time import perf_counter
DARTS=1000*1000#指的是当前区域中抛洒点的总数量
hits=0.0#目前在圆的内部的点的数量
start=perf_counter()
for i in range(1,DARTS+1):#遍历循环撒点,每个点做循环体运算,对所有点抛洒
    x,y=random(),random()#生成两个随机数坐标值
    dist=pow(x**2+y**2,0.5)#判断点是否在圆内，利用点到圆心距算
    if dist<=1.0:
        hits=hits+1#经过撒点后在圆内部点的数量
pi=4*(hits/DARTS)
print("圆周率的值是：{}".format(pi))
print("运行的时间是：{:.5f}s".format(perf_counter()-start))

实例七：七段数码管的绘制

绘制七段数码管风格的时间
步骤一：绘制单个数字对应的数码管
步骤二：获得一串数字，绘制对应的数码管
步骤三：使用time库获得当前系统的时间，绘制对应的数码管,增加年月日标记，且与绘制的数字颜色不同
七段数码管由7个基本线条组成，七段数码管可以有固定顺序，不同数字显示不同线条

import turtle as t
import time
def drawGap():#绘制数码管间隔
    t.penup()
    t.fd(5)
def drawLine(draw):#绘制单段数码管
    drawGap()
    t.pendown() if draw else t.penup()#draw为true则真实绘制，否则只飞过去不绘制
    t.fd(40)
    drawGap()
    t.right(90)
def drawDight(dight):#根据数字绘制七段数码管
    drawLine(True) if dight in [2,3,4,5,6,8,9] else drawLine(False)
    drawLine(True) if dight in [0,1,3,4,5,6,7,8,9] else drawLine(False)
    drawLine(True) if dight in [0,2,3,5,6,8,9] else drawLine(False)
    drawLine(True) if dight in [0,2,6,8] else drawLine(False)
    t.left(90)
    drawLine(True) if dight in [0,4,5,6,8,9] else drawLine(False)
    drawLine(True) if dight in [0,2,3,5,6,7,8,9] else drawLine(False)
    drawLine(True) if dight in [0,1,2,3,4,7,8,9] else drawLine(False)
    t.left(180)
    t.penup()# 为绘制后续数字确定位置
    t.fd(20)# 为绘制后续数字确定位置
def drawDate(date):#data为日期，格式为'%Y-%m=%d+',即-,=,+对应年月日汉字（出现减号绘制汉字年等）
    t.pencolor("seagreen")
    for i in date:
        if i=='-':
            t.write('年',font=("Arial",18,"normal"))
            t.pencolor("darkblue")
            t.fd(40)
        elif i=='=':
            t.write('月',font=("Arial",18,"normal"))
            t.pencolor("purple")
            t.fd(40)
        elif i=='+':
            t.write('日',font=("Arial",18,"normal"))
        else:
            drawDight(eval(i))
def main():
    t.setup(800,350,200,200)
    t.penup()
    t.fd(-300)#画笔初始位置
    t.pensize(5)
    drawDate(time.strftime('%Y-%m=%d+',time.gmtime()))
    t.hideturtle()
    t.done()
main()

效果如下图

实例八:科赫雪花小包裹

分形几何是一种迭代的几何图形，即整体与局部很相似

绘制n阶科赫曲线需要递归实现

import turtle as t
def koch(size,n):#每个直线的长度，绘制的阶数n
    if n==0:
        t.fd(size)

    else:
        for angle in [0,60,-120,60]:
            t.left(angle)
            koch(size/3,n-1)
def main():
    t.setup(600,600)
    t.penup()
    t.goto(-200,100)
    t.pendown()
    t.pensize(2)
    for i in range(3):
        level=3#三阶科赫雪花，阶数
        koch(400,level)#三阶科赫曲线，阶数
        t.right(120)
    t.hideturtle()
main()

实现效果如下图：

实例九：基本统计值计算

给出一组数，对它们有个概要理解
总个数len()、求和for in、平均值、方差、中位数：排序奇数找中间1个，偶数中间两个取平均。

def getNum():#获取用户不定长度输入
    nums=[]
    iNumStr=input("请输入数字（回车输入，空格退出)：")
    while iNumStr !=" ":
        nums.append(eval(iNumStr))
        iNumStr=input("请输入数字（回车退出)：")
    return nums
def mean(numbers):#计算平均值
    s=0.0
    for num in numbers:
        s=s+num
    return s/len(numbers)
def dev(numbers,mean):#计算方差
    sdev=0.0
    for num in numbers:
        sdev=sdev+(num-mean)**2
    return pow(sdev/(len(numbers)-1),0.5)
def median(numbers):#计算中位数
    sorted(numbers)#sorted()函数可以对列表进行排序
    size=len(numbers)
    if size % 2==0:
        med=(numbers[size//2-1]+numbers[size//2])/2
    else:
        med=numbers[size//2]
    return med
n=getNum()
m=mean(n)
print("平均值:{}，方差:{:.2},中位数:{}.".format(m,dev(n,m),median(n)))

实例十：文本词频统计

一篇文章，出现了那些词，那些词出现最多
判断是英文文本还是中文的

需要噪音处理，归一化，提取其中每一个英文单词

#Hamlet英文词频统计
def getText():
    txt=open("hamlet.txt","r").read()#打开文件
    txt=txt.lower()#避免大小写干扰，将所有变为小写
    for ch in '!"#$%&()*+,-./:;<=>?@[\\]^_`{|}~':#去掉特殊符号
        txt=txt.replace(ch," ")#特殊符替换为空格
    return txt
hamleTxt=getText()
words=hamleTxt.split()#用空格分隔变成列表
counts={}#字典类型将单词与出现频率做映射
for word in words:
    counts[word]=counts.get(word,0)+1#判断word中取出的元素是否在counts中，.get()方法从字典中获得某一个键对应的值
    # 指的是用当前的某一个英文单词作为键索引字典，若在则返回它的次数并+1，若不在则将其+到字典中并且赋给当前值为0，而0+1=1
items=list(counts.items())#转换为列表类型
items.sort(key=lambda x:x[1],reverse=True)#lambda用来指定使用哪一个多元选项的列作为排序列，默认从小到大
#reverse=True则返回的排序是从大到小
for i in range(10):#排序后的信息保存在item中,打印输出前十位
    word,count=items[i]
    print("{0:<10}{1:>5}".format(word,count))

中文文本，三国演义人物出场统计，需要使用jieba词库分词
不存在大小写，在分词中就会处理掉标点符号

import jieba
txt=open("threekingdoms.txt","r"encoding="utf-8").read()
words=jieba.lcut(txt)
counts={}
for word in words:
    if len(word)==1:
        continue
    else:
        counts[word]=counts.get(word,0)+1
items=list(counts.items())
items.sort(key=lambda x:x[1],reverse=True)
for i in range(15):
    word,count=items[i]
    print("{0;<10}{1:>5}".format(word,count))

输出有缺陷，分词不太正确，需要改进，比如一个人可能有不同的称谓
将确定不是人名但排名比较靠前的词删去

import jieba
txt=open("threekingdoms.txt","r",encoding="utf-8").read()
excludes={"将军","却说","荆州","二人","不可","不能","如此"}
words=jieba.lcut(txt)
counts={}
for word in words:
    if len(word)==1:
        continue
    elif word=="诸葛亮"or word =="孔明曰":
        rword="孔明"
    elif word=="关公"or word =="云长":
        rword="关羽"
    elif word=="玄德" or word=="玄德曰":
        rword="刘备"
    elif word=="孟德" or word=="丞相":
        rword="曹操"
    else:
        rword=word
        counts[rword]=counts.get(rword,0)+1
for word in excludes:
    del counts[word]
items=list(counts.items())
items.sort(key=lambda x:x[1],reverse=True)
for i in range(10):
    word,count=items[i]
    print("{0;<10}{1:>5}".format(word,count))

还需进一步不断删查完善。

实例十一：自动轨迹绘制

需求：根据脚本来绘制图形
不是写代码而是写数据绘制轨迹
读取一个文件解析其数据进行自动绘制
1.定义数据文件格式（接口）
2.编写程序，根据文件接口解析参数绘制图形
3.编制数据文件
写一个可以读取数据并按如下按方式处理的接口

#可以据文件数据绘制的接口
import turtle as t
t.title('自动绘制轨迹')
t.setup(800,600,0,0)
t.pencolor("red")
t.pensize(5)
#数据读取,并处理
datals=[]
f=open("data.txt")
for line in f:
    line=line.replace("\n"," ")#每行的换行符转为空字符串
    datals.append(list(map(eval,line.split(","))))#数据接口的值分隔处理并提取
    #首先据逗号分隔字符串装换为列表，装换为数据
    #将处理好的通过append放入datalsf.close()
#自动绘制
    for i in range(len(datals)):#逐一的获取其中的遍历整数
        t.pencolor(datals[i][3],datals[i][4],datals[i][5])#获得当前detals的一个元素的三个参数
        t.fd(datals[i][0])#获取当前这一行中的第一个元素作为行进距离
        if datals[i][1]:#为1右转，为0左转
            t.right(datals[i][2])
        else:
            t.left(datals[i][2])

其中data.txt的内容为

300,0,144,1,0,0
300,0,144,0,1,0
300,0,144,0,0,1
300,0,144,1,1,0
300,0,108,0,1,1

运行结果如下图：
再想绘制不同的图，只要改文件就行，不用改代码

实例十二：政府工作报告词云

1.读取文件，分词整理
2.设置并输出词云
3.观察结果，迭代优化

import jieba
import wordcloud
f=open("新时代中国特色社会主义.txt"

> 这里是引用

,"r",encoding="utf-8")
t=f.read()
f.close()
ls=jieba.lcut(t)
txt=" ".join(ls)
w=wordcloud.WordCloud(font_path="msyh.ttc',\
width=1000,height=700,background_color="white", max_word=15)
w.generate(txt)
w.to_file("grwordcloud.png")

实例十三：“体育竞技分析”问题

输入：球员的水平，输出：可预测的比赛成绩
模拟n场比赛，n越大模拟结果越科学
计算思维：抽象+自动化
抽象比赛过程+自动化执行N场比赛

比赛规则：双人击球，A&B回合制，5局3胜
开始时一方先发球，直至判分，接下来胜者发球
球员只能在发球局得分，15分一局

从用户处获得程序运行参数：porA,porB（运动员AB的能力值），n（模拟场数），模拟比赛，输出A，B获胜比赛的场次及概率

from random import random
def printIntro():
    print("这个程序模拟两个选手A和B的某种竞技比赛")
    print("这个程序运行需要A和B的能力值（以0到1之间的小数表示）")
def getInputs():
    a=eval(input("请输入选手A的能力值（0-1）:"))
    b=eval(input("请输入选手B的能力值（0-1）:"))
    n=eval(input("模拟比赛的场次:"))
    return a,b,n
def printSummary(winsA,winsB):#输出结果
    n=winsA+winsB
    print("竞技分析开始，共模拟{}场比赛".format(n))
    print("选手A获胜{}场比赛，占比{:0.1%}".format(winsA,winsA/n))
    print("选手B获胜{}场比赛，占比{:0.1%}".format(winsB,winsB/n))
    return winsA+winsB
def gameOver(a,b):
    return a==15 or b==15
def simOneGame(probA,probB):#模拟一次比赛
    scoreA,scoreB=0,0
    serving="A"
    while not gameOver(scoreA,scoreB):
        if serving=="A":#表示选手A开始发球
            if random()<probA:#随机量在A能力的范围内A获得1分
                scoreA+=1
            else:
                serving="B"#发起人换成B
        else:
            if random()<probB:
                scoreB+=1
            else:
                serving="A"
    return scoreA,scoreB
def simNGames(n,probA,probB):#模拟n次比赛
    winsA,winsB=0,0
    for i in range(n):
        scoreA,scoreB=simOneGame(probA,probB)
        if scoreA>scoreB:
            winsA+=1
        else:
            winsB+=1
    return winsA,winsB
def main():
    printIntro()
    probA,probB,n=getInputs()
    winsA,winsB=simNGames(n,probA,probB)
    printSummary(winsA,winsB)
main()

运行结果如下图：

实例十四：“第三方库自动安装脚本”

批量安装第三方库，能否自动安装
自动执行pip逐一根据安装需求安装
安装如下库：NumPy（N维数据表示和运算）、Matplotlib（二维数据可视化）、PIL(图像处理)、Scikit-Learn(机器学习和数据挖掘)、Requests(HTTP协议访问及网络爬虫)、Jieba(中文分词）、 Beautiful Soup（HTML和XML解析工具）、Wheel(Python第三方文件打包工具)、PyInstaller(打包Python源文件为可执行文件)、Django（Python最流行的Web开发框架）、Flask（轻量级Web开发框架）、WeRoBot（微信机器人开发框架）、SymPy(数学符号计算工具)、Pandas(高效数学分析和计算)、Networkx(复杂网络和图结构的建模和分析)、
PyQt5(基于Qt的专业级GUI开发框架)、PyOpenGL(多平台OpenGL开发接口)、PyPDF2（PDF文件内容提取及处理）、docopt(Python命令行解析)、PyGame（简单小游戏开发框架）

import os
libs={"numpy","matplotlib","pillow","sklearn","requests",\
      "jieba","beautifulsoup4","wheel","networkx","sympy",\
      "pyinstaller","django","flask","werobot","pympy",\
      "pandas","pyopengl","pypdf2","docopt","pygame"}
try:
    for lib in libs():
        os.system("pip install"+lib)
    print("successful")
except:
    print("Failed SomehowS")

实例十五：霍兰德人格分析雷达图

雷达图方式验证霍兰德人格分析
输入：各职业人群结合兴趣的调研数据，输出：雷达图
通用雷达图绘制：matplotlib,多维数据表示：numply库

import numpy as np
import matplotlib.pyplot as plt
import matplotlib
#namply中的array方法将多维数据组织起来
matplotlib.rcParams['font.family']='SimHei'
radar_labels = np.array(['研究型(I)','艺术型(A)','社会型(S)',\
                         '企业型(E)','常规型(C)','现实型(R)']) #雷达标签
nAttr = 6
data = np.array([[0.40, 0.32, 0.35, 0.30, 0.30, 0.88],
                 [0.85, 0.35, 0.30, 0.40, 0.40, 0.30],
                 [0.43, 0.89, 0.30, 0.28, 0.22, 0.30],
                 [0.30, 0.25, 0.48, 0.85, 0.45, 0.40],
                 [0.20, 0.38, 0.87, 0.45, 0.32, 0.28],
                 [0.34, 0.31, 0.38, 0.40, 0.92, 0.28]]) #数据值
data_labels = ('艺术家', '实验员', '工程师', '推销员', '社会工作者','记事员')
angles = np.linspace(0, 2*np.pi, nAttr, endpoint=False)
data = np.concatenate((data, [data[0]]))
#使用matplotlib中绘制雷达图的方法，并将给定的相关数据嵌入到雷达图表示中
angles = np.concatenate((angles, [angles[0]]))
fig = plt.figure(facecolor="white")
plt.subplot(111, polar=True)
plt.plot(angles,data,'o-', linewidth=1, alpha=0.2)
plt.fill(angles,data, alpha=0.25)
plt.thetagrids(angles*180/np.pi, radar_labels,frac = 1.2)
#绘制的雷达图输出形成相关文件
plt.figtext(0.52, 0.95, '霍兰德人格分析', ha='center', size=20)
legend = plt.legend(data_labels, loc=(0.94, 0.80), labelspacing=0.1)
plt.setp(legend.get_texts(), fontsize='large')
plt.grid(True)
plt.savefig('holland_radar.jpg')
plt.show()

实例十六：玫瑰花绘制

输入：你的想象力！输出一朵玫瑰花，使用turtle

#RoseDraw.py
import turtle as t
# 定义一个曲线绘制函数
def DegreeCurve(n, r, d=1):
    for i in range(n):
        t.left(d)
        t.circle(r, abs(d))
# 初始位置设定
s = 0.2 # size
t.setup(450*5*s, 750*5*s)
t.pencolor("black")
t.fillcolor("red")
t.speed(100)
t.penup()
t.goto(0, 900*s)
t.pendown()
# 绘制花朵形状
t.begin_fill()
t.circle(200*s,30)
DegreeCurve(60, 50*s)
t.circle(200*s,30)
DegreeCurve(4, 100*s)
t.circle(200*s,50)
DegreeCurve(50, 50*s)
t.circle(350*s,65)
DegreeCurve(40, 70*s)
t.circle(150*s,50)
DegreeCurve(20, 50*s, -1)
t.circle(400*s,60)
DegreeCurve(18, 50*s)
t.fd(250*s)
t.right(150)
t.circle(-500*s,12)
t.left(140)
t.circle(550*s,110)
t.left(27)
t.circle(650*s,100)
t.left(130)
t.circle(-300*s,20)
t.right(123)
t.circle(220*s,57)
t.end_fill()
# 绘制花枝形状
t.left(120)
t.fd(280*s)
t.left(115)
t.circle(300*s,33)
t.left(180)
t.circle(-300*s,33)
DegreeCurve(70, 225*s, -1)
t.circle(350*s,104)
t.left(90)
t.circle(200*s,105)
t.circle(-500*s,63)
t.penup()
t.goto(170*s,-30*s)
t.pendown()
t.left(160)
DegreeCurve(20, 2500*s)
DegreeCurve(220, 250*s, -1)
# 绘制一个绿色叶子
t.fillcolor('green')
t.penup()
t.goto(670*s,-180*s)
t.pendown()
t.right(140)
t.begin_fill()
t.circle(300*s,120)
t.left(60)
t.circle(300*s,120)
t.end_fill()
t.penup()
t.goto(180*s,-550*s)
t.pendown()
t.right(85)
t.circle(600*s,40)
# 绘制另一个绿色叶子
t.penup()
t.goto(-150*s,-1000*s)
t.pendown()
t.begin_fill()
t.rt(120)
t.circle(300*s,115)
t.left(75)
t.circle(300*s,100)
t.end_fill()
t.penup()
t.goto(430*s,-1070*s)
t.pendown()
t.right(30)
t.circle(-600*s,35)
t.done()