# 辞書オブジェクト (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 an attached thread state 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();

  注釈

  On the free-threaded build, this function can be used safely inside a critical section. However, the references returned for pkey and pvalue are borrowed and are only valid while the critical section is held. If you need to use these objects outside the critical section or when the critical section can be suspended, create a strong reference (for example, using `Py_NewRef()`).

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.