本章主要讲讲我对Python中string的实现的认识。PyStringObject的定义如下：
typedef struct {
PyObject_VAR_HEAD
long ob_shash;
int ob_sstate;
char ob_sval[1];
} PyStringObject;
可以看到，PyStringObject的头部是PyObject_VAR_HEAD,说明PyStringObject实际上是一个变长对象，而要注意的是，Python中的string是一个不可变对象。这是不是与前面的变长有点矛盾？其实不矛盾，前面的变长对象指的是string在创建的时候长度不一定，“p"长度为1，”Python“长度为6，长度值存在于PyObject_VAR_Head里面的ob_size里面。而后面的不可变指的是一旦Python的string对象创建出来之后，它在内存中就是不可变的了。所以如果对string进行”+“操作，得到的结果其实是一个新的string
对象。
ob_shash其实是这个string的哈希值，这样可以避免每次都计算这个string的哈希值。如果还没计算过的话，默认值为-1.
ob_sstate表示的是该string 有没有被intern机制处理过（接下来马上就讲intern机制）
ob_sval看似数组，但其实只有一个元素，指向我们保存的字符串数组的头部。
好，接下来将Python string中的intern机制。
首先来看如合创建PyStringObject对象：
PyObject * PyString_FromString(const char *str)
{
register size_t size;
register PyStringObject *op;
/* 省略了不少中间代码*/
op = (PyStringObject *)PyObject_MALLOC(PyStringObject_SIZE + size);
if (op == NULL)
return PyErr_NoMemory();
PyObject_INIT_VAR(op, &PyString_Type, size);
op->ob_shash = -1;
op->ob_sstate = SSTATE_NOT_INTERNED;
Py_MEMCPY(op->ob_sval, str, size+1);
/* share short strings */
if (size == 0) {
/* 省略了不少中间代码*/
} else if (size == 1) {
/* 省略了不少中间代码*/
}
return (PyObject *) op;
}
如果我们写上以下代码：
a = "python"
b = "python"
c = "Python"
那根据这个创建代码Python是肯定要创建三个PyStringObject了，再多几个，岂不是会很浪费内存？聪明的Python肯定不会这么做。于是就有了Intern机制
Intern机制的目的在于，在Python运行系统中，不论用户创建了多少像上面的a,b,c，只有一个”Python“对象，其他的都是指向这个对象，大家共用这个对象。也就是说，当a创建的时候，Python会对a进行Intern机制处理，然后当b创建的时候，b指向一个PyStringObject temp,通过intern机制发现已经有b与a的对象存储的字符串其实一样，那么就会把b指向a指向的那个对象，这样用来创建b的那个临时对象temp会因为b指向其他对象而进行de_allocate而销毁，这样就不会浪费内存了。
上面代码中的size==0括号的内容其实也就是对nullstring的一种intern机制处理，令所有创建的Null string都指向同一个对象。
下面是intern机制的代码：
static PyObject *interned;
void PyString_InternInPlace(PyObject **p)
{
register PyStringObject *s = (PyStringObject *)(*p);
PyObject *t;
if (s == NULL || !PyString_Check(s))
Py_FatalError("PyString_InternInPlace: strings only please!");
/* If it's a string subclass, we don't really know what putting
it in the interned dict might do. */
if (!PyString_CheckExact(s))
return;
if (PyString_CHECK_INTERNED(s))
return;
if (interned == NULL) {
interned = PyDict_New();
if (interned == NULL) {
PyErr_Clear(); /* Don't leave an exception */
return;
}
}
t = PyDict_GetItem(interned, (PyObject *)s);
if (t) {
Py_INCREF(t);
Py_DECREF(*p);
*p = t;
return;
}
if (PyDict_SetItem(interned, (PyObject *)s, (PyObject *)s) < 0) {
PyErr_Clear();
return;
}
/* The two references in interned are not counted by refcnt.
The string deallocator will take care of this */
Py_REFCNT(s) -= 2;
PyString_CHECK_INTERNED(s) = SSTATE_INTERNED_MORTAL;
}
其中重要的我已经粗体字表明了，interned的定义是一个PyObject,但从下面的代码可以看出，在interned=nul的时候，interned = PyDict_New();所以它实际上是一个PyDictObject，我们可以暂时理解为c++里面的map对象。对一个PyStringObject对象进行intern机制处理的时候，会通过PyDict_GetItem去从Interned对象中查找有没有一样的已经创建的对象，有的话就直接拿来用，没有的话就说明这种对象是第一次创建，用PyDict_SetItem函数把相应的信息存到interned里面，下次再创建一样的就能从中找到了。
之前在讲PyIntObject的时候有提到过对象池，那么对于PyStringObject，又怎么可能没有呢？对于int，是比较小的整数会一直存在于内存中，那么对于string,为会长度为1的字符创建对象池。
static PyStringObject *characters[UCHAR_MAX + 1];
下面补全上面部分省略的代码：
if (size == 1 && str != NULL) {
PyObject *t = (PyObject *)op;
PyString_InternInPlace(&t);
op = (PyStringObject *)t;
characters[*str & UCHAR_MAX] = op;
Py_INCREF(op);
}
这样，每当创建长度为1的字符串的时候，都会把它存到characters里面，这样之后创建长度为1的字符时，如果检测到已经在characters里面了，就直接返回这个缓冲的对象(如下面代码所示)，不用进行malloc,这也就是该缓冲池的作用
if (size == 1 && str != NULL &&
(op = characters[*str & UCHAR_MAX]) != NULL)
{
#ifdef COUNT_ALLOCS
one_strings++;
#endif
Py_INCREF(op);
return (PyObject *)op;
}
好了，觉得PyStringObject重要的一些就在上面了。：）