原标题：用 Python 做一个 Windows 扫雷游戏
本文代码基于 python3.6 和 pygame1.9.4。
Windows XP 上的扫雷是无数80/90后的集体回忆，今天我们就用 Python 来制作一个高仿版的 扫雷游戏。
原谅我手残，扫雷基本就没赢过，测试的时候我是偷偷的把雷的数量从99改到50才赢了。。。
下面将一下我的实现逻辑。
首先，如何表示雷和非雷，一开始想的是，建立一个二维数组表示整个区域，0表示非地雷，1表示地雷。后来一想不对，还有标记为地雷，标记为问号，还有表示周边雷数的数字，好多状态，干脆就做个类吧：
classBlockStatus(Enum):
normal = 1# 未点击
opened = 2# 已点击
mine = 3# 地雷
flag = 4# 标记为地雷
ask = 5# 标记为问号
bomb = 6# 踩中地雷
hint = 7# 被双击的周围
double = 8# 正被鼠标左右键双击
classMine:
def__init__(self, x, y, value= 0):
self._x = x
self._y = y
self._value = 0
self._around_mine_count = -1
self._status = BlockStatus.normal
self.set_value(value)
def__repr__(self):
returnstr(self._value)
# return f'({self._x},{self._y})={self._value}, status={self.status}'
defget_x(self):
returnself._x
defset_x(self, x):
self._x = x
x = property(fget=get_x, fset=set_x)
defget_y(self):
returnself._y
defset_y(self, y):
self._y = y
y = property(fget=get_y, fset=set_y)
defget_value(self):
returnself._value
defset_value(self, value):
ifvalue:
self._value = 1
else:
self._value = 0
value = property(fget=get_value, fset=set_value, doc= '0:非地雷 1:雷')
defget_around_mine_count(self):
returnself._around_mine_count
defset_around_mine_count(self, around_mine_count):
self._around_mine_count = around_mine_count
around_mine_count = property(fget=get_around_mine_count, fset=set_around_mine_count, doc= '四周地雷数量')
defget_status(self):
returnself._status
defset_status(self, value):
self._status = value
status = property(fget=get_status, fset=set_status, doc= 'BlockStatus')
布雷就很简单了，随机取99个数，从上往下顺序排就是了：
classMineBlock:
def__init__(self):
self._block = [[Mine(i, j) fori inrange(BLOCK_WIDTH)] forj inrange(BLOCK_HEIGHT)]
# 埋雷
fori inrandom.sample(range(BLOCK_WIDTH * BLOCK_HEIGHT), MINE_COUNT):
self._block[i // BLOCK_WIDTH][i % BLOCK_WIDTH].value = 1
我们点击一个格子的时候，只要根据点击的坐标，找到对应的 Mine，看它的值是多少，就知道有没有踩中雷了。
如果没踩中雷的话，要计算周边8个位置中有几个雷，以便显示对应的数字。
如果周边有雷，那么显示数字，这个简单，可是如果周边没有雷，那就要显示一片区域，直到有雷出现，如下图，我只点了当中一下，就出现了那么大一片区域
这个计算其实也容易，只要用递归就可以了，如果计算出周围的雷数为0，则 递归计算周边8个位置的四周雷数，直到雷数不为0。
classMineBlock:
defopen_mine(self, x, y):
# 踩到雷了
ifself._block[y][x].value:
self._block[y][x].status = BlockStatus.bomb
returnFalse
# 先把状态改为 opened
self._block[y][x].status = BlockStatus.opened
around = _get_around(x, y)
_sum = 0
fori, j inaround:
ifself._block[j][i].value:
_sum += 1
self._block[y][x].around_mine_count = _sum
# 如果周围没有雷，那么将周围8个未中未点开的递归算一遍
# 这就能实现一点出现一大片打开的效果了
if_sum == 0:
fori, j inaround:
ifself._block[j][i].around_mine_count == -1:
self.open_mine(i, j)
returnTrue
def_get_around(x, y):
"""返回(x, y)周围的点的坐标"""
# 这里注意，range 末尾是开区间，所以要加 1
return[(i, j) fori inrange(max( 0, x - 1), min(BLOCK_WIDTH - 1, x + 1) + 1)
forj inrange(max( 0, y - 1), min(BLOCK_HEIGHT - 1, y + 1) + 1) ifi != x orj != y]
接下来还有一个麻烦的地方，我们经常鼠标左右键同时按下，如果雷被全部标记，则会一下子打开周围所有的格子，如果其中有标记错的，那么不好意思，GAME OVER。
如果没有全标记完，会有一个效果显示周围一圈未被打开和标记的格子
classMineBlock:
defdouble_mouse_button_down(self, x, y):
ifself._block[y][x].around_mine_count == 0:
returnTrue
self._block[y][x].status = BlockStatus.double
around = _get_around(x, y)
sumflag = 0# 周围被标记的雷数量
fori, j in_get_around(x, y):
ifself._block[j][i].status == BlockStatus.flag:
sumflag += 1
# 周边的雷已经全部被标记
result = True
ifsumflag == self._block[y][x].around_mine_count:
fori, j inaround:
ifself._block[j][i].status == BlockStatus.normal:
ifnotself.open_mine(i, j):
result = False
else:
fori, j inaround:
ifself._block[j][i].status == BlockStatus.normal:
self._block[j][i].status = BlockStatus.hint
returnresult
defdouble_mouse_button_up(self, x, y):
self._block[y][x].status = BlockStatus.opened
fori, j in_get_around(x, y):
ifself._block[j][i].status == BlockStatus.hint:
self._block[j][i].status = BlockStatus.normal
扫雷的主要逻辑就这么多，剩下来的就是一些杂七杂八的事件了。当然，这些杂七杂八的事件也还是够你折腾一番的。
我们的代码里已经给大家完善并提供了相关的图片资源供使用。 获取源代码，请在公众号对话里回复关键字 扫雷
作者：丹枫无迹
责任编辑：

如何用Python给游戏加防沉迷
又名：我杀我自己
重点参考
【实战案例】利用Python做出趣味版防沉迷小程序

Python3.7将代码打包成exe程序并添加图标，一分钟学会！
代码
#这是一个防沉迷程序

import psutil
import os
import tkinter
import tkinter.messagebox
import time

class Regulation:
	def __init__(self):
		self.ban_week=[i for i in range(1,6)]  #周一至周五
		self.ban_hour=[i for i in range(15)]   #凌晨至下午2点
		self.allow_duration=2 #可连续在线2小时
		self.t_interval=60 #每隔60s监测一次
		self.start_time={'hour':99,'minute':99} #记录开始游戏的时间
		self.current_time={'hour':0,'minute':0} #记录当前时间
		self.week=0 #记录当前星期
		
	def show_warning(self):
		root = tkinter.Tk()
		root.withdraw() #为了隐藏tk窗口
		root.wm_attributes('-topmost',1) #显示在最上层
		tkinter.messagebox.showinfo('警告','垃圾！！！！！') #我骂我自己

	def show_remind(self):
		root = tkinter.Tk()
		root.withdraw()
		root.wm_attributes('-topmost',1)
		tkinter.messagebox.showinfo('提醒','已经游戏两小时，请于5分钟内退出')

	def get_time(self):
		self.week=int(time.strftime('%w'))
		self.current_time['hour']=int(time.strftime('%H'))
		self.current_time['minute']=int(time.strftime('%M'))
	
	def record_start_time(self):
		self.start_time['hour']=self.current_time['hour']
		self.start_time['minute']=self.current_time['minute']
	
	def judge_time(self):
		d_hour=self.current_time['hour']-self.start_time['hour']
		d_minute=self.current_time['minute']-self.start_time['minute']
		if d_hour>=self.allow_duration:
			if d_minute>=0: #已达到可允许时长
				self.show_remind()
			if d_minute>=5: #数次提醒无效，强制退出
				self.exit()
	
	def exit(self):
		cmd = 'taskkill /F /IM YuanShen.exe'
		os.system(cmd) #杀死进程YuanShen.exe(这游戏该死的好玩)，可更换为其他
		self.show_warning()			

	def judge(self):
		pids = psutil.pids() #获取当前所有进程
		self.get_time()
		for pid in pids:
			p = psutil.Process(pid)
			if p.name() == 'YuanShen.exe': #监测有无运行游戏，可更换为其他
				if self.week in self.ban_week:
					self.exit()
				elif self.current_time['hour'] in self.ban_hour:
					self.exit()
				else:
					if self.start_time['hour']==99:
						self.record_start_time() #首次监测到游戏，记录时间
					self.judge_time()
				

if __name__=='__main__':
	R=Regulation()
	while True:
		R.judge()
		time.sleep(R.t_interval) #监视官需要休息

#打包为.exe文件
#1.打开CMD
#2.准备一个.ico文件作为图标
#  可在线将.png转换为.ico，链接：https://www.easyicon.net/covert/	
#3.输入 pyinstaller -F -w -i D:\xxx\.xxx.ico D:\xxx\xxx.py
#  运行成功会提示.exe文件位置 
#4.可设为开机自启,WIN+R输入shell:startup,将.exe文件放入文件夹
#  倒也不必，会拖慢开机时间

#此程序运行无窗口，需从任务管理器中结束运行

Pygame 是一组用来开发游戏软件的 Python 程序模块，基于 SDL 库的基础上开发。我们今天将利用它来制作一款大家基本都玩过的小游戏——贪吃蛇。
一、需要导入的包
import pygame
import time
import random
pygame：获取图形组件构建游戏
time：主要用来设置帧率
random：主要用来设置食物的刷新位置
二、窗口界面设置
首先我们初始化游戏，建立一个窗口
pygame.init()
然后我们定义游戏中需要使用的颜色，在这个示例中，我们定义了六种颜色
white = (255, 255, 255)
yellow = (255, 255, 102)
black = (0, 0, 0)
red = (213, 50, 80)
green = (0, 255, 0)
blue = (50, 153, 213)
接下来，我们设置窗口的尺寸和标题栏，在这个示例中，我们将窗口设置为800*600
dis_width = 800
dis_height = 600
dis = pygame.display.set_mode((dis_width, dis_height))
pygame.display.set_caption('贪吃蛇游戏')
三、游戏中的变量
初始化一个clock变量，使用开头导入的time包。这个变量将用来处理游戏的帧率。
clock = pygame.time.Clock()
定义蛇的速度与大小。可以随意更改，选择你适应的即可
snake_block = 10
snake_speed = 12
设置分数显示和其他信息的字体大小与样式。
font_style = pygame.font.SysFont("bahnschrift", 25)
score_font = pygame.font.SysFont("comicsansms", 35)
四、设置功能函数
定义三个辅助功能函数，实现以下功能。
显示计算分数
蛇的参数
其他消息显示，比如失败后的重玩提示。
首先，定义一个计算分数的函数
def Your_score(score):
value = score_font.render("Your Score: " + str(score), True, yellow)
dis.blit(value, [0, 0]
接下来定义蛇的参数。我们定义了蛇的颜色，位置与大小，即snake_block。我们额外定义了一个snake_list作为输入，将在下面用到。
def our_snake(snake_block, snake_list):
for x in snake_list:
pygame.draw.rect(dis, black, [x[0], x[1], snake_block, snake_block])
最后定义一个消息显示函数，这个辅助函数将msg和颜色作为输入参数。我们将设置字体，然后以所需的颜色显示信息。我们需要指定信息在游戏中显示的位置。
def message(msg, colour):
mesg = font_style.render(msg, True, colour)
dis.blit(mesg, [width / 6, height / 3])
五、构建游戏
开始建立游戏循环，让游戏运行并能响应键盘输入。首先定义两个变量game_over和game_close，用来描述游戏的状态。第一个提示游戏是否结束，下一个定义是否关闭游戏。都定义为false
game_over = False
game_close = False
下一步，我们将定义x1和y1来表示蛇在游戏中的位置。我们分别初始化它们的宽度/2和高度/2。同时，我们将定义变量x1_change和y1_change来表示蛇的位置根据用户提供的输入而发生的变化。
x1 = width / 2
y1 = height / 2
x1_change = 0
y1_change = 0
另外，我们还需要定义snake_List和snake_length变量，分别存储蛇的所有头部位置和蛇的长度。
snake_List = []
snake_length = 1
吃掉食物新食物产生的位置，用random模块来实现。
foodx = round(random.randrange(0, width — snake_block) / 10.0) * 10.0
foody = round(random.randrange(0, height — snake_block) / 10.0) * 10.0
接下来，我们将启动一个循环，直到game_over变成True为止。
在这个循环中，我们将首先定义在 game_close 变量为 True 时要执行的指令。
下面的代码将帮助我们处理game_close等于True时的情况。
while game_close == True:
dis.fill(blue)
message("Lost! q quit or p again", red)
Your_score(Length_of_snake - 1)
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_q:
game_over = True
game_close = False
if event.key == pygame.K_p:
gameLoop()
如你所见，我们已经定义了很多东西。我们用蓝色填充显示(你当然可以选择你的颜色)。游戏结束时，我们显示一条消息，显示该用户输掉了游戏，我们应该询问用户是想再玩一次还是退出游戏。
我们也会显示用户的分数，等于蛇的长度减1。每当我们的蛇吃到食物时，我们都会更新1分。
现在，为了接受用户关于他是想再玩一次还是退出游戏的输入，我们定义了一个for-loop。当我们要求用户输入关于他的决定时，我们定义了输入的可能性。
如果用户输入的是'p'，那么我们将继续我们的游戏循环。如果用户输入的是'q'，那么我们就需要退出游戏。
现在，在处理完game_close的条件后，我们将定义所有需要的步骤，这将使我们的蛇根据用户的输入移动。我们将接受W、A、S、D和上、下、左、右键组合来进行游戏。你可以自由选择你的按键来玩游戏。
for event in pygame.event.get():
if event.type == pygame.QUIT:
game_over = True
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT or event.key == pygame.K_a:
x1_change = -snake_block
y1_change = 0
elif event.key == pygame.K_RIGHT or event.key == pygame.K_d:
x1_change = snake_block
y1_change = 0
elif event.key == pygame.K_UP or event.key == pygame.K_w:
y1_change = -snake_block
x1_change = 0
elif event.key == pygame.K_DOWN or event.key == pygame.K_s:
y1_change = snake_block
x1_change = 0
在上面的代码中，我们根据用户提供的输入改变x1_change和y1_change的值。同时，如果用户想退出游戏，我们也会退出游戏。
接下来，我们将定义输掉游戏的条件。同时，我们借助x1_change和y1_change更新x1和y1的值。我们还将用蓝色填充整个显示屏，并通过在显示屏中传递蛇和食物的出现位置来绘制它们。
if x1 >= width or x1 < 0 or y1 >= height or y1 < 0:
game_close = True
x1 += x1_change
y1 += y1_change
dis.fill(blue)
pygame.draw.rect(dis, green, [foodx, foody, snake_block, snake_block])
接下来，我们定义一个名为snake_Head的列表，它将在每次迭代后存储蛇头的值。我们将x1和y1的值追加到它上面。然后，我们将该snake_Head追加到snake_List中。
然后我们检查条件检查snake_List的长度是否大于snake_length。如果是，则删除snake_List中的第一个元素。
然后，我们检查当前的snake_Head是否等于snake_List中的任何一个元素，除了新增加的那个元素，也就是被检查的snake_Head。如果是，那么我们就关闭游戏，玩家就输了。
这是因为在snake_List中出现snake_Head意味着它曾经被添加到snake_List中，再次找到相同的值意味着蛇碰到了自己。所以，此时游戏结束。
然后我们调用函数our_snake和Your_score(前面定义的)，并将所需参数传递给这些函数，以显示更新后的蛇和玩家的分数。
snake_Head = []
snake_Head.append(x1)
snake_Head.append(y1)
snake_List.append(snake_Head)
if len(snake_List) > snake_length:
del snake_List[0]
for x in snake_List[:-1]:
if x == snake_Head:
game_close = True
our_snake(snake_block, snake_List)
Your_score(snake_length — 1)
pygame.display.update()
接下来，我们将在蛇吃完前一个食物后，形成新的食物。所以，为了做到这一点，我们需要在显示屏中找到一个新的随机位置来生成食物。另外，由于蛇刚吃完食物，我们需要将蛇的长度增加1。
最后，我们将蛇的速度作为参数给clock.tick，作为游戏的帧率。
if x1 == foodx and y1 == foody:
foodx = round(random.randrange(0, width — snake_block) / 10.0) * 10.0
foody = round(random.randrange(0, height — snake_block) / 10.0) * 10.0
snake_length += 1
clock.tick(snake_speed)
功能已经完全实现，我们最后退出游戏，并再次调用游戏循环
pygame.quit()
quit()
gameLoop()
六、完整代码
import pygame
import time
import random
pygame.init()
white = (255, 255, 255)
yellow = (255, 255, 102)
black = (0, 0, 0)
red = (213, 50, 80)
green = (0, 255, 0)
blue = (50, 153, 213)
dis_width = 800
dis_height = 600
dis = pygame.display.set_mode((dis_width, dis_height))
pygame.display.set_caption('贪吃蛇')
clock = pygame.time.Clock()
snake_block = 10
snake_speed = 15
font_style = pygame.font.SysFont("bahnschrift", 25)
score_font = pygame.font.SysFont("comicsansms", 35)
def Your_score(score):
value = score_font.render("Score: " + str(score), True, yellow)
dis.blit(value, [0, 0])
def our_snake(snake_block, snake_list):
for x in snake_list:
pygame.draw.rect(dis, black, [x[0], x[1], snake_block, snake_block])
def message(msg, color):
mesg = font_style.render(msg, True, color)
dis.blit(mesg, [dis_width / 6, dis_height / 3])
def gameLoop():
game_over = False
game_close = False
x1 = dis_width / 2
y1 = dis_height / 2
x1_change = 0
y1_change = 0
snake_List = []
Length_of_snake = 1
foodx = round(random.randrange(0, dis_width - snake_block) / 10.0) * 10.0
foody = round(random.randrange(0, dis_height - snake_block) / 10.0) * 10.0
while not game_over:
while game_close == True:
dis.fill(blue)
message("Lost! q quit or p again", red)
Your_score(Length_of_snake - 1)
pygame.display.update()
for event in pygame.event.get():
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_q:
game_over = True
game_close = False
if event.key == pygame.K_p:
gameLoop()
for event in pygame.event.get():
if event.type == pygame.QUIT:
game_over = True
if event.type == pygame.KEYDOWN:
if event.key == pygame.K_LEFT or event.key == pygame.K_a:
x1_change = -snake_block
y1_change = 0
elif event.key == pygame.K_RIGHT or event.key == pygame.K_d:
x1_change = snake_block
y1_change = 0
elif event.key == pygame.K_UP or event.key == pygame.K_w:
y1_change = -snake_block
x1_change = 0
elif event.key == pygame.K_DOWN or event.key == pygame.K_s:
y1_change = snake_block
x1_change = 0
if x1 >= dis_width or x1 < 0 or y1 >= dis_height or y1 < 0:
game_close = True
x1 += x1_change
y1 += y1_change
dis.fill(blue)
pygame.draw.rect(dis, green, [foodx, foody, snake_block, snake_block])
snake_Head = []
snake_Head.append(x1)
snake_Head.append(y1)
snake_List.append(snake_Head)
if len(snake_List) > Length_of_snake:
del snake_List[0]
for x in snake_List[:-1]:
if x == snake_Head:
game_close = True
our_snake(snake_block, snake_List)
Your_score(Length_of_snake - 1)
pygame.display.update()
if x1 == foodx and y1 == foody:
foodx = round(random.randrange(0, dis_width - snake_block) / 10.0) * 10.0
foody = round(random.randrange(0, dis_height - snake_block) / 10.0) * 10.0
Length_of_snake += 1
clock.tick(snake_speed)
pygame.quit()
quit()
gameLoop()
更多关于python的文章，欢迎关注python客栈。
以上就是五分钟学会怎么用python做一个简单的贪吃蛇的详细内容，更多关于python 贪吃蛇的资料请关注脚本之家其它相关文章！

你有没有想过电脑游戏是怎样制作出来的？其实它没有你想象的那样复杂！
PyGame是一个Python的库，能够让你更容易的写出一个游戏。它提供的功能包括图片处理和声音重放的功能，并且它们能很容易的整合进你的游戏里。去官网点击这里下载适合你的PyGame安装包。
我们就拿打飞机来做个例子(推荐学习：Python视频教程)
1 .创建游戏框架以及游戏背景#这个模块放一些常用的工具和基础类和精灵类
#在其他模块调用
import pygame
import random
#设置游戏屏幕大小 这是一个常量
SCREEN_RECT = pygame.Rect(0,0,580,700)
#敌机的定时器事件常量
CREATE_ENEMY_EVENT = pygame.USEREVENT
#定制一个精灵类，需要继承pygame提供的精灵类
#需要定义的属性有：
#image图片
#rect坐标
#speed速度
#接下来开始写敌机方面的内容 产生敌机
#先定义一个事件常量
CREATE_ENEMY_EVENT = pygame.USEREVENT
#我们还可以定义一个事件常量(发射子弹)
HERO_FIRE_EVENT = pygame.USEREVENT   1
class GameSprite(pygame.sprite.Sprite):
def __init__(self,new_image,new_speed=1):
super().__init__()
#图片
self.image = pygame.image.load(new_image)
#速度
self.speed = new_speed
#位置 获取图片的宽和高 get_rect()(0,0,宽，高)
self.rect = self.image.get_rect()
#精灵移动的速度 包括英雄精灵 背景精灵 敌机精灵 子弹精灵
self.speed = new_speed
def update(self):
#默认垂直方向移动 y轴控制垂直方向
self.rect.y  = self.speed
#self.rect.x  = 1
#以上是游戏的基础类，接下来设置背景类
#明确背景类继承自游戏的精灵类
class Background(GameSprite):
def __init__(self,is_alt = False):
#is_alt判断是否为另一张图像
#False表示第一张图像
#Ture表示另外一张图像
#两张图像交替循环
#传图片
super().__init__("/home/zhangyuan/下载/beijing.png")
if is_alt:
#如果是第二张图片 初始位置为-self.rect.height
self.rect.y = -self.rect.height
#def __init__(self,new_image):
#   super().init__(new_image)
def update(self):
#调用父类方法
super().update()
if self.rect.y >= SCREEN_RECT.height:
self.rect.y = -self.rect.height
2 .创建敌机精灵class Enemy(GameSprite):
def __init__(self):
super().__init__("/home/zhangyuan/images/enemy1.png")
#随机速度
self.speed = random.randint(10, 15)
#设置敌机的初始位置
self.rect.left = SCREEN_RECT.width
max_ = SCREEN_RECT.height -self.rect.height
self.rect.bottom = random.randint(0, max_)
def update(self):
panduan = random.randint(0, 1)
if panduan == 0:
self.rect.y -= self.speed
self.rect.x -= self.speed
else:
self.rect.y  = self.speed
self.rect.x -= self.speed
#判断敌机是否飞出屏幕  如果飞出屏幕将敌机从精灵组删除
if self.rect.y >= SCREEN_RECT.height or self.rect.right <=0 or self.rect.bottom <=0:
self.kill()
3 .创建英雄精灵class Bullet(GameSprite):
def __init__(self):
super().__init__("/home/zhangyuan/images/bullet1.png",-5)
def update(self):
super().update()
#判断是否超出屏幕 如果是 从精灵组删除
if self.rect.bottom < 0:
self.kill()
5 .碰撞检测#第一个参数和第二个参数是要参与碰撞检测的精灵
#第三个参数为Ture的时候 就是当碰撞的时候被碰撞的精灵从精灵组移除
pygame.sprite.groupcollide( self.enemy_group,self.hero.bullet, True, True)#子弹
#判断列表时候有内容
if len(enemies)>0:
#让英雄牺牲
self.hero.kill()
#结束游戏
PlaneGame.__game_over()
@staticmethod
def __game_over():
print("游戏结束")
#这是pygame提供的卸载模块功能
pygame.quit()
#这是pygame本身提供的退出脚本的功能
exit()
#需要先卸载pygame模块 然后退出脚本
if __name__ == "__main__":
game = PlaneGame()
game.star_game()
过程大体就是这样，Pygame还可以做许多游戏，只有专研过后才知道其中的乐趣
更多Python相关技术文章，请访问Python教程栏目进行学习！