版权声明：本文为博主原创文章，未经博主允许不得转载。

在Python世界中，我们常常听到的GIL到底是什么？因为它的存在，对程序的执行产生什么影响？其背后的原理又是怎样的？

GIL是什么

GIL全称Global Interpreter Lock，也叫全局解释锁，官方解释如下：

In CPython, the global interpreter lock, or GIL, is a mutex that protects access to Python objects, preventing multiple threads from executing Python bytecodes at once. This lock is necessary mainly because CPython’s memory management is not thread-safe. (However, since the GIL exists, other features have grown to depend on the guarantees that it enforces.)

翻译为：

在CPython解释器中，全局解释锁GIL是在于执行Python字节码时为了保护访问Python对象而阻止多个线程执行的一把互斥锁。这把锁的存在在主要是因为CPython解释器的内存管理不是线程安全的。然而直到今天GIL依旧存在，现在的很多功能已经习惯于依赖它作为执行的保证。

关注几个重点：

• GIL是存在于CPython解释器中的，属于解释器层级的，而并非属于Python语言特性，也就是说，如果你自己有能力实现一个Python解释器，完全可以不使用GIL
• GIL是为了让Python解释器在执行Python代码过程中，同一时刻只有一个线程在运行，以此保证内存管理是安全的
• 历史原因，现在很多Python的功能已经习惯依赖GIL

由于CPython是Python的默认解释器，所以平时我们说到GIL就会把它想成是Python语言层面的，这个表述是不准确的。

常见的Python解释器有如下几种，以及这些解释器是否存在GIL：

• CPython：C语言开发的解释器，默认官方版本，使用最为广泛，有GIL
• IPython：基于CPython开发的交互式解释器，只是增强了交互功能，执行功能与CPython完全一样
• PyPy：目标是加快执行速度，采用JIT技术，对Python代码进行动态编译（不是解释），可显著提高执行速度，但执行结果可能与CPython不同。有GIL，但其开发者宣布发布去掉GIL的版本
• Jython：运行在Java平台上的Python解释器，可以把Python代码编译成Java字节码，依赖Java平台，没有GIL
• IronPython：和Jython类似，执行在微软.Net平台的Python解释器，可以把Python代码编译成.Net字节码依赖.Net平台，没有GIL

版权声明：本文为博主原创文章，未经博主允许不得转载。

Python中的元类metaclass，我们在开发中用到的不是很多，这个特性常用于开源框架中。

不过理解元类能够帮我们更深入地理解Python的设计理念，以及Python世界中常说的：一切皆对象！

什么是元类

我们知道类（class）是创建实例（instance）的东西，在Python中，元类（metaclass）是创建类（class）的东西，关系如下图：

简单来说，可以这样理解：

1
2

klass = MetaClass()     # 元类创建类
obj = klass()           # 类创建实例

我们可以通过__class__属性来查看一个实例的类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

>>> a = 1               # 创建a的类是int,a是int的实例
>>> a.__class__
<type 'int'>
>>> b = 'abc'           # 创建b的类是str,b是str的实例
>>> b.__class__
<type 'str'>
>>> def c():            # 创建c的类是function,方法c是function的实例
...     pass
>>> c.__class__
<type 'function'>
>>> class D(object):    # 创建d的类是D,d是D的实例
...     pass
>>> d.__class__
<class '__main__.D'>

平时我们在使用int、str、list、dict等内置对象时，实际上使用的是这些类创建出来的实例。

我们再来看，创建这些类的是什么？

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

>>> a = 1
>>> a.__class__.__class__
<type 'type'>
>>>
>>> b = 'abc'
>>> b.__class__.__class__
<type 'type'>
>>>
>>> def c():
...     pass
>>> c.__class__.__class__
<type 'type'>
>>>
>>> class D(object):
...     pass
>>> d = D()
>>> d.__class__.__class__
<type 'type'>

从代码结果看到，创建这些类的都是type，type是创建所有类的元类。

你可以更深刻地感受一下：Python中一切皆对象！我们也可以说元类是创建所有类的工厂。

在Python中，使用type关键字可就以创建一个类，type的语法：

1

type(class_name, (base_class, ...), {attr_key: attr_value, ...})

使用type关键字创建一个类：

1
2
3
4
5

>>> A = type('MyClass', (object, ), {}) # type创建一个类，继承object
>>> A
<class '__main__.MyClass'>
>>> A()
<__main__.MyClass object at 0x10d905950>

使用type关键字创建一个类，并包含某些属性和方法：

1
2
3
4
5
6
7
8
9
10

>>> def foo(self):
...     return 'foo'
...
>>> name = 'zhangsan'
>>>
>>> B = type('MyClass', (object, ), {'name': name, 'foo': foo})     # type创建类B，继承object，包含name属性和foo方法
>>> B.name          # 打印属性name
'zhangsan'
>>> print B().foo() # 调用方法foo
foo

type是Python中使用的内建元类，其实它也允许我们建立自己的元类。

版权声明：本文为博主原创文章，未经博主允许不得转载。

在Python开发中，我们见过很常见的概念，如容器、可迭代对象、迭代器、生成器。

这些概念之间有什么联系和区别呢？

总览

容器（container）、可迭代对象（iterable）、迭代器（iterator）、生成器（generator）的关系如下图：

• list、set、tuple、dict都是容器
• 容器通常是一个可迭代对象
• 但凡可以返回一个迭代器的对象，都称之为可迭代对象
• 实现了迭代器协议方法的称作一个迭代器
• 生成器是一种特殊的迭代器

容器

简单来说，容器就是存储一些事物的概念统称，它最大的特性就是给你一个事物，告诉我这个事物是否在这个容器内。

在Python中，使用in或not in来判断某个事物是存在或不存在某个容器内。

也就是说一个对象实现了__contains__方法，我们都可以称之为容器。

在Python中，str、list、tuple、set、dict都是容器，因为我们可以用in或not in语法得知某个元素是否在容器内，它们内部都实现了__contains__方法。

1
2
3
4
5

print 1 in [1, 2, 3]    # True
print 2 not in (1, 2, 3)        # False
print 'a' in ('a', 'b', 'c')    # True
print 'x' in 'xyz'      # True
print 'a' not in 'xyz'      # True

如果我们想自定义一个容器，只需像下面这样：

1
2
3
4
5
6
7
8
9
10
11
12

class A(object):
    def __init__(self):
        self.items = [1, 2]
    def __contains__(self, item):   # x in y
        return item in self.items
a = A()
print 1 in a    # True
print 2 in a    # True
print 3 in a    # False

但一个容器不一定支持输出存储在内的所有元素的功能。

一个容器要想输出保存在内的所有元素，其内部需要实现迭代器协议。

版权声明：本文为博主原创文章，未经博主允许不得转载。

with语句

我们操作文件时，一般的写法：

1
2
3
4

f = open('a.txt')   # 打开文件
for line in f:
    print line      # 输出内容
f.close()           # 关闭文件

这么写会产生一个问题，如果在打开文件后，输出内容或其他操作发生异常，就会导致不会关闭文件句柄，没有释放资源。

修改如下：

1
2
3
4
5
6

f = open('a.txt')   # 打开文件
try:
    for line in f:
        print line      # 输出内容
finally:
    f.close()           # 关闭文件

这么写的好处是能够保证文件资源始终会被释放，但代码结构难免有些繁琐，可读性较差。

使用with就能有效解决这些问题：

1
2
3

with open('a.txt') as f:
    for line in f:
        print line

使用with语句，能够在执行完with语句块后，自动关闭文件资源，并且保证了代码的结构干净清晰，可读性较好。

上下文管理器协议

那么with的实现机制是怎样的？

with语句是从Python2.5开始引入的一种与异常处理相关的功能，（2.5 版本中要通过from __future__ import with_statement导入后才可以使用），但从2.6版本开始缺省可用。

with语句适用于对资源进行访问的场合，确保不管使用过程中是否发生异常都会执行必要的清理操作，释放资源。

多用于在读取文件、线程锁中使用后自动释放等场景。

with语句格式如下：

1
2

with context_expression [as target(s)]:
    with-body

要想实现with语法，只需要实现上下文管理器协议即可：

• __enter__：在进入with语句块之前调用，返回值赋给target
• __exit__：在退出with语句块之后调用，主要做异常处理操作

版权声明：本文为博主原创文章，未经博主允许不得转载。

前言

在Python开发中，我们很少能接触到描述器的直接使用，但对于熟练使用Python的开发者，了解Python描述器的工作原理，能让你更深入地了解Python以及其设计的优雅之处。

其实我们开发中遇到的很多例子，例如：

• 装饰器property、staticmethod、classmethod
• function、bound method、unbound method

是不是都很熟悉，其实这些都与描述器有着千丝万缕的关系，这篇文章就为大家一一解答其中的奥秘。

什么是描述器？

一般来说，描述器是一个有「绑定行为」的对象属性，它的访问控制被描述器协议方法重写。

回忆一下，在编程中我们说「行为」一般指的是方法。

那么这就容易理解了，「绑定行为」的对象属性，就是指这个「对象属性」依托于了另外的对象，这个对象里包含了很多「方法」来控制这个行为。

描述器协议

对象属性依托的对象中，包含的「方法」不能随便定义，而是规定好的，实现这些方法，就是实现了描述器协议，具体有以下几个：

• __get__
• __set__
• __delete__

只要实现以上方法其一，这个对象就叫做描述器。

• 定义了__get__和__set__的对象叫做资料描述器
• 只定义了__get___的对象叫做非资料描述器

这两者有什么区别呢？我们下面再做解释。

版权声明：本文为博主原创文章，未经博主允许不得转载。

最近在公司做了垂直网络爬虫平台的技术分享，故整理成文章分享给大家。

写一个爬虫很简单，写一个可持续稳定运行的爬虫也不难，但如何构建一个通用化的垂直网络爬虫平台？

这篇文章主要介绍垂直网络爬虫平台的构建思路。

爬虫简介

首先介绍一下什么是爬虫？

网络爬虫（又被称为网页蜘蛛，网络机器人），是一种按照一定的规则，自动地抓取网页信息的程序或者脚本。

很简单，爬虫就是指定规则自动采集数据的程序脚本，目的在于拿到想要的数据。

爬虫主要分两类：

• 通用网络爬虫（搜索引擎）
• 垂直网络爬虫（特定领域）

由于第一类的开发成本较高，故只有搜索引擎公司在做，如谷歌、百度等。

而大多数企业在做的是第二类，成本低、数据价值高。例如一家做电商的公司只需要电商领域有价值的数据，那开发一个电商领域的爬虫平台，意义较大。

这篇文章主要针对第二类的平台构建提供设计与思路。

版权声明：本文为博主原创文章，未经博主允许不得转载。

在上一篇文章Python技术进阶——魔法方法（一）中，主要介绍了构造与初始化、类的表示、访问控制这几大类魔法方法，同时阐述了各自的使用场景。

本篇文章继续介绍剩下的魔法方法，主要包括：比较操作、容器类操作、可调用对象、Picking序列化。

比较操作

__cmp__

在比较2个对象时，我们可以定义__cmp__方法，来达到比较的操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

class Person(object):
	def __init__(self, uid):
        self.uid = uid
    def __cmp__(self, other):
        if self.uid == other.uid:
            return 0
        if self.uid > other.uid:
            return 1
        return -1
p1 = Person(1)
p2 = Person(2)
print p1 > p2	# False
print p1 < p2	# True
print p1 == p2	# False

• self > other，则返回大于0的整数，一般为1
• self < other，返回小于0的整数，一般为-1
• self == other，返回0

当然，这种比较有局限性，如果我有N个属性，比较最大时，我想用第一个属性比较，比较最小时，我想用第二个属性比较，此时__cmp__就不合适了，它只能用于通用的比较逻辑。如何进行不同的比较逻辑，我们可以使用如下方式：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

class Person(object):
    def __init__(self, uid, name, salary):
        self.uid = uid
        self.name = name
        self.salary = salary
    def __eq__(self, other):
        """对象==判断"""
        return self.uid == other.uid
    def __ne__(self, other):
        """对象!=判断"""
        return self.uid != other.uid
    def __lt__(self, other):
        """对象<判断,根据len(name)"""
        return len(self.name) < len(other.name)
    def __gt__(self, other):
        """对象>判断,根据alary"""
        return self.salary > other.salary
p1 = Person(1, 'zhangsan', 1000)
p2 = Person(1, 'lisi', 2000)
p3 = Person(1, 'wangwu', 3000)
print p1 == p1	# uid是否相同
print p1 != p2	# uid是否不同
print p2 < p3	# name长度比较
print p3 > p2	# salary大小

__eq__

在判断两个对象是否相等==时，此方法被调用。同时在上一篇文章中也介绍到，如果需要在set、dict中实现去重，可配合__hash__方法使用。

__ne__

在判断两个对象是否不相等!=时，此方法被调用。

__lt__

在判断一个对象是否小于<另一个对象时，此方法被调用。

__gt__

在判断一个对象是否大于>另一个对象时，此方法被调用。

在Python3中，__cmp__被取消了，因为和其他魔法方法有功能上的重复。

版权声明：本文为博主原创文章，未经博主允许不得转载。

想必只要是做Python开发的同学，都会或多或少见到以双下划线开头的方法，这些就是我们经常说的“魔法”方法。它可以对你的类添加特殊的功能，使用恰当会给我们的开发带来很大的便利。

这篇文章主要是总结了在我们开发中，经常遇到的那些“魔法”方法，如何使用以及它们的使用场景。

概览

目前我们常见的魔法方法大致可分为以下几类：

• 构造与初始化
• 类的表示
• 访问控制
• 比较操作
• 容器类操作
• 可调用对象
• Pickling序列化

我们这次主要介绍这几类常用魔法方法。

构造与初始化

__init__

构造方法是我们使用频率最高的魔法方法了，几乎在我们定义类的时候，都会去定义构造方法，它的主要作用就是在初始化一个对象时，定义这个对象的初始值。

1
2
3
4
5
6
7
8
9
10

# coding: utf8
class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
p1 = Person('张三', 25)
p2 = Person('李四', 30)

__new__

这个方法我们一般很少定义，不过我们在一些开源框架中偶尔会遇到定义这个方法的类。实际上，这才是“真正的构造方法”，它会在对象实例化时第一个被调用，然后再调用__init__，它们的区别主要如下：

• __new__的第一个参数是cls，而__init__的第一个参数是self
• __new__返回值是一个实例，而__init__没有任何返回值，只做初始化操作
• __new__由于是返回一个实例对象，所以它可以给所有实例进行统一的初始化操作

由于__new__优先于__init__调用，且返回一个实例，所以我们可以利用这种特性，每次返回同一个实例来实现一个单例类：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

class Singleton(object):
    """单例"""
    _instance = None
    def __new__(cls, *args, **kwargs):
        if not cls._instance:
            cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs)
        return cls._instance
class MySingleton(Singleton):
    pass
a = MySingleton()
b = MySingleton()
assert a is b	# True

另外一种使用场景是当你需要继承内置类时，例如int、str、tuple，只能通过__new__来达到初始化数据的效果：

1
2
3
4
5
6
7
8
9

class g(float):
    """千克转克"""
    def __new__(cls, kg):
        return float.__new__(cls, kg * 2)
# 50千克转为克
a = g(50)
print a 	# 100
print a + 100	# 200, 由于继承了float，所以可以直接运算，非常方便！

除此之外，__new__比较多的应用场景是配合元类使用，具体会在以后的文章中讲解到。