Pythonの動的代入のトラップ解析

この記事は、Python での動的代入の落とし穴についての分析を提供します。これには一定の参考価値があります。必要な友人は参照できます。お役に立てば幸いです。

名前空間とスコープの問題は些細なことのように思えるかもしれませんが、実際にはその背後に多くのことがあります。

紙面の都合上、まだ議論されていない重要な知識内容、すなわち「locals()とglobals()の読み書きの問題」が存在します。この問題が重要である理由は、柔軟な動的割り当て機能を実装できるためです。

これらはすべて辞書タイプであり、その使用法は一目瞭然です。ただし、これを使用するときに注意すべき落とし穴があります。globals() は読み取りおよび書き込み可能ですが、locals() は読み取りのみ可能で書き込みはできません。今日私が共有した記事は、この問題を探求するもので、非常に詳細な内容なので、皆さんにも共有したいと思います。

職場では、ローカル変数であろうとグローバル変数であろうと、動的な変数の割り当てという状況に遭遇することがあります。頭を悩ませているときに、Python がこの問題を解決してくれました。

Python の名前空間は辞書形式で反映されており、具体的な関数はローカル名前空間とグローバル名前空間にそれぞれ対応する locals() と globals() です。

例:

def test():
    globals()['a2'] = 4
test()
print a2   # 输出 4

グローバルはグローバル名前空間を変更できるため、当然ローカルもローカル名前空間を変更できるはずです。ローカル変数を変更します。

#しかし、これは本当にそうなのでしょうか? いいえ!

def aaaa():
    print locals()
    for i in ['a', 'b', 'c']:
        locals()[i] = 1
    print locals()
    print a
aaaa()

出力:

{}
{'i': 'c', 'a': 1, 'c': 1, 'b': 1}
Traceback (most recent call last):
  File "5.py", line 17, in <module>
    aaaa()
  File "5.py", line 16, in aaaa
    print a
NameError: global name &#39;a&#39; is not defined

プログラムが実行され、エラーが報告されます!

しかし、2 回目に locals() を出力すると、それらの変数がローカル空間にすでに存在し、値 1 を持つ変数 a も存在することがはっきりとわかります。しかし、a を出力するときに NameError 例外が表示されるのはなぜですか?

詳細 例を見てください:

def aaaa():
    print locals()
    s = 'test'                    # 加入显示赋值 s       
    for i in ['a', 'b', 'c']:
        locals()[i] = 1
    print locals()
    print s                       # 打印局部变量 s 
    print a
aaaa()

出力:

{}
{'i': 'c', 'a': 1, 's': 'test', 'b': 1, 'c': 1}
test
Traceback (most recent call last):
  File "5.py", line 19, in <module>
    aaaa()
  File "5.py", line 18, in aaaa
    print a
NameError: global name &#39;a&#39; is not defined

コードの上部と下部の部分。違いは、次のコードが割り当てを示していることです。ただし、NameError 例外は発生します。もトリガーされ、ローカル変数 s の値が出力されます。

これは、私たちを非常に困惑させます。locals() を介してローカル変数を変更することは、直接代入とは異なるのでしょうか? この問題を解決するには、次のことを確認することしかできません。実行中のプログラムの真実を突き止め、最大のキラー ディスを取得します~

根本原因の調査

コードの 2 番目の部分を直接分析します:

13           0 LOAD_GLOBAL              0 (locals)
              3 CALL_FUNCTION            0
              6 PRINT_ITEM
              7 PRINT_NEWLINE
 14           8 LOAD_CONST               1 ('test')
             11 STORE_FAST               0 (s)
 15          14 SETUP_LOOP              36 (to 53)
             17 LOAD_CONST               2 ('a')
             20 LOAD_CONST               3 ('b')
             23 LOAD_CONST               4 ('c')
             26 BUILD_LIST               3
             29 GET_ITER
        >>   30 FOR_ITER                19 (to 52)
             33 STORE_FAST               1 (i)
 16          36 LOAD_CONST               5 (1)
             39 LOAD_GLOBAL              0 (locals)
             42 CALL_FUNCTION            0
             45 LOAD_FAST                1 (i)
             48 STORE_SUBSCR
             49 JUMP_ABSOLUTE           30
        >>   52 POP_BLOCK
 17     >>   53 LOAD_GLOBAL              0 (locals)
             56 CALL_FUNCTION            0
             59 PRINT_ITEM
             60 PRINT_NEWLINE
 18          61 LOAD_FAST                0 (s)
             64 PRINT_ITEM
             65 PRINT_NEWLINE
 19          66 LOAD_GLOBAL              1 (a)
             69 PRINT_ITEM
             70 PRINT_NEWLINE
             71 LOAD_CONST               0 (None)
             74 RETURN_VALUE
None

それがわかります。上記のバイトコード:

locals() に対応するバイトコードは次のとおりです: LOAD_GLOBAL

s='test' 対応するバイトコードは次のとおりです: LOAD_CONST および STORE_FAST

print s 対応するバイトコードは: LOAD_FAST

print a に対応するバイトコードは: LOAD_GLOBAL

上記のいくつかの重要なステートメントのバイトコードからわかるように、直接の代入/読み取り、および locals() /The を介した代入が行われます。読み取りの性質は非常に異なります。それで、NameError 例外がトリガーされたとき、locals()[i] = 1 によって保存された値と実際のローカル名前空間が 2 つの異なる場所にあることが証明されますか?

答えを考えるこの質問では、最初に 1 つのことを決定する必要があります。それは、実際のローカル名前空間を取得する方法です?実際、この質問に対する標準的な答えは上記のバイトコードで示されています!

真のローカル名前空間実際の名前空間対応するデータ構造 STORE_FAST に存在します。これは一体何ですか? これには、ソース コードで次のように答える必要があります:

// ceval.c  从上往下, 依次是相应函数或者变量的定义
// 指令源码
TARGET(STORE_FAST)
{
    v = POP();
    SETLOCAL(oparg, v);
    FAST_DISPATCH();
}
--------------------
// SETLOCAL 宏定义      
#define SETLOCAL(i, value)      do { PyObject *tmp = GETLOCAL(i); \
                                     GETLOCAL(i) = value; \
                                     Py_XDECREF(tmp); } while (0)
-------------------- 
// GETLOCAL 宏定义                                    
#define GETLOCAL(i)     (fastlocals[i])     
-------------------- 
// fastlocals 真面目
PyObject * PyEval_EvalFrameEx(PyFrameObject *f, int throwflag){
    // 省略其他无关代码
   fastlocals = f->f_localsplus;
....
}

これを見ると、関数内のローカル名前空間が実際には、はい、メンバーであることが明らかになるはずです。フレーム オブジェクトの f_localsplus. これは配列です。関数によって作成された子供の靴を理解するとわかりやすいかもしれません。CALL_FUNCTION 中に、この配列は初期化され、仮パラメータの割り当てが順番に詰め込まれます。ワード内ではセクション コード18 61 LOAD_FAST 0 (s)、4 番目の列の 0 は、f_localsplus の 0 番目のメンバー (値 "s") を取り出すことです。

つまり、STORE_FAST は、変数 Local 名前空間を格納する実際の方法です。 , locals() とは何ですか? なぜ本物のように見えるのですか?

これには、ローカルの分析が必要です。このためには、バイトコードは役に立たない可能性があります。組み込み関数を直接調べてみてはどうでしょうか? 定義します。

// bltinmodule.c
static PyMethodDef builtin_methods[] = {
    ...
    // 找到 locals 函数对应的内置函数是 builtin_locals 
    {"locals",          (PyCFunction)builtin_locals,     METH_NOARGS, locals_doc},
    ...
}
-----------------------------
// builtin_locals 的定义
static PyObject *
builtin_locals(PyObject *self)
{
    PyObject *d;
    d = PyEval_GetLocals();
    Py_XINCREF(d);
    return d;
}
-----------------------------
PyObject *
PyEval_GetLocals(void)
{
    PyFrameObject *current_frame = PyEval_GetFrame();  // 获取当前堆栈对象
    if (current_frame == NULL)
        return NULL;
    PyFrame_FastToLocals(current_frame); // 初始化和填充 f_locals
    return current_frame->f_locals;
}
-----------------------------
// 初始化和填充 f_locals 的具体实现
void
PyFrame_FastToLocals(PyFrameObject *f)
{
    /* Merge fast locals into f->f_locals */
    PyObject *locals, *map;
    PyObject **fast;
    PyObject *error_type, *error_value, *error_traceback;
    PyCodeObject *co;
    Py_ssize_t j;
    int ncells, nfreevars;
    if (f == NULL)
        return;
    locals = f->f_locals;
    // 如果locals为空, 就新建一个字典对象
    if (locals == NULL) {
        locals = f->f_locals = PyDict_New();  
        if (locals == NULL) {
            PyErr_Clear(); /* Can't report it :-( */
            return;
        }
    }
    co = f->f_code;
    map = co->co_varnames;
    if (!PyTuple_Check(map))
        return;
    PyErr_Fetch(&error_type, &error_value, &error_traceback);
    fast = f->f_localsplus;
    j = PyTuple_GET_SIZE(map);
    if (j > co->co_nlocals)
        j = co->co_nlocals;
    // 将 f_localsplus 写入 locals
    if (co->co_nlocals)
        map_to_dict(map, j, locals, fast, 0);
    ncells = PyTuple_GET_SIZE(co->co_cellvars);
    nfreevars = PyTuple_GET_SIZE(co->co_freevars);
    if (ncells || nfreevars) {
        // 将 co_cellvars 写入 locals
        map_to_dict(co->co_cellvars, ncells,
                    locals, fast + co->co_nlocals, 1);
        if (co->co_flags & CO_OPTIMIZED) {
            // 将 co_freevars 写入 locals
            map_to_dict(co->co_freevars, nfreevars,
                        locals, fast + co->co_nlocals + ncells, 1);
        }
    }
    PyErr_Restore(error_type, error_value, error_traceback);
}

上記の PyFrame_FastToLocals からわかるように、locals() は実際に次のことを行います:

フレーム オブジェクトの f_f->f_locals が空かどうかを判断します。次に、新しい辞書オブジェクトを作成します。

localsplus、co_cellvars、および co_freevars を f_f->f_locals に書き込みます。

上記の内容について簡単に説明します:

localsplus : 関数パラメータ (位置パラメータ キーワード パラメータ)、割り当てられた変数を表示します。

co_cellvars および co_freevars: クロージャ関数で使用されるローカル変数。

結論

上記のソース コードを通じて、 locals() が参照するものは確かに関数のローカル名前空間の内容であることはすでに明確にわかっていますが、それ自体はローカル名前空間を表すことはできません。これは A、B、C のものを収集するプロキシのようなものです。しかし、A、B、C が実際に所有するものを変更するためにこのプロキシを単純に変更することはできません!

だからこそ、locals() を渡すときに、[i] = 1 を使用して値を動的に割り当てるときに、出力します。 a は NameError 例外をトリガーします。それどころか、globals() は確かに実際のグローバル名前空間であるため、一般に「locals() は読み取り専用であり、globals() は読み取り可能」と言われています。

この記事はここで終了しています。さらに興味深いコンテンツについては、PHP 中国語 Web サイトの Python ビデオ チュートリアル 列に注目してください。

以上がPythonの動的代入のトラップ解析の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。