目录

• 蟒蛇绘制
  • 小知识1.0
• 温度转换
  • 小知识2.0
• 文本进度条
• 七段数码管绘制
• 科赫雪花
• 基本统计值计算
• 文本词频统计
• 自动轨迹绘制
• time库的使用
• random库的使用

蟒蛇绘制

import turtle #引入绘图库
turtle.setup(650,350,200,200) #不是必需的，对窗口有要求时设置即可
#turtle.setup(width,height,startx,starty)，括号内前两者设置窗口大小，后两者是相对屏幕坐标原点的窗口坐标
turtle.penup() #拿起画笔，画布不显示痕迹。海龟默认位置在画布中央
turtle.fd(-250)
turtle.pendown() #放下画笔，画布显示痕迹
turtle.pensize(25) #画笔宽度，pensize可换成 width
turtle.pencolor("purple") #可用颜色字符串(小写)或 RGB小数值或 RGB元组值(小数值的括号外再加一层括号)设置
turtle.seth(-40)

for i in range(4): # i默认从0开始
    # range(N) 产生0到 N-1的整数序列
    # range(M,N) 产生 M到 N-1的整数序列
    turtle.circle(40,80)
    turtle.circle(-40,80)
turtle.circle(40,80/2)
turtle.fd(40)
turtle.circle(16,180)
turtle.fd(40*2/3)
turtle.done() #程序运行完后不能自动退出，需要手动关闭窗体；去掉即可自动退出

小知识1.0

1、空间坐标体系

1. 绝对坐标：
   turtle.goto(x,y) 从当前位置直线前往(x,y)所在位置
2. turtle坐标：（都是前进方向，只是分前后左右）
   turtle.circle(r,angle)：根据半径 r绘制 angle角度的弧形（r默认海龟左侧 r距离的位置；若是右侧，用负数。angle默认360度整圆）
   turtle.bk(d)：后退
   turtle.fd(d)：前进

2、角度坐标体系

1. 绝对角度
   turtle.seth(angle) 改变海龟行进方向，但不前进。angle为绝对度数
2. turtle角度(以当前方向为基准)
   turtle.left(angle)：向左转
   turtle.right(angle)：向右转

3、RGB色彩
turtle默认采用小数值（0~1），可切换为整数值（0~255）
turtle.colormode(mode)

• 1.0：RGB小数值模式
• 255：RGB整数值模式

4、库引用

import <库名>
<库名>.<函数名>(<函数参数>)

简化库名方式：使用 from和 import保留字共同完成，即

from <库名> import <函数名>
from <库名> import *
<函数名>(<函数参数>)

#修改后代码
from turtle import*
setup(650,350,200,200)
penup()
fd(-250)
pendown()
pensize(25)
pencolor("purple")
seth(-40)

for i in range(4):
    circle(40,80)
    circle(-40,80)
circle(40,80/2)
fd(40)
circle(16,180)
fd(40*2/3)
done()

注意：当 import多个库时，可能出现函数重名问题
解决办法：使用 import和 as保留字共同完成（相当于给调用的外部库关联一个更短、更适合的名字），即

import <库名> as <函数名>
<库名>.<函数名>(<函数参数>)

#修改后代码
import turtle as t
t.setup(650,350,200,200)
t.penup()
t.fd(-250)
t.pendown()
t.pensize(25)
t.pencolor("purple")
t.seth(-40)

for i in range(4):
    t.circle(40,80)
    t.circle(-40,80)
t.circle(40,80/2)
t.fd(40)
t.circle(16,180)
t.fd(40*2/3)
t.done()

温度转换

#TempConvert.py
TempStr=input("请输入带有符号的温度值\n")
if TempStr[-1] in ['F','f']:
    C=(eval(TempStr[0:-1])-32)/1.8
    print("转换后的温度是{:.2f}C\n".format(C))
elif TempStr[-1] in ['C','c']: #注意最后的冒号和下两行代码的缩进
    F=(eval(TempStr[0:-1]))*1.8+32
    print("转换后的温度是{:.2f}F\n".format(F))
else:
    print("输入格式错误\n")

小知识2.0

1、列表：由0个或多个数据组成的有序序列

• 使用[]表示，采用逗号分隔各元素
• 使用保留字 in判断一个元素是否在列表中

2、评估函数 eval()：去掉参数最外侧括号并执行余下语句

eval("1")               -> 1
eval("1+2")             -> 3
eval('"1+2"')           -> '1+2'
eval('print("Hello")')  -> Hello

3、输出函数——print()函数的格式化
print("转换后的温度是{:.2f}C\n".format(C))

• { }表示槽，后续变量填充到槽中
• {:.2f}表示将变量C填充到这个位置时取小数点后2位
• "{ }:计算机{ }的CPU占用率为{ }%".format("2019-9-5","C",10) 字符串中槽的默认顺序和 format()中参数的顺序一致
• "{1}:计算机{0}的CPU占用率为{2}%".format("2019-9-5","C",10) format()中参数标号默认从0开始，字符串中槽内的数字代表 format()中对应位置的参数

4、format()方法的格式控制

举例：

• "{0:=^20}".format("python") 为 ‘=======python=======‘
• "{0:*>20}".format("bit") 为 ‘*****************bit‘
• "{:10}".format("bit") 为 ‘bit ‘
• "{0:,.2f}".format(123456.789) 为 ‘12,345.68‘
• "{0:b},{0:c},{0:d},{0:o},{0:x},{0:X}".format(425) 为 ‘110101001,Σ,425,651,1a9,1A9‘
• "{0:e},{0:E},{0:f},{0:%}".format(3.14) 为 ‘3.140000e+00,3.140000E+00,3.140000,314.000000%‘

文本进度条

#简单版
import time
scale=10
print("------执行开始------")
for i in range(scale+1):
    a='*'*i
    b='.'*(scale-i)
    c=(i/scale)*100
    print("{:^3.0f}%[{}->{}]".format(c,a,b))
    time.sleep(1)
print("------执行结束------")
print("\n")

#单行动态刷新
for i in range(101):
    print("\r{:3}%".format(i),end='')
    time.sleep(0.1)
print("\n")

#两者结合
import time
scale=10
print("------执行开始------")
for i in range(scale+1):
    a='*'*i
    b='.'*(scale-i)
    c=(i/scale)*100
    print("\r{:^3.0f}%[{}->{}]".format(c,a,b),end='')
    time.sleep(0.5)
print("\n------执行结束------")

七段数码管绘制

#基本思路
#步骤1：绘制单个数字对应的数码管
import turtle,time

def drawGap(): #绘制数码管间隔
    turtle.penup()
    turtle.fd(5)
def drawLine(draw): #绘制单段数码管
    drawGap()
    turtle.pendown() if draw else turtle.penup()
    turtle.fd(40)
    drawGap()
    turtle.right(90)
def drawDigit(digit): #根据数字绘制七段数码管
    drawLine(True) if digit in [2,3,4,5,6,8,9] else drawLine(False)
    drawLine(True) if digit in [0,1,3,4,5,6,7,8,9] else drawLine(False)
    drawLine(True) if digit in [0,2,3,5,6,8,9] else drawLine(False)
    drawLine(True) if digit in [0,2,6,8] else drawLine(False)
    turtle.left(90)
    drawLine(True) if digit in [0,4,5,6,8,9] else drawLine(False)
    drawLine(True) if digit in [0,2,3,5,6,7,8,9] else drawLine(False)
    drawLine(True) if digit in [0,1,2,3,4,7,8,9] else drawLine(False)
    turtle.left(180)
    turtle.penup() #为绘制后续数字确定位置
    turtle.fd(20) #为绘制后续数字确定位置

  #drawDigit(7)
  #time.sleep(2)

#步骤2：获得一串数字，绘制对应的数码管
def drawDate(date): # date为日期，格式为 '%y-%m=%d+%h*%m&%s#'
    turtle.pencolor("red")
    for i in date:
        #增加年月日标记且使用不同颜色
        if i=='-':
            turtle.write('年',font=("Arial",18,"normal"))
            turtle.pencolor("orange")
            turtle.fd(40)
        elif i=='=':
            turtle.write('月',font=("Arial", 18, "normal"))
            turtle.pencolor("yellow")
            turtle.fd(40)
        elif i=='+':
            turtle.write('日',font=("Arial", 18, "normal"))
            turtle.pencolor("green")
            turtle.fd(40)
        elif i=='*':
            turtle.write('时',font=("Arial", 18, "normal"))
            turtle.pencolor("blue")
            turtle.fd(40)
        elif i=='&':
            turtle.write('分',font=("Arial", 18, "normal"))
            turtle.pencolor("purple")
            turtle.fd(40)
        elif i=='#':
            turtle.write('秒',font=("Arial", 18, "normal"))
        else:
            drawDigit(eval(i))
def main():
    turtle.penup()
    turtle.fd(-600)
    turtle.pensize(5)
# 步骤3：获得当前系统时间，绘制对应的数码管
    drawDate(time.strftime('%Y-%m=%d+%H*%M&%S#',time.gmtime()))
    turtle.hideturtle()
    turtle.done()

main()

科赫雪花

import turtle,time
def koch(size,n):
    if n==0:
        turtle.fd(size)
    else:
        for angle in [0,60,-120,60]:
            turtle.left(angle)
            koch(size/3,n-1)
def main():
    turtle.penup
    turtle.goto(-200,100)
    turtle.pendown()
    turtle.pensize(2)
    level=3 #3阶科赫曲线，雪花
    koch(400,level)
    turtle.right(120)
    koch(400, level)
    turtle.right(120)
    koch(400, level)
    turtle.hideturtle()

main()
time.sleep((3))

基本统计值计算

#简单版
import time
scale=10
print("------执行开始------")
for i in range(scale+1):
    a='*'*i
    b='.'*(scale-i)
    c=(i/scale)*100
    print("{:^3.0f}%[{}->{}]".format(c,a,b))
    time.sleep(1)
print("------执行结束------")
print("\n")

#单行动态刷新
for i in range(101):
    print("\r{:3}%".format(i),end='')
    time.sleep(0.1)
print("\n")

#两者结合
import time
scale=10
print("------执行开始------")
for i in range(scale+1):
    a='*'*i
    b='.'*(scale-i)
    c=(i/scale)*100
    print("\r{:^3.0f}%[{}->{}]".format(c,a,b),end='')
    time.sleep(0.5)
print("\n------执行结束------")

文本词频统计

#hamlet英文词频统计
def getText():
    txt=open("hamlet.txt","r").read()
    txt=txt.lower        for ch in '!"#$%&()*+,-./:;<=>[email protected][\\]^_{|}~':
            txt=txt.replace(ch," ")
        return txt

hamletTxt=getText()
words=hamletTxt.split()
counts={}
for word in words:
    counts[word]=counts.get(word,0)+1
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))

#《三国演义》人物出场统计
import jieba
txt=open("三国演义.txt","r",encoding="utf-8").read()
words=jieba.lcut(txt)
counts={}
for word in words:
    if len==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(10):
    word,count=items[i]
    print("{0:<10}{1:>5}".format(word,count))
    #第二个例子有些瑕疵，比如“孔明说”“却说”这些不是人名的字眼也会出现，只能通过结果筛选，在程序中指名道姓地避免，较为繁琐

自动轨迹绘制

'''
给出一些参数，根据参数利用脚本绘制图形

基本思路
    1、定义数据文件格式（接口）
    2、编写程序，根据文件接口解析参数绘制图形
    3、编制数据文件

300,0,144,1,0,0
前三个参数对应：行进距离，转向判断（0：左转，1：右转），转向角度.后三个参数是RGB三个颜色通道（0~1间的浮点数）
'''
import turtle as t
t.title('自动轨迹绘制')
t.pencolor('red')
t.pensize(5)

#数据读取
datals=[]
f=open('data.txt')
for line in f:
    line=line.replace("\n","")
    #读取遍历每一行，并将最后的换行符变为空字符.此时 line存放的是定义的文件中每一行数据的接口的值
    datals.append(list(map(eval,line.split(","))))
    # split函数用逗号把字符串分割，生成列表（每个元素是用逗号分割的字符串）
    # map 函数的作用是把第一个参数作用于第二个参数上.本例中是将列表中每个元素的引号去掉
    # list将内部参数转换为列表
    #文件中的每一行经过三步处理后转为6个数值，作为列表的一个元素填入 datals中
f.close()

#自动绘制
for i in range(len(datals)):
    t.pencolor(datals[i][3],datals[i][4],datals[i][5])
    t.fd(datals[i][0])
    if datals[i][1]:
        t.right(datals[i][2])
    else:
        t.left(datals[i][2])

time库的使用

'''
time库是Python中处理时间的标准库
    计算机时间的表达
    提供获取系统时间并格式化输出功能
    提供系统级精确计时功能，用于程序性能分析
'''
import time
time.time() #获取当前时间戳，即计算机内部时间值，浮点数
#1567670013.2207754

time.ctime() #获取当前时间并以易读方式表示，返回字符串
#'Thu Sep  5 15:53:41 2019'

T=time.gmtime() #获取当前时间，表示为计算机可处理的时间格式
#time.struct_time(tm_year=2019, tm_mon=9, tm_mday=5, tm_hour=7, tm_min=53, tm_sec=48, tm_wday=3, tm_yday=248, tm_isdst=0)

'''
时间格式化：将时间以合理的方式展示出来
    格式化：类似字符串格式化，需要展示模板
    展示模板由特定的格式化控制符组成
strftime(tpl,ts) tpl是格式化模板字符串，用来定义输出效果，ts是计算机内部时间类型变量
strptime(str,tpl) str是字符串形式的时间值，tpi是格式化模板字符串，用来定义输入效果
'''
time.strftime("%Y-%m-%d %H:%M:%S",T)
#'2019-09-05 16:31:01'

timeStr='2019-09-05 16:37:55'
time.strptime(timeStr,"%Y-%m-%d %H:%M:%S")
#time.struct_time(tm_year=2019, tm_mon=9, tm_mday=5, tm_hour=16, tm_min=37, tm_sec=55, tm_wday=3, tm_yday=248, tm_isdst=-1)

'''
程序计时：测量起止动作所经历时间的过程
    测量时间：perf_counter() 返回一个CPU级别的精确时间计数值，单位为秒。由于该计数值起点不确定，连续调用取差值才有意义
    产生时间：sleep(s) s为休眠时间，单位是秒，可以是浮点数
'''
start=time.perf_counter()
end=time.perf_counter()
end-start
#5.327739800000018

def wait():
    time.sleep(3.3)
wait()
#程序将等待3.3秒后再继续运行

random库的使用

'''
random库是Python中用于生成随机数的标准库
计算机无法生成真的随机数，但是可以通过梅森旋转算法生成伪随机数

1、基本随机数函数
Python中的随机数使用随机数种子生成，只要种子相同，产生的随机序列都是一样的
    seed(a=None) 初始化给定的随机数种子，默认为当前系统时间。如：random.seed(10) #产生种子10对应的序列
    random() 生成一个[0.0,1.0)之间的随机小数
'''
import random
random.seed(10)
random.random()
#0.5714025946899135
random.random()
#0.4288890546751146
'''
2、扩展随机数函数
    randint(a,b) 生成一个[a,b]之间的随机整数
    randrande(m,n[,k]) 生成一个[m,n]之间以 k为步长的随机整数
    getrandbits(k) 生成一个 k比特长的随机整数
    uniform(a,b) 生成一个[a,b]之间的随机小数
    choice(seq) 从序列 seq中随机选择一个元素
    shuffle(seq) 将序列 seq中元素随机排序，返回打乱后的序列
'''