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

信息的二进制编码

在计算机内部，所有信息都是采用二进制进行编码和计算的，有没有想过，为什么采用这种方式？

其原因在于二进制只有两种状态，制造一个只有两个稳定状态的物理器件要比多个稳定状态的物理期间容易得多，使用高、低电位或脉冲有、无表示都很方便，能够很可靠的表示“0”和“1”。

如果都采用二进制计算，那么我们平时使用的数字、符号甚至图片和视频，都应该通过某种方式转换成二进制，
才能得以让计算机运算。这种转换方式称为“编码”。

我们人类角度看到的数据到计算机内部的数据转换如下：

这篇文章，我们先来分析数值型数据的进制与转换规则。

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

如果你想对计算机的组成和系统结构有个系统的了解，推荐你看一本书，叫做《深入理解计算机系统》。这本书也是计算机界的经典书籍，如果能吃透这本书里的内容，你会对计算机系统和软件开发有一个全新的认识。

由于这本书不太容易学习，有很多程序员买了这本书，但可能读了一两个章节发现太过枯燥理解不了，便放下珍藏了。

我和你一样，每次拿起这本书都刻意让自己学下去，但都败下阵来。

后来在知乎发现有人指导如何阅读这本书时，有网友推荐了国人写的教材，与《深入理解计算机系统》内容非常类似，但更易读。

这本书的作者叫袁春风，她是南京大学计算机系的教授，写过2本书《计算机组成与系统结构》（2010年出版)、《计算机系统基础》(2014年出版)，两者内容差不多，第二本更像是第一本的升级版。

在阅读这2本书时，发现还是比较容易理解的，这个系列整理出了相关知识点，加深记忆以备忘。

计算机的功能和特性

我们现在使用计算机能做的事情非常多，能够看网页、听音乐、看视频、社交聊天，这背后其实都是对信息的处理。

计算机背后是如何工作的呢？我们先来看计算机的一个简单定义：

计算机是一种能自动化对数字信息进行运算和逻辑处理的高速处理装置，计算机处理的对象都是数字化信息。

计算机的基本功能包括以下3个方面：

• 数据处理：计算机最基本的功能，可以计算加减乘除等运算，也可以处理文字、数字、音乐、视频信息。
• 数据存储：计算机能够自动工作的最基本保证，数据和程序事先被存储好，在需要时被取出自动执行。
• 数据传送：计算机内部各功能部件之间的数据传输，以达到信息交换，计算机外部连接使得信息得以传输到另一台计算机，从而构建出了计算机网络。

有了这些基本功能，计算机中肯定需要有对数据处理、数据存储、数据传送相对应的功能部件，它们分别是：算术逻辑运算器、存储器、总线和IO接口。

计算机主要的核心部件都采用高速电子元器件制造，处理速度极快，这就为运算速度提供了基础保证。

计算机可以处理各种信息，应用也极其广泛，只要现实世界中某个问题能找到相应的算法，就能编写成程序通过计算机执行算出结果，这为计算机的准确性和智能化提供了重要的基础。

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

只要你是做软件开发的，就肯定听说过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

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

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