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

只要你是做软件开发的，就肯定听说过ASCII、Unicode、UTF-8、GBK这些字符编码，而且字符编码时刻与我们开发相关联。

它们之间到底有什么区别？为什么会有这么多字符编码？这篇文章我们来看一下它们之间的的关系以及区别。

概念

在开始之前，作为程序员，我希望大家能够先理清楚两个概念：字符集、字符编码。

很多人搞不清楚这两者的关系与区别，以至于对于字符编码方面的知识了解不深，甚至混乱。

字符集

平时我们生活中使用的文字、标点符号、图形符号、数字，这些可以统称为字符。

由非常多个字符组合后产生的集合，这个集合称为字符集。

也就是说，我们可以人为的根据某个规则归纳一些我们使用的文字、符号，这些文字、符号的集合就称为一个字符集，并且可以根据不同的规则划分不同的字符集。

字符编码

那字符编码是什么？

我们知道计算机内部使用的是二进制运算，如果要想让计算机识别我们人类的文字、符号、数字，就需要一个转换规则，把我们人类使用的这些字符转换成计算机认识的二进制，也就是0和1。

这个转换的规则就称为字符编码。

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

yield关键字在Python中开发中使用较为频繁，它为我们某些开发场景提供了便利，这篇文章我们来深入讲解yield相关知识。

生成器

在讲yield之前，我们先复习一下迭代器与生成器的区别，可以参考我之前写的文章：Python技术进阶——迭代器、可迭代对象、生成器。

简单总结如下：

• 实现了迭代器协议__iter__和next/__next__方法的对象被称作迭代器
• 迭代器可以使用for执行输出每个元素
• 生成器是一种特殊的迭代器

一个函数内，如果包含了yield关键字，这个函数就是一个生成器。

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

# coding: utf8
def gen(n):
    # 生成器函数
    for i in range(n):
        yield i
g = gen(5)      # 创建一个生成器
print g         # <generator object gen at 0x10bb46f50>
print type(g)   # <type 'generator'>
# 生成器迭代
for i in g:
    print i
    
# Output:
# 0 1 2 3 4

注意，在执行g = gen(5)时，函数中的代码并没有执行，此时我们只是创建了一个生成器对象，他的类型是generator。

当执行for i in g时，每执行一次循环，直到执行到yield时，返回yield后面的值。

换句话说，我们想输出5个元素，在创建生成器时，这个5个元素此时并没有产生，什么时候产生呢？在执行for循环遇到yield时，此时才会逐个生成每个元素。

生成器除了实现迭代器协议可以进行迭代之外，还包含一些方法：

• generator.next()：每次执行到遇到yield后返回，直到没有yield，抛出StopIterator异常
• generator.send(value)：将yield的值设置为value
• generator.throw(type[, value[, traceback]])：向生成器当前状态抛出一个异常
• generator.close()：关闭生成器

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

为了提高程序的运行效率，Python与其他语言一样，提供了多进程和多线程的开发方式，这篇文章我们来讲Python的多进程和多线程开发。

进程

Python提供了mutilprocessing模块，为多进程编程提供了友好的API，并且提供了多进程之间信息同步和通信的相关组件，如Queue、Event、Pool、Lock、Pipe、Semaphore、Condition等模块。

函数当做进程

Python中创建多进程的方式有2种：

• 函数当做进程
• 类当做进程

逻辑简单的任务一般使用函数当做进程，逻辑较多或代码结构复杂的建议使用类当做进程。

首先来看函数当做进程的例子：

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

# coding: utf8
import os
import time
import random
from multiprocessing import Process
def task(name):
    s = random.randint(1, 10)
    print 'pid: %s, name: %s, sleep %s ...' % (os.getpid(), name, s)
    time.sleep(s)
if __name__ == '__main__':
    # 创建5个子进程执行
    ps = []
    for i in range(5):
        p = Process(target=task, args=('p%s' % i, ))
        ps.append(p)
        p.start()
    
    # 主进程等待子进程结束
    for p in ps:
        p.join()
    
# Output:
# pid: 52361, name: p0, sleep 8 ...
# pid: 52362, name: p1, sleep 7 ...
# pid: 52363, name: p2, sleep 8 ...
# pid: 52364, name: p3, sleep 3 ...
# pid: 52365, name: p4, sleep 2 ...

使用p = Process(target=func, args=(arg1, arg2...))即可创建一个进程，调用p.start()启动一个进程，p.join()使得主进程等待子进程执行结束后才退出。

当这个程序执行时，你可以ps查看一下进程，会发现一共有6个进程在执行，其中包括1个主进程，5个子进程。

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

在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___的对象叫做非资料描述器

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