
## 为什么要封装？

pygame写起游戏都是函数式编写，对于一些简单的小游戏或许可以应付，随着游戏内容的增加，我们不可能只在一个.py文件中写下所有的游戏代码，这个时候，我们应该考虑对游戏中组件及对象进行封装，用面向对象的方式来进行游戏代码的编写。

## 一些具体的封装内容

游戏中的关键词，假设游戏没有条件判断，那么游戏从头运行到尾就是一部电影。
这样的话，我们定义一些游戏的基本对象：

+ 渲染器（APP）--只负责渲染游戏场景中存在的游戏片段，属性有：一个游戏片段容器及一些游戏窗口常用设置，并初始化游戏设置。
+ 游戏片段(scene)--可能是游戏中的一个片段，一个情节，一节过场，片头，片尾等，游戏片段中包含一个开关属性，用来控制是否可以渲染此游戏片段。
+ 游戏逻辑判断器--游戏中的裁判，负责判断修改游戏中的执行条件。
+ 精灵--游戏中的角色，他可以是游戏中的场景，主角，配角，怪物，子弹，文字对白。
+ 工具类包括：场景中文字渲染工具，游戏中的素材目录的定制，方便调用。一些其它可能需要重复使用的工具。



## 定义渲染器

渲染器定义为一个游戏的APP，他应该是这个游戏的最外层，可以定义他的，分辨率，标题，刷新频率。
如果游戏中有精灵贯穿全局（比如RPG游戏中的主要角色），这种精灵角色他不属于某个游戏片段，这样他应该存在于这个游戏app中。


## 定义游戏片段

一个gameApp中，至少得有一个游戏片段，游戏片段包括三个主要方法：

    draw() update() handle_event()

这三个方法分别对应:

+ 渲染场景
+ 更新数据 
+ 事件处理

当我们继承新建游戏片段类的时候，需要根据自己的需求重写这三个方法。

## 如何使用PY_RPG？

    app = GameApp()#创建游戏
    appscreen = app.screen#获取渲染器
    app.scenes.append(MainScene(appscreen))#创建游戏菜单
    app.scenes.append(TestScene(appscreen))#创建游戏内容
    app.scenes.append(GameOverScene(appscreen))#游戏结束画面
    app.run() #游戏开始

根据需要创建并重写上边的三个类，然后创建游戏就可以了，现在这样看来，游戏的创建是不是很有层次了？

这个框架还没有封装完毕，我还会继续的，之后的游戏制作都要从这个框架上弄起了，初步还要写几个完整的小游戏例子。

以下为游戏效果图，建议下载相关代码跑一下，有问题可以留言给我。

![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/12/Snip20171228_5.png)

![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/12/Snip20171228_6.png)

![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/12/Snip20171228_7.png)

## 本文源码下载

请git clone My_pygame下所有代码，以免造成游戏跑不起来的情况。本例源文件在PY_RPG目录下

+ [github](https://github.com/bosichong/My_pygame/)
+ [开源中国码云镜像gitee](https://gitee.com/J_Sky/My_pygame/)

pygame写起游戏都是函数式编写，对于一些简单的小游戏或许可以应付，随着游戏内容的增加，我们不可能只在一个.py文件中写下所有的游戏代码，这个时候，我们应该考虑对游戏中组件及对象进行封装，用面向对象的方式来进行游戏代码的编写。

“编学编玩”用Pygame编写游戏（6）PY_RPG 一个pygame的简单封装。


![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/12/Snip20171224_4.png)

python中有没有文件目录选择对话框？答案是肯定的，这个可以有。tkinter.filedialog这个模块就是负责选择文件及目录的。

## tkinter.filedialog的测试

创建一个tk的窗口，包括一个文本框、按键及一个列表框，这些的创建都是很简单的，其中文本框及列表框中的关联数据我们采用tk中特有的绑定数据模式，具体可以查看代码。
测试代码中有一个是按键回调方法filedir，主要是用来弹出目录选择对话框的,filedialog中有很多比较用用的对话框：


    'askdirectory',
    'askopenfile',
    'askopenfilename',
    'askopenfilenames',
    'askopenfiles',
    'asksaveasfile',
    'asksaveasfilename'

以上是通过print(dir(filedialog))打印查看到的，也可以通过源码查看到，通过单词字面应该大体上可以了解到这些函数弹出的对话框是干什么用的。

好了，具体测试源码如下：

'''


    import tkinter.filedialog as filedialog
    from tkinter import *
    import os
    
    def filedir():
        print('按键已被点击')
        v.set('')#清空文本框里内容
        var.set((('')))
        path = filedialog.askdirectory()
        print(dir(filedialog))
        if path :
            v.set(path)
        getdir(path)
    
    def getdir(p):
        #把目录中遍历出来的文件目录显示到列表框中
        fp = os.listdir(p)
        var.set(fp)
    
    root = Tk()
    root.title('文件目录选择对话框测试')
    frame = Frame(root)
    frame.pack(fill=X,side=TOP)
    #加入一个文本框显示目录地址
    v = StringVar()#绑定文本框的变量
    ent = Entry(frame, width=50,textvariable = v).pack(fill=X,side=LEFT)
    #加入一个按键，点击后弹出文件目录选择对话框
    button = Button(frame, text='选择文件夹', command=filedir).pack(fill=X,side= LEFT)
    #加入一个列表框，显示目录中的文件列表
    listframe = Frame(root)
    listframe.pack(fill=X,side=LEFT)
    var = StringVar()#绑定listbox的列表值
    var.set((''))
    listbox = Listbox(listframe,width=60,listvariable = var).pack()
    root.mainloop()


## 相关参考

+ [可爱的 Python：Python 中的 TK编程](https://www.ibm.com/developerworks/cn/linux/sdk/python/charm-12/index.html)
+ [An Introduction To Tkinter](http://effbot.org/tkinterbook/tkinter-index.htm)

## 本文源码下载：

+ [github](https://github.com/bosichong/17python.com/tree/master/gui)
+ [开源中国码云镜像gitee](https://gitee.com/J_Sky/17python.com/tree/master/gui)

python中有没有文件目录选择对话框？答案是肯定的，这个可以有。tkinter.filedialog这个模块就是负责选择文件及目录的。

Python TK和Tkinter的GUI编程(10) filedialog 文件目录选择对话框


`Python`生成器`yield`是编写基于处理管道，流或数据流程序的一种极其强大的方式，在《Python参考手册》中有一则实例非常简单实用，略加修改，分享一下给大家。

## 需要分析

假设服务器有一个日志文件，每隔一秒都会更新日志的内容，日志每行中都有一组类似：`2017-12-21 14:07:26.471691 99123`数据被写入日志。
**我们的目的是分析日志中的数字如果大于5000就要打印出来。**
这样来看，我们需要一个程序负责模拟日志写入，另一个程序负责分析日志打印数据。

## 模拟日志写入

`server_log.py:`

    import random
    from datetime import *
    import os
    import time
    
    
    def server_log():
        # 生成模拟的日志数据
        server_int = random.randint(1,99999)#生成需要的随机数
        server_date = datetime.now()#获取当前系统时间
        return str(server_date) + ' ' + str(server_int)#拼装日志字符串
    
    
    while True:
        #模拟系统写入日志
        #打开日志文件并写入日志
        with open(os.path.join(os.path.dirname(__file__),'server_log.log'),'at') as f :
            s = server_log()
            print(s)
            f.write(s + '\n')
        time.sleep(1)


上边的代码我已经添加了相关的注释，这样我们就有了一个日志文件，每秒会有一第记录插入到日志中。

## 利用生成器yield解析日志

生成器可以返回一个迭代的流式的对象，我们可以通过这种方式便捷的获得相关数据，而且代码也更清晰易懂

`tail.py` 代码如下：

    import time

    def tail(f):
        f.seek(0,2)#移动到文件尾部。
        while True:
            line = f.readline()
            if not line :
                time.sleep(1)
                continue
            yield line
    
    def grep(lines):
        for l in lines:
            k = int(l.split()[2])
            if k >50000:
                yield l
    
    serverlog = tail(open('server_log.log'))
    lines = grep(serverlog)
    
    for line in lines:
        print(line)

我们运行两个文件看下效果：


![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/12/QQ20171222-090710-HD1.gif)

代码虽然简单，但值得细细品味，感受python的简约与强大吧。

## 本文源码下载：

+ [github](https://github.com/bosichong/17python.com/tree/master/deftest)
+ [开源中国码云镜像gitee](https://gitee.com/J_Sky/17python.com/tree/master/deftest)

Python生成器yield是编写基于处理管道，流或数据流程序的一种极其强大的方式，在《Python参考手册》中有一则实例非常简单实用，略加修改，分享一下给大家。

Python生成器yield应用实例——监控日志


曾经以为数据库自己一定需要大的，好的，功能多的，处理数据快的，迸发牛的，现在想想就象上小学时时常想：以后考大学是北大还是清华呢？后来才发现自己真特么多虑了。
如果你只是个人或是小型的应用，我这里隆重的推荐给你SQLite这个迷你型的数据库。

## SQLite
SQLite 是一个软件库，实现了自给自足的、无服务器的、零配置的、事务性的 SQL 数据库引擎。SQLite 是在世界上最广泛部署的 SQL 数据库引擎。SQLite 源代码不受版权限制。
是不是很兴奋？没有其它数据库的安装配置繁琐步骤，没有占用你吃紧的内存，最重要的是功能一样大而全而且免费不要钱。

## SQLite安装
几乎所有版本的 Linux 操作系统都附带 SQLite，所以win党们请自行在官网上下载安装即可。

    ➜  ~ sqlite3 
    SQLite version 3.8.10.2 2015-05-20 18:17:19
    Enter ".help" for usage hints.
    Connected to a transient in-memory database.
    Use ".open FILENAME" to reopen on a persistent database.
    sqlite> 

通过终端输入sqlite3即可验证数据库是否安装成功！

## python中使用sqlite3

通过Python结合sqlite3实现一个简单的个人备忘录，简单了解一下在Python中是如何操作数据库的。
在Python中操作sqlite很简单，引入sqlite3模块，就可以开始进行数据库的编程之旅了。

## 创建数据库

    import sqlite3#引入模块
    import os
    from datetime import *
    print(os.path.join(os.path.dirname(__file__), 'memorandum.db'))
    conn = sqlite3.connect(os.path.join(os.path.dirname(__file__), 'memorandum.db'))#在当目录下创建数据库
    print('备忘录数据库创建成功！')

## 创建表及字段

cursor()将创建一个cursor对象，将在Python数据库编程中用到。
cursor.execute()将处理操作与数据库相关的几乎所有命令。

    c = conn.cursor()#创建一个cursor对象
    # 创建表
    c.execute('''create table tab(
        id integer not null primary key autoincrement,
        title char(50),
        content text not null,
        c_date text);''')
    print('数据表创建成功！')
    conn.commit()#提交事务
    conn.close()#关闭连接

通过以上代码就可以在数据库中创建一个表了，如果你不太习惯在代码中创建表，你可以使用DBeaver,操作简单方便人性化，是编写数据库命令，查看数据库表结构，备份数据之良品。
有了数据表，我们就可以对表进行增删改查了。
sqlite中的sql语句和大部分数据库操作语名是相同的，如果你有过其它数据库操作的基础，那么使用sqlite就会非常简单了

## 插入数据

    title = '测试标题'
    content = '插入数据测试。'
    format = "%Y-%m-%d %H:%M:%S"
    now = datetime.now().strftime(format)#创建当前时间字符串
    sql = "insert into tab (id,title, content, c_date) values (NULL,'{0}','{1}','{2}')".format(title,content,now)
    print(sql)
    c.execute(sql)
    conn.commit()
    conn.close()#关闭连接

## 批量插入数据

python往sqlite3插入数据的sql语句支持'?'占位符，这样我们很方便的可以批量插入数据。

    # 准备10000条数据插入
    for i in range(10000):
        format = "%Y-%m-%d %H:%M:%S"
        now = datetime.now().strftime(format)#创建当前时间字符串
        c.execute('insert into tab (id,title, content, c_date) values(?,?,?,?)',(None,str(i),str(i),now))
    conn.commit()#提交事务
    conn.close()

## 删除数据

    sql = "delete from tab where id = 2"#拼装sql语句
    c.execute(sql)#执行删除
    conn.commit()
    conn.close()

执行上边的代码，发现id为2的数据已经被删除。
![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/11/Snip20171116_11.png)

## 更新数据

    sql = "update tab set title='Boy' where id = 20004"
    c.execute(sql)
    conn.commit()
    conn.close()

##查询数据

    sql = "select * from tab"
    l = c.execute(sql)
    for s in l :
        print(s)
    conn.close

运行代码后可以看到终端输出：
![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/11/Snip20171116_12.png)

其它查询只是sql语句的不同，这里暂时不再测试了，有兴趣的可以查阅sql编程相关资料。
综合来说，`python`与`sqlite3`联合使用真是很方便，是数据采集入库处理查询必备哇。

## 本文源码下载：

+ [github](https://github.com/bosichong/17python.com/tree/master/sqlite3)
+ [开源中国码云镜像gitee](https://gitee.com/J_Sky/17python.com/tree/master/sqlite3)

曾经以为数据库自己一定需要大的，好的，功能多的，处理数据快的，迸发牛的，现在想想就象上小学时时常想：以后考大学是北大还是清华呢？后来才发现自己真特么多虑了。

听说存储数据Python与SQLite3更配哦！


最近老妈骨折住院，在医院护理了有8天，终于回出院回家了。回到家第一件事就是想到之前学习了python，如何快速的复习一下曾经学过的`python`呢？

## 语法/变量/表达式

也许我们能找到一个小小例子来快速的复习一下基本语法，那么这种例子有很多，比如：打印九九乘法表/斐波那契数列/排序法等等。

## 九九乘法表

快速复习`for`及`print format`等函数的用法。

    for i in range(1,10):
        for j in range(1,i+1):
            print("{}X{}={}".format(i,j,i*j), end=' ')
        print()



## 一摞`Python`风格的纸牌

在看《流畅Python》那本书的时候，第一章第一个小例子非常吸引人，具体代码如下
Python3 扑克牌
`collections.namedtuple`这个函数可以快速创建一个只有属性的类，我们通过这个方法来创建一张扑克牌的类，rank 和 suit 分别代表牌面数值和花色

    import collections
    from random import choice
    Card = collections.namedtuple('Card',['rank','suit'])
    #创建一副扑克牌的类
    class Cards:
        ranks = [str(n) for n in range(2,11)] + list('JQKA')#从2-10的数字
        suits = 'spades clubs diamonds clubs'.split()# 黑桃 方块 草花 红桃
    
        def __init__(self):
            '''创建一副扑克牌'''
            self._cards = [Card(rank,suit) for suit in self.suits
                                           for rank in self.ranks] + ['King','Queen']
        def __len__(self):
            return len(self._cards)
        def __getitem__(self,position):
            return self._cards[position]
    
    deck = Cards()#创建一副扑克牌
    print(len(deck))#打印有多少张
    #打印所有纸牌
    for i in range(len(deck)):
        print(deck[i])
    print(choice(deck))#随机抽取一张纸牌


我觉得这个纸牌的小例子很有意思，复习了类及列表推导等一些小概念。当然快速复习的小例子还有很多的，比如下边的例子

## 简单的复利计算

    p = 10000 #初始金额
    rate = 0.04/365 #利率 例如余额宝的年化收益为4%，那么每天的这里计算每天的收益
    days = 100
    
    day = 1
    while day <= days :
        p = p * (1+rate)#复利，余额宝是每天的利滚利
        print('%s天：%2.2f' % (day,p)) #打印当前年份及金额
        day += 1


通过以上三个小例子，是不是又引起了你对Python的兴趣？温故而知新，大家加油哦！

## 本文源码下载：

+ [github](https://github.com/bosichong/17python.com/blob/master/ReviewPython.py)
+ [开源中国码云镜像gitee](https://gitee.com/J_Sky/17python.com/blob/master/ReviewPython.py)

最近老妈骨折住院，在医院护理了有8天，终于回出院回家了。回到家第一件事就是想到之前学习了python，如何快速的复习一下曾经学过的python呢？

如何快速的复习学习过的Python


前几天在封装`PY_RPG`框架时，需要导入一些自定义的类、函数、常量的时候，发现始终找不到相关模块，后来参考书籍及网络上的一些经验终于解决了这个问题。

## 包和模块导入的需求

假设有一个项目，有a/a.py（此为工具类提供一些简单的方法和常量），b/b.py（需要调用a/a.py）项目文件，我们先在a.py中定义一些函数及常量一会引入使用。

    M_TEST = 888
    def print_text():
        print('这a.py下的一个打印文字函数')

现在我们引入测试

    import a.a
    a.print_text()

ModuleNotFoundError: No module named 'a'  很显然这样是找不到正确目录的，那么问题来了，
如果是在同一目录，我们直接`import a`就搞定了，但实际工作中我们不可能把所有文件都放在一个目录中，如果需要导入其它目录的中.py文件，这时我们就需要用到`sys.path.append()`

    ['/Users/mac/PycharmProjects/PythonStudy/b', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python36.zip', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/lib-dynload', '/Users/mac/Library/Python/3.6/lib/python/site-packages', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/beautifulsoup4-4.6.0-py3.6.egg', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/PyMySQL-0.7.11-py3.6.egg', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/xadmin-0.6.1-py3.6.egg', '/Library/Frameworks/Python.framework/Versions/3.6/lib/python3.6/site-packages/django_formtools-2.0-py3.6.egg']

打印后，我们会发现很多目录，`python`加载包模块的目录就都在上边了，他会从这些目录中搜索需要加载内容的名称，如果有就加载进来。
那么我们如何把自己的文件加到上边的目录里？有几种方法：

+ 通过修改环境变量，这个不环保，而且文件多了，不可能都去修改。
+ 复制文件到上边的目录中，有些不方便，不推荐
+ `sys.path.append()`把目录加进索引，方便python搜索，推荐

那么我们来试试吧

## 如何优雅的获得目录地址？

如果需要把目录加进到索引中，我们只需要一个绝对地址即可，但是这种方法如果我们复制工程到其它目录后，我们还需要修改这个索引，很不方便不科学。
这时我想到了`Django`配置文件中有一段代码

    BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))

我们理解一下这段代码，`__file__ `表示当前.py文件，`os.path.abspath(__file__)` 表示当前.py文件的绝对地址，`dirname`获得上一层目录地址，
那么如果我们当前的文件在根目录下的一个目录下边，那么上条语句正好获得了根目录的地址。我们来打印试试

    /Users/mac/PycharmProjects/PythonStudy/b/b.py
    /Users/mac/PycharmProjects/PythonStudy/b
    /Users/mac/PycharmProjects/PythonStudy

可以看到根目录地址已经得到了，然后通过`os.path.join()` 就可以拼装到工具类目录地址了，到这里我们的所有功能基本上可以实现了，具体实现请看下边的代码。

    import os 
    BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))#获取根目录
    print(os.path.abspath(__file__))
    print(os.path.dirname(os.path.abspath(__file__)))
    print(BASE_DIR)
    T_DIR = os.path.join(BASE_DIR,'a')#拼装工具类地址
    print(T_DIR)
    sys.path.append(T_DIR)
    import a
    print(a.M_TEST)
    a.print_text()

## 本文源码下载： a b 两个目录下为相关源文件

+ [github](https://github.com/bosichong/17python.com/)
+ [开源中国码云镜像gitee](https://gitee.com/J_Sky/17python.com/)

前几天在封装PY_RPG框架时，需要导入一些自定义的类、函数、常量的时候，发现始终找不到相关模块，后来参考书籍及网络上的一些经验终于解决了这个问题。

python中导入不同目录中的自定义模块/class/函数/方法


之前用java GUI写过一个简单的目录同步助手，前几天在WIN10下边想用的时候，发现竟然无法使用了，正好最近在学习python，所以用python重写了一简单的目录文件同步助手。


![输入图片说明](https://suiyan.cc/assets/images/media/upload/2018/01/Snip20180109_24.png)

## 功能需求

之前有些喜欢拍照，但设备和场景比较多，所以每次照相回来，都为每台设备创建目录，然后在目录下边创建以时间为名的目录进行照片备份。
之后这个备份了几年，后来目录越来越多，经常发现无法准确的判断哪些照片是否备份过，因为实在太多了，所以，需要一个实际目录与备份目录比较，
并且能把比较后的结果复制到备份目录中进行备份。

## 需求分析

从需求上分析：参数需要给定两个目录，然后有比较和复制两个功能，GUI构建上只需要两个目录选择和两个按钮，使用Tk即可实现。
技术上实现采用python的 filecmp shutil os 进行一些目录及文件的比较及复制来实现需求。

## 逻辑分析

通过目录选择框获得了两个字符串，然后进行比较，分析出不同的目录与文件，然后复制到目标目录中。
为此，我创建了一个目录比较类，专门负责比较目录与文件。
此类中的比较方法中使用到了递归，Python中的递归记得最大是1000次，我觉得这个目录层次应该是够了吧？
其实本程序中，目录与文件的分析是重要部分：

+ 先判断根目录中不相同的目录与文件，然后分别记录。
+ 如果有相同的目录，使用递归比较这二个相同的目录。
+ 最后分别创建目录，复制文件到目标目录中。

## Tk Button传参方法

在构建GUI的时候，点击按钮激活的函数需要传参数进去，但Python并没有在Button中提供传参的方法，后来查到可以使用lambda

    command=lambda: def(参数1, 参数2)

这样即可达到函数传参的实现。

## 目录与文件的操作

通过这个小软件的制作，达到了对python目录及文件的分析及创建复制的模块功能的复制，功能上还可以继续扩展，后续有需要再继续添加。


## 本文源码下载

+ [github](https://github.com/bosichong/PyDirectoryComparison)
+ [开源中国码云镜像gitee](https://gitee.com/J_Sky/PyDirectoryComparison)

之前用java GUI写过一个简单的目录同步助手，前几天在WIN10下边想用的时候，发现竟然无法使用了，正好最近在学习python，所以用python重写了一简单的目录文件同步助手。

基于Python、Tk构建的可视化目录文件同步助手


游戏中绘制圆及圆形的轨迹需求还是不少的，而且很多地方都需要用到圆及弧度的理论，如果想做些游戏的话，必须熟练掌握这些基本知识。

## 一些知识点

+ radius 圆的半径
+ diameter 圆的直径
+ angle 角度
+ 一个圆的完整的弧度 PI*2=6.28
+ 1弧度的角度值为 360/6.28=57.3248
+ 1度的弧度值为 6.28/360=0.0174
+ math.degrees(x)将角度x从弧度转换为度。
+ math.radians(x)将角度x从度转换为弧度。
+ math.sin(x)返回x弧度的正弦值。
+ math.cos(x)返回x弧度的余弦值。

## 圆周上点的坐标

    x = math.cos(math.radians(angle)) * (radius)
    y = math.sin(math.radians(angle)) * (radius）

如果不想深入了解的话，只需要记住，我们需要角度，即可求得圆周上的坐标值，对就上边的函数解释应该可以理解上边的python语句的含意。

## 实例

没有比绘制一个表盘更贴近实际需求的例子了，通过pythondatetime函数，我们可以很方便的获得时间，然后转换成相关数据。

以下为游戏效果图，建议下载相关代码跑一下，有问题可以留言给我。

![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/10/Snip20171023_1.png)

## 本文源码下载

请git clone 下所有代码，以免造成游戏跑不起来的情况。本例源文件pygame05.py

+ [github](https://github.com/bosichong/My_pygame/)
+ [开源中国码云镜像gitee](https://gitee.com/J_Sky/My_pygame/)

游戏中绘制圆及圆形的轨迹需求还是不少的，而且很多地方都需要用到圆及弧度的理论，如果想做些游戏的话，必须熟练掌握这些基本知识。

“编学编玩”用Pygame编写游戏（5）pygame绘制一个钟表


![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/10/Snip20171022_7.png)
![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/10/Snip20171022_8.png)
![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/10/Snip20171022_9.png)

好开心，买的书终于到手了，极力推荐《Python游戏编程入门》！非常不错的一本书，另千万别买《Python和Pygame游戏开发指南》，好了，不要问什么，请叫我雷锋！

## 游戏流程

我觉得新手编写游戏的时候最大的难点是先把游戏构思的太细致了，以至于真正上手编程的时候完全不知道从哪里开始，平时构思设计游戏时，脑子里那闪耀的光芒，就觉得只要拿起键盘，一个旷世神作的游戏就要蛋生了！
实际呢？两眼瞪着电脑，我特么从哪开始写呢？，所以你需要一个流程，你可以拿纸笔画，或是找个流程图画一下。可以参考下图：

![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/10/Snip20171022_5.png)

有游戏流程后，先不要急于实现游戏的细节功能，先把流程走一下，先搭建游戏骨架`pygame.init()`，嗯，这个你应该很熟了。
然后我们通过面向对象的方法来进行这个小游戏的编写：


    pyqa.game_Start()
    pyqa.show_qt()
    pyqa.game_Over()

这样在循环中你应该很明白游戏的流程，虽然他们都在循环中，但我们可以控制他们在游戏中渲染的逻辑，这样我们就可以考虑好游戏中类的属性了。
这是一个问答游戏，需要有基本的题库数据，我们通过python的流读入数据，因为python可以很方便的读行，这样我们可以定义一些规律，把每一题的问题、选择项，答案都分别占一行。
这样导入数据后可以返回一个list，方便操作。

好了，我们定义一下当前答题类`class Pyqa`的一些属性，首先他需要三个开关，分别代表游戏开始画面，答题画面，游戏结束画面，当然游戏一开始就是开始画面，我们可以设置他为`True`，
这样游戏一旦开始，即可直接进入游戏开始画面，当然我们还需要定义三个函数，分别渲染三个场景，通过`if self.gameStart`判断当前是否要渲染这段场景。
好了，流程说到这里应该了解了吧？如果还是很头疼，建议先打代码试试，游戏内容可以不用填加，就试过场。

## 游戏中的事件

当我们运行游戏的时候，我们发现游戏只停止在游戏开始画面上，并没有继续进和到问答画面，因为我们没有加入游戏的控制，我们通过玩家来按键获取当前的游戏按键事件，
`pygame`中的游戏事件轮询获取相应的事件来响应用户的操作。

    while True:
        for event in pygame.event.get():

当我们通过`event.key == K_RETURN:`在游戏开始画面处获得了回车键的事件，就可以把游戏中的`self.showQuestion`设置`True`，然后开始游戏了，其它响应也是如此，
比如获取游戏中的答案数字，也是通过相应的键值获取，具体可以查看代码了解。

## 答题场景编写

本游戏的核心就是回答问题，导入题库后，通过`def show_qt()`方法来渲染问题及选项。我在游戏中定义了一个函数`def print_text`是专门用来打印游戏中的文字的。
当我们在游戏中选择答案按下数字键1-4的时候，我们会通过`pyqa.handle_input(int)`方法来处理当前游戏中的一些数据，比如回答是否正确，提示正确答案，记录回答正确数等，
当我们再次按下回车键，`def next_question`方法会更新问题题库的索引指针，告诉`def show_qt()`我得渲染下一道题了！

## 游戏结束

当`def next_question`通过`self.current >= len(self.data)`发现已经到达题库最后边了，游戏就要结束了，设置游戏开关相关参数为false，设置游戏结束标识`gameOver`为`true`
进入游戏结束画面，展示游戏数据统计，最后当然还可以让你有重来的机会，具体实现请看代码吧，无非就是一些按键事件触发。

## 写在最后

无论是整个游戏还是中间的答题系统，我们发现在这个游戏中我们必须细致入微的进行设计判断每一步的操作，这就是游戏设计的精髓及乐趣，至少我们可以按着自己的需要来进行设计，当你把游戏设计成功，代码编写运行无错时，希望你能体会到这其中的乐趣！如果你有时间，可否帮忙丰富一下题？谢啦，记得提git提交给我哦，谢谢了。

## 本文源码下载

请git clone 下所有代码，以免造成游戏跑不起来的情况。

+ [github](https://github.com/bosichong/My_pygame/)
+ [开源中国码云镜像gitee](https://gitee.com/J_Sky/My_pygame/)

好开心，买的书终于到手了，极力推荐《Python游戏编程入门》！非常不错的一本书，另千万别买《Python和Pygame游戏开发指南》，好了，不要问什么，请叫我雷锋！

“编学编玩”用Pygame写游戏（4）一个python问答游戏


上次的代码中，除了绘制基本图形与图片外，中间还插入了一个小小动画，就是头像在不停的移动，这个移动确实简单了些，游戏中的的角色肯定不是简单的移动几像素那么简单了。

![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/10/QQ20171020-145146-HD111.gif)


## 屡屡顺序

我觉得刚开始做游戏写代码的时候，总是弄不清游戏的顺序，你可以这样想象一下，比如是拍电影，大家都了解电影是一段一段拍，最后合成在一起然后电影可以播放了。
游戏呢和这个差不多，也是一段一段做，只不过游戏需要一些条件判断，True了，我就播放第三段，这个属性值达到了我就播放第五段，游戏over了，我就播放结尾。
好吧，那么我们规划一下现在这个小游戏（应该算不上是一个游戏）场景及角色。

## 游戏内容

建一个 640X480的黑色背景的游戏场景，场景中随机生成一些大小一样的小球，他们随机属性值，有一个绿色，有一组红色，如果绿色碰到红色他们就会反转滚动，这些小球如果碰到边界也会反转滚动。
注意：这里碰撞的检测之后的动作，只是简单的，并不是真的物理运动哦，当然如果你很懂物理学，做一组力学物理运动应该也不是很难的。

## 游戏场景

+ 游戏场景的搭建和之前基本上差不多，这里不在介绍了，如果不了解可以翻看之前或是本节的代码参考。

## 游戏中的角色

之前我们在场景中是直接绘制的图形，这次我们通过面向对象的方式来管理场景中的角色，pygame中提供了一个`Sprite`类，这个类专门为游戏中的角色精灵准备的。
框架中还提供了一个`pygame.sprite.Group()`容器，他可以把sprite加进去，通过group来管理，group这个容器，通过查看源代码，他只能处理图片类型的sprite。
如果创建的Rect对象是不行的，这种加到组里后，通过draw是无法绘制出来的，`group.draw()`这个方法中的画笔使用了`blit()`，而不是`draw()`

## 游戏中的逻辑判断

这个我们直接在游戏中的循环当中直接判断，我是这么把游戏分成各种对象的：

+ 游戏场景对象，他只负责绘制场景中的任何角色及精灵
+ 游戏逻辑判断对象，他只负责判断游戏场景中的碰撞，时间检测，然后修改他们的属性。
+ 精灵group，他们只负责创建，删除。


## 开始制作

理论课结束，我们来实践一下，`main()`函数中创建一个游戏运行函数`rungame()`，这个函数中运行着当前游戏的所有数据，及各种事件触发的检测。
为什么需要`rungame()`?你可以把他这个函数看成一个电影片段，当前你还可以有`gamestart() gameover()`函数，这样游戏运行到哪个部位时就让哪个函数运行即可。


## Sprite 精灵

说说`class MyImgSprite(pygame.sprite.Sprite`，这是当前游戏中的精灵，我们为他创建了几个属性，其中比较重要的有：

    self.image = pygame.image.load('./images/a.png') #导入图片
    self.rect = self.image.get_rect() #返回一个rect对象
    self.rect.topleft = (random.randint(40,590),random.randint(40,430))#设置他的坐标  
    self.last_update = pygame.time.get_ticks()#获取当前游戏动行的时间，这是一个整数，不明白可以打印看看
    #移动速度
    self.speed_x = random.randint(1,10)
    self.speed_y = random.randint(1,10)

有了速度，我们就可以通过`update()`方法来更新自己的坐标

    now = pygame.time.get_ticks()
    if now - self.last_update >1:#通过这个时间差来做一些动画       
        #self.rect.topleft = (random.randint(0,600),random.randint(0,440))#随机变化位置
        self.rect.x += self.speed_x
        self.rect.y += self.speed_y
        self.last_update = now

如果你不在`update()`方法更新任何值，那么 这个精灵就是不会动弹的。
那么问题来了，为什么不直接在游戏循环中更新？
上节的代码中有段小小的移动是在循环中更新的，因为那只有一段动画，如果以后有很多个对象的话，在循环中更新会很麻烦，这里更新更符合面向对象的的编程方式。

## 绘制及更新

在rungame函数中创建个绿球，一组红球，然后就可以直接在场景里绘制了，绘制方法：

    drawbackground()#绘制场景背景颜色
    DISPLAYSURF.blit(m.image,m.rect)#绘制绿球
    myimgs.draw(DISPLAYSURF)#绘制一组红球 

场景中的绘制顺序应该是：

1. 绘制精灵
2. 逻辑判断
3. udpate()更新数据

以此为循环，这样反复循环即可生成画面。

## 逻辑判断

说到逻辑判断，这次场景中包括的判断有二种：边界碰撞及球体之间的碰撞。
边界碰撞，我自个写了个边界碰撞检测器`BorderCrossing.py`，因为我在pygame中没找到边界碰撞检测的方法，大家在运行代码的时候，记得git clone一下整个项目。
这个边界碰撞检测器，我就不多说了，不然这又一篇博客了，有兴趣可以自己看看源码。

球体之间的碰撞检测直接套用的pygame中的碰撞检测，具体可以参考官方文档

[碰撞检测官方文档](http://pygame.org/docs/ref/sprite.html#pygame.sprite.spritecollide)

## 更新游戏数据

在逻辑判断中根据自己的需要进行速度等数据修改，最后记得用方法更新一下精灵们的坐标。
说的不是很好，具体大家跑跑程序，改改数值就明白了，如果有什么不懂的，可以直接留言或是邮件给我。欢迎各位大佬指正！

## 本文源码下载

请git clone 下所有代码，以免造成游戏跑不起来的情况。

+ [github](https://github.com/bosichong/My_pygame/)
+ [开源中国码云镜像gitee](https://gitee.com/J_Sky/My_pygame/)

上次的代码中，除了绘制基本图形与图片外，中间还插入了一个小小动画，就是头像在不停的移动，这个移动确实简单了些，游戏中的的角色肯定不是简单的移动几像素那么简单了。

“编学编玩”用Pygame写游戏（3）让角色动起来及碰撞检测


`pygame`的框架使用起来很简单，但这个框架功能也还算可以的，虽然网上对`pygame`评价褒贬不一，但对于其的存在必有其的存在意义，功能上虽然不能说是十分的完美，但对于新手来说，在使用和学习中还是很有价值的。

## `pygame` 图形绘制

rect	绘制矩形
polygon	绘制多边形（三个及三个以上的边）
circle	绘制圆
ellipse	绘制椭圆
arc	绘制圆弧
line	绘制线
lines	绘制一系列的线
aaline	绘制一根平滑的线
aalines	绘制一系列平滑的线

上边列举了一些图形绘制的方法，第一结中的代码我们只是给出pygame中最简约的实现代码，我们在上节代码的基础之上继续添加一下，试试画出各种图形。

    pygame.draw.polygon(screen, RED, ((146,0),(290,100),(36,277),(55,200),(0,106)),2)
    pygame.draw.line(screen, BLUE, (11,33), (55,300), 1)
    pygame.draw.circle(screen, GREEN, (300,50), 100, 0)
    pygame.draw.ellipse(screen, RED, (300,250,180,80), 1)
    pygame.draw.rect(screen, RED, (200,150,100,100), 1)

以上为各种图形绘制的方法演示，关于这些方法的参数，我们可以参考官方的文档，其实都是挺简单的。



## 在场景中绘制图片

游戏中的角色不可能只是一些简单的图形，大多数时应该都是一张张图片，我们看下图片的绘制方法

    bosiImg = pygame.image.load('./images/bosi.png')
    screen.blit(bosiImg,(bosix,bosiy))

通过`pygame.image.load()`加载图片后，在场景中使用`screen.blit`绘制，两个参数：图片对象和一个坐标元组。

## 在场景中写字

pygame中的文字绘制稍稍有一点麻烦，我们看代码：

    fobj = pygame.font.Font('./font/3.ttf', 40)
    textobj = fobj.render('Hello World', True, GREEN,)
    text = textobj.get_rect()
    text.center = (400, 400)
    screen.blit(textobj, text)#文字显示

看代码行数是五步：

1. 通过`pygame.font.Font()`加载字体，创建一个font对象，设置文字的大小
2. 通过`render('Hello World', True, GREEN,)`设置文字的内容，颜色。
3. `get_rect()`或得一个rect对象，之后就有些象绘制图象了。
4. 设置绘制图像的坐标
5. `blit()`方法绘制文字到场景

## 让图片动起来

如何在场景中绘制动画？动画其实就是角色坐标值的修改，

    bosix = 100
    bosiy = 100

在代码中我定义了二个变量，然后我在游戏场景的循环输出中，不断的修改角色的坐标值即可达到需要的动画效果了。

![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/10/Snip20171019_3.png)

## 本文源码下载：

+ [github](https://github.com/bosichong/My_pygame/blob/master/pygame00.py)
+ [开源中国码云镜像gitee](https://gitee.com/J_Sky/My_pygame/blob/master/pygame00.py)

pygame的框架使用起来很简单，但这个框架功能也还算可以的，虽然网上对pygame评价褒贬不一，但对于其的存在必有其的存在意义，功能上虽然不能说是十分的完美，但对于新手来说，在使用和学习中还是很有价值的。

“编学编玩”用Pygame写游戏（2）在场景中绘制图形与动画


![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/10/timg.jpeg)

## 啰嗦几句

这阵子一直在看有关`Python`相关的书，`Python`上手确实很简单，但这并不意味着`Python`是一门浅显的编程语言，语法简练确实让我们节省了大量的时间。不过当你深入的学习`Python`的时候，比如：装饰器，推导，多线程及多进程，协程，高阶函数，元编程等等等等很多，你会发现，`Python`的深入学习并不是很简单。会写代`Python`和会优雅的编写`Python`代码是两回事，出来混的，坑迟早还是要挖的，这不前几天协程的深入学习，搞的我很不爽，到现在还是一头雾水。

为了让自己换换心情，前几天想到用`python`写写小游戏玩玩吧，想到自己以前用`java`还编写了一个小小的2D游戏引擎半路就放弃了（java就是不爽），这次来试试用`Python`写些小游戏试试。其实写游戏练习编程确实是一个比较好的方法，几百行的工程量也不算大，游戏设计的逻辑比较紧密，比较适合新手养成编程思维，不过如果是刚刚学习编程，可能还是会觉得游戏中大段的代码，摸不清逻辑，所以通过阅读代码了解游戏的设计意图也算是对编程能力很好的锻炼。

好了，啰嗦了半天，我们开始pygame的学习之旅吧。

## pygame 安装

    pip3 install pygame

就是这么简单，然后我们可以在python3的终端环境下测试一下

    import pygame

如果没有报错，那么恭喜你安装成功了。

## pygame的 Hello World

导入pygame模块及常用变量，如果还需要其它模块，可以一并导入，比如sys,os,time random等。

    import pygame
    from pygame.locals import *

这里是一个游戏初始化的设置，他应该在游戏代码编写的最前边，不要忘记哦。

    pygame.init()

SCREEN 定义了一个游戏的屏幕，我觉得管它叫做画布更形象些，因为后续游戏场景中的游戏对象，都要在这个screen上绘制。

    SCREEN = pygame.display.set_mode((640, 480))

设置当前游戏窗口的标题

    pygame.display.set_caption("Hello World!")

这里有个死循环，这是游戏的主要逻辑处理及场景渲染器，for循环是处理游戏中的事件触发，其中QUIT表示触发了游戏离开件事，然后调用`pygame.quit()`函数。`pygame.display.updae()`这个函数表示更新当前screen的画面。

    while True:
        for event in pygame.event.get():
            if event.type == QUIT:
                pygame.quit()
        pygame.display.update()

## 效果如图：

![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/10/Snip20171019_2.png)


## 本文源码下载：

+ [github](https://github.com/bosichong/My_pygame/blob/master/pygame00.py)
+ [开源中国码云镜像gitee](https://gitee.com/J_Sky/My_pygame/blob/master/pygame00.py)

这阵子一直在看有关Python相关的书，Python上手确实很简单，但这并不意味着Python是一门浅显的编程语言，语法简练确实让我们节省了大量的时间。不过当你深入的学习Python的时候，比如：装饰器，推导，多线程及多进程，协程，高阶函数，元编程等等等等很多，你会发现，Python的深入学习并不是...

“编学编玩”用Pygame写游戏（1）初识pygame


协程定义说的清楚明了的文章不是很多，手头上有几本Python相关的书籍，其中流畅的Python一书中解释协程的定义是我认为最简单明了的。

## 生成器如何演变成协程？

乍看生成器和协程长的可真象，因为都用到了yield关键字，那么问题来了，如何区分二者？

    def cd(n):
        print("Counting down from %s" % n)
        while n > 0:
            yield n
            n -= 1
    c = cd(10)
    next(c)
    for i in c :
        print(i,end=' ')


上边是一个典型的生成器函数，我们稍加变化使之成为协程。

    def cd1():
        n = yield
        while n > 0:
            print("Counting down from %s" % n)
            n -= 1
    
    c1 = cd1()
    next(c1)
    c1.send(10)
    #运行到这里应该抛出一个异常


生成器和协程的不同有没有看出来？很明显的有两处：

+ yield的位置
+ next()和send()函数的用法

通过运行结果我们可以到最后抛出了一个异常`StopIteration`,结束了这个协程。我们可以考虑一下：用装饰器省略掉next()这步，然后捕获抛出的异常，优雅的关闭掉协程函数。

    from functools import wraps
    def coroutine(func):
        @wraps(func)
        def primer(*args, **kwargs):
            gen = func(*args,**kwargs)
            next(gen)
            return gen
        return primer
    @coroutine
    def cd2():
        n = yield
        while n > 0:
            print("Counting down from %s" % n)
            n -= 1
    try:
        cd2().send(10)
    except Exception as e:
        print('协程任务终止')


带上了装饰器，就更简便一些了，最后捕获异常，就可以优雅的结束这个协程了。

## 利用协程代替线程或进程进行并发编程

我们想用生成器（协程）作为系统线程的替代方案来实现并发。协程有时也称为用户级线程或绿色线程。————引自《Python Cookbook》
这里的协程用到了asyncio模块，利用asyncio模块实现了一个协程的并发。关于asyncio的实现原理，稍后再研究一下。

    import asyncio
    import time
    import threading
    def tn(func):
        '''定义一个程序运行时间计算函数'''
        def wrapper(*args, **kwargs):
            start = time.time() # 起始时间
            func(*args, **kwargs) # 要执行的函数
            end = time.time() # 结束时间
            print('程序运行时间:{:.2f}ms'.format((end-start)))
        return wrapper
    
    def loop1(tname):
        print(tname+"循环loop1打印时间======" + time.ctime())
        time.sleep(1)
    
    # @asyncio.coroutine
    async def loop2(tname):# async等同于@asyncio.coroutine
        print(tname+"循环loop1打印时间======" + time.ctime())
        # yield from asyncio.sleep(1)
        await asyncio.sleep(1)  # 等同于yield from
    
    @asyncio.coroutine
    def loop3(tname):# async等同于@asyncio.coroutine
        print(tname+"循环loop1打印时间======" + time.ctime())
        yield from asyncio.sleep(1)
        # await asyncio.sleep(1)  # 等同于yield from
    
    @tn
    def main():
        print('多线程任务开始执行=====')
        threads = []#定义一个线程队列
        for i in range(5):
            t = threading.Thread(target=loop1, args=("thread"+str(i),))
            threads.append(t)
        for i in range(5):
            threads[i].start()
        for i in range(5):
            threads[i].join()
    
        #协程并发测试
        print('协程并发测试开始======')
        loop = asyncio.get_event_loop()# 获取一个event_loop
        #任务列表
        tasks = [
            asyncio.ensure_future(loop2('11111')),
            asyncio.ensure_future(loop2('22222')),
            asyncio.ensure_future(loop2('33333')),
            asyncio.ensure_future(loop3('44444')),#loop3
            asyncio.ensure_future(loop3('55555'))]#loop3
        loop.run_until_complete(asyncio.wait(tasks))
        loop.close()
    if __name__ == '__main__':
        main()


上边这组代码稍稍有点乱，可能你需要认真的理下思绪，对比一下结果，你会发现虽然后边执行的代码没有利用多线程，但打印结果上的时间和多线程的执行结果是一样的。
这就是协程的魅力所在，一条线程搞定多线程任务。

+ [github](https://github.com/bosichong/17python.com/blob/master/deftest/yieldtest2.py)
+ [开源中国码云镜像gitee](https://gitee.com/J_Sky/17python.com/blob/master/deftest/yieldtest2.py)

协程定义说的清楚明了的文章不是很多，手头上有几本Python相关的书籍，其中流畅的Python一书中解释协程的定义是我认为最简单明了的。

浅谈Python中的协程及利用协程代替多线程及多进程并发编程


![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/10/Snip20171014_4.png)

## 晦涩的生成器yield

刚开始接触Python的时候感觉很清爽，入门很简单，但后边学到生成器和协程的时候就感觉有些吃力了，是时候深入的学习一下了。

## 什么是生成器？

书上说：函数使用yield可以定义生成器对象，那么包含yield的函数主是一个生成器函数，它可以生成一个序列，方便迭代中使用，`__next__()`#python3中的特殊方法，应该避免使用特殊方法，`next(c)`使用内置函数next()即可。

    def countdown(n):
        print("Counting down from %s" % n)
        while n > 0:
            yield n
            n -= 1
        return
    
    c = countdown(10)
    print(c.__next__())#python3中的特殊方法，应该避免使用特殊方法
    print(next(c))#使用内置函数next()
    for i in c :
        print(i,end=' ')


函数对象调用`.__next__()`函数时开始执行语句，遇到yield语句时停止。可以使用循环来操作生成器。
调用`close()`方法关闭未使用完的生成器。
那么问题来了，yield到底是什么？

我们把上边的代码稍加变化:

    def countdown1(n):
        print("Counting down from %s" % n)
        while n > 0:
            yield n*n
            n -= 1
        return
    
    c = countdown1(10)
    print(next(c))
    print(next(c))
    print(next(c))
    for i in c :
        print(i,end=' ')


运行之后我们可以发现程序运行到yield的时候返回了一个值，那么yield和return在功能上有些相似。

## 生成器表达式

如果你对列表推导有些了解，你会发现，生成器表达式只不过是把列表的[]换成了元组的()，但列表推导返回的是一个结果集，而生成器表达式返回的是一个生成器。
因为这个特点，我们可以通过流方式访问一个巨大的文件而不必把它直接加载到内存，这样很大的提高了程序的性能。

代码如下：

    print('')
    print("生成器表达式:")
    b = (x*x for x in range(10) if (x % 2 ==0))
    print(next(b))
    print(next(b))
    for i in b :
        print(i, end=' ')



## 本文源码下载：

+ [github](https://github.com/bosichong/17python.com/blob/master/deftest/yieldtest.py)
+ [开源中国码云镜像gitee](https://gitee.com/J_Sky/17python.com/blob/master/deftest/yieldtest.py)

刚开始接触Python的时候感觉很清爽，入门很简单，但后边学到生成器和协程的时候就感觉有些吃力了，是时候深入的学习一下了。

聊聊Python中晦涩的生成器（yield）与生成器表达式


先这样吧，为了不耽误稍后的学习进程，这个聊天室先码到这里，不想继续填坑了。服务器端用TK实现了图形展示，客户端依然终端。具体如下图：

![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/10/Snip20171013_1.png)
![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/10/Snip20171013_3.png)
## Tk多线程中的坑

+ 在图形化后，主线程中开出一条线程，不要直接在主线程中进行通信，不然循环会卡死，专门处理创建socket线程的工作线程，记得self.t.setDaemon(True)#这里很重要，不加程序界面会卡死！
+ 客户端没有实现图形化，完全不知道怎么弄，只要一启动，窗口就会被线程卡死，暂时先终端吧。

## 多用户服务器端

每条连接都创建一个socket，这样每个线程处理自己的收发消息，但是这种架构如果在大量连接下会占用很多的系统资源，如果把socket放到一个容器里，然后使用生成器协程来轮循收发消息，
这样的话只需要一个线程即可，性能必会提高不少，这正是稍后要学习的任务，也是python中的难点。

关于服务器的命令及私聊功能，这些应该都是通过消息来判断，所以后续一定会把消息进行封装发送，一条消息中应该包括命令及消息正文，这样就可以通过命令来判断用户的需求了。

## 客户端

客户端目前就是没有实现图形化，哪位大侠如果实现了，记得通知我，万分感谢，这个坑先放这里不踩了。

具体代码就不贴了，到git下载吧。

代码运行，请在终端中，不要在IDE中启动。代码运行，请在终端中，不要在IDE中启动。代码运行，请在终端中，不要在IDE中启动。

## 本文源码下载：

+ [github](https://github.com/bosichong/17python.com/tree/master/TCP/GUISocket)
+ [开源中国码云镜像gitee](https://gitee.com/J_Sky/17python.com/tree/master/TCP/GUISocket)

为了不耽误稍后的学习进程，这个聊天室先码到这里，不想继续填坑了。服务器端用TK实现了图形展示，客户端依然终端。

Python中创建TCP服务器与客户端进行通信(下)Tk、thread与socket组合。


![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/10/Snip20171012_19.png)

## 前言
学习套接字编程最好的方法就是从实际应用的开发中边学边用，这样对TCP服务器及客户端通信中遇到的知识点才会更加了解。
开发一个拥有服务器并且可以处理多客户端的聊天室应用程序，服务器有一定的管理权限，比如：群发消息，管理客户端可以限制连接及断开客户端连接等。
客户端可以在聊天室里群聊，私聊。

好吧，为了保证这个小小的应用开发跨度不会太大，我们采用循序渐进的方式，从基础代码上迭代开发，这里会用到的知识点有：

+ `Python`的socket套接字模块
+ `Python`的多线程模块
+ `Python Tk GUI`模块，后边有可能考虑做成可视化的聊天室。

## socket模块
关于套接字网络编程的理论知识，这里就不在重复了，网上有很多，大家自己搜索一下好了。
要创建套接字，使用`Python socket.socket()`函数即可，他有一些固定的方式：

    s = socket(AF_INET, SOCK_STREAM)# 创建TCP/IP套接字对象

获得了套接字对象后，就可以使用套接字对象的方法进行交互了。

## `socket`中一些常用方法

服务器套接字方法：

+ `s.bind()`这个方法，绑定服务器的IP及端口
+ `s.listen(int)`监听，可以设置一个整数限制客户端的连接。
+ `s.accpt()`被动接受TCP客户端的连接（阻塞）

客户端套接字方法：

+ `s.connect()` 连接服务器

其它方法：

+ `s.recv()` 接收TCP消息
+ `s.send()` 发送TCP消息
+ `s.close()` 关闭套接字。

## 关于消息

发送和接收消息时需要进行编码和解码，这里使用`data.encode('utf-8')`和`data.decode()`保证通信消息的正常发送，如果不使用会报错。


好了，先来个简单的例子，下边是代码，建议代码运行的时候不要在IDE里运行，请在终端中运行。

## 服务器端

    from socket import *
    from time import ctime
    
    HOST = '127.0.0.1'
    PORT = 6666
    BUFSIZ = 1024
    ADDR = (HOST, PORT)# IP 端口
    
    tcpSerSock = socket(AF_INET, SOCK_STREAM)# 创建TCP/IP套接字服务器
    tcpSerSock.bind(ADDR)#绑定IP及端口
    tcpSerSock.listen(5)
    
    while True:
        print("等待客户端连接=======")
        tcpCliSock, addr = tcpSerSock.accept()#被动接受客户端连接
        print("客户端已连接=====")
    
        while True:
            data = tcpCliSock.recv(BUFSIZ)#接收客户端发来的数据
            print(data.decode())
            if 'exit' == data.decode():break
            data = "{0}".format(ctime())+" "+data.decode()
            tcpCliSock.send(data.encode('utf-8'))
        tcpCliSock.close()
    tcpSerSock.close()

## 客户端

    from socket import *
    HOST = '127.0.0.1'
    PORT = 6666
    BUFSIZ = 1024
    ADDR = (HOST,PORT)
    # 创建客户端，并连接服务器
    tcpCliSock = socket(AF_INET, SOCK_STREAM)
    tcpCliSock.connect(ADDR)
    
    while True:
        data = input("> ")
        tcpCliSock.send(data.encode('utf-8'))
        if 'exit' == data :break
        data = tcpCliSock.recv(BUFSIZ)
        print(data.decode())
    tcpCliSock.close()


就目前这个聊天室只是完成了通信的最基本功能，只能由客户端发送一条消息，服务器端自动回应消息。之后的继续都是建立在这个基础模型之上了。

## 半双工的聊天室

如果稍加修改，我们就可以使这个服务器和客户端进行一对一的聊天了。

+ 服务器端添加判断，如果客户端发来的数据有内容，就进行输入，然后把数据发送给客户端。
+ 客户端连接后，先进行消息的发送，然后就一直等待服务器的消息回送，然后循环。

现在的这个聊天系统缺点就是，必须等待另一方发来消息，才能回复消息，稍后我们继续改进。

相关代码如下：

## 半双工服务器

    from socket import *
    from time import ctime
    
    HOST = '127.0.0.1'
    PORT = 6666
    BUFSIZ = 1024
    ADDR = (HOST, PORT)# IP 端口
    
    tcpSerSock = socket(AF_INET, SOCK_STREAM)# 创建TCP/IP套接字
    tcpSerSock.bind(ADDR)#绑定IP及端口
    tcpSerSock.listen(5)
    
    while True:
        print("等待客户端连接=======")
        tcpCliSock, addr = tcpSerSock.accept()#被动接受客户端连接
        print("客户端已连接=====")
    
        while True:
            data = tcpCliSock.recv(BUFSIZ)#接收客户端发来的数据
            print(data.decode())
            if 'exit' == data.decode():break
            if data:
                data = input("> ")
                data = "{0}".format(ctime())+" "+data
                tcpCliSock.send(data.encode('utf-8'))
        tcpCliSock.close()
    tcpSerSock.close()

## 半双式的客户端

    from socket import *
    HOST = '127.0.0.1'
    PORT = 6666
    BUFSIZ = 1024
    ADDR = (HOST,PORT)
    # 创建客户端，并连接服务器
    tcpCliSock = socket(AF_INET, SOCK_STREAM)
    tcpCliSock.connect(ADDR)
    
    while True:
        data = input("> ")
        tcpCliSock.send(data.encode('utf-8'))
        if 'exit' == data :break
        while True:
            data = tcpCliSock.recv(BUFSIZ)
            if data:
                print(data.decode())
                break
    tcpCliSock.close()

## 本文源码下载：

+ [github](https://github.com/bosichong/17python.com/tree/master/TCP)
+ [开源中国码云镜像gitee](https://gitee.com/J_Sky/17python.com/tree/master/TCP)

学习套接字编程最好的方法就是从实际应用的开发中边学边用，这样对TCP服务器及客户端通信中遇到的知识点才会更加了解。