python游戏编程

思远学堂

已于 2023-03-24 18:13:43 修改

阅读量1.9k

点赞数 5

文章标签： python 青少年编程

于 2023-03-21 13:42:32 首次发布

本文链接：https://blog.csdn.net/m0_48863337/article/details/129681169

版权

前言：本人接触的第一本编程书，记录下自学历程，希望有共同爱好的朋友一起探讨，共同进步，我会在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_x
    ball[1] = ball[1] + ball[3]  # y 坐标 = x + speed_y
    if 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_x
        ball[1] = ball[1] + ball[3]  # y 坐标 = y + speed_y
        if 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_x
        ball[1] = ball[1] + ball[3]  # y 坐标 = y + speed_y
        if 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 轴坐标小于 0
        bar_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  # 得分加 1
        if (score % 5 == 0): # 如果得分增加了5分，就让游戏速度增加
            speed = speed + 1  # 速度加 1

    elif bird.colliderect(bar_up) or bird.colliderect(bar_down)\
            or bird.y < 0 or bird.y > HEIGHT:  # 如果小鸟碰到上树或下树或 y 轴小于 0 或 y轴大于高度
        print('游戏失败')
        score = 0
        speed = 1
        bird.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 newNeedle
    newNeedle.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，后面游戏结束后改成0

def 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:  # 如果游戏速度等于 0
        screen.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 坐标等于 400
            needle.angle += rotatespeed  # 针的角度逆时针加 1

def on_mouse_down():  # 当按下鼠标
    global rotatespeed,score  # 定义全局变量
    if rotatespeed >0: # 如果速度大于 0
        music.play_once('弹簧')  # 播放音效
    # newNeedle.x = 400
    newNeedle = 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  # 速度等于 0
            music.play_once('溜走')
    if rotatespeed > 0:  # 如果针还在旋转
        score = score + 1  # 得分加1
    needles.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 - 70

pgzrun.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, isLoose
    if 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 # 得分加1
        bullet.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 - 70

pgzrun.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, isLoose
    if 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 # 得分加1
        bullet.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 - 70

pgzrun.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  # 分数+1
            if 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 -= 1

    if 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  # 玩家水平移动速度设为0
        brickSpeed = 0   # 砖块自动上移速度设为0
        isLoose = 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_SIZE
            newSnakeHead.y = Snake[0].y
        if direction == 'up':  # 小蛇向上移动
            newSnakeHead.x = Snake[0].x
            newSnakeHead.y = Snake[0].y - TILE_SIZE
        if direction == 'down':  # 小蛇向下移动
            newSnakeHead.x = Snake[0].x
            newSnakeHead.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 = True
                break  

        # 当蛇头碰到食物时（坐标一样），不处理，也就是长度+1
        if newSnakeHead.x == cookie.x and newSnakeHead.y == cookie.y:        
            cookie.x = random.randint(5, 35)*TILE_SIZE  # 饼干重新随机位置出现
            cookie.y = random.randint(5, 25)*TILE_SIZE
            score = score + 1  # 得分加1
        else:  # 否则，删除掉旧蛇尾，也就是蛇的长度保持不变
            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].pos
    grid[i].pos = grid[j].pos
    grid[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].pos
    grid[i].pos = grid[j].pos
    grid[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 # 点击次数加1
    elif clickTime % 2 == 1:  # 点击奇数次
        clickId2 = k  # 第二个要交换的小拼图块序号
        clickTime += 1  # 点击次数加1
        swapPosition(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+60

clickTime = 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].pos
    grid[i].pos = grid[j].pos
    grid[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  # 点击次数加1
    elif clickTime % 2 == 1:  # 点击奇数次
        clickId2 = k  # 第二个要交换的拼图块下标
        clickTime += 1  # 点击次数加1
        swapPosition(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:  # 如果二维数组中该坐标的值不是0
                stars[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）查 看这一列加起来是否等于0
        if 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  # 最右边的一列都改为0

    updateTiles()  # 根据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.vy

balls = []  # 存储所有小球的信息，初始为空

# 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:  # 如果什么小于0
        clock.unschedule(count)  # 结束函数的计划执行任务
        # 画出动态信息
        screen.draw.text("游戏结束！", (80, 300),
                         fontsize=100, fontname='s', color='red')
# 5.动起来
def update():  # 更新模块，每帧重复操作
    global live  # 全局变量
    if live <=0: # 没有生命了，函数返回，不执行
        return

    for ball in balls:  # 变量球列表
        ball.update()  # 更新小球的位置、速度
        # 如果（飞机x坐标-球x坐标）小于25 同时（飞机y坐标-球y坐标）小于30
        if abs(hero.x - ball.x) < 25 and abs(hero.y - ball.y) < 30:  # 玩家飞机和小球碰撞
            live -= 1 # 生命减1
            sounds.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秒，加一个小球，并且小球数目不超过100
    if 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 = 1
    elif keyboard.k_2:  
        key = 2
    elif keyboard.k_3:  
        key = 3
    elif keyboard.k_4:  
        key = 4
    elif keyboard.k_5:  
        key = 5
    elif keyboard.k_6:  
        key = 6
    elif 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 r
    x = pos[0]   # 鼠标的x坐标
    r = x*10//WIDTH + 1  # 鼠标在最左边r=1，最右边r=10
    if mouse.RIGHT in buttons:   # 当鼠标右键按下时，准备清屏
        key == -1

pgzrun.go()  # 开始执行游戏

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

思远学堂

关注

5
点赞
踩
23

收藏

觉得还不错? 一键收藏
0
评论
python游戏编程

在python官网下载最新版本的解释器，然后下载一个编辑器，（海龟编辑器不错的。注意：图片文件夹名一定要为images，必须和代码文件在同一文件夹里面。4，了解pqzrun里的函数作用。5，了解游戏窗口的设置和坐标。3，函数的定义与调用。2，鼠标控制小鸟移动。知识点： 1，什么是库？知识点： 1，掌握for循环和嵌套的使用。知识点： 1，认识全局变量global。知识点： 1，了解列表和列表的取值。知识点： 1，掌握设置背景图。
复制链接

扫一扫