前言：本人接触的第一本编程书，记录下自学历程，希望有共同爱好的朋友一起探讨，共同进步，我会在B站上发表都代码的解读，最后感谢童晶老师

---

第一章  python的开发环境

在python官网下载最新版本的解释器，然后下载一个编辑器，（海龟编辑器不错的）

---

第二章 弹跳的小球

"""弹跳的小球"""
# 1 导入库设置窗口和参数
import pgzrun  # 导入 pgzrun 游戏库
WIDTH = 600  # 设置窗口的宽度
HEIGHT = 400  # 设置窗口的高度
x = WIDTH/2  # 小球的 x 坐标，初始化在窗口的中间
y = HEIGHT/2  # 小球的 y 坐标，初始化在窗口的中间
speed_x = 3  # 小球 x 方向的速度
speed_y = 5  # 小球 y 方向的速度
r = 20  # 小球的半径# 2 画出来
def draw():  # 绘制模块，每帧重复执行screen.fill('white')  # 白色背景screen.draw.filled_circle((x,y), r, 'red')  # 绘制一个填充圆，坐标（x，y），半径 r ，红色# 3 动起来
def update():  # 更新模块每帧重复执行global x,y,speed_x,speed_y  # 要修改的变量在这里说明x = x + speed_x  # 利用 x 方向速度更新 x 坐标y = y + speed_y  # 利用 y 方向速度更新 y 坐标if x >= WIDTH - r or x <= r:  # 当小球碰到左右边界时speed_x = -speed_x  # x 方向速度反转if y >= HEIGHT - r or y <= r:  # 当小球碰到上下边界时speed_y = -speed_y  # y 方向速度反转pgzrun.go()  # 开始执行游戏

---

知识点： 1，什么是库？如何安装，如何导入

2，变量的引用

3，函数的定义与调用

4，了解if语句

5，了解游戏窗口的设置和坐标

---

第三章 美丽的圆圈

"""利用for循环画同心圆"""
import pgzrun  # 导入游戏库
def draw():  # 定义画画函数screen.fill('white')  # 利用方法把屏幕填充为白色for r in range(250,0,-50):  # 临时变量在 1-201 里面间隔 10 位递增循环screen.draw.circle((400,300),r,'black')  # 屏幕。画。圆。（（参数）半径‘颜色’）
pgzrun.go()  # 执行游戏

"""颜色的表示"""
import pgzrun  # 导入游戏库
def draw():  # 定义画画函数screen.fill('white')  # 利用方法把屏幕填充为白色for r in range(250,0,-50):  # 临时变量在 250-0 里面间隔 50 位递减循环screen.draw.filled_circle((400,300),r,(r,0,0))  # 把颜色的参数设置为变量随循环递减
pgzrun.go()  # 执行游戏

"""有趣的随机颜色"""
import pgzrun  # 导入游戏库
import random # 导入随机库
def draw():  # 定义画画函数screen.fill('white')  # 利用方法把屏幕填充为白色for r in range(250,0,-50):  # 临时变量在 250-0 里面间隔 50 位递减循环screen.draw.filled_circle((400,300),r,(random.randint(0,255),random.randint(0,255),random.randint(0,255)))  # 导入随机库中的随机整数函数并设置参数
def on_mouse_down():  # 定义按下鼠标键函数draw()  # 调用函数
pgzrun.go()  # 执行游戏

"""循环嵌套的使用"""
# 连续在 x 轴上画圆
import pgzrun  # 导入游戏库
R = 50  # 定义半径的变量
def draw():  # 定义画画函数screen.fill('white')  # 利用方法把屏幕填充为白色for x in range(R,800,2*R):  # 临时变量循环在 50 - 800 之间，间隔 100 的递增screen.draw.filled_circle((x,300),R,'blue')  # 把变量 x 作为 x 轴的参数画半径为 50 的 圆
pgzrun.go()  # 执行游戏

"""循环嵌套再嵌套画满彩色的圆"""
import pgzrun  # 导入游戏库
import random
R = 50  # 定义半径的变量
def draw():  # 定义画画函数screen.fill('white')  # 利用方法把屏幕填充为白色for x in range(R,800,2*R):  # 临时变量 x 循环在 50 - 800 之间，间隔 100 的递增for y in range(R, 600, 2 * R):  # 临时变量 y 循环在 50 - 600 之间，间隔 100 的递增for r in range(1,R,5):screen.draw.filled_circle((x,y),R-r,(random.randint(0,255),random.randint(0,255),random.randint(0,255)))def on_mouse_down():  # 定义按下鼠标键函数draw()  # 调用函数
pgzrun.go()  # 执行游戏

知识点： 1，掌握for循环和嵌套的使用

2，颜色的表示

3，了解随机库

4，了解pqzrun里的函数作用

---

第四章 疯狂的圆圈

"""认识列表"""
# 1.列表的输出
xlist = [1,2,3,4,5]  # 定义列表
print(xlist)# 2.列表的输入
xlist = []  # 定义列表
for i in range(1, 6):  # 临时变量在1-6里面循环xlist.append(i)  # 把循环出的每个值添加到列表
print(xlist)# 3.列表的修改
xlist = [1, 2, 3, 4, 5]  # 定义列表
for i in range(5):  # 指定循环5次xlist[i] = 2 * xlist[i]  # 把取出的每个自己*2，再赋值给自己
print(xlist)# 4.列表的循环遍历
xlist = [1, 2, 3, 4, 5]  # 定义列表
for x in xlist:print(x)# 5.列表的长度统计
xlist = [1, 2, 3, 4, 5]  # 定义列表
print(len(xlist))  # 返回列表长度# 6.利用遍历统计列表的长度和相应的值
xlist = [1, 3, 5, 7, 9]  # 定义列表
for i in range(len(xlist)):  # 有几长就循环几次print(i,xlist)

"""实现一个小球反弹"""
import pgzrun  # 导入游戏库
WIDTH = 800  # 定义屏幕宽度
HEIGHT = 600  # 定义屏幕高度
x = WIDTH/2  # 定义小球的 x 坐标
y = HEIGHT/2  # 定义小球的 y 坐标
speed_x = 3  # 定义小球 x 方向下降的速度
speed_y = 5  # 定义小球 y 方向下降的速度
r = 30  # 定义小球半径
colorR = 255  # 定义小球三个颜色 R 的分量
colorG = 0  # 定义小球三个颜色 G 的分量
colorB = 0  # 定义小球三个颜色 B 的分量
ball = [x,y,speed_x,speed_y,r,colorR,colorG,colorB]  # 定义变量储存小球所有的信息
def draw():  # 定义画画函数screen.fill('white')  # 屏幕填充为白色# 在屏幕。画。填充圆（（坐标，半径，（颜色））screen.draw.filled_circle((ball[0],ball[1]),ball[4],  # 列表名 + 【相对应的下标】就是小球储存在列表中的各类信息(ball[5],ball[6],ball[7]))
def update():  # 定义重复执行函数ball[0] = ball[0] + ball[2]  # x 坐标 = x + speed_xball[1] = ball[1] + ball[3]  # y 坐标 = x + speed_yif ball[0] > WIDTH - ball[4] or ball[0] < ball[4]:  # 当小球 x 坐标碰到左右边界时ball[2] = - ball[2]  # x 方向速度反转elif ball[1] > HEIGHT - ball[4] or ball[1] < ball[4]:  # 当小球 y 坐标碰到上下边界时ball[3] = - ball[3]  # y 方向速度反转
pgzrun.go()  # 开始执行游戏

"""实现多个彩色小球反弹"""
import pgzrun  # 导入游戏库
import random  # 导入随机库
WIDTH = 800  # 定义屏幕宽度
HEIGHT = 600  # 定义屏幕高度
balls = []  # 定义空列表用来储存小球信息
for i in range(100):  # 临时变量 i 在 100 里面循环x = random.randint(100,WIDTH - 100)  # 调用机函数在（100，700）生成 x 的坐标y = random.randint(100,HEIGHT - 100)  # 调用机函数在（100，600）生成 y 的坐标speed_x = random.randint(1,5)  # 调用机函数在（1，5）生成 x 坐标的下降速度speed_y = random.randint(1,5)  # 调用机函数在（1，5）生成 y 坐标的下降速度r = random.randint(5,50)  # 调用机函数在（5，50）生成半径colorR = random.randint(10,255)  # 调用机函数生成小球三个颜色 R 的分量colorG = random.randint(10,255)  # 调用机函数生成小球三个颜色 G 的分量colorB = random.randint(10,255)  # 调用机函数生成小球三个颜色 B 的分量ball1 = [x,y,speed_x,speed_y,r,colorR,colorG,colorB]  # 把小球的信息赋值给列表balls.append(ball1)  # 把每次循环生成的小球信息列表添加到函数外的空列表
def draw():  # 定义画画函数screen.fill('white')  # 屏幕填充为白色背景for ball in balls:  # 临时变量在外面列表里面循环# 在屏幕。画。填充圆（（坐标，半径，（颜色））# screen.draw.filled_circle((ball[0],ball[1]),ball[4],  # 列表名 + 【相对应的下标】就是小球储存在列表中的各类信息#                            (ball[5],ball[6],ball[7]))for x in range(1, ball[4], 3):  # 用同心圆填充screen.draw.filled_circle((ball[0], ball[1]), ball[4] - x, (random.randint(ball[5], 255), random.randint(ball[6], 255), random.randint(ball[7], 255)))
def update():  # 绘制模块，每帧重复执行for ball in balls:  # 临时变量在外面列表里面循环ball[0] = ball[0] + ball[2]  # x 坐标 = x + speed_xball[1] = ball[1] + ball[3]  # y 坐标 = y + speed_yif ball[0] > WIDTH - ball[4] or ball[0] < ball[4]:  # 当小球 x 坐标碰到左右边界时ball[2] = - ball[2]  # x 方向速度反转elif ball[1] > HEIGHT - ball[4] or ball[1] < ball[4]: # 当小球 y 坐标碰到上下边界时ball[3] = - ball[3]  # y 方向速度反转
pgzrun.go()  # 开始执行游戏

"""实现鼠标控制多个彩色小球反弹"""
import pgzrun  # 导入游戏库
import random  # 导入随机库
WIDTH = 800  # 定义屏幕宽度
HEIGHT = 600  # 定义屏幕高度
balls = []  # 定义空列表用来储存小球信息def draw():  # 定义画画函数screen.fill('white')  # 屏幕填充为白色背景for ball in balls:  # 临时变量在外面列表里面循环# 在屏幕。画。填充圆（（坐标，半径，（颜色））screen.draw.filled_circle((ball[0],ball[1]),ball[4],  # 列表名 + 【相对应的下标】就是小球储存在列表中的各类信息(ball[5],ball[6],ball[7]))for x in range(1, ball[4], 3):  # 用同心圆填充screen.draw.filled_circle((ball[0], ball[1]), ball[4] - x, (random.randint(ball[5], 255), random.randint(ball[6], 255), random.randint(ball[7], 255)))def update():  # 绘制模块，每帧重复执行for ball in balls:  # 临时变量在外面列表里面循环ball[0] = ball[0] + ball[2]  # x 坐标 = x + speed_xball[1] = ball[1] + ball[3]  # y 坐标 = y + speed_yif ball[0] > WIDTH - ball[4] or ball[0] < ball[4]:  # 当小球 x 坐标碰到左右边界时ball[2] = - ball[2]  # x 方向速度反转elif ball[1] > HEIGHT - ball[4] or ball[1] < ball[4]: # 当小球 y 坐标碰到上下边界时ball[3] = - ball[3]  # y 方向速度反转def on_mouse_move(pos,rel,buttons):  # 当鼠标移到时（坐标,按下）if mouse.LEFT in buttons:  # 如果鼠标左键时执行x = pos[0]  # x轴y = pos[1]  # y轴speed_x = random.randint(1, 5)  # 调用机函数在（1，5）生成 x 坐标的下降速度speed_y = random.randint(1, 5)  # 调用机函数在（1，5）生成 y 坐标的下降速度r = random.randint(5, 50)  # 调用机函数在（5，50）生成半径colorR = random.randint(10, 255)  # 调用机函数生成小球三个颜色 R 的分量colorG = random.randint(10, 255)  # 调用机函数生成小球三个颜色 G 的分量colorB = random.randint(10, 255)  # 调用机函数生成小球三个颜色 B 的分量ball = [x, y, speed_x, speed_y, r, colorR, colorG, colorB]  # 把小球的信息赋值给列表balls.append(ball)  # 把每次循环生成的小球信息列表添加到函数外的空列表pgzrun.go()  # 开始执行游戏

知识点： 1，了解列表和列表的取值

---

第五章 飞翔的小鸟

图片资源：

注意：图片文件夹名一定要为images，必须和代码文件在同一文件夹里面

http://链接：https://pan.baidu.com/s/18Ms_J1XQsRqlUSG9AcER5Q 提取码：u38m --来自百度网盘超级会员V6的分享

"""飞翔的小鸟"""
import pgzrun  # 导入游戏库
import random  # 导入随机库WIDTH = 350  # 设置屏幕宽度
HEIGHT = 600  # 设置屏幕高度
score = 0  # 设置得分初始值
speed = 1  # 设置速度初始值background = Actor('background')  # 导入背景图片
bird = Actor('bird')  # 导入小鸟图片
bird.x = 50  # 设置小鸟 x 坐标
bird.y = HEIGHT / 2  # 设置小鸟 y 坐标
bar_up = Actor('bar_up')  # 导入上树图片
bar_up.x = 300  # 设置树 x 坐标
bar_up.y = 0  # 设置树 y 坐标
bar_down = Actor('bar_down')  # 导入下树图片
bar_down.x = 300  # 设置树 x 坐标
bar_down.y = 600  # 设置树 y 坐标def draw():  # 定义画画函数background.draw()  #  画背景bar_up.draw()  # 画上树bar_down.draw()  # 画下树bird.draw()  # 画小鸟# 设置记分牌的数据类型，坐标，大小，颜色screen.draw.text(str(score), (30, 30), fontsize=50, color='green')def update():  # 定义更新模块重复执行函数global score, speed  # 定义全局变量bird.y += 2  # 增加小鸟 y 轴参数让其下落bar_up.x += -speed  # 增加上树 x 轴参数让其左移动bar_down.x += -speed  # 增加上树 y 轴参数让其左移动if bar_up.x < 0:  # 如果上树 x 轴坐标小于 0bar_up.x = WIDTH  # 就上树 x 坐标调整到屏幕宽度bar_down.x = WIDTH  # 就下树 x 坐标调整到屏幕宽度bar_up.y = random.randint(-200,200)  # 上树 y 轴坐标随机在（）之间bar_down.y = 600 + bar_up.y  # 上下树 之间的距离要固定score += 1  # 得分加 1if (score % 5 == 0): # 如果得分增加了5分，就让游戏速度增加speed = speed + 1  # 速度加 1elif bird.colliderect(bar_up) or bird.colliderect(bar_down)\or bird.y < 0 or bird.y > HEIGHT:  # 如果小鸟碰到上树或下树或 y 轴小于 0 或 y轴大于高度print('游戏失败')score = 0speed = 1bird.x = 50  # 设置小鸟的x坐标bird.y = HEIGHT / 2  # 设置小鸟的y坐标bar_up.x = WIDTH  # 设置障碍物上半部分的x坐标bar_up.y = 0  # 设置障碍物上半部分的y坐标bar_down.x = WIDTH  # 设置障碍物下半部分的x坐标bar_down.y = 600  # 设置障碍物下半部分的y坐标\def on_mouse_down():  # 定义当按下鼠标时就运行bird.y = bird.y - 60  # 小鸟 y 坐标减少 60 即上升pgzrun.go()  # 开始执行

知识点： 1，掌握设置背景图

2，鼠标控制小鸟移动

3， 怎样判断输赢

---

第六章 见缝插针

图片和音效资源：

http://链接：https://pan.baidu.com/s/1iQY5duW-BIb-EINPhAXEXA 提取码：oabs --来自百度网盘超级会员V6的分享

"""画出针和圆盘"""
import pgzrun  # 导入游戏库
needle = Actor('needle')  # 导入针的图片
needle.x = 100     # 设置针的x坐标
needle.y = 300     # 设置针的y坐标def draw():   # 绘制模块，每帧重复执行screen.fill('white')  # 白色背景screen.draw.circle((400, 300), 80, 'red') # 绘制圆盘needle.draw()        # 绘制针pgzrun.go()   # 开始执行游戏

"""让针转起来"""
import pgzrun  # 导入游戏库
# 导入针的图片、设置锚点相对坐标
needle = Actor('needle', anchor=(170+50, 1))
needle.x = 400     # 设置针锚点的x坐标
needle.y = 300     # 设置针锚点的y坐标def draw():   # 绘制模块，每帧重复执行screen.fill('white')  # 白色背景screen.draw.circle((400, 300), 80, 'red') # 绘制圆盘needle.draw()        # 绘制针def update():   # 更新模块，每帧重复操作needle.angle = needle.angle + 1  # 针的角度增加，即慢慢旋转pgzrun.go()   # 开始执行游戏

"""鼠标控制针的发射"""
import pgzrun  # 导入游戏库
needles = []  # 存储所有针的列表，开始为空
# 导入针的图片、设置锚点相对坐标
newNeedle = Actor('needle', anchor=(170+50, 1))
newNeedle.x = 220     # 设置针锚点的x坐标
newNeedle.y = 300     # 设置针锚点的y坐标
needles.append(newNeedle)  # 初始一根针加入列表中def draw():   # 绘制模块，每帧重复执行screen.fill('white')  # 白色背景screen.draw.circle((400, 300), 80, 'red') # 绘制圆盘for needle in needles:  # 绘制列表中每根针needle.draw()        # 绘制针def update():   # 更新模块，每帧重复操作for needle in needles:  # 对列表中每根针遍历处理if needle.x == 400:  # 如果针到了目标位置，才开始旋转needle.angle = needle.angle + 1  # 针的角度增加，即慢慢旋转def on_mouse_down():  # 当按下鼠标global newNeedlenewNeedle.x = 400  # 针移动到目标位置# 再新建一根针newNeedle = Actor('needle', anchor=(170+50, 1))newNeedle.x = 220     # 设置针锚点的x坐标newNeedle.y = 300     # 设置针锚点的y坐标needles.append(newNeedle)  # 初始一根针加入列表中pgzrun.go()   # 开始执行游戏

"""判断输赢"""
import pgzrun  # 导入游戏库# 导入初始位置针的图片、设置锚点相对坐标
startNeedle = Actor('needle', anchor=(170+50, 1))
startNeedle.x = 200     # 设置针锚点的x坐标
startNeedle.y = 300     # 设置针锚点的y坐标
needles = []  # 存储所有针的列表，开始为空
rotateSpeed = 1  # 旋转速度，默认是1，后面游戏结束后改成0def draw():   # 绘制模块，每帧重复执行screen.fill('white')  # 白色背景startNeedle.draw()    # 初始位置针的绘制for needle in needles:  # 绘制列表中每根针needle.draw()        # 绘制针screen.draw.circle((400, 300), 80, 'red')  # 绘制圆盘def update():   # 更新模块，每帧重复操作for needle in needles:  # 对列表中每根针遍历处理needle.angle = needle.angle + rotateSpeed  # 针的角度增加，即慢慢旋转def on_mouse_down():  # 当按下鼠标global rotateSpeed# 再新建一根针newNeedle = Actor('needle', anchor=(170+50, 1))newNeedle.x = 400     # 设置针锚点的x坐标newNeedle.y = 300     # 设置针锚点的y坐标for needle in needles:if newNeedle.colliderect(needle):print('游戏失败')rotateSpeed = 0 # 游戏失败，针停止旋转needles.append(newNeedle)  # 把针加入列表中pgzrun.go()   # 开始执行游戏

"""添加音效显示得分"""
import pgzrun  # 导入游戏库
TITLE = 'Python见缝插针'  # 设置游戏名
newNeedle = Actor('needle', anchor=(170 + 50, 1.5))  # 导入针并设置针旋转的锚点
newNeedle.x = 220  # 针的 x 坐标
newNeedle.y = 300  # 针的 y 坐标
needles = []  # 定义储存针的列表
rotatespeed = 1  # 速度设置为 1
score = 0  # 计分器设置为 0
#needles.append(newNeedle)def draw():  # 定义画画函数screen.fill('white')  # 屏幕填充为白色newNeedle.draw()  # 画针screen.draw.circle((400,300),80,'red')  # 屏幕上画圆（坐标，半径，颜色）screen.draw.text(str(score), (50, 250),fontsize=50, color='green')  # 显示游戏得分if rotatespeed == 0:  # 如果游戏速度等于 0screen.draw.text("Game Over!", (10, 320), fontsize=35, color='red')  # 屏幕上画"Game Over!"for needle in needles:  # 临时变量在针列表里面循环needle.draw()  # 画针def update():  # 定义重复执行函数for needle in needles:  # 临时变量在针列表里面循环if needle.x == 400:  # 如果针的 x 坐标等于 400needle.angle += rotatespeed  # 针的角度逆时针加 1def on_mouse_down():  # 当按下鼠标global rotatespeed,score  # 定义全局变量if rotatespeed >0: # 如果速度大于 0music.play_once('弹簧')  # 播放音效# newNeedle.x = 400newNeedle = Actor('needle', anchor=(170 + 50, 1.5))  # 导入针并设置针旋转的锚点newNeedle.x = 400  # 针的 x 坐标newNeedle.y = 300  # 针的 y 坐标for needle in needles:  # 临时变量在针列表里面循环if newNeedle.colliderect(needle):  # 如果新针碰撞到针print('游戏失败')rotatespeed = 0  # 速度等于 0music.play_once('溜走')if rotatespeed > 0:  # 如果针还在旋转score = score + 1  # 得分加1needles.append(newNeedle)  # 把新针添加到列表里面pgzrun.go()  # 执行

知识点： 1，认识全局变量global

2，锚点的设置

3，屏幕上画文字

4，添加音效

---

第七章 飞机大战

图片，音效，资源：http://链接：https://pan.baidu.com/s/1gQqpjNgblyfpqZSd4Qz6-A?pwd=8888 提取码：8888 --来自百度网盘超级会员V6的分享

"""画出背景与飞机"""
import pgzrun  # 导入游戏库
WIDTH = 480    # 设置窗口的宽度
HEIGHT = 852   # 设置窗口的高度background = Actor('background')  # 导入背景图片
hero = Actor('hero')  # 导入玩家飞机图片
hero.x = WIDTH/2      # 设置玩家飞机的x坐标
hero.y = HEIGHT*2/3   # 设置玩家飞机的y坐标def draw():background.draw()  # 绘制游戏背景hero.draw()  # 绘制玩家飞机pgzrun.go()  # 开始执行游戏

"""飞机和背景动起来"""
import pgzrun  # 导入游戏库
WIDTH = 480    # 设置窗口的宽度
HEIGHT = 700   # 设置窗口的高度background1 = Actor('background')  # 导入背景图片
background1.x = 480/2  # 背景1的x坐标
background1.y = 852/2  # 背景1的y坐标
background2 = Actor('background')  # 导入背景图片
background2.x = 480/2   # 背景2的x坐标
background2.y = -852/2  # 背景2的y坐标hero = Actor('hero')  # 导入玩家飞机图片
hero.x = WIDTH/2      # 设置玩家飞机的x坐标
hero.y = HEIGHT*2/3   # 设置玩家飞机的y坐标def draw():  # 绘制模块，每帧重复执行background1.draw()  # 绘制游戏背景background2.draw()  # 绘制游戏背景hero.draw()  # 绘制玩家飞机def update():  # 更新模块，每帧重复操作# 以下代码用于实现背景图片的循环滚动效果if background1.y > 852/2 + 852:background1.y = -852/2  # 背景1移动到背景2的正上方if background2.y > 852/2 + 852:background2.y = -852/2  # 背景2移动到背景1的正上方background1.y += 1  # 背景1向下滚动background2.y += 1  # 背景2向下滚动def on_mouse_move(pos, rel, buttons):  # 当鼠标移动时执行hero.x = pos[0]  # 玩家飞机的x坐标设为鼠标的x坐标hero.y = pos[1]  # 玩家飞机的y坐标设为鼠标的y坐标pgzrun.go()  # 开始执行游戏

"""添加敌机"""
import pgzrun  # 导入游戏库
import random  # 导入随机库WIDTH = 480    # 设置窗口的宽度
HEIGHT = 700   # 设置窗口的高度background1 = Actor('background')  # 导入背景1图片
background1.x = 480/2  # 背景1的x坐标
background1.y = 852/2  # 背景1的y坐标
background2 = Actor('background')  # 导入背景2图片
background2.x = 480/2   # 背景2的x坐标
background2.y = -852/2  # 背景2的y坐标bullet = Actor('bullet')  # 导入子弹图片
bullet.x = WIDTH/2        # 子弹的x坐标
bullet.y = -HEIGHT       # 子弹的y坐标，开始不可见hero = Actor('hero')  # 导入玩家飞机图片
hero.x = WIDTH/2      # 设置玩家飞机的x坐标
hero.y = HEIGHT*2/3   # 设置玩家飞机的y坐标enemy = Actor('enemy')  # 导入敌机图片
enemy.x = WIDTH/2       # 设置敌机的x坐标
enemy.y = 0             # 设置敌机的y坐标def draw():  # 绘制模块，每帧重复执行background1.draw()  # 绘制游戏背景background2.draw()  # 绘制游戏背景hero.draw()  # 绘制玩家飞机enemy.draw()  # 绘制敌机飞机bullet.draw()  # 绘制子弹def update():  # 更新模块，每帧重复操作# 以下代码用于实现背景图片的循环滚动效果if background1.y > 852/2 + 852:background1.y = -852/2  # 背景1移动到背景2的正上方if background2.y > 852/2 + 852:background2.y = -852/2  # 背景2移动到背景1的正上方background1.y += 1  # 背景1向下滚动background2.y += 1  # 背景2向下滚动if bullet.y > -HEIGHT:bullet.y = bullet.y - 10 # 子弹自动向上移动enemy.y += 3 # 敌机自动下落if enemy.y > HEIGHT: # 敌机落到画面底部enemy.y = 0 # 敌机从上面重新出现enemy.x = random.randint(30, WIDTH-30)  # 敌机水平位置随机def on_mouse_move(pos, rel, buttons):  # 当鼠标移动时执行hero.x = pos[0]  # 玩家飞机的x坐标设为鼠标的x坐标hero.y = pos[1]  # 玩家飞机的y坐标设为鼠标的y坐标def on_mouse_down(): # 当鼠标键按下时bullet.x = hero.x   # 把子弹位置设为玩家飞机的正上方bullet.y = hero.y - 70pgzrun.go()  # 开始执行游戏

"""判断输赢和得分"""
import pgzrun  # 导入游戏库
import random  # 导入随机库WIDTH = 480    # 设置窗口的宽度
HEIGHT = 700   # 设置窗口的高度
TITLE = 'Python飞机大战'background1 = Actor('background')  # 导入背景1图片
background1.x = 480/2  # 背景1的x坐标
background1.y = 852/2  # 背景1的y坐标
background2 = Actor('background')  # 导入背景2图片
background2.x = 480/2   # 背景2的x坐标
background2.y = -852/2  # 背景2的y坐标bullet = Actor('bullet')  # 导入子弹图片
bullet.x = WIDTH/2        # 子弹的x坐标
bullet.y = -HEIGHT       # 子弹的y坐标，开始不可见hero = Actor('hero')  # 导入玩家飞机图片
hero.x = WIDTH/2      # 设置玩家飞机的x坐标
hero.y = HEIGHT*2/3   # 设置玩家飞机的y坐标enemy = Actor('enemy')  # 导入敌机图片
enemy.x = WIDTH/2       # 设置敌机的x坐标
enemy.y = 0             # 设置敌机的y坐标score = 0     # 游戏得分isLoose = False # 游戏是否失败，初始不失败def draw():  # 绘制模块，每帧重复执行background1.draw()  # 绘制游戏背景background2.draw()  # 绘制游戏背景hero.draw()  # 绘制玩家飞机enemy.draw()  # 绘制敌机飞机bullet.draw()  # 绘制子弹# 下面显示得分screen.draw.text("得分: "+str(score), (200, HEIGHT-50), fontsize=30,fontname='s', color='black')if isLoose: # 游戏失败后输出信息screen.draw.text("游戏失败！", (50, HEIGHT/2), fontsize=90,fontname='s', color='red')def update():  # 更新模块，每帧重复操作global score, isLooseif isLoose:return # 如果游戏失败，返回，不做下面的操作# 以下代码用于实现背景图片的循环滚动效果if background1.y > 852/2 + 852:background1.y = -852/2  # 背景1移动到背景2的正上方if background2.y > 852/2 + 852:background2.y = -852/2  # 背景2移动到背景1的正上方background1.y += 1  # 背景1向下滚动background2.y += 1  # 背景2向下滚动if bullet.y > -HEIGHT:bullet.y = bullet.y - 10 # 子弹自动向上移动enemy.y += 3 # 敌机自动下落if enemy.y > HEIGHT: # 敌机落到画面底部enemy.y = 0 # 敌机从上面重新出现enemy.x = random.randint(50, WIDTH-50)  # 敌机水平位置随机if bullet.colliderect(enemy): # 子弹与敌机发生碰撞后enemy.y = 0 # 敌机从上面重新出现enemy.x = random.randint(0, WIDTH)  # 敌机水平位置随机score = score + 1 # 得分加1bullet.y = -HEIGHT  # 隐藏子弹if hero.colliderect(enemy): # 玩家飞机和敌机发生碰撞isLoose = True  # 游戏失败hero.image = 'hero_blowup' # 更换游戏玩家的图片为爆炸图片def on_mouse_move(pos, rel, buttons):  # 当鼠标移动时执行if isLoose:return  # 如果游戏失败，返回，不做下面的操作hero.x = pos[0]  # 玩家飞机的x坐标设为鼠标的x坐标hero.y = pos[1]  # 玩家飞机的y坐标设为鼠标的y坐标def on_mouse_down(): # 当鼠标键按下时if isLoose:return  # 如果游戏失败，返回，不做下面的操作bullet.x = hero.x   # 把子弹位置设为玩家飞机的正上方bullet.y = hero.y - 70pgzrun.go()  # 开始执行游戏

"""判断输赢和得分"""
import pgzrun  # 导入游戏库
import random  # 导入随机库WIDTH = 480    # 设置窗口的宽度
HEIGHT = 700   # 设置窗口的高度
TITLE = 'Python飞机大战'background1 = Actor('background')  # 导入背景1图片
background1.x = 480/2  # 背景1的x坐标
background1.y = 852/2  # 背景1的y坐标
background2 = Actor('background')  # 导入背景2图片
background2.x = 480/2   # 背景2的x坐标
background2.y = -852/2  # 背景2的y坐标bullet = Actor('bullet')  # 导入子弹图片
bullet.x = WIDTH/2        # 子弹的x坐标
bullet.y = -HEIGHT       # 子弹的y坐标，开始不可见hero = Actor('hero')  # 导入玩家飞机图片
hero.x = WIDTH/2      # 设置玩家飞机的x坐标
hero.y = HEIGHT*2/3   # 设置玩家飞机的y坐标enemy = Actor('enemy')  # 导入敌机图片
enemy.x = WIDTH/2       # 设置敌机的x坐标
enemy.y = 0             # 设置敌机的y坐标score = 0     # 游戏得分isLoose = False # 游戏是否失败，初始不失败def draw():  # 绘制模块，每帧重复执行background1.draw()  # 绘制游戏背景background2.draw()  # 绘制游戏背景hero.draw()  # 绘制玩家飞机enemy.draw()  # 绘制敌机飞机bullet.draw()  # 绘制子弹# 下面显示得分screen.draw.text("得分: "+str(score), (200, HEIGHT-50), fontsize=30,fontname='s', color='black')if isLoose: # 游戏失败后输出信息screen.draw.text("游戏失败！", (50, HEIGHT/2), fontsize=90,fontname='s', color='red')def update():  # 更新模块，每帧重复操作global score, isLooseif isLoose:return # 如果游戏失败，返回，不做下面的操作# 以下代码用于实现背景图片的循环滚动效果if background1.y > 852/2 + 852:background1.y = -852/2  # 背景1移动到背景2的正上方if background2.y > 852/2 + 852:background2.y = -852/2  # 背景2移动到背景1的正上方background1.y += 1  # 背景1向下滚动background2.y += 1  # 背景2向下滚动if bullet.y > -HEIGHT:bullet.y = bullet.y - 10 # 子弹自动向上移动enemy.y += 3 # 敌机自动下落if enemy.y > HEIGHT: # 敌机落到画面底部enemy.y = 0 # 敌机从上面重新出现enemy.x = random.randint(50, WIDTH-50)  # 敌机水平位置随机if bullet.colliderect(enemy): # 子弹与敌机发生碰撞后enemy.y = 0 # 敌机从上面重新出现enemy.x = random.randint(0, WIDTH)  # 敌机水平位置随机score = score + 1 # 得分加1bullet.y = -HEIGHT  # 隐藏子弹if hero.colliderect(enemy): # 玩家飞机和敌机发生碰撞isLoose = True  # 游戏失败hero.image = 'hero_blowup' # 更换游戏玩家的图片为爆炸图片def on_mouse_move(pos, rel, buttons):  # 当鼠标移动时执行if isLoose:return  # 如果游戏失败，返回，不做下面的操作hero.x = pos[0]  # 玩家飞机的x坐标设为鼠标的x坐标hero.y = pos[1]  # 玩家飞机的y坐标设为鼠标的y坐标def on_mouse_down(): # 当鼠标键按下时if isLoose:return  # 如果游戏失败，返回，不做下面的操作bullet.x = hero.x   # 把子弹位置设为玩家飞机的正上方bullet.y = hero.y - 70pgzrun.go()  # 开始执行游戏

知识点： 1，怎样让背景动起来

2，怎样判断输赢

3，怎样切换画面

4，另一种添加音效 的方法

5，了解布尔值

小节：如果你认真学习前面几个案例就会发现游戏编程的流程

1，导入所需的库设置游戏的窗口

2，设置好角色的坐标

3，画出角色

4，让角色动起来

5，判断输赢

6，添加音效

7，显示游戏的动态（得分，关卡）

8，仔细找bug（每个程序员必须经历的）

所以接下来的游戏代码不再按步骤上传：

---

第八章 勇闯地下100层

图片资源：http://链接：https://pan.baidu.com/s/1tj2ODWN6aun5XfzYtG47sA?pwd=8888 提取码：8888 --来自百度网盘超级会员V6的分享

"""勇闯地下一百层"""
# 1.导入库设置窗口
import pgzrun  # 导入游戏库
import random  # 导入随即库
WIDTH = 600  # 屏幕宽度
HEIGHT = 800  # 屏幕高度# 2.定义角色坐标和初始速度
playerspeed = 5  # 角色移动速度
brickSpeed = 2  # 砖块上升速度
score = 0  # 定义分数
isLoose = False  # 定义游戏为失败alien = Actor('alien')  # 导入角色图片
alien.x = WIDTH/2  # 定义角色 x 坐标
alien.y = HEIGHT/2  # 定义角色 y 坐标
lastAlienY = alien.y  # 把角色 y 坐标赋值给判断角色下降的变量bricks = []  # 定义储存砖块的空列表
for i in range(5):  # 临时变量在 5 里面循环brick = Actor('brick')  # 导入砖块图片brick.pos = 100*(i+1), 150*(i+1)  # 定义砖块 x，y 坐标bricks.append(brick)  # 把定义好的砖块添加的列表# 3.画出来
def draw():  # 定义画画函数screen.clear()  # 清空屏幕alien.draw()  # 画出角色for brick in bricks:  # 让临时变量在列表里面循环brick.draw()  # 画出遍历的值screen.draw.text('你坚持了'+str(score)+'层', (400,200), fontsize=25,fontname='s', color='red')  # 画出计分器if isLoose:  # 如果游戏失败，输出相关信息screen.draw.text("游戏失败！", (80, HEIGHT/2-100),fontsize=100, fontname='s', color='red')# 4.动起来的同时判断输赢更新动态
def update():  # 定义重复执行函数global isLoose, playerSpeed, brickSpeed, lastAlienY, score  # 设置全局变量isPlayerOnGround = False  # 假设角色没有站在砖块上# 5.更新动态for brick in bricks:  # 临时变量循环在砖块列表里# 如果角色底部坐标减砖块顶部坐标小于 5 和砖左边坐标减角色左边坐标小于宽度的一半和角色右边减砖块右边小于宽度的一半if abs(alien.bottom - brick.top) < 5 \and brick.left - alien.left < alien.width * 2 / 3 \and alien.right - brick.right < alien.width * 2 / 3:  #alien.image = 'alien'  # 设为在砖块上站立的图片isPlayerOnGround = True  # 假设角色站在砖块上alien.bottom = brick.top  # 让角色跟着砖块一直向上移动（砖块顶部赋值给角色底部）if lastAlienY < alien.y:  # 如果角色下降的 y 坐标小于原来的 y 坐标（之前还不在砖上，现在刚落到下一块砖上）score += 1  # 分数+1if keyboard.left:  # 如果按下键盘左键alien.x -= playerspeed  # 角色左边移if keyboard.right:  # 如果按下键盘右键alien.x += playerspeed  # 角色右移lastAlienY = alien.y  # 对所有砖块遍历后，更新lastAlienY的值if not isPlayerOnGround:  # 如果角色不在砖块上alien.image = 'alien_falling'  # 设为在空中的玩家图片alien.y += 5  # 玩家不在任何一块砖上，就下落for birck in bricks:  # 所有砖块缓慢上移birck.y -= 1if bricks[0].top < 10: # 最上面的一个砖块达到画面顶部时del bricks[0]  # 删除最上面的砖块brick = Actor('brick') # 新增一个砖块brick.x = random.randint(100, 500) # 水平位置随机brick.y = HEIGHT # 从最下部出现bricks.append(brick) # 将新砖块添加到列表中# 6.判断输赢if alien.top < 0 or alien.bottom > HEIGHT:  # 角色超出上下范围，游戏失败playerSpeed = 0  # 玩家水平移动速度设为0brickSpeed = 0   # 砖块自动上移速度设为0isLoose = True   # 游戏失败pgzrun.go()

知识点：  1，对列表的操作

2，绝对值函

3，键盘控制角色

---

第九章 贪食蛇

图片资源：http://链接：https://pan.baidu.com/s/1McY2IYqTDu3eO7F_1ExiFA?pwd=8888 提取码：8888 --来自百度网盘超级会员V6的分享

"""贪食蛇"""
# 1. 导入库设置窗口
import pgzrun  # 导入游戏库
import time  # 导入时间库
import random  # 导入随机库TILE_SIZE = 20  # 小蛇方块的大小，20*20
WIDTH = 40*TILE_SIZE  # 设置窗口的宽度 800
HEIGHT = 30*TILE_SIZE  # 设置窗口的高度 600# 2.导入图片定义坐标，分数等
snkaeHead = Actor('snake1')  # 导入蛇头方块图片
snkaeHead.x = WIDTH/2   # 蛇头方块图片的x坐标
snkaeHead.y = HEIGHT/2  # 蛇头方块图片的y坐标cookie = Actor('cookie')  # 导入食物方块图片
cookie.x = random.randint(10, 30)*TILE_SIZE  # 食物方块图片的x坐标
cookie.y = random.randint(10, 30)*TILE_SIZE  # 食物方块图片的y坐标Snake = []  # 存储蛇的列表
Snake.append(snkaeHead)  # 把蛇头加入到列表中direction = 'up'  # 控制小蛇运动初始方向
isLoose = False  # 游戏是否失败
score = 0  # 游戏得分for i in range(4):  # 再为蛇添加4段蛇身snakebody = Actor('snake1')  # 导入蛇身方块图片snakebody.x = Snake[i].x - TILE_SIZE  # 蛇身方块图片的x坐标snakebody.y = Snake[i].y  # 蛇身方块图片的y坐标Snake.append(snakebody)   # 把蛇身加入到列表中# 3.画出蛇
def draw():  # 调用画画函数screen.clear()  # 清除屏幕，便于重新绘制for snkaebody in Snake:  # 循环取出每段蛇snkaebody.draw()  # 画出来cookie.draw()  # 画食物# 画出文本（把得分转为字符串，坐标，字体大小，字体，颜色）screen.draw.text("得分："+str(score), (360, 20), fontsize=25,fontname='s', color='white')if isLoose:  # 如果游戏失败# 就画出文本screen.draw.text("游戏失败！", (180, HEIGHT/2-100),fontsize=100, fontname='s', color='blue')# 4.定义控制方向键
def update():  # 调用重复执行函数global direction  # 全局变量# 控制蛇动的方向if keyboard.left:  # 如果按下键盘左键direction = 'left'  # 小蛇要向左移if keyboard.right:  # 如果按下键盘右键direction = 'right'  # 小蛇要向右移if keyboard.up:  # 如果按下键盘上键direction = 'up'  # 小蛇要向上移if keyboard.down:  # 如果按下键盘下键direction = 'down'  # 小蛇要向下移# 5.让蛇动起来
def moveSnake():  # 自定义动起来函数global direction, isLoose, score  # 全局变量# 根据direction变量设定新蛇头的运动方向，比如小蛇向右移动，就在旧蛇头的右边创建个新蛇头if not isLoose:  # 如果游戏没有失败就newSnakeHead = Actor('snake1')  # 创建个新蛇头if direction == 'right':  # 小蛇向右移动newSnakeHead.x = Snake[0].x + TILE_SIZE  # 新蛇头x坐标在旧蛇头的右边+20的位置newSnakeHead.y = Snake[0].y  # 新蛇头y坐标和旧蛇头一样if direction == 'left':  # 小蛇向左移动newSnakeHead.x = Snake[0].x - TILE_SIZEnewSnakeHead.y = Snake[0].yif direction == 'up':  # 小蛇向上移动newSnakeHead.x = Snake[0].xnewSnakeHead.y = Snake[0].y - TILE_SIZEif direction == 'down':  # 小蛇向下移动newSnakeHead.x = Snake[0].xnewSnakeHead.y = Snake[0].y + TILE_SIZE# 6.判断输赢# 如果蛇头超出边框if newSnakeHead.y < 0 or newSnakeHead.y > HEIGHT \or newSnakeHead.x < 0 or newSnakeHead.x > WIDTH:isLoose = True  # 游戏真的失败# 当蛇头碰到自身时，游戏失败for snakebody in Snake:  # 对所有蛇身循环，判断是否和蛇头坐标一致# 如果蛇头和蛇身一样平and蛇头和蛇身一样高if newSnakeHead.x == snakebody.x and newSnakeHead.y == snakebody.y:isLoose = Truebreak  # 当蛇头碰到食物时（坐标一样），不处理，也就是长度+1if newSnakeHead.x == cookie.x and newSnakeHead.y == cookie.y:        cookie.x = random.randint(5, 35)*TILE_SIZE  # 饼干重新随机位置出现cookie.y = random.randint(5, 25)*TILE_SIZEscore = score + 1  # 得分加1else:  # 否则，删除掉旧蛇尾，也就是蛇的长度保持不变del Snake[len(Snake)-1]Snake.insert(0, newSnakeHead)  # 把新蛇头加到列表的第0个位置clock.schedule_unique(moveSnake, 0.2)  # 调用时间函数让蛇速度降下来（下一次隔0.2秒调用动起来函数）moveSnake()  # 调用蛇动起来的函数pgzrun.go()  # 开始执行游戏

知识点： 1，了解时间库

2，对列表更多的操作

3，定义对游戏的控制键

4，自定义函数的定义和调用

---

第十章 拼图游戏

图片资源：http://链接：https://pan.baidu.com/s/1rYVMfmqzLWGTpJWl5rIAcw?pwd=8888 提取码：8888 --来自百度网盘超级会员V6的分享这个对初学有点复杂了所以先掌握几个知识点：

"""导入时间模块记录程序运行时间"""
import datetime  # 导入模块
start = datetime.datetime.now()  # 记录程序开始运行的时间点（开始）
a = input('按回车键后统计程序运行时间')  #
end = datetime.datetime.now()  # 再次记录程序开始运行的时间点（结束）
time = (end - start).seconds  # 用结束的时间点 - 开始的时间点
print('程序一共运行', time, '秒')  # 就计算出程序运行时间

"""对文件的操作"""
time = 38  # 运行游戏的时间
txtFile = open('rank.txt', 'w')  # 以写入的方式打开'rank.txt'文件
txtFile.write(str(time))  # 把运行游戏的时间以字符串格式写入'rank.txt'文件
txtFile.close()  # 关闭文件

"""利用中间变量交换变量的值""""
i = 0
j = 8
print(i, j)temp = i  # 中间变量
i = j
j = temp  # 顺利交换了两变量的值
print(i, j)

掌握以上三知识点开始编写代码：

"""把图片打乱并画出来"""
# 1.导入库设置窗口
import pgzrun  # 导入游戏库
import random  # 导入随机库TILE_SIZE = 100  # 小拼图块的大小，100*100
WIDTH = 3*TILE_SIZE  # 设置窗口的宽度 300
HEIGHT = 3*TILE_SIZE  # 设置窗口的高度 300# 2.导入图片，存在列表当中
tiles = [Actor('3×3_01'), Actor('3×3_02'), Actor('3×3_03'),Actor('3×3_04'), Actor('3×3_05'),Actor('3×3_06'),Actor('3×3_07'),Actor('3×3_08'),Actor('3×3_09')]grid = [] # 定义列表用来存放最终所有拼图信息
for i in range(3): # 对行循环for j in range(3): # 对列循环tile = tiles[i*3+j]  # 对应拼图方块图片tile.left = j * TILE_SIZE  # 拼图方块图片最左边的x坐标tile.top = i * TILE_SIZE  # 拼图方块图片最顶部的y坐标grid.append(tile) # 将当前拼图加入到列表中# 3.自定义函数实现两个小拼图块位置的交换
def swapPosition(i, j):# i，j为要交换的两个小拼图块的序号# 以下利用tempPos中间变量，实现两个小拼图块位置的交换tempPos = grid[i].posgrid[i].pos = grid[j].posgrid[j].pos = tempPos# 重复随机交换多次小拼图的位置
for k in range(10):i = random.randint(0, 8)  # 第一个小拼图块的序号j = random.randint(0, 8)  # 第二个小拼图块的序号swapPosition(i, j) # 调用函数交换两个小拼图块的位置# 4.画出来
def draw():  # 绘制模块，每帧重复执行for tile in grid:tile.draw()  # 绘制小拼图块pgzrun.go()  # 开始执行游戏

"""实现图片的交换"""
# 1.导入库设置窗口
import pgzrun  # 导入游戏库
import random  # 导入随机库TILE_SIZE = 100  # 小拼图块的大小，100*100
WIDTH = 3*TILE_SIZE  # 设置窗口的宽度 300
HEIGHT = 3*TILE_SIZE  # 设置窗口的高度 300
# 添加交换图片所需变量
clickTime = 0  # 记录鼠标点击了多少次
clickId1 = clickId2 = -1 # 两次点击的小拼图块的序号# 2.导入图片，存在列表当中
tiles = [Actor('3×3_01'), Actor('3×3_02'), Actor('3×3_03'),Actor('3×3_04'), Actor('3×3_05'),Actor('3×3_06'),Actor('3×3_07'),Actor('3×3_08'),Actor('3×3_09')]grid = [] # 列表，用来存放最终所有拼图信息
for i in range(3): # 对行循环for j in range(3): # 对列循环tile = tiles[i*3+j]  # 对应拼图方块图片tile.left = j * TILE_SIZE  # 拼图方块图片最左边的x坐标tile.top = i * TILE_SIZE  # 拼图方块图片最顶部的y坐标grid.append(tile) # 将当前拼图加入到列表中# 3.自定义函数实现两个小拼图块位置的交换
def swapPosition(i, j):# i，j为要交换的两个小拼图块的序号# 以下利用tempPos中间变量，实现两个小拼图块位置的交换tempPos = grid[i].posgrid[i].pos = grid[j].posgrid[j].pos = tempPos# 重复随机交换多次小拼图的位置
for k in range(10):i = random.randint(0, 8)  # 第一个小拼图块的序号j = random.randint(0, 8)  # 第二个小拼图块的序号swapPosition(i, j) # 调用函数交换两个小拼图块的位置# 4.画出来
def draw():  # 绘制模块，每帧重复执行screen.clear()  # 每帧清除屏幕，便于重新绘制for tile in grid:tile.draw()  # 绘制小拼图块# 5.自定义交换图片函数
def on_mouse_down(pos, button): # 当鼠标按键时执行global clickTime, clickId1, clickId2  # 全局变量for k in range(9):  # 对所有grid中的小拼图块遍历if grid[k].collidepoint(pos): # 如果小拼图与鼠标位置碰撞print(k) # 输出拼图块序号break    # 跳出当前循环if clickTime % 2 ==  0: # 点击偶数次clickId1 = k  # 第一个要交换的小拼图块序号clickTime += 1 # 点击次数加1elif clickTime % 2 == 1:  # 点击奇数次clickId2 = k  # 第二个要交换的小拼图块序号clickTime += 1  # 点击次数加1swapPosition(clickId1, clickId2) # 调用交换函数交换两个小拼图块位置pgzrun.go()  # 开始执行游戏

注意：运行游戏之前你必须在同一文件夹下先用记事本建一个文本文件并写上数字

否则程序读不出原来的记录会报错

"""拼图游戏"""
# 1.导入库设置窗口
import pgzrun  # 导入游戏库
import random  # 导入随机库
import datetime  # 导入日期和时间库txtFile = open('rank.txt', 'r')  # 打开最佳时间记录存档文件
line = txtFile.readline()  # 读取一行字符串
oldTime = int(line)  # 将记录的秒数转换为整型存储
txtFile.close()  # 关闭文件
start = datetime.datetime.now()  # 程序运行开始计时
newTime = 0  # 这次游戏花了多长时间TILE_SIZE = 100  # 拼图块的大小，100*100
WIDTH = 3*TILE_SIZE  # 设置窗口的宽度 300
HEIGHT = 3*TILE_SIZE + 60  # 设置窗口的高度 300+60clickTime = 0  # 记录鼠标点击了多少次
clickId1 = clickId2 = -1  # 两次点击的拼图块的序号
allRight = False  # 是否拼图的位置全对了（初始为没有对）# 2.导入图片，存在列表当中
tiles = [Actor('3×3_01'), Actor('3×3_02'), Actor('3×3_03'),Actor('3×3_04'), Actor('3×3_05'), Actor('3×3_06'),Actor('3×3_07'), Actor('3×3_08'), Actor('3×3_09')]grid = []  # 列表，用来存放最终所有拼图信息
for i in range(3):  # 对行循环for j in range(3):  # 对列循环tile = tiles[i*3+j]  # 对应拼图方块图片tile.left = j * TILE_SIZE  # 拼图方块图片最左边的x坐标tile.top = i * TILE_SIZE  # 拼图方块图片最顶部的y坐标grid.append(tile)  # 将当前拼图加入到列表中# 3.自定义函数实现两个拼图块位置的交换
def swapPosition(i, j):  # 该函数实现两个拼图块位置的交换# i，j为要交换的两个小拼图块的序号，利用tempPos中间变量，实现两个拼图块位置的交换tempPos = grid[i].posgrid[i].pos = grid[j].posgrid[j].pos = tempPos
# 重复随机交换多次小拼图的位置
for k in range(10):i = random.randint(0, 8)  # 第一个拼图块的序号j = random.randint(0, 8)  # 第二个拼图块的序号swapPosition(i, j)  # 调用函数交换两个拼图块的位置# 4.画出来
def draw():  # 绘制模块，每帧重复执行screen.clear()  # 每帧清除屏幕，便于重新绘制for tile in grid:  # 遍历图片列表tile.draw()  # 绘制小拼图块# 屏幕上画文本（最佳记录：老记录，坐标，字大小，字体，颜色）screen.draw.text("最佳记录："+str(oldTime)+'秒', (60, 300), fontsize=25,fontname='s', color='red')screen.draw.text("游戏运行："+str(newTime)+'秒', (60, 330), fontsize=25,fontname='s', color='red')if allRight:  # 输出游戏胜利信息screen.draw.text("游戏胜利！", (40, HEIGHT/2-50),fontsize=50, fontname='s', color='blue')else:  # 如果没有成功，可以画几条提示线for i in range(3):  # 画三条横线、三条竖线# 屏幕上画线（（起始点：x坐标，y坐标）（结束点：x坐标，y坐标），颜色）screen.draw.line((0, i*TILE_SIZE), (WIDTH, i*TILE_SIZE), 'white')  # 横线# 屏幕上画线（（起始点：y坐标，x坐标）（结束点：y坐标，x坐标），颜色screen.draw.line((i*TILE_SIZE, 0), (i*TILE_SIZE,3*TILE_SIZE), 'white')  # 竖线if clickId1 != -1:  # 为选中的拼图块画一个红色框# 屏幕上画矩形（矩形（图片左边，图片上边），（距离，距离），颜色）screen.draw.rect(Rect((grid[clickId1].left, grid[clickId1].top), (TILE_SIZE, TILE_SIZE)), 'red')  #画框框# 5.记录游戏运行时间
def update():  # 更新模块，每帧重复操作global newTime  # 全局变量if not allRight:  # 如果拼对了end = datetime.datetime.now()  # 变量接收 = 记录结束时间点newTime = (end - start).seconds  # 变量接收 = 计算出程序运行了多少秒# 6.记录点击的图片
def on_mouse_down(pos, button):  # 当鼠标按键时执行global clickTime, clickId1, clickId2, allRight  # 全局变量for k in range(9):  # 对所有grid中的拼图块遍历if grid[k].collidepoint(pos):  # 如果拼图与鼠标位置碰撞break    # 跳出当前循环（就记录了图片的下标）if clickTime % 2 == 0:  # 点击偶数次clickId1 = k  # 第一个要交换的拼图块下标clickTime += 1  # 点击次数加1elif clickTime % 2 == 1:  # 点击奇数次clickId2 = k  # 第二个要交换的拼图块下标clickTime += 1  # 点击次数加1swapPosition(clickId1, clickId2)  # 调用函数交换两个拼图块位置# 7.判断输赢allRight = True  # 假设全拼对了for i in range(3):for j in range(3):tile = grid[i*3+j]# 遍历如果只要有一个拼图的位置不对，就没有全拼对if tile.left != j * TILE_SIZE or tile.top != i * TILE_SIZE:allRight = False  # 拼错了break  # 如果上面的if语句都不执行，则表示全拼对了# 8.更新记录if allRight:  # 如果对了if newTime < oldTime:  # 新记录小于旧记录txtFile = open('rank.txt', 'w')  # 写入方式打开文件txtFile.write(str(newTime))  # 写入新记录txtFile.close()  #关闭文件pgzrun.go()  # 开始执行游戏

知识点： 1，时间模块

2，文件的操作

3，自定义交换函数

4，画线，画框

5，collidepoin（）函数

---

第十一章 消灭星星

这个对新手也有点复杂还是分三步吧：

图片资源：

http://链接：https://pan.baidu.com/s/1FMqJjMwK75C9T0r5STBK2Q?pwd=8888 提取码：8888 --来自百度网盘超级会员V6的分享

"""导入图片并画出来"""
# 1.导入库设置窗口
import pgzrun  # 导入游戏库
import random  # 导入随机库TILE_SIZE = 50  # 小方块的大小，50*50
WIDTH = 10*TILE_SIZE  # 设置窗口的宽度 500
HEIGHT = 10*TILE_SIZE  # 设置窗口的高度 500# 2.用二维数组中的值代替图片名中的数字实现打乱图片
stars = []  # 二维数组，开始为空列表，用于储存小方块颜色编号
for i in range(10):  # 对行遍历row = []  # 存储一行的数据，开始为空列表for j in range(10):  # 对列遍历x = random.randint(1, 6) # 取1-6之间的随机数row.append(x)  # 把数据添加到行列表row中stars.append(row)  # 再行列表row添加到二维数组stars中Tiles = []  # 二维数组，开始为空列表，存放所有小方块图片信息
for i in range(10):for j in range(10):tile = Actor('star'+str(stars[i][j]))  # 对应小方块图片初始化tile.left = j * TILE_SIZE  # 小方块图片最左边的x坐标tile.top = i * TILE_SIZE  # 小方块图片最顶部的y坐标Tiles.append(tile)  # 将当前小方块加入到列表中# 3.画出来
def draw():   # 绘制模块，每帧重复执行screen.clear()  # 每帧清除屏幕，便于重新绘制for tile in Tiles:tile.draw()  # 绘制所有小方块# 以下绘制出所有小方块的编号（方便理解）for i in range(10):for j in range(10):screen.draw.text(str(stars[i][j]),(j*TILE_SIZE, i*TILE_SIZE), fontsize=35, color='white')pgzrun.go()  # 开始执行游戏

"""让图片消失"""
# 1.导入库设置窗口
import pgzrun  # 导入游戏库
import random  # 导入随机库TILE_SIZE = 50  # 小方块的大小，50*50
WIDTH = 10*TILE_SIZE  # 设置窗口的宽度 500
HEIGHT = 10*TILE_SIZE  # 设置窗口的高度 500# 2.用二维数组中的值代替图片名中的数字实现打乱图片
stars = []  # 二维数组，开始为空列表，用于储存小方块颜色编号
for i in range(10):  # 对行遍历row = []  # 存储一行的数据，开始为空列表for j in range(10):  # 对列遍历x = random.randint(1, 6)  # 取1-6之间的随机数row.append(x)  # 把数据添加到行列表row中stars.append(row)  # 再把行列表row添加到二维数组stars中Tiles = []  # 二维数组，开始为空列表，存放所有小方块图片信息
def updateTiles():  # 根据stars更新Tiles二维数组for i in range(10):for j in range(10):tile = Actor('star'+str(stars[i][j]))  # 对应小方块图片初始化tile.left = j * TILE_SIZE  # 小方块图片最左边的x坐标tile.top = i * TILE_SIZE  # 小方块图片最顶部的y坐标Tiles.append(tile)  # 将当前小方块加入到列表中
updateTiles()  # 根据stars更新Tiles二维数组# 3.画出来
def draw():   # 绘制模块，每帧重复执行screen.clear()  # 每帧清除屏幕，便于重新绘制for tile in Tiles:tile.draw()  # 绘制所有小方块# 以下绘制出所有小方块的编号for i in range(10):for j in range(10):screen.draw.text(str(stars[i][j]),(j*TILE_SIZE, i*TILE_SIZE), fontsize=35, color='white')# 4.点击鼠标让图片消失（就是变成黑色）
def on_mouse_down(pos, button):  # 当鼠标按键时执行（位置，点击）iClicked = int(pos[1]/TILE_SIZE)  # 点击方块在二维数组中的行序号（相当于鼠标的x轴）jClicked = int(pos[0]/TILE_SIZE)  # 点击方块在二维数组中的列序号（相当于鼠标的y轴）stars[iClicked][jClicked] = 0  # 鼠标点击的点，标记为0，对应star0.jpg正好是黑色图片updateTiles() # 根据stars更新Tiles二维数组pgzrun.go()  # 开始执行游戏

"""消灭星星"""
# 1.导入库设置窗口
import pgzrun  # 导入游戏库
import random  # 导入随机库
import copy  # 导入复制库TILE_SIZE = 50  # 小方块的大小，50*50
WIDTH = 10*TILE_SIZE  # 设置窗口的宽度 500
HEIGHT = 11*TILE_SIZE  # 设置窗口的高度 500
score = 0  # 得分# 2.用二维数组中的值代替图片名中的数字实现打乱图片
stars = []  # 二维数组，用于储存小方块编号代替图片名中的数字
for i in range(10):  # 对行遍历row = []  # 存储一行的数据，开始为空列表for j in range(10):  # 对列遍历x = random.randint(1, 5)  # 取1-5之间的随机数row.append(x)  # 把数据添加到行列表row中stars.append(row)  # 再把行列表row添加到二维数组stars中
Tiles = []  # 二维数组，存放所有小方块图片def updateTiles():  # 图片的位置会更新所以要封装成函数for i in range(10):for j in range(10):tile = Actor('star'+str(stars[i][j]))  # 对应小方块图片初始化tile.left = j * TILE_SIZE  # 小方块图片最左边的x坐标tile.top = i * TILE_SIZE  # 小方块图片最顶部的y坐标Tiles.append(tile)  # 将当前小方块加入到列表中
updateTiles()  # 根据stars更新Tiles二维数组# 3.画出来
def draw():   # 绘制函数screen.clear()  # 每帧清除屏幕，便于重新绘制for tile in Tiles:  # 遍历图片列表tile.draw()  # 绘制所有小方块# 画出游戏动态screen.draw.text("消除方块："+str(score), (180, 510), fontsize=25,fontname='s', color='red')# 4.点击鼠标让图片消失（就是变成黑色）
def on_mouse_down(pos, button):  # 当鼠标按键时执行（位置，点击）# 寻找鼠标所点击的颜色一样的方块global score  # 全局变量iClicked = int(pos[1]/TILE_SIZE)  # 点击方块在二维数组中的行序号（相当于鼠标的x轴）jClicked = int(pos[0]/TILE_SIZE)  # 点击方块在二维数组中的列序号（相当于鼠标的y轴）connectedSet = {(iClicked, jClicked)}  # 创建集合，以元组类型存储选方块及其连通的点序号for k in range(20):  # 重复找多次，就可以把所有连通区域都找到了tempSet = copy.deepcopy(connectedSet)  # 复制一份临时集合储存图片周围颜色一样的图片for each in tempSet:  # 遍历集合取出来的就是元组i = each[0]  # 元组的第0个下标就是小方块对应的行序号j = each[1]  # 元组的第1个下标就是小方块对应的列序号#  找到上下左右四个方块，把颜色一致的添加到集合中，注意防止超过边界colorId = stars[i][j]  # 定义鼠标所点击的颜色if i > 0 and stars[i-1][j] == colorId:  # 如果图片上面的颜色等于鼠标所点击的颜色connectedSet.add((i-1, j))  # 就坐标添加到集合if i < 9 and stars[i+1][j] == colorId:  # 如果图片下面的颜色等于鼠标所点击的颜色connectedSet.add((i+1, j))  # 就坐标添加到集合if j > 0 and stars[i][j-1] == colorId:  # 如果图片左面的颜色等于鼠标所点击的颜色connectedSet.add((i, j-1))  # 就坐标添加到集合if j < 9 and stars[i][j+1] == colorId:  # 如果图片右面的颜色等于鼠标所点击的颜色connectedSet.add((i, j+1))  # 就坐标添加到集合tempSet.clear()  # 临时集合清空# 把颜色一样的方块消除（就是把文件名序号改为0）if len(connectedSet) >= 2:  # 连通方块个数最少两个一样的才消除for each in connectedSet:  # 遍历集合中的所有方块if stars[each[0]][each[1]] != 0:  # 如果二维数组中该坐标的值不是0stars[each[0]][each[1]] = 0  # 就标记为0，对应黑色小方块图片score = score + 1  # 得分等于消去的方块数目# 5.让方块下落，从下往上遍历，下面一个是0的话，上面的小色块就往下落。最顶上的空出来，变成黑色for j in range(10):# （1）取 出点击图片的那一列templist = []  # 存储第j列的所有元素的列表for i in range(10):templist.append(stars[i][j])#（2）查 看这一列有几个0并删除count = 0  # 记录列表中值为0的元素个数while 0 in templist:  # 0在列表里面循环templist.remove(0)  # 发现一个删除一个count += 1  # 计数器+1# （3）改 变第j列的所有元素的排列顺序for i in range(count):  # 有几个0就循环几次templist.insert(0, 0)  # 把0移动到列表起始位置# （4）还 第j列的所有元素顺序重新排列for i in range(10):  # 循环10次stars[i][j] = templist[i]  # 把重新排列的顺序再赋值给原始的二维数组# 6.让方块左移，如果某一列都消除了，则右边列的方块向左移#（1）取 出点击图片的那一列zeroColId = -1  # 记录j列的变量for j in range(10):templist = []  # 存储第j列的所有元素的列表for i in range(10):templist.append(stars[i][j])#（2）查 看这一列加起来是否等于0if sum(templist) == 0:  # 这一列加起来为0了zeroColId = j  # 记录这是第几列break  # 停止# （3）改if zeroColId != -1:  # 如果这一列为0了for j in range(zeroColId, 9, 1):  # 从这一列开始间隔为1的遍历for i in range(10):  # 循环10次stars[i][j] = stars[i][j+1]  # 把右边的一列赋值给左边的一列for i in range(10):  # 循环10次stars[i][9] = 0  # 最右边的一列都改为0updateTiles()  # 根据stars更新Tiles二维数组pgzrun.go()  # 开始执行游戏

知识点： 1，复制库

2，二维数组的操作

3，元祖的操作

4，on_mouse_down() 函数的作用

5，sum（）函数的作用

---

第十二章 坚持100秒

图片资源：

http://链接：https://pan.baidu.com/s/1j_a3bzG7XIU0JT6QDIdUHg?pwd=8888 提取码：8888 --来自百度网盘超级会员V6的分享

"""坚持100秒"""
# 1.导入库设置窗口
import pgzrun  # 导入游戏库
import random  # 导入随机库
WIDTH = 600   # 设置窗口的宽度
HEIGHT = 800  # 设置窗口的高度# 2.导入图片
time = 0  # 游戏坚持的时间
hero = Actor('hero')  # 导入玩家飞机图片
live = 3 # 飞机一共3条命livePics = []  # 在左上角显示生命
for i in range(live):  # 循环3次livePic = Actor('hero_small')  # 导入生命飞机livePic.x = 40 + i*60  # 定义x坐标livePic.y = 40  # 定义y坐标livePics.append(livePic)  # 添加到列表# 3.定义类
class Ball: # 定义小球类def __init__(self,x,y,vx,vy,r,color):  # 类属性（x坐标，y坐标，x方向速度，y方向速度，半径，颜色）self.x = x  # x坐标self.y = y  # y坐标self.vx = vx  # x方向速度self.vy = vy  # y方向速度self.r = r  # 半径self.color = color  # 颜色def draw(self): # 类方法画出来# 屏幕上画圆（（x坐标,y坐标），半径r，颜色）screen.draw.filled_circle((self.x, self.y), self.r, self.color)def update(self): # 类方法更新小球的位置、速度self.x += self.vx   # 利用x方向速度更新x坐标self.y += self.vy   # 利用y方向速度更新y坐标# 当小球碰到左右边界时，x方向速度反转if self.x > WIDTH-self.r or self.x < self.r:self.vx = -self.vx# 当小球碰到上下边界时，y方向速度反转if self.y > HEIGHT-self.r or self.y < self.r:self.vy = -self.vyballs = []  # 存储所有小球的信息，初始为空# 4.画出来
def draw():   # 绘制模块，每帧重复执行screen.fill('white')  # 白色背景hero.draw()  # 绘制玩家飞机for i in range(live): # 遍历3次livePics[i].draw()  # 画出生命飞机for ball in balls:  # 遍历小球列表ball.draw()   # 绘制每个小球# 画出动态信息    screen.draw.text(str(time)+'秒', (270, 10), fontsize=50,fontname='s', color='black')if live<=0:  # 如果什么小于0clock.unschedule(count)  # 结束函数的计划执行任务# 画出动态信息screen.draw.text("游戏结束！", (80, 300),fontsize=100, fontname='s', color='red')
# 5.动起来
def update():  # 更新模块，每帧重复操作global live  # 全局变量if live <=0: # 没有生命了，函数返回，不执行returnfor ball in balls:  # 变量球列表ball.update()  # 更新小球的位置、速度# 如果（飞机x坐标-球x坐标）小于25 同时（飞机y坐标-球y坐标）小于30if abs(hero.x - ball.x) < 25 and abs(hero.y - ball.y) < 30:  # 玩家飞机和小球碰撞live -= 1 # 生命减1sounds.explode.play() # 爆炸一条命的音效ball.y = 10 # 当前小球立刻远离飞机，防止重复碰撞if live <= 0: # 生命减完了hero.image = 'blowup'  # 更换游戏玩家的图片为爆炸图片sounds.boom.play()  # 播放玩家飞机爆炸音效# 6.鼠标控制飞机
def on_mouse_move(pos, rel, buttons):  # 当鼠标移动时执行if live > 0:  # 生命数大于0才执行hero.x = pos[0]  # 玩家飞机的x坐标设为鼠标的x坐标hero.y = pos[1]  # 玩家飞机的y坐标设为鼠标的y坐标# 7.把造球的步骤定义成函数
def count(): # 定义造球函数global time  # 全局变量time += 1 # 计时，每秒钟时间+1# 每隔2秒，加一个小球，并且小球数目不超过100if time % 2 == 0 and len(balls) <= 100:x = WIDTH//2   # 设为小球的x坐标y = random.randint(5, HEIGHT//10)   # 设为小球的y坐标vx = random.choice([-3, -2, -1, 1, 2, 3])  # 小球x方向的速度vy = random.randint(1, 3)  # 小球y方向的速度r = 3      # 小球的半径color = 'black'  # 小球的颜色ball = Ball(x, y, vx, vy, r, color)  # 创建ball对象balls.append(ball)  # 把该小球的信息添加到球列表中sounds.throw.play()  # 放音乐clock.schedule_unique(count, 0.5)  # 隔0.5秒调用count()函数（每隔一秒造个球count()  # 调用函数运行pgzrun.go()   # 开始执行游戏

知识点： 1，了解什么是类

2，了解类属性，和方法，怎么调用

---

第十三章 趣味图像生成

图片资源：http://链接：https://pan.baidu.com/s/1czszSACVKLJlatPDK8YOAw?pwd=8888 提取码：8888 --来自百度网盘超级会员V6的分享

"""打开图像"""
# 1.导入库
import pgzrun  # 导入游戏库
from PIL import Image # 导入图像处理库# 2.打开图像文件
im = Image.open('images\image1.jpg')  # 变量接收 = 打开（文件夹，文件名）
w, h = im.size  # 获得图像文件尺寸# 3.把图像尺寸赋值给窗口
WIDTH = w  # 设置窗口的宽度
HEIGHT = h  # 设置窗口的高度
pic = Actor('image1')  # 导入图片# 4.画出来
def draw():  # 调用画画函数pic.draw()  # 绘制图片pgzrun.go()  # 开始执行游戏

"""裁剪图像"""
# 1.导入库
from PIL import Image  # 导入图像处理库# 2. 打开一个图像文件，注意是文件路径
im = Image.open('images\image1.jpg')
w, h = im.size  # 获得图像文件尺寸
step = 250  # 裁剪小图片的宽、高均为250# 3.裁剪图像
for i in range(3):  # 对行循环for j in range(3):  # 对列循环# box = （左上角x坐标，左上角y坐标，右下角x坐标，右下角y坐标）box = (i*step, j*step, (i+1)*step, (j+1)*step)  # 利用box对图像进行剪裁index = j*3+i+1 # 裁剪出的小图像编号pic = im.crop(box) # 裁剪图像filename = "images\image_"+str(index)+".jpg" # 待保存的图像文件名pic.save(filename) # 保存裁剪好的小图像

"""图像的复制与粘贴"""
# 1.导入库
from PIL import Image  # 导入图像处理库# 2.新建图像
newImage = Image.new('RGB', (400, 400), 'red')# 3.打开Python标志图片文件，大小为80*80
py = Image.open("images\python.jpg") # 4.生成用Python图标平铺的图片
for i in range(5):for j in range(5):newImage.paste(py, (i*80, j*80))# 5.保存新建图片
newImage.save('images\\newImage.jpg')

"""国际象棋棋盘"""
# 1.导入库
from PIL import Image  # 导入图像处理库# 2 .新建图像，宽高都为800，初始化为白色
im = Image.new('RGB', (800, 800), (255, 255, 255))# 3.导入图片像素
px = im.load()  # 导入图片像素# 4.绘制棋盘
for i in range(800):for j in range(800):if (i//80 + j//80) % 2 == 1:  # 自己看算术运算符px[i, j] = 0, 0, 0  # 将像素设为黑色# 5.保存图像
im.save('images\\国际象棋棋盘.jpg')

"""随机互动的风格图片生成"""
# 1.导入库
from PIL import Image  # 导入图像处理库
import pgzrun  # 导入游戏库
import random  # 导入随机库# 2.打开图像设置窗口
im = Image.open("images\\image2.jpg")  # 打开图像文件
w, h = im.size  # 获得图像文件尺寸
WIDTH = w  # 设置窗口的宽度
HEIGHT = h  # 设置窗口的高度# 3.导入图片定义颜色，坐标等参数
px = im.load()  # 导入图片像素
XY = [] # 列表中存储点坐标
RGB = [] # 列表中存储对应的像素颜色值
key = 1 # 定义按了哪个数字键，缺省为1
r = 3 # 定义了绘制小基本元素的大小，受鼠标左右移动控制# 4. 调用重复执行函数
def update():  global key  # 全局变量# 按下键盘数字键后，对应key相应的值if keyboard.k_1:key = 1elif keyboard.k_2:  key = 2elif keyboard.k_3:  key = 3elif keyboard.k_4:  key = 4elif keyboard.k_5:  key = 5elif keyboard.k_6:  key = 6elif keyboard.escape:  key = -1   XY.clear()  # 清空坐标列表RGB.clear()  # 清空颜色列表for i in range(100):x = random.randint(0, w-1)  # 取随机坐标y = random.randint(0, h-1)r, g, b = px[x, y]  # 取对应图片像素的颜色XY.append((x, y))   # 将位置信息添加到列表中RGB.append((r, g, b))  # 将颜色信息添加到列表中# 5.画出来
def draw():  # 调用画画if key == -1:  #当鼠标右键按下时screen.clear()  # 清除屏幕for i in range(100):x = XY[i][0] # 当前点坐标y = XY[i][1]box = Rect((x, y), (r, r))  # 画正方形区域的范围if key == 1:  # 绘制填充圆screen.draw.filled_circle(XY[i], r, RGB[i])if key == 2:  # 绘制空心圆screen.draw.circle(XY[i], r, RGB[i])if key == 3:  # 绘制线条screen.draw.line((x, y), (x+r, y+r), RGB[i])if key == 4:  # 绘制两条线条组成的叉号screen.draw.line((x-r, y-r), (x+r, y+r), RGB[i])screen.draw.line((x-r, y+r), (x+r, y-r), RGB[i])if key == 5:  # 绘制空心正方形screen.draw.rect(box, RGB[i])if key == 6:  # 绘制实心正方形screen.draw.filled_rect(box, RGB[i])def on_mouse_move(pos, rel, buttons):  # 当鼠标移动时global rx = pos[0]   # 鼠标的x坐标r = x*10//WIDTH + 1  # 鼠标在最左边r=1，最右边r=10if mouse.RIGHT in buttons:   # 当鼠标右键按下时，准备清屏key == -1pgzrun.go()  # 开始执行游戏

知识点：本人觉得图像处理库没有ps功能强大还不如用ps简单些

python游戏编程相关推荐

1. python游戏编程入门书籍推荐-游戏编程入门书籍推荐：想要游戏编程尽快入门这些书不要错过...

   游戏编程一直都是编程之中的一大热点,这也是由于游戏本身的火热造成的结果,所以每年都有很多人在关注着游戏编程.介于此小编今天就来将一些好的游戏编程入门书籍推荐给大家,希望对想要了解和学习游戏编程的朋友能 ...

2. python游戏编程书籍-《Python游戏编程快速上手》一1.3 如何使用本书

   本节书摘来异步社区<Python游戏编程快速上手>一书中的第1章,第1.3节,作者: [美]Al Sweigart(斯维加特) 译者: 李强 责编: 陈冀康,更多章节内容可以访问云栖社区& ...

3. python游戏编程入门-python游戏编程入门

   <Python游戏编程入门> 这些文章负责整理在这本书中的知识点.注意事项和课后习题的尝试实现. 并且对每一个章节给出的最终实例进行分析和注释. 初识pygame:pie游戏 pygame ...

4. python游戏编程入门 免费-python游戏编程入门 python游戏编程入门课

   python游戏编程入门 python游戏编程入门课 什么是python游戏编程入门?首先我们需要认识什么是Python Python既是一个软件工具包,也是一种语言.Python软件包包含了一个名为 ...

5. 《Python游戏编程快速上手》第十四章----凯撒密码

   <Python游戏编程快速上手>的第十二章主要讲了笛卡尔坐标系的基本数学知识,我就不重现了:然后第十三章主要是一个笛卡尔坐标系的小应用,这个小应用也是非常简单的,所以我就不重现了. 今天主 ...

6. 《Python游戏编程快速上手》第十一章猜数字，推理游戏Bagels

   <Python游戏编程快速上手>的第十一章的小游戏也非常简单,话不多少,简单介绍下: 系统随机生成几个数字,由玩家来猜,若有一个数字猜对但位置不对,输出一个Pico:若一个数字即猜对了位置 ...

7. 《Python游戏编程快速上手》第十章TicTacToe

   <Python游戏编程快速上手>第九章的内容是对上一个游戏进行了些小拓展,所以我就不写博客了,非常简单大家自己去看吧. 所以我们今天看下第十章,第十章主要是讲了一个叫TicTacToe的游 ...

8. 《Python游戏编程快速上手》第八章--Hangman

   可能有的读者会觉得很奇怪,上一篇还是第五章,这一篇就是第八章了,中间的第六七章难道被博主吃掉了吗? 我想说明一下的是,在学习<Python游戏编程快速上手>一书的过程中,我越发觉得这本书更 ...

9. 《Python游戏编程快速上手》第五章--龙穴探险

   接着昨天的工作,今天来看<Python游戏编程快速上手>的第五章----龙穴探险. 这一章我将不会给出书中的代码,我会直接给我我修改后的代码.我增加了一些游戏的规则,如下: 管理员(编程人 ...

10. 《Python游戏编程快速上手》第四章-讲笑话

    接着昨天的文章,今天实现<Python游戏编程快速上手>的第四章–讲笑话.这个小游戏的实现非常之简单.所以我就不说什么了,直接上代码 print("What do you get ...

最新文章

1. java aio_java中的AIO
2. 当你 ping 的时候，你知道背后发生了什么吗？
3. IntelliJ IDEA导入JDK出现The selected directory is not a valid home for JDK问题的解决方法
4. Android学习笔记（十一）：Activity-ListView
5. 【Android 安全】DEX 加密 ( 代理 Application 开发 | 加载 dex 文件 | 反射获取系统的 Element[] dexElements )
6. 05 Diagnostics 诊断
7. Python实现的导弹跟踪算法，燃！
8. maven打包的各种方式和如何在使用maven-assembly-plugin打包时去掉assembly id
9. windows下搭建Apache+Mysql+PHP开发环境
10. Linux基础(6)--文件IO操作
11. 等压线上怎么画风向_如何利用等压线图判定天气
12. Hadoop 配置文件存放位置
13. 【新品重磅发布】FOHEART·HF1面部表情捕捉头盔
14. m725扫描仪无法找到计算机,惠普m725扫描设置指定的网络文件夹路径不存在？
15. 这黑科技从 B站 火到 GitHub
16. 你肯定没见过，科幻作品中的邪恶圣诞老人
17. 最近整理的一些常见的面试题，面试大全，黑马程序员面试宝典题库---框架--篇
18. 关于 input在 chrome 、IE浏览器中遇到的兼容性问题处理
19. 漫画中国式项目管理重点总结
20. 模式识别技术漫谈(2)

热门文章

1. 如何把标签输出为PDF文件
2. 数据库毕业设计选题系统课程设计
3. 阿里云ECS学习资源
4. 常规计算机 符号键是,有谁知道电脑键盘上的标示符号都代表什么意思
5. Outlook 点击邮箱签名没有反应卡死
6. GMA Round 1 YGGDRASIL
7. MC皮肤站和外置登陆教程
8. Java桌面应用程序设计新贵：SWT 简介
9. JavaSE-day01
10. 起底野蛮成长的腾讯共享wifi赚钱小程序，到底是机遇还是陷阱？