1. Word guessing game
2. Licensing game
3. Figure guessing game
4. Picture licensing game
5. Character mosaic

1, Word guessing game

Running screenshot:

Code and steps:

1. Import relevant modules in the word guessing game program.

import random

2. Create all word sequence tuples to be guessed WORDS.

words=("python","jumble","easy","difficult","answer","continue","phone","posistion","game","position")

3. Display the game welcome interface.

print(

"""
Welcome to the word guessing game
 Combine the letters into a correct word
"""

)

4. Realize the logic of the game.

First, randomly pick out a word from the sequence, such as "easy"; then disorder the alphabetical order of the word; then, a new disordered word jumble can be generated through multiple cycles; finally, the disordered word will be displayed to the player. Players input guess words, the program judges right and wrong. If the player guesses wrong, he can continue to guess.

word=random.choice(words)
correct=word
jumble=""
while word:
    position=random.randrange(len(word))
    jumble+=word[position]
    word=word[:position]+word[(position+1):]
print("Disordered words:",jumble)
guess=input("\n Please guess:")
while guess!=correct and guess!="":
    print("I'm sorry it's not right.")
    guess=input("Continue to guess:")
if guess==correct:
    print("Great, you guessed it!\n")

5. Need to nest another cycle to judge whether players need to play word guessing games again

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

Iscontinue = input ("\ n \ ndo you want to continue (Y/N):")

Full code screenshot:

2, Licensing game

Run screenshots

Code and steps:

1. Three classes are designed in the licensing program: Card class, Hand class and Poke class.

class Card():
	pass
class Hand():
	pass
class Poke(Hand):
	pass

2, class Card

The Card class represents a Card, in which the FaceNum field refers to the Card numbers 1-13, the Suit field refers to the decor, "Mei" refers to plum blossom, "Fang" refers to diamonds, "red" refers to hearts, "black" refers to spades.

The Card constructor initializes the encapsulated member variables according to the parameters to initialize the Card face size and decor, and whether to display the Card face. The default value is True to display the front of the Card; the str() method is used to output the Card face size and decor; the pic_order() method is used to obtain the order number of the Card, and the Card face is based on clubs 1-13, diamonds 14-26, hearts 27-39, and spades 40- 52 sequence number (before shuffling), that is to say, the sequence number of plum 2 is 2, the sequence number of block A is 14, and the sequence number of block K is 26 (this method is reserved for the graphic display of the Card face); flip() is the flip method, which changes the attribute value of whether the Card face is displayed.

class Card():
RANKS = ["A", "2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K"]  # Card number
SUITS = ["Plum blossom", "square", "red", "black"]

def __init__(self, rank, suit, face_up=True):
    self.rank = rank  # Refers to the number of cards
    self.suit = suit  # suit is Decor
    self.is_face_up = face_up  # Whether to display the front of the card, True for the front, False for the back of the card

def __str__(self):  # print()
    if self.is_face_up:
        rep = self.suit + self.rank  # +" "+str(self.pic_order())
    else:
        rep = "XX"
    return rep

# Flop method
def flip(self):
    self.is_face_up = not self.is_face_up

# Serial number of the card
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 == "Plum blossom":
        Suit = 1
    elif self.suit == "square":
        Suit = 2
    elif self.suit == "red":
        Suit = 3
    else:
        Suit = 4
    return (Suit - 1) * 13 + FaceNum

3, class Hand

The Hand class represents a Hand (a card held by a player), which can be considered as a card held by a player. The cards list variable stores the cards held by the player. You can add cards, empty the cards in your Hand, and give one card to another player.

class Hand():
"""A hand of playing cards."""

def __init__(self):
    self.cards = []

def __str__(self):  # Override print() method
    if self.cards:
        rep = ""
        for card in self.cards:
            rep += str(card) + "\t"
    else:
        rep = "No cards"
    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)

4, class Poke

The Poke class represents a deck of cards, and we can think of a deck as a player with 52 cards, so we inherit the Hand class. Because the cards list variable needs to store 52 cards, and needs to be dealt and shuffled, the following methods are added.

populate(self) generates a deck of 52 cards. Of course, these cards are stored in the cards list variable in the order of plum 1-13, diamonds 14-26, hearts 27-39, and spades 40-52 (before shuffling). shuffle(self) shuffle, use Python's random module shuffle() method to shuffle the storage order of cards. Deal (self., hands, per_hand = 13) can complete the licensing action, giving four players 13 cards by default. Of course, if per_hand=10, each player will be dealt 10 cards, but there are still cards left in the end.

class Poke(Hand):
"""A desk of playing cards."""

def populate(self):  # Generate a deck of cards
    for suit in Card.SUITS:
        for rank in Card.RANKS:
            self.add(Card(rank, suit))

def shuffle(self):  # Shuffle the cards
    import random
    random.shuffle(self.cards)  # Order of playing cards

def deal(self, hands, per_hand=13):
    for rounds in range(per_hand):
        for hand in hands:
            top_card = self.cards[0]
            self.cards.remove(top_card)
            hand.add(top_card)

5. Main program

The main program is relatively simple. Because there are four players, the players list is generated to store the initialized four players. The object instance poke1 of a deck of cards is generated. A deck of 52 cards is generated by calling the populate() method. The shuffle order is disrupted by calling the huffle() method. The deal(players, 13) method is called to issue 13 cards to each player respectively. Finally, all the cards of the four players are shown.

if __name__ == "__main__":
print("This is a module with classes for playing cards.")
# Four game player
players = [Hand(), Hand(), Hand(), Hand()]
poke1 = Poke()
poke1.populate()  # Generating card
poke1.shuffle()  # Shuffle the cards
poke1.deal(players, 13)  # 13 cards for each player
# Show 4 players' cards
n = 1
for hand in players:
    print("card-game competitor", n, end=":")
    print(hand)
    n = n + 1
input("\n Press the enter key to exit.")

3, Figure guessing game

Running screenshot:

Code and steps:

1. Import related modules in the number guessing game program:

import tkinter as tk
import sys
import random
import re

2. random.randint(01024) randomly generates the number the player wants to guess.

number=random.randint(0,1024)
running=True
num=0
nmaxn=1024
nmin=0

3. The guess button event function obtains the guessed number from the single line text box entry_a and converts it to the number val a, then judges whether it is correct, and judges whether the number is too large or too small according to the number to be guessed.

def eBtnGuess(event):
global nmaxn
global nmin
global num
global running
if running:
    val_a=int(entry_a.get())
    if val_a==number:
        labelqval("Congratulations!")
        num+=1
        running=False
        numGuess()
    elif val_a<number:
        if val_a>nmin:
            nmin=val_a
            num+=1
            label_tip_min.config(label_tip_min,text=nmin)
        labelqval("Small.")
    else:
        if val_a <nmaxn:
            nmaxn = val_a
            num += 1
            label_tip_max.config(label_tip_max, text=nmaxn)
        labelqval("Oh, big.")
else:
    labelqval("You're right")

4. The HumGuess() function modifies the prompt label text to show the number of guesses.

def numGuess():
	if num == 1:
    	labelqval("You're right!")
	elif num<10:
      	labelqval("==I got it right within ten times... Number of attempts:"+str(num))
 	elif num<50:
     	labelqval("OK, number of attempts:"+str(num))
 	else:
     	labelqval("ok You've done it more than 50 times... Number of attempts:"+str(num))
def labelqval(vText):
 	label_val_q.config(label_val_q,text=vText)

5. Construction of main forms.

root=tk.Tk(className="Figure guessing game")
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=nmin)
label_tip_max.pack(side="top",fill="x")
label_tip_min.pack(side="bottom",fill="y")
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="guess")
entry_a.pack(side="left")
entry_a.bind('<Return>',eBtnGuess)
btnguess.bind('<Button-1>',eBtnGuess)
btnguess.pack(side="left")
line_input.pack(side="top",fill="x")
#close button
line_btn=tk.Frame(root)
btnClose=tk.Button(line_btn,text="Close")
btnClose.bind('<Button-1>',eBtnClose)
btnClose.pack(side="left")
line_btn.pack(side="top")`

Full code screenshot:

4, Graphic licensing program game

Running screenshot:

Code and steps:

The 52 cards to be issued are numbered in the order of 0-12 clubs, 13-25 diamonds, 26-38 hearts and 39-51 spades, and stored in the pocker list c before shuffling. The list element stores the number of A card c is actually A card. At the same time, according to this number, the playing card pictures are stored in the imgs list. That is to say, imgs[0] stores the picture of plum blossom A, imgs[1] stores the picture of plum blossom 2, imgs[14] stores the picture of block 2, and so on.

After licensing, according to the card number list of each player (pl,p2, p3, p4), obtain the corresponding card picture from imgs, and use create- image "x coordinate, y coordinate", image = image file) to display the card in the specified position.

Using canvas to draw a small window,

The code is as follows:

from tkinter import *
import random
n=52
def gen_pocker(n):
    x=100
    while(x>0):
        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)=([],[],[],[])
(p1,p2,p3,p4)=([],[],[],[])
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=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()

5, Character puzzle

Running screenshot:

Code and steps: 1. Divide the picture and put it under the code file

2. Defining constants and loading images

from tkinter import*
from tkinter.messagebox import *
import random

root = Tk('Jigsaw puzzle')
root.title('Jigsaw puzzle')
Pics=[]
for i in range(9):
	filename=str(i)+".gif"
	Pics.append(PhotoImage(file=filename))
#Define constants
#canvas size
WIDTH=700
HEIGHT=623

3. Image block (collage) class

Each image block (collage) is a Square object with draw function, so this collage picture can be drawn to Canvas. The orderID attribute is the number of each image block (collage).

#Image block side length
IMAGE_WIDTH=WIDTH//3
IMAGE_HEIGHT=HEIGHT//3
#Chessboard side length
ROWS=3
COLS=3
steps=0   #Mobile steps
board=[[0,1,2],[3,4,5],[6,7,8]]   #Save block list
#Image block class
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)

4. Initialize game

random.shuffle(board) can only scramble the two-dimensional list by lines, so it uses one-dimensional list to realize the function of scrambling image blocks, and then generates corresponding image blocks (collages) into the board list according to the number.

#Initialize the platter
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)

5. Draw the elements of the game interface

There are also various elements in the game interface, such as black boxes,

#Draw the elements of the game interface
def drawBoard(canvas):
	canvas.create_polygon((0,0,WIDTH,0,WIDTH,HEIGHT,0,HEIGHT),width=1,outline='Black',fill='pink')
    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)))`

6. Mouse events

Convert the click position to the chessboard coordinate on the puzzle board. If you click the empty position, all image blocks will not move; otherwise, check whether there are empty positions on the top, bottom, left and right of the current image block that you click in turn, and if so, move the current image block.

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="Congratulations",message="Jigsaw puzzle completed")`

7. Judge win or lose

Determines whether the number of the collage is in order. If not, returns False.

def win():
    for i in range(ROWS):
        for j in range(COLS):
            if board[i][j] is not None and board[i][j].orderID!=i*ROWS+j:
                return False
    return True

8. Reset game

def callBack2():
    print("Restart")
    play_game()
    cv.delete('all')
    drawBoard(cv)

9. Window design

cv=Canvas(root,bg='white',width=WIDTH,height=HEIGHT)
b1=Button(root,text="Restart",command=callBack2,width=20)
label1=Label(root,text="0",fg="red",width=20)
label1.pack()
cv.bind("<Button-1>",mouseclick)
cv.pack()
b1.pack()
play_game()
drawBoard(cv)

Full code:

from tkinter import*
from tkinter.messagebox import *
import random

root = Tk('Jigsaw puzzle')
root.title('Jigsaw puzzle')
Pics=[]
for i in range(9):
    filename=str(i)+".gif"
    Pics.append(PhotoImage(file=filename))
WIDTH=700
HEIGHT=623
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 play_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='pink')
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="Congratulations",message="Jigsaw puzzle completed")

def win():
    for i in range(ROWS):
        for j in range(COLS):
            if board[i][j] is not None and board[i][j].orderID!=i*ROWS+j:
                return False
    return True
def callBack2():
    print("Restart")
    play_game()
    cv.delete('all')
    drawBoard(cv)

cv=Canvas(root,bg='white',width=WIDTH,height=HEIGHT)
b1=Button(root,text="Restart",command=callBack2,width=20)
label1=Label(root,text="0",fg="red",width=20)
label1.pack()
cv.bind("<Button-1>",mouseclick)
cv.pack()
b1.pack()
play_game()
drawBoard(cv)
root.mainloop()

Impressions: in this python game development, we mainly know that python's multi-faceted applications, the application of tkinter's package and random's application are the most common and can be better developed. When using pictures, it's better to put pictures and codes in the same folder, or the path teacher will make mistakes. Of course, if the picture path can be right, it's best It's better to put them together for safety.