シーケンス型プロトコル (sequence protocol)
******************************************

int PySequence_Check(PyObject *o)

   オブジェクトがシーケンス型プロトコルを提供している場合に "1" を返し
   、そうでないときには "0" を返します。この関数呼び出しは常に成功しま
   す。

Py_ssize_t PySequence_Size(PyObject *o)
Py_ssize_t PySequence_Length(PyObject *o)

   Returns the number of objects in sequence *o* on success, and "-1"
   on failure.  This is equivalent to the Python expression "len(o)".

   バージョン 2.5 で変更: これらの関数は以前は "int" を返していました
   。この変更により、 64bit システムを正しくサポートするには修正が必要
   になります。

PyObject* PySequence_Concat(PyObject *o1, PyObject *o2)
    *Return value: New reference.*

   成功すると *o1* と *o2* の連結 (concatenation) を返し、失敗すると
   *NULL* を返します。Python の式 "o1 + o2" と同じです。

PyObject* PySequence_Repeat(PyObject *o, Py_ssize_t count)
    *Return value: New reference.*

   成功するとオブジェクト *o* の *count* 回繰り返しを返し、失敗すると
   *NULL* を返します。Python の式 "o * count" と同じです。

   バージョン 2.5 で変更: この関数は以前は *count* の型に "int" を利用
   していました。この変更により、 64bit システムを正しくサポートするに
   は修正が必要になります。

PyObject* PySequence_InPlaceConcat(PyObject *o1, PyObject *o2)
    *Return value: New reference.*

   成功すると *o1* と *o2* の連結 (concatenation) を返し、失敗すると
   *NULL* を返します。*o1* が *in-place* 演算をサポートする場合、in-
   place 演算を行います。Python の式 "o1 += o2" と同じです。

PyObject* PySequence_InPlaceRepeat(PyObject *o, Py_ssize_t count)
    *Return value: New reference.*

   成功するとオブジェクト *o* の *count* 回繰り返しを返し、失敗すると
   *NULL* を返します。*o* が *in-place* 演算をサポートする場合、in-
   place 演算を行います。Python の式 "o *= count" と同じです。

   バージョン 2.5 で変更: この関数は以前は *count* の型に "int" を利用
   していました。この変更により、 64bit システムを正しくサポートするに
   は修正が必要になります。

PyObject* PySequence_GetItem(PyObject *o, Py_ssize_t i)
    *Return value: New reference.*

   成功すると *o* の *i* 番目の要素を返し、失敗すると *NULL* を返しま
   す。Python の式 "o[i]" と同じです。

   バージョン 2.5 で変更: この関数は以前は *i* の型に "int" を利用して
   いました。この変更により、 64bit システムを正しくサポートするには修
   正が必要になります。

PyObject* PySequence_GetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2)
    *Return value: New reference.*

   成功すると *o* の *i1* から *i2* までの間のスライスを返し、失敗する
   と *NULL* を返します。Python の式 "o[i1:i2]" と同じです。

   バージョン 2.5 で変更: この関数は以前は *i1*, *i2* の型に "int" を
   利用していました。この変更により、 64bit システムを正しくサポートす
   るには修正が必要になります。

int PySequence_SetItem(PyObject *o, Py_ssize_t i, PyObject *v)

   *o* の *i* 番目の要素に *v* を代入します。 失敗すると、例外を送出し
   "-1" を返します; 成功すると "0" を返します。 これは Python の文
   "o[i] = v" と同じです。 この関数は *v* への参照を *盗み取りません*
   。

   *v* が *NULL* の場合はその要素が削除されますが、この機能は非推奨で
   あり、 "PyObject_DelAttr()" を使うのが望ましいです。

   バージョン 2.5 で変更: この関数は以前は *i* の型に "int" を利用して
   いました。この変更により、 64bit システムを正しくサポートするには修
   正が必要になります。

int PySequence_DelItem(PyObject *o, Py_ssize_t i)

   *o* の *i* 番目の要素を削除します。失敗すると "-1" を返します。
   Python の文 "del o[i]" と同じです。

   バージョン 2.5 で変更: この関数は以前は *i* の型に "int" を利用して
   いました。この変更により、 64bit システムを正しくサポートするには修
   正が必要になります。

int PySequence_SetSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2, PyObject *v)

   シーケンスオブジェクト *o* の *i1* から *i2* までのスライスに、シー
   ケンスオブジェクト *v* を代入します。 失敗すると例外を送出し "-1"
   を返します; 成功すると "0" を返します。 これは Python の文
   "o[i1:i2] = v" と同じです。

   *v* が *NULL* の場合はスライスは削除されますが、この機能は非推奨で
   あり "PySequence_DelSlice()" を使うのが望ましいです。

   バージョン 2.5 で変更: この関数は以前は *i1*, *i2* の型に "int" を
   利用していました。この変更により、 64bit システムを正しくサポートす
   るには修正が必要になります。

int PySequence_DelSlice(PyObject *o, Py_ssize_t i1, Py_ssize_t i2)

   シーケンスオブジェクト *o* の *i1* から *i2* までの間のスライスを削
   除します。失敗すると "-1" を返します。Python の文 "del o[i1:i2]" と
   同じです。

   バージョン 2.5 で変更: この関数は以前は *i1*, *i2* の型に "int" を
   利用していました。この変更により、 64bit システムを正しくサポートす
   るには修正が必要になります。

Py_ssize_t PySequence_Count(PyObject *o, PyObject *value)

   *o* における *value* の出現回数、すなわち  "o[key] == value" となる
   *key* の個数を返します。失敗すると "-1" を返します。Python の式
   "o.count(value)" と同じです。

   バージョン 2.5 で変更: この関数は以前は "int" を返していました。こ
   の変更により、 64 bit システムを正しくサポートするには修正が必要に
   なります。

int PySequence_Contains(PyObject *o, PyObject *value)

   *o* に *value* が入っているか判定します。*o* のある要素が *value*
   と等価 (equal) ならば "1" を返し、それ以外の場合には "0" を返します
   。エラーが発生すると "-1" を返します。Python の式 "value in o" と同
   じです。

Py_ssize_t PySequence_Index(PyObject *o, PyObject *value)

   "o[i] == value" となる最初に見つかったインデクス *i* を返します。エ
   ラーが発生すると "-1" を返します。Python の式 "o.index(value)" と同
   じです。

   バージョン 2.5 で変更: この関数は以前は "int" を返していました。こ
   の変更により、 64 bit システムを正しくサポートするには修正が必要に
   なります。

PyObject* PySequence_List(PyObject *o)
    *Return value: New reference.*

   任意のシーケンス *o* と同じ内容を持つリストオブジェクトを返します。
   返されるリストは必ず新しいリストオブジェクトになります。

PyObject* PySequence_Tuple(PyObject *o)
    *Return value: New reference.*

   任意のシーケンス *o* と同じ内容を持つタプルオブジェクトを返します。
   失敗したら *NULL* を返します。*o* がタプルの場合、新たな参照を返し
   ます。それ以外の場合、適切な内容が入ったタプルを構築して返します。
   Pythonの式 "tuple(o)" と同じです。

PyObject* PySequence_Fast(PyObject *o, const char *m)
    *Return value: New reference.*

   シーケンス *o* がすでにタプルやリストであれば *o* を返し、そうでな
   ければ *o* をタプルで返します。返されるタプルのメンバにアクセスする
   には "PySequence_Fast_GET_ITEM()" を使ってください。失敗すると
   *NULL* を返します。オブジェクトがシーケンスでなければ、 *m* がメッ
   セージテキストになっている "TypeError" を送出します。

PyObject* PySequence_Fast_GET_ITEM(PyObject *o, Py_ssize_t i)
    *Return value: Borrowed reference.*

   *o* が *NULL* でなく、 "PySequence_Fast()" が返したオブジェクトであ
   り、かつ *i* がインデクスの範囲内にあると仮定して、 *o* の *i* 番目
   の要素を返します。

   バージョン 2.5 で変更: この関数は以前は *i* の型に "int" を利用して
   いました。この変更により、 64bit システムを正しくサポートするには修
   正が必要になります。

PyObject** PySequence_Fast_ITEMS(PyObject *o)

   PyObject ポインタの背後にあるアレイを返します。この関数では、 *o*
   は "PySequence_Fast()" の返したオブジェクトであり、 *NULL* でないも
   のと仮定しています。

   リストのサイズが変更されるとき、メモリ再確保が要素の配列を再配置す
   るかもしれないことに注意してください。そのため、シーケンスの変更が
   発生しないコンテキストでのみ背後にあるポインタを使ってください。

   バージョン 2.4 で追加.

PyObject* PySequence_ITEM(PyObject *o, Py_ssize_t i)
    *Return value: New reference.*

   成功すると *o* の *i* 番目の要素を返し、失敗すると *NULL* を返しま
   す。 "PySequence_GetItem()" ですが、 *o* への "PySequence_Check()"
   が真になるかチェックせず、負のインデクスに対する調整を行いません。

   バージョン 2.3 で追加.

   バージョン 2.5 で変更: この関数は以前は *i* の型に "int" を利用して
   いました。この変更により、 64bit システムを正しくサポートするには修
   正が必要になります。

Py_ssize_t PySequence_Fast_GET_SIZE(PyObject *o)

   *o* が *NULL* でなく、 "PySequence_Fast()" が返したオブジェクトであ
   ると仮定して、 *o* の長さを返します。 *o* のサイズは
   "PySequence_Size()" を呼び出しても得られますが、
   "PySequence_Fast_GET_SIZE()" の方が *o* をリストかタプルであると仮
   定して処理するため、より高速です。
