Python 源码剖析 - Small Python

时间：12-14来源：作者：点击数：

1. Small Python

在详细考察了 Python 中最常用的几个对象之后，我们现在完全可以利用这些对象做出一个最简单的 Python。这一章的目的就是模拟出一个最简单的Python——Small Python。

在 Small Python 中，我们首先需要实现之前已经分析过的那些对象，比如 PyIntObject，与 CPython 不同的是，我们并没有实现象CPython那样复杂的机制，作为一个模拟程序，我们只实现了简单的功能，也没有引入对象缓冲池的机制。这一切都是为了简洁而清晰地展示出Python运行时的脉络。

在 Small Python 中，实际上还需要实现 Python 的运行时环境，Python 的运行时环境是我们在以后的章节中将要剖析的重点。在这里只是展示了其核心的思想——利用 PyDictObject 对象来维护变量名到变量值的映射。

当然，在 CPython 中，还有许多其他的主题，比如Python源代码的编译，Python 字节码的生成和执行等等，在Small Python中，我们都不会涉及，因为到目前为止，我们没有任何资本做出如此逼真的模拟。不过当我们完成这本书的探索之后，就完全有能力实现一个真正的Python了。

在 Small Python 中，我们仅仅实现了 PyIntObject，PyStringObject 以及 PyDictObject 对象，仅仅实现了加法运算和输出操作。同时编译的过程也被简化到了极致，因此我们的 Small Python 只能处理非常受限的表达式。虽然很简陋，但从中可以看到 Python 的骨架，同时，这也是我们深入Python解释器和运行时的起点。

2. 对象机制

在 Small Python 中，对象机制与 CPython 完全相同：

[PyObject] 
#define PyObject_HEAD \ 
    int refCount;\ 
    struct tagPyTypeObject *type 
#define PyObject_HEAD_INIT(typePtr)\ 
    0, typePtr 
typedef struct tagPyObject{ 
    PyObject_HEAD; 
}PyObject;

但是对于类型对象，我们进行了大规模的删减。最终在类型对象中，只定义了加法操作，Hash 操作以及输出操作：

[PyTypeObject] 
//definition of PyTypeObject 
typedef void (*PrintFun)(PyObject* object); 
typedef PyObject* (*AddFun)(PyObject* left, PyObject* right); 
typedef long (*HashFun)(PyObject* object);
typedef struct tagPyTypeObject{ 
    PyObject_HEAD; 
    char* name; 
    PrintFun print; 
    AddFun add; 
    HashFun hash; 
}PyTypeObject;

PyIntObject 的实现与 CPython 几乎是一样的，不过没有复杂的对象缓冲机制：

[PyIntObject] 
typedef struct tagPyIntObject 
{ 
    PyObject_HEAD; 
    int value; 
}PyIntObject; 
PyObject* PyInt_Create(int value) 
{ 
    PyIntObject* object = new PyIntObject; 
    object->refCount = 1; 
    object->type = &PyInt_Type; 
    object->value = value; 
    return (PyObject*)object; 
} 
static void int_print(PyObject* object) 
{ 
    PyIntObject* intObject = (PyIntObject*)object; 
    printf("%d\n", intObject->value); 
} 
static PyObject* int_add(PyObject* left, PyObject* right) 
{ 
    PyIntObject* leftInt = (PyIntObject*)left; 
    PyIntObject* rightInt = (PyIntObject*)right; 
    PyIntObject* result = (PyIntObject*)PyInt_Create(0); 
    if(result == NULL) 
    { 
        printf("We have no enough memory!!"); 
    } 
    else 
    { 
        result->value = leftInt->value + rightInt->value; 
    } 
    return (PyObject*)result; 
} 
static long int_hash(PyObject* object) 
{ 
    return (long)((PyIntObject*)object)->value; 
} 
PyTypeObject PyInt_Type = 
{ 
    PyObject_HEAD_INIT(&PyType_Type), 
    "int", 
    int_print, 
    int_add, 
    int_hash 
};

Small Python 中的 PyStringObject 与 CPython 中大不相同，在 CPython 中，它是一个变长对象，而 Small Python 中只是一个简单的定长对象，因为 Small Python 的定位就是个演示的程序：

[PyStrObject] 
typedef struct tagPyStrObject 
{ 
    PyObject_HEAD; 
    int length; 
    long hashValue; 
    char value[50]; 
}PyStringObject; 
PyObject* PyStr_Create(const char* value) 
{ 
    PyStringObject* object = new PyStringObject; 
    object->refCount = 1; 
    object->type = &PyString_Type; 
    object->length = (value == NULL) ? 0 : strlen(value); 
    object->hashValue = -1; 
    memset(object->value, 0, 50); 
    if(value != NULL) 
    { 
        strcpy(object->value, value); 
    } 
    return (PyObject*)object; 
} 
static void string_print(PyObject* object) 
{ 
    PyStringObject* strObject = (PyStringObject*)object; 
    printf("%s\n", strObject->value); 
} 
static long string_hash(PyObject* object) 
{ 
    PyStringObject* strObject = (PyStringObject*)object; 
    register int len; 
    register unsigned char *p; 
    register long x; 
    if (strObject->hashValue != -1) 
        return strObject->hashValue; 
    len = strObject->length; 
    p = (unsigned char *)strObject->value; 
    x = *p << 7; 
    while (--len >= 0) 
        x = (1000003*x) ^ *p++; 
    x ^= strObject->length; 
    if (x == -1) 
        x = -2; 
    strObject->hashValue = x; 
    return x; 
} 
static PyObject* string_add(PyObject* left, PyObject* right) 
{ 
    PyStringObject* leftStr = (PyStringObject*)left; 
    PyStringObject* rightStr = (PyStringObject*)right; 
    PyStringObject* result = (PyStringObject*)PyStr_Create(NULL); 
    if(result == NULL) 
    { 
        printf("We have no enough memory!!"); 
    } 
    else 
    { 
        strcpy(result->value, leftStr->value); 
        strcat(result->value, rightStr->value); 
    } 
    return (PyObject*)result; 
} 
PyTypeObject PyString_Type = 
{ 
    PyObject_HEAD_INIT(&PyType_Type), 
        "str", 
        string_print, 
        string_add, 
        string_hash 
};

在 Python 的解释器工作时，还有一个非常重要的对象，PyDictObject 对象。PyDictObject 对象在 Python 运行时会维护（变量名，变量值）的映射关系，Python 所有的动作都是基于这种映射关系。在 Small Python 中，我们基于 C++ 中的 map 来实现 PyDictObject 对象。当然，map 的运行效率比 CPython 中所采用的 hash 技术会慢上一些，但是对于我们的 Small Python，map 就足够了：

[PyDictObject] 
typedef struct tagPyDictObject 
{ 
    PyObject_HEAD; 
    map<long, PyObject*> dict; 
}PyDictObject; 
PyObject* PyDict_Create() 
{ 
    //create object 
    PyDictObject* object = new PyDictObject; 
    object->refCount = 1; 
    object->type = &PyDict_Type; 
    return (PyObject*)object; 
} 
PyObject* PyDict_GetItem(PyObject* target, PyObject* key) 
{ 
    long keyHashValue = (key->type)->hash(key); 
    map<long, PyObject*>& dict = ((PyDictObject*)target)->dict; 
    map<long, PyObject*>::iterator it = dict.find(keyHashValue); 
    map<long, PyObject*>::iterator end = dict.end(); 
    if(it == end) 
    { 
        return NULL; 
    } 
    return it->second; 
} 
int PyDict_SetItem(PyObject* target, PyObject* key, PyObject* value) 
{ 
    long keyHashValue = (key->type)->hash(key); 
    PyDictObject* dictObject = (PyDictObject*)target; 
    (dictObject->dict)[keyHashValue] = value; 
    return 0; 
} 
// function for PyDict_Type 
static void dict_print(PyObject* object) 
{ 
    PyDictObject* dictObject = (PyDictObject*)object; 
    printf("{"); 
    map<long, PyObject*>::iterator it = (dictObject->dict).begin(); 
    map<long, PyObject*>::iterator end = (dictObject->dict).end(); 
    for( ; it != end; ++it) 
    { 
        //print key 
        printf("%d : ", it->first); 
        //print value 
        PyObject* value = it->second; 
        (value->type)->print(value); 
        printf(", "); 
    } 
    printf("}\n"); 
} 
PyTypeObject PyDict_Type = 
{ 
    PyObject_HEAD_INIT(&PyType_Type), 
        "dict", 
        dict_print, 
        0, 
        0 
};

Small Python 中的对象机制的所有内容都在上边列出了，非常简单，对吧，这就对了，要的就是这个简单。

3. 解释过程

说 Small Python 中没有编译，对的，它根本就不会进行任何常规的编译动作，没有 token 解析，没有抽象语法树的建立。但说 Small Python 中有那么一点点编译的味道，其实也不错，我们叫这种动作为解释。无论如何，它至少要解析输入的语句，以判断这条语句到底是要干什么，它是要上山打虎呢，还是要下河摸鱼呢，如果连这最基本的都做不到，Small Python 还不如回家卖红薯得了。

然而 Small Python 中的这种解释动作还是被简化到了极致，它实际上就是简单的字符串查找加 if…else… 结构：

void ExcuteCommand(string& command)
{ 
  string::size_type pos = 0; 
  if((pos = command.find("print ")) != string::npos) 
  { 
      ExcutePrint(command.substr(6)); 
  } 
  else if((pos = command.find(" = ")) != string::npos) 
  { 
      string target = command.substr(0, pos); 
      string source = command.substr(pos+3); 
      ExcuteAdd(target, source); 
  } 
} 
void ExcuteAdd(string& target, string& source)
{ 
  string::size_type pos; 
  if(IsSourceAllDigit(source)) 
  { 
      PyObject* intValue = PyInt_Create(atoi(source.c_str())); 
      PyObject* key = PyStr_Create(target.c_str()); 
      PyDict_SetItem(m_LocalEnvironment, key, intValue); 
  } 
  else if(source.find("\"") != string::npos) 
  { 
      PyObject* strValue = PyStr_Create(source.substr(1, source.size()-2).c_str()); 
      PyObject* key = PyStr_Create(target.c_str()); 
      PyDict_SetItem(m_LocalEnvironment, key, strValue); 
  } 
  else if((pos = source.find("+")) != string::npos) 
  { 
      PyObject* leftObject = GetObjectBySymbol(source.substr(0, pos)); 
      PyObject* rightObject = GetObjectBySymbol(source.substr(pos+1)); 
      if(leftObject != NULL && right != NULL && leftObject->type == rightObject->type) 
      { 
          PyObject* resultValue = (leftObject->type)->add(leftObject, rightObject); 
                PyObject* key = PyStr_Create(target.c_str()); 
          PyDict_SetItem(m_LocalEnvironment, key, resultValue); 
      } 
      (m_LocalEnvironment->type)->print(m_LocalEnvironment); 
  } 
}

通过字符串搜索，如果命令中出现 =，就是一个赋值或加法过程；如果命令中出现 print，就是一个输出过程。进一步，在 ExcuteAdd 中，又进一步进行字符串搜索，以确定是否需要有一个额外的加法过程。根据这些解析的结果进行不同的动作，就是 Small Python 中的解释过程。这个过程在 CPython 中是通过正常的编译过程来实现的，而且最后会得到字节码的编译结果。

在这里需要重点指出的是那个 m_LocalEnvironment，这是一个 PyDictObject 对象，其中维护着 Small Python 运行过程中，动态创建的变量的变量名和变量值的映射。这个就是 Small Python 中的执行环境，Small Python 正是靠它来维护运行过程中的所有变量的状态。在 CPython中，运行环境实际上也是这样一个机制。当需要访问变量时，就从这个 PyDictObject 对象中查找变量的值。这一点在执行输出操作时可以看得很清楚：

PyObject* GetObjectBySymbol(string& symbol)
{ 
    PyObject* key = PyStr_Create(symbol.c_str()); 
    PyObject* value = PyDict_GetItem(m_LocalEnvironment, key); 
    if(value == NULL) 
    { 
        cout << "[Error] : " << symbol << " is not defined!!" << endl; 
        return NULL; 
    } 
    return value; 
} 
void ExcutePrint(string symbol) 
{ 
    PyObject* object = GetObjectFromSymbol(symbol); 
    if(object != NULL) 
    { 
        PyTypeObject* type = object->type; 
        type->print(object); 
    } 
}

在这里，通过变量名 symbol，获得了变量值 object。而在刚才的 ExcueteAdd 中，我们将变量名和变量值建立了联系，并存放到 m_LocalEnvironment 中。这种一进一出的机制正是 CPython 执行时的关键，在以后对 Python 字节码解释器的详细剖析中，我们将真实而具体地看到这种机制。

4. 交互式环境

好了，我们的 Small Python 几乎已经完成了，最后所缺的就是一个交互式环境：

char* info = "********** Python Research **********\n"; 
char* prompt = ">>> "; 
void Excute() 
{ 
    cout << info; 
    cout << prompt; 
    while(getline(cin, m_Command){ 
        if(m_Command.size() == 0){ 
            cout << prompt; 
            continue; 
        } 
        else if(m_Command == "exit"){ 
            return; 
        } 
        else{ 
            ExcuteCommand(m_Command); 
        } 
        cout << prompt; 
    } 
}

有了它，我们的 Small Python 就大功告成了。现在，来看一看我们的成果吧：

到这里，我们就结束了对 Python 中对象的探索，通过 Small Python 这一个简陋的承前启后的东西，我们将敲开 Python 运行时的大门，那里是字节码，解释器，条件判断语句，函数，类，异常等等的神秘世界，提起精神，我们出发了…

考了这些证书的可享个	怎样用 PS 把电子文档
记录在本地电脑部署自	围棋入门教程十天即