使用python制作简单的游戏案例

编辑环境：python3.7

编译工具：vscode

案例目录：

1.序列应用——猜单词游戏

2.面向对象设计应用——发牌游戏

3.图形界面设计——猜数字游戏

4.Tkinter图形绘制——图形版发牌程序

5.Python图像处理——人物拼图游戏

一、序列应用——猜单词游戏

运行结果：

WORDS中定义需要被猜的词库，默认游戏自动开始，使用random函数从WORDS中随机选择一个单词，之后将单词随机打乱输出。猜测时，如果答案不对会一直循环，若答案正确则让用户输入yes or no 选择是否继续。

完整代码：

import random

WORDS = ("python", "jumble", "easy", "code", "sleep",

"flask", "django", "game", "break", "phone")

print(

'''欢迎参加猜单词游戏

请将字母组合成一个正确的单词

'''

)

iscontinue = "y"

while iscontinue == "Y" or iscontinue == "y":

word = random.choice(WORDS)

correct = word

jumble = ""

while word:

position = random.randrange(len(word))

jumble += word[position]

word = word[:position]+word[(position+1):]

print("打乱顺序之后的单词为：", jumble)

guess = input("请输入猜测的单词:")

while guess != correct and guess != "":

print("猜测错误，请再来一次！")

guess = input("请输入：")

if guess == correct:

print("真棒！你猜对了")

iscontinue = input("请问是否继续？(Y/N)")

二、面向对象设计应用——发牌游戏

由于扑克有52张(出去大小王)，每一种都有四种花色，方块，梅花，黑桃，红桃。为了区分牌和牌的花色，令梅花A——K为序号1-13，方块A——K为14-26，红桃A——K为27-39，黑桃A——K为40-52。使用随机数函数分别选出牌。

运行结果：

完整代码：

class Card:

'''A playing card.card'''

RANKS = ['A', '2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K']

SUITS = ['梅花', '方片', '红桃', '黑桃']

def __init__(self, rank, suit, face_up=True):

self.rank = rank

self.suit = suit

self.is_face_up = face_up

def __str__(self):

if self.is_face_up:

rep = self.suit + self.rank

else:

rep = 'XX'

return rep

def pic_order(self):

if self.rank == 'A':

FaceNum = 1

elif self.rank == 'J':

FaceNum = 11

elif self.rank == 'Q':

FaceNum = 12

elif self.rank == 'K':

FaceNum = 13

else:

FaceNum = int(self.rank)

if self.suit == '梅花':

Suit = 1

elif self.suit == '方片':

Suit = 2

elif self.suit == '红桃':

Suit = 3

else:

Suit = 4

return (Suit - 1) * 13 + FaceNum

def flip(self): # 翻牌方法

self.is_face_up = not self.is_face_up

class Hand():

def __init__(self):

self.cards=[]

def __str__(self):

if self.cards:

rep=''

for card in self.cards:

rep+=str(card)+'\t'

else :

rep='无牌'

return rep

def clear(self):

self.cards=[]

def add(self,card):

self.cards.append(card)

def give(self,card,other_hand):

self.cards.remove(card)

other_hand.add(card)

class Poke(Hand):

def populate(self):

for suit in Card.SUITS:

for rank in Card.RANKS:

self.add(Card(rank,suit))

def shuffle(self):

import random

random.shuffle(self.cards)

def deal(self,hands,per_hand=13):

for rounds in range(per_hand):

for hand in hands:

if self.cards:

top_card=self.cards[0]

self.cards.remove(top_card)

hand.add(top_card)

else:

print('不能继续发牌了，牌已经发完了!')

if __name__=="__main__":

print('This is a module with classes for playing cards.')

players=[Hand(),Hand(),Hand(),Hand()]

poke1=Poke()

poke1.populate()

poke1.shuffle()

poke1.deal(players,13)

n=1

for hand in players:

print('牌手',n,end=':')

print(hand)

n=n+1

input('\nPress the enter key to exit.')

三、图形界面设计——猜数字游戏

1.在猜数字游戏程序中导入相关模块：

random.randint(0，1024)随机产生玩家要猜的数字。

2.猜按钮事件函数从单行文本框entry_a获取猜的数字并转换成数字vale，然后判断是否正确，并根据要猜的数字number判断数字是过大还是过小。

3.HumGuess()函数修改提示标签文字来显示猜的次数。

4.关闭按钮事件函数实现窗体关闭。

运行结果：

完整代码：

import tkinter as tk

import sys

import random

import re

number = random.randint(0, 1024)

running = True

num = 0

nmaxn = 1024

nminn = 0

def eBtnClose(event):

root.destory()

def eBtnGuess(event):

global nmaxn

global nminn

global num

global running

if running:

val_a = int(entry_a.get())

if val_a == number:

labelqval("恭喜你答对了")

num += 1

running = False

numGuess()

elif val_a < number:

if val_a > nminn:

nminn = val_a

num += 1

label_tip_min.config(label_tip_min, text=nminn)

labelqval("小了哦")

else:

if val_a < nmaxn:

nmaxn = val_a

num += 1

label_tip_max.config(label_tip_max, text=nmaxn)

labelqval("大了哦")

else:

labelqval("你已经答对啦...")

def numGuess():

if num == 1:

labelqval("哇，竟然一次答对")

elif num < 10:

labelqval("厉害，十次之内就答对了，尝试次数："+str(num))

elif num < 50:

labelqval("还行哦尝试次数："+str(num))

else:

labelqval("您都超过50次了，尝试次数："+str(num))

def labelqval(vText):

label_val_q.config(label_val_q, text=vText)

root = tk.Tk(className="猜数字游戏")

root.geometry("400x90+200+200")

line_a_tip = tk.Frame(root)

label_tip_max = tk.Label(line_a_tip, text=nmaxn)

label_tip_min = tk.Label(line_a_tip, text=nminn)

label_tip_max.pack(side="top", fill="x")

label_tip_min.pack(side="bottom", fill="x")

line_a_tip.pack(side="left", fill="y")

line_question = tk.Frame(root)

label_val_q = tk.Label(line_question, width="80")

label_val_q.pack(side="left")

line_question.pack(side="top", fill="x")

line_input = tk.Frame(root)

entry_a = tk.Entry(line_input, width="40")

btnGuess = tk.Button(line_input, text="猜")

entry_a.pack(side="left")

entry_a.bind('', eBtnGuess)

btnGuess.bind('', eBtnGuess)

btnGuess.pack(side="left")

line_input.pack(side="top", fill="x")

line_btn = tk.Frame(root)

btnClose = tk.Button(line_btn, text="关闭")

btnClose.bind('', eBtnClose)

btnClose.pack(side="left")

line_btn.pack(side="top")

labelqval("请输入0-1024之间得任意整数：")

entry_a.focus_set()

print(number)

root.mainloop()

四、Tkinter图形绘制——图形版发牌程序

运行结果：

完整代码：

from tkinter import *

import random

n = 52

def gen_pocker(n):

x = 100

while(x > 100):

x = x-1

p1 = random.randint(0, n-1)

p2 = random.randint(0, n-1)

t = pocker[p1]

pocker[p1] = pocker[p2]

pocker[p2] = t

return pocker

pocker = [i for i in range(n)]

pocker = gen_pocker(n)

print(pocker)

(player1, player2, player3, player4) = ([], [], [], []) # 4位牌手各自牌的图片列表

(p1, p2, p3, p4) = ([], [], [], []) # 4位牌手各自牌的编号列表

root = Tk()

cv = Canvas(root, bg='white', width=700, height=600)

imgs = []

for i in range(1, 5):

for j in range(1, 14):

imgs.insert((i-1)*13+(j-1), PhotoImage(

file='C:\\Users\\10649\Desktop\\2D开发\\python_game\\sy1\\puke\\images\\'+str(i)+'-'+str(j)+'.gif'))

for x in range(13):

m = x*4

p1.append(pocker[m])

p2.append(pocker[m+1])

p3.append(pocker[m+2])

p4.append(pocker[m+3])

p1.sort()

p2.sort()

p3.sort()

p4.sort()

for x in range(0, 13):

img = imgs[p1[x]]

player1.append(cv.create_image((200+20*x, 80), image=img))

img = imgs[p2[x]]

player2.append(cv.create_image((100, 150+20*x), image=img))

img = imgs[p3[x]]

player3.append(cv.create_image((200+20*x, 500), image=img))

img = imgs[p4[x]]

player4.append(cv.create_image((560, 150+20*x), image=img))

print("player1:", player1)

print("player2:", player2)

print("player3:", player3)

print("player4:", player4)

cv.pack()

root.mainloop()

五、Python图像处理——人物拼图游戏

设计思路：

游戏程序首先将图片分割成相应3行3列的拼块，并按顺序编号。动态地生成一个＼为3x3的列表board，用于存放数字0一8，其中，每个数字代表一个拼块，8号拼块不显示。

游戏开始时，随机打乱这个数组board，如board是5号拼块，则在左上角显示编号是5的拼块。根据玩家用鼠标单击的拼块和空白块所在位置，来交换该board数组对应的元素，最后通过元素排列顺序来判断是否已经完成游戏。

运行结果：

完整代码：

from tkinter import *

from tkinter.messagebox import *

import random

root = Tk('拼图游戏')

root.title('拼图')

Pics = []

for i in range(9):

filename = "C:\\Users\\10649\Desktop\\2D开发\\python_game\\sy1\\timg_0" + \

str(i)+".png"

Pics.append(PhotoImage(file=filename))

WIDTH = 312

HEIGHT = 450

IMAGE_WIDTH = WIDTH // 3

IMAGE_HEIGHT = HEIGHT // 3

ROWS = 3

COLS = 3

steps = 0

board = [[0, 1, 2], [3, 4, 5], [6, 7, 8]]

class Square:

def __init__(self, orderID):

self.orderID = orderID

def draw(self, canvas, board_pos):

img = Pics[self.orderID]

canvas.create_image(board_pos, image=img)

def init_board():

L = list(range(8))

L.append(None)

random.shuffle(L)

for i in range(ROWS):

for j in range(COLS):

idx = i*ROWS+j

orderID = L[idx]

if orderID is None:

board[i][j] = None

else:

board[i][j] = Square(orderID)

def paly_game():

global steps

steps = 0

init_board()

def drawBoard(canvas):

canvas.create_polygon((0, 0, WIDTH, 0, WIDTH, HEIGHT,

0, HEIGHT), width=1, outline='black', fill='green')

for i in range(ROWS):

for j in range(COLS):

if board[i][j] is not None:

board[i][j].draw(

canvas, (IMAGE_WIDTH*(j+0.5), IMAGE_HEIGHT*(i+0.5)))

def mouseclick(pos):

global steps

r = int(pos.y // IMAGE_HEIGHT)

c = int(pos.x // IMAGE_WIDTH)

print(r, c)

if r < 3 and c < 3:

if board[r][c] is None:

return

else:

current_square = board[r][c]

if r-1 >= 0 and board[r-1][c] is None:

board[r][c] = None

board[r-1][c] = current_square

steps += 1

elif c+1 <= 2 and board[r][c+1] is None:

board[r][c] = None

board[r][c+1] = current_square

steps += 1

elif r+1 <= 2 and board[r+1][c] is None:

board[r][c] = None

board[r+1][c] = current_square

steps += 1

elif c-1 >= 0 and board[r][c-1] is None:

board[r][c] = None

board[r][c-1] = current_square

steps += 1

label1["text"] = str(steps)

cv.delete('all')

drawBoard(cv)

if win():

showinfo(title="恭喜", message="你成功了")

def win():

for i in range(ROWS):

for j in range(COLS):

if board[i][j] is not None and board[i][j].orderID != 1*ROWS+j:

return False

return True

def callBack2():

print("重新开始")

paly_game()

cv.delete("all")

drawBoard(cv)

cv = Canvas(root, bg='white', width=WIDTH, height=HEIGHT)

b1 = Button(root, text="重新开始", command=callBack2(), width=20)

label1 = Label(root, text="0", fg="red", width=20)

label1.pack()

cv.bind("", mouseclick)

cv.pack()

b1.pack()

paly_game()

drawBoard(cv)

root.mainloop()

来源：oschina

链接：https://my.oschina.net/u/4460763/blog/3193568