devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

用python做一个小项目,python做简单小项目_python项目开发案例

作者：花生_TL007 | 2024-03-01 06:49:03

赞

踩

python项目开发案例

大家好，小编来为大家解答以下问题，用python做一个小项目，python做简单小项目，现在让我们一起来看看吧！

今天分享7个学妹看见都惊呆的 Python 小项目！【附源码】

建议收藏

界面应用

1、计算器

1. 案例介绍

本例利用 Python 开发一个可以进行简单的四则运算的图形化计算器，会用到 Tkinter 图形组件进行开发。主要知识点：Python Tkinter 界面编程；计算器逻辑运算实现学c+还是python。本例难度为初级，适合具有 Python 基础和 Tkinter 组件编程知识的用户学习。

2. 设计原理

要制作一个计算器，首先需要知道它由哪些部分组成。示意如下图所示。

22c9ab73e86152abcafc6b4ee51ea3e0.png

从结构上来说，一个简单的图形界面，需要由界面组件、组件的事件监听器(响应各类事件的逻辑)和具体的事件处理逻辑组成。界面实现的主要工作是创建各个界面组件对象，对其进行初始化，以及控制各组件之间的层次关系和布局。

3. 示例效果

98a446fb70b311bf0b89ca0959bf779a.gif

4. 示例源码

  1. import tkinter
  2. import math
  3. import tkinter.messagebox
  4.  
  5.  
  6. class Calculator(object):
  7.     # 界面布局方法
  8.     def __init__(self):
  9.         # 创建主界面，并且保存到成员属性中
  10.         self.root = tkinter.Tk()
  11.         self.root.minsize(280, 450)
  12.         self.root.maxsize(280, 470)
  13.         self.root.title('计算器')
  14.         # 设置显式面板的变量
  15.         self.result = tkinter.StringVar()
  16.         self.result.set(0)
  17.         # 设置一个全局变量  运算数字和f符号的列表
  18.         self.lists = []
  19.         # 添加一个用于判断是否按下运算符号的标志
  20.         self.ispresssign = False
  21.         # 界面布局
  22.         self.menus()
  23.         self.layout()
  24.         self.root.mainloop()
  25.  
  26.     # 计算器菜单界面摆放
  27.  
  28.     def menus(self):
  29.         # 添加菜单
  30.         # 创建总菜单
  31.         allmenu = tkinter.Menu(self.root)
  32.         # 添加子菜单
  33.         filemenu = tkinter.Menu(allmenu, tearoff=0)
  34.         # 添加选项卡
  35.         filemenu.add_command(
  36.             label='标准型(T)            Alt+1', command=self.myfunc)
  37.         filemenu.add_command(
  38.             label='科学型(S)            Alt+2', command=self.myfunc)
  39.         filemenu.add_command(
  40.             label='程序员(P)            Alt+3', command=self.myfunc)
  41.         filemenu.add_command(label='统计信息(A)        Alt+4', command=self.myfunc)
  42.         # 添加分割线
  43.         filemenu.add_separator()
  44.         # 添加选项卡
  45.         filemenu.add_command(label='历史记录(Y)      Ctrl+H', command=self.myfunc)
  46.         filemenu.add_command(label='数字分组(I)', command=self.myfunc)
  47.         # 添加分割线
  48.         filemenu.add_separator()
  49.         # 添加选项卡
  50.         filemenu.add_command(
  51.             label='基本(B)             Ctrl+F4', command=self.myfunc)
  52.         filemenu.add_command(label='单位转换(U)      Ctrl+U', command=self.myfunc)
  53.         filemenu.add_command(label='日期计算(D)      Ctrl+E', command=self.myfunc)
  54.         menu1 = tkinter.Menu(filemenu, tearoff=0)
  55.         menu1.add_command(label='抵押(M)', command=self.myfunc)
  56.         menu1.add_command(label='汽车租赁(V)', command=self.myfunc)
  57.         menu1.add_command(label='油耗(mpg)(F)', command=self.myfunc)
  58.         menu1.add_command(label='油耗(l/100km)(U)', command=self.myfunc)
  59.         filemenu.add_cascade(label='工作表(W)', menu=menu1)
  60.         allmenu.add_cascade(label='查看(V)', menu=filemenu)
  61.  
  62.         # 添加子菜单2
  63.         editmenu = tkinter.Menu(allmenu, tearoff=0)
  64.         # 添加选项卡
  65.         editmenu.add_command(label='复制(C)         Ctrl+C', command=self.myfunc)
  66.         editmenu.add_command(label='粘贴(V)         Ctrl+V', command=self.myfunc)
  67.         # 添加分割线
  68.         editmenu.add_separator()
  69.         # 添加选项卡
  70.         menu2 = tkinter.Menu(filemenu, tearoff=0)
  71.         menu2.add_command(label='复制历史记录(I)', command=self.myfunc)
  72.         menu2.add_command(
  73.             label='编辑(E)                      F2', command=self.myfunc)
  74.         menu2.add_command(label='取消编辑(N)            Esc', command=self.myfunc)
  75.         menu2.add_command(label='清除(L)    Ctrl+Shift+D', command=self.myfunc)
  76.         editmenu.add_cascade(label='历史记录(H)', menu=menu2)
  77.         allmenu.add_cascade(label='编辑(E)', menu=editmenu)
  78.  
  79.         # 添加子菜单3
  80.         helpmenu = tkinter.Menu(allmenu, tearoff=0)
  81.         # 添加选项卡
  82.         helpmenu.add_command(label='查看帮助(V)       F1', command=self.myfunc)
  83.         # 添加分割线
  84.         helpmenu.add_separator()
  85.         # 添加选项卡
  86.         helpmenu.add_command(label='关于计算器(A)', command=self.myfunc)
  87.         allmenu.add_cascade(label='帮助(H)', menu=helpmenu)
  88.  
  89.         self.root.config(menu=allmenu)
  90.  
  91.     # 计算器主界面摆放
  92.  
  93.     def layout(self):
  94.         # 显示屏
  95.         result = tkinter.StringVar()
  96.         result.set(0)
  97.         show_label = tkinter.Label(self.root, bd=3, bg='white', font=(
  98.             '宋体', 30), anchor='e', textvariable=self.result)
  99.         show_label.place(x=5, y=20, width=270, height=70)
  100.         # 功能按钮MC
  101.         button_mc = tkinter.Button(self.root, text='MC', command=self.wait)
  102.         button_mc.place(x=5, y=95, width=50, height=50)
  103.         # 功能按钮MR
  104.         button_mr = tkinter.Button(self.root, text='MR', command=self.wait)
  105.         button_mr.place(x=60, y=95, width=50, height=50)
  106.         # 功能按钮MS
  107.         button_ms = tkinter.Button(self.root, text='MS', command=self.wait)
  108.         button_ms.place(x=115, y=95, width=50, height=50)
  109.         # 功能按钮M+
  110.         button_mjia = tkinter.Button(self.root, text='M+', command=self.wait)
  111.         button_mjia.place(x=170, y=95, width=50, height=50)
  112.         # 功能按钮M-
  113.         button_mjian = tkinter.Button(self.root, text='M-', command=self.wait)
  114.         button_mjian.place(x=225, y=95, width=50, height=50)
  115.         # 功能按钮←
  116.         button_zuo = tkinter.Button(self.root, text='←', command=self.dele_one)
  117.         button_zuo.place(x=5, y=150, width=50, height=50)
  118.         # 功能按钮CE
  119.         button_ce = tkinter.Button(
  120.             self.root, text='CE', command=lambda: self.result.set(0))
  121.         button_ce.place(x=60, y=150, width=50, height=50)
  122.         # 功能按钮C
  123.         button_c = tkinter.Button(self.root, text='C', command=self.sweeppress)
  124.         button_c.place(x=115, y=150, width=50, height=50)
  125.         # 功能按钮±
  126.         button_zf = tkinter.Button(self.root, text='±', command=self.zf)
  127.         button_zf.place(x=170, y=150, width=50, height=50)
  128.         # 功能按钮√
  129.         button_kpf = tkinter.Button(self.root, text='√', command=self.kpf)
  130.         button_kpf.place(x=225, y=150, width=50, height=50)
  131.         # 数字按钮7
  132.         button_7 = tkinter.Button(
  133.             self.root, text='7', command=lambda: self.pressnum('7'))
  134.         button_7.place(x=5, y=205, width=50, height=50)
  135.         # 数字按钮8
  136.         button_8 = tkinter.Button(
  137.             self.root, text='8', command=lambda: self.pressnum('8'))
  138.         button_8.place(x=60, y=205, width=50, height=50)
  139.         # 数字按钮9
  140.         button_9 = tkinter.Button(
  141.             self.root, text='9', command=lambda: self.pressnum('9'))
  142.         button_9.place(x=115, y=205, width=50, height=50)
  143.         # 功能按钮/
  144.         button_division = tkinter.Button(
  145.             self.root, text='/', command=lambda: self.presscalculate('/'))
  146.         button_division.place(x=170, y=205, width=50, height=50)
  147.         # 功能按钮%
  148.         button_remainder = tkinter.Button(
  149.             self.root, text='//', command=lambda: self.presscalculate('//'))
  150.         button_remainder.place(x=225, y=205, width=50, height=50)
  151.         # 数字按钮4
  152.         button_4 = tkinter.Button(
  153.             self.root, text='4', command=lambda: self.pressnum('4'))
  154.         button_4.place(x=5, y=260, width=50, height=50)
  155.         # 数字按钮5
  156.         button_5 = tkinter.Button(
  157.             self.root, text='5', command=lambda: self.pressnum('5'))
  158.         button_5.place(x=60, y=260, width=50, height=50)
  159.         # 数字按钮6
  160.         button_6 = tkinter.Button(
  161.             self.root, text='6', command=lambda: self.pressnum('6'))
  162.         button_6.place(x=115, y=260, width=50, height=50)
  163.         # 功能按钮*
  164.         button_multiplication = tkinter.Button(
  165.             self.root, text='*', command=lambda: self.presscalculate('*'))
  166.         button_multiplication.place(x=170, y=260, width=50, height=50)
  167.         # 功能按钮1/x
  168.         button_reciprocal = tkinter.Button(
  169.             self.root, text='1/x', command=self.ds)
  170.         button_reciprocal.place(x=225, y=260, width=50, height=50)
  171.         # 数字按钮1
  172.         button_1 = tkinter.Button(
  173.             self.root, text='1', command=lambda: self.pressnum('1'))
  174.         button_1.place(x=5, y=315, width=50, height=50)
  175.         # 数字按钮2
  176.         button_2 = tkinter.Button(
  177.             self.root, text='2', command=lambda: self.pressnum('2'))
  178.         button_2.place(x=60, y=315, width=50, height=50)
  179.         # 数字按钮3
  180.         button_3 = tkinter.Button(
  181.             self.root, text='3', command=lambda: self.pressnum('3'))
  182.         button_3.place(x=115, y=315, width=50, height=50)
  183.         # 功能按钮-
  184.         button_subtraction = tkinter.Button(
  185.             self.root, text='-', command=lambda: self.presscalculate('-'))
  186.         button_subtraction.place(x=170, y=315, width=50, height=50)
  187.         # 功能按钮=
  188.         button_equal = tkinter.Button(
  189.             self.root, text='=', command=lambda: self.pressequal())
  190.         button_equal.place(x=225, y=315, width=50, height=105)
  191.         # 数字按钮0
  192.         button_0 = tkinter.Button(
  193.             self.root, text='0', command=lambda: self.pressnum('0'))
  194.         button_0.place(x=5, y=370, width=105, height=50)
  195.         # 功能按钮.
  196.         button_point = tkinter.Button(
  197.             self.root, text='.', command=lambda: self.pressnum('.'))
  198.         button_point.place(x=115, y=370, width=50, height=50)
  199.         # 功能按钮+
  200.         button_plus = tkinter.Button(
  201.             self.root, text='+', command=lambda: self.presscalculate('+'))
  202.         button_plus.place(x=170, y=370, width=50, height=50)
  203.  
  204.     # 计算器菜单功能
  205.  
  206.     def myfunc(self):
  207.         tkinter.messagebox.showinfo('', '预留接口，学成之后，你是不是有冲动添加该功能.')
  208.  
  209.     # 数字方法
  210.     def pressnum(self, num):
  211.         # 全局化变量
  212.         # 判断是否按下了运算符号
  213.         if self.ispresssign == False:
  214.             pass
  215.         else:
  216.             self.result.set(0)
  217.             # 重置运算符号的状态
  218.             self.ispresssign = False
  219.         if num == '.':
  220.             num = '0.'
  221.         # 获取面板中的原有数字
  222.         oldnum = self.result.get()
  223.         # 判断界面数字是否为0
  224.         if oldnum == '0':
  225.             self.result.set(num)
  226.         else:
  227.             # 连接上新按下的数字
  228.             newnum = oldnum + num
  229.  
  230.             # 将按下的数字写到面板中
  231.             self.result.set(newnum)
  232.  
  233.     # 运算函数
  234.     def presscalculate(self, sign):
  235.         # 保存已经按下的数字和运算符号
  236.         # 获取界面数字
  237.         num = self.result.get()
  238.         self.lists.append(num)
  239.         # 保存按下的操作符号
  240.         self.lists.append(sign)
  241.         # 设置运算符号为按下状态
  242.         self.ispresssign = True
  243.  
  244.     # 获取运算结果
  245.  
  246.     def pressequal(self):
  247.         # 获取所有的列表中的内容（之前的数字和操作）
  248.         # 获取当前界面上的数字
  249.         curnum = self.result.get()
  250.         # 将当前界面的数字存入列表
  251.         self.lists.append(curnum)
  252.         # 将列表转化为字符串
  253.         calculatestr = ''.join(self.lists)
  254.         # 使用eval执行字符串中的运算即可
  255.         endnum = eval(calculatestr)
  256.         # 将运算结果显示在界面中
  257.         self.result.set(str(endnum)[:10])
  258.         if self.lists != 0:
  259.             self.ispresssign = True
  260.         # 清空运算列表
  261.         self.lists.clear()
  262.  
  263.     # 暂未开发说明
  264.  
  265.     def wait(self):
  266.         tkinter.messagebox.showinfo('', '更新中......')
  267.  
  268.     # ←按键功能
  269.  
  270.     def dele_one(self):
  271.         if self.result.get() == '' or self.result.get() == '0':
  272.             self.result.set('0')
  273.             return
  274.         else:
  275.             num = len(self.result.get())
  276.             if num > 1:
  277.                 strnum = self.result.get()
  278.                 strnum = strnum[0:num - 1]
  279.                 self.result.set(strnum)
  280.             else:
  281.                 self.result.set('0')
  282.  
  283.     # ±按键功能
  284.  
  285.     def zf(self):
  286.         strnum = self.result.get()
  287.         if strnum[0] == '-':
  288.             self.result.set(strnum[1:])
  289.         elif strnum[0] != '-' and strnum != '0':
  290.             self.result.set('-' + strnum)
  291.  
  292.     # 1/x按键功能
  293.  
  294.     def ds(self):
  295.         dsnum = 1 / int(self.result.get())
  296.         self.result.set(str(dsnum)[:10])
  297.         if self.lists != 0:
  298.             self.ispresssign = True
  299.         # 清空运算列表
  300.         self.lists.clear()
  301.  
  302.     # C按键功能
  303.  
  304.     def sweeppress(self):
  305.         self.lists.clear()
  306.         self.result.set(0)
  307.  
  308.     # √按键功能
  309.  
  310.     def kpf(self):
  311.         strnum = float(self.result.get())
  312.         endnum = math.sqrt(strnum)
  313.         if str(endnum)[-1] == '0':
  314.             self.result.set(str(endnum)[:-2])
  315.         else:
  316.             self.result.set(str(endnum)[:10])
  317.         if self.lists != 0:
  318.             self.ispresssign = True
  319.         # 清空运算列表
  320.         self.lists.clear()
  321.  
  322.  
  323. # 实例化对象
  324. my_calculator = Calculator()

2、记事本

1. 案例介绍

tkinter 是 Python下面向 tk 的图形界面接口库，可以方便地进行图形界面设计和交互操作编程。tkinter 的优点是简单易用、与 Python 的结合度好。tkinter 在 Python 3.x 下默认集成，不需要额外的安装操作；不足之处为缺少合适的可视化界面设计工具，需要通过代码来完成窗口设计和元素布局。本例采用的 Python 版本为 3.8，如果想在 python 2.x下使用 tkinter，请先进行安装。需要注意的是，不同 Python 版本下的 tkinter 使用方式可能略有不同，建议采用 Python3.x 版本。本例难度为中级，适合具有 Python 基础和 Tkinter 组件编程知识的用户学习。

2. 示例效果

a9bc1f29c0ac39b5577d2bc616f4ea89.gif

3. 示例源码

  1. from tkinter import *
  2. from tkinter.filedialog import *
  3. from tkinter.messagebox import *
  4. import os
  5.  
  6. filename = ""
  7.  
  8.  
  9. def author():
  10.     showinfo(title="作者", message="Python")
  11.  
  12.  
  13. def power():
  14.     showinfo(title="版权信息", message="课堂练习")
  15.  
  16.  
  17. def mynew():
  18.     global top, filename, textPad
  19.     top.title("未命名文件")
  20.     filename = None
  21.     textPad.delete(1.0, END)
  22.  
  23.  
  24. def myopen():
  25.     global filename
  26.     filename = askopenfilename(defaultextension=".txt")
  27.     if filename == "":
  28.         filename = None
  29.     else:
  30.         top.title("记事本" + os.path.basename(filename))
  31.         textPad.delete(1.0, END)
  32.         f = open(filename, 'r')
  33.         textPad.insert(1.0, f.read())
  34.         f.close()
  35.  
  36.  
  37. def mysave():
  38.     global filename
  39.     try:
  40.         f = open(filename, 'w')
  41.         msg = textPad.get(1.0, 'end')
  42.         f.write(msg)
  43.         f.close()
  44.     except:
  45.         mysaveas()
  46.  
  47.  
  48. def mysaveas():
  49.     global filename
  50.     f = asksaveasfilename(initialfile="未命名.txt", defaultextension=".txt")
  51.     filename = f
  52.     fh = open(f, 'w')
  53.     msg = textPad.get(1.0, END)
  54.     fh.write(msg)
  55.     fh.close()
  56.     top.title("记事本 " + os.path.basename(f))
  57.  
  58.  
  59. def cut():
  60.     global textPad
  61.     textPad.event_generate("<<Cut>>")
  62.  
  63.  
  64. def copy():
  65.     global textPad
  66.     textPad.event_generate("<<Copy>>")
  67.  
  68.  
  69. def paste():
  70.     global textPad
  71.     textPad.event_generate("<<Paste>>")
  72.  
  73.  
  74. def undo():
  75.     global textPad
  76.     textPad.event_generate("<<Undo>>")
  77.  
  78.  
  79. def redo():
  80.     global textPad
  81.     textPad.event_generate("<<Redo>>")
  82.  
  83.  
  84. def select_all():
  85.     global textPad
  86.     # textPad.event_generate("<<Cut>>")
  87.     textPad.tag_add("sel", "1.0", "end")
  88.  
  89.  
  90. def find():
  91.     t = Toplevel(top)
  92.     t.title("查找")
  93.     t.geometry("260x60+200+250")
  94.     t.transient(top)
  95.     Label(t, text="查找：").grid(row=0, column=0, sticky="e")
  96.     v = StringVar()
  97.     e = Entry(t, width=20, textvariable=v)
  98.     e.grid(row=0, column=1, padx=2, pady=2, sticky="we")
  99.     e.focus_set()
  100.     c = IntVar()
  101.     Checkbutton(t, text="不区分大小写", variable=c).grid(row=1, column=1, sticky='e')
  102.     Button(t, text="查找所有", command=lambda: search(v.get(), c.get(),
  103.                                                   textPad, t, e)).grid(row=0, column=2, sticky="e" + "w", padx=2,
  104.                                                                        pady=2)
  105.  
  106.     def close_search():
  107.         textPad.tag_remove("match", "1.0", END)
  108.         t.destroy()
  109.  
  110.     t.protocol("WM_DELETE_WINDOW", close_search)
  111.  
  112.  
  113. def mypopup(event):
  114.     # global editmenu
  115.     editmenu.tk_popup(event.x_root, event.y_root)
  116.  
  117.  
  118. def search(needle, cssnstv, textPad, t, e):
  119.     textPad.tag_remove("match", "1.0", END)
  120.     count = 0
  121.     if needle:
  122.         pos = "1.0"
  123.         while True:
  124.             pos = textPad.search(needle, pos, nocase=cssnstv, stopindex=END)
  125.             if not pos:
  126.                 break
  127.             lastpos = pos + str(len(needle))
  128.             textPad.tag_add("match", pos, lastpos)
  129.             count += 1
  130.             pos = lastpos
  131.         textPad.tag_config('match', fg='yellow', bg="green")
  132.         e.focus_set()
  133.         t.title(str(count) + "个被匹配")
  134.  
  135.  
  136. top = Tk()
  137. top.title("记事本")
  138. top.geometry("600x400+100+50")
  139.  
  140. menubar = Menu(top)
  141.  
  142. # 文件功能
  143. filemenu = Menu(top)
  144. filemenu.add_command(label="新建", accelerator="Ctrl+N", command=mynew)
  145. filemenu.add_command(label="打开", accelerator="Ctrl+O", command=myopen)
  146. filemenu.add_command(label="保存", accelerator="Ctrl+S", command=mysave)
  147. filemenu.add_command(label="另存为", accelerator="Ctrl+shift+s", command=mysaveas)
  148. menubar.add_cascade(label="文件", menu=filemenu)
  149.  
  150. # 编辑功能
  151. editmenu = Menu(top)
  152. editmenu.add_command(label="撤销", accelerator="Ctrl+Z", command=undo)
  153. editmenu.add_command(label="重做", accelerator="Ctrl+Y", command=redo)
  154. editmenu.add_separator()
  155. editmenu.add_command(label="剪切", accelerator="Ctrl+X", command=cut)
  156. editmenu.add_command(label="复制", accelerator="Ctrl+C", command=copy)
  157. editmenu.add_command(label="粘贴", accelerator="Ctrl+V", command=paste)
  158. editmenu.add_separator()
  159. editmenu.add_command(label="查找", accelerator="Ctrl+F", command=find)
  160. editmenu.add_command(label="全选", accelerator="Ctrl+A", command=select_all)
  161. menubar.add_cascade(label="编辑", menu=editmenu)
  162.  
  163. # 关于 功能
  164. aboutmenu = Menu(top)
  165. aboutmenu.add_command(label="作者", command=author)
  166. aboutmenu.add_command(label="版权", command=power)
  167. menubar.add_cascade(label="关于", menu=aboutmenu)
  168.  
  169. top['menu'] = menubar
  170.  
  171. # shortcutbar = Frame(top, height=25, bg='light sea green')
  172. # shortcutbar.pack(expand=NO, fill=X)
  173. # Inlabe = Label(top, width=2, bg='antique white')
  174. # Inlabe.pack(side=LEFT, anchor='nw', fill=Y)
  175.  
  176. textPad = Text(top, undo=True)
  177. textPad.pack(expand=YES, fill=BOTH)
  178. scroll = Scrollbar(textPad)
  179. textPad.config(yscrollcommand=scroll.set)
  180. scroll.config(command=textPad.yview)
  181. scroll.pack(side=RIGHT, fill=Y)
  182.  
  183. # 热键绑定
  184. textPad.bind("<Control-N>", mynew)
  185. textPad.bind("<Control-n>", mynew)
  186. textPad.bind("<Control-O>", myopen)
  187. textPad.bind("<Control-o>", myopen)
  188. textPad.bind("<Control-S>", mysave)
  189. textPad.bind("<Control-s>", mysave)
  190. textPad.bind("<Control-A>", select_all)
  191. textPad.bind("<Control-a>", select_all)
  192. textPad.bind("<Control-F>", find)
  193. textPad.bind("<Control-f>", find)
  194.  
  195. textPad.bind("<Button-3>", mypopup)
  196. top.mainloop()

3、登录和注册

1. 案例介绍

本例设计一个用户登录和注册模块，使用 Tkinter 框架构建界面，主要用到画布、文本框、按钮等组件。涉及知识点：Python Tkinter 界面编程、pickle 数据存储。本例实现了基本的用户登录和注册互动界面，并提供用户信息存储和验证。pickle 是 python 语言的一个标准模块，安装 python 后已包含 pickle 库，不需要单独再安装。pickle 模块实现了基本的数据序列化和反序列化。通过 pickle 模块的序列化操作能够将程序中运行的对象信息保存到文件中去，永久存储；通过 pickle 模块的反序列化操作，能够从文件中创建上一次程序保存的对象。本例难度为中级，适合具有 Python 基础和 Tkinter 组件编程知识的用户学习。

2. 示例效果

55e4623f7f61e8243d54fae8ccfa5954.png 2a3e3cf65a09d5fcdd96223edebd86c9.png

3. 示例源码

  1. import tkinter as tk
  2. import pickle
  3. import tkinter.messagebox
  4. from PIL import Image, ImageTk
  5.  
  6. # 设置窗口---最开始的母体窗口
  7. window = tk.Tk()  # 建立一个窗口
  8. window.title('欢迎登录')
  9. window.geometry('450x300')  # 窗口大小为300x200
  10.  
  11. # 画布
  12. canvas = tk.Canvas(window, height=200, width=900)
  13. # 加载图片
  14. im = Image.open("images/01.png")
  15. image_file = ImageTk.PhotoImage(im)
  16. # image_file = tk.PhotoImage(file='images/01.gif')
  17. image = canvas.create_image(100, 40, anchor='nw', image=image_file)
  18. canvas.pack(side='top')
  19.  
  20. # 两个文字标签，用户名和密码两个部分
  21. tk.Label(window, text='用户名').place(x=100, y=150)
  22. tk.Label(window, text='密  码').place(x=100, y=190)
  23.  
  24. var_usr_name = tk.StringVar()  # 讲文本框的内容，定义为字符串类型
  25. var_usr_name.set('amoxiang@163.com')  # 设置默认值
  26. var_usr_pwd = tk.StringVar()
  27.  
  28. # 第一个输入框-用来输入用户名的。
  29. # textvariable 获取文本框的内容
  30. entry_usr_name = tk.Entry(window, textvariable=var_usr_name)
  31. entry_usr_name.place(x=160, y=150)
  32. # 第二个输入框-用来输入密码的。
  33. entry_usr_pwd = tk.Entry(window, textvariable=var_usr_pwd, show='*')
  34. entry_usr_pwd.place(x=160, y=190)
  35.  
  36.  
  37. def usr_login():
  38.     usr_name = var_usr_name.get()
  39.     usr_pwd = var_usr_pwd.get()
  40.     try:
  41.         with open('usrs_info.pickle', 'rb') as usr_file:
  42.             usrs_info = pickle.load(usr_file)
  43.     except FileNotFoundError:
  44.         with open('usrs_info.pickle', 'wb') as usr_file:
  45.             usrs_info = {'admin': 'admin'}
  46.             pickle.dump(usrs_info, usr_file)
  47.  
  48.     if usr_name in usrs_info:
  49.         if usr_pwd == usrs_info[usr_name]:
  50.             tk.messagebox.showinfo(
  51.                 title='欢迎光临', message=usr_name + '：请进入个人首页，查看最新资讯')
  52.         else:
  53.             tk.messagebox.showinfo(message='错误提示：密码不对，请重试')
  54.     else:
  55.         is_sign_up = tk.messagebox.askyesno('提示', '你还没有注册，请先注册')
  56.         print(is_sign_up)
  57.         if is_sign_up:
  58.             usr_sign_up()
  59.  
  60.  
  61. # 注册按钮
  62. def usr_sign_up():
  63.     def sign_to_Mofan_Python():
  64.         np = new_pwd.get()
  65.         npf = new_pwd_confirm.get()
  66.         nn = new_name.get()
  67.         # 上面是获取数据，下面是查看一下是否重复注册过
  68.         with open('usrs_info.pickle', 'rb') as usr_file:
  69.             exist_usr_info = pickle.load(usr_file)
  70.             if np != npf:
  71.                 tk.messagebox.showerror('错误提示', '密码和确认密码必须一样')
  72.             elif nn in exist_usr_info:
  73.                 tk.messagebox.showerror('错误提示', '用户名早就注册了！')
  74.             else:
  75.                 exist_usr_info[nn] = np
  76.                 with open('usrs_info.pickle', 'wb') as usr_file:
  77.                     pickle.dump(exist_usr_info, usr_file)
  78.                 tk.messagebox.showinfo('欢迎', '你已经成功注册了')
  79.                 window_sign_up.destroy()
  80.  
  81.     # 点击注册之后，会弹出这个窗口界面。
  82.     window_sign_up = tk.Toplevel(window)
  83.     window_sign_up.title('欢迎注册')
  84.     window_sign_up.geometry('360x200')  # 中间是x，而不是*号
  85.  
  86.     # 用户名框--这里输入用户名框。
  87.     new_name = tk.StringVar()
  88.     new_name.set('amoxiang@163.com')  # 设置的是默认值
  89.     tk.Label(window_sign_up, text='用户名').place(x=10, y=10)
  90.     entry_new_name = tk.Entry(window_sign_up, textvariable=new_name)
  91.     entry_new_name.place(x=100, y=10)
  92.  
  93.     # 新密码框--这里输入注册时候的密码
  94.     new_pwd = tk.StringVar()
  95.     tk.Label(window_sign_up, text='密  码').place(x=10, y=50)
  96.     entry_usr_pwd = tk.Entry(window_sign_up, textvariable=new_pwd, show='*')
  97.     entry_usr_pwd.place(x=100, y=50)
  98.  
  99.     # 密码确认框
  100.     new_pwd_confirm = tk.StringVar()
  101.     tk.Label(window_sign_up, text='确认密码').place(x=10, y=90)
  102.     entry_usr_pwd_confirm = tk.Entry(
  103.         window_sign_up, textvariable=new_pwd_confirm, show='*')
  104.     entry_usr_pwd_confirm.place(x=100, y=90)
  105.  
  106.     btn_confirm_sign_up = tk.Button(
  107.         window_sign_up, text=' 注  册 ', command=sign_to_Mofan_Python)
  108.     btn_confirm_sign_up.place(x=120, y=130)
  109.  
  110.  
  111. # 创建注册和登录按钮
  112. btn_login = tk.Button(window, text=' 登  录 ', command=usr_login)
  113. btn_login.place(x=150, y=230)  # 用place来处理按钮的位置信息。
  114. btn_sign_up = tk.Button(window, text=' 注  册 ', command=usr_sign_up)
  115. btn_sign_up.place(x=250, y=230)
  116.  
  117. window.mainloop()

游戏开发

1、2048

1. 游戏简介

2048 是一款比较流行的数字游戏。游戏规则：每次可按上、下、左、右方向键滑动数字，每滑动一次，所有数字都会往滑动方向靠拢，同时在空白位置随机出现一个数字，相同数字在靠拢时会相加。不断叠加最终拼出 2048 这个数字算成功。2048 最早于 2014年3月20日发行。原版 2048 首先在 GitHub 上发布，原作者是 Gabriele Cirulli，后被移植到各个平台。本例难度为初级，适合具有 Python 基础和 Pygame 编程知识的用户学习。

2. 设计原理

这个游戏的本质是二维列表，就以 4*4 的二位列表来分析关键的逻辑以及实现。二维列表如下图：

e1f40555b3236a03c00a3ca55e988036.png

所有的操作都是对这个二维列表的数据的操作。分为上下左右四个方向。先说向左的方向(如图)。

7c921c2fc78269fe3024f224cd273c6b.png

向左操作的结果如下图；当向左的方向是，所有的数据沿着水平方向向左跑。

3734eb8c80e3ce26debd54abfeddadf1.png

水平说明操作的是二维列表的一行，而垂直操作的则是二位列表的一列。这样就可以将二维列表的操作变成遍历后对一维列表的操作。向左说明数据的优先考虑的位置是从左开始的。这样就确定了一维列表的遍历开始的位置。上面第 2 个图共四行，每一个行都能得到一个列表。

  1. list1：[0,0,2,0]
  2. list2：[0,4,2,0]
  3. list3：[0,0,4,4]
  4. list4：[2,0,2,0]

这样一来向左的方向就变成。从上到下获得每一行的列表，方向向左。参数(row,left)。

5cfb914682e6cf37057314a6b7567714.png

其他的三个方向在开始的时候记住是怎样获得以为列表的，等操作完才放回去这样就能实现了。

**3. 示例效果  **

bee615320e757c3638598462f3f36d55.png

4. 示例源码

  1. import random
  2. import sys
  3. import pygame
  4. from pygame.locals import *
  5.  
  6. PIXEL = 150
  7. SCORE_PIXEL = 100
  8. SIZE = 4
  9.  
  10.  
  11. # 地图的类
  12.  
  13.  
  14. class Map:
  15.     def __init__(self, size):
  16.         self.size = size
  17.         self.score = 0
  18.         self.map = [[0 for i in range(size)] for i in range(size)]
  19.         self.add()
  20.         self.add()
  21.  
  22.     # 新增2或4，有1/4概率产生4
  23.     def add(self):
  24.         while True:
  25.             p = random.randint(0, self.size * self.size - 1)
  26.             if self.map[int(p / self.size)][int(p % self.size)] == 0:
  27.                 x = random.randint(0, 3) > 0 and 2 or 4
  28.                 self.map[int(p / self.size)][int(p % self.size)] = x
  29.                 self.score += x
  30.                 break
  31.  
  32.     # 地图向左靠拢，其他方向的靠拢可以通过适当旋转实现，返回地图是否更新
  33.     def adjust(self):
  34.         changed = False
  35.         for a in self.map:
  36.             b = []
  37.             last = 0
  38.             for v in a:
  39.                 if v != 0:
  40.                     if v == last:
  41.                         b.append(b.pop() << 1)
  42.                         last = 0
  43.                     else:
  44.                         b.append(v)
  45.                         last = v
  46.             b += [0] * (self.size - len(b))
  47.             for i in range(self.size):
  48.                 if a[i] != b[i]:
  49.                     changed = True
  50.             a[:] = b
  51.         return changed
  52.  
  53.     # 逆时针旋转地图90度
  54.     def rotate90(self):
  55.         self.map = [[self.map[c][r]
  56.                      for c in range(self.size)] for r in reversed(range(self.size))]
  57.  
  58.     # 判断游戏结束
  59.     def over(self):
  60.         for r in range(self.size):
  61.             for c in range(self.size):
  62.                 if self.map[r][c] == 0:
  63.                     return False
  64.         for r in range(self.size):
  65.             for c in range(self.size - 1):
  66.                 if self.map[r][c] == self.map[r][c + 1]:
  67.                     return False
  68.         for r in range(self.size - 1):
  69.             for c in range(self.size):
  70.                 if self.map[r][c] == self.map[r + 1][c]:
  71.                     return False
  72.         return True
  73.  
  74.     def moveUp(self):
  75.         self.rotate90()
  76.         if self.adjust():
  77.             self.add()
  78.         self.rotate90()
  79.         self.rotate90()
  80.         self.rotate90()
  81.  
  82.     def moveRight(self):
  83.         self.rotate90()
  84.         self.rotate90()
  85.         if self.adjust():
  86.             self.add()
  87.         self.rotate90()
  88.         self.rotate90()
  89.  
  90.     def moveDown(self):
  91.         self.rotate90()
  92.         self.rotate90()
  93.         self.rotate90()
  94.         if self.adjust():
  95.             self.add()
  96.         self.rotate90()
  97.  
  98.     def moveLeft(self):
  99.         if self.adjust():
  100.             self.add()
  101.  
  102.  
  103. # 更新屏幕
  104.  
  105.  
  106. def show(map):
  107.     for i in range(SIZE):
  108.         for j in range(SIZE):
  109.             # 背景颜色块
  110.             screen.blit(map.map[i][j] == 0 and block[(i + j) % 2]
  111.                         or block[2 + (i + j) % 2], (PIXEL * j, PIXEL * i))
  112.             # 数值显示
  113.             if map.map[i][j] != 0:
  114.                 map_text = map_font.render(
  115.                     str(map.map[i][j]), True, (106, 90, 205))
  116.                 text_rect = map_text.get_rect()
  117.                 text_rect.center = (PIXEL * j + PIXEL / 2,
  118.                                     PIXEL * i + PIXEL / 2)
  119.                 screen.blit(map_text, text_rect)
  120.     # 分数显示
  121.     screen.blit(score_block, (0, PIXEL * SIZE))
  122.     score_text = score_font.render((map.over(
  123.     ) and "Game over with score " or "Score: ") + str(map.score), True, (106, 90, 205))
  124.     score_rect = score_text.get_rect()
  125.     score_rect.center = (PIXEL * SIZE / 2, PIXEL * SIZE + SCORE_PIXEL / 2)
  126.     screen.blit(score_text, score_rect)
  127.     pygame.display.update()
  128.  
  129.  
  130. map = Map(SIZE)
  131. pygame.init()
  132. screen = pygame.display.set_mode((PIXEL * SIZE, PIXEL * SIZE + SCORE_PIXEL))
  133. pygame.display.set_caption("2048")
  134. block = [pygame.Surface((PIXEL, PIXEL)) for i in range(4)]
  135. # 设置颜色
  136. block[0].fill((152, 251, 152))
  137. block[1].fill((240, 255, 255))
  138. block[2].fill((0, 255, 127))
  139. block[3].fill((225, 255, 255))
  140. score_block = pygame.Surface((PIXEL * SIZE, SCORE_PIXEL))
  141. score_block.fill((245, 245, 245))
  142. # 设置字体
  143. map_font = pygame.font.Font(None, int(PIXEL * 2 / 3))
  144. score_font = pygame.font.Font(None, int(SCORE_PIXEL * 2 / 3))
  145. clock = pygame.time.Clock()
  146. show(map)
  147.  
  148. while not map.over():
  149.     # 12为实验参数
  150.     clock.tick(12)
  151.     for event in pygame.event.get():
  152.         if event.type == QUIT:
  153.             sys.exit()
  154.     # 接收玩家操作
  155.     pressed_keys = pygame.key.get_pressed()
  156.     if pressed_keys[K_w] or pressed_keys[K_UP]:
  157.         map.moveUp()
  158.     elif pressed_keys[K_s] or pressed_keys[K_DOWN]:
  159.         map.moveDown()
  160.     elif pressed_keys[K_a] or pressed_keys[K_LEFT]:
  161.         map.moveLeft()
  162.     elif pressed_keys[K_d] or pressed_keys[K_RIGHT]:
  163.         map.moveRight()
  164.     show(map)
  165.  
  166. # 游戏结束
  167. pygame.time.delay(3000)

2、贪吃蛇

1. 案例介绍

贪吃蛇是一款经典的益智游戏，简单又耐玩。该游戏通过控制蛇头方向吃蛋，从而使得蛇变得越来越长。通过上下左右方向键控制蛇的方向，寻找吃的东西，每吃一口就能得到一定的积分，而且蛇的身子会越吃越长，身子越长玩的难度就越大，不能碰墙，不能咬到自己的身体，更不能咬自己的尾巴，等到了一定的分数，就能过关，然后继续玩下一关。本例难度为中级，适合具有 Python 基础和 Pygame 编程知识的用户学习。

2. 设计要点

游戏是基于 PyGame 框架制作的，程序核心逻辑如下：游戏界面分辨率是 640*480，蛇和食物都是由 1 个或多个 20*20 像素的正方形块儿(为了方便，下文用点表示 20*20 像素的正方形块儿) 组成，这样共有 32*24 个点，使用 pygame.draw.rect 来绘制每一个点；初始化时蛇的长度是 3，食物是 1 个点，蛇初始的移动的方向是右，用一个数组代表蛇，数组的每个元素是蛇每个点的坐标，因此数组的第一个坐标是蛇尾，最后一个坐标是蛇头；游戏开始后，根据蛇的当前移动方向，将蛇运动方向的前方的那个点 append 到蛇数组的末位，再把蛇尾去掉，蛇的坐标数组就相当于往前挪了一位；如果蛇吃到了食物，即蛇头的坐标等于食物的坐标，那么在第 2 点中蛇尾就不用去掉，就产生了蛇长度增加的效果；食物被吃掉后，随机在空的位置(不能与蛇的身体重合) 再生成一个；通过 PyGame 的 event 监控按键，改变蛇的方向，例如当蛇向右时，下一次改变方向只能向上或者向下；当蛇撞上自身或墙壁，游戏结束，蛇头装上自身，那么蛇坐标数组里就有和舌头坐标重复的数据，撞上墙壁则是蛇头坐标超过了边界，都很好判断；其他细节：做了个开始的欢迎界面；食物的颜色随机生成；吃到实物的时候有声音提示等。

3. 示例效果

e8bb2eaaa051cd3b77f12b3e4636abf6.png

4. 示例源码

  1. import pygame
  2. from os import path
  3. from sys import exit
  4. from time import sleep
  5. from random import choice
  6. from itertools import product
  7. from pygame.locals import QUIT, KEYDOWN
  8.  
  9.  
  10. def direction_check(moving_direction, change_direction):
  11.     directions = [['up', 'down'], ['left', 'right']]
  12.     if moving_direction in directions[0] and change_direction in directions[1]:
  13.         return change_direction
  14.     elif moving_direction in directions[1] and change_direction in directions[0]:
  15.         return change_direction
  16.     return moving_direction
  17.  
  18.  
  19. class Snake:
  20.     colors = list(product([0, 64, 128, 192, 255], repeat=3))[1:-1]
  21.  
  22.     def __init__(self):
  23.         self.map = {(x, y): 0 for x in range(32) for y in range(24)}
  24.         self.body = [[100, 100], [120, 100], [140, 100]]
  25.         self.head = [140, 100]
  26.         self.food = []
  27.         self.food_color = []
  28.         self.moving_direction = 'right'
  29.         self.speed = 4
  30.         self.generate_food()
  31.         self.game_started = False
  32.  
  33.     def check_game_status(self):
  34.         if self.body.count(self.head) > 1:
  35.             return True
  36.         if self.head[0] < 0 or self.head[0] > 620 or self.head[1] < 0 or self.head[1] > 460:
  37.             return True
  38.         return False
  39.  
  40.     def move_head(self):
  41.         moves = {
  42.             'right': (20, 0),
  43.             'up': (0, -20),
  44.             'down': (0, 20),
  45.             'left': (-20, 0)
  46.         }
  47.         step = moves[self.moving_direction]
  48.         self.head[0] += step[0]
  49.         self.head[1] += step[1]
  50.  
  51.     def generate_food(self):
  52.         self.speed = len(
  53.             self.body) // 16 if len(self.body) // 16 > 4 else self.speed
  54.         for seg in self.body:
  55.             x, y = seg
  56.             self.map[x // 20, y // 20] = 1
  57.         empty_pos = [pos for pos in self.map.keys() if not self.map[pos]]
  58.         result = choice(empty_pos)
  59.         self.food_color = list(choice(self.colors))
  60.         self.food = [result[0] * 20, result[1] * 20]
  61.  
  62.  
  63. def main():
  64.     key_direction_dict = {
  65.         119: 'up',  # W
  66.         115: 'down',  # S
  67.         97: 'left',  # A
  68.         100: 'right',  # D
  69.         273: 'up',  # UP
  70.         274: 'down',  # DOWN
  71.         276: 'left',  # LEFT
  72.         275: 'right',  # RIGHT
  73.     }
  74.  
  75.     fps_clock = pygame.time.Clock()
  76.     pygame.init()
  77.     pygame.mixer.init()
  78.     snake = Snake()
  79.     sound = False
  80.     if path.exists('eat.wav'):
  81.         sound_wav = pygame.mixer.Sound("eat.wav")
  82.         sound = True
  83.     title_font = pygame.font.SysFont('simsunnsimsun', 32)
  84.     welcome_words = title_font.render(
  85.         '贪吃蛇', True, (0, 0, 0), (255, 255, 255))
  86.     tips_font = pygame.font.SysFont('simsunnsimsun', 20)
  87.     start_game_words = tips_font.render(
  88.         '点击开始', True, (0, 0, 0), (255, 255, 255))
  89.     close_game_words = tips_font.render(
  90.         '按ESC退出', True, (0, 0, 0), (255, 255, 255))
  91.     gameover_words = title_font.render(
  92.         '游戏结束', True, (205, 92, 92), (255, 255, 255))
  93.     win_words = title_font.render(
  94.         '蛇很长了，你赢了！', True, (0, 0, 205), (255, 255, 255))
  95.     screen = pygame.display.set_mode((640, 480), 0, 32)
  96.     pygame.display.set_caption('贪吃蛇')
  97.     new_direction = snake.moving_direction
  98.     while 1:
  99.         for event in pygame.event.get():
  100.             if event.type == QUIT:
  101.                 exit()
  102.             elif event.type == KEYDOWN:
  103.                 if event.key == 27:
  104.                     exit()
  105.                 if snake.game_started and event.key in key_direction_dict:
  106.                     direction = key_direction_dict[event.key]
  107.                     new_direction = direction_check(
  108.                         snake.moving_direction, direction)
  109.             elif (not snake.game_started) and event.type == pygame.MOUSEBUTTONDOWN:
  110.                 x, y = pygame.mouse.get_pos()
  111.                 if 213 <= x <= 422 and 304 <= y <= 342:
  112.                     snake.game_started = True
  113.         screen.fill((255, 255, 255))
  114.         if snake.game_started:
  115.             snake.moving_direction = new_direction  # 在这里赋值，而不是在event事件的循环中赋值，避免按键太快
  116.             snake.move_head()
  117.             snake.body.append(snake.head[:])
  118.             if snake.head == snake.food:
  119.                 if sound:
  120.                     sound_wav.play()
  121.                 snake.generate_food()
  122.             else:
  123.                 snake.body.pop(0)
  124.             for seg in snake.body:
  125.                 pygame.draw.rect(screen, [0, 0, 0], [
  126.                     seg[0], seg[1], 20, 20], 0)
  127.             pygame.draw.rect(screen, snake.food_color, [
  128.                 snake.food[0], snake.food[1], 20, 20], 0)
  129.             if snake.check_game_status():
  130.                 screen.blit(gameover_words, (241, 310))
  131.                 pygame.display.update()
  132.                 snake = Snake()
  133.                 new_direction = snake.moving_direction
  134.                 sleep(3)
  135.             elif len(snake.body) == 512:
  136.                 screen.blit(win_words, (33, 210))
  137.                 pygame.display.update()
  138.                 snake = Snake()
  139.                 new_direction = snake.moving_direction
  140.                 sleep(3)
  141.         else:
  142.             screen.blit(welcome_words, (240, 150))
  143.             screen.blit(start_game_words, (246, 310))
  144.             screen.blit(close_game_words, (246, 350))
  145.         pygame.display.update()
  146.         fps_clock.tick(snake.speed)
  147.  
  148.  
  149. if __name__ == '__main__':
  150.     main()

3、俄罗斯方块

1. 案例介绍

俄罗斯方块是由 4 个小方块组成不同形状的板块，随机从屏幕上方落下，按方向键调整板块的位置和方向，在底部拼出完整的一行或几行。这些完整的横条会消失，给新落下来的板块腾出空间，并获得分数奖励。没有被消除掉的方块不断堆积，一旦堆到顶端，便告输，游戏结束。本例难度为高级，适合具有 Python 进阶和 Pygame 编程技巧的用户学习。

2. 设计要点

边框――由 15*25 个空格组成，方块就落在这里面。盒子――组成方块的其中小方块，是组成方块的基本单元。方块――从边框顶掉下的东西，游戏者可以翻转和改变位置。每个方块由 4 个盒子组成。形状――不同类型的方块。这里形状的名字被叫做 T, S, Z ,J, L, I , O。如下图所示：
34b1cebfdbfb8b7685d12b9b2cd2717a.png1bcbdd91d3f114f9fefd3b203b586adf.png

模版――用一个列表存放形状被翻转后的所有可能样式。全部存放在变量里，变量名字如 S or J。着陆――当一个方块到达边框的底部或接触到在其他的盒子话，就说这个方块着陆了。那样的话，另一个方块就会开始下落。

3. 示例效果

954f93938580b7f4627c26800b6db83a.gif

4. 示例源码

  1. import pygame
  2. import random
  3. import os
  4.  
  5. pygame.init()
  6.  
  7. GRID_WIDTH = 20
  8. GRID_NUM_WIDTH = 15
  9. GRID_NUM_HEIGHT = 25
  10. WIDTH, HEIGHT = GRID_WIDTH * GRID_NUM_WIDTH, GRID_WIDTH * GRID_NUM_HEIGHT
  11. SIDE_WIDTH = 200
  12. SCREEN_WIDTH = WIDTH + SIDE_WIDTH
  13. WHITE = (0xff, 0xff, 0xff)
  14. BLACK = (0, 0, 0)
  15. LINE_COLOR = (0x33, 0x33, 0x33)
  16.  
  17. CUBE_COLORS = [
  18.     (0xcc, 0x99, 0x99), (0xff, 0xff, 0x99), (0x66, 0x66, 0x99),
  19.     (0x99, 0x00, 0x66), (0xff, 0xcc, 0x00), (0xcc, 0x00, 0x33),
  20.     (0xff, 0x00, 0x33), (0x00, 0x66, 0x99), (0xff, 0xff, 0x33),
  21.     (0x99, 0x00, 0x33), (0xcc, 0xff, 0x66), (0xff, 0x99, 0x00)
  22. ]
  23.  
  24. screen = pygame.display.set_mode((SCREEN_WIDTH, HEIGHT))
  25. pygame.display.set_caption("俄罗斯方块")
  26. clock = pygame.time.Clock()
  27. FPS = 30
  28.  
  29. score = 0
  30. level = 1
  31.  
  32. screen_color_matrix = [[None] * GRID_NUM_WIDTH for i in range(GRID_NUM_HEIGHT)]
  33.  
  34. # 设置游戏的根目录为当前文件夹
  35. base_folder = os.path.dirname(__file__)
  36.  
  37.  
  38. def show_text(surf, text, size, x, y, color=WHITE):
  39.     font_name = os.path.join(base_folder, 'font/font.ttc')
  40.     font = pygame.font.Font(font_name, size)
  41.     text_surface = font.render(text, True, color)
  42.     text_rect = text_surface.get_rect()
  43.     text_rect.midtop = (x, y)
  44.     surf.blit(text_surface, text_rect)
  45.  
  46.  
  47. class CubeShape(object):
  48.     SHAPES = ['I', 'J', 'L', 'O', 'S', 'T', 'Z']
  49.     I = [[(0, -1), (0, 0), (0, 1), (0, 2)],
  50.          [(-1, 0), (0, 0), (1, 0), (2, 0)]]
  51.     J = [[(-2, 0), (-1, 0), (0, 0), (0, -1)],
  52.          [(-1, 0), (0, 0), (0, 1), (0, 2)],
  53.          [(0, 1), (0, 0), (1, 0), (2, 0)],
  54.          [(0, -2), (0, -1), (0, 0), (1, 0)]]
  55.     L = [[(-2, 0), (-1, 0), (0, 0), (0, 1)],
  56.          [(1, 0), (0, 0), (0, 1), (0, 2)],
  57.          [(0, -1), (0, 0), (1, 0), (2, 0)],
  58.          [(0, -2), (0, -1), (0, 0), (-1, 0)]]
  59.     O = [[(0, 0), (0, 1), (1, 0), (1, 1)]]
  60.     S = [[(-1, 0), (0, 0), (0, 1), (1, 1)],
  61.          [(1, -1), (1, 0), (0, 0), (0, 1)]]
  62.     T = [[(0, -1), (0, 0), (0, 1), (-1, 0)],
  63.          [(-1, 0), (0, 0), (1, 0), (0, 1)],
  64.          [(0, -1), (0, 0), (0, 1), (1, 0)],
  65.          [(-1, 0), (0, 0), (1, 0), (0, -1)]]
  66.     Z = [[(0, -1), (0, 0), (1, 0), (1, 1)],
  67.          [(-1, 0), (0, 0), (0, -1), (1, -1)]]
  68.     SHAPES_WITH_DIR = {
  69.         'I': I, 'J': J, 'L': L, 'O': O, 'S': S, 'T': T, 'Z': Z
  70.     }
  71.  
  72.     def __init__(self):
  73.         self.shape = self.SHAPES[random.randint(0, len(self.SHAPES) - 1)]
  74.         # 骨牌所在的行列
  75.         self.center = (2, GRID_NUM_WIDTH // 2)
  76.         self.dir = random.randint(0, len(self.SHAPES_WITH_DIR[self.shape]) - 1)
  77.         self.color = CUBE_COLORS[random.randint(0, len(CUBE_COLORS) - 1)]
  78.  
  79.     def get_all_gridpos(self, center=None):
  80.         curr_shape = self.SHAPES_WITH_DIR[self.shape][self.dir]
  81.         if center is None:
  82.             center = [self.center[0], self.center[1]]
  83.  
  84.         return [(cube[0] + center[0], cube[1] + center[1])
  85.                 for cube in curr_shape]
  86.  
  87.     def conflict(self, center):
  88.         for cube in self.get_all_gridpos(center):
  89.             # 超出屏幕之外，说明不合法
  90.             if cube[0] < 0 or cube[1] < 0 or cube[0] >= GRID_NUM_HEIGHT or \
  91.                     cube[1] >= GRID_NUM_WIDTH:
  92.                 return True
  93.  
  94.             # 不为None，说明之前已经有小方块存在了，也不合法
  95.             if screen_color_matrix[cube[0]][cube[1]] is not None:
  96.                 return True
  97.  
  98.         return False
  99.  
  100.     def rotate(self):
  101.         new_dir = self.dir + 1
  102.         new_dir %= len(self.SHAPES_WITH_DIR[self.shape])
  103.         old_dir = self.dir
  104.         self.dir = new_dir
  105.         if self.conflict(self.center):
  106.             self.dir = old_dir
  107.             return False
  108.  
  109.     def down(self):
  110.         # import pdb; pdb.set_trace()
  111.         center = (self.center[0] + 1, self.center[1])
  112.         if self.conflict(center):
  113.             return False
  114.  
  115.         self.center = center
  116.         return True
  117.  
  118.     def left(self):
  119.         center = (self.center[0], self.center[1] - 1)
  120.         if self.conflict(center):
  121.             return False
  122.         self.center = center
  123.         return True
  124.  
  125.     def right(self):
  126.         center = (self.center[0], self.center[1] + 1)
  127.         if self.conflict(center):
  128.             return False
  129.         self.center = center
  130.         return True
  131.  
  132.     def draw(self):
  133.         for cube in self.get_all_gridpos():
  134.             pygame.draw.rect(screen, self.color,
  135.                              (cube[1] * GRID_WIDTH, cube[0] * GRID_WIDTH,
  136.                               GRID_WIDTH, GRID_WIDTH))
  137.             pygame.draw.rect(screen, WHITE,
  138.                              (cube[1] * GRID_WIDTH, cube[0] * GRID_WIDTH,
  139.                               GRID_WIDTH, GRID_WIDTH),
  140.                              1)
  141.  
  142.  
  143. def draw_grids():
  144.     for i in range(GRID_NUM_WIDTH):
  145.         pygame.draw.line(screen, LINE_COLOR,
  146.                          (i * GRID_WIDTH, 0), (i * GRID_WIDTH, HEIGHT))
  147.  
  148.     for i in range(GRID_NUM_HEIGHT):
  149.         pygame.draw.line(screen, LINE_COLOR,
  150.                          (0, i * GRID_WIDTH), (WIDTH, i * GRID_WIDTH))
  151.  
  152.     pygame.draw.line(screen, WHITE,
  153.                      (GRID_WIDTH * GRID_NUM_WIDTH, 0),
  154.                      (GRID_WIDTH * GRID_NUM_WIDTH, GRID_WIDTH * GRID_NUM_HEIGHT))
  155.  
  156.  
  157. def draw_matrix():
  158.     for i, row in zip(range(GRID_NUM_HEIGHT), screen_color_matrix):
  159.         for j, color in zip(range(GRID_NUM_WIDTH), row):
  160.             if color is not None:
  161.                 pygame.draw.rect(screen, color,
  162.                                  (j * GRID_WIDTH, i * GRID_WIDTH,
  163.                                   GRID_WIDTH, GRID_WIDTH))
  164.                 pygame.draw.rect(screen, WHITE,
  165.                                  (j * GRID_WIDTH, i * GRID_WIDTH,
  166.                                   GRID_WIDTH, GRID_WIDTH), 2)
  167.  
  168.  
  169. def draw_score():
  170.     show_text(screen, u'得分：{}'.format(score), 20, WIDTH + SIDE_WIDTH // 2, 100)
  171.  
  172.  
  173. def remove_full_line():
  174.     global screen_color_matrix
  175.     global score
  176.     global level
  177.     new_matrix = [[None] * GRID_NUM_WIDTH for i in range(GRID_NUM_HEIGHT)]
  178.     index = GRID_NUM_HEIGHT - 1
  179.     n_full_line = 0
  180.     for i in range(GRID_NUM_HEIGHT - 1, -1, -1):
  181.         is_full = True
  182.         for j in range(GRID_NUM_WIDTH):
  183.             if screen_color_matrix[i][j] is None:
  184.                 is_full = False
  185.                 continue
  186.         if not is_full:
  187.             new_matrix[index] = screen_color_matrix[i]
  188.             index -= 1
  189.         else:
  190.             n_full_line += 1
  191.     score += n_full_line
  192.     level = score // 20 + 1
  193.     screen_color_matrix = new_matrix
  194.  
  195.  
  196. def show_welcome(screen):
  197.     show_text(screen, u'俄罗斯方块', 30, WIDTH / 2, HEIGHT / 2)
  198.     show_text(screen, u'按任意键开始游戏', 20, WIDTH / 2, HEIGHT / 2 + 50)
  199.  
  200.  
  201. running = True
  202. gameover = True
  203. counter = 0
  204. live_cube = None
  205. while running:
  206.     clock.tick(FPS)
  207.     for event in pygame.event.get():
  208.         if event.type == pygame.QUIT:
  209.             running = False
  210.         elif event.type == pygame.KEYDOWN:
  211.             if gameover:
  212.                 gameover = False
  213.                 live_cube = CubeShape()
  214.                 break
  215.             if event.key == pygame.K_LEFT:
  216.                 live_cube.left()
  217.             elif event.key == pygame.K_RIGHT:
  218.                 live_cube.right()
  219.             elif event.key == pygame.K_DOWN:
  220.                 live_cube.down()
  221.             elif event.key == pygame.K_UP:
  222.                 live_cube.rotate()
  223.             elif event.key == pygame.K_SPACE:
  224.                 while live_cube.down() == True:
  225.                     pass
  226.             remove_full_line()
  227.  
  228.     # level 是为了方便游戏的难度，level 越高 FPS // level 的值越小
  229.     # 这样屏幕刷新的就越快，难度就越大
  230.     if gameover is False and counter % (FPS // level) == 0:
  231.         # down 表示下移骨牌，返回False表示下移不成功，可能超过了屏幕或者和之前固定的
  232.         # 小方块冲突了
  233.         if live_cube.down() == False:
  234.             for cube in live_cube.get_all_gridpos():
  235.                 screen_color_matrix[cube[0]][cube[1]] = live_cube.color
  236.             live_cube = CubeShape()
  237.             if live_cube.conflict(live_cube.center):
  238.                 gameover = True
  239.                 score = 0
  240.                 live_cube = None
  241.                 screen_color_matrix = [[None] * GRID_NUM_WIDTH for i in range(GRID_NUM_HEIGHT)]
  242.         # 消除满行
  243.         remove_full_line()
  244.     counter += 1
  245.     # 更新屏幕
  246.     screen.fill(BLACK)
  247.     draw_grids()
  248.     draw_matrix()
  249.     draw_score()
  250.     if live_cube is not None:
  251.         live_cube.draw()
  252.     if gameover:
  253.         show_welcome(screen)
  254.     pygame.display.update()

4、连连看

1. 案例介绍

连连看是一款曾经非常流行的小游戏。

游戏规则：

  1. 点击选中两个相同的方块。

  2. 两个选中的方块之间连接线的折点不超过两个(接线由X轴和Y轴的平行线组成)。

  3. 每找出一对，它们就会自动消失。

  4. 连线不能从尚未消失的图案上经过。

  5. 把所有的图案全部消除即可获得胜利。

2. 设计思路

  1. 生成成对的图片元素。

  2. 将图片元素打乱排布。

  3. 定义什么才算 相连(两张图片的连线不多于3跟直线，或者说转角不超过2个)。

  4. 实现 相连 判断算法。

  5. 消除图片元素并判断是否消除完毕。

3. 示例效果

b98dec78aa6be80e2d688be378e54416.gif

4. 示例源码

  1. from tkinter import *
  2. from tkinter.messagebox import *
  3. from threading import Timer
  4. import time
  5. import random
  6.  
  7.  
  8. class Point:
  9.     # 点类
  10.     def __init__(self, x, y):
  11.         self.x = x
  12.         self.y = y
  13.  
  14.  
  15. # --------------------------------------
  16.  
  17.  
  18. '''
  19. 判断选中的两个方块是否可以消除
  20. '''
  21.  
  22.  
  23. def IsLink(p1, p2):
  24.     if lineCheck(p1, p2):
  25.         return True
  26.     if OneCornerLink(p1, p2):  # 一个转弯（折点）的联通方式
  27.         return True
  28.     if TwoCornerLink(p1, p2):  # 两个转弯（折点）的联通方式
  29.         return True
  30.     return False
  31.  
  32.  
  33. # ---------------------------
  34. def IsSame(p1, p2):
  35.     if map[p1.x][p1.y] == map[p2.x][p2.y]:
  36.         print("clicked at IsSame")
  37.         return True
  38.     return False
  39.  
  40.  
  41. def callback(event):  # 鼠标左键事件代码
  42.     global Select_first, p1, p2
  43.     global firstSelectRectId, SecondSelectRectId
  44.  
  45.     # print ("clicked at", event.x, event.y,turn)
  46.     x = (event.x) // 40  # 换算棋盘坐标
  47.     y = (event.y) // 40
  48.     print("clicked at", x, y)
  49.  
  50.     if map[x][y] == " ":
  51.         showinfo(title="提示", message="此处无方块")
  52.     else:
  53.  
  54.         if Select_first == False:
  55.             p1 = Point(x, y)
  56.             # 画选定（x1,y1)处的框线
  57.             firstSelectRectId = cv.create_rectangle(x * 40, y * 40, x * 40 + 40, y * 40 + 40, width=2, outline="blue")
  58.             Select_first = True
  59.         else:
  60.             p2 = Point(x, y)
  61.             # 判断第二次点击的方块是否已被第一次点击选取，如果是则返回。
  62.             if (p1.x == p2.x) and (p1.y == p2.y):
  63.                 return
  64.             # 画选定（x2,y2)处的框线
  65.             print('第二次点击的方块', x, y)
  66.             # SecondSelectRectId=cv.create_rectangle(100,20,x*40+40,y*40+40,width=2,outline="yellow")
  67.             SecondSelectRectId = cv.create_rectangle(x * 40, y * 40, x * 40 + 40, y * 40 + 40, width=2,
  68.                                                      outline="yellow")
  69.             print('第二次点击的方块', SecondSelectRectId)
  70.             cv.pack()
  71.  
  72.             # 判断是否连通
  73.             if IsSame(p1, p2) and IsLink(p1, p2):
  74.                 print('连通', x, y)
  75.                 Select_first = False
  76.                 # 画选中方块之间连接线
  77.                 drawLinkLine(p1, p2)
  78.                 # clearTwoBlock()
  79.                 # time.sleep(0.6)
  80.                 # clearFlag=True
  81.                 t = Timer(timer_interval, delayrun)  # 定时函数
  82.                 t.start()
  83.  
  84.  
  85.             else:  # 重新选定第一个方块
  86.                 # 清除第一个选定框线
  87.                 cv.delete(firstSelectRectId)
  88.                 cv.delete(SecondSelectRectId)
  89.                 # print('清除第一个选定框线')
  90.                 # firstSelectRectId=SecondSelectRectId
  91.                 # p1=Point(x,y)           #设置重新选定第一个方块的坐标
  92.                 Select_first = False
  93.  
  94.  
  95. timer_interval = 0.3  # 0.3秒
  96.  
  97.  
  98. # --------------------------------------
  99. def delayrun():
  100.     clearTwoBlock()  # 清除连线及方块
  101.  
  102.  
  103. def clearTwoBlock():  # 清除连线及方块
  104.     # 延时0.1秒
  105.     # time.sleep(0.1)
  106.     # 清除第一个选定框线
  107.     cv.delete(firstSelectRectId)
  108.     # 清除第2个选定框线
  109.     cv.delete(SecondSelectRectId)
  110.     # 清空记录方块的值
  111.     map[p1.x][p1.y] = " "
  112.     cv.delete(image_map[p1.x][p1.y])
  113.     map[p2.x][p2.y] = " "
  114.     cv.delete(image_map[p2.x][p2.y])
  115.     Select_first = False
  116.     undrawConnectLine()  # 清除选中方块之间连接线
  117.  
  118.  
  119. def drawQiPan():  # 画棋盘
  120.     for i in range(0, 15):
  121.         cv.create_line(20, 20 + 40 * i, 580, 20 + 40 * i, width=2)
  122.     for i in range(0, 15):
  123.         cv.create_line(20 + 40 * i, 20, 20 + 40 * i, 580, width=2)
  124.     cv.pack()
  125.  
  126.  
  127. def print_map():  # 输出map地图
  128.     global image_map
  129.     for x in range(0, Width):  # 0--14
  130.         for y in range(0, Height):  # 0--14
  131.             if (map[x][y] != ' '):
  132.                 img1 = imgs[int(map[x][y])]
  133.                 id = cv.create_image((x * 40 + 20, y * 40 + 20), image=img1)
  134.                 image_map[x][y] = id
  135.     cv.pack()
  136.     for y in range(0, Height):  # 0--14
  137.         for x in range(0, Width):  # 0--14
  138.             print(map[x][y], end=' ')
  139.         print(",", y)
  140.  
  141.  
  142. '''
  143. * 同行同列情况消除方法 原理：如果两个相同的被消除元素之间的 空格数
  144. spaceCount等于他们的（行/列差-1）则 两者可以联通消除
  145. * x代表列，y代表行
  146. * param p1 第一个保存上次选中点坐标的点对象
  147. * param p2 第二个保存上次选中点坐标的点对象
  148. '''
  149.  
  150.  
  151. # 直接连通
  152. def lineCheck(p1, p2):
  153.     absDistance = 0
  154.     spaceCount = 0
  155.     if (p1.x == p2.x or p1.y == p2.y):  # 同行同列的情况吗？
  156.         print("同行同列的情况------")
  157.         # 同列的情况
  158.         if (p1.x == p2.x and p1.y != p2.y):
  159.             print("同列的情况")
  160.             # 绝对距离(中间隔着的空格数)
  161.             absDistance = abs(p1.y - p2.y) - 1
  162.             # 正负值
  163.             if p1.y - p2.y > 0:
  164.                 zf = -1
  165.             else:
  166.                 zf = 1
  167.             for i in range(1, absDistance + 1):
  168.                 if (map[p1.x][p1.y + i * zf] == " "):
  169.                     # 空格数加1
  170.                     spaceCount += 1
  171.                 else:
  172.                     break;  # 遇到阻碍就不用再探测了
  173.  
  174.         # 同行的情况
  175.         elif (p1.y == p2.y and p1.x != p2.x):
  176.             print(" 同行的情况")
  177.             absDistance = abs(p1.x - p2.x) - 1
  178.             # 正负值
  179.             if p1.x - p2.x > 0:
  180.                 zf = -1
  181.             else:
  182.                 zf = 1
  183.             for i in range(1, absDistance + 1):
  184.                 if (map[p1.x + i * zf][p1.y] == " "):
  185.                     # 空格数加1
  186.                     spaceCount += 1
  187.                 else:
  188.                     break;  # 遇到阻碍就不用再探测了
  189.         if (spaceCount == absDistance):
  190.             # 可联通
  191.             print(absDistance, spaceCount)
  192.             print("行/列可直接联通")
  193.             return True
  194.         else:
  195.             print("行/列不能消除！")
  196.             return False
  197.     else:
  198.         # 不是同行同列的情况所以直接返回false
  199.         return False;
  200.  
  201.     # --------------------------------------
  202.  
  203.  
  204. # 第二种，直角连通
  205. '''
  206. 直角连接，即X,Y坐标都不同的，可以用这个方法尝试连接
  207.  param first:选中的第一个点
  208.  param second:选中的第二个点
  209. '''
  210.  
  211.  
  212. def OneCornerLink(p1, p2):
  213.     # 第一个直角检查点，如果这里为空则赋予相同值供检查
  214.     checkP = Point(p1.x, p2.y)
  215.     # 第二个直角检查点，如果这里为空则赋予相同值供检查
  216.     checkP2 = Point(p2.x, p1.y);
  217.     # 第一个直角点检测
  218.     if (map[checkP.x][checkP.y] == " "):
  219.         if (lineCheck(p1, checkP) and lineCheck(checkP, p2)):
  220.             linePointStack.append(checkP)
  221.             print("直角消除ok", checkP.x, checkP.y)
  222.             return True
  223.     # 第二个直角点检测
  224.     if (map[checkP2.x][checkP2.y] == " "):
  225.         if (lineCheck(p1, checkP2) and lineCheck(checkP2, p2)):
  226.             linePointStack.append(checkP2)
  227.             print("直角消除ok", checkP2.x, checkP2.y)
  228.             return True
  229.     print("不能直角消除")
  230.     return False;
  231.  
  232.  
  233. # -----------------------------------------
  234. '''
  235. #第三种，双直角连通
  236. 双直角联通判定可分两步走：
  237. 1. 在p1点周围4个方向寻找空格checkP
  238. 2. 调用OneCornerLink(checkP, p2)
  239. 3. 即遍历 p1 4 个方向的空格，使之成为 checkP,然后调用 OneCornerLink(checkP, 
  240. p2)判定是否为真，如果为真则可以双直角连同，否则当所有的空格都遍历完而没有找
  241. 到一个checkP使OneCornerLink(checkP, p2)为真，则两点不能连同
  242. 具体代码：
  244. 双直角连接方法
  245. @param p1 第一个点
  246. @param p2 第二个点
  247. '''
  248.  
  249.  
  250. def TwoCornerLink(p1, p2):
  251.     checkP = Point(p1.x, p1.y)
  252.     # 四向探测开始
  253.     for i in range(0, 4):
  254.         checkP.x = p1.x
  255.         checkP.y = p1.y
  256.         # 向下
  257.         if (i == 3):
  258.             checkP.y += 1
  259.             while ((checkP.y < Height) and map[checkP.x][checkP.y] == " "):
  260.                 linePointStack.append(checkP)
  261.                 if (OneCornerLink(checkP, p2)):
  262.                     print("下探测OK")
  263.                     return True
  264.                 else:
  265.                     linePointStack.pop()
  266.                 checkP.y += 1
  267.             print("ssss", checkP.y, Height - 1)
  268.             # 补充两个折点都在游戏区域底侧外部
  269.             if checkP.y == Height:  # 出了底部，则仅需判断p2能否也达到底部边界
  270.                 z = Point(p2.x, Height - 1)  # 底部边界点
  271.                 if lineCheck(z, p2):  # 两个折点在区域外部的底侧
  272.                     linePointStack.append(Point(p1.x, Height))
  273.                     linePointStack.append(Point(p2.x, Height))
  274.                     print("下探测到游戏区域外部OK")
  275.                     return True
  276.         # 向右
  277.         elif (i == 2):
  278.             checkP.x += 1
  279.             while ((checkP.x < Width) and map[checkP.x][checkP.y] == " "):
  280.                 linePointStack.append(checkP)
  281.                 if (OneCornerLink(checkP, p2)):
  282.                     print("右探测OK")
  283.                     return True
  284.                 else:
  285.                     linePointStack.pop()
  286.                 checkP.x += 1
  287.             # 补充两个折点都在游戏区域右侧外部
  288.             if checkP.x == Width:  # 出了右侧，则仅需判断p2能否也达到右部边界
  289.                 z = Point(Width - 1, p2.y)  # 右部边界点
  290.                 if lineCheck(z, p2):  # 两个折点在区域外部的底侧
  291.                     linePointStack.append(Point(Width, p1.y))
  292.                     linePointStack.append(Point(Width, p2.y))
  293.                     print("右探测到游戏区域外部OK")
  294.                     return True
  295.         # 向左
  296.         elif (i == 1):
  297.             checkP.x -= 1
  298.             while ((checkP.x >= 0) and map[checkP.x][checkP.y] == " "):
  299.                 linePointStack.append(checkP)
  300.                 if (OneCornerLink(checkP, p2)):
  301.                     print("左探测OK")
  302.                     return True
  303.                 else:
  304.                     linePointStack.pop()
  305.                 checkP.x -= 1
  306.         # 向上
  307.         elif (i == 0):
  308.             checkP.y -= 1
  309.             while ((checkP.y >= 0) and map[checkP.x][checkP.y] == " "):
  310.                 linePointStack.append(checkP)
  311.                 if (OneCornerLink(checkP, p2)):
  312.                     print("上探测OK")
  313.                     return True
  314.                 else:
  315.                     linePointStack.pop()
  316.                 checkP.y -= 1
  317.  
  318.     # 四个方向都寻完都没找到适合的checkP点
  319.     print("两直角连接没找到适合的checkP点")
  320.     return False;
  321.  
  322.  
  323. # ---------------------------
  324. # 画连接线
  325. def drawLinkLine(p1, p2):
  326.     if (len(linePointStack) == 0):
  327.         Line_id.append(drawLine(p1, p2))
  328.     else:
  329.         print(linePointStack, len(linePointStack))
  330.     if (len(linePointStack) == 1):
  331.         z = linePointStack.pop()
  332.         print("一折连通点z", z.x, z.y)
  333.         Line_id.append(drawLine(p1, z))
  334.         Line_id.append(drawLine(p2, z))
  335.     if (len(linePointStack) == 2):
  336.         z1 = linePointStack.pop()
  337.         print("2折连通点z1", z1.x, z1.y)
  338.         Line_id.append(drawLine(p2, z1))
  339.         z2 = linePointStack.pop()
  340.         print("2折连通点z2", z2.x, z2.y)
  341.         Line_id.append(drawLine(z1, z2))
  342.         Line_id.append(drawLine(p1, z2))
  343.  
  344.  
  345. # 删除连接线
  346. def undrawConnectLine():
  347.     while len(Line_id) > 0:
  348.         idpop = Line_id.pop()
  349.         cv.delete(idpop)
  350.  
  351.  
  352. def drawLine(p1, p2):
  353.     print("drawLine p1,p2", p1.x, p1.y, p2.x, p2.y)
  354.     # cv.create_line( 40+20, 40+20,200,200,width=5,fill='red')
  355.     id = cv.create_line(p1.x * 40 + 20, p1.y * 40 + 20, p2.x * 40 + 20, p2.y * 40 + 20, width=5, fill='red')
  356.     # cv.pack()
  357.     return id
  358.  
  359.  
  360. # --------------------------------------
  361. def create_map():  # 产生map地图
  362.     global map
  363.     # 生成随机地图
  364.     # 将所有匹配成对的动物物种放进一个临时的地图中
  365.     tmpMap = []
  366.     m = (Width) * (Height) // 10
  367.     print('m=', m)
  368.     for x in range(0, m):
  369.         for i in range(0, 10):  # 每种方块有10个
  370.             tmpMap.append(x)
  371.     random.shuffle(tmpMap)
  372.     for x in range(0, Width):  # 0--14
  373.         for y in range(0, Height):  # 0--14
  374.             map[x][y] = tmpMap[x * Height + y]
  375.  
  376.  
  377. # --------------------------------------
  378. def find2Block(event):  # 自动查找
  379.     global firstSelectRectId, SecondSelectRectId
  380.     m_nRoW = Height
  381.     m_nCol = Width
  382.     bFound = False;
  383.     # 第一个方块从地图的0位置开始
  384.     for i in range(0, m_nRoW * m_nCol):
  385.         # 找到则跳出循环
  386.         if (bFound):
  387.             break
  388.  
  389.         # 算出对应的虚拟行列位置
  390.         x1 = i % m_nCol
  391.         y1 = i // m_nCol
  392.         p1 = Point(x1, y1)
  393.         # 无图案的方块跳过
  394.         if (map[x1][y1] == ' '):
  395.             continue
  396.         # 第二个方块从前一个方块的后面开始
  397.         for j in range(i + 1, m_nRoW * m_nCol):
  398.             # 算出对应的虚拟行列位置
  399.             x2 = j % m_nCol
  400.             y2 = j // m_nCol
  401.             p2 = Point(x2, y2)
  402.             # 第二个方块不为空 且与第一个方块的动物相同
  403.             if (map[x2][y2] != ' ' and IsSame(p1, p2)):
  404.                 # 判断是否可以连通
  405.                 if (IsLink(p1, p2)):
  406.                     bFound = True
  407.                     break
  408.     # 找到后自动消除
  409.     if (bFound):  # p1（x1,y1）与p2（x2,y2）连通
  410.         print('找到后', p1.x, p1.y, p2.x, p2.y)
  411.         # 画选定（x1,y1)处的框线
  412.         firstSelectRectId = cv.create_rectangle(x1 * 40, y1 * 40, x1 * 40 + 40, y1 * 40 + 40, width=2, outline="red")
  413.         # 画选定（x2,y2)处的框线
  414.         secondSelectRectId = cv.create_rectangle(x2 * 40, y2 * 40, x2 * 40 + 40, y2 * 40 + 40, width=2, outline="red")
  415.         # t=Timer(timer_interval,delayrun)#定时函数
  416.         # t.start()
  417.  
  418.     return bFound
  419.  
  420.  
  421. # 游戏主逻辑
  422. root = Tk()
  423. root.title("Python连连看 ")
  424. imgs = [PhotoImage(file='images\\bar_0' + str(i) + '.gif') for i in range(0, 10)]  # 所有图标图案
  425. Select_first = False  # 是否已经选中第一块
  426. firstSelectRectId = -1  # 被选中第一块地图对象
  427. SecondSelectRectId = -1  # 被选中第二块地图对象
  428. clearFlag = False
  429. linePointStack = []
  430. Line_id = []
  431. Height = 10
  432. Width = 10
  433. map = [[" " for y in range(Height)] for x in range(Width)]
  434. image_map = [[" " for y in range(Height)] for x in range(Width)]
  435. cv = Canvas(root, bg='green', width=440, height=440)
  436. # drawQiPan( )
  437. cv.bind("<Button-1>", callback)  # 鼠标左键事件
  438. cv.bind("<Button-3>", find2Block)  # 鼠标右键事件
  439. cv.pack()
  440. create_map()  # 产生map地图
  441. print_map()  # 打印map地图
  442. root.mainloop()

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。本文链接：

https://blog.csdn.net/xw1680/article/details/116201057

推荐阅读    点击标题可跳转

Python之父推荐！《Python 3网络爬虫开发实战》第二版来了！文末送签名版！

分享3个好用到爆的Python模块，点赞收藏

用Python可视化分析全球火山分布，发现了这些有趣的现象

【原创干货】6000字、22个案例详解Pandas数据分析/预处理时的实用技巧，超简单

db81f69f39567b1f0db032b4a8709d87.gif

点击这里，阅读更多

Python

文章！

文章知识点与官方知识档案匹配，可进一步学习相关知识
OpenCV技能树首页概览24703 人正在系统学习中
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/171756?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号