本篇内容来自https://www.cnblogs.com/lws865/category/1520289.html
玛丽冒险
文件结构：
marie.py
import pygame # 将pygame库导入到python程序中
from pygame.locals import * # 导入pygame中的常量
import sys # 导入系统模块
SCREENWIDTH = 822 # 窗口宽度
SCREENHEIGHT = 199 # 窗口高度
FPS = 30 # 更新画面的时间
# 定义一个移动地图类
class MyMap():
def __init__(self, x, y):
# 加载背景图片
self.bg = pygame.image.load("image/bg.png").convert_alpha()
self.x = x
self.y = y
def map_rolling(self):
if self.x < -790: # 小于-790说明地图已经完全移动完毕
self.x = 800 # 给地图一个新的坐标点
else:
self.x -= 5 # 5个像素向左移动
# 更新地图
def map_update(self):
SCREEN.blit(self.bg, (self.x, self.y))
# 背景音乐按钮
class Music_Button():
is_open = True # 背景乐音的标记
def __init__(self):
self.open_img = pygame.image.load('image/btn_open.png').convert_alpha()
self.close_img = pygame.image.load('image/btn_close.png').convert_alpha()
self.bg_music = pygame.mixer.Sound('audio/bg_music.wav') # 加载背景音乐
# 判断鼠标是否在，按钮的范围内
def is_select(self):
# 获取鼠标，的坐标
point_x, point_y = pygame.mouse.get_pos()
w, h = self.open_img.get_size() # 获取按钮图片的大小
# 判断鼠标是否在按钮范围内
in_x = point_x > 20 and point_x < 20 + w
in_y = point_y > 20 and point_y < 20 + h
return in_x and in_y
from itertools import cycle # 导入迭代工具
# 玛丽类
class Marie():
def __init__(self):
# 初始化小玛丽矩形
self.rect = pygame.Rect(0, 0, 0, 0)
self.jumpState = False # 跳跃的状态
self.jumpHeight = 130 # 跳跃的高度
self.lowest_y = 140 # 最低坐标
self.jumpValue = 0 # 跳跃增变量
# 小玛丽动图索引
self.marieIndex = 0
self.marieIndexGen = cycle([0, 1, 2])
# 加载小玛丽图片
self.adventure_img = (
pygame.image.load("image/adventure1.png").convert_alpha(),
pygame.image.load("image/adventure2.png").convert_alpha(),
pygame.image.load("image/adventure3.png").convert_alpha(),
)
self.jump_audio = pygame.mixer.Sound('audio/jump.wav') # 跳音效
self.rect.size = self.adventure_img[0].get_size()
self.x = 50; # 绘制小玛丽的X坐标
self.y = self.lowest_y; # 绘制小玛丽的Y坐标
self.rect.topleft = (self.x, self.y)
# 跳状态
def jump(self):
self.jumpState = True
# 小玛丽移动
def move(self):
if self.jumpState: # 当起跳的时候
if self.rect.y >= self.lowest_y: # 如果站在地上
self.jumpValue = -5 # 以5个像素值向上移动
if self.rect.y <= self.lowest_y - self.jumpHeight: # 小玛丽到达顶部回落
self.jumpValue = 5 # 以5个像素值向下移动
self.rect.y += self.jumpValue # 通过循环改变玛丽的Y坐标
if self.rect.y >= self.lowest_y: # 如果小玛丽回到地面
self.jumpState = False # 关闭跳跃状态
# 绘制小玛丽
def draw_marie(self):
# 匹配小玛丽动图
marieIndex = next(self.marieIndexGen)
# 绘制小玛丽
SCREEN.blit(self.adventure_img[marieIndex],
(self.x, self.rect.y))
import random # 随机数
# 障碍物类
class Obstacle():
score = 1 # 分数
move = 5 # 移动距离
obstacle_y = 150 # 障碍物y坐标
def __init__(self):
# 初始化障碍物矩形
self.rect = pygame.Rect(0, 0, 0, 0)
# 加载障碍物图片
self.missile = pygame.image.load("image/missile.png").convert_alpha()
self.pipe = pygame.image.load("image/pipe.png").convert_alpha()
# 加载分数图片
self.numbers = (pygame.image.load('image/0.png').convert_alpha(),
pygame.image.load('image/1.png').convert_alpha(),
pygame.image.load('image/2.png').convert_alpha(),
pygame.image.load('image/3.png').convert_alpha(),
pygame.image.load('image/4.png').convert_alpha(),
pygame.image.load('image/5.png').convert_alpha(),
pygame.image.load('image/6.png').convert_alpha(),
pygame.image.load('image/7.png').convert_alpha(),
pygame.image.load('image/8.png').convert_alpha(),
pygame.image.load('image/9.png').convert_alpha())
# 加载加分音效
self.score_audio = pygame.mixer.Sound('audio/score.wav') # 加分
# 0和1随机数
r = random.randint(0, 1)
if r == 0: # 如果随机数为0显示导弹障碍物相反显示管道
self.image = self.missile # 显示导弹障碍
self.move = 15 # 移动速度加快
self.obstacle_y = 100 # 导弹坐标在天上
else:
self.image = self.pipe # 显示管道障碍
# 根据障碍物位图的宽高来设置矩形
self.rect.size = self.image.get_size()
# 获取位图宽高
self.width, self.height = self.rect.size
# 障碍物绘制坐标
self.x = 800
self.y = self.obstacle_y
self.rect.center = (self.x, self.y)
# 障碍物移动
def obstacle_move(self):
self.rect.x -= self.move
# 绘制障碍物
def draw_obstacle(self):
SCREEN.blit(self.image, (self.rect.x, self.rect.y))
# 获取分数
def getScore(self):
self.score
tmp = self.score;
if tmp == 1:
self.score_audio.play() # 播放加分音乐
self.score = 0;
return tmp;
# 显示分数
def showScore(self, score):
# 获取得分数字
self.scoreDigits = [int(x) for x in list(str(score))]
totalWidth = 0 # 要显示的所有数字的总宽度
for digit in self.scoreDigits:
# 获取积分图片的宽度
totalWidth += self.numbers[digit].get_width()
# 分数横向位置
Xoffset = (SCREENWIDTH - (totalWidth+30))
for digit in self.scoreDigits:
# 绘制分数
SCREEN.blit(self.numbers[digit], (Xoffset, SCREENHEIGHT * 0.1))
# 随着数字增加改变位置
Xoffset += self.numbers[digit].get_width()
# 游戏结束的方法
def game_over():
bump_audio = pygame.mixer.Sound('audio/bump.wav') # 撞击
bump_audio.play() # 播放撞击音效
# 获取窗体宽、高
screen_w = pygame.display.Info().current_w
screen_h = pygame.display.Info().current_h
# 加载游戏结束的图片
over_img = pygame.image.load('image/gameover.png').convert_alpha()
# 将游戏结束的图片绘制在窗体的中间位置
SCREEN.blit(over_img, ((screen_w - over_img.get_width()) / 2,
(screen_h - over_img.get_height()) / 2))
def mainGame():
score = 0 # 得分
over = False # 游戏结束标记
global SCREEN, FPSCLOCK
pygame.init() # 经过初始化以后我们就可以尽情地使用pygame了。
# 使用Pygame时钟之前，必须先创建Clock对象的一个实例，
# 控制每个循环多长时间运行一次。
FPSCLOCK = pygame.time.Clock()
SCREEN = pygame.display.set_mode((SCREENWIDTH, SCREENHEIGHT)) # 通常来说我们需要先创建一个窗口，方便我们与程序的交互。
pygame.display.set_caption('玛丽冒险') # 设置窗口标题
# 创建地图对象
bg1 = MyMap(0, 0)
bg2 = MyMap(800, 0)
# 创建小玛丽对象
marie = Marie()
addObstacleTimer = 0 # 添加障碍物的时间
list = [] # 障碍物对象列表
music_button = Music_Button() # 创建背景音乐按钮对象
btn_img = music_button.open_img # 设置背景音乐按钮的默认图片
music_button.bg_music.play(-1) # 循环播放背景音乐
while True:
# 获取单击事件
for event in pygame.event.get():
if event.type == pygame.MOUSEBUTTONUP: # 判断鼠标事件
if music_button.is_select(): # 判断鼠标是否在静音按钮范围
if music_button.is_open: # 判断背景音乐状态
btn_img = music_button.close_img # 单击后显示关闭状态的图片
music_button.is_open = False # 关闭背景音乐状态
music_button.bg_music.stop() # 停止背景音乐的播放
else:
btn_img = music_button.open_img
music_button.is_open = True
music_button.bg_music.play(-1)
# 如果单击了关闭窗口就将窗口关闭
if event.type == QUIT:
pygame.quit() # 退出窗口
sys.exit() # 关闭窗口
# 单击键盘空格键，开启跳的状态
if event.type == KEYDOWN and event.key == K_SPACE:
if marie.rect.y >= marie.lowest_y: # 如果小玛丽在地面上
marie.jump_audio.play() # 播放小玛丽跳跃音效
marie.jump() # 开启小玛丽跳的状态
if over == True: # 判断游戏结束的开关是否开启
mainGame() # 如果开启将调用mainGame方法重新启动游戏
if over == False:
# 绘制地图起到更新地图的作用
bg1.map_update()
# 地图移动
bg1.map_rolling()
bg2.map_update()
bg2.map_rolling()
# 小玛丽移动
marie.move()
# 绘制小玛丽
marie.draw_marie()
# 计算障碍物间隔时间
if addObstacleTimer >= 1300:
r = random.randint(0, 100)
if r > 40:
# 创建障碍物对象
obstacle = Obstacle()
# 将障碍物对象添加到列表中
list.append(obstacle)
# 重置添加障碍物时间
addObstacleTimer = 0
# 循环遍历障碍物
for i in range(len(list)):
# 障碍物移动
list[i].obstacle_move()
# 绘制障碍物
list[i].draw_obstacle()
# 判断小玛丽与障碍物是否碰撞
if pygame.sprite.collide_rect(marie, list[i]):
over = True # 碰撞后开启结束开关
game_over() # 调用游戏结束的方法
music_button.bg_music.stop()
else:
# 判断小玛丽是否跃过了障碍物
if (list[i].rect.x + list[i].rect.width) < marie.rect.x:
# 加分
score += list[i].getScore()
# 显示分数
list[i].showScore(score)
addObstacleTimer += 20 # 增加障碍物时间
SCREEN.blit(btn_img, (20, 20)) # 绘制背景音乐按钮
pygame.display.update() # 更新整个窗口
FPSCLOCK.tick(FPS) # 循环应该多长时间运行一次
if __name__ == '__main__':
mainGame()
View Code
五子棋（控制台版）
文件结构
gobang.py
finish = False # 游戏是否结束
flagNum = 1 # 当前下棋者标记
flagch = '*' # 当前下棋者棋子
x = 0 # 当前棋子的横坐标
y = 0 # 当前棋子的纵坐标
print('\033[1;37;41m---------简易五子棋游戏（控制台版）---------\033[0m')
# 棋盘初始化
checkerboard=[]
for i in range(10):
checkerboard.append([])
for j in range(10):
checkerboard[i].append('-')
def msg():
# 输出最后胜利的棋盘
print("\033[1;37;44m--------------------------------")
print(" 1 2 3 4 5 6 7 8 9 10")
for i in range(len(checkerboard)):
print(chr(i + ord('A')) + " ", end=' ')
for j in range(len(checkerboard[i])):
print(checkerboard[i][j] + " ", end=' ')
print()
print("--------------------------------\033[0m")
# 输出赢家
if (flagNum == 1):
print('\033[32m*棋胜利！***\033[0m')
else:
print('\033[32mo棋胜利！***\033[0m')
while not finish:
# 打印棋盘
print("\033[1;30;46m--------------------------------")
print(" 1 2 3 4 5 6 7 8 9 10")
for i in range(len(checkerboard)):
print(chr(i + ord('A')) + " ", end=' ');
for j in range(len(checkerboard[i])):
print(checkerboard[i][j] + " ", end=' ')
print()
print("--------------------------------\033[0m")
# 判断当前下棋者
if flagNum == 1:
flagch = '*'
print('\033[1;37;40m请*输入棋子坐标（例如A1）：\033[0m', end=' ') # 白字黑底
else:
flagch = 'o'
print('\033[1;30;42m请o输入棋子坐标（例如J5）：\033[0m', end=' ') # 黑字绿底
# 输入棋子坐标
str = input()
ch = str[0] # 获取第一个字符的大写形式
x = ord(ch) - 65
y = int(str[1]) - 1
# 判断坐标是否在棋盘之内
if (x < 0 or x > 9 or y < 0 or y > 9):
print('\033[31m***您输入的坐标有误请重新输入！***\033[0m')
continue
# 判断坐标上是否有棋子
if (checkerboard[x][y] == '-'):
if (flagNum == 1):
checkerboard[x][y] = '*'
else:
checkerboard[x][y] = 'o'
else:
print('\033[31m******您输入位置已经有其他棋子，请重新输入！\033[0m')
continue
# 判断棋子左侧
if (y - 4 >= 0):
if (checkerboard[x][y - 1] == flagch
and checkerboard[x][y - 2] == flagch
and checkerboard[x][y - 3] == flagch
and checkerboard[x][y - 4] == flagch):
finish = True
msg()
# 判断棋子右侧
if (y + 4 <= 9):
if (checkerboard[x][y + 1] == flagch
and checkerboard[x][y + 2] == flagch
and checkerboard[x][y + 3] == flagch
and checkerboard[x][y + 4] == flagch):
finish = True
msg()
# 判断棋子上方
if (x - 4 >= 0):
if (checkerboard[x - 1][y] == flagch
and checkerboard[x - 2][y] == flagch
and checkerboard[x - 3][y] == flagch
and checkerboard[x - 4][y] == flagch):
finish = True
msg()
# 判断棋子下方
if (x + 4 <= 9):
if (checkerboard[x + 1][y] == flagch
and checkerboard[x + 2][y] == flagch
and checkerboard[x + 3][y] == flagch
and checkerboard[x + 4][y] == flagch):
finish = True
msg()
# 判断棋子右上方向
if (x - 4 >= 0 and y - 4 >= 0):
if (checkerboard[x - 1][y - 1] == flagch
and checkerboard[x - 2][y - 2] == flagch
and checkerboard[x - 3][y - 3] == flagch
and checkerboard[x - 4][y - 4] == flagch):
finish = True
msg()
# 判断棋子右下方向
if (x + 4 <= 9 and y - 4 >= 0):
if (checkerboard[x + 1][y - 1] == flagch
and checkerboard[x + 2][y - 2] == flagch
and checkerboard[x + 3][y - 3] == flagch
and checkerboard[x + 4][y - 4] == flagch):
finish = True
msg()
# 判断棋子左上方向
if (x - 4 >= 0 and y + 4 <= 9):
if (checkerboard[x - 1][y + 1] == flagch
and checkerboard[x - 2][y + 2] == flagch
and checkerboard[x - 3][y + 3] == flagch
and checkerboard[x - 4][y + 4] == flagch):
finish = True
msg()
# 判断棋子左下方向
if (x + 4 <= 9 and y + 4 <= 9):
if (checkerboard[x + 1][y + 1] == flagch
and checkerboard[x + 2][y + 2] == flagch
and checkerboard[x + 3][y + 3] == flagch
and checkerboard[x + 4][y + 4] == flagch):
finish = True
msg()
flagNum *= -1; # 更换下棋者标记
View Code
企业编码管理系统
文件结构
pollcode.py
import os
import qrcode
import random
import time
import tkinter
from pystrich.ean13 import EAN13Encoder
import tkinter.filedialog
import tkinter.messagebox
from string import digits
root = tkinter.Tk() # tkinter模4
# 块为python的标准图形界面接口。本代码的目的是建立根窗口
# 初始化数据
number = "1234567890"
letter = "ABCDEFGHIJKLMNPQRSTUVWXYZ1234567890"
allis = "1234567890ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz!@#$%^&*()_+"
i = 0
randstr = []
fourth = []
fifth = []
randfir = ""
randsec = ""
randthr = ""
str_one = ""
strone = ""
strtwo = ""
nextcard = ""
userput = ""
nres_letter = ""
# 创建文件夹函数
def mkdir(path):
isexists = os.path.exists(path) # 判断文件夹路径是否存在
if not isexists: # 如果文件夹路径不存在
os.mkdir(path) # 创建要创建的文件夹
# 读取文件内容函数
def openfile(filename):
f = open(filename) # 打开指定文件
fllist = f.read() # 读取文件内容
f.close() # 关闭文件
return fllist # 返回读取的文件内容
# 输入验证函数，showstr为input函数提供动态输入提示文字，showorder提供验证方式，length提供要求输入数据的长度
def inputbox(showstr,showorder,length):
instr = input(showstr) # 使用input函数要求用户输入信息，showstr为输入提示文字
if len(instr) != 0: # 输入数据的长度不为零
# 根据输入数据的要求，分成三种验证方式验证，1：数字，不限位数；2：字母；3：数字且有位数要求
if showorder == 1: # 验证方式 ，数字格式，不限位数，大于零的整数
if str.isdigit(instr): # 验证是否为数字
if instr == 0: # 验证数字是否为0，如果是，要求重新输入，返回值为0
print("\033[1;31;40m 输入为零，请重新输入！！\033[0m") # 要求重新输入，返回值为“0”
return "0" # 函数返回值为“0”，为什么返回值为“0”呢？读者思考一下
else: # 如果输入正确，返回输入的数据给返回值
return instr #将输入的数据传给函数返回值
else: # 如果输入不是数字，要求用户重新输入，函数返回值为“0”
print("\033[1;31;40m输入非法，请重新输入！！\033[0m") # 要求用户重新输入
return "0" # 函数返回值为“0”
if showorder == 2: # 验证方式2 ，要求字母格式，且是三个字母
if str.isalpha(instr): # 判断输入是否为字母
if len(instr) != length: # 判断输入的是否为三个字母，如果不是，则要求重新输入，返回值为“0”
print("\033[1;31;40m必须输入三个字母，请重新输入！！\033[0m") # 要求重新输入
return "0" # 返回值为“0”
else: # 如果输入是三个字母，返回输入的字母
return instr # 将函数返回值设置为输入的字母
else: # 如果输入不是字母
print("\033[1;31;40m输入非法，请重新输入！！\033[0m") # 要求重新输入
return "0" # 返回值为“0”
if showorder == 3: # 验证方式3 ，要求数字格式，且输入数字位数有要求
if str.isdigit(instr): # 验证是否为数字
if len(instr) != length: # 验证输入数字是否为要求长度位数，如果不是3位数字，则要求重新输入
print("\033[1;31;40m必须输入" + str(length) + "个数字，请重新输入！！\033[0m") # 要求重新输入
return "0" # 返回值为“0”
else: # 输入数字满足要求，设置函数返回值为输入信息
return instr #设置函数返回值为输入信息
else: # 如果输入不是数字
print("\033[1;31;40m输入非法，请重新输入！！\033[0m") # 提示输入非法，要求重新输入
return "0" # 函数返回值为“0”
else: # 如果没有输入任何内容，即输入为空
print("\033[1;31;40m输入为空，请重新输入！！\033[0m") # 提示输入为空，要求重新输入
return "0" # 函数返回值为“0”
# 实现屏幕输出和文件输出编码信息函数，# sstr参数为输出防伪码数据, sfile为输出的文件名称
# typeis设置输出完成后是否通过信息框提示, smsg为信息提示框的提示文字，datapath 保存防伪码的文件夹
def wfile(sstr, sfile, typeis, smsg,datapath):
mkdir(datapath) # 调用该函数创建文件夹
datafile = datapath + "\\" + sfile # 设置保存防伪码的文件（包含路径）
file = open(datafile, 'w') # 打开保存防伪码的文件，如果文件不存在，则创建该文件
wrlist = sstr # 将防伪码信息赋值给wrlist
pdata = "" # 清空变量pdata，pdata存储屏幕输出的防伪码信息
wdata = "" # 清空变量 wdata ， wdata 存储保存到文本文件的防伪码信息
for i in range(len(wrlist)): # 按条循环读取防伪码数据
wdata = str(wrlist[i].replace('[', '')).replace(']', '') # 去掉字符的中括号
wdata = wdata.replace(''''','').replace(''''', '') # 去掉字符的引号
file.write(str(wdata)) # 写入保存防伪码的文件
pdata = pdata + wdata # 将单条防伪码存储到pdata 变量
file.close() # 关闭文件
print("\033[1;31m" + pdata + "\033[0m") # 屏幕输出生成的防伪码信息
if typeis != "no": # 是否显示“输出完成”的信息提示框。如果typeis的值为“no”,不现显示
# 显示“输出完成”的信息提示框。显示信息包含方位信息码的保存路径
tkinter.messagebox.showinfo("提示", smsg + str(len(randstr)) + "\n 防伪码文件存放位置：" + datafile)
root.withdraw() # 关闭辅助窗口
# 实现屏幕输出和文件输出编码信息，参数schoice设置输出的文件名称
def scode1( schoice):
# 调用inputbox函数对输入数据进行非空、输入合法性判断
incount = inputbox("\033[1;32m 请输入您要生成验证码的数量:\33[0m", 1, 0)
while int(incount) == 0: # 如果输入为字母或数字0,则要求重新输入
incount = inputbox("\033[1;32m 请输入您要生成验证码的数量:\33[0m", 1, 0)
randstr.clear() # 清空保存批量注册码信息的变量randstr
for j in range(int(incount)): # 根据输入的验证码数量循环批量生成注册码
randfir = '' # 设置存储单条注册码的变量为空
for i in range(6): # 循环生成单条注册码
randfir = randfir + random.choice(number) # 产生数字随机因子
randfir = randfir + "\n" # 在单条注册码后面添加转义换行字符“\n”，使验证码单条列显示
randstr.append(randfir) # 将单条注册码添加到保存批量验证码的变量randstr
#调用函数wfile()，实现生成的防伪码屏幕输出和文件输出
wfile(randstr,"scode" + str(schoice) + ".txt", "", "已生成6位防伪码共计：","codepath")
# 生成9位系列产品数字防伪编码函数，参数schoice设置输出的文件名称
def scode2(schoice):
ordstart = inputbox("\033[1;32m 请输入系列产品的数字起始号（3位）:\33[0m", 3, 3)
while int(ordstart) == 0: # 如果输入非法（符号、字母或者数字0都认为是非法输入），重新输入
ordstart = inputbox("\033[1;32m 请输入系列产品的数字起始号（3位）:\33[0m", 3, 3)
ordcount = inputbox("\033[1;32m 请输入产品系列的数量:", 1, 0)
# 如果输入的产品系列数量小于1或者大于9999,,则要求重新输入
while int(ordcount) < 1 or int(ordcount) > 9999:
ordcount = inputbox("\033[1;32m 请输入产品系列的数量:", 1, 0)
incount = inputbox("\033[1;32m 请输入要生成的每个系列产品的防伪码数量:\33[0m", 1, 0)
while int(incount) == 0: # 如果输入为字母或数字0,则要求重新输入
incount = inputbox("\033[1;32m 请输入您要生成验证码的数量:\33[0m", 1, 0)
randstr.clear() # 清空保存批量注册码信息的变量randstr
for m in range(int(ordcount)): # 分类产品编号
for j in range(int(incount)): # 产品防伪码编号
randfir = ''
for i in range(6): # 生成一个不包含类别的产品防伪码
randfir = randfir + random.choice(number) # 每次生成一个随机因子
randstr.append(str(int(ordstart) + m) + randfir + "\n") # 将生成的单条防伪码添加到防伪码列表
#调用函数wfile()，实现生成的防伪码屏幕输出和文件输出
wfile(randstr, "scode" + str(schoice) + ".txt", "", "已生成9位系列产品防伪码共计：","codepath")
# 生成25位混合产品序列号函数，参数schoice设置输出的文件名称
def scode3(schoice):
# 输入要生成的防伪码数量
incount = inputbox("\033[1;32m 请输入要生成的25位混合产品序列号数量:\33[0m", 1, 0)
while int(incount) == 0: # 如果输入非法（符号、字母或者数字0都认为是非法输入），重新输入
incount = inputbox("\033[1;32m 请输入要生成的25位混合产品序列号数量:\33[0m", 1, 0)
randstr.clear() # 清空保存批量注册码信息的变量randstr
for j in range(int(incount)): # 按输入数量生成防伪码
strone = '' # 保存生成的单条防伪码，不带横线“-”，循环时清空
for i in range(25):
strone = strone + random.choice(letter) #每次产生一个随机因子，也就是每次产生单条防伪码的一位
# 将生成的防伪码每隔5位添加横线“-”
strtwo = strone[:5] + "-" + strone[5:10] + "-" + strone[10:15] + "-" + strone[15:20] + "-" + strone[20:25] + "\n"
randstr.append(strtwo) # 添加防伪码到防伪码列表
#调用函数wfile()，实现生成的防伪码屏幕输出和文件输出
wfile(randstr, "scode" + str(schoice) + ".txt", "", "已生成25混合防伪序列码共计：","codepath")
# 生成含数据分析功能防伪编码函数，参数schoice设置输出的文件名称
def scode4(schoice):
intype = inputbox("\033[1;32m 请输入数据分析编号（3位字母）:\33[0m", 2, 3)
# 验证输入是否是三个字母，所以要判断输入是否是字母和输入长度是否为3
while not str.isalpha(intype) or len(intype) != 3:
intype = inputbox("\033[1;32m 请输入数据分析编号（3位字母）:\33[0m", 2, 3)
incount = inputbox("\033[1;32m 请输入要生成的带数据分析功能的验证码数量:\33[0m", 1, 0) #
# 验证输入是否是大于零的整数，判断输入转换为整数值时是否大于零
while int(incount) == 0: # 如果转换为整数时为零，则要求重新输入
incount = inputbox("\033[1;32m 请输入要生成的带数据分析功能的验证码数量:\33[0m", 1, 0) #
ffcode(incount,intype,"",schoice) # 调用 ffcode函数生成注册信息
# 生成含数据分析功能防伪编码函数，参数scount为要生成的防伪码数量，typestr为数据分析字符
# 参数ismessage在输出完成时是否显示提示信息，为“no”不显示，为其他值显示；参数schoice设置输出的文件名称
def ffcode(scount, typestr,ismessage, schoice):
randstr.clear() # 清空保存批量注册码信息的变量randstr
# 按数量生成含数据分析功能注册码
for j in range(int(scount)):
strpro = typestr[0].upper() # 取得三个字母中的第一个字母，并转为大写，区域分析码
strtype = typestr[1].upper() # 取得三个字母中的第二个字母，并转为大写，颜色分析码
strclass = typestr[2].upper() # 取得三个字母中的第三个字母，并转为大写，版本分析码
randfir = random.sample(number, 3) # 随机抽取防伪码中的三个位置，不分先后
randsec = sorted(randfir) # 对抽取的位置进行排序并存储给randsec变量，以便按顺序排列三个字母的位置
letterone = "" # 清空存储单条防伪码的变量letterone
for i in range(9): # 生成9位的数字防伪码
letterone = letterone + random.choice(number)
# 将三个字母按randsec变量中存储的位置值添加到数字防伪码中，并放到sim变量中
sim = str(letterone[0:int(randsec[0])]) + strpro + str(
letterone[int(randsec[0]):int(randsec[1])]) + strtype + str(
letterone[int(randsec[1]):int(randsec[2])]) + strclass + str(letterone[int(randsec[2]):9]) + "\n"
randstr.append(sim) # 将组合生成的新防伪码添加到randstr变量
# 调用wfile()函数，实现生成的防伪码屏幕输出和文件输出
wfile(randstr, typestr + "scode" + str(schoice) + ".txt", ismessage, "生成含数据分析防伪码共计：","codepath")
# 生成含数据分析功能防伪编码函数，参数schoice设置输出的文件名称
def scode5(schoice):
default_dir = r"mrsoft.mri" # 设置默认打开的文件名称
# 打开文件选择对话框，指定打开的文件名称为"mrsoft.mri" ，扩展名为“mri”，可以使用记事本打开和编辑
file_path = tkinter.filedialog.askopenfilename(filetypes=[("Text file","*.mri")],title=u"请选择自动防伪码智能批处理文件：",
initialdir=(os.path.expanduser(default_dir)))
codelist = openfile(file_path) # 读取从文件选择对话框选中的文件
print("前：",codelist)
codelist = codelist.split("\n") # 把读取的信息内容添加回车，以便列输出显示
print("后：",codelist)
for item in codelist: # 按读取的信息循环生成防伪码
codea = item.split(",")[0] # 每一行信息中用 ","分割，","前面的信息存储防伪码标准信息
codeb = item.split(",")[1] # 每一行信息中用 ","分割，","后面的信息存储防伪码生成的数量
ffcode(codeb, codea,"no" ,schoice) # 调用ffcode函数批量生成同一标识信息的防伪码
# 后续补加生成防伪码函数，防伪码格式为带数据分析功能注册码
def scode6(schoice):
default_dir = r"c:\ABDscode5.txt" # 设置默认打开的文件名称
# 按默认的文件名称打开文件选择对话框，用于打开已经存在的防伪码文件
file_path = tkinter.filedialog.askopenfilename(title=u"请选择已经生成的防伪码文件",initialdir=(os.path.expanduser(default_dir)))
codelist = openfile(file_path) # 读取从文件选择对话框选中的文件
codelist = codelist.split("\n") # 把读取的信息内容添加回车，以便列输出显示
codelist.remove("") # 删除列表中的空行
strset = codelist[0] # 读取一行数据，以便获取原验证码的字母标志信息
remove_digits = strset.maketrans("", "", digits) # 用maketrans方法创建删除数字的字符映射转换表
res_letter = strset.translate(remove_digits) # 根据字符映射转换表删除该条防伪码中的数字，获取字母标识信息
nres_letter = list(res_letter) # 把信息用列表变量nres_letter存储
strpro = nres_letter[0] # 从列表变量中取得第一个字母，即区域分析码
strtype = nres_letter[1] # 从列表变量中取得第二个字母，即色彩分析码
strclass = nres_letter[2] # 从列表变量中取得第三个字母，即版次分析码
# 去除信息中的括号和引号
nres_letter = strpro.replace(''''','').replace(''''', '') + strtype.replace(
''''','').replace(''''', '') + strclass.replace(''''','').replace(''''', '')
print("sssssssssss",nres_letter)
card = set(codelist) # 将原有防伪码放到集合变量card中
# 利用tkinter的messagebox提示用户之前生成的防伪码数量
tkinter.messagebox.showinfo("提示", "之前的防伪码共计：" + str(len(card)))
root.withdraw() # 关闭提示信息框
incount = inputbox("请输入补充验证码生成的数量:", 1, 0) # 让用户输入新补充生成的防伪码数量
# 最大值按输入生成数量的2倍数量生成新防伪码，防止新生成防伪码与原有防伪码重复造成新生成的防伪码数量不够,
for j in range(int(incount) * 2):
randfir = random.sample(number, 3) # 随机产生3位不重复的数字
randsec = sorted(randfir) #对产生的数字排序
addcount = len(card) # 记录集合中防伪码的总数量
strone = "" # 清空存储单条防伪码的变量strone
for i in range(9): # 生成9位的数字防伪码
strone = strone + random.choice(number)
# 将三个字母按randsec变量中存储的位置值添加到数字防伪码中，并放到sim变量中
sim = str(strone[0:int(randsec[0])]) + strpro + str(
strone[int(randsec[0]):int(randsec[1])]) + strtype + str(
strone[int(randsec[1]):int(randsec[2])]) + strclass + str(strone[int(randsec[2]):9]) + "\n"
card.add(sim) # 添加新生成的防伪码到集合
# 如果添加到集合,证明生成的防伪码与原有的防伪码没有产生重复
if len(card) > addcount:
randstr.append(sim) # 添加新生成的防伪码到新防伪码列表
addcount = len(card) # 记录最添加新生成防伪码集合的防伪码数量
if len(randstr) >= int(incount): # 如果新防伪码列表中的防伪码数量达到输入的防伪码数量
print(len(randstr)) # 输出已生成防伪码的数量
break # 退出循环
# 调用函数wfile()函数，实现生成的防伪码屏幕输出和文件输出
wfile(randstr, nres_letter + "ncode" + str(choice) + ".txt", nres_letter, "生成后补防伪码共计：","codeadd")
# tkinter.messagebox.showinfo("提示", "已生成补充防伪码共：" + str(len(randstr))) # 提示
# root.withdraw()
# 条形码EAN13批量生成函数
def scode7(schoice):
mainid = inputbox("\033[1;32m 请输入EN13的国家代码（3位） :\33[0m", 3, 3) # 输入3位国家代码
# while int(mainid) < 1 or len(mainid) != 3: # 验证输入是否为3位数字（转为整数后小于1和长度不等于3，重新输入）
# mainid = inputbox("\033[1;32m 请输入EAN13的国家代码（3位）::\33[0m", 1, 0)
compid = inputbox("\033[1;32m 请输入EAN13的企业代码（4位）:\33[0m", 3, 4) # 输入4位企业代码
# while int(compid) < 1 or len(compid) != 4: # 验证输入是否为4位数字
# compid = inputbox("\033[1;32m 请输入EAN13的企业代码（4位）:\33[0m", 1, 0)
incount = inputbox("\033[1;32m 请输入要生成的条形码数量:\33[0m", 1, 0) # 输入要生成的条形码数量
while int(incount) == 0: # 输入信息转为整数后等于0，重新输入
incount = inputbox("\033[1;32m 请输入要生成的条形码数量:\33[0m", 1, 0)
mkdir("barcode") # 判断保存条形码的文件夹是否存在，不存在，则创建该文件夹
for j in range(int(incount)): # 批量生成条形码
strone = '' # 清空存储单条条形码的变量
for i in range(5): # 生成条形码的6位（除国家代码、企业代码和校验位之外的6位）数字
strone = strone + str(random.choice(number))
barcode=mainid +compid +strone # 把国家代码、企业代码和新生成的随机码进行组合
# 计算条形码的校验位
evensum = int(barcode[1]) + int(barcode[3]) + int(barcode[5]) + int(barcode[7]) + int(barcode[9]) +int(barcode[11]) # 偶数位
oddsum =int( barcode[0])+int(barcode[2])+int(barcode[4])+int(barcode[6])+int(barcode[8]) +int(barcode[10])
# checkbit=int(10-(evensum *3 + oddsum)%10)
checkbit = int((10 - (evensum * 3 + oddsum) %10)% 10)
barcode=barcode+str(checkbit) # 组成完整的EAN13条形码的13位数字
print (barcode)
encoder = EAN13Encoder(barcode) # 调用EAN13Encoder生成条形码
encoder.save("barcode\\" + barcode + ".png") # 保存条形码信息图片到文件
# 本函数生成固定的12位二维码，读者可以根据实际需要修改成按输入位数进行生成的函数
def scode8(schoice):
# 输入要生成的二维码数量
incount = inputbox("\033[1;32m 请输入要生成的12位数字二维码数量:\33[0m", 1, 0)
while int(incount) == 0: # 如果输入不是大于0的数字，重新输入
incount = inputbox("\033[1;32m 请输入要生成的12位数字二维码数量:\33[0m", 1, 0)
mkdir("qrcode") # 判断保存二维码的文件夹是否存在，不存在，则创建该文件夹
for j in range(int(incount)): # 批量生成二维码
strone = '' # 清空存储单条二维码的变量
for i in range(12): # 生成单条二维码数字
strone = strone + str(random.choice(number))
encoder =qrcode.make(strone) # 生成二维码
encoder.save("qrcode\\" + strone + ".png") # 保存二维码图片到文件
#抽奖函数
def scode9(schoice):
default_dir = r"lottery.ini" # 设置默认打开文件为开发路径下的"lottery.ini"
# 选择包含用户抽奖信息票号的文件，扩展名为“*.ini”
file_path = tkinter.filedialog.askopenfilename(filetypes=[("Ini file","*.ini")],title=u"请选择包含抽奖号码的抽奖文件：",initialdir=(os.path.expanduser(default_dir)))
codelist = openfile(file_path) # 调用 openfile()函数读取刚打开的抽奖文件
codelist = codelist.split("\n") # 通过回行转义符把抽奖信息分割成抽奖数列
incount = inputbox("\033[1;32m 请输入要生成的中奖数量:\33[0m", 1, 0) # 要求用户输入中（抽）奖数量
while int(incount) == 0 or len(codelist)< int(incount): # 如果输入中（抽）奖数量等于0或超过抽奖数组数量，重新输入
incount = inputbox("\033[1;32m 请输入要生成的抽奖数量:\33[0m", 1, 0)
strone = random.sample(codelist,int(incount)) # 根据输入的中奖数量进行抽奖
print("\033[1;35m 抽奖信息名单发布： \33[0m")
for i in range(int(incount)): # 循环将抽奖数列的引号和中括号去掉
wdata = str(strone[i].replace('[', '')).replace(']', '') # 将抽奖数列的中括号去掉
wdata = wdata.replace(''''','').replace(''''', '') # 将抽奖数列的引号去掉
print("\033[1;32m " + wdata + "\33[0m") # 输出中奖信息
# 输入数字验证，判断输入是否在0-9之间的整数
def input_validation(insel):
if str.isdigit(insel):
insel = int(insel)
# if insel == 0:
# # print("\033[1;31;40m 输入非法，请重新输入！！\033[0m")
# return 0
# else:
# return insel
return insel
else:
print("\033[1;31;40m 输入非法，请重新输入！！\033[0m")
return 0
# 企业编码管理系统主菜单
def mainmenu():
# os.system("clear")
print("""\033[1;35m
****************************************************************
企业编码生成系统
****************************************************************
1.生成6位数字防伪编码 （213563型）
2.生成9位系列产品数字防伪编码(879-335439型)
3.生成25位混合产品序列号(B2R12-N7TE8-9IET2-FE35O-DW2K4型)
4.生成含数据分析功能的防伪编码(5A61M0583D2)
5.智能批量生成带数据分析功能的防伪码
6.后续补加生成防伪码(5A61M0583D2)
7.EAN-13条形码批量生成
8.二维码批量输出
9.企业粉丝防伪码抽奖
0.退出系统
================================================================
说明：通过数字键选择菜单
================================================================
\033[0m""")
def codeprint(cstr, cint):
str1 = cstr[0]
str2 = cstr[1]
str3 = cstr[2]
for i in range(int(cint)):
strbook = str1 + str2 + random.choice(letter) + random.choice(letter) + random.choice(letter) + str2 + str3
print(strbook)
# 通过循环控制用户对程序功能的选择
while i < 9:
# 调入程序主界面菜单
mainmenu()
# 键盘输入需要操作的选项
choice = input("\033[1;32m 请输入您要操作的菜单选项:\33[0m")
if len(choice) != 0: # 输入如果不为空
choice = input_validation(choice) # 验证输入是否为数字
if choice == 1:
scode1( str(choice)) # 如果输入大于零的整数，调用scode1()函数生成注册码
# 选择菜单2,调用scode2()函数生成9位系列产品数字防伪编码
if choice == 2:
scode2(choice)
# 选择菜单3,调用scode3()函数生成25位混合产品序列号
if choice == 3:
scode3(choice)
# 选择菜单4,调用scode4()函数生成含数据分析功能的防伪编码
if choice == 4:
scode4(choice)
# 选择菜单5,调用scode5()函数智能批量生成带数据分析功能的防伪码
if choice == 5:
scode5(choice)
# 选择菜单６,调用scode6()函数后续补加生成防伪码
if choice == 6:
scode6(choice)
# 选择菜单7,调用scode7()函数批量生成条形码
if choice == 7:
scode7( choice)
# 选择菜单8,调用scode8()函数批量生成二维码
if choice == 8:
scode8( choice)
# 选择菜单9,调用scode9()函数生成企业粉丝抽奖程序
if choice == 9:
scode9( choice)
# 选择菜单0,退出系统
if choice == 0:
i = 0
print("正在退出系统!!")
break
else:
print("\033[1;31;40m 输入非法，请重新输入！！\033[0m")
time.sleep(2)
View Code
学生信息管理系统
文件结构
studentsystem.py
# 文件名称：studentsystem.py
# 开发工具：PyCharm
import re # 导入正则表达式模块
import os # 导入操作系统模块
filename = "students.txt" # 定义保存学生信息的文件名
def menu():
# 输出菜单
print('''
╔———————学生信息管理系统————————╗
│ │
│ =============== 功能菜单 =============== │
│ │
│ 1 录入学生信息 │
│ 2 查找学生信息 │
│ 3 删除学生信息 │
│ 4 修改学生信息 │
│ 5 排序 │
│ 6 统计学生总人数 │
│ 7 显示所有学生信息 │
│ 0 退出系统 │
│ ========================================== │
│ 说明：通过数字或↑↓方向键选择菜单 │
╚———————————————————————╝
''')
def main():
ctrl = True # 标记是否退出系统
while (ctrl):
menu() # 显示菜单
option = input("请选择：") # 选择菜单项
option_str = re.sub("\D", "", option) # 提取数字
if option_str in ['0', '1', '2', '3', '4', '5', '6', '7']:
option_int = int(option_str)
if option_int == 0: # 退出系统
print('您已退出学生成绩管理系统！')
ctrl = False
elif option_int == 1: # 录入学生成绩信息
insert()
elif option_int == 2: # 查找学生成绩信息
search()
elif option_int == 3: # 删除学生成绩信息
delete()
elif option_int == 4: # 修改学生成绩信息
modify()
elif option_int == 5: # 排序
sort()
elif option_int == 6: # 统计学生总数
total()
elif option_int == 7: # 显示所有学生信息
show()
'''1 录入学生信息'''
def insert():
stdentList = [] # 保存学生信息的列表
mark = True # 是否继续添加
while mark:
id = input("请输入ID（如 1001）：")
if not id: # ID为空，跳出循环
break
name = input("请输入名字：")
if not name: # 名字为空，跳出循环
break
try:
english = int(input("请输入英语成绩："))
python = int(input("请输入Python成绩："))
c = int(input("请输入C语言成绩："))
except:
print("输入无效，不是整型数值．．．．重新录入信息")
continue
stdent = {"id": id, "name": name, "english": english, "python": python, "c": c} # 将输入的学生信息保存到字典
stdentList.append(stdent) # 将学生字典添加到列表中
inputMark = input("是否继续添加？（y/n）:")
if inputMark == "y": # 继续添加
mark = True
else: # 不继续添加
mark = False
save(stdentList) # 将学生信息保存到文件
print("学生信息录入完毕！！！")
# 将学生信息保存到文件
def save(student):
try:
students_txt = open(filename, "a") # 以追加模式打开
except Exception as e:
students_txt = open(filename, "w") # 文件不存在，创建文件并打开
for info in student:
students_txt.write(str(info) + "\n") # 按行存储，添加换行符
students_txt.close() # 关闭文件
'''2 查找学生成绩信息'''
def search():
mark = True
student_query = [] # 保存查询结果的学生列表
while mark:
id = ""
name = ""
if os.path.exists(filename): # 判断文件是否存在
mode = input("按ID查输入1；按姓名查输入2：")
if mode == "1":
id = input("请输入学生ID：")
elif mode == "2":
name = input("请输入学生姓名：")
else:
print("您的输入有误，请重新输入！")
search() # 重新查询
with open(filename, 'r') as file: # 打开文件
student = file.readlines() # 读取全部内容
for list in student:
d = dict(eval(list)) # 字符串转字典
if id is not "": # 判断是否按ID查
if d['id'] == id:
student_query.append(d) # 将找到的学生信息保存到列表中
elif name is not "": # 判断是否按姓名查
if d['name'] == name:
student_query.append(d) # 将找到的学生信息保存到列表中
show_student(student_query) # 显示查询结果
student_query.clear() # 清空列表
inputMark = input("是否继续查询？（y/n）:")
if inputMark == "y":
mark = True
else:
mark = False
else:
print("暂未保存数据信息...")
return
'''3 删除学生成绩信息'''
def delete():
mark = True # 标记是否循环
while mark:
studentId = input("请输入要删除的学生ID：")
if studentId is not "": # 判断要删除的学生是否存在
if os.path.exists(filename): # 判断文件是否存在
with open(filename, 'r') as rfile: # 打开文件
student_old = rfile.readlines() # 读取全部内容
else:
student_old = []
ifdel = False # 标记是否删除
if student_old: # 如果存在学生信息
with open(filename, 'w') as wfile: # 以写方式打开文件
d = {} # 定义空字典
for list in student_old:
d = dict(eval(list)) # 字符串转字典
if d['id'] != studentId:
wfile.write(str(d) + "\n") # 将一条学生信息写入文件
else:
ifdel = True # 标记已经删除
if ifdel:
print("ID为 %s 的学生信息已经被删除..." % studentId)
else:
print("没有找到ID为 %s 的学生信息..." % studentId)
else: # 不存在学生信息
print("无学生信息...")
break # 退出循环
show() # 显示全部学生信息
inputMark = input("是否继续删除？（y/n）:")
if inputMark == "y":
mark = True # 继续删除
else:
mark = False # 退出删除学生信息功能
'''4 修改学生成绩信息'''
def modify():
show() # 显示全部学生信息
if os.path.exists(filename): # 判断文件是否存在
with open(filename, 'r') as rfile: # 打开文件
student_old = rfile.readlines() # 读取全部内容
else:
return
studentid = input("请输入要修改的学生ID：")
with open(filename, "w") as wfile: # 以写模式打开文件
for student in student_old:
d = dict(eval(student)) # 字符串转字典
if d["id"] == studentid: # 是否为要修改的学生
print("找到了这名学生，可以修改他的信息！")
while True: # 输入要修改的信息
try:
d["name"] = input("请输入姓名：")
d["english"] = int(input("请输入英语成绩："))
d["python"] = int(input("请输入Python成绩："))
d["c"] = int(input("请输入C语言成绩："))
except:
print("您的输入有误，请重新输入。")
else:
break # 跳出循环
student = str(d) # 将字典转换为字符串
wfile.write(student + "\n") # 将修改的信息写入到文件
print("修改成功！")
else:
wfile.write(student) # 将未修改的信息写入到文件
mark = input("是否继续修改其他学生信息？（y/n）：")
if mark == "y":
modify() # 重新执行修改操作
'''5 排序'''
def sort():
show() # 显示全部学生信息
if os.path.exists(filename): # 判断文件是否存在
with open(filename, 'r') as file: # 打开文件
student_old = file.readlines() # 读取全部内容
student_new = []
for list in student_old:
d = dict(eval(list)) # 字符串转字典
student_new.append(d) # 将转换后的字典添加到列表中
else:
return
ascORdesc = input("请选择（0升序；1降序）：")
if ascORdesc == "0": # 按升序排序
ascORdescBool = False # 标记变量，为False表示升序排序
elif ascORdesc == "1": # 按降序排序
ascORdescBool = True # 标记变量，为True表示降序排序
else:
print("您的输入有误，请重新输入！")
sort()
mode = input("请选择排序方式（1按英语成绩排序；2按Python成绩排序；3按C语言成绩排序；0按总成绩排序）：")
if mode == "1": # 按英语成绩排序
student_new.sort(key=lambda x: x["english"], reverse=ascORdescBool)
elif mode == "2": # 按Python成绩排序
student_new.sort(key=lambda x: x["python"], reverse=ascORdescBool)
elif mode == "3": # 按C语言成绩排序
student_new.sort(key=lambda x: x["c"], reverse=ascORdescBool)
elif mode == "0": # 按总成绩排序
student_new.sort(key=lambda x: x["english"] + x["python"] + x["c"], reverse=ascORdescBool)
else:
print("您的输入有误，请重新输入！")
sort()
show_student(student_new) # 显示排序结果
''' 6 统计学生总数'''
def total():
if os.path.exists(filename): # 判断文件是否存在
with open(filename, 'r') as rfile: # 打开文件
student_old = rfile.readlines() # 读取全部内容
if student_old:
print("一共有 %d 名学生！" % len(student_old))
else:
print("还没有录入学生信息！")
else:
print("暂未保存数据信息...")
''' 7 显示所有学生信息 '''
def show():
student_new = []
if os.path.exists(filename): # 判断文件是否存在
with open(filename, 'r') as rfile: # 打开文件
student_old = rfile.readlines() # 读取全部内容
for list in student_old:
student_new.append(eval(list)) # 将找到的学生信息保存到列表中
if student_new:
show_student(student_new)
else:
print("暂未保存数据信息...")
# 将保存在列表中的学生信息显示出来
def show_student(studentList):
if not studentList:
print("(o@.@o) 无数据信息 (o@.@o) \n")
return
format_title = "{:^6}{:^12}\t{:^8}\t{:^10}\t{:^10}\t{:^10}"
print(format_title.format("ID", "名字", "英语成绩", "Python成绩", "C语言成绩", "总成绩"))
format_data = "{:^6}{:^12}\t{:^12}\t{:^12}\t{:^12}\t{:^12}"
for info in studentList:
print(format_data.format(info.get("id"), info.get("name"), str(info.get("english")), str(info.get("python")),
str(info.get("c")),
str(info.get("english") + info.get("python") + info.get("c")).center(12)))
if __name__ == "__main__":
main()
View Code