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部分-关闭窗口

程序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部分-关闭窗口

程序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()     

代码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()           

程序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()

游戏重新开始
玩家总点数: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>]

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

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

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

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

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