検索

ホームページ >バックエンド開発 >Python チュートリアル >Python組み込み型strソースコード解析

Python組み込み型strソースコード解析

PHPz
PHPz転載
2023-05-09 14:16:291357ブラウズ

1 Unicode

コンピュータ ストレージの基本単位は 8 ビットで構成されるバイトです。英語は 26 文字といくつかの記号のみで構成されているため、英語の文字はバイト単位で直接格納できます。ただし、他の言語 (中国語、日本語、韓国語など) では、文字数が多いため、エンコードに複数のバイトを使用する必要があります。

コンピューター技術の普及に伴い、非ラテン文字エンコーディング技術は発展を続けていますが、依然として 2 つの大きな制限があります。

  • 複数の言語をサポートしていません。ある言語のエンコード スキームを別の言語に使用することはできません

  • 統一された標準はありません。たとえば、中国語には GBK、GB2312、GB18030

    • などの複数のエンコード標準があります。

エンコード方式が統一されていないため、開発者は異なるエンコード間で変換を行ったり来たりする必要があり、必然的に多くのエラーが発生します。このような不一致の問題を解決するために、Unicode 標準が提案されました。 Unicode は、世界中のほとんどの書記体系を整理してエンコードし、コンピュータが統一された方法でテキストを処理できるようにします。 Unicode には現在 140,000 文字以上が含まれており、当然ながら複数の言語をサポートしています。 (Unicode の uni は「unification」の語源です)

2 Python における Unicode

2.1 Unicode オブジェクトの利点

Python 3 以降、Unicode は str オブジェクトの内部で使用されます。を表すため、ソース コードでは Unicode オブジェクトになります。 Unicode 表現を使用する利点は、プログラムのコア ロジックが Unicode を均一に使用し、入力層と出力層でのみデコードおよびエンコードする必要があるため、さまざまなエンコードの問題を最大限に回避できることです。

図は次のとおりです:

Python組み込み型strソースコード解析

##2.2 Python による Unicode の最適化

問題: Unicode には 140,000 を超える文字が含まれているため、それぞれの A 文字は保存するには少なくとも 4 バイトが必要です (これはおそらく 2 バイトでは不十分であるため、4 バイトが使用され、3 バイトは通常は使用されません)。英語文字の ASCII コードには 1 バイトしか必要ありませんが、Unicode を使用すると、頻繁に使用される英語文字のコストが 4 倍になります。

まず、Python のさまざまな形式の str オブジェクトのサイズの違いを見てみましょう: 

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

テキストの内容に従って、Python が内部的に Unicode オブジェクトを最適化していることがわかります。 、基礎となるストレージユニットが選択されます。

Unicode オブジェクトの基礎となるストレージは、テキスト文字の Unicode コード ポイント範囲に従って 3 つのカテゴリに分類されます:

  • PyUnicode_1BYTE_KIND: すべての文字コード ポイントは U 0000 の間にあります。および U 00FF

  • PyUnicode_2BYTE_KIND: すべての文字コード ポイントが U 0000 から U FFFF の間にあり、少なくとも 1 つの文字のコード ポイントが U 00FF

    ## より大きい
    • #PyUnicode_1BYTE_KIND: すべての文字コード ポイントは U 0000 ～ U 10FFFF であり、少なくとも 1 つの文字のコード ポイントが U FFFF

  • ##対応する列挙は次のとおりです。 ##
    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;

対応する関係は次のとおりです:

テキスト タイプ文字ストレージ ユニットPy_UCS1Py_UCS2Py_UCS4Unicode の内部ストレージ構造はテキスト タイプによって異なるため、タイプの種類は Unicode オブジェクトのパブリック フィールドとして保存する必要があります。 Python は内部的にいくつかのフラグ ビットを Unicode パブリック フィールドとして定義します: (作成者のレベルが限られているため、ここにあるすべてのフィールドは後続のコンテンツでは紹介されません。これについては後ほど自分で学ぶことができます。頑張ってください~)
文字ストレージ ユニット サイズ (バイト) PyUnicode_1BYTE_KIND
1 ##PyUnicode_2BYTE_KIND
2 PyUnicode_4BYTE_KIND
4

interned: interned メカニズムを維持するかどうか

  • kind: type、基礎となる文字の記憶単位のサイズを区別するために使用されます

  • compact: メモリ割り当て方法、オブジェクトとテキスト バッファーが分離されているかどうか

  • asscii: テキストがすべて純粋な ASCII かどうか

  • PyUnicode_New 関数を通じて、テキスト文字数のサイズと最大文字数に従って、maxchar が Unicode オブジェクトを初期化します。この関数は主に、maxchar に基づいて最もコンパクトな文字格納ユニットと Unicode オブジェクトの基礎となる構造を選択します。 (ソース コードは比較的長いため、ここには記載しません。ご自身で理解してください。以下の表形式で示します) )

maxchar kindPyUnicode_1BYTE_KIND11PyASCIIObject
128 256 65536
PyUnicode_1BYTE_KIND PyUnicode_2BYTE_KIND PyUnicode_4BYTE_KIND ascii
0 0 0 文字格納単位サイズ (バイト)
1 2 4 基礎構造
PyCompactUnicodeObject PyCompactUnicodeObject PyCompactUnicodeObject

3 Unicode对象的底层结构体

3.1 PyASCIIObject

C源码：

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;

源码分析：

length：文本长度

hash：文本哈希值

state：Unicode对象标志位

wstr：缓存C字符串的一个wchar_t指针，以“\0”结束（这里和我看的另一篇文章讲得不太一样，另一个描述是：ASCII文本紧接着位于PyASCIIObject结构体后面，我个人觉得现在的这种说法比较准确，毕竟源码结构体后面没有别的字段了）

图示如下：

（注意这里state字段后面有一个4字节大小的空洞，这是结构体字段内存对齐造成的现象，主要是为了优化内存访问效率）

Python組み込み型strソースコード解析

ASCII文本由wstr指向，以’abc’和空字符串对象’'为例：

Python組み込み型strソースコード解析

Python組み込み型strソースコード解析

3.2 PyCompactUnicodeObject

如果文本不全是ASCII，Unicode对象底层便由PyCompactUnicodeObject结构体保存。C源码如下：

/* 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 \0. */
    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;

PyCompactUnicodeObject在PyASCIIObject的基础上增加了3个字段：

utf8_length：文本UTF8编码长度

utf8：文本UTF8编码形式，缓存以避免重复编码运算

wstr_length：wstr的“长度”（这里所谓的长度没有找到很准确的说法，笔者也不太清楚怎么能打印出来，大家可以自行研究下）

注意到，PyASCIIObject中并没有保存UTF8编码形式，这是因为ASCII本身就是合法的UTF8，这也是ASCII文本底层由PyASCIIObject保存的原因。

结构图示：

Python組み込み型strソースコード解析

3.3 PyUnicodeObject

PyUnicodeObject则是Python中str对象的具体实现。C源码如下：

/* 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;

3.4 示例

在日常开发时，要结合实际情况注意字符串拼接前后的内存大小差别：

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

4 interned机制

如果str对象的interned标志位为1，Python虚拟机将为其开启interned机制，

源码如下：（相关信息在网上可以看到很多说法和解释，这里笔者能力有限，暂时没有找到最确切的答案，之后补充。抱拳~但是我们通过分析源码应该是能看出一些门道的）

/* 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;
void
PyUnicode_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;
}

可以看到，源码前面还是做一些基本的检查。我们可以看一下37行和50行：将s添加到interned字典中时，其实s同时是key和value（这里我不太清楚为什么会这样做），所以s对应的引用计数是+2了的（具体可以看PyDict_SetDefault()的源码），所以在50行时会将计数-2，保证引用计数的正确。

考虑下面的场景：

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

由于对象的属性由dict保存，这意味着每个User对象都要保存一个str对象‘name’，这会浪费大量的内存。而str是不可变对象，因此Python内部将有潜在重复可能的字符串都做成单例模式，这就是interned机制。Python具体做法就是在内部维护一个全局dict对象，所有开启interned机制的str对象均保存在这里，后续需要使用的时候，先创建，如果判断已经维护了相同的字符串，就会将新创建的这个对象回收掉。

示例：

由不同运算生成’abc’，最后都是同一个对象：

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

以上がPython組み込み型strソースコード解析の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。

声明：
この記事はyisu.comで複製されています。侵害がある場合は、admin@php.cn までご連絡ください。
前の記事：Python GUIレイアウトツールTkinterの使い方次の記事：Python GUIレイアウトツールTkinterの使い方

関連記事

続きを見る