python中字符串实现原理_Python原理与实现：字符串子串

a='dddddddddd'

a=a[1:6]

0 LOAD_CONST 0 ('dddddddddd')

2 STORE_NAME 0 (a)

4 LOAD_NAME 0 (a)

6 LOAD_CONST 1 (1)

8 LOAD_CONST 2 (6)

10 BUILD_SLICE 2

12 BINARY_SUBSCR

14 STORE_NAME 0 (a)

16 LOAD_CONST 3 (None)

18 RETURN_VALUE

【BUILD_SLICE】

PyObject *start, *stop, *step, *slice;

if (oparg == 3)

step = POP();

else

step = NULL;

stop = POP();

start = TOP();

slice = PySlice_New(start, stop, step);

Py_DECREF(start);

Py_DECREF(stop);

Py_XDECREF(step);

SET_TOP(slice);

if (slice == NULL)

goto error;

DISPATCH();

【BINARY_SUBSCR】

PyObject *sub = POP();

PyObject *container = TOP();

PyObject *res = PyObject_GetItem(container, sub);

Py_DECREF(container);

Py_DECREF(sub);

SET_TOP(res);

if (res == NULL)

goto error;

DISPATCH();

//有删减

PyObject *

PyObject_GetItem(PyObject *o, PyObject *key)

{

PyMappingMethods *m;

PySequenceMethods *ms;

//字符串用此方式

//mapping.mp_subscript

m = Py_TYPE(o)->tp_as_mapping;

if (m && m->mp_subscript) {

PyObject *item = m->mp_subscript(o, key);//调用函数->unicode_subscript

assert((item != NULL) ^ (PyErr_Occurred() != NULL));

return item;

}

//sequence.sq_item

ms = Py_TYPE(o)->tp_as_sequence;

if (ms && ms->sq_item) {

'''

}

if (PyType_Check(o)) {

'''

}

return type_error("'%.200s' object is not subscriptable", o);

}

//有删减

static PyObject*

unicode_subscript(PyObject* self, PyObject* item)

{

//单个索引

if (PyIndex_Check(item)) {

Py_ssize_t i = PyNumber_AsSsize_t(item, PyExc_IndexError);

if (i == -1 && PyErr_Occurred())

return NULL;

if (i < 0)

i += PyUnicode_GET_LENGTH(self);

return unicode_getitem(self, i);

//Slice类型

}else if (PySlice_Check(item)) {

Py_ssize_t start, stop, step, slicelength, i;

size_t cur;

PyObject *result;

void *src_data, *dest_data;

int src_kind, dest_kind;

Py_UCS4 ch, max_char, kind_limit;

//获取对应值

if (PySlice_Unpack(item, &start, &stop, &step) < 0) {

return NULL;

}

slicelength = PySlice_AdjustIndices(PyUnicode_GET_LENGTH(self),

&start, &stop, step);

//空串情况

if (slicelength <= 0) {

_Py_RETURN_UNICODE_EMPTY();

//不操作情况

} else if (start == 0 && step == 1 &&

slicelength == PyUnicode_GET_LENGTH(self)) {

return unicode_result_unchanged(self);

//step为1情况

} else if (step == 1) {

return PyUnicode_Substring(self,

start, start + slicelength);

}

//通常情况

src_kind = PyUnicode_KIND(self);

src_data = PyUnicode_DATA(self);

if (!PyUnicode_IS_ASCII(self)) {

kind_limit = kind_maxchar_limit(src_kind);

max_char = 0;

for (cur = start, i = 0; i < slicelength; cur += step, i++) {

ch = PyUnicode_READ(src_kind, src_data, cur);

if (ch > max_char) {

max_char = ch;

if (max_char >= kind_limit)

break;

}

}

}

else

max_char = 127;

result = PyUnicode_New(slicelength, max_char);

if (result == NULL)

return NULL;

dest_kind = PyUnicode_KIND(result);

dest_data = PyUnicode_DATA(result);

for (cur = start, i = 0; i < slicelength; cur += step, i++) {

Py_UCS4 ch = PyUnicode_READ(src_kind, src_data, cur);

PyUnicode_WRITE(dest_kind, dest_data, i, ch);

}

assert(_PyUnicode_CheckConsistency(result, 1));

return result;

//其他类型

} else {

PyErr_SetString(PyExc_TypeError, "string indices must be integers");

return NULL;

}

}

//索引情况

//有删减

static PyObject *

unicode_getitem(PyObject *self, Py_ssize_t index)

{

void *data;

enum PyUnicode_Kind kind;

Py_UCS4 ch;

'''

kind = PyUnicode_KIND(self);//类型

data = PyUnicode_DATA(self);//buffer

ch = PyUnicode_READ(kind, data, index);

return unicode_char(ch);

}

#define PyUnicode_READ(kind, data, index) \

((Py_UCS4) \

((kind) == PyUnicode_1BYTE_KIND ? \

((const Py_UCS1 *)(data))[(index)] : \ //UCS1

((kind) == PyUnicode_2BYTE_KIND ? \

((const Py_UCS2 *)(data))[(index)] : \ //UCS2

((const Py_UCS4 *)(data))[(index)] \ //UCS4

) \

))

//step为1情况

//有删减

PyObject*

PyUnicode_Substring(PyObject *self, Py_ssize_t start, Py_ssize_t end)

{

unsigned char *data;

int kind;

Py_ssize_t length;

length = PyUnicode_GET_LENGTH(self);

end = Py_MIN(end, length);

//不操作

if (start == 0 && end == length)

return unicode_result_unchanged(self);

//非法范围

if (start < 0 || end < 0) {

PyErr_SetString(PyExc_IndexError, "string index out of range");

return NULL;

}

//非法范围

if (start >= length || end < start)

_Py_RETURN_UNICODE_EMPTY();

length = end - start;

//ascii处理

if (PyUnicode_IS_ASCII(self)) {

data = PyUnicode_1BYTE_DATA(self);

return _PyUnicode_FromASCII((char*)(data + start), length);

}

//其他编码处理

else {

kind = PyUnicode_KIND(self);

data = PyUnicode_1BYTE_DATA(self);

return PyUnicode_FromKindAndData(kind,

data + kind * start,

length);

}

}

//ascii类型处理

PyObject*

_PyUnicode_FromASCII(const char *buffer, Py_ssize_t size)

{

const unsigned char *s = (const unsigned char *)buffer;

PyObject *unicode;

//单个字符

if (size == 1) {

return get_latin1_char(s[0]);

}

//创建新对象拷贝

unicode = PyUnicode_New(size, 127);

if (!unicode)

return NULL;

memcpy(PyUnicode_1BYTE_DATA(unicode), s, size);

assert(_PyUnicode_CheckConsistency(unicode, 1));

return unicode;

}

//unicode类型的处理

PyObject*

PyUnicode_FromKindAndData(int kind, const void *buffer, Py_ssize_t size)

{

switch (kind) {

case PyUnicode_1BYTE_KIND:

return _PyUnicode_FromUCS1(buffer, size);

case PyUnicode_2BYTE_KIND:

return _PyUnicode_FromUCS2(buffer, size);

case PyUnicode_4BYTE_KIND:

return _PyUnicode_FromUCS4(buffer, size);

default:

PyErr_SetString(PyExc_SystemError, "invalid kind");

return NULL;

}

}

//US1

static PyObject*

_PyUnicode_FromUCS1(const Py_UCS1* u, Py_ssize_t size)

{

PyObject *res;

unsigned char max_char;

//空串

if (size == 0)

_Py_RETURN_UNICODE_EMPTY();

assert(size > 0);

//单个字符

if (size == 1)

return get_latin1_char(u[0]);

//编码最大值

max_char = ucs1lib_find_max_char(u, u + size);

res = PyUnicode_New(size, max_char);

#拷贝到新对象

memcpy(PyUnicode_1BYTE_DATA(res), u, size);

return res;

}

//US2

static PyObject*

_PyUnicode_FromUCS2(const Py_UCS2 *u, Py_ssize_t size)

{

PyObject *res;

Py_UCS2 max_char;

//空串

if (size == 0)

_Py_RETURN_UNICODE_EMPTY();

assert(size > 0);

//单个字符

if (size == 1)

return unicode_char(u[0]);

//编码最大值

max_char = ucs2lib_find_max_char(u, u + size);

res = PyUnicode_New(size, max_char);

//一般情况

if (max_char >= 256)

#拷贝到新对象

memcpy(PyUnicode_2BYTE_DATA(res), u, sizeof(Py_UCS2)*size);

//编码最大值过小转换编码

else {

_PyUnicode_CONVERT_BYTES(

Py_UCS2, Py_UCS1, u, u + size, PyUnicode_1BYTE_DATA(res));

}

return res;

}

//US4

static PyObject*

_PyUnicode_FromUCS4(const Py_UCS4 *u, Py_ssize_t size)

{

PyObject *res;

Py_UCS4 max_char;

//空串

if (size == 0)

_Py_RETURN_UNICODE_EMPTY();

//单个字符

if (size == 1)

return unicode_char(u[0]);

//编码最大值

max_char = ucs4lib_find_max_char(u, u + size);

res = PyUnicode_New(size, max_char);

//编码最大值过小转换编码

if (max_char < 256)

_PyUnicode_CONVERT_BYTES(Py_UCS4, Py_UCS1, u, u + size,

PyUnicode_1BYTE_DATA(res));

//编码最大值过小转换编码

else if (max_char < 0x10000)

_PyUnicode_CONVERT_BYTES(Py_UCS4, Py_UCS2, u, u + size,

PyUnicode_2BYTE_DATA(res));

//一般情况

else

#拷贝到新对象

memcpy(PyUnicode_4BYTE_DATA(res), u, sizeof(Py_UCS4)*size);

return res;

}