辞書オブジェクト (dictionary object)
************************************

type PyDictObject

   この "PyObject" のサブタイプは Python の辞書オブジェクトを表現しま
   す。

PyTypeObject PyDict_Type
    * 次に属します: Stable ABI.*

   この "PyTypeObject" のインスタンスは Python の辞書を表現します。こ
   のオブジェクトは、Python レイヤにおける "dict" と同じオブジェクトで
   す。

int PyDict_Check(PyObject *p)

   *p* が辞書オブジェクトか辞書型のサブタイプのインスタンスである場合
   に真を返します。この関数は常に成功します。

int PyDict_CheckExact(PyObject *p)

   *p* が辞書オブジェクトだが辞書型のサブタイプのインスタンスでない場
   合に真を返します。この関数は常に成功します。

PyObject *PyDict_New()
    *戻り値: 新しい参照。** 次に属します: Stable ABI.*

   空の新たな辞書を返します。 失敗すると "NULL" を返します。

PyObject *PyDictProxy_New(PyObject *mapping)
    *戻り値: 新しい参照。** 次に属します: Stable ABI.*

   あるマップ型オブジェクトに対して、読み出し専用に制限された
   "types.MappingProxyType" オブジェクトを返します。通常、この関数は動
   的でないクラス型 (non-dynamic class type) のクラス辞書が変更されな
   いようにビューを作成するために使われます。

void PyDict_Clear(PyObject *p)
    * 次に属します: Stable ABI.*

   現在辞書に入っている全てのキーと値のペアを除去して空にします。

int PyDict_Contains(PyObject *p, PyObject *key)
    * 次に属します: Stable ABI.*

   辞書 *p* に *key* が入っているか判定します。*p* の要素が *key* に一
   致した場合は "1" を返し、それ以外の場合には "0" を返します。エラー
   の場合 "-1" を返します。この関数は Python の式 "key in p" と等価で
   す。

int PyDict_ContainsString(PyObject *p, const char *key)

   This is the same as "PyDict_Contains()", but *key* is specified as
   a const char* UTF-8 encoded bytes string, rather than a PyObject*.

   Added in version 3.13.

PyObject *PyDict_Copy(PyObject *p)
    *戻り値: 新しい参照。** 次に属します: Stable ABI.*

   *p* と同じキーと値のペアが入った新たな辞書を返します。

int PyDict_SetItem(PyObject *p, PyObject *key, PyObject *val)
    * 次に属します: Stable ABI.*

   辞書 *p* に、 *key* をキーとして値 *val* を挿入します。 *key* はハ
   ッシュ可能(*hashable*)でなければなりません。ハッシュ可能でない場合
   、 "TypeError" を送出します。 成功した場合には "0" を、失敗した場合
   には "-1" を返します。 この関数は *val* への参照を盗み取り *ません*
   。

int PyDict_SetItemString(PyObject *p, const char *key, PyObject *val)
    * 次に属します: Stable ABI.*

   This is the same as "PyDict_SetItem()", but *key* is specified as a
   const char* UTF-8 encoded bytes string, rather than a PyObject*.

int PyDict_DelItem(PyObject *p, PyObject *key)
    * 次に属します: Stable ABI.*

   辞書 *p* から *key* をキーとするエントリを除去します。 *key* は *ハ
   ッシュ可能* でなければなりません;  ハッシュ可能でない場合、
   "TypeError" を送出します。*key* が辞書になければ、"KeyError" を送出
   します。成功した場合には "0" を、失敗した場合には "-1" を返します。

int PyDict_DelItemString(PyObject *p, const char *key)
    * 次に属します: Stable ABI.*

   This is the same as "PyDict_DelItem()", but *key* is specified as a
   const char* UTF-8 encoded bytes string, rather than a PyObject*.

int PyDict_GetItemRef(PyObject *p, PyObject *key, PyObject **result)
    * 次に属します: Stable ABI (バージョン 3.13 より).*

   Return a new *strong reference* to the object from dictionary *p*
   which has a key *key*:

   * If the key is present, set **result* to a new *strong reference*
     to the value and return "1".

   * If the key is missing, set **result* to "NULL" and return "0".

   * エラーの場合例外を送出し "-1" を返します。

   Added in version 3.13.

   See also the "PyObject_GetItem()" function.

PyObject *PyDict_GetItem(PyObject *p, PyObject *key)
    *戻り値: 借用参照。** 次に属します: Stable ABI.*

   Return a *borrowed reference* to the object from dictionary *p*
   which has a key *key*.  Return "NULL" if the key *key* is missing
   *without* setting an exception.

   注釈:

     Exceptions that occur while this calls "__hash__()" and
     "__eq__()" methods are silently ignored. Prefer the
     "PyDict_GetItemWithError()" function instead.

   バージョン 3.10 で変更: Calling this API without *GIL* held had
   been allowed for historical reason. It is no longer allowed.

PyObject *PyDict_GetItemWithError(PyObject *p, PyObject *key)
    *戻り値: 借用参照。** 次に属します: Stable ABI.*

   "PyDict_GetItem()" の変種で例外を隠しません。 例外が発生した場合は
   、例外をセット **した上で** "NULL" を返します。 キーが存在しなかっ
   た場合は、例外をセット **せずに** "NULL" を返します。

PyObject *PyDict_GetItemString(PyObject *p, const char *key)
    *戻り値: 借用参照。** 次に属します: Stable ABI.*

   This is the same as "PyDict_GetItem()", but *key* is specified as a
   const char* UTF-8 encoded bytes string, rather than a PyObject*.

   注釈:

     Exceptions that occur while this calls "__hash__()" and
     "__eq__()" methods or while creating the temporary "str" object
     are silently ignored. Prefer using the
     "PyDict_GetItemWithError()" function with your own
     "PyUnicode_FromString()" *key* instead.

int PyDict_GetItemStringRef(PyObject *p, const char *key, PyObject **result)
    * 次に属します: Stable ABI (バージョン 3.13 より).*

   Similar to "PyDict_GetItemRef()", but *key* is specified as a const
   char* UTF-8 encoded bytes string, rather than a PyObject*.

   Added in version 3.13.

PyObject *PyDict_SetDefault(PyObject *p, PyObject *key, PyObject *defaultobj)
    *戻り値: 借用参照。*

   これは Python レベルの "dict.setdefault()" と同じです。 もしあれば
   、辞書 *p* から *key* に対応する値を返します。 キーが辞書になければ
   、値 *defaultobj* を挿入し *defaultobj* を返します。 この関数は、
   *key* のハッシュ値を検索と挿入ごとに別々に評価するのではなく、一度
   だけしか評価しません。

   Added in version 3.4.

int PyDict_SetDefaultRef(PyObject *p, PyObject *key, PyObject *default_value, PyObject **result)

   Inserts *default_value* into the dictionary *p* with a key of *key*
   if the key is not already present in the dictionary. If *result* is
   not "NULL", then **result* is set to a *strong reference* to either
   *default_value*, if the key was not present, or the existing value,
   if *key* was already present in the dictionary. Returns "1" if the
   key was present and *default_value* was not inserted, or "0" if the
   key was not present and *default_value* was inserted. On failure,
   returns "-1", sets an exception, and sets "*result" to "NULL".

   For clarity: if you have a strong reference to *default_value*
   before calling this function, then after it returns, you hold a
   strong reference to both *default_value* and **result* (if it's not
   "NULL"). These may refer to the same object: in that case you hold
   two separate references to it.

   Added in version 3.13.

int PyDict_Pop(PyObject *p, PyObject *key, PyObject **result)

   Remove *key* from dictionary *p* and optionally return the removed
   value. Do not raise "KeyError" if the key missing.

   * If the key is present, set **result* to a new reference to the
     removed value if *result* is not "NULL", and return "1".

   * If the key is missing, set **result* to "NULL" if *result* is not
     "NULL", and return "0".

   * エラーの場合例外を送出し "-1" を返します。

   Similar to "dict.pop()", but without the default value and not
   raising "KeyError" if the key missing.

   Added in version 3.13.

int PyDict_PopString(PyObject *p, const char *key, PyObject **result)

   Similar to "PyDict_Pop()", but *key* is specified as a const char*
   UTF-8 encoded bytes string, rather than a PyObject*.

   Added in version 3.13.

PyObject *PyDict_Items(PyObject *p)
    *戻り値: 新しい参照。** 次に属します: Stable ABI.*

   辞書内の全ての要素対が入った "PyListObject" を返します。

PyObject *PyDict_Keys(PyObject *p)
    *戻り値: 新しい参照。** 次に属します: Stable ABI.*

   辞書内の全てのキーが入った "PyListObject" を返します。

PyObject *PyDict_Values(PyObject *p)
    *戻り値: 新しい参照。** 次に属します: Stable ABI.*

   辞書 *p* 内の全ての値が入った "PyListObject" を返します。

Py_ssize_t PyDict_Size(PyObject *p)
    * 次に属します: Stable ABI.*

   辞書内の要素の数を返します。辞書に対して "len(p)" を実行するのと同
   じです。

int PyDict_Next(PyObject *p, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue)
    * 次に属します: Stable ABI.*

   辞書 *p* 内の全てのキー/値のペアにわたる反復処理を行います。 *ppos*
   が参照している "Py_ssize_t" 型は、この関数で反復処理を開始する際に
   、最初に関数を呼び出すよりも前に "0" に初期化しておかなければなりま
   せん。この関数は辞書内の各ペアを取り上げるごとに真を返し、全てのペ
   アを取り上げたことが分かると偽を返します。 パラメーター *pkey* およ
   び *pvalue* には、それぞれ辞書の各々のキーと値が埋められた
   PyObject* 変数を指すポインタか、または "NULL" が入ります。 この関数
   から返される参照はすべて借用参照になります。 反復処理中に *ppos* を
   変更してはなりません。 この値は内部的な辞書構造体のオフセットを表現
   しており、構造体はスパースなので、オフセットの値に一貫性がないため
   です。

   例えば:

      PyObject *key, *value;
      Py_ssize_t pos = 0;

      while (PyDict_Next(self->dict, &pos, &key, &value)) {
          /* do something interesting with the values... */
          ...
      }

   反復処理中に辞書 *p* を変更してはなりません。辞書を反復処理する際に
   、キーに対応する値を変更しても大丈夫になりましたが、キーの集合を変
   更しないことが前提です。以下に例を示します:

      PyObject *key, *value;
      Py_ssize_t pos = 0;

      while (PyDict_Next(self->dict, &pos, &key, &value)) {
          long i = PyLong_AsLong(value);
          if (i == -1 && PyErr_Occurred()) {
              return -1;
          }
          PyObject *o = PyLong_FromLong(i + 1);
          if (o == NULL)
              return -1;
          if (PyDict_SetItem(self->dict, key, o) < 0) {
              Py_DECREF(o);
              return -1;
          }
          Py_DECREF(o);
      }

   The function is not thread-safe in the *free-threaded* build
   without external synchronization.  You can use
   "Py_BEGIN_CRITICAL_SECTION" to lock the dictionary while iterating
   over it:

      Py_BEGIN_CRITICAL_SECTION(self->dict);
      while (PyDict_Next(self->dict, &pos, &key, &value)) {
          ...
      }
      Py_END_CRITICAL_SECTION();

int PyDict_Merge(PyObject *a, PyObject *b, int override)
    * 次に属します: Stable ABI.*

   マップ型オブジェクト *b* の全ての要素にわたって、反復的にキー/値の
   ペアを辞書 *a* に追加します。 *b* は辞書か、 "PyMapping_Keys()" ま
   たは "PyObject_GetItem()" をサポートする何らかのオブジェクトにでき
   ます。 *override* が真ならば、 *a* のキーと一致するキーが *b* にあ
   る際に、既存のペアを置き換えます。それ以外の場合は、 *b* のキーに一
   致するキーが *a* にないときのみ追加を行います。成功した場合には "0"
   を返し、例外が送出された場合には "-1" を返します。

int PyDict_Update(PyObject *a, PyObject *b)
    * 次に属します: Stable ABI.*

   C で表せば "PyDict_Merge(a, b, 1)" と同じで、また Python の
   "a.update(b)" と似ていますが、 "PyDict_Update()" は第二引数が
   "keys" 属性を持たない場合にキー/値ペアのシーケンスを反復することは
   ありません。成功した場合には "0" を返し、例外が送出された場合には
   "-1" を返します。

int PyDict_MergeFromSeq2(PyObject *a, PyObject *seq2, int override)
    * 次に属します: Stable ABI.*

   *seq2* 内のキー/値ペアを使って、辞書 *a* の内容を更新したり統合した
   りします。*seq2* は、キー/値のペアとみなせる長さ 2 の反復可能オブジ
   ェクト(iterable object) を生成する反復可能オブジェクトでなければな
   りません。重複するキーが存在する場合、*override* が真ならば先に出現
   したキーを使い、そうでない場合は後に出現したキーを使います。成功し
   た場合には "0" を返し、例外が送出された場合には "-1" を返します。(
   戻り値以外は) 等価な Python コードを書くと、以下のようになります:

      def PyDict_MergeFromSeq2(a, seq2, override):
          for key, value in seq2:
              if override or key not in a:
                  a[key] = value

int PyDict_AddWatcher(PyDict_WatchCallback callback)

   Register *callback* as a dictionary watcher. Return a non-negative
   integer id which must be passed to future calls to
   "PyDict_Watch()". In case of error (e.g. no more watcher IDs
   available), return "-1" and set an exception.

   Added in version 3.12.

int PyDict_ClearWatcher(int watcher_id)

   Clear watcher identified by *watcher_id* previously returned from
   "PyDict_AddWatcher()". Return "0" on success, "-1" on error (e.g.
   if the given *watcher_id* was never registered.)

   Added in version 3.12.

int PyDict_Watch(int watcher_id, PyObject *dict)

   Mark dictionary *dict* as watched. The callback granted
   *watcher_id* by "PyDict_AddWatcher()" will be called when *dict* is
   modified or deallocated. Return "0" on success or "-1" on error.

   Added in version 3.12.

int PyDict_Unwatch(int watcher_id, PyObject *dict)

   Mark dictionary *dict* as no longer watched. The callback granted
   *watcher_id* by "PyDict_AddWatcher()" will no longer be called when
   *dict* is modified or deallocated. The dict must previously have
   been watched by this watcher. Return "0" on success or "-1" on
   error.

   Added in version 3.12.

type PyDict_WatchEvent

   Enumeration of possible dictionary watcher events:
   "PyDict_EVENT_ADDED", "PyDict_EVENT_MODIFIED",
   "PyDict_EVENT_DELETED", "PyDict_EVENT_CLONED",
   "PyDict_EVENT_CLEARED", or "PyDict_EVENT_DEALLOCATED".

   Added in version 3.12.

typedef int (*PyDict_WatchCallback)(PyDict_WatchEvent event, PyObject *dict, PyObject *key, PyObject *new_value)

   Type of a dict watcher callback function.

   If *event* is "PyDict_EVENT_CLEARED" or "PyDict_EVENT_DEALLOCATED",
   both *key* and *new_value* will be "NULL". If *event* is
   "PyDict_EVENT_ADDED" or "PyDict_EVENT_MODIFIED", *new_value* will
   be the new value for *key*. If *event* is "PyDict_EVENT_DELETED",
   *key* is being deleted from the dictionary and *new_value* will be
   "NULL".

   "PyDict_EVENT_CLONED" occurs when *dict* was previously empty and
   another dict is merged into it. To maintain efficiency of this
   operation, per-key "PyDict_EVENT_ADDED" events are not issued in
   this case; instead a single "PyDict_EVENT_CLONED" is issued, and
   *key* will be the source dictionary.

   The callback may inspect but must not modify *dict*; doing so could
   have unpredictable effects, including infinite recursion. Do not
   trigger Python code execution in the callback, as it could modify
   the dict as a side effect.

   If *event* is "PyDict_EVENT_DEALLOCATED", taking a new reference in
   the callback to the about-to-be-destroyed dictionary will resurrect
   it and prevent it from being freed at this time. When the
   resurrected object is destroyed later, any watcher callbacks active
   at that time will be called again.

   Callbacks occur before the notified modification to *dict* takes
   place, so the prior state of *dict* can be inspected.

   If the callback sets an exception, it must return "-1"; this
   exception will be printed as an unraisable exception using
   "PyErr_WriteUnraisable()". Otherwise it should return "0".

   There may already be a pending exception set on entry to the
   callback. In this case, the callback should return "0" with the
   same exception still set. This means the callback may not call any
   other API that can set an exception unless it saves and clears the
   exception state first, and restores it before returning.

   Added in version 3.12.
