什么是实现Python虚拟机字节的方法？

typedef struct {    PyObject_VAR_HEAD    Py_hash_t ob_shash;    char ob_sval[1];     /* Invariants:     *     ob_sval contains space for 'ob_size+1' elements.     *     ob_sval[ob_size] == 0.     *     ob_shash is the hash of the string or -1 if not computed yet.     */} PyBytesObject; typedef struct {    PyObject ob_base;    Py_ssize_t ob_size; /* Number of items in variable part */} PyVarObject; typedef struct _object {    Py_ssize_t ob_refcnt;    struct _typeobject *ob_type;} PyObject;

static PyObject *_PyBytes_FromSize(Py_ssize_t size, int use_calloc){    PyBytesObject *op;    assert(size >= 0);     if (size == 0 && (op = nullstring) != NULL) {#ifdef COUNT_ALLOCS        null_strings++;#endif        Py_INCREF(op);        return (PyObject *)op;    }     if ((size_t)size > (size_t)PY_SSIZE_T_MAX - PyBytesObject_SIZE) {        PyErr_SetString(PyExc_OverflowError,                        "byte string is too large");        return NULL;    }     /* Inline PyObject_NewVar */    // PyBytesObject_SIZE + size 就是实际申请的内存空间的大小 PyBytesObject_SIZE 就是表示 PyBytesObject 各个字段占用的实际的内存空间大小    if (use_calloc)        op = (PyBytesObject *)PyObject_Calloc(1, PyBytesObject_SIZE + size);    else        op = (PyBytesObject *)PyObject_Malloc(PyBytesObject_SIZE + size);    if (op == NULL)        return PyErr_NoMemory();    // 将对象的 ob_size 字段赋值成 size     (void)PyObject_INIT_VAR(op, &PyBytes_Type, size);    // 由于对象的哈希值还没有进行计算 因此现将哈希值赋值成 -1    op->ob_shash = -1;    if (!use_calloc)        op->ob_sval[size] = '';    /* empty byte string singleton */    if (size == 0) {        nullstring = op;        Py_INCREF(op);    }    return (PyObject *) op;}

>>> import sys>>> a = b"hello world">>> sys.getsizeof(a)44>>>

static Py_ssize_tbytes_length(PyBytesObject *a){    // (((PyVarObject*)(ob))->ob_size)    return Py_SIZE(a);}

>>> b"abc" + b"edf"

/* This is also used by PyBytes_Concat() */static PyObject *bytes_concat(PyObject *a, PyObject *b){    Py_buffer va, vb;    PyObject *result = NULL;     va.len = -1;    vb.len = -1;    // Py_buffer 当中有一个指针字段 buf 可以用户保存 PyBytesObject 当中字节数据的首地址    // PyObject_GetBuffer 函数的主要作用是将 对象 a 当中的字节数组赋值给 va 当中的 buf    if (PyObject_GetBuffer(a, &va, PyBUF_SIMPLE) != 0 ||        PyObject_GetBuffer(b, &vb, PyBUF_SIMPLE) != 0) {        PyErr_Format(PyExc_TypeError, "can't concat %.100s to %.100s",                     Py_TYPE(b)->tp_name, Py_TYPE(a)->tp_name);        goto done;    }     /* Optimize end cases */    if (va.len == 0 && PyBytes_CheckExact(b)) {        result = b;        Py_INCREF(result);        goto done;    }    if (vb.len == 0 && PyBytes_CheckExact(a)) {        result = a;        Py_INCREF(result);        goto done;    }     if (va.len > PY_SSIZE_T_MAX - vb.len) {        PyErr_NoMemory();        goto done;    }    result = PyBytes_FromStringAndSize(NULL, va.len + vb.len);    // 下方就是将对象 a b 当中的字节数据拷贝到新的    if (result != NULL) {        // PyBytes_AS_STRING 宏定义在下方当中 主要就是使用 PyBytesObject 对象当中的        // ob_sval 字段 也就是将 buf 数据（也就是 a 或者 b 当中的字节数据）拷贝到 ob_sval当中        memcpy(PyBytes_AS_STRING(result), va.buf, va.len);        memcpy(PyBytes_AS_STRING(result) + va.len, vb.buf, vb.len);    }   done:    if (va.len != -1)        PyBuffer_Release(&va);    if (vb.len != -1)        PyBuffer_Release(&vb);    return result;}

#define PyBytes_AS_STRING(op) (assert(PyBytes_Check(op)),                                 (((PyBytesObject *)(op))->ob_sval))

Python 3.9.0b1 (default, Mar 23 2023, 08:35:33) [GCC 4.8.5 20150623 (Red Hat 4.8.5-44)] on linuxType "help", "copyright", "credits" or "license" for more information.>>> b"abc" + b"edf"In concat function: abc <> edfb'abcedf'>>>

>>> res = b"">>> for item in  [b"a", b"b", b"c"]:...     res += item...>>> resb'abc'>>>

Py_LOCAL_INLINE(PyObject *)STRINGLIB(bytes_join)(PyObject *sep, PyObject *iterable){    char *sepstr = STRINGLIB_STR(sep);    const Py_ssize_t seplen = STRINGLIB_LEN(sep);    PyObject *res = NULL;    char *p;    Py_ssize_t seqlen = 0;    Py_ssize_t sz = 0;    Py_ssize_t i, nbufs;    PyObject *seq, *item;    Py_buffer *buffers = NULL;#define NB_STATIC_BUFFERS 10    Py_buffer static_buffers[NB_STATIC_BUFFERS];     seq = PySequence_Fast(iterable, "can only join an iterable");    if (seq == NULL) {        return NULL;    }     seqlen = PySequence_Fast_GET_SIZE(seq);    if (seqlen == 0) {        Py_DECREF(seq);        return STRINGLIB_NEW(NULL, 0);    }#ifndef STRINGLIB_MUTABLE    if (seqlen == 1) {        item = PySequence_Fast_GET_ITEM(seq, 0);        if (STRINGLIB_CHECK_EXACT(item)) {            Py_INCREF(item);            Py_DECREF(seq);            return item;        }    }#endif    if (seqlen > NB_STATIC_BUFFERS) {        buffers = PyMem_NEW(Py_buffer, seqlen);        if (buffers == NULL) {            Py_DECREF(seq);            PyErr_NoMemory();            return NULL;        }    }    else {        buffers = static_buffers;    }     /* Here is the general case.  Do a pre-pass to figure out the total     * amount of space we'll need (sz), and see whether all arguments are     * bytes-like.     */    for (i = 0, nbufs = 0; i < seqlen; i++) {        Py_ssize_t itemlen;        item = PySequence_Fast_GET_ITEM(seq, i);        if (PyBytes_CheckExact(item)) {            /* Fast path. */            Py_INCREF(item);            buffers[i].obj = item;            buffers[i].buf = PyBytes_AS_STRING(item);            buffers[i].len = PyBytes_GET_SIZE(item);        }        else if (PyObject_GetBuffer(item, &buffers[i], PyBUF_SIMPLE) != 0) {            PyErr_Format(PyExc_TypeError,                         "sequence item %zd: expected a bytes-like object, "                         "%.80s found",                         i, Py_TYPE(item)->tp_name);            goto error;        }        nbufs = i + 1;  /* for error cleanup */        itemlen = buffers[i].len;        if (itemlen > PY_SSIZE_T_MAX - sz) {            PyErr_SetString(PyExc_OverflowError,                            "join() result is too long");            goto error;        }        sz += itemlen;        if (i != 0) {            if (seplen > PY_SSIZE_T_MAX - sz) {                PyErr_SetString(PyExc_OverflowError,                                "join() result is too long");                goto error;            }            sz += seplen;        }        if (seqlen != PySequence_Fast_GET_SIZE(seq)) {            PyErr_SetString(PyExc_RuntimeError,                            "sequence changed size during iteration");            goto error;        }    }     /* Allocate result space. */    res = STRINGLIB_NEW(NULL, sz);    if (res == NULL)        goto error;     /* Catenate everything. */    p = STRINGLIB_STR(res);    if (!seplen) {        /* fast path */        for (i = 0; i < nbufs; i++) {            Py_ssize_t n = buffers[i].len;            char *q = buffers[i].buf;            Py_MEMCPY(p, q, n);            p += n;        }        goto done;    }    // 具体的实现逻辑就是在这里    for (i = 0; i < nbufs; i++) {        Py_ssize_t n;        char *q;        if (i) {            // 首先现将 sepstr 拷贝到新的数组里面但是在我们举的例子当中是空串 b""            Py_MEMCPY(p, sepstr, seplen);            p += seplen;        }        n = buffers[i].len;        q = buffers[i].buf;        // 然后将列表当中第 i 个 bytes 的数据拷贝到 p 当中 这样就是实现了我们所需要的效果        Py_MEMCPY(p, q, n);        p += n;    }    goto done; error:    res = NULL;done:    Py_DECREF(seq);    for (i = 0; i < nbufs; i++)        PyBuffer_Release(&buffers[i]);    if (buffers != static_buffers)        PyMem_FREE(buffers);    return res;}

static PyBytesObject *characters[UCHAR_MAX + 1]; // UCHAR_MAX 在 64 位系统当中等于 255

PyObject *PyBytes_FromStringAndSize(const char *str, Py_ssize_t size){    PyBytesObject *op;    if (size < 0) {        PyErr_SetString(PyExc_SystemError,            "Negative size passed to PyBytes_FromStringAndSize");        return NULL;    }    // 如果创建长度等于 1 而且对象在 characters 当中存在的话那么就直接返回    if (size == 1 && str != NULL &&        (op = characters[*str & UCHAR_MAX]) != NULL)    {#ifdef COUNT_ALLOCS        one_strings++;#endif        Py_INCREF(op);        return (PyObject *)op;    }     op = (PyBytesObject *)_PyBytes_FromSize(size, 0);    if (op == NULL)        return NULL;    if (str == NULL)        return (PyObject *) op;     Py_MEMCPY(op->ob_sval, str, size);    /* share short strings */    // 如果创建的对象的长度等于 1 那么久将这个对象保存到 characters 当中    if (size == 1) {        characters[*str & UCHAR_MAX] = op;        Py_INCREF(op);    }    return (PyObject *) op;}

>>> a = b"a">>> b  =b"a">>> a == bTrue>>> a is bTrue>>> a = b"aa">>> b = b"aa">>> a == bTrue>>> a is bFalse