深入 Python 解释器源码，我终于搞明白了字符串驻留的原理！

>>> 'python' is 'python'True

PyAPI_FUNC(void) PyUnicode_InternInPlace(PyObject **);

#define PyUnicode_CHECK_INTERNED(op) \    (((PyASCIIObject *)(op))->state.interned)

voidPyUnicode_InternInPlace(PyObject **p){    PyObject *s = *p;
    .........
    // Lazily build the dictionary to hold interned Strings    if (interned == NULL) {        interned = PyDict_New();        if (interned == NULL) {            PyErr_Clear();            return;        }    }
    PyObject *t;
    // Make an entry to the interned dictionary for the    // given object    t = PyDict_SetDefault(interned, s, s);
    .........        // The two references in interned dict (key and value) are    // not counted by refcnt.    // unicode_dealloc() and _PyUnicode_ClearInterned() take    // care of this.    Py_SET_REFCNT(s, Py_REFCNT(s) - 2);
    // Set the state of the string to be INTERNED    _PyUnicode_STATE(s).interned = SSTATE_INTERNED_MORTAL;}

void_PyUnicode_ClearInterned(PyThreadState *tstate){    .........
    // Get all the keys to the interned dictionary    PyObject *keys = PyDict_Keys(interned);
    .........
    // Interned Unicode strings are not forcibly deallocated;    // rather, we give them their stolen references back    // and then clear and DECREF the interned dict.
    for (Py_ssize_t i = 0; i < n; i++) {        PyObject *s = PyList_GET_ITEM(keys, i);
        .........
        switch (PyUnicode_CHECK_INTERNED(s)) {        case SSTATE_INTERNED_IMMORTAL:            Py_SET_REFCNT(s, Py_REFCNT(s) + 1);            break;        case SSTATE_INTERNED_MORTAL:            // Restore the two references (key and value) ignored            // by PyUnicode_InternInPlace().            Py_SET_REFCNT(s, Py_REFCNT(s) + 2);            break;        case SSTATE_NOT_INTERNED:            /* fall through */        default:            Py_UNREACHABLE();        }
        // marking the string to be NOT_INTERNED        _PyUnicode_STATE(s).interned = SSTATE_NOT_INTERNED;    }
    // decreasing the reference to the initialized and    // access keys object.    Py_DECREF(keys);
    // clearing the dictionary    PyDict_Clear(interned);
    // clearing the object interned    Py_CLEAR(interned);}

PyCodeObject *PyCode_NewWithPosOnlyArgs(int argcount, int posonlyargcount, int kwonlyargcount,                          int nlocals, int stacksize, int flags,                          PyObject *code, PyObject *consts, PyObject *names,                          PyObject *varnames, PyObject *freevars, PyObject *cellvars,                          PyObject *filename, PyObject *name, int firstlineno,                          PyObject *linetable){
    ........
    if (intern_strings(names) < 0) {        return NULL;    }
    if (intern_strings(varnames) < 0) {        return NULL;    }
    if (intern_strings(freevars) < 0) {        return NULL;    }
    if (intern_strings(cellvars) < 0) {        return NULL;    }
    if (intern_string_constants(consts, NULL) < 0) {        return NULL;    }
    ........
}

intPyDict_SetItemString(PyObject *v, const char *key, PyObject *item){    PyObject *kv;    int err;    kv = PyUnicode_FromString(key);    if (kv == NULL)        return -1;
    // Invoking String Interning on the key    PyUnicode_InternInPlace(&kv); /* XXX Should we really? */
    err = PyDict_SetItem(v, kv, item);    Py_DECREF(kv);    return err;}

intPyObject_SetAttr(PyObject *v, PyObject *name, PyObject *value){
    ........
    PyUnicode_InternInPlace(&name);
    ........}

static PyObject *sys_intern_impl(PyObject *module, PyObject *s){
    ........
    if (PyUnicode_CheckExact(s)) {        Py_INCREF(s);        PyUnicode_InternInPlace(&s);        return s;    }
    ........}