python3-GUI概述及应用

一、什么是GUI

图形用户界面（Graphical User Interface，简称 GUI，又称图形用户接口）是指采用图形方式显示的计算机操作用户界面。
图形用户界面是一种人与计算机通信的界面显示格式，允许用户使用鼠标等输入设备操纵屏幕上的图标或菜单选项，以选择命令、调用文件、启动程序或执行其它一些日常任务。与通过键盘输入文本或字符命令来完成例行任务的字符界面相比，图形用户界面有许多优点。
图形用户界面由窗口、下拉菜单、对话框及其相应的控制机制构成，在各种应用程序中都是标准化的，即相同的操作总是以同样的方式来完成，在图形用户界面，用户看到和操作的都是图形对象，底层应用的是计算机图形学的技术。

二、Python GUI

Python主要有以下GUI库：
1、Tk/Tcl
Tk/Tcl长期以来一直是Python不可或缺的一部分。它提供了一个健壮且独立于平台的窗口工具包，Python程序员可以使用tkinter包及其扩展tkinter来使用该工具包。Tix和tkinter。ttk模块。
tkinter包是Tcl/Tk之上的一个面向对象的薄层。要使用tkinter，不需要编写Tcl代码，但需要参考Tk文档，偶尔也需要参考Tcl文档。tkinter是一组包装器，将Tk小部件实现为Python类。此外，内部模块_tkinter提供了一个线程安全机制，允许Python和Tcl交互。
tkinter的主要优点是速度快，并且通常与Python捆绑在一起。
2、PyGObject
PyGObject使用GObject为C库提供了内省绑定。其中一个库是GTK+ 3小部件集。GTK+附带的小部件比Tkinter提供的要多得多。
3、PyGTK
PyGTK为旧版本的库GTK+ 2提供了绑定。它提供了一个面向对象的接口，其级别略高于C接口。也有到GNOME的绑定。
4、PyQt
PyQt是对Qt工具包的封装绑定。Qt是一个广泛的c++ GUI应用开发框架，可用于Unix, Windows和Mac OS x。sip是一个为Python类生成c++库绑定的工具，是专门为Python设计的。
5、PyQt
PyQt是对Qt工具包的封装绑定。Qt是一个广泛的c++ GUI应用开发框架，可用于Unix, Windows和Mac OS x。sip是一个为Python类生成c++库绑定的工具，是专门为Python设计的。
6、wxPython
wxPython是一个跨平台的Python GUI工具包，它是围绕流行的wxWidgets(以前是wxWindows) c++工具包构建的。它通过尽可能地使用每个平台的本机小部件(类Unix系统上的GTK+)，为Windows、Mac OS X和Unix系统上的应用程序提供本机外观和感觉。除了一组广泛的小部件外，wxPython还提供了用于在线文档和上下文敏感帮助、打印、HTML查看、低层设备上下文绘制、拖放、系统剪贴板访问、基于xml的资源格式等的类，包括一个不断增长的用户贡献模块库。
7、Web (Remi)
Remi是一个用于在web浏览器中呈现Python应用程序的GUI库。这允许您在本地和远程访问您的接口。
8、PySimpleGUI
在2018年推出，创建自定义GUI的超级简单，非常适合初学者和高级GUI程序员。它通过使用初学者能够理解的Python核心数据类型(列表和字典)，简化窗口定义，并通过将事件处理从基于回调的模型更改为传递消息的模型，可以进一步简化事件处理。

PySimpleGUI概述

一、PySimpleGUI简介

PySimpleGUI是一个Python包，它允许所有级别的Python程序员创建gui。与直接使用底层框架编写相比，PySimpleGUI代码更简单、更短，因为PySimpleGUI实现了许多“样板代码”。此外，接口被简化为需要尽可能少的代码来获得期望的结果。根据所使用的程序和框架，一个PySimpleGUI程序可能需要1/2到1/10的代码量来直接使用其中一个框架创建一个相同的窗口。
PySimpleGUI可以使用包含小部件(在PySimpleGUI中称为“元素”)的“布局”来指定GUI窗口，布局用于创建一个窗口，使用支持的4个框架之一来显示和与窗口交互。支持的框架包括tkinter、Qt、WxPython或Remi。虽然目标是封装/隐藏运行在GUI框架上的特定对象和代码，但如果需要，可以直接访问框架的依赖小部件和窗口。

二、PySimpleGUI特征

PySimpleGUI具有以下特征：
1、将tkinter、Qt、WxPython和Remi(基于浏览器)GUI框架转换为更简单的界面。通过使用初学者能够理解的Python核心数据类型(列表和字典)，窗口定义得到了简化。
2、通过将事件处理从基于回调的模型更改为传递消息的模型，可以进一步简化事件处理。
3、代码不需要具有面向对象的体系结构，从而使包可以被更大的受众使用。
4、虽然体系结构很容易理解，但它并不一定只能在处理简单的问题。

三、输出设备

1、桌面GUI。
2、web浏览器中运行GUI。可通过PySimpleGUIWeb，运行一个永远不会退出的Web程序，在WEB端输出，这种情况最适合没有显示器的应用，如树莓派的核心机器人或其他设计，然后使用浏览器转到运行PySimpleGUI的硬件设备IP地址(和端口#)，就可连接到应用程序，与应用程序进行通信，使用它进行配置更改，甚至可以使用Web GUI中的按钮控制机器人或其他硬件。

hello,world

一、PySimpleGui的安装与配置
如果系统中只有Python3版本，则可运行下面2个命令中任一个，否则运行第2个命令，完成安装与配置。
pip install pysimplegui
pip3 install pysimplegui
二、简单的hello,world
程序2-8-3-1.py的功能是，在屏幕上显示一个hello,world的窗口。用户按OK按钮后退出程序。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#2-8-3-1.py
import PySimpleGUI as sg                        # 第1部分-导入
# 定义窗口内容
layout = [  [sg.Text("hello,world")],     # 第2部分 - 指定布局（The Layout）
            [sg.Text("你好，世界")],
            [sg.Button('Ok')] ]
# 创建窗口
window = sg.Window('hello', layout)      # 第3部分-窗口定义

#显示和与窗口交互
event, values  = window.read()     # 第4部分-事件循环或调用window.read

#最后从屏幕上移除
window.close()                    # 第5部分-关闭窗口
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

程序2-8-3-1.py分为5个部分：
1、第1部分导入PySimpleGUI，别名为sg。
2、第2部分定义窗口内容，实质就是指定窗口的布局layout。
窗口总体从上到下分为3个内容：文本框"hello,world"、文本框"你好，世界"以及OK按钮。
3、第3部分使用第2部分定义的窗口布局layout，创建窗口。
4、第4部分创建事件循环或调用window.read，这样窗口才可以显示。其中，事件在
5、第5部分关闭窗口。
程序运行结果如下图所示：

程序2-8-3-2.py的功能是，在屏幕上显示一个hello,world的窗口，但增加一个用户输入的部分，让用户可输入自己的名字，并在用户按OK按钮后退出程序前在控制台输出用户名字，向用户问好。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#2-8-3-1.py
import PySimpleGUI as sg                          # 第1部分-导入

# 定义窗口内容
layout = [  [sg.Text("hello,world")],       # 第2部分 - 指定层次（The Layout）
            [sg.Text("你好，世界")],
            [sg.Text("如何称呼您?")],     
            [sg.Input()],            
            [sg.Button('Ok')] ]

# 创建窗口
window = sg.Window('hello world', layout)      # 第3部分-窗口定义


#显示和与窗口交互
event, values  = window.read()                   # 第4部分-事件循环或调用window.read

print(values[0],",很高兴认识您！")
#最后从屏幕上移除
window.close()                                   # 第5部分-关闭窗口
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

程序2-8-3-1.py分为5个部分：
6、第1部分导入PySimpleGUI，别名为sg。
7、第2部分定义窗口内容，实质就是指定窗口的布局layout。
窗口总体从上到下分为5个内容：文本框"hello,world"、文本框"你好，世界"、文本框"如何称呼您"以及OK按钮。
8、第3部分使用第2部分定义的窗口布局layout，创建窗口。
9、第4部分创建事件循环或调用window.read，这样窗口才可以显示，才可以接受用户交互输入。其中，事件在event中，而交互输入结果在values中。
10、第5部分关闭窗口。

程序2-8-3-2.py运行结果如下图所示。

控制台输出结果如下：
张三 ,很高兴认识您！

猜数字

猜数字游戏就是1-100中随机产生一个数字，然后开始猜产生的数字是多少，当猜的数字比实际数字大时，提示玩家数字大了，当猜的数字比实际数字小时，提示玩家数字小了，当猜的数字正好是实际数字时，游戏挑战成功。

一、玩家猜数字

代码2-8-4-1.py演示了由玩家（人类）猜数字游戏。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#2-8-4-1.py
import PySimpleGUI as sg     
import random as rnd


playNum=rnd.randint(1,100)
gameShowMess=["猜对了，新的随机数已经重新生成！","您猜的数字大了","您猜的数字小了"]
# 定义窗口内容
layout = [  [sg.Text("计算机随机生成1-100以内的一个数字。\n请您猜测这个数字是多少?")],      
            [sg.Text("请输入您猜的数字")],     
            [sg.Input()],        
            [sg.Text(size=(40,2), key='-OUTPUT-')],
            [sg.Button('Ok'), sg.Button('Cancel')] ]
# 创建窗口
window = sg.Window('猜数字游戏', layout)      
#显示和与窗口交互
while True:
    event, values = window.read()
    if event == sg.WIN_CLOSED or event == 'Cancel': 
        break
    guessNum=int(values[0])
    gameState=guessNum-playNum
    if gameState>0: 
        gameState=1
    elif gameState<0:
        gameState=2  
    else:
        playNum=rnd.randint(1,100)
    window['-OUTPUT-'].update('你猜的数字是： ' + str(guessNum) + "!\n"+gameShowMess[gameState])

               

print(values[0])
#最后从屏幕上移除
window.close()     
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

代码2-8-4-1.py的执行结果如下：

代码2-8-4-1.py的执行过程如下：
1、导入PySimpleGUI库，以便后面调用其GUI功能，再导入random库，以便后面调用其随机数功能。
2、先定义变量playNum，取值为1到100内的随机数；再定义gameShowMess，存放猜数结果提示消息，这个变量是一个列表，第0个元素表示猜数成功，第1个元素表示猜的数字大了，第2个元素表示猜的数字小了。
3、定义窗口内容，从上到下有以下构件：
（1）2个文本，分别提示抽数规则和玩家输入数字。
（2）1个输出框，接受玩家输入猜测的数字。
（3）1个文本框，用于显示游戏过程。
（4）从左到右2个按钮，分别为确定和取消。
4、根据第3步定义的窗口内容，创建窗口。
5、显示窗口和与窗口交互。
（1）创建while循环，循环条件为永远为True
（2）循环体完成以下功能：
首先，读取窗口事件（OK或cancel按钮以及窗口事件）和窗口交互输入内容（猜的数字）；接着，对事件进行判断，如果玩家点击了cancel按钮或关闭窗口，则退出循环，这也是退出第（1）步创建的循环的唯一方法；然后，得到玩家输入的猜的数字到变量guessNum中，并计算猜数和实际数的差额存到变量gameState中；再然后，对gameState差额进行分析，如果猜数大了或小了，重新设置gameState值，该值用于访问gameShowMess列表的索引，以便显示相应的猜数结果（取自gameShowMess列表）。
如果猜数大了，索引为1；如果猜数小了，索引为2；否则就是猜中了，索引为0（不用重新设置，因为gameState在前一步计算时已经为0）。此外，如果结果是猜中了，则重新生成随机数，开始新一轮的游戏；最后，根据gameState值在用于显示游戏过程的文本构件中更新本轮猜数情况。
6、循环结束，从屏幕上移除窗口。

二、电脑猜数字

1、二分法
在数学领域中，对于区间[a，b]上连续不断且f（a）·f（b）<0的函数y=f（x），通过不断地把函数f（x）的零点所在的区间一分为二，使区间的两个端点逐步逼近零点，进而得到零点近似值的方法叫二分法。
将数学意义上的二分法扩展一下，形成二分查找法：二分查找也称折半查找（Binary Search），它是一种效率较高的查找方法。但是，折半查找要求线性表必须采用顺序存储结构，而且表中元素按关键字有序排列。
首先，假设表中元素是按升序排列，将表中间位置记录的关键字与查找关键字比较，如果两者相等，则查找成功；否则利用中间位置记录将表分成前、后两个子表，如果中间位置记录的关键字大于查找关键字，则进一步查找前一子表，否则进一步查找后一子表。重复以上过程，直到找到满足条件的记录，使查找成功，或直到子表不存在为止，此时查找不成功。
2、自动猜数字算法
该算法的过程如下：
(1)生成需要猜的随机数或由玩家输入要猜的数为A。
(2)设置数的查找范围为[a,b]。
(3)从这一步开始，应用二分查找法找到正确的猜数。取[a,b]的中间int((a+b)/2)，将该位置设置为中间位置，取中间位置的数B与要猜的随机数A对比，对比有3种结果：相等、B大了、B小了。
(4)如果对比结果为相等，则算法结束，找到要猜的数。
(5)如果对比结果为B大了，则将b设为B，如果对比结果为B小了，则将a设为B。这样新的查找范围更新缩小了很多。
(6)回到第（3）步，继续下一轮二分查找。
3、代码实现
程序2-8-4-2.py实现了自动猜数字算法。

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#2-8-4-2.py
import PySimpleGUI as sg     
import random as rnd
import time



guessNum=rnd.randint(1,100)
gameShowMess=["猜对了！","猜的数字大了","猜的数字小了"]
# 定义窗口内容
layout = [  [sg.Text("请输入您要机器猜的数字(1-100)")],     
            [sg.Input()],        
            [sg.Output(size=(40,2), key='-OUTPUT-')],
            [sg.Button('Ok'), sg.Button('Cancel')] ]

# 创建窗口
window = sg.Window('猜数字游戏', layout)      

minNum=1
maxNum=100

#显示和与窗口交互
while True:
    isGameContinue=True
    event, values = window.read()
    if event == sg.WIN_CLOSED or event == 'Cancel': 
        break
    playNum=int(values[0])
    gameState=guessNum-playNum
    while isGameContinue and playNum>=1 and  playNum<=100:  
        gameState=guessNum-playNum
        if gameState>0: 
            gameState=1
            maxNum=guessNum
            
        elif gameState<0:
            gameState=2  
            minNum=guessNum

        else:
            minNum=1
            maxNum=100  
            isGameContinue=False   
        window['-OUTPUT-'].update(window['-OUTPUT-'].Get()+'机器猜的数字是： ' + str(guessNum) + "!"+gameShowMess[gameState])
        guessNum=int((minNum+maxNum)/2)
               


#最后从屏幕上移除
window.close()           
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52

程序2-8-4-2.py的执行结果如下：

程序2-8-4-2.py执行过程如下：
1、导入PySimpleGUI库，以便后面调用其GUI功能，再导入random库，以便后面调用其随机数功能。
2、先定义变量guessNum，取值为1到100内的随机数，此变量表示机器猜的数字，并非实际数；再定义gameShowMess，存放猜数结果提示消息，这个变量是一个列表，第0个元素表示猜数成功，第1个元素表示猜的数字大了，第2个元素表示猜的数字小了。
3、定义窗口内容，从上到下有以下构件：
（1）1个文本，提示玩家要机器猜的数字(1-100)。
（2）1个输入框，接受玩家输入猜测的数字。
（3）1个输出框，用于显示游戏过程。
（4）从左到右2个按钮，分别为确定和取消。
4、 根据第3步定义的窗口内容，创建窗口，并定义minNum（用于二分法的查找范围的最小数）和maxNum（用于二分法的查找范围的最大数）共2个变量值分别为1和100。
5、 创建while循环（此循环为外循环），显示窗口和与窗口交互。
（1） 将循环条件设为True，接着，开始如下循环:
（2） 读取窗口事件（OK或cancel按钮以及窗口事件）和窗口交互输入内容（猜的数字）
（3） 对事件进行判断，如果玩家点击了cancel按钮或关闭窗口，则退出循环。
（4） 将机器自动猜的数字到变量guessNum中，计算猜数和实际数的差额存到变量gameState中。
（5） 再定义一个循环体（此循环体为内循环），此时形成了内外2个循环体：外循环开始处使用event读取玩家事件，values接受玩家输入，以及初始化内循环需要条件isGameContinue（设置为True，以便内循环体首次可运行）；内循环体的条件是isGameContinue and playNum>=1 and playNum<=100（and表示而且），其中，isGameContinue表示猜数是否继续（为True表示继续）， playNum>=1 and playNum<=100表示玩家给出要猜的数字在1-100之内。
内循环体内容如下：
①计算猜数和实际数的差额存到变量gameState中。
②对gameState差额进行分析，如果猜数guessNum大或小了，重新设置gameState值，该值用于访问gameShowMess列表的索引，以便显示相应的猜数结果（取自gameShowMess列表）。
如果猜数guessNum大了，索引为1，变量maxNum值设为猜数guessNum；如果猜数guessNum小了，索引为2，变量minNum值设为猜数guessNum；否则就是猜中了，索引为0（不用重新设置，因为gameState在前一步计算时已经为0），将变量minNum初始化为1，变量maxNum初始化为100，并将内循环条件isGameContinue设置为False，表示结束内循环，程序重新回到外循环体起始处执行，程序将提示玩家输入新要猜的数字，开始新一轮的游戏。
③根据gameState值在输出构件中更新本轮游戏猜数情况。
④计算机器下次猜的数字，取查找范围的中间数字，即：int((minNum+maxNum)/2)
6、外循环结束，从屏幕上移除窗口。

21点游戏

一、21点游戏简介

21点又名BlackJack，。该游戏由2到6个人玩，使用除大小王之外的52张牌，游戏者的目标是使手中的牌的点数之和不超过21点且尽量大，以游戏只有2个人为例，在不超过21点的情况下，大者胜利，如果以一方超过21点，则该失败，另一方赢得此局，游戏中的任何一方可以选择在某轮终止抽牌。2至9牌，按其原点数计算；K、Q、J和10牌都算作10点（一般记作T，即ten之意）；A 牌（ace）算作1点。
为方便程序设计与讲解，在此将扑克牌使用数字代替，并将规则改为：玩家和电脑轮流从1-10中抽取1个数，使手中的数之和不超过21点且尽量大，游戏中的任何一方可以选择在某轮终止抽牌。

二、程序代码

#      /usr/bin/env python3
# -*- coding: utf-8 -*-
#2-8-4-2.py
import PySimpleGUI as sg     
import random as rnd
import time
from enum import Enum


playerNums=[]
playerNumSum=0
computerNums=[]
computerNumSum=0
computerWin=False
playerWin=False
GamePlayer=Enum('GamePlayer', 'COMPUTER PLAYER')
gameShowMess=["玩家停止抽数！","玩家继续抽数：","电脑停止抽数","电脑继续抽数："]

def UpdateStatus(statusStr,window):
    window['-OUTPUT-'].update(statusStr+ "\n"+window['-OUTPUT-'].Get())

    
def AddRndNum(gamePlayer):
    global  playerNumSum,computerNumSum
    if gamePlayer==GamePlayer.COMPUTER:
        computerNum=rnd.randint(1,10)
        computerNums.append(computerNum)  
        computerNumSum+=computerNum
        return computerNum   
    else:            
        playerNum=rnd.randint(1,10)
        playerNums.append(playerNum)
        playerNumSum+=playerNum
        return playerNum

def AddPlayerNum(window):
    nRes=AddRndNum(GamePlayer.PLAYER)
    UpdateStatus(gameShowMess[1] + str(nRes) + "      总点数:"+ str(GetPlayerSum()),window) 
    return GetPlayerSum()
    
    
def AddComputerNum(window):
    nRes=AddRndNum(GamePlayer.COMPUTER)
    UpdateStatus(gameShowMess[3] + str(nRes) + "      总点数:"+ str(GetComputerSum()),window) 
    return GetComputerSum()
    
def GetPlayerSum():
    return playerNumSum
def GetComputerSum():
    return computerNumSum
    
def isGameOver(isGameContine):
    computerWin=playerWin=gameOver=False
    if  GetPlayerSum()>21 and GetComputerSum()<=21 :
        computerWin=True 
        playerWin=False  
        gameOver=True
    elif  GetComputerSum()>21 and GetPlayerSum()<=21:
        computerWin=False 
        playerWin=True 
        gameOver=True
    elif  GetComputerSum()>=21 and GetPlayerSum()>=21:
        gameOver=True
    elif (not isGameContine):
        if  GetComputerSum()>GetPlayerSum():
            computerWin=True
            playerWin=False 
            gameOver=True  
        elif GetComputerSum()==GetPlayerSum():
            gameOver=True  
        else:
            computerWin=False 
            playerWin=True 
            gameOver=True   
        
    return (computerWin,playerWin,gameOver)

def main():   
    global playerNums,playerNumSum,computerNums,computerNumSum,computerWin,playerWin

    # 定义窗口内容
    layout = [  [sg.Text("您是否继续抽数？")],            
                [sg.Button('Yes'), sg.Button('No'),sg.Button('Exit')],
                [sg.Output(size=(40,2), key='-OUTPUT-')]]
    
    # 创建窗口
    window = sg.Window('21点游戏', layout)      
    
    isComputerContinue=True
    isPlayerContinue=True
    #显示和与窗口交互
    while True:
        if isPlayerContinue:
            event, values = window.read()
        if event == sg.WIN_CLOSED or event == 'Exit': 
            break
        if isPlayerContinue: 
            if event == 'Yes':
                UpdateStatus("玩家确定抽数",window)
            elif event == 'No':
                UpdateStatus("玩家放弃抽数",window)  
                isPlayerContinue=False      
        else:
            UpdateStatus("玩家放弃抽数",window)
            
        if isComputerContinue and GetComputerSum()<17:
            UpdateStatus("电脑确定抽数",window) 
        else:
            UpdateStatus("电脑放弃抽数",window) 
            isComputerContinue=False
            
        if isPlayerContinue:  
            AddPlayerNum(window)
        if isComputerContinue :
            AddComputerNum(window)
        if isComputerContinue or isPlayerContinue:
            (cWin,pWin,isGameEnd)=isGameOver(True)
        else:
            (cWin,pWin,isGameEnd)=isGameOver(False)
            isGameRestart=True         
        isGameRestart=False
        if pWin:
            UpdateStatus("玩家赢了",window)
            isGameRestart=True          
        elif cWin:
            UpdateStatus("电脑赢了",window)  
            isGameRestart=True 
        
        if (not pWin) and (not cWin) and isGameEnd:
            UpdateStatus("电脑和玩家都没有赢",window)
            isGameRestart=True 

                
           
        if  isGameRestart:
            UpdateStatus(" 玩家总点数:"+ str(GetPlayerSum())+"！电脑总点数："+ str(GetComputerSum()),window) 
            isComputerContinue=True
            isPlayerContinue=True
            playerNums=[]
            playerNumSum=0
            computerNums=[]
            computerNumSum=0
            computerWin=False
            playerWin=False  
            UpdateStatus("游戏重新开始",window)


  


                
    
    
    #最后从屏幕上移除

    window.close()   

if __name__ == "__main__":
    main()
    exit()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

游戏重新开始
玩家总点数:20！电脑总点数：20
电脑和玩家都没有赢
电脑放弃抽数
玩家放弃抽数
玩家继续抽数：5 总点数:20
电脑放弃抽数
玩家确定抽数
电脑继续抽数：5 总点数:20
玩家继续抽数：1 总点数:15
电脑确定抽数
玩家确定抽数
电脑继续抽数：1 总点数:15
玩家继续抽数：3 总点数:14
电脑确定抽数
玩家确定抽数
电脑继续抽数：3 总点数:14
玩家继续抽数：1 总点数:11
电脑确定抽数
玩家确定抽数
电脑继续抽数：7 总点数:11
玩家继续抽数：9 总点数:10
电脑确定抽数
玩家确定抽数
电脑继续抽数：4 总点数:4
玩家继续抽数：1 总点数:1
电脑确定抽数
玩家确定抽数
游戏重新开始
玩家总点数:21！电脑总点数：22
玩家赢了
电脑继续抽数：9 总点数:22
玩家继续抽数：3 总点数:21
电脑确定抽数
玩家确定抽数
电脑继续抽数：4 总点数:13
玩家继续抽数：8 总点数:18
电脑确定抽数
玩家确定抽数
电脑继续抽数：9 总点数:9
玩家继续抽数：10 总点数:10
电脑确定抽数
玩家确定抽数

对2-8-4-2.py分析如下：
1、导入程序需要使用的库。
（1）导入GUI库PySimpleGUI，并指定别名为sg。
import PySimpleGUI as sg
（2）导入随机数库random
import random as rnd
（3）导入时间库time
Import time
time 模块可进行时间处理，也可转换时间格式。
（4）导入enum枚举库
from enum import Enum
枚举是与多个唯一常量值绑定的一组符号名（即成员）。枚举中的成员可以进行身份比较，并且枚举自身也可迭代。enum定义了4个枚举类，可定义名称与值的唯一组合，它们是 Enum、IntEnum、Flag 和 IntFlag。
class enum.Enum用于创建枚举常量的基类；class enum.IntEnu用于创建 int 子类枚举常量的基类；class enum.IntFlag用于创建可与位运算符搭配使用，又不失去 IntFlag 成员资格的枚举常量的基类；class enum.Flag用于创建可与位运算符搭配使用，又不会失去 Flag 成员资格的枚举常量的基类。
2、定义游戏用变量
（1）抽数列表变量，存储玩家每轮抽取的数字，每个元素为玩家本轮每次抽取的数字。
playerNums=[]
（2）本轮抽数总计。
playerNumSum=0
（3）抽数列表变量，存储电脑每轮抽取的数字，每个元素为电脑本轮每次抽取的数字。
computerNums=[]
（4）电脑本轮抽数总计。
computerNumSum=0
（5）电脑赢取游戏否
computerWin=False
（6）玩家赢取游戏否
playerWin=False
（7）游戏玩家的枚举变量
GamePlayer=Enum(‘GamePlayer’, ‘COMPUTER PLAYER’)
Enum 类属于可调用对象，它提供了功能性 API，可直接使用Enum函数创建枚举。比如下面代码段，首先通过Enum(‘Animal’, ‘ANT BEE CAT DOG’)定义动物枚举变量Animal，该变量包括ANT、BEE、CAT、DOG共4种动物；接着通过Animal.ANT输出ANT枚举名和枚举值，通过 Animal.ANT.value输出ANT的枚举值；最后，通过list函数将Animal变量转化为列表类型，并输出4个枚举成员。

>>> Animal = Enum('Animal', 'ANT BEE CAT DOG')
>>> Animal
<enum 'Animal'>
>>> Animal.ANT
<Animal.ANT: 1>
>>> Animal.ANT.value
1
>>> list(Animal)
[<Animal.ANT: 1>, <Animal.BEE: 2>, <Animal.CAT: 3>, <Animal.DOG: 4>]
1
2
3
4
5
6
7
8
9

（8）定义提示信息列表，每个元素为需要显示的文本提示。
gameShowMess=[“玩家停止抽数！”,“玩家继续抽数：”,“电脑停止抽数”,“电脑继续抽数：”]
3、定义刷新提示消息的函数UpdateStatus。

def UpdateStatus(statusStr,window):
   window['-OUTPUT-'].update(statusStr+ "\n"+window['-OUTPUT-'].Get())
1
2

其中，window[‘-OUTPUT-’] 表示GUI中关键字为“-OUTPUT-”的组件，该组件是OUTPUT组件，具有快速添加在窗口中显示滚动文本的能力， 用户将在窗口内看到一个滚动的文本区域。
观察UpdateStatus函数体代码，通过对window[‘-OUTPUT-’]的update方法调用，完成消息更新，调用参数是需要显示的文本字符串。也可通过print函数完成更新，任何“打印”的内容都将显示在这个元素中， 也是一种显示滚动文本的“简单”方法。 上面函数体也可如下定义：

def UpdateStatus(statusStr,window):
  print(statusStr)
1
2

4、抽数并更新游戏点数的函数 AddRndNum。

def AddRndNum(gamePlayer):
    global  playerNumSum,computerNumSum
    if gamePlayer==GamePlayer.COMPUTER:
        computerNum=rnd.randint(1,10)
        computerNums.append(computerNum)  
        computerNumSum+=computerNum
        return computerNum   
    else:            
        playerNum=rnd.randint(1,10)
        playerNums.append(playerNum)
        playerNumSum+=playerNum
        return playerNum
1
2
3
4
5
6
7
8
9
10
11
12