Python零基础先修课第六周两个单元

最新推荐文章于 2023-10-20 23:32:35 发布

魔法少女竹千代

最新推荐文章于 2023-10-20 23:32:35 发布

阅读量538

点赞数

分类专栏：自学文章标签： python

本文链接：https://blog.csdn.net/qq_43541776/article/details/112786367

版权

自学专栏收录该内容

32 篇文章 14 订阅

订阅专栏

Python零基础先修课第六周两个单元

笔记
- 第一单元
- 第二单元
课后练习
- 第一单元
- 第二单元

笔记

第一单元

计算生态

计算思维
-抽象、自动化
-实证思维、逻辑思维、计算思维
计算机模拟：模拟现实世界的计算过程，提供一般情况下无法获得的信息
自顶向下的设计
自顶向下的设计：从顶层开始分解问题为更小的问题。
例子：体育竞技分析

from random import random
#顶层设计
def main():
    printInto()
    probA,probB,n=getInputs()
    winsA,winsB=simNGames(n,probA,probB)
    PrintSummary(winsA,winsB)
#第二阶段
def printInto():
    print("This program simulateds a game between two")
    print("There are two players, A and B")
    print("Probability (a number between 0 and 1) is used")


def getInputs():
    a=eval(input("What is the prob.player A wins?"))
    b=eval(input("What is the prob.player B wins?"))
    n=eval(input("How many games to simulate?"))
    return a,b,n
#核心
def simNGames(n,probA,probB):
    winsA=0
    winsB=0
    for i in range(n):
        scoreA,scoreB=simOneGame(probA,probB)
        if scoreA>scoreB:
            winsA=winsA+1
        else:
            winsB=winsB+1
    return winsA,winsB
                 
#第三阶段
def simOneGame(probA,probB):
    scoreA=0
    scoreB=0
    serving="A"
    while not gameOver(scoreA,scoreB):
        if serving=="A":
            if random()<probA:
                scoreA=scoreA+1
            else:
                serving="B"
        else:
            if random()<probB:
                scoreB=scoreB+1
            else:
                serving="A"
    return scoreA,scoreB
                 
def gameOver(a,b):
    return a==15 or b==15

def PrintSummary(winsA,winsB):
    n=winsA+winsB
    print("\nGames simulated:%d"%n)
    print("Wins for A:{0}({1:0.1%})".format(winsA,winsA/n))
    print("Wins for B:{0}({1:0.1%})".format(winsB,winsB/n))                 

main()

自底向上的执行：从底层模块开始一个一个进行测试
软件测试
-小规模程序：直接运行
-中等规模：底层开始，逐步上升、运行基本函数，测试整体函数
-较大规模：高级软件测试方法
3. 软件开发方法
软件：
-能够完成预定功能和性能的可执行的计算机程序
-支持程序正常运行的数据
-描述程序的操作和使用的文档
软件工程：
-系统、严格约束、可量化的方法
-应用于软件的开发、运行和维护
在这里插入图片描述
常见的软件开发模式：瀑布模式、螺旋模式、快速原型模式、喷泉模式、混合模式、敏捷开发模式。
（1）瀑布模式：
-重视各个阶段的顺序性
-当一个阶段的文档获得认可才进入下一阶段

该模式不可迭代和重复，因此错误往往到最后才发现。开发进程易发生阻塞状态。
（2）螺旋模式
-首先设计、执行并测试原型。
-然后再设计、执行并测试新特征。
-再将原型逐步扩展为最终程序。
在这里插入图片描述
举例：体育竞技原型分析
-模拟一场比赛：每个球员50%概率赢分、比赛30回合、谁得分或改变发球权。

#原型例子
def simOneGame(probA,probB):
    scoreA=0
    scoreB=0
    serving="A"
    for i in range(30):
        if serving=="A":
            if random.random()<0.5:
                scoreA=scoreA+1
            else:
                serving="B"
        else:
            if random.random()<0.5:
                scoreB=scoreB+1
            else:
                serving="A"
    print(scoreA)
    print(scoreB)
simOneGame()

对上述程序分阶段补充程序
-阶段一：构建最初原型
-阶段二：增加两个赢球概率的参数
-阶段三：比赛直至一个球员获得15分
-阶段四：将比赛扩展为多场比赛，输出每个球员赢得的比赛场次

-阶段五：建立完整的程序，添加交互式输出和格式化报告
（3）敏捷开发方法：
-以人为核心、迭代、循序渐进
-多个相互联系、独立运行的小项目
-软件一直处于可使用状态
敏捷开发更符合软件开发规律：自底向上、逐步有序、遵序软件客观规律、迭代增量开发。
敏捷开发更能提高开发效率：在传统方法中，管理者“控制”团队，团队成员独立工作、协作少；敏捷开发方法中，管理者“激发”团队，团队成员共同参与。
敏捷开发采用轻量级的软件开发方法：
-Scrum：流行的敏捷开发框架、一个开发过程、几种角色、一套规范的实施方法。
-极限编程（XP）
-精益开发（Lean Development）
-动态系统开发方法（DSDM）
-特征驱动开发（Feature Driver Development）
-水晶开发（Cristal Clear）
敏捷开发典型过程：
-第一步：产品形成共识
-第二步：建立维护产品需求列表进行优先级排序
-第三步：筛选需求进入本轮迭代开发
-第四步：细化需求，完成本轮开发
-第五步：每日站立会议
-第六步：现场验收和反馈
-第七步：从第三步进行下一轮迭代
任务看板：
-记录未完成、正在做、已完成的工作状态
在这里插入图片描述
面向过程的程序设计（也叫结构化编程）
-程序执行过程为设计流程
-最自然的设计方法
举例：世界锦标赛——铅球
铅球飞行轨迹：已知投掷角度、初始速度，求解铅球飞行距离
铅球飞行轨迹IPO模式
-输入：铅球投掷角度、初始速度（m/s）、初始高度（m）
-处理：模拟铅球飞行
-输出：铅球飞行距离（m）
简化问题：
-忽略空气阻力
-重力加速度9.8m/s^2
-铅球的飞行：高度、距离
时刻更新铅球在飞行中的位置：
-起始位置(0,0)
-垂直方向运动距离(y轴)
-水平方向运动距离(x轴)
相关参数：
-仿真参数：投掷角度angle、初始速度velocity、初始高度height、飞行距离interval
-位置参数：x轴坐标xpos，y轴坐标ypos
-速度分量：x轴方向上速度xvel，y轴方向上速度yvel
计算初始速度：
-x轴速度xvel=velocity*cos(theta)
-y轴速度yvel=velocity*sin(theta)
Python的math库中用的是弧度rad不是°

#铅球飞行实例
from math import pi,sin,cos,radians
def main():
    angle=eval(input("Enter the launch angle (in degrees):"))
    vel=eval(input("Enter the initial velocity (in meters/sec):"))
    h0=eval(input("Enter the initial height (in meters):"))
    time=eval(input("Enter the time interval:"))


    xpos=0
    ypos=h0
    theta=radians(angle)
    xvel=vel*cos(theta)
    yvel=vel*sin(theta)

    #程序主体的循环
    while ypos>=0.0:
        xpos=xpos+time*xvel
        yvel1=yvel-time*9.8
        ypos=ypos+time*(yvel+yvel1)/2.0
        yvel=yvel1
    print("\nDistance traveled:{0:0.1f}meters.".format(xpos))
main()

#模块化
from math import pi,sin,cos,radians
def main():
    angle,vel,h0,time=getInputs()
    xpos,ypos=0,h0
    xvel,yvel=getXYComponents(vel,angle)
    while ypos>=0:
        xpos,ypos,yvel=updatePosition(time,xpos,ypos,xvel,yvel)
    print("\nDistance traveled:{0:0.1f}meters.".format(xpos))

def getInputs():
    angle=eval(input("Enter the launch angle (in degrees):"))
    vel=eval(input("Enter the initial velocity (in meters/sec):"))
    h0=eval(input("Enter the initial height (in meters):"))
    time=eval(input("Enter the time interval:"))
    return angle,vel,h0,time


def getXYComponents(vel,angle):
    theta=radians(angle)
    xvel=vel*cos(theta)
    yvel=vel*sin(theta)
    return xvel,yvel

def updatePosition(time,xpos,ypos,xvel,yvel):
    xpos=xpos+time*xvel
    yvel1=yvel-time*9.8
    ypos=ypos+time*(yvel+yvel1)/2.0
    yvel=yvel1
    return xpos,ypos,yvel
main()

面向过程的程序设计基本步骤：
-第一步：分子程序从输入到输出的各步骤
-第二步：按照执行过程从前到后编写程序
-第三步：将高耦合部分封装成模块或函数
-第四步：输入参数，按照程序执行过程调试
面向过程程序设计的特点：
-通过分步骤、模块化：将大问题分解为小问题、全局过程分解为局部过程
-面向过程：最为自然、最贴近程序执行过程；面向对象程序设计也会使用面向过程的程序设计
5. 面向对象的程序设计
-对象包含两种特征：状态和行为
类的概念：
-类：某种类型集合的描述
-属性：类本身的一些特性，如名字、身高和体重等属性；属性具体值则会根据每个人的不同而不同
-方法：类所能实现的行为，吃饭、走路和睡觉等方法。
类的定义
class classname[(父类名)] #父类名是可选的，定义父类名后子类拥有父类名的相应属性和方法。
[成员函数及成员变量]
-用_init_构造函数：初始化对象
-用_del_析构函数：销毁对象
举例：学生成绩计算
-学生评估：学分和平均绩点GPA
-GPA计算以4分为准则：3学分课程，学生得“A”，量分数为3*4=12

#创建一个类
class Student:
    def __init__(self,name,hours,qpoints):
        self.name=name
        self.hours=float(hours)
        self.qpoints=float(qpoints)
def getName(self):
    return self.name
def getHours(self):
    return self.hours
def getQPoints(self):
    return self.qpoints
def gpa(self):
return self.qpoints/self.hours

GPA算法描述
-获取文件名
-打开文件
-设置第一个学生为best
-对文件中的每一个学生：
if s.gpa()>best.gpa():
设置s为best

#找到GPA最高的学生
#创建一个类
class Student:
    def __init__(self,name,hours,qpoints):
        self.name=name
        self.hours=float(hours)
        self.qpoints=float(qpoints)
    def getName(self):
        return self.name
    def getHours(self):
        return self.hours
    def getQPoints(self):
        return self.qpoints
    def gpa(self):
        return self.qpoints/self.hours
def makeStudent(infoStr):
    name,hours,qpoints=infoStr.split("\t")
    return Student(name,hours,qpoints)
def main():
    #打开输入文件
    filename=input("Enter name the grade file: ")
    infile=open(filename,"r")
    #设置文件中第一个学生记录为best
    best=makeStudent(infile.readline())
    #处理文件剩余行数据
    for line in infile:
        #将每一行数据转换为一个记录
        s=makeStudent(line)
        #如果该学生是目前GPA最高的，则记录下来
	'''注意这里课程上给的代码错误，把if放到前面了，实际上if应该在for循环内部'''
        if s.gpa()>best.gpa():
            best=s
        infile.close()
        #打印GPA成绩最高的学生信息
        print("The best student is:",best.getName())
        print("hours:",best.getHours())
        print("GPA:",best.gpa())
if __name__=="__main__":
main()

在这里插入图片描述
面向对象程序设计的基本步骤：
-第一步：根据功能，抽象业务对象。
-第二步：构建独立的业务模块，利用封装、继承、多态等抽象业务需求。
-第三步：编写程序。
-第四步：以对象为单位输入参数、开展测试。
面向对象实例：铅球飞行轨迹计算
-铅球对象四个属性：xpos、ypos、xvel、yvel
-构建投射体的类Projectile
-创建和更新对象的变量

from math import sin,cos,radians

class Projectile:
    def __init__(self,angle,velocity,height):
        #根据给定的发射角度、初始速度和位置创建一个投射体对象
        self.xpos=0.0
        self.ypos=height
        theta=radians(angle)
        self.xvel=velocity*cos(theta)
        self.yvel=velocity*sin(theta)
    def update(self,time):
        #更新投射体的状态
        self.xpos=self.xpos+time*self.xvel
        yvel1=self.yvel-9.8*time
        self.ypos=self.ypos+time*(self.yvel+yvel1)/2.0
        self.yvel=yvel1
    def getY(self):
        #返回投射体的角度
        return self.ypos
    def getX(self):
        #返回投射体的距离
        return self.xpos
from Projectile import *
def getInputs():
    a=eval(input("Enter the launch angle (in degrees):"))
    v=eval(input("Enter the initial velocity (in meters/sec):"))
    h=eval(input("Enter the initial height (in meters):"))
    t=eval(input("Enter the time interval:"))
    return a,v,h,t
def main():
    angle,vel,h0,time=getInputs()
    shot=Projectile(angle,vel,h0)
    while shot.getY()>=0:
        shot.update(time)
    print("\nDistance traveled:{0:0.1f}meters.".format(shot.getX()))
if __name__=="__main__":
main()

我这里不知道为什么调用不了自己写的Projectile类，未找到解决方法，希望知道的朋友不吝赐教。
！！我知道了，就是class这个库要放在另一个py文件中，不能与主程序放在同一个py文件里。
6. 面向对象的特点
-封装：抽象对象、打包数据和操作；对象的实现与使用独立，支持代码复用
-多态：对象怎么回应消息，同一函数名启用不同方法；灵活性
-继承：一个类（subclass）可以借用另一个类（superclass）的行为；有点：避免操作重复、提升代码复用程度。

第二单元

交互式图形编程

图形编程基本介绍
现代计算机的图形图像应用：图形用户界面、图形对象、照片管理软件、视频播放软件。
图形显示有图素法和像素法，二者均用光栅扫描方式形成点阵，再将点阵信息存放在显示存储中，显示存储的内容与屏幕像素相对应，最后通过硬件设备显示出来。
-图素法：以图形对象为基本元素，如矩形、圆形。
-像素法：以像素点为基本单位。
图素法和像素法的区别
-图形——矢量图（放大不失真）
-图像——标量图（放大失真）
Python图形工具包：tkinter（简称tk接口）、Graphics、turtle
图形用户界面：
-Graphical User Interface, GUI
-Tkinter——Python标准GUI

Graphics——基于Tkinter扩展
-Turtle——Python内置的图形库
图形窗口：
-点（像素）的集合
-GraphWin对象尺寸默认值高200像素，宽200像素
点对象point：
-图形模块中最简单的对象
-参考坐标系定位
-坐标(x,y)
参考坐标系
-Graphics\Tkinter，点(0,0)表示屏幕左上角
-X轴正方向为从左到右
-Y轴正方向为从上到下
-默认窗口大小为200*200

图形对象的概念
类的实例：
-定义了实例包含的属性和方法
-两个独立的point实例：p1和p2：x,y值、getX()和draw()；不同的实例可以有不同的属性值

#绘制一个卡通脸
from graphics import *
win=GraphWin()
face=Circle(Point(100,95),50)
leftEye=Circle(Point(80,80),5)
leftEye.setFill("yellow")
leftEye.setOutline("red")
rightEye=Circle(Point(120,80),5)
rightEye.setFill("yellow")
rightEye.setOutline("red")
mouth=Line(Point(80,110),Point(120,110))

face.draw(win)
mouth.draw(win)
leftEye.draw(win)
rightEye.draw(win)

在这里插入图片描述
3. 交互式图形用户接口
图形用户界面（图形用户接口）：
-图形方式计算机操作界面
-用于程序的输入和输出
-事件驱动
事件：
-移动鼠标
-点击按钮
-键盘输入
事件驱动程序需要编程人员知道任何指定的时刻“谁在负责”。
Graphics模块：
-隐藏了底层事件的处理机制
-获得用户在窗口中的输入：捕捉鼠标点击、处理文本输入

#连续点击10次鼠标返回坐标值
from graphics import *
def main():
    win=GraphWin("Click Me!")
    for i in range(10):
        p=win.getMouse()
        print("You clicked at:",p.getX(),p.getY())
if __name__=="__main__":
main()

在这里插入图片描述
-Text对象：setText()和getText()
-Entry对象：setText()和getText()：但是内容可以被用户修改

#温度转换程序
from graphics import *

win = GraphWin("Celsius Converter", 400, 300)
win.setCoords(0.0, 0.0, 3.0, 4.0)
# 绘制接口
Text(Point(1,3), " Celsius Temperature:").draw(win)
Text(Point(1,1), "Fahrenheit Temperature:").draw(win)
input = Entry(Point(2,3), 5)
input.setText("0.0")
input.draw(win)
output = Text(Point(2,1),"")
output.draw(win)
button = Text(Point(1.5,2.0),"Convert It")
button.draw(win)
Rectangle(Point(1,1.5), Point(2,2.5)).draw(win)
# 等待鼠标点击
win.getMouse()
# 转换输入
celsius = eval(input.getText())
fahrenheit = 9.0/5.0 * celsius + 32.0
# 显示输出，改变按钮
output.setText(fahrenheit)
button.setText("Quit")
# 等待响应鼠标点击，退出程序
win.getMouse()
win.close()

在这里插入图片描述
Tkinter创建GUI程序的基本步骤
-第一步：导入Tkinter模块
-第二步：创建GUI应用程序的主窗口
-第三步：添加控件或GUI应用程序
-第四步：进入主事件循环，等待响应用户触发事件

Tkinter库创建GUI应用程序窗口的代码模板

from tkinter import *
tk=Tk()
#此处添加控件代码
...
tk.mainloop()

#简单GUI示例
from tkinter import *
tk=Tk()
label=Label(tk,text="Welcome  to python Tinter")
button=Button(tk,text="Click Me")
label.pack()
button.pack()
tk.mainloop()

在这里插入图片描述
不响应任何事件

#响应用户事件
from tkinter import *

def processOK():
    print("OK button is clicked")
def processCancel():
    print("Cancel button is clicked")
def main():
    tk=Tk()
    btnOK=Button(tk,text="OK",fg="red",command=processOK)
    btnCancel=Button(tk,text="Cancel",bg="yellow",command=processCancel)
    btnOK.pack()
    btnCancel.pack()

    tk.mainloop()

if __name__=="__main__":
    main()

在这里插入图片描述

#画布显示文字、图片和绘制图形
from tkinter import *

def main():
    tk=Tk()
    canvas=Canvas(tk,width=200,height=200)
    canvas.pack()
    canvas.create_text(100,40,text="Welcome to Tkinter",
                       fill="blue",font=("Times",16))
    myImage=PhotoImage(file="python_logo.gif")
    canvas.create_image(10,70,anchor=NW,image=myImage)
    canvas.create_rectangle(10,70,190,130)

    tk.mainloop()

if __name__=="__main__":
    main()

在这里插入图片描述

#上下左右键控制图形移动
from tkinter import *

def main():   
    tk = Tk()
    canvas = Canvas(tk, width = 400, height = 400)
    canvas.pack()

    def moverectangle(event):
        if event.keysym == "Up":
            canvas.move(1,0,-5)
        elif event.keysym == "Down":
            canvas.move(1,0,5)
        elif event.keysym == "Left":
            canvas.move(1,-5,0)
        elif event.keysym == "Right":
            canvas.move(1,5,0)
        
    canvas.create_rectangle(180,180,220,220,fill="red")
    canvas.bind_all("<KeyPress-Up>",moverectangle)
    canvas.bind_all("<KeyPress-Down>",moverectangle)
    canvas.bind_all("<KeyPress-Left>",moverectangle)
    canvas.bind_all("<KeyPress-Right>",moverectangle)
if __name__=="__main__":
    main()

在这里插入图片描述
4. 图形库的应用方法
GraphWin对象
-程序可以定义任意数量的窗体
-GraphWin()新窗口
-默认标题是”Graphics Windows”
-默认大小为200*200

-图形对象：点、线段、圆、椭圆、矩形、多边形以及文本
-默认初始化：黑色边框、未被填充
在这里插入图片描述

图形颜色：
-Python中颜色由字符串指定
-颜色具有不同深浅

#温度转换实例
from graphics import *

def convert(input):
    celsius = eval(input.getText())    # 输入转换
    fahrenheit = 9.0/5.0 * celsius + 32
    return fahrenheit 
def colorChange(win,input):
    cnum = eval(input.getText())
    weight = cnum / 100.0
    newcolor =color_rgb(int(255*weight),int(66+150*(1-weight)),int(255*(1-weight)))#这里要改一下，将color_rgb()内改成整数，否则报错
    win.setBackground(newcolor)
def main():
    win = GraphWin("Celsius Converter", 400, 300)
    win.setCoords(0.0, 0.0, 3.0, 4.0)
    # 绘制输入接口
    Text(Point(1,3),
         " Celsius Temperature:").draw(win)
    Text(Point(2,2.7),
         " (Please input 0.0-100.0 )").draw(win)
    Text(Point(1,1),
         "Fahrenheit Temperature:").draw(win)
    input = Entry(Point(2,3), 5)
    input.setText("0.0")
    input.draw(win)
    output = Text(Point(2,1),"")
    output.draw(win)
    button = Text(Point(1.5,2.0),"Convert It")
    button.draw(win)
    rect = Rectangle(Point(1,1.5), Point(2,2.5))
    rect.draw(win)
    # 等待鼠标点击
    win.getMouse()
    result = convert(input)    # 转换输入
    output.setText(result)    # 显示输出 
    # 改变颜色
    colorChange(win,input)
    # 改变按钮字体
    button.setText("Quit")
    # 等待点击事件，退出程序
    win.getMouse()
    win.close()

if __name__ == '__main__':
    main()

在这里插入图片描述
5. Turtle库

#应用circle绘制图形
import turtle

def main():
    turtle.pensize(3)
    turtle.penup()
    turtle.goto(-200,-50)
    turtle.pendown()
    turtle.begin_fill()
    turtle.color("red")
    turtle.circle(40, steps=3)
    turtle.end_fill()


    turtle.penup()
    turtle.goto(-100,-50)
    turtle.pendown()
    turtle.begin_fill()
    turtle.color("blue")
    turtle.circle(40, steps=4)
    turtle.end_fill()

    turtle.penup()
    turtle.goto(0,-50)
    turtle.pendown()
    turtle.begin_fill()
    turtle.color("green")
    turtle.circle(40, steps=5)
    turtle.end_fill()

    turtle.penup()
    turtle.goto(100,-50)
    turtle.pendown()
    turtle.begin_fill()
    turtle.color("yellow")
    turtle.circle(40, steps=6)
    turtle.end_fill()

    turtle.penup()
    turtle.goto(200,-50)
    turtle.pendown()
    turtle.begin_fill()
    turtle.color("purple")
    turtle.circle(40)
    turtle.end_fill()

    turtle.color("green")
    turtle.penup()
    turtle.goto(-100,50)
    turtle.pendown()
    turtle.write(("Cool Colorful shapes"),
        font = ("Times", 18, "bold"))
    turtle.hideturtle()

    turtle.done

if __name__ == '__main__':
    main()

在这里插入图片描述
6. 图形用户接口实例
Frame控件：
-容器区域布局
-frmLT、frmLC、frmLB、frmRT
控件对象命名规则：
-统一
-“控件类型”+“功能”

frmLT，frame+LeftTop
-txtMsg，text控件+消息
-btnSend，button控件+发送
sendMsg()
-回调函数
-通过函数指针调用的函数
grid()方法：界面上控件的布局

#聊天窗口
from tkinter import *
import time
def main():

    def sendMsg():#发送消息
        strMsg="我:"+time.strftime("%Y-%m-%d %H:%M:%S",time.localtime())+"\n"
        txtMsgList.insert(END,strMsg,"greencolor")
        txtMsgList.insert(END,txtMsg.get("0.0",END))
        txtMsg.delete("0.0",END)

    def cancelMsg():#取消消息
        txtMsg.delete("0.0",END)

    def sendMsgEvent(event):#发送消息事件
        if event.keysym=="Up":
            sendMsg()

    #创建窗口
    t=Tk()
    t.title("与python聊天中")

    #创建fame容器
    frmLT=Frame(width=500,height=320,bg="white")
    frmLC=Frame(width=500,height=150,bg="white")
    frmLB=Frame(width=500,height=30)
    frmRT=Frame(width=200,height=500)


    #创建控件
    txtMsgList=Text(frmLT)
    txtMsgList.tag_config("greencolor",foreground="#008C00")#创建tag
    txtMsg=Text(frmLC);
    txtMsg.bind("<KeyPress-Up>",sendMsgEvent)
    btnSend=Button(frmLB,text="发送",width=8,command=sendMsg)
    btnCancel=Button(frmLB,text="取消",width=8,command=cancelMsg)
    imgInfo=PhotoImage(file="python.gif")
    lblImage=Label(frmRT,image=imgInfo)
    lblImage.image=imgInfo
    
    #窗口布局
    frmLT.grid(row=0,column=0,columnspan=2,padx=1,pady=3)
    frmLC.grid(row=1,column=0,columnspan=2,padx=1,pady=3)
    frmLB.grid(row=2,column=0,columnspan=2)
    frmRT.grid(row=0,column=2,rowspan=3,padx=2,pady=3)
    #固定大小
    frmLT.grid_propagate(0)
    frmLC.grid_propagate(0)
    frmLB.grid_propagate(0)
    frmRT.grid_propagate(0)

    btnSend.grid(row=3,column=0)
    btnCancel.grid(row=3,column=1)
    lblImage.grid()
    txtMsgList.grid()
    txtMsg.grid()

    #主事件循环
    t.mainloop()

if __name__=="__main__":
    main()

在这里插入图片描述
界面设计和实现的过程
-界面布局设计
-创建所需控件：设定事件和命令响应
-对控件进行布局
-完成程序代码

模拟时钟程序过程
第一步：建立turtle对象并初始化
-表盘绘制turtle对象
-文本输出turtle对象
-三个指针turtle对象
第二步：静态表盘绘制
第三步：根据时钟更新表针位置和时间信息

from turtle import *
from datetime import *


def Week(t):    
    week = ["星期一", "星期二", "星期三",
            "星期四", "星期五", "星期六", "星期日"]
    return week[t.weekday()]

def Date(t):
    y = t.year
    m = t.month
    d = t.day
    return "%s %d %d" % (y, m, d)

def SetupClock(radius):
    #建立表的外框
    reset()
    pensize(7)
    for i in range(60):
        Skip(radius)
        if i%5==0:
            forward(20)
            Skip(-radius-20)
        else:
            dot(5)
            Skip(-radius)
        right(6)
#跨越函数Skip(step)
def Skip(step):
    penup()
    forward(step)
    pendown()

#定义表针函数mkHand()
def mkHand(name,length):
    #注册turtle形状，建立表针turtle
    reset()
    Skip(-length*0.1)
    begin_poly()
    forward(length*1.1)
    end_poly()
    handForm=get_poly()
    register_shape(name,handForm)
    
#初始化函数Init()
def Init():
    global secHand,minHand,hurHand,printer
    mode("logo")#重置turtle指向北
    #建立三个表针turtle并初始化
    mkHand("secHand",125)
    mkHand("minHand",130)
    mkHand("hurHand",90)
    secHand=Turtle()
    secHand.shape("secHand")
    minHand=Turtle()
    minHand.shape("minHand")
    hurHand=Turtle()
    hurHand.shape("hurHand")
    for hand in secHand, minHand, hurHand:
        hand.shapesize(1,1,3)
        hand.speed(0)
    #建立输出文字Turtle
    printer=Turtle()
    printer.hideturtle()
    printer.penup()

#更新时钟函数Tick()
def Tick():
    #绘制表针的动态显示
    t=datetime.today()
    second=t.second+t.microsecond*0.000001
    minute=t.minute+second/60.0
    hour=t.hour+minute/60.0

    tracer(False)
    printer.forward(65)
    printer.write(Week(t),align="center",font=("Courier",14,"bold"))
    printer.back(130)
    printer.write(Date(t),align="center",font=("Courier",14,"bold"))
    printer.home()
    tracer(True)
    secHand.setheading(6*second)
    minHand.setheading(6*minute)
    hurHand.setheading(30*hour)
    ontimer(Tick,100)#100ms后继续调用tick
    
def main():
    tracer(False)
    Init()
    SetupClock(160)
    tracer(True)
    Tick()
    mainloop()

if __name__=="__main__":
	main()

在这里插入图片描述
7. Turtle Art

from turtle import *
from random import *   

def ground():
    hideturtle()
    speed(100)
    for i in range(400):
        pensize(randint(5,10))
        x = randint(-400,350)
        y = randint(-280,-1)
        r = -y/280
        g = -y/280
        b = -y/280
        pencolor((r, g, b))
        penup()
        goto(x,y)
        pendown()
        forward(randint(40,100))

def snow():    
    hideturtle()
    pensize(2)
    speed(100)
    for i in range(100):
        r = random()
        g = random()
        b = random()
        pencolor(r, g, b)
        penup()
        setx(randint(-350,350))
        sety(randint(1,270))
        pendown()
        dens = randint(8,12)
        snowsize = randint(10,14)
        for j in range(dens):
            forward(snowsize)
            backward(snowsize)
            right(360/dens)
        

def main():
    setup(800, 600, 0, 0)
    tracer(False)#隐藏绘制过程
    bgcolor("black")    
    snow()
    ground()
    tracer(True)
    mainloop()
    
if __name__ == "__main__":
main()

在这里插入图片描述

颜色空间：
-RGB模型：光的三原色、色相由RGB共同决定
-HSV模型：H色彩、S深浅、V明暗；色相由H决定

from turtle import *

def HSB2RGB(hues):
    hues = hues * 3.59 #100转成359范围
    rgb=[0.0,0.0,0.0]
    i = int(hues/60)%6
    f = hues/60 -i
    if i == 0:
        rgb[0] = 1; rgb[1] = f; rgb[2] = 0
    elif i == 1:
        rgb[0] = 1-f; rgb[1] = 1; rgb[2] = 0
    elif i == 2:
        rgb[0] = 0; rgb[1] = 1; rgb[2] = f
    elif i == 3:
        rgb[0] = 0; rgb[1] = 1-f; rgb[2] = 1
    elif i == 4:
        rgb[0] = f; rgb[1] = 0; rgb[2] = 1
    elif i == 5:
        rgb[0] = 1; rgb[1] = 0; rgb[2] = 1-f
    return rgb
    
def rainbow():
    hues = 0.0
    color(1,0,0)
    #绘制彩虹
    hideturtle()
    speed(100)
    pensize(3)
    penup()
    goto(-400,-300)
    pendown()
    right(110)
    for i in range (100):
        circle(1000)
        right(0.13)
        hues = hues + 1
        rgb = HSB2RGB(hues)
        color(rgb[0],rgb[1],rgb[2])    
    penup()
    
def main():
    setup(800, 600, 0, 0)
    bgcolor((0.8, 0.8, 1.0))
    #tracer(False)
    rainbow()
    #输出文字
    tracer(False)
    goto(100,-100)
    pendown()
    color("yellow")
    write("Rainbow",align="center",
          font=("Script MT Bold", 80, "bold"))
    tracer(True)
    
    mainloop()

if __name__ == "__main__":
main()

在这里插入图片描述

课后练习

第一单元

在这里插入图片描述
为什么pip/pip3 install pyinstaller也不行！！！
安装不上呜呜呜。

第二单元

在这里插入图片描述
用的是主课程绘制玫瑰花实例中的代码

#玫瑰花的绘制
#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()

在这里插入图片描述
完结撒花

魔法少女竹千代

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
1
评论
Python零基础先修课第六周两个单元

Python零基础先修课第六周两个单元笔记第一单元第二单元课后练习第一单元第二单元笔记第一单元计算生态计算思维-抽象、自动化-实证思维、逻辑思维、计算思维计算机模拟：模拟现实世界的计算过程，提供一般情况下无法获得的信息自顶向下的设计自顶向下的设计：从顶层开始分解问题为更小的问题。例子：体育竞技分析from random import random#顶层设计def main(): printInto() probA,probB,n=getInputs()
复制链接

扫一扫