
今天发布了一段代码，微博上有朋友在win10下边测试报错，看错误应该是中文编码问题，然后自己试了下，总结了一下原因：

## 测试中文打印print()

在win10中新建记事本文档， 敲入代码：

    print("我来试试哈")

保存test.py，运行，果然报错，如下图：

    SyntaxError: Non-UTF-8 code starting with '\xce' in file i:/python3/te
    st.py on line 1, but no encoding declared; see http://python.org/dev/p
    eps/pep-0263/ for details

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

## 为什么呢？

因为win10下边新建记事本文件是ANSIX编码的

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

## 解决方法

把文件另存，在编码中选择utf8。

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

然后运行，完美解决！

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

今天发布了一段代码，微博上有朋友在win10下边测试报错，看错误应该是中文编码问题，然后自己试了下，总结了一下原因

Python程序在Windows10终端运行中文乱码解决方法


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

雷布斯曾说过：“必须写够十万行代码，不要心存侥幸。没有写过足够代码量的，想成为高手是不可能的，只能纸上谈兵！”，看来要成一名黑客10万代码量也许只是个起步。那么自己与黑客差了多少呢，要不咱统计一下吧。

## 编写思路

程序的编写思路其实很简单：统计自己编写过的.py文件，然后统计文件行数累加到一起就ok。

`os.walk`这个方法可以统计当前目录下所有的文件、子目录、子目录下的文件，有了这个数据，我们只需要排除掉不需要的，统计以.py为结尾的文件目录地址加入一个列表即可。

有了所有.py文件的列表，循环迭代出每个文件的行数，加到一起总数据就出来了。具体实现请看代码：

    import os
    def getpys(dir):
        '''
        递归获得当前目录及其子目录中所有的.py文件列表。
        '''
        pys = []
        # 当前目录下所有的文件、子目录、子目录下的文件。
        for root, dirs, files in os.walk(dir):
            for name in files:
                #排除掉git目录中的备份的文件，只保留.py文件
                if '.git' not in root and name.endswith('.py'):
                    pys.append(os.path.join(root, name))
            #下边是拼装所有目录
            # for name in dirs:
            #     print(os.path.join(root, name))
        return pys
    pys = getpys(os.path.dirname(__file__))
    # print(pys)
    hacker=100000#假设黑客需要10万行代码才能练成
    lines = 0
    for file in pys:
        with open(file, mode='r', encoding='utf8') as f:
            lines = lines + len(f.readlines())#统计每个文件的行数。
    print("累计编写了源文件{0}个,手打{1}行Python代码，完成度{2:.2f}%".format(len(pys),lines,lines/hacker*100))
    print("距离成为一名黑客还差{0}行代码".format(hacker-lines))


累计编写了源文件32个,手打2133行Python代码，完成度2.13%
距离成为一名黑客还差97867行代码

这个数量有点惨。。。不过我会努力的。

## 本文源码下载：

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

雷布斯曾说过：“必须写够十万行代码，不要心存侥幸。没有写过足够代码量的，想成为高手是不可能的，只能纸上谈兵！”，看来要成一名黑客10万代码量也许只是个起步。那么自己与黑客差了多少呢，要不咱统计一下吧。

你与黑客之间差了多少行Python代码？


+ [百度搜索资源平台](http://ziyuan.baidu.com)

+ [百度联盟](http://union.baidu.com)

+ [360站长平台](http://zhanzhang.so.com/)

+ [百度云观测](http://ce.baidu.com/)

+ [百度搜索资源平台](http://ziyuan.baidu.com)

+ [JiaThis社会化分享按钮](http://www.jiathis.com/)

+ [署名-非商业性使用-相同方式共享 4.0 国际 (CC BY-NC-SA 4.0) ](https://creativecommons.org/licenses/by-nc-sa/4.0/deed.zh)

+ [畅言网站评论系统](http://changyan.kuaizhan.com/)

+ [搜狗站长平台](http://zhanzhang.sogou.com)

+ [CNZZ站长统计数据专家](https://web.umeng.com/main.php?c=site&a=add)

+ [工信部ICP备案查询](http://www.miitbeian.gov.cn/)

+ [全国公安机关互联网安全服务备案](http://www.beian.gov.cn/)

一些站长常用的搜索收录、访问统计平台


记得当年学`JavaScript`时，对闭包的认识那真是朦朦胧胧，后来接触到`jQuery`之后，对闭包的认识还是一知半解，可能被之前一直学习本分的静态语言`java`给耽误了。。。。。。好吧，闭包到是个什么？是一个让初学编程的人头疼的问题

## Pythib闭包

先来一个栗子，我们慢慢理顺一下：

    def callf():
        def hello():
            return "hello world"
        return hello
    
    cf = callf() #创建一个callf函数，这时把hello()赋值给了cf
    print(type(cf)) # 查看cf类型，证实上边的结论。
    print(cf()) #打印最终结果。


在一个函数中，把这个函数内部的一个函数做为返回值，那个这个被返回的函数就可以叫做闭包。（这条是本人自己写的，和网上其它处的理论会有些出入或是不同）
上边就算是闭包最简单的例子，多看几次应该就理解了。

再看下边的例子,这是一个利用闭包设计的简单自减计数器，其实我第一眼看去的时候就觉得为什么要这么写？

    def countdown(n):
        def next():
            nonlocal n 
            r = n 
            n -= 1
            return r
        return next
    
    nt = countdown(5)
    while True:
        v = nt()
        print(v)
        if not v :break


这个自减计数器的应该还有几种其它写法，而且加之使用nonlocal这个关键字，使人更加迷惑了，如果注释掉`nonlocal n`，程序运行就会抛出错误，可见nonlocal的使用使next()函数内部变量`n`的值可以修改。 本人对此得的理解也不是很好，希望有大侠给与指点，也许这个例子不太理想。

## 再看循环中的闭包：

    def loop():
        fs = []
        for i in range(1,4):
            def f():
                return i*i
            fs.append(f)
        return fs
    f1,f2,f3 = loop()
    print(f1())


`f1()`的打印竟然9，这个有点出乎意料！我们修改一下这个函数

    def loop(): 
        def f(j):
            return lambda: j*j
        fs = []
        for i in range(1,4):
            fs.append(f(i))       
        return fs
    f1,f2,f3 = loop()
    print(f1())
    print(f2())
    print(f3())


对比上边的两段代码，第一段直接返回了三次循环的最终结果，而第二段代码，再循环中遇到了`f()`函数`return`所以暂停了程序的运行，直到第二个赋值时又循环了一次，然后继续，这也说明，闭包的函数不要放在循环体内，不然直接返回的是循环的最终结果。
有的同学会问，了解闭包有什么用？闭包是装饰器和生成器的基础，如果你应用`Python`函数的高级应用，不妨仔细的了解一下闭包吧。

## 参考文档

+ [深入浅出python闭包](https://zhuanlan.zhihu.com/p/22229197)

## 本文源码下载：

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

聊聊Python闭包（Closure）的那点事。


![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/10/e.jpg)
在`Python`的日常生活中，当你要进行一系列超大型密集的计算任务或是超多未知的数据需要采集时，一台机器或许已经无法满足你的需求了，这时就得考虑使用到分布式操作进行任务处理了。

## 一个无聊而又变态的需求

我们假设有一个无聊而又变态的任务：有一系列的任务会成生一组随机>=0的整数队列[n,n,n,.....n,n]，我们需要立即取得他们的n*n自乘结果。当然你也可以使用单线程进行相关的操作，但是由于计算任务巨大，我们不得采用分布式多进程生产者与消费者模式来进行程序的执行了，好吧，我们先了解一下相关术语。

## 分布式

在一个分布式系统中，一组独立的计算机展现给用户的是一个统一的整体，就好像是一个系统似的。这种情景下就是分布式。

## 为什么要用分布式多进程而不是多线程？

由于`Python`解释器中使用了内部的GIL全局解释器锁，使得`Python`多线程的并发在任意时刻只允许单个CPU来运行，这样的运行方式会影响程序的并发。所以多线程并不适用于高密度的计算任务，由于计算任务数量庞大，所以采用分布式可以大大提高计算的速度。

## 关于`Python`的进程

请点击传送门:[Python并发编程（上）进程模块multiprocessing模块和Process类](http://www.17python.com/blog/34)

## Managers

管理器提供一种创建可在不同进程之间共享的数据的方法，包括在不同机器上运行的进程之间通过网络共享。管理员对象控制管理共享对象的服务器进程。其他进程可以通过使用代理访问共享对象。这里我们使用`multiprocessing.managers.BaseManager`来创建一个多进程管理器，对网络的任务进行注册和管理。`BaseManager`下边封装了很多相关的方法，大大简化了网络上进程之间的通信，可以方便的组建分布式的进程任务。

## Queue

`Queue`实现多生产者，多消费者队列。它特别适用于信息必须在多个线程间安全地交换的多线程程序中。在本次分布式多进程的任务`Queue`起到了非常重要的作用。

## 开始编码前

我们先构思一下程序需要的模块：

- 上帝（God也是服务器，服务器负责注册队列queue,并接收并查看到最终结果。） 
- 生产者（Producer,负责生产出需要进行计算的数据并发送给消费者。）
-  消费者（Consumer，负责接收生产者发来的数据并进行计算，最后把结果发送给上帝看.）

相关思维导图：如果下
![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/10/swdt.png)

## 程序构建要点：

    class GodManager(BaseManager):
        pass

注册一个管理器，负责注册或获取网上的队列`Queue`。

服务器上需要创建程序中必需的queue,并注册到网上。

    GodManager(address=('192.168.0.88',5678),authkey=b'www.17python.com')

注册服务器，通过`start()`启动，通过`connect()`连接。通过`manager.pq()`类似的方法获取网上的队列。

*注意，分布式多进程中一定要获取网上注册的`queue`*，否则会造成数据错乱。

另外，测试时，请在终端中启动程序，网络连接错误的，建议查看一下防火墙是不是禁止了网络的连通，不要在IDE中使用调试来测试本程序。

## God源码

    import random, time, queue
    from multiprocessing.managers import BaseManager
    # 创建任务需要的两个队列
    pq = queue.Queue()
    cq = queue.Queue()
    # 注册一个管理器，注册Queue队列到网，供其它终端使用。
    class GodManager(BaseManager):
        pass
    
    #把任务队列通过管理器注册到网上，这样就可以在多台机器间访问通信，做到分布式通信。
    GodManager.register('pq',callable=lambda:pq)
    GodManager.register('cq',callable=lambda:cq)
    #设置服务器的ip、端口及密码
    manager = GodManager(address=('192.168.0.88',5678),authkey=b'www.17python.com')
    manager.start()#启动服务器
    print('服务器已经启动！')
    #重新获取已经在网上注册的队列,使用队列名()方法来获得网上注册的队列名。
    p_q = manager.pq()
    c_q = manager.cq()
    
    while True:
        if c_q.empty():#如果结果集队列空
            time.sleep(1)
            print("静静的等待计算结果中。。。。。。")
        else:
            r = c_q.get()#获得传来的计算结果
            print("收到任务计算结果%s" % r)


## Producer 生产者

    import random, time
    from multiprocessing.managers import BaseManager
    
    # 注册一个管理器，负责管理调度网上注册的Queue队列
    class ProducerMagager(BaseManager):
        pass
    #获取网络上的Queue 生产者，只关心生产需要计算的数据即可。
    ProducerMagager.register('pq')
    # 注册生产者服务器，address 真写IP及端口，authkey是一个密码，如果需要访问此处必须与服务器一致。
    pm = ProducerMagager(address=('192.168.0.88',5678), authkey=b'www.17python.com')
    pm.connect()#连接服务器
    print('生产者服务器已经准备就绪！')
    task = pm.pq()#获取生产者的队列
    k = 1
    #
    while True:
        for i in range(10):
            r = random.randint(0,999)
            task.put(r)
        print("第{0}轮任务完毕！稍后继续！".format(k))
        k += 1
        time.sleep(3)


## Consumer 消费者

    import time
    from multiprocessing.managers import BaseManager
    
    # 注册一个管理器，负责管理调度网上注册的Queue队列
    class ConsumerMagager(BaseManager):
        pass
    
    #获取网络上的Queue 消费者，需要获取任务，计算后发送任务。
    ConsumerMagager.register('pq')
    ConsumerMagager.register('cq')
    
    m = ConsumerMagager(address=('192.168.0.88',5678),authkey=b'www.17python.com')
    m.connect()#连接服务器
    pq = m.pq()
    cq = m.cq()
    #开始计算任务
    while True:
        if not pq.empty():#如果任务队列不为空
            n = pq.get(timeout=1)#如果超。
            print('收到计算任务{0}*{1}={2}'.format(n,n,n*n))
            cq.put('%d * %d = %d' %(n,n,n*n))
        else:
            time.sleep(1)
            print("好无聊，我在等待任务安排中")


在终端分别启动`python3 God.py` `python3 producer.py` `python3 Consumer.py`

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

然后就可以观察终端打印的结果，服务器终端显示着计算回来的结果，除了服务器以外，生产者和消费者都可以分布式在各个终端上启动多个进行任务的生成和计算。
我这里只在本机上进行测试了，如果只是在一台机器上进行多进程的计算，可以不必网上注册，使用唯一的`Queue`进行通信即可。

别小睢这个小小的分布式，稍加修改任务即可变成强大的分布式采集程序，看你怎么用了。

## 参考文档

+ [queue - 同步队列类](http://python.usyiyi.cn/documents/python_352/library/queue.html#queue.Queue)
+ [multiprocessing —— 基于进程的并行](http://python.usyiyi.cn/documents/python_352/library/multiprocessing.html)

## 本文源码下载：

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

功能强大设置简单的分布式多进程生产者与消费者模式

Python并发编程（下）功能强大设置简单的分布式多进程生产者与消费者模式


## Python中为什么要用多进程编程？

由于`Python`解释器中使用了内部的GIL全局解释器锁，使得`Python`多线程的并发在任意时刻只允许单个CPU来运行，这样的运行方式会影响程序的并发。
当程序是在I/O密集时，CPU可能会有更多的空闲处理多线程的并发，这种情况下一般是没有问题的。如果是大量计算密集型的应用，如果使用多线程来并发，性能会大大降低，这个时候，我们就得考虑使用进程`Process`来进行编程及通信了。

## 创建进程Process(方法1)

    import time, os
    from multiprocessing import Process
    def clock(x,y):
        for i in range(x):
            print('当前时间=={0}'.format(time.ctime()))
            time.sleep(y)
    if __name__ == '__main__':
        p = Process(target=clock,args=(5,1))
        p.start()
        p.join()


## 创建进程Process(方法2)

    import time, os
    from multiprocessing import Process
    class ClockProcess(Process):
        def __init__(self,x,y):
            Process.__init__(self)
            self.x=x
            self.y=y
    
        def run(self):
            for i in range(self.x):
                print('{0}=={1}'.format(os.getpid(),time.ctime()))
                time.sleep(self.y)
    if __name__ == '__main__':
        p = ClockProcess(5,1)
        p1= ClockProcess(5,1)
        p.start()
        p1.start()
        p.join()
        p1.join()


通过`Process`类创建实例，然后传函数创建进程，另一种是继承`Process`类，然后重写`run()`方法创建要执行的任务。

## 进程池 Pool(方法3)

    from multiprocessing import Pool
    import os
    
    def clock(k):
        for i in range(k):
            print('{0}当前时间=={1}'.format(os.getpid(),time.ctime()))
            time.sleep(k)
    if __name__ == '__main__':
        l = [1 for i in range(20)]# 列表推导出一个列表对象
        with Pool(5) as p:
            p.map(clock,l)


进程池方便创建多进程进行操作，创建使用也是比较简单的，使用时可以根据应用场景对线程的控制要求来选择线程的创建方式。

## 线程间的通信

`Python`为线程提供了`Queue、Pipes`等多种方式来交换数据，我们以`Queue`为例来演示学习一下进程间的通信及协作，稍后我们还要做分布式多进程的演示。

`Queue`进程间通信演示：

    import multiprocessing as mp
    import time, os
    from queue import Queue
    
    def prt_q(q):
        '''消费者打印数据'''
        while True:
            v = q.get()
            print(v)
            time.sleep(0.1)
    def wrt_q(q):
        '''生产者添加数据'''
        for k in ['aa','bb','cc','dd','ee','ff','gg']:
            print("{0}已经加入到队列中".format(k))
            q.put(k)
            time.sleep(0.2)
    if __name__ == '__main__':
        q = Queue()
        wrt_q(q)
        p = mp.Process(target=prt_q, args=(q,))
        p.start()
        p.join()


`Queue`的使用其实就是生产者与消费者的模式，上边的代码运行后会有死锁，请按`ctrl+c`强制停止程序运行。
`Python`的进程有个很强大的地方，就是通过简单的配置就可以进行分布式多进程，这点是很吸引人的，稍后我会有一个篇幅来介绍一下分布式多进程。

## 本文源码下载：

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

Python中为什么要用多进程编程？

Python并发编程（上）进程模块multiprocessing模块和Process类


在多线程任务中，线程对数据的操作是随机的，这个先后次序无法预测，如果利用多线程修改唯一数据，由于对数据操作的随机性，必会影响到数据结果的准确性，所以在多线程的任务的编码中，我们必须使用线程锁。

## Python的多线程锁 threading.Lock

通过下边的例子，我们来看看多线程锁的重要性，定义两个数据，同时利用多线程对其+ -相同的数值，
如果操作次序是正常的，一加一减，那个数据应该是没有变化的，但是因为多线程操作没有加锁时对数据的操作是随机争抢资源的，
多线程操作时会发生，多加或是多减的结果，我们看下边的例子：

    import threading
    
    data = 0
    lock_data = 0
    lock = threading.Lock()#创建一把线程锁
    
    lock.acquire()
    lock.release()
    
    def change_d(n):
        '''修改无锁数据的函数'''
        global data
        data += n
        data -= n
    
    def change_l_d(n):
        '''修改有锁数据的函数'''
        global lock_data
        lock_data += n
        lock_data -= n
    
    def myfun(n):
        for i in range(500000):
            change_d(n)
            #lock.acquire()
            #change_l_d(n)
            #lock.release()
            #与下边的with语句处相同
            with lock:
                change_l_d(n)
    
    def main():
        threads = []
        k = 5
        for i in range(k):
            t = threading.Thread(target=myfun, args=(10,))
            threads.append(t)
        for i in range(k):
            threads[i].start()
        for i in range(k):
            threads[i].join()
        print("无锁数据最终结果=={0}".format(data))
        print("有锁数据最终结果=={0}".format(lock_data))
    
    if __name__ == '__main__':
        main()



多次运行后我们会发现，无锁数据的最终结果会出现不同，因为可以证明，无锁的时候多线程操作是随机性的。所以在多线程操作中，如果存在多线程操作唯一数据时，一定要加锁保证每次只有一个线程对基进行操作。

除了对多唯一数据进行加锁这种方法以外，在`Python`中还可以使用信号量或是事件对线程进行控制，但笔者认为，还是使用Lock对象比较方便。


## 本文源码下载：

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

在多线程任务中，线程对数据的操作是随机的，这个先后次序无法预测，如果利用多线程修改唯一数据，由于对数据操作的随机性，必会影响到数据结果的准确性，所以在多线程的任务的编码中，我们必须使用线程锁。

Python多线程编程（下）多线程锁 threading.Lock


## Python多线程
在编程的日常中，如果遇到大量相同并且重复的计算任务时，我们考虑使用多线程，多线程可以并发的执行程序中的函数，这样就可以更快的利用CPU计算结果，结省时间成本。
`Python`中创建线程的方法有很多，可以通过`thread threading.Thread`或是线程池提供的方法来创建线程,这节我们主要讨论如何创建线程。

## 单线程时的操作

我们定义一些操作，先用单线顺序操作。

    
    import time
    def loop():
        print("循环loop1打印时间======",time.ctime())
        time.sleep(3)   
    loop()
    loop()
    print("loop1打印结束时间======",time.ctime())


程序执行结果：

循环loop1打印时间====== Mon Oct  2 07:59:17 2017

循环loop1打印时间====== Mon Oct  2 07:59:20 2017

loop1打印结束时间====== Mon Oct  2 07:59:23 2017

顺序执行程序后，共花掉6秒时间，如果我们可以并发执行这个打印，或许我们能节约一些时间。

## thread

`thread`提供了一些线程创建与操作的方法，但官方文档及各类参考书中均有提到，`_thread`是一个比较低级的线程操作模块不建使用，这里我们也只是带过。

    import _thread
    from utils import tn # 导入工具类中计算程序执行时间的函数
    def loop():
        print("循环loop1打印时间======",time.ctime())
        time.sleep(3)  
    @tn
    def main():
        _thread.start_new_thread(loop, ())
        _thread.start_new_thread(loop, ())
        time.sleep(3)
        print("如果上边没有sleep()，程序会没有运行完打印直接退出")
    if __name__ == '__main__':
        main()


程序执行结果：

循环loop1打印时间====== Mon Oct  2 14:24:49 2017

循环loop1打印时间====== Mon Oct  2 14:24:49 2017

如果上边没有sleep()，程序会没有运行完打印直接退出

程序运行时间:3.01ms

这次程序的运行我节省了3秒钟的宝贵时间！但也发现了`thread`模块的一些缺点，比如主线程结束时不会等待其它线程，这将导致程序没有打印结果直接退出了，这是我们不想看到的。
所以，由于`thread`模块的功能缺陷，通常不推荐使用`thread`,我们将继续讨论更高级的线程模块`threading`和其它线程相关模块。


## threading模块 Thread类

创建一个`Thread`实例，其中`target`这个参数可以接受一个函数.
我们先来试试，代码如下：

    import time
    import threading
    from utils import tn # 导入工具类中计算程序执行时间的函数
    def loop1(tname):
        print(tname+"循环loop1打印时间======" + time.ctime())
        time.sleep(2)
    @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()
    if __name__ == '__main__':
        main()


通过继承`Thread`类派生子类并创建线程的对象，是创建线程的另一种方法：

    
    import time
    import threading
    from utils import tn # 导入工具类中计算程序执行时间的函数
    class MyThread(threading.Thread):
        def __init__(self, func, name=''):
            threading.Thread.__init__(self) # 这里必须添加父类的构器方法
            self.func = func
            self.name = name
        #此方法必须实现
        def run(self):
            self.func(self.name)
    
    def loop1(tname):
        print(tname+"循环loop1打印时间======" + time.ctime())
        time.sleep(2)
    @tn
    def main():
        print('程序开始执行，耐心等待几秒。')
        threads = [] #定义一个线程队列
        for i in range(5):
            t = MyThread(loop1, "thread"+str(i))
            threads.append(t)
        for i in range(5):
            threads[i].start()
        for i in range(5):
            threads[i].join()
    if __name__ == '__main__':
        main()


注意：`run()`此方法必须实现;`threading.Thread.__init__(self)` 必须添加父类的构器方法

二种方法相比较起来，通过继承`Thread`类来创建线程的实例更直观灵活一些，通过以上例子的对比来看，多线程并发执行程序要比单线程执行节约很多时间。
关于多线程实例的创建还有其它方法，比如`Thread`构建方法中target参数也可以传入一个实例，不过个人感觉没有继承`Thread`类创建的实例更直观些，这里也就不举例了，
另外还可以通过线程池创建一组线程用来执行任务。

## threadpool Python线程池

`Python3`下载安装模块

    pip3 install threadpool

用线程池测试一下刚才的打印，代码如下：

    import time
    import threadpool
    from utils import tn # 导入工具类中计算程序执行时间的函数
    def loop1(tname):
        print(tname+"循环loop1打印时间======" + time.ctime())
        time.sleep(2)
    @tn
    def main():
        l = ['11111','22222','33333','44444','55555']
        pool = threadpool.ThreadPool(5)# 创建一个线程池
        requests = threadpool.makeRequests(loop1, l) #传入函数 及函数需要的参数
        [pool.putRequest(req) for req in requests]# 不理角这段代码，猜测是循环创建线程 分配任务。
        pool.wait()#设置池内所有线程等待。
    
    if __name__ == '__main__':
        main()



`Python`线程的创建方法应该还有很多种，这里就不在介绍了，博主感觉继承`Thread`类创建实例的方法比较经典可行，代码直观，其次是创建`Thread`对象传参进去也是简单到家了。
有关`Python`线程的创建就先聊到这里，稍后再研究一下线程锁，这几天正值国庆节，祝大家玩的开心！

## 本文源码下载：

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

在编程的日常中，如果遇到大量相同并且重复的计算任务时，我们考虑使用多线程，多线程可以并发的执行程序中的函数，这样就可以更快的利用CPU计算结果，结省时间成本。

Python多线程编程（上）多线程创建的几种方法


### 静态方法和类方法的定义

`Python`中类的静态方法使用`@staticmethod`装饰器来定义
`Python`中类方法使用`@classmethod`装饰器来定义


    class Hello:
        k = 2
        #定义一个类的静态方法
        @staticmethod
        def add(x,y):
            return x + y
        #定义一个类方法
        @classmethod
        def mul(cls,x):
            return cls.k * x
    
    print(Hello.add(999,1))#使用静态方法 结果为1000
    print(Hello.mul(2))#使用类方法 结果为4


类的静态方法使用和使用普通函数一样简单，但类方法确有些不同，她只能用于类本身，把自身做为对象进行操作。
我们继承一下`Hello`这个类，看看静态方法和类方法是不是能被继承？

    class World(Hello):
        k = 4
    
    print(World.add(1,999))
    print(World.mul(2))


通过上边的例子，我们可以发现子类可以继承使用父类方法和父类的静态方法，如果类变量值有所变化，结果也会有所不同。

## 本文源码下载：

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

python 类的静态方法和类方法


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

## 面向对象编程

说起面向对象编程，除了那些晦涩抽象的定义，我脑海中印象比较深的就是那张王宝强的表情图：程序员？面向对象编程？哈哈哈没有对象你编毛程？

## 三大特征

学过java的同学应该非常的了解这三个特征：*封装、继承、多态*
在Python的世界中，一切都是对象，为什么要用面向对象模式来进行编程？因为这样更接近人类对自然的认识过程，更直观，如果对面向编程的理论不太了解，建议百度搜索相关知识了解一下。

## Python中的Class

在Python中定义一个Class是非常简单的，语方法如下：

    Class classname(object):
        pass

其中（object）是用来定义需要继承的父类，Python中，可以继承多个类，这个与java的单继承不同。

    def run():
        print("我会跑！")
    
    class Animal(object):
        k = 0#类属性
        def __init__(self,name):#类构造器
            self.name = name#实例的属性
        #实例的方法
        def say(self):
            Animal.k += 1
            print("{0}:我会呼吸！".format(self.name))
            print("Animal.k={0}".format(Animal.k))
    
    a = Animal("aaaa")
    a.say()#执行实例的方法
    print("Animal.k:{0}".format(Animal.k))#打印类属性
    print(Animal.__init__)
    print(Animal.say)
    Animal.m = 1
    a.color = "red" #动态的添加属性
    a.run = run()#动态的添加属性
    print("我的颜色是=%s" % a.color)
    print("Animal.m=%s" % Animal.m)
    print("a.m=%s" % a.m)
    # print("Animal.a：%s" % Animal.a)  这里会抛出错误


上边的实例不难发现，在类中，包括`k`类变量、`self.name`实例变量、`say`实例的方法，这些成员，都是类的的属性。
Python中的实例对象可以动态的添加类变量及实例变量，只需要点一个`.`这和Java不同（当然Java也可以通过反射aop切面方式动态为对象添加功能方法）。

## 构造器和self

`__init__(self)`类中的这个特殊方法就是类的构造器，`self`代表着这个类创建的对象。
关于成员变量我们可以这样理解：对象和类说：`关于变量，你的就是我的，我的确只是我的。`


## Python的继承

Python中，类的继承很简单方便，看下下边的代码


    class Dog(Animal):
        k = 999 #我们定义了一个与父类相同的类变量
        def __init__(self,name):#同样定义了一个相同名称的实例变量
            Animal.__init__(self,name)#注意这里没有:::::号
    
        def say(self):
            print(self.name+":我的叫声是：汪汪汪！")
            print("Dog.k={0}".format(Dog.k)),
    
    dog = Dog("wangwang")
    dog.say()
    print("Animal.k:{0}".format(Animal.k))#打印父类属性
    print("Dog.k:{0}".format(Dog.k))#打印子类属性
    # dog.run #这个动态添加到父类创建的实例中的变量是无法继承过来的。 非得执行的话会报错。


通过上边的例子，我们可以看出，类继承后，实例的变量是可以继承的，通过调用父类的`__init__()`方法来简化实例构造。
但是父类的类属性是无法继承的，他们互相独立存在在内存中。
`Dog`类中的也有一个`say()`的方法，象这样与父类拥有相同的方法名称而具有不相同的执行结果的行为叫做方法重写。

## 多态

我们在创建一个新类继承`Animal`


    class Cat(Animal):
        def __init__(self,name):
            Animal.__init__(self,name)
        
        def say(self):
            print(self.name+":我的叫声是：喵喵喵")
    
    cat = Cat("Tom")
    cat.say()


`isinstance()`函数，可以用来判断一个变量是否是某个类，我们测试一下

    print(isinstance(cat,Cat))#True
    print(isinstance(cat,Animal))#True
    print(isinstance(a,Animal))#True
    print(isinstance(a,Cat))#False

很明显，动物的对象不能说成是猫，但猫的对象可以是猫类，说猫是动物类也没什么错误。也就是说，继承是从上到下。
那多态是什么？我们还需要一个函数，然后来看看。

    def isay(animal):
        animal.say()
    
    isay(a)#aaaa:我会呼吸！
    isay(dog)#wangwang:我的叫声是：汪汪汪！
    isay(cat)#Tom:我的叫声是：喵喵喵


通过`isay()`方法的输出，我们多少对多态这个概念有那么一点了解了，回想当年学Java的多态的时候，和现在的情况大同小异乎？
如果我们随便建一个类，包括`say()`方法，然后用`isay()`方法输出打印，会不会也是产生多态的效果呢？
答案是：会的！在`Pyhong`中，这就是动态语言的“鸭子类型”，一个对象只要“看起来像鸭子，走起路来像鸭子”，那它就可以被看做是鸭子。
然在`Java`静态语言中，则会对父类进行检查，如果不是同一个父类，那么就会报错。

好吧，有关Python类，对象相关先说到这里，希望大家国庆节快乐哦！

## 本文源码下载：

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

说起面向对象编程，除了那些晦涩抽象的定义，我脑海中印象比较深的就是那张王宝强的表情图：程序员？面向对象编程？哈哈哈没有对象你编毛程？

Python面向对象编程（OOP）初探


## Event鼠标事件

+ <Button-1>：鼠标左击事件  
+ <Button-2>：鼠标右击事件  
+ <Button-3>：鼠标中击事件  
+ <Double-Button-1>：双击事件  
+ <Triple-Button-1>：三击事件  
+ <Bx-Motion>：鼠标移动事件,x=[1,2,3]分别表示左、中、右鼠标操作。  
+ <ButtonRelease-x>鼠标释放事件,x=[1,2,3],分别表示鼠标的左、中、右键操作  
+ <Leave>：鼠标离开时产生此事件  

## Event键盘事件
bing<Key>和事件函数来触发，其中Key 可以换成对应的键值，也可以是组合键。

## 程序事件

程序退出`root.protocol('WM_DELETE_WINDOW', printProtocol)  `

## 源码

![](https://suiyan.cc/assets/images/media/upload/2017/09/Snip20170928_18.png)

    import tkinter as tk
    
    root = tk.Tk()
    
    ###################################
    # 鼠标事件
    ###################################
    def printroot(event):
        print(event.x,event.y)
    
    bt = tk.Button(root, text="<Double-Button-1>：双击事件 ")
    bt1 = tk.Button(root, text="<Triple-Button-1>：三击事件  ")
    bt2 = tk.Button(root, text="<Leave>：鼠标离开时产生此事件")
    bt3 = tk.Button(root, text="<Button-1>：鼠标左击事件")
    bt4 = tk.Button(root, text="<Button-2>：鼠标右击事件")
    bt5 = tk.Button(root, text="<Button-3>：鼠标中击事件")
    bt6 = tk.Button(root, text="<B1-Motion>：鼠标移动事件,x=[1,2,3]分别表示左、右、中鼠标操作。  ")
    bt7 = tk.Button(root, text="<ButtonRelease-2>鼠标释放事件,x=[1,2,3],分别表示鼠标的左、右、中键操作  ")
    bt.grid()
    bt1.grid()
    bt2.grid()
    bt3.grid()
    bt4.grid()
    bt5.grid()
    bt6.grid()
    bt7.grid()
    bt.bind("<Double-Button-1>",printroot)
    bt1.bind("<Triple-Button-1>",printroot)
    bt2.bind("<Leave>",printroot)
    bt3.bind("<Button-1>",printroot)
    bt4.bind("<Button-2>",printroot)
    bt5.bind("<Button-3>",printroot)
    bt6.bind("<B1-Motion>",printroot)
    bt7.bind("<ButtonRelease-2>",printroot)
    
    
    ###################################
    # 键盘事件
    ###################################
    def printkey(event):
        print("event.char = " + event.char)
        print('event.keycode = ', event.keycode)  
    
    
    root.bind("<Shift_R>",printkey)
    root.bind("<Shift_L>",printkey)
    root.bind("<Return>",printkey)
    root.bind("<Key>",printkey)
    
    
    ###################################
    # 程序退出
    ###################################
    def printProtocol():  
        print('WM_DELETE_WINDOW')  
        root.destroy() 
    
    root.protocol('WM_DELETE_WINDOW', printProtocol)  
    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 TK和Tkinter的GUI编程Event键盘鼠标事件

Python TK和Tkinter的GUI编程(9) Event 键盘鼠标事件


Scalet和Spinbox 是tk中用来调节刻度的小部件。

## Scalet 滑动模块部件

Scalet 在使用中有几个必要的地方：

+ 设置刻度，`from_=0, to=1000,`还可以`from_=0, to=10,resolution=0.1`,设置每次调结刻度值
+ 滑块滑动事件，当滑动时，返回当前的刻度，有二种方法，无论哪种方法，需要先绑定回调函数`command=prtsa`
+ 取回当前刻度值，回调函数包括一个text字符串参数，通过这个参数可以直接返回当前的刻度值，另外还可以通过绑定变量来返回刻度值。

## Spinbox 

+ 绑定回调函数，然后通过`get()`方法返部件当前值。

## 源码

![](https://suiyan.cc/assets/images/media/upload/2017/09/Snip20170928_17.png)

    import tkinter as tk
    
    root = tk.Tk()
    root.title("Scrollbar 测试")
    #分别创建一个横向，一个坚向的滚动条，
    ybar = tk.Scrollbar(root)
    ybar.pack(fill=tk.Y, side=tk.RIGHT)
    xbar = tk.Scrollbar(root,orient=tk.HORIZONTAL)#orient=tk.HORIZONTAL表示为坚向滚动
    xbar.pack(fill=tk.X, side=tk.BOTTOM,)
    # 创建文本框，并设置横向及坚向的滚动条，wrap='none'表示文本不换
    t = tk.Text(root,yscrollcommand=ybar.set,xscrollcommand=xbar.set, wrap='none')
    t.pack(fill=tk.BOTH)
    # 添加一些字符串
    s = ""
    for i in range(100):
        for j in range(100):
            s = s+str(i)+" "
        s = s+"\n"
    t.insert(tk.END,s)
    #为滚动条添加对应的函数，添加后，滚动条才会有效滚动
    ybar.config(command=t.yview)
    xbar.config(command=t.xview)
    
    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)

Scalet和Spinbox 是tk中用来调节刻度的小部件。

Python TK和Tkinter的GUI编程(8) Scalet和Spinbox的简单使用


## Scrollbar

Scrollbar就是窗口中的滚动条，一般应用在文本框和列表框的外围，如果内容显示超出范围之外，就会显示滚动条。

## 创建及使用

+ 创建Scrollbar对象，通过orient设置他的滚动方向，HORIZONTAL or VERTICAL. 默认是VERTICAL。
+ 在部件中指定滚动条部件`yscrollcommand=ybar.set,xscrollcommand=xbar`
+ `ybar.config(command=t.yview) xbar.config(command=t.xview)` 设置滚动条事件，使滚动条交互起来。

## 源码

![](https://suiyan.cc/assets/images/media/upload/2017/09/Snip20170927_16.png)

    import tkinter as tk
    
    root = tk.Tk()
    root.title("Scrollbar 测试")
    #分别创建一个横向，一个坚向的滚动条，
    ybar = tk.Scrollbar(root)
    ybar.pack(fill=tk.Y, side=tk.RIGHT)
    xbar = tk.Scrollbar(root,orient=tk.HORIZONTAL)#orient=tk.HORIZONTAL表示为坚向滚动
    xbar.pack(fill=tk.X, side=tk.BOTTOM,)
    # 创建文本框，并设置横向及坚向的滚动条，wrap='none'表示文本不换
    t = tk.Text(root,yscrollcommand=ybar.set,xscrollcommand=xbar.set, wrap='none')
    t.pack(fill=tk.BOTH)
    # 添加一些字符串
    s = ""
    for i in range(100):
        for j in range(100):
            s = s+str(i)+" "
        s = s+"\n"
    t.insert(tk.END,s)
    #为滚动条添加对应的函数，添加后，滚动条才会有效滚动
    ybar.config(command=t.yview)
    xbar.config(command=t.xview)
    
    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)

Scrollbar就是窗口中的滚动条，一般应用在文本框和列表框的外围，如果内容显示超出范围之外，就会显示滚动条。

Python TK和Tkinter的GUI编程(7) Scrollbar的使用


Checkbutton和Radiobutton单选和多选按钮在GUI编程中是经常使用的选项选择方法，tk提供的单选与多选按钮功能虽然简约，但功能上也是足够应付日常应用了。

## Checkbutton

多选按钮，因为是选择按钮，所以我们需要判断当这个按钮被点击后，应该属于选择状态，然后根据状态的选择状态返回值进行相关操作。
`variable`是多选按钮的一个属性，这个属性的值用来显示当前多选择按钮的状态，1时为选中，2时为释放。
`select() deselect() toggle()`这三个方法用来切换多选择按钮的选择状态。

## Radiobutton
单选选按钮一般都是二个以上成组显示，一般最需要的就是获取单选按钮的返回值，程序中先设置一组包括属性及显示字符串的list，然后用for循环来创建多选按钮。
`variable=v, value=mode,`这二个属性配合使用，当使用`get()`方法返回值的时候，返回的是value上的这个值（这里的原因我也没明白，希望高人指点一下。），所以设置单选按钮值的时候，记得设置value。

## LabelFrame 

LabelFrame 是一个带线的部件容器，具体效果请看下边的截图：

## 源码

![](https://suiyan.cc/assets/images/media/upload/2017/09/Snip20170927_13.png)

    import tkinter as tk
    
    def cdef():
        if var.get():
            strvar.set("看，我改变了！")
        else:
            strvar.set("有种你点我试试")
    
    def rdoprt():
        print(v.get())
        r_frame['bg']=v.get()
    root = tk.Tk()
    root.title("Checkbutton和Radiobutton")
    
    c_frame = tk.LabelFrame(root,text="Checkbutton", padx=5, pady=5)
    c_frame.pack(fill=tk.X, side=tk.TOP)
    
    var = tk.IntVar()
    strvar = tk.StringVar()
    strvar.set("有种你点我试试")
    cbt = tk.Checkbutton(c_frame,textvariable=strvar, variable = var,command= cdef,)
    # cbt.select()#选中
    # print(var.get())
    # cbt.deselect()#取消选中
    # print(var.get())
    # cbt.toggle()#切换选中开关
    # print(var.get())
    cbt.pack(side=tk.LEFT)
    cbt1 = tk.Checkbutton(c_frame,text="Checkbutton", variable = var, command=cdef)
    cbt1.pack(side=tk.LEFT)
    
    r_frame = tk.LabelFrame(root,text="Radiobutton", padx=5, pady=5)
    r_frame.pack(fill=tk.X, side=tk.TOP)
    v = tk.StringVar()
    v.set("L") # initialize
    MODES = [
            ("#c00", "#c00"),
            ("#fff", "#fff"),
            ("#000", "#000"),
            ("#ccc", "#ccc"),
        ]
    
    for text, mode in MODES:
            b = tk.Radiobutton(r_frame, text=text,variable=v, value=mode,command=rdoprt)
            b.pack(anchor=tk.W)
    
    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)

Checkbutton和Radiobutton单选和多选按钮在GUI编程中是经常使用的选项选择方法，tk提供的单选与多选按钮功能虽然简约，但功能上也是足够应付日常应用了。

Python TK和Tkinter的GUI编程(6) Checkbutton Radiobutton


messagebox 弹出提示框 一共有七种常用方法，基本上可以应付一般简单的程序需求了：
showinfo, showwarning, showerror, askquestion, askokcancel, askyesno, or askretrycancel.
其中askquestion, askokcancel, askyesno, or askretrycancel这4个方法，应该注意一下点击按钮的返回值。

演示图如下：

![演示图](![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/09/Snip20170926_5.png)
![演示图](![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/09/Snip20170926_6.png)
![演示图](![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/09/Snip20170926_7.png)
![演示图](![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/09/Snip20170926_8.png)
![演示图](![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/09/Snip20170926_9.png)
![演示图](![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/09/Snip20170926_10.png)
![演示图](![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/09/Snip20170926_11.png)
![演示图](![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/09/Snip20170926_12.png)

    import tkinter as tk
    from tkinter import messagebox  # 导入提示窗口包
    
    str1=("showinfo","showwarning","showerror","askquestion","askokcancel","askyesno","askretrycancel")
    def showMsg(str):
        """弹出窗口设置函数"""
        print(str)
        if str == str1[0]:
            messagebox.showinfo("showinfo","信息提示框！")
        elif str == str1[1]:
            messagebox.showwarning("showwarning","警告框！")
        elif str == str1[2]:
            messagebox.showerror("showerror","错误信息框！")
        elif str == str1[3]:
            if messagebox.askquestion("askquestion","askquestion提示框") == messagebox.YES:
                messagebox.showinfo("yes","你点了yes!")
            else:
                messagebox.showinfo("no","你点了no")
        elif str == str1[4]:
            if messagebox.askokcancel("askokcancel","askokcancel提示框"):
                messagebox.showinfo("OK","你点Ok")
            else:
                messagebox.showwarning("cancel","你点了cancel")
        elif str == str1[5]:    
            print(messagebox.askyesno("askyesno","askyesno提示框"))
        elif str == str1[6]:    
            print(messagebox.askretrycancel("askretrycancel","askretrycancel提示框"))
    
    root = tk.Tk()
    root.title("messagebox 弹出对话框使用例子")
    
    show_frame = tk.Frame(root)
    show_frame.pack(fill=tk.X, side=tk.TOP)
    btn1= tk.Button(show_frame, text=str1[0],command=lambda showMsg = showMsg : showMsg(str1[0]) ).pack(side=tk.LEFT)
    btn2= tk.Button(show_frame, text=str1[1],command=lambda showMsg = showMsg : showMsg(str1[1]) ).pack(side=tk.LEFT)
    btn3= tk.Button(show_frame, text=str1[2],command=lambda showMsg = showMsg : showMsg(str1[2]) ).pack(side=tk.LEFT)
    
    asky_frame = tk.Frame(root)
    asky_frame.pack(fill=tk.X,side=tk.TOP)
    bt4 = tk.Button(asky_frame,text=str1[3],command=lambda showMsg = showMsg : showMsg(str1[3]) ).pack(side=tk.LEFT)
    bt5 = tk.Button(asky_frame,text=str1[4],command=lambda showMsg = showMsg : showMsg(str1[4]) ).pack(side=tk.LEFT)
    bt6 = tk.Button(asky_frame,text=str1[5],command=lambda showMsg = showMsg : showMsg(str1[5]) ).pack(side=tk.LEFT)
    bt7 = tk.Button(asky_frame,text=str1[6],command=lambda showMsg = showMsg : showMsg(str1[6]) ).pack(side=tk.LEFT)
    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)

messagebox 弹出提示框 一共有七种常用方法，基本上可以应付一般简单的程序需求了

Python TK和Tkinter的GUI编程(5) messagebox tk的弹出对话框


Tk的功能不多，但应付一般应用还是足够了，Entry和Text是Tk下边显示及处理文本的小部件。
涉及到文本，从使用角度来说，有几个功能是必须的：

+ 设置文本框的内容`insert()`
+ 删除文本框的内容`delete()`
+ 获得文本框的内容`get()`
+ `show="*"`这个可以设置密码框用***来显示密码

关于布局，和其它部件基本上是一样的，前边的章节有过介绍。

本次使用tk制作了一个用户登陆验证用户名和密码的小例子。

演示图如下：

![演示图](![输入图片说明](https://suiyan.cc/assets/images/media/upload/2017/09/Snip20170926_4.png)

    import tkinter as tk
    def isLogin(uname,pword):
        """验证用户登陆函数"""
        if uname == "17python" and pword == "17python":
            print("登陆成功！")
            out.insert(tk.END,"登陆成功！\n")
        else:
            print("用户名或密码错误！")
            out.insert(tk.END,"用户名或密码错误！ \n")
    
    root = tk.Tk()
    root.title('文本框的测试')
    userinfo_frame = tk.Frame(root)
    userinfo_frame.pack(fill=tk.X, side=tk.TOP)
    ########
    user_frame = tk.Frame(userinfo_frame, )
    user_frame.pack(fill=tk.X, side=tk.TOP)
    user_label = tk.Label(user_frame, text="username:",font=("Symbol", 14)).pack(side=tk.LEFT)
    username = tk.Entry(user_frame, width=40)
    username.pack(fill=tk.X, side= tk.LEFT)
    
    #######
    pass_frame = tk.Frame(userinfo_frame)
    pass_frame.pack(fill=tk.X, side=tk.TOP)
    pass_label = tk.Label(pass_frame, text="password:",font=("Symbol", 14)).pack(side=tk.LEFT)
    password = tk.Entry(pass_frame, width=40, show="*")
    password.pack(fill=tk.X, side= tk.LEFT)
    ########
    btn_frame = tk.Frame(userinfo_frame)
    btn_frame.pack(fill=tk.X, side=tk.TOP)
    btn = tk.Button(btn_frame, text='登陆', command= lambda isLogin = isLogin : isLogin(username.get(), password.get())).pack(fill=tk.X)
    out = tk.Text(btn_frame,width=40,font=("Symbol", 14))
    out.insert(tk.END, "world \n")
    out.pack(fill=tk.X)
    
    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)

Tk的功能不多，但应付一般应用还是足够了，Entry和Text是Tk下边显示及处理文本的小部件。