Python内建类型str源码分析

>>> sys.getsizeof('ab') - sys.getsizeof('a')1>>> sys.getsizeof('一二') - sys.getsizeof('一')2>>> sys.getsizeof('????????') - sys.getsizeof('????')4

enum PyUnicode_Kind {/* String contains only wstr byte characters.  This is only possible   when the string was created with a legacy API and _PyUnicode_Ready()   has not been called yet.  */    PyUnicode_WCHAR_KIND = 0,/* Return values of the PyUnicode_KIND() macro: */    PyUnicode_1BYTE_KIND = 1,    PyUnicode_2BYTE_KIND = 2,    PyUnicode_4BYTE_KIND = 4};

/* Py_UCS4 and Py_UCS2 are typedefs for the respective   unicode representations. */typedef uint32_t Py_UCS4;typedef uint16_t Py_UCS2;typedef uint8_t Py_UCS1;

typedef struct {    PyObject_HEAD    Py_ssize_t length;          /* Number of code points in the string */    Py_hash_t hash;             /* Hash value; -1 if not set */    struct {        unsigned int interned:2;        unsigned int kind:3;        unsigned int compact:1;        unsigned int ascii:1;        unsigned int ready:1;        unsigned int :24;    } state;    wchar_t *wstr;              /* wchar_t representation (null-terminated) */} PyASCIIObject;

/* Non-ASCII strings allocated through PyUnicode_New use the   PyCompactUnicodeObject structure. state.compact is set, and the data   immediately follow the structure. */typedef struct {    PyASCIIObject _base;    Py_ssize_t utf8_length;     /* Number of bytes in utf8, excluding the                                 * terminating . */    char *utf8;                 /* UTF-8 representation (null-terminated) */    Py_ssize_t wstr_length;     /* Number of code points in wstr, possible                                 * surrogates count as two code points. */} PyCompactUnicodeObject;

/* Strings allocated through PyUnicode_FromUnicode(NULL, len) use the   PyUnicodeObject structure. The actual string data is initially in the wstr   block, and copied into the data block using _PyUnicode_Ready. */typedef struct {    PyCompactUnicodeObject _base;    union {        void *any;        Py_UCS1 *latin1;        Py_UCS2 *ucs2;        Py_UCS4 *ucs4;    } data;                     /* Canonical, smallest-form Unicode buffer */} PyUnicodeObject;

>>> import sys>>> text = 'a' * 1000>>> sys.getsizeof(text)1049>>> text += '????'>>> sys.getsizeof(text)4080

/* This dictionary holds all interned unicode strings.  Note that references   to strings in this dictionary are *not* counted in the string's ob_refcnt.   When the interned string reaches a refcnt of 0 the string deallocation   function will delete the reference from this dictionary.   Another way to look at this is that to say that the actual reference   count of a string is:  s->ob_refcnt + (s->state ? 2 : 0)*/static PyObject *interned = NULL;voidPyUnicode_InternInPlace(PyObject **p){    PyObject *s = *p;    PyObject *t;#ifdef Py_DEBUG    assert(s != NULL);    assert(_PyUnicode_CHECK(s));#else    if (s == NULL || !PyUnicode_Check(s))        return;#endif    /* If it's a subclass, we don't really know what putting       it in the interned dict might do. */    if (!PyUnicode_CheckExact(s))        return;    if (PyUnicode_CHECK_INTERNED(s))        return;    if (interned == NULL) {        interned = PyDict_New();        if (interned == NULL) {            PyErr_Clear(); /* Don't leave an exception */            return;        }    }    Py_ALLOW_RECURSION    t = PyDict_SetDefault(interned, s, s);    Py_END_ALLOW_RECURSION    if (t == NULL) {        PyErr_Clear();        return;    }    if (t != s) {        Py_INCREF(t);        Py_SETREF(*p, t);        return;    }    /* The two references in interned are not counted by refcnt.       The deallocator will take care of this */    Py_REFCNT(s) -= 2;    _PyUnicode_STATE(s).interned = SSTATE_INTERNED_MORTAL;}

>>> class User:    def __init__(self, name, age):        self.name = name        self.age = age>>> user = User('Tom', 21)>>> user.__dict__{'name': 'Tom', 'age': 21}

>>> a = 'abc'>>> b = 'ab' + 'c'>>> id(a), id(b), a is b(2752416949872, 2752416949872, True)