标签：blog http 使用 os io 数据 for ar
python 中常用的内置对象有：整数对象，字符串对象，列表对象，字典对象。这些对象在python中使用最多，所以在实现上提供缓存机制，以提高运行效率。
python 中的整数对象是不可变对象(immutable)，即创建了一个 python 整数对象之后，不能再改变该对象的值。
python 为创建整数对象提供了下面三种方法，其中 PyInt_FromString 和 PyInt_FromUnicode 内部也是调用 PyInt_FromLong 创建的整数对象。
PyObject * PyInt_FromLong(long ival); PyObject * PyInt_FromString(char *s, char **pend, int base); PyObject * PyInt_FromUnicode(Py_UNICODE *s, Py_ssize_t length, int base);
下面主要看下 PyInt_FromLong内部的实现
PyObject *PyInt_FromLong(long ival)
{
register PyIntObject *v;
#if NSMALLNEGINTS + NSMALLPOSINTS > 0
// NSMALLNEGINTS = 5，NSMALLPOSINTS = 257
// 如果创建的整数对象值在[-5,256] 则从 small_ints 缓存池中直接返回整数对象
if (-NSMALLNEGINTS <= ival && ival < NSMALLPOSINTS) {
v = small_ints[ival + NSMALLNEGINTS];
Py_INCREF(v);
#ifdef COUNT_ALLOCS
if (ival >= 0)
quick_int_allocs++;
else
quick_neg_int_allocs++;
#endif
return (PyObject *) v;
}
#endif
// 创建 free_list 缓存列表，提供创建不在 small_ints 缓存池内的对象
if (free_list == NULL) {
if ((free_list = fill_free_list()) == NULL)
return NULL;
}
// 从 free_list 中获取新对象
v = free_list;
free_list = (PyIntObject *)Py_TYPE(v);
// 初始化并返回新的整数对象
PyObject_INIT(v, &PyInt_Type);
v->ob_ival = ival;
return (PyObject *) v;
}
整数对象销毁的操作，仅仅记录释放的内存到 free_list 中
static void
int_dealloc(PyIntObject *v)
{
if (PyInt_CheckExact(v)) {
Py_TYPE(v) = (struct _typeobject *)free_list;
free_list = v;
}
else
Py_TYPE(v)->tp_free((PyObject *)v);
}
free_list 与 PyIntBlock 一起管理小整数范围以外的整数对象缓存
struct _intblock {
struct _intblock *next;
PyIntObject objects[N_INTOBJECTS];
};
typedef struct _intblock PyIntBlock;
static PyIntBlock *block_list = NULL;
static PyIntObject *free_list = NULL;
small_ints 是小整数对象的缓存池，范围是 [-5,256]，可以快速的提供缓存中的对象，仅仅增加对象的引用计数就可以。
free_list 和 block_list 保存创建过的整数对象分配的内存，在创建新的整数对象时，直接从free_list获取对象的内存空间，初始化对象后就可以使用。
python 的整数对象在释放的时候，整数对象占用的内存将继续保存在 block_list 中，并且在 free_list 中记录，将来提供给新创建的整数对象使用。（就是创建整数后分配的内存不会归还给操作系统，所以尽量降低同一时刻分配的整数数量，这样可以降低内存消耗）
python 的字符串对象是变长对象，同时也是不可变对象，字符串不可以修改。
python 内部创建字符串对象的两种方法，PyString_FromStringAndSize 指定了长度。
PyObject * PyString_FromString(const char *str); PyObject * PyString_FromStringAndSize(const char *str, Py_ssize_t size);
看下 PyString_FromString 内部的实现
PyObject *PyString_FromString(const char *str)
{
register size_t size;
register PyStringObject *op;
assert(str != NULL);
size = strlen(str);
if (size > PY_SSIZE_T_MAX - PyStringObject_SIZE) {
PyErr_SetString(PyExc_OverflowError,
"string is too long for a Python string");
return NULL;
}
// 判断，单字符可以从缓冲中直接返回
if (size == 0 && (op = nullstring) != NULL) {
#ifdef COUNT_ALLOCS
null_strings++;
#endif
Py_INCREF(op);
return (PyObject *)op;
}
if (size == 1 && (op = characters[*str & UCHAR_MAX]) != NULL) {
#ifdef COUNT_ALLOCS
one_strings++;
#endif
Py_INCREF(op);
return (PyObject *)op;
}
/* Inline PyObject_NewVar */
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);
/* 创建单字符的缓冲 */
if (size == 0) {
PyObject *t = (PyObject *)op;
PyString_InternInPlace(&t);
op = (PyStringObject *)t;
nullstring = op;
Py_INCREF(op);
} else if (size == 1) {
PyObject *t = (PyObject *)op;
PyString_InternInPlace(&t);
op = (PyStringObject *)t;
characters[*str & UCHAR_MAX] = op;
Py_INCREF(op);
}
return (PyObject *) op;
}
字符缓冲池，这个缓冲池会在第一次创建单字符对象的时候填充，如上面 PyString_FromString 函数内。
#define UCHAR_MAX 0xff static PyStringObject *characters[UCHAR_MAX + 1];
性能相关的 ‘+‘ 操作和 join 操作。每次 ‘+‘ 操作都需要新创建对象，性能较差。join 先计算结果对象的总长度，创建一个结果字符串对象，然后拷贝数据到结果内存位置，所以性能较好。
static PyObject *string_concat(register PyStringObject *a, register PyObject *bb)
{
// ...
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, a->ob_sval, Py_SIZE(a));
Py_MEMCPY(op->ob_sval + Py_SIZE(a), b->ob_sval, Py_SIZE(b));
op->ob_sval[size] = ‘\0‘;
return (PyObject *) op;
}
static PyObject *string_join(PyStringObject *self, PyObject *orig)
{
// ...
// 计算拼接后字符串总长度
for (i = 0; i < seqlen; i++) {
const size_t old_sz = sz;
item = PySequence_Fast_GET_ITEM(seq, i);
if (!PyString_Check(item)){
#ifdef Py_USING_UNICODE
if (PyUnicode_Check(item)) {
/* Defer to Unicode join. * CAUTION: There‘s no gurantee that the * original sequence can be iterated over * again, so we must pass seq here. */
PyObject *result;
result = PyUnicode_Join((PyObject *)self, seq);
Py_DECREF(seq);
return result;
}#endif
PyErr_Format(PyExc_TypeError,
"sequence item %zd: expected string,"
" %.80s found",
i, Py_TYPE(item)->tp_name);
Py_DECREF(seq);
return NULL;
}
sz += PyString_GET_SIZE(item);
if (i != 0)
sz += seplen;
if (sz < old_sz || sz > PY_SSIZE_T_MAX) {
PyErr_SetString(PyExc_OverflowError,
"join() result is too long for a Python string");
Py_DECREF(seq);
return NULL;
}
}
// 为拼接后字符串分配空间
res = PyString_FromStringAndSize((char*)NULL, sz);
if (res == NULL) {
Py_DECREF(seq);
return NULL;
}
// 拷贝拼接字符串到新创建的字符串的内存位置
p = PyString_AS_STRING(res);
for (i = 0; i < seqlen; ++i) {
size_t n;
item = PySequence_Fast_GET_ITEM(seq, i);
n = PyString_GET_SIZE(item);
Py_MEMCPY(p, PyString_AS_STRING(item), n);
p += n;
if (i < seqlen - 1) {
Py_MEMCPY(p, sep, seplen);
p += seplen;
}
}
Py_DECREF(seq);
return res;}
字符串对象实现了单字符的缓冲区，创建单字符的对象时直接从缓冲区中获取对象。
多字符串对象的拼接使用 join 性能好于 ‘+‘。
原文链接: zg手册 之 python2.7.7源码分析（2）-- python 的整数对象和字符串对象
zg手册 之 python2.7.7源码分析（2）-- python 的整数对象和字符串对象,布布扣,bubuko.com
zg手册 之 python2.7.7源码分析（2）-- python 的整数对象和字符串对象
标签：blog http 使用 os io 数据 for ar
原文地址：http://my.oschina.net/hopez/blog/299378
