객체 프로토콜
*************

PyObject *Py_GetConstant(unsigned int constant_id)
    * Part of the 안정 ABI 버전 3.13 이후로.*

   Get a *strong reference* to a constant.

   Set an exception and return "NULL" if *constant_id* is invalid.

   *constant_id* must be one of these constant identifiers:

   +------------------------------------------+-------+---------------------------+
   | Constant Identifier                      | Value | Returned object           |
   |==========================================|=======|===========================|
   | Py_CONSTANT_NONE                         | "0"   | "None"                    |
   +------------------------------------------+-------+---------------------------+
   | Py_CONSTANT_FALSE                        | "1"   | "False"                   |
   +------------------------------------------+-------+---------------------------+
   | Py_CONSTANT_TRUE                         | "2"   | "True"                    |
   +------------------------------------------+-------+---------------------------+
   | Py_CONSTANT_ELLIPSIS                     | "3"   | "Ellipsis"                |
   +------------------------------------------+-------+---------------------------+
   | Py_CONSTANT_NOT_IMPLEMENTED              | "4"   | "NotImplemented"          |
   +------------------------------------------+-------+---------------------------+
   | Py_CONSTANT_ZERO                         | "5"   | "0"                       |
   +------------------------------------------+-------+---------------------------+
   | Py_CONSTANT_ONE                          | "6"   | "1"                       |
   +------------------------------------------+-------+---------------------------+
   | Py_CONSTANT_EMPTY_STR                    | "7"   | "''"                      |
   +------------------------------------------+-------+---------------------------+
   | Py_CONSTANT_EMPTY_BYTES                  | "8"   | "b''"                     |
   +------------------------------------------+-------+---------------------------+
   | Py_CONSTANT_EMPTY_TUPLE                  | "9"   | "()"                      |
   +------------------------------------------+-------+---------------------------+

   Numeric values are only given for projects which cannot use the
   constant identifiers.

   Added in version 3.13.

   **CPython 구현 상세:** In CPython, all of these constants are
   *immortal*.

PyObject *Py_GetConstantBorrowed(unsigned int constant_id)
    * Part of the 안정 ABI 버전 3.13 이후로.*

   Similar to "Py_GetConstant()", but return a *borrowed reference*.

   This function is primarily intended for backwards compatibility:
   using "Py_GetConstant()" is recommended for new code.

   The reference is borrowed from the interpreter, and is valid until
   the interpreter finalization.

   Added in version 3.13.

PyObject *Py_NotImplemented

   지정된 형 조합에 대해 연산이 구현되지 않았음을 알리는 데 사용되는
   "NotImplemented" 싱글톤.

Py_RETURN_NOTIMPLEMENTED

   C 함수 내에서 "Py_NotImplemented" 반환을 올바르게 처리합니다 (즉,
   "NotImplemented"에 대한 새로운 *강한 참조*를 만들고 반환합니다).

Py_PRINT_RAW

   Flag to be used with multiple functions that print the object (like
   "PyObject_Print()" and "PyFile_WriteObject()"). If passed, these
   functions use the "str()" of the object instead of the "repr()".

int PyObject_Print(PyObject *o, FILE *fp, int flags)

   파일 *fp*에 객체 *o*를 인쇄합니다. 에러 시 "-1"을 반환합니다. flags
   인자는 특정 인쇄 옵션을 활성화하는 데 사용됩니다. 현재 지원되는 유
   일한 옵션은 "Py_PRINT_RAW"입니다; 주어지면, "repr()" 대신 객체의
   "str()"이 기록됩니다.

int PyObject_HasAttrWithError(PyObject *o, PyObject *attr_name)
    * Part of the 안정 ABI 버전 3.13 이후로.*

   *o*에 *attr_name* 어트리뷰트가 있으면 "1"을, 그렇지 않으면 "0"을 반
   환합니다. 이것은 파이썬 표현식 "hasattr(o, attr_name)"과 동등합니다
   . 실패하면, "-1"을 반환합니다.

   Added in version 3.13.

int PyObject_HasAttrStringWithError(PyObject *o, const char *attr_name)
    * Part of the 안정 ABI 버전 3.13 이후로.*

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

   Added in version 3.13.

int PyObject_HasAttr(PyObject *o, PyObject *attr_name)
    * Part of the 안정 ABI.*

   *o*에 *attr_name* 어트리뷰트가 있으면 "1"을, 그렇지 않으면 "0"을 반
   환합니다. 이 함수는 항상 성공합니다.

   참고:

     Exceptions that occur when this calls "__getattr__()" and
     "__getattribute__()" methods aren't propagated, but instead given
     to "sys.unraisablehook()". For proper error handling, use
     "PyObject_HasAttrWithError()", "PyObject_GetOptionalAttr()" or
     "PyObject_GetAttr()" instead.

int PyObject_HasAttrString(PyObject *o, const char *attr_name)
    * Part of the 안정 ABI.*

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

   참고:

     "__getattr__()"과 "__getattribute__()" 메서드를 호출할 때나 임시
     "str" 객체를 만드는 중에 발생하는 예외는 조용히 무시됩니다. 적절
     한 에러 처리를 위해서는, 대신
     "PyObject_HasAttrStringWithError()",
     "PyObject_GetOptionalAttrString()" 또는
     "PyObject_GetAttrString()"을 사용하십시오.

PyObject *PyObject_GetAttr(PyObject *o, PyObject *attr_name)
    *반환값: 새 참조.** Part of the 안정 ABI.*

   객체 *o*에서 *attr_name*이라는 이름의 어트리뷰트를 가져옵니다. 성공
   하면 어트리뷰트 값을, 실패하면 "NULL"을 반환합니다. 이것은 파이썬
   표현식 "o.attr_name"과 동등합니다.

   If the missing attribute should not be treated as a failure, you
   can use "PyObject_GetOptionalAttr()" instead.

PyObject *PyObject_GetAttrString(PyObject *o, const char *attr_name)
    *반환값: 새 참조.** Part of the 안정 ABI.*

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

   If the missing attribute should not be treated as a failure, you
   can use "PyObject_GetOptionalAttrString()" instead.

int PyObject_GetOptionalAttr(PyObject *obj, PyObject *attr_name, PyObject **result);
    * Part of the 안정 ABI 버전 3.13 이후로.*

   Variant of "PyObject_GetAttr()" which doesn't raise
   "AttributeError" if the attribute is not found.

   If the attribute is found, return "1" and set **result* to a new
   *strong reference* to the attribute. If the attribute is not found,
   return "0" and set **result* to "NULL"; the "AttributeError" is
   silenced. If an error other than "AttributeError" is raised, return
   "-1" and set **result* to "NULL".

   Added in version 3.13.

int PyObject_GetOptionalAttrString(PyObject *obj, const char *attr_name, PyObject **result);
    * Part of the 안정 ABI 버전 3.13 이후로.*

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

   Added in version 3.13.

PyObject *PyObject_GenericGetAttr(PyObject *o, PyObject *name)
    *반환값: 새 참조.** Part of the 안정 ABI.*

   형 객체의 "tp_getattro" 슬롯에 배치되는 일반 어트리뷰트 게터
   (getter) 함수. 객체의 (있다면) "__dict__"에 있는 어트리뷰트뿐만 아
   니라 객체의 MRO에 있는 클래스의 딕셔너리에 있는 디스크립터를 찾습니
   다. 디스크립터 구현하기에 요약된 것처럼, 데이터 디스크립터는 인스턴
   스 어트리뷰트보다 우선하지만, 비 데이터 디스크립터는 그렇지 않습니
   다. 그렇지 않으면, "AttributeError"가 발생합니다.

int PyObject_SetAttr(PyObject *o, PyObject *attr_name, PyObject *v)
    * Part of the 안정 ABI.*

   객체 *o*에 대해, *attr_name*이라는 이름의 어트리뷰트 값을 *v* 값으
   로 설정합니다. 실패 시 예외를 발생시키고 "-1"을 반환합니다. 성공하
   면 "0"을 반환합니다. 이것은 파이썬 문장 "o.attr_name = v"와 동등합
   니다.

   *v*가 "NULL"이면, 어트리뷰트가 삭제됩니다. 이 동작은 폐지되었고
   "PyObject_DelAttr()"로 대체되었습니다만, 현재 제거할 계획이 없습니
   다.

int PyObject_SetAttrString(PyObject *o, const char *attr_name, PyObject *v)
    * Part of the 안정 ABI.*

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

   *v*가 "NULL"이면, 어트리뷰트가 삭제되지만, 이 기능은 폐지되었고
   "PyObject_DelAttrString()"으로 대체되었습니다.

   The number of different attribute names passed to this function
   should be kept small, usually by using a statically allocated
   string as *attr_name*. For attribute names that aren't known at
   compile time, prefer calling "PyUnicode_FromString()" and
   "PyObject_SetAttr()" directly. For more details, see
   "PyUnicode_InternFromString()", which may be used internally to
   create a key object.

int PyObject_GenericSetAttr(PyObject *o, PyObject *name, PyObject *value)
    * Part of the 안정 ABI.*

   형 객체의 "tp_setattro" 슬롯에 배치되는 일반 어트리뷰트 세터
   (setter)와 딜리터(deleter) 함수. 객체의 MRO에 있는 클래스의 딕셔너
   리에서 데이터 디스크립터를 찾고, 발견되면 인스턴스 딕셔너리에 있는
   어트리뷰트를 설정하거나 삭제하는 것보다 우선합니다. 그렇지 않으면,
   객체의 (있다면) "__dict__"에서 어트리뷰트가 설정되거나 삭제됩니다.
   성공하면 "0"이 반환되고, 그렇지 않으면 "AttributeError"가 발생하고
   "-1"이 반환됩니다.

int PyObject_DelAttr(PyObject *o, PyObject *attr_name)
    * Part of the 안정 ABI 버전 3.13 이후로.*

   객체 *o*에 대해, *attr_name*이라는 이름의 어트리뷰트를 삭제합니다.
   실패 시 "-1"을 반환합니다. 이것은 파이썬 문장 "del o.attr_name"과
   동등합니다.

int PyObject_DelAttrString(PyObject *o, const char *attr_name)
    * Part of the 안정 ABI 버전 3.13 이후로.*

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

   The number of different attribute names passed to this function
   should be kept small, usually by using a statically allocated
   string as *attr_name*. For attribute names that aren't known at
   compile time, prefer calling "PyUnicode_FromString()" and
   "PyObject_DelAttr()" directly. For more details, see
   "PyUnicode_InternFromString()", which may be used internally to
   create a key object for lookup.

PyObject *PyObject_GenericGetDict(PyObject *o, void *context)
    *반환값: 새 참조.** Part of the 안정 ABI 버전 3.10 이후로.*

   "__dict__" 디스크립터의 게터(getter)를 위한 일반적인 구현. 필요하면
   딕셔너리를 만듭니다.

   This function may also be called to get the "__dict__" of the
   object *o*. Pass "NULL" for *context* when calling it. Since this
   function may need to allocate memory for the dictionary, it may be
   more efficient to call "PyObject_GetAttr()" when accessing an
   attribute on the object.

   On failure, returns "NULL" with an exception set.

   Added in version 3.3.

int PyObject_GenericSetDict(PyObject *o, PyObject *value, void *context)
    * Part of the 안정 ABI 버전 3.7 이후로.*

   "__dict__" 디스크립터의 세터(setter)를 위한 일반적인 구현. 이 구현
   은 딕셔너리 삭제를 허락하지 않습니다.

   Added in version 3.3.

PyObject **_PyObject_GetDictPtr(PyObject *obj)

   Return a pointer to "__dict__" of the object *obj*. If there is no
   "__dict__", return "NULL" without setting an exception.

   This function may need to allocate memory for the dictionary, so it
   may be more efficient to call "PyObject_GetAttr()" when accessing
   an attribute on the object.

PyObject *PyObject_RichCompare(PyObject *o1, PyObject *o2, int opid)
    *반환값: 새 참조.** Part of the 안정 ABI.*

   *opid*에 의해 지정된 연산을 사용하여 *o1*과 *o2*의 값을 비교합니다.
   *opid*는 "Py_LT", "Py_LE", "Py_EQ", "Py_NE", "Py_GT" 또는 "Py_GE"
   중 하나여야 하고 각각 "<", "<=", "==", "!=", ">" 또는 ">="에 해당합
   니다. 이는 파이썬 표현식 "o1 op o2"와 동등합니다. 여기서 "op"는
   *opid*에 해당하는 연산자입니다. 성공 시 비교 값을, 실패 시 "NULL"을
   반환합니다.

int PyObject_RichCompareBool(PyObject *o1, PyObject *o2, int opid)
    * Part of the 안정 ABI.*

   Compare the values of *o1* and *o2* using the operation specified
   by *opid*, like "PyObject_RichCompare()", but returns "-1" on
   error, "0" if the result is false, "1" otherwise.

참고:

  *o1*과 *o2*가 같은 객체이면, "PyObject_RichCompareBool()" 은 항상
  "Py_EQ"의 경우는 "1"을, "Py_NE"의 경우는 "0"을 반환합니다.

PyObject *PyObject_Format(PyObject *obj, PyObject *format_spec)
    * Part of the 안정 ABI.*

   Format *obj* using *format_spec*. This is equivalent to the Python
   expression "format(obj, format_spec)".

   *format_spec* may be "NULL". In this case the call is equivalent to
   "format(obj)". Returns the formatted string on success, "NULL" on
   failure.

PyObject *PyObject_Repr(PyObject *o)
    *반환값: 새 참조.** Part of the 안정 ABI.*

   객체 *o*의 문자열 표현을 계산합니다. 성공하면 문자열 표현을, 실패하
   면 "NULL"을 반환합니다. 이것은 파이썬 표현식 "repr(o)"와 동등합니다
   . "repr()" 내장 함수에 의해 호출됩니다.

   버전 3.4에서 변경: 이 함수에는 이제 디버그 어서션이 포함되어 있어
   활성 예외를 조용히 버리지 않도록 합니다.

PyObject *PyObject_ASCII(PyObject *o)
    *반환값: 새 참조.** Part of the 안정 ABI.*

   "PyObject_Repr()"처럼, 객체 *o*의 문자열 표현을 계산하지만, "\x",
   "\u" 또는 "\U" 이스케이프를 사용하여 "PyObject_Repr()"이 반환한 문
   자열에서 비 ASCII 문자를 이스케이프 합니다. 이것은 파이썬 2에서
   "PyObject_Repr()"에 의해 반환된 것과 유사한 문자열을 생성합니다.
   "ascii()" 내장 함수에 의해 호출됩니다.

PyObject *PyObject_Str(PyObject *o)
    *반환값: 새 참조.** Part of the 안정 ABI.*

   객체 *o*의 문자열 표현을 계산합니다. 성공 시 문자열 표현을, 실패 시
   "NULL"을 반환합니다. 이것은 파이썬 표현식 "str(o)"와 동등합니다.
   "str()" 내장 함수에 의해, 따라서 "print()" 함수에 의해서도 호출됩니
   다.

   버전 3.4에서 변경: 이 함수에는 이제 디버그 어서션이 포함되어 있어
   활성 예외를 조용히 버리지 않도록 합니다.

PyObject *PyObject_Bytes(PyObject *o)
    *반환값: 새 참조.** Part of the 안정 ABI.*

   객체 *o*의 바이트열 표현을 계산합니다. 실패하면 "NULL"을, 성공하면
   바이트열 객체를 반환됩니다. 이는 *o*가 정수가 아닐 때 파이썬 표현식
   "bytes(o)"와 동등합니다. "bytes(o)"와 달리, *o*가 정수이면 0으로 초
   기화된 바이트열 객체 대신 TypeError가 발생합니다.

int PyObject_IsSubclass(PyObject *derived, PyObject *cls)
    * Part of the 안정 ABI.*

   클래스 *derived*가 클래스 *cls*와 동일하거나 *cls*에서 파생되었으면
   "1"을 반환하고, 그렇지 않으면 "0"을 반환합니다. 에러가 발생하면
   "-1"을 반환합니다.

   *cls*가 튜플이면, *cls*의 모든 항목에 대해 검사가 수행됩니다. 적어
   도 하나의 검사에서 "1"을 반환하면 결과는 "1"이 되고, 그렇지 않으면
   "0"이 됩니다.

   *cls*에 "__subclasscheck__()" 메서드가 있으면, **PEP 3119**에 설명
   된 대로 서브 클래스 상태를 판별하기 위해 호출됩니다. 그렇지 않으면,
   *derived*가 직접 또는 간접 서브 클래스일 때 *cls*의 서브 클래스입니
   다, 즉 "cls.__mro__"에 포함되어 있습니다.

   일반적으로 클래스 객체(즉 "type"이나 파생 클래스의 인스턴스)만 클래
   스로 간주합니다. 그러나, 객체는 "__bases__" 어트리뷰트(베이스 클래
   스의 튜플이어야 합니다)를 가짐으로써 이를 재정의할 수 있습니다.

int PyObject_IsInstance(PyObject *inst, PyObject *cls)
    * Part of the 안정 ABI.*

   *inst*가 *cls* 클래스나 *cls*의 서브 클래스의 인스턴스이면 "1"을 반
   환하고, 그렇지 않으면 "0"을 반환합니다. 에러가 발생하면 "-1"을 반환
   하고 예외를 설정합니다.

   *cls*가 튜플이면, *cls*의 모든 항목에 대해 검사가 수행됩니다. 적어
   도 하나의 검사에서 "1"을 반환하면 결과는 "1"이 되고, 그렇지 않으면
   "0"이 됩니다.

   *cls*에 "__instancecheck__()" 메서드가 있으면, **PEP 3119**에 설명
   된 대로 서브 클래스 상태를 판별하기 위해 호출됩니다. 그렇지 않으면,
   *inst*는 해당 클래스가 *cls*의 서브 클래스일 때 *cls*의 인스턴스입
   니다.

   인스턴스 *inst*는 "__class__" 어트리뷰트를 가짐으로써 클래스로 간주
   하는 것을 재정의할 수 있습니다.

   객체 *cls*는 "__bases__" 어트리뷰트(베이스 클래스의 튜플이어야 합니
   다)를 가짐으로써, 클래스로 간주하는지와 베이스 클래스가 무엇인지를
   재정의할 수 있습니다.

Py_hash_t PyObject_Hash(PyObject *o)
    * Part of the 안정 ABI.*

   객체 *o*의 해시값을 계산하고 반환합니다. 실패하면 "-1"을 반환합니다
   . 이것은 파이썬 표현식 "hash(o)"와 동등합니다.

   버전 3.2에서 변경: 반환형은 이제 Py_hash_t입니다. 이것은
   "Py_ssize_t"와 같은 크기의 부호 있는 정수입니다.

Py_hash_t PyObject_HashNotImplemented(PyObject *o)
    * Part of the 안정 ABI.*

   "type(o)"가 *해시 가능*하지 않음을 나타내는 "TypeError"를 설정하고
   "-1"을 반환합니다. 이 함수는 "tp_hash" 슬롯에 저장될 때 특수한 처방
   을 받아서, 인터프리터에 형이 해시 가능하지 않음을 명시적으로 알립니
   다.

int PyObject_IsTrue(PyObject *o)
    * Part of the 안정 ABI.*

   객체 *o*를 참으로 간주하면 "1"을, 그렇지 않으면 "0"을 반환합니다.
   이것은 파이썬 표현식 "not not o"와 동등합니다. 실패하면 "-1"을 반환
   합니다.

int PyObject_Not(PyObject *o)
    * Part of the 안정 ABI.*

   객체 *o*를 참으로 간주하면 "0"을, 그렇지 않으면 "1"을 반환합니다.
   이것은 파이썬 표현식 "not o"와 동등합니다. 실패하면 "-1"을 반환합니
   다.

PyObject *PyObject_Type(PyObject *o)
    *반환값: 새 참조.** Part of the 안정 ABI.*

   *o*가 "NULL"이 아니면, 객체 *o*의 객체 형에 해당하는 형 객체를 반환
   합니다. 실패하면 "SystemError"를 발생시키고 "NULL"을 반환합니다. 이
   것은 파이썬 표현식 "type(o)"와 동등합니다. 이 함수는 반환 값에 대한
   새로운 *강한 참조*를 만듭니다. 새로운 *강한 참조*가 필요할 때를 제
   외하고, PyTypeObject* 형의 포인터를 반환하는 "Py_TYPE()" 함수 대신
   이 함수를 사용할 이유가 없습니다.

int PyObject_TypeCheck(PyObject *o, PyTypeObject *type)

   객체 *o*가 *type* 형이거나 *type*의 서브 형이면 0이 아닌 값을 반환
   하고, 그렇지 않으면 "0"을 반환합니다. 두 매개 변수 모두 "NULL"이 아
   니어야 합니다.

Py_ssize_t PyObject_Size(PyObject *o)
Py_ssize_t PyObject_Length(PyObject *o)
    * Part of the 안정 ABI.*

   객체 *o*의 길이를 반환합니다. 객체 *o*가 시퀀스와 매핑 프로토콜을
   제공하면, 시퀀스 길이가 반환됩니다. 에러가 발생하면 "-1"이 반환됩니
   다. 이것은 파이썬 표현식 "len(o)"와 동등합니다.

Py_ssize_t PyObject_LengthHint(PyObject *o, Py_ssize_t defaultvalue)

   *o* 객체의 추정된 길이를 반환합니다. 먼저 실제 길이를 반환하려고 시
   도한 다음, "__length_hint__()"를 사용하여 추정값을 반환하고, 마지막
   으로 기본값을 반환합니다. 에러 시 "-1"을 반환합니다. 이것은 파이썬
   표현식 "operator.length_hint(o, defaultvalue)"와 동등합니다.

   Added in version 3.4.

PyObject *PyObject_GetItem(PyObject *o, PyObject *key)
    *반환값: 새 참조.** Part of the 안정 ABI.*

   객체 *key*에 해당하는 *o*의 요소를 반환하거나 실패 시 "NULL"을 반환
   합니다. 이것은 파이썬 표현식 "o[key]"와 동등합니다.

int PyObject_SetItem(PyObject *o, PyObject *key, PyObject *v)
    * Part of the 안정 ABI.*

   객체 *key*를 값 *v*에 매핑합니다. 실패 시 예외를 발생시키고 "-1"을
   반환합니다; 성공하면 "0"을 반환합니다. 이것은 파이썬 문장 "o[key] =
   v"와 동등합니다. 이 함수는 *v*에 대한 참조를 훔치지 *않습니다*.

int PyObject_DelItem(PyObject *o, PyObject *key)
    * Part of the 안정 ABI.*

   객체 *o*에서 객체 *key*에 대한 매핑을 제거합니다. 실패하면 "-1"을
   반환합니다. 이것은 파이썬 문장 "del o[key]"와 동등합니다.

int PyObject_DelItemString(PyObject *o, const char *key)
    * Part of the 안정 ABI.*

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

PyObject *PyObject_Dir(PyObject *o)
    *반환값: 새 참조.** Part of the 안정 ABI.*

   이것은 파이썬 표현식 "dir(o)"와 동등하며, 객체 인자에 적합한 문자열
   의 (비어있을 수 있는) 리스트를 반환하거나, 에러가 있으면 "NULL"을
   반환합니다. 인자가 "NULL"이면, 파이썬 "dir()"과 비슷하며, 현재 지역
   (locals)의 이름들을 반환합니다; 이 경우, 실행 프레임이 활성화되어
   있지 않으면 "NULL"이 반환되지만 "PyErr_Occurred()"는 거짓을 반환합
   니다.

PyObject *PyObject_GetIter(PyObject *o)
    *반환값: 새 참조.** Part of the 안정 ABI.*

   이것은 파이썬 표현식 "iter(o)"와 동등합니다. 객체 인자에 대한 새로
   운 이터레이터를 반환하거나, 객체가 이미 이터레이터이면 객체 자체를
   반환합니다. 객체를 이터레이트 할 수 없으면 "TypeError"를 발생시키고
   "NULL"을 반환합니다.

PyObject *PyObject_SelfIter(PyObject *obj)
    *반환값: 새 참조.** Part of the 안정 ABI.*

   This is equivalent to the Python "__iter__(self): return self"
   method. It is intended for *iterator* types, to be used in the
   "PyTypeObject.tp_iter" slot.

PyObject *PyObject_GetAIter(PyObject *o)
    *반환값: 새 참조.** Part of the 안정 ABI 버전 3.10 이후로.*

   이것은 파이썬 표현식 "aiter(o)"와 동등합니다. "AsyncIterable"을 받
   아서 그 것의 "AsyncIterator"를 반환합니다. 보통 새 이터레이터이지만
   , 인자가 "AsyncIterator"면 그 자신을 반환합니다. 객체를 이터레이트
   할 수 없으면 "TypeError"를 발생시키고 "NULL"을 반환합니다.

   Added in version 3.10.

void *PyObject_GetTypeData(PyObject *o, PyTypeObject *cls)
    * Part of the 안정 ABI 버전 3.12 이후로.*

   Get a pointer to subclass-specific data reserved for *cls*.

   The object *o* must be an instance of *cls*, and *cls* must have
   been created using negative "PyType_Spec.basicsize". Python does
   not check this.

   On error, set an exception and return "NULL".

   Added in version 3.12.

Py_ssize_t PyType_GetTypeDataSize(PyTypeObject *cls)
    * Part of the 안정 ABI 버전 3.12 이후로.*

   Return the size of the instance memory space reserved for *cls*,
   i.e. the size of the memory "PyObject_GetTypeData()" returns.

   This may be larger than requested using "-PyType_Spec.basicsize";
   it is safe to use this larger size (e.g. with "memset()").

   The type *cls* **must** have been created using negative
   "PyType_Spec.basicsize". Python does not check this.

   On error, set an exception and return a negative value.

   Added in version 3.12.

void *PyObject_GetItemData(PyObject *o)

   Get a pointer to per-item data for a class with
   "Py_TPFLAGS_ITEMS_AT_END".

   On error, set an exception and return "NULL". "TypeError" is raised
   if *o* does not have "Py_TPFLAGS_ITEMS_AT_END" set.

   Added in version 3.12.

int PyObject_VisitManagedDict(PyObject *obj, visitproc visit, void *arg)

   Visit the managed dictionary of *obj*.

   This function must only be called in a traverse function of the
   type which has the "Py_TPFLAGS_MANAGED_DICT" flag set.

   Added in version 3.13.

void PyObject_ClearManagedDict(PyObject *obj)

   Clear the managed dictionary of *obj*.

   This function must only be called in a clear function of the type
   which has the "Py_TPFLAGS_MANAGED_DICT" flag set.

   Added in version 3.13.
