모듈 객체¶

PyTypeObject PyModule_Type¶: Part of the 안정 ABI.
This instance of PyTypeObject represents the Python module type. This is exposed to Python programs as types.ModuleType.

int PyModule_Check(PyObject *p)¶: p가 모듈 객체이거나 모듈 객체의 서브 형이면 참을 반환합니다. 이 함수는 항상 성공합니다.

int PyModule_CheckExact(PyObject *p)¶: p가 모듈 객체이지만, PyModule_Type의 서브 형이 아니면 참을 반환합니다. 이 함수는 항상 성공합니다.

PyObject *PyModule_NewObject(PyObject *name)¶

반환값: 새 참조. Part of the 안정 ABI 버전 3.7 이후로.

module.__name__이 name으로 설정된 새 모듈 객체를 반환합니다. 모듈의 __name__, __doc__, __package__ 및 __loader__ 어트리뷰트가 채워집니다 (__name__을 제외하고 모두 None으로 설정됩니다). __file__ 어트리뷰트를 설정하는 것은 호출자의 책임입니다.

Return NULL with an exception set on error.

Added in version 3.3.

버전 3.4에서 변경: __package__와 __loader__가 이제 None으로 설정됩니다.

PyObject *PyModule_New(const char *name)¶: 반환값: 새 참조. Part of the 안정 ABI.
PyModule_NewObject()와 비슷하지만, name이 유니코드 객체 대신 UTF-8로 인코딩된 문자열입니다.

PyObject *PyModule_GetDict(PyObject *module)¶

반환값: 빌린 참조. Part of the 안정 ABI.

module의 이름 공간을 구현하는 딕셔너리 객체를 반환합니다; 이 객체는 모듈 객체의 __dict__ 어트리뷰트와 같습니다. module이 모듈 객체(또는 모듈 객체의 서브 형)가 아니면, SystemError가 발생하고 NULL이 반환됩니다.

확장은 모듈의 __dict__를 직접 조작하지 말고 다른 PyModule_*과 PyObject_* 함수를 사용하는 것이 좋습니다.

The returned reference is borrowed from the module; it is valid until the module is destroyed.

PyObject *PyModule_GetNameObject(PyObject *module)¶: 반환값: 새 참조. Part of the 안정 ABI 버전 3.7 이후로.
module의 __name__ 값을 반환합니다. 모듈이 제공하지 않거나, 문자열이 아니면, SystemError가 발생하고 NULL이 반환됩니다.

Added in version 3.3.

const char *PyModule_GetName(PyObject *module)¶

Part of the 안정 ABI.

PyModule_GetNameObject()와 비슷하지만 'utf-8'로 인코딩된 이름을 반환합니다.

The returned buffer is only valid until the module is renamed or destroyed. Note that Python code may rename a module by setting its __name__ attribute.

PyModuleDef *PyModule_GetDef(PyObject *module)¶

Part of the 안정 ABI.

모듈이 만들어진 PyModuleDef 구조체에 대한 포인터나 모듈이 정의에서 만들어지지 않았으면 NULL을 반환합니다.

On error, return NULL with an exception set. Use PyErr_Occurred() to tell this case apart from a missing PyModuleDef.

PyObject *PyModule_GetFilenameObject(PyObject *module)¶: 반환값: 새 참조. Part of the 안정 ABI.
module의 __file__ 어트리뷰트를 사용하여 module이 로드된 파일 이름을 반환합니다. 정의되지 않았거나 문자열이 아니면, SystemError를 발생시키고 NULL을 반환합니다; 그렇지 않으면 유니코드 객체에 대한 참조를 반환합니다.

Added in version 3.2.

const char *PyModule_GetFilename(PyObject *module)¶

Part of the 안정 ABI.

PyModule_GetFilenameObject()와 비슷하지만 ‘utf-8’로 인코딩된 파일명을 반환합니다.

The returned buffer is only valid until the module’s __file__ attribute is reassigned or the module is destroyed.

버전 3.2부터 폐지됨: PyModule_GetFilename()은 인코딩할 수 없는 파일명에 대해 UnicodeEncodeError를 발생시킵니다, 대신 PyModule_GetFilenameObject()를 사용하십시오.

Module definition¶

Modules created using the C API are typically defined using an array of slots. The slots provide a “description” of how a module should be created.

버전 3.15.0a2 (unreleased)에서 변경: Previously, a PyModuleDef struct was necessary to define modules. The older way of defining modules is still available: consult either the Module definition struct section or earlier versions of this documentation if you plan to support earlier Python versions.

The slots array is usually used to define an extension module’s “main” module object (see Defining extension modules for details). It can also be used to create extension modules dynamically.

Unless specified otherwise, the same slot ID may not be repeated in an array of slots.

type PyModuleDef_Slot¶

Part of the 안정 ABI (including all members) 버전 3.5 이후로.

int slot¶

A slot ID, chosen from the available Py_mod_* values explained below.

An ID of 0 marks the end of a PyModuleDef_Slot array.

void *value¶

슬롯 ID에 따라 그 의미가 달라지는, 슬롯의 값.

The value may not be NULL. To leave a slot out, omit the PyModuleDef_Slot entry entirely.

Added in version 3.5.

Metadata slots¶

Py_mod_name¶

Part of the 안정 ABI 버전 3.15 이후로.

Slot ID for the name of the new module, as a NUL-terminated UTF8-encoded const char *.

Note that modules are typically created using a ModuleSpec, and when they are, the name from the spec will be used instead of Py_mod_name. However, it is still recommended to include this slot for introspection and debugging purposes.

Added in version 3.15.0a2 (unreleased): Use PyModuleDef.m_name instead to support previous versions.

Py_mod_doc¶

Part of the 안정 ABI 버전 3.15 이후로.

Slot ID for the docstring of the new module, as a NUL-terminated UTF8-encoded const char *.

Usually it is set to a variable created with PyDoc_STRVAR.

Added in version 3.15.0a2 (unreleased): Use PyModuleDef.m_doc instead to support previous versions.

Feature slots¶

Py_mod_abi¶

Part of the 안정 ABI 버전 3.15 이후로.

Slot ID whose value points to a PyABIInfo structure describing the ABI that the extension is using.

A suitable PyABIInfo variable can be defined using the PyABIInfo_VAR macro, as in:

PyABIInfo_VAR(abi_info);

static PyModuleDef_Slot mymodule_slots[] = {
   {Py_mod_abi, &abi_info},
   ...
};

When creating a module, Python checks the value of this slot using PyABIInfo_Check().

Added in version 3.15.

Py_mod_multiple_interpreters¶

Part of the 안정 ABI 버전 3.12 이후로.

Slot ID whose value is one of:

Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED¶: The module does not support being imported in subinterpreters.

Py_MOD_MULTIPLE_INTERPRETERS_SUPPORTED¶: The module supports being imported in subinterpreters, but only when they share the main interpreter’s GIL. (See Isolating Extension Modules.)

Py_MOD_PER_INTERPRETER_GIL_SUPPORTED¶: The module supports being imported in subinterpreters, even when they have their own GIL. (See Isolating Extension Modules.)

This slot determines whether or not importing this module in a subinterpreter will fail.

If Py_mod_multiple_interpreters is not specified, the import machinery defaults to Py_MOD_MULTIPLE_INTERPRETERS_SUPPORTED.

Added in version 3.12.

Py_mod_gil¶

Part of the 안정 ABI 버전 3.13 이후로.

Slot ID whose value is one of:

Py_MOD_GIL_USED¶: The module depends on the presence of the global interpreter lock (GIL), and may access global state without synchronization.

Py_MOD_GIL_NOT_USED¶: The module is safe to run without an active GIL.

This slot is ignored by Python builds not configured with --disable-gil. Otherwise, it determines whether or not importing this module will cause the GIL to be automatically enabled. See 제한 없는 스레드를 사용하는 파이썬(CPython) for more detail.

If Py_mod_gil is not specified, the import machinery defaults to Py_MOD_GIL_USED.

Added in version 3.13.

Creation and initialization slots¶

Py_mod_create¶

Part of the 안정 ABI 버전 3.5 이후로.

Slot ID for a function that creates the module object itself. The function must have the signature:

PyObject *create_module(PyObject *spec, PyModuleDef *def)¶

The function will be called with:

spec: a ModuleSpec-like object, meaning that any attributes defined for importlib.machinery.ModuleSpec have matching semantics. However, any of the attributes may be missing.
def: NULL, or the module definition if the module is created from one.

The function should return a new module object, or set an error and return NULL.

이 함수는 최소한으로 유지해야 합니다. 특히 같은 모듈을 다시 임포트 하려고 시도하면 무한 루프가 발생할 수 있어서, 임의의 파이썬 코드를 호출하면 안 됩니다.

Py_mod_create를 지정하지 않으면, 임포트 절차는 PyModule_New()를 사용하여 일반 모듈 객체를 만듭니다. 이름은 정의가 아니라 spec에서 취합니다, 확장 모듈이 단일 모듈 정의를 공유하면서 모듈 계층 구조에서 해당 위치에 동적으로 조정되고 심볼릭 링크를 통해 다른 이름으로 임포트 될 수 있도록 하기 위함입니다.

There is no requirement for the returned object to be an instance of PyModule_Type. However, some slots may only be used with PyModule_Type instances; in particular:

Py_mod_exec,
module state slots (Py_mod_state_*),
Py_mod_token.

Added in version 3.5.

버전 3.15.0a2 (unreleased)에서 변경: The slots argument may be a ModuleSpec-like object, rather than a true ModuleSpec instance. Note that previous versions of CPython did not enforce this.

The def argument may now be NULL, since modules are not necessarily made from definitions.

Py_mod_exec¶

Part of the 안정 ABI 버전 3.5 이후로.

Slot ID for a function that will execute, or initialize, the module. This function does the equivalent to executing the code of a Python module: typically, it adds classes and constants to the module. The signature of the function is:

int exec_module(PyObject *module)¶

See the 지원 함수 section for some useful functions to call.

For backwards compatibility, the PyModuleDef.m_slots array may contain multiple Py_mod_exec slots; these are processed in the order they appear in the array. Elsewhere (that is, in arguments to PyModule_FromSlotsAndSpec() and in return values of PyModExport_<name>), repeating the slot is not allowed.

Added in version 3.5.

버전 3.15.0a2 (unreleased)에서 변경: Repeated Py_mod_exec slots are disallowed, except in PyModuleDef.m_slots.

Py_mod_methods¶

Part of the 안정 ABI 버전 3.15 이후로.

Slot ID for a table of module-level functions, as an array of PyMethodDef values suitable as the functions argument to PyModule_AddFunctions().

Like other slot IDs, a slots array may only contain one Py_mod_methods entry. To add functions from multiple PyMethodDef arrays, call PyModule_AddFunctions() in the Py_mod_exec function.

The table must be statically allocated (or otherwise guaranteed to outlive the module object).

Added in version 3.15.0a2 (unreleased): Use PyModuleDef.m_methods instead to support previous versions.

Module state¶

Extension modules can have module state – a piece of memory that is allocated on module creation, and freed when the module object is deallocated. The module state is specified using dedicated slots.

A typical use of module state is storing an exception type – or indeed any type object defined by the module –

Unlike the module’s Python attributes, Python code cannot replace or delete data stored in module state.

Keeping per-module information in attributes and module state, rather than in static globals, makes module objects isolated and safer for use in multiple sub-interpreters. It also helps Python do an orderly clean-up when it shuts down.

Extensions that keep references to Python objects as part of module state must implement Py_mod_state_traverse and Py_mod_state_clear functions to avoid reference leaks.

To retrieve the state from a given module, use the following functions:

void *PyModule_GetState(PyObject *module)¶

Part of the 안정 ABI.

Return the “state” of the module, that is, a pointer to the block of memory allocated at module creation time, or NULL. See Py_mod_state_size.

On error, return NULL with an exception set. Use PyErr_Occurred() to tell this case apart from missing module state.

int PyModule_GetStateSize(PyObject*, Py_ssize_t *result)¶

Part of the 안정 ABI 버전 3.15 이후로.

Set *result to the size of the module’s state, as specified using Py_mod_state_size (or PyModuleDef.m_size), and return 0.

On error, set *result to -1, and return -1 with an exception set.

Added in version 3.15.0a2 (unreleased).

Slots for defining module state¶

The following PyModuleDef_Slot.slot IDs are available for defining the module state.

Py_mod_state_size¶

Part of the 안정 ABI 버전 3.15 이후로.

Slot ID for the size of the module state, in bytes.

Setting the value to a non-negative value means that the module can be re-initialized and specifies the additional amount of memory it requires for its state.

자세한 내용은 PEP 3121을 참조하십시오.

Use PyModule_GetStateSize() to retrieve the size of a given module.

Added in version 3.15.0a2 (unreleased): Use PyModuleDef.m_size instead to support previous versions.

Py_mod_state_traverse¶

Part of the 안정 ABI 버전 3.15 이후로.

Slot ID for a traversal function to call during GC traversal of the module object.

The signature of the function, and meanings of the arguments, is similar as for PyTypeObject.tp_traverse:

int traverse_module_state(PyObject *module, visitproc visit, void *arg)¶

This function is not called if the module state was requested but is not allocated yet. This is the case immediately after the module is created and before the module is executed (Py_mod_exec function). More precisely, this function is not called if the state size (Py_mod_state_size) is greater than 0 and the module state (as returned by PyModule_GetState()) is NULL.

Added in version 3.15.0a2 (unreleased): Use PyModuleDef.m_size instead to support previous versions.

Py_mod_state_clear¶

Part of the 안정 ABI 버전 3.15 이후로.

Slot ID for a clear function to call during GC clearing of the module object.

The signature of the function is:

int clear_module_state(PyObject *module)¶

This function is not called if the module state was requested but is not allocated yet. This is the case immediately after the module is created and before the module is executed (Py_mod_exec function). More precisely, this function is not called if the state size (Py_mod_state_size) is greater than 0 and the module state (as returned by PyModule_GetState()) is NULL.

Like PyTypeObject.tp_clear, this function is not always called before a module is deallocated. For example, when reference counting is enough to determine that an object is no longer used, the cyclic garbage collector is not involved and the Py_mod_state_free function is called directly.

Added in version 3.15.0a2 (unreleased): Use PyModuleDef.m_clear instead to support previous versions.

Py_mod_state_free¶

Part of the 안정 ABI 버전 3.15 이후로.

Slot ID for a function to call during deallocation of the module object.

The signature of the function is:

int free_module_state(PyObject *module)¶

This function is not called if the module state was requested but is not allocated yet. This is the case immediately after the module is created and before the module is executed (Py_mod_exec function). More precisely, this function is not called if the state size (Py_mod_state_size) is greater than 0 and the module state (as returned by PyModule_GetState()) is NULL.

Added in version 3.15.0a2 (unreleased): Use PyModuleDef.m_free instead to support previous versions.

Module token¶

Each module may have an associated token: a pointer-sized value intended to identify of the module state’s memory layout. This means that if you have a module object, but you are not sure if it “belongs” to your extension, you can check using code like this:

PyObject *module = <the module in question>

void *module_token;
if (PyModule_GetToken(module, &module_token) < 0) {
    return NULL;
}
if (module_token != your_token) {
    PyErr_SetString(PyExc_ValueError, "unexpected module")
    return NULL;
}

// This module's state has the expected memory layout; it's safe to cast
struct my_state state = (struct my_state*)PyModule_GetState(module)

A module’s token – and the your_token value to use in the above code – is:

For modules created with PyModuleDef: the address of that PyModuleDef;
For modules defined with the Py_mod_token slot: the value of that slot;
For modules created from an PyModExport_* export hook: the slots array that the export hook returned (unless overriden with Py_mod_token).

Py_mod_token¶

Part of the 안정 ABI 버전 3.15 이후로.

Slot ID for the module token.

If you use this slot to set the module token (rather than rely on the default), you must ensure that:

The pointer outlives the class, so it’s not reused for something else while the class exists.
It “belongs” to the extension module where the class lives, so it will not clash with other extensions.
If the token points to a PyModuleDef struct, the module should behave as if it was created from that PyModuleDef. In particular, the module state must have matching layout and semantics.

Modules created from PyModuleDef allways use the address of the PyModuleDef as the token. This means that Py_mod_token cannot be used in PyModuleDef.m_slots.

Added in version 3.15.0a2 (unreleased).

int PyModule_GetToken(PyObject *module, void **result)¶

Part of the 안정 ABI 버전 3.15 이후로.

Set *result to the module’s token and return 0.

On error, set *result to NULL, and return -1 with an exception set.

Added in version 3.15.0a2 (unreleased).

Creating extension modules dynamically¶

The following functions may be used to create an extension module dynamically, rather than from an extension’s export hook.

PyObject *PyModule_FromSlotsAndSpec(const PyModuleDef_Slot *slots, PyObject *spec)¶

반환값: 새 참조. Part of the 안정 ABI 버전 3.15 이후로.

Create a new module object, given an array of slots and the ModuleSpec spec.

The slots argument must point to an array of PyModuleDef_Slot structures, terminated by an entry slot with slot ID of 0 (typically written as {0} or {0, NULL} in C). The slots argument may not be NULL.

The spec argument may be any ModuleSpec-like object, as described in Py_mod_create documentation. Currently, the spec must have a name attribute.

On success, return the new module. On error, return NULL with an exception set.

Note that this does not process the module’s execution slot (Py_mod_exec). Both PyModule_FromSlotsAndSpec() and PyModule_Exec() must be called to fully initialize a module. (See also Multi-phase initialization.)

The slots array only needs to be valid for the duration of the PyModule_FromSlotsAndSpec() call. In particular, it may be heap-allocated.

Added in version 3.15.0a2 (unreleased).

int PyModule_Exec(PyObject *module)¶

Part of the 안정 ABI 버전 3.15 이후로.

Execute the Py_mod_exec slot(s) of the given module.

On success, return 0. On error, return -1 with an exception set.

For clarity: If module has no slots, for example if it uses legacy single-phase initialization, this function does nothing and returns 0.

Added in version 3.15.0a2 (unreleased).

Module definition struct¶

Traditionally, extension modules were defined using a module definition as the “description” of how a module should be created. Rather than using an array of slots directly, the definition has dedicated members for most common functionality, and allows additional slots as an extension mechanism.

This way of defining modules is still available and there are no plans to remove it.

type PyModuleDef¶

Part of the 안정 ABI (including all members).

The module definition struct, which holds information needed to create a module object.

This structure must be statically allocated (or be otherwise guaranteed to be valid while any modules created from it exist). Usually, there is only one variable of this type for each extension module defined this way.

PyModuleDef_Base m_base¶

Always initialize this member to PyModuleDef_HEAD_INIT:

type PyModuleDef_Base¶: Part of the 안정 ABI (including all members).
The type of PyModuleDef.m_base.

PyModuleDef_HEAD_INIT¶: The required initial value for PyModuleDef.m_base.

const char *m_name¶: Corresponds to the Py_mod_name slot.

const char *m_doc¶: These members correspond to the Py_mod_doc slot. Setting this to NULL is equivalent to omitting the slot.

Py_ssize_t m_size¶

Corresponds to the Py_mod_state_size slot. Setting this to zero is equivalent to omitting the slot.

When using legacy single-phase initialization or when creating modules dynamically using PyModule_Create() or PyModule_Create2(), m_size may be set to -1. This indicates that the module does not support sub-interpreters, because it has global state.

PyMethodDef *m_methods¶: Corresponds to the Py_mod_methods slot. Setting this to NULL is equivalent to omitting the slot.

PyModuleDef_Slot *m_slots¶

An array of additional slots, terminated by a {0, NULL} entry.

This array may not contain slots corresponding to PyModuleDef members. For example, you cannot use Py_mod_name in m_slots; the module name must be given as PyModuleDef.m_name.

버전 3.5에서 변경: 버전 3.5 이전에는, 이 멤버가 항상 NULL로 설정되었으며, 다음과 같이 정의되었습니다:

inquiry m_reload¶

traverseproc m_traverse¶

inquiry m_clear¶

freefunc m_free¶

These members correspond to the Py_mod_state_traverse, Py_mod_state_clear, and Py_mod_state_free slots, respectively.

Setting these members to NULL is equivalent to omitting the corresponding slots.

버전 3.9에서 변경: m_traverse, m_clear and m_free functions are longer called before the module state is allocated.

The following API can be used to create modules from a PyModuleDef struct:

PyObject *PyModule_Create(PyModuleDef *def)¶: 반환값: 새 참조.
Create a new module object, given the definition in def. This is a macro that calls PyModule_Create2() with module_api_version set to PYTHON_API_VERSION, or to PYTHON_ABI_VERSION if using the limited API.

PyObject *PyModule_Create2(PyModuleDef *def, int module_api_version)¶

반환값: 새 참조. Part of the 안정 ABI.

def의 정의에 따라, API 버전 module_api_version을 가정하여 새 모듈 객체를 만듭니다. 해당 버전이 실행 중인 인터프리터 버전과 일치하지 않으면, RuntimeWarning을 발생시킵니다.

Return NULL with an exception set on error.

This function does not support slots. The m_slots member of def must be NULL.

참고

이 함수는 대부분 PyModule_Create()를 대신 사용해야 합니다; 확실히 필요할 때만 사용하십시오.

PyObject *PyModule_FromDefAndSpec(PyModuleDef *def, PyObject *spec)¶: 반환값: 새 참조.
This macro calls PyModule_FromDefAndSpec2() with module_api_version set to PYTHON_API_VERSION, or to PYTHON_ABI_VERSION if using the limited API.

Added in version 3.5.

PyObject *PyModule_FromDefAndSpec2(PyModuleDef *def, PyObject *spec, int module_api_version)¶

반환값: 새 참조. Part of the 안정 ABI 버전 3.7 이후로.

API 버전 module_api_version을 가정하여, 주어진 def의 정의와 ModuleSpec spec으로 새 모듈 객체를 만듭니다. 해당 버전이 실행 중인 인터프리터 버전과 일치하지 않으면, RuntimeWarning을 발생시킵니다.

Return NULL with an exception set on error.

Note that this does not process execution slots (Py_mod_exec). Both PyModule_FromDefAndSpec and PyModule_ExecDef must be called to fully initialize a module.

참고

이 함수는 대부분 PyModule_FromDefAndSpec()을 대신 사용해야 합니다; 확실히 필요할 때만 사용하십시오.

Added in version 3.5.

int PyModule_ExecDef(PyObject *module, PyModuleDef *def)¶: Part of the 안정 ABI 버전 3.7 이후로.
def에 지정된 모든 실행 슬롯(Py_mod_exec)을 처리합니다.

Added in version 3.5.

PYTHON_API_VERSION¶

The C API version. Defined for backwards compatibility.

Currently, this constant is not updated in new Python versions, and is not useful for versioning. This may change in the future.

PYTHON_ABI_VERSION¶

Defined as 3 for backwards compatibility.

Currently, this constant is not updated in new Python versions, and is not useful for versioning. This may change in the future.

지원 함수¶

The following functions are provided to help initialize a module object. They are intended for a module’s execution slot (Py_mod_exec), the initialization function for legacy single-phase initialization, or code that creates modules dynamically.

int PyModule_AddObjectRef(PyObject *module, const char *name, PyObject *value)¶

Part of the 안정 ABI 버전 3.10 이후로.

module에 객체를 name으로 추가합니다. 모듈의 초기화 함수에서 사용할 수 있는 편의 함수입니다.

성공하면, 0을 반환합니다. 에러 시, 예외를 발생시키고 -1을 반환합니다.

사용 예:

static int
add_spam(PyObject *module, int value)
{
    PyObject *obj = PyLong_FromLong(value);
    if (obj == NULL) {
        return -1;
    }
    int res = PyModule_AddObjectRef(module, "spam", obj);
    Py_DECREF(obj);
    return res;
 }

To be convenient, the function accepts NULL value with an exception set. In this case, return -1 and just leave the raised exception unchanged.

The example can also be written without checking explicitly if obj is NULL:

static int
add_spam(PyObject *module, int value)
{
    PyObject *obj = PyLong_FromLong(value);
    int res = PyModule_AddObjectRef(module, "spam", obj);
    Py_XDECREF(obj);
    return res;
 }

Note that Py_XDECREF() should be used instead of Py_DECREF() in this case, since obj can be NULL.

The number of different name strings passed to this function should be kept small, usually by only using statically allocated strings as name. For 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.

Added in version 3.10.

int PyModule_Add(PyObject *module, const char *name, PyObject *value)¶

Part of the 안정 ABI 버전 3.13 이후로.

Similar to PyModule_AddObjectRef(), but “steals” a reference to value. It can be called with a result of function that returns a new reference without bothering to check its result or even saving it to a variable.

사용 예:

if (PyModule_Add(module, "spam", PyBytes_FromString(value)) < 0) {
    goto error;
}

Added in version 3.13.

int PyModule_AddObject(PyObject *module, const char *name, PyObject *value)¶

Part of the 안정 ABI.

Similar to PyModule_AddObjectRef(), but steals a reference to value on success (if it returns 0).

The new PyModule_Add() or PyModule_AddObjectRef() functions are recommended, since it is easy to introduce reference leaks by misusing the PyModule_AddObject() function.

참고

참조를 훔치는 다른 함수와 달리, PyModule_AddObject()는 성공 시에만 value에 대한 참조를 해제합니다.

이는 반환 값을 확인해야 하며, 에러 시 호출하는 코드가 수동으로 value를 Py_XDECREF() 해야 함을 뜻합니다.

사용 예:

PyObject *obj = PyBytes_FromString(value);
if (PyModule_AddObject(module, "spam", obj) < 0) {
    // 'obj' 가 NULL 이 아니고 PyModule_AddObject() 가 실패하면,
    // 'obj' 강한 참조는 Py_XDECREF() 로 삭제해야 합니다.
    // 'obj' 가 NULL 이면, Py_XDECREF() 는 아무것도 하지 않습니다.
    Py_XDECREF(obj);
    goto error;
}
// PyModule_AddObject() 는 obj 에 대한 참조를 훔칩니다:
// 여기에서 Py_XDECREF(obj) 는 필요 없습니다.

버전 3.13부터 폐지됨: PyModule_AddObject() is soft deprecated.

int PyModule_AddIntConstant(PyObject *module, const char *name, long value)¶

Part of the 안정 ABI.

module에 정수 상수를 name으로 추가합니다. 이 편의 함수는 모듈의 초기화 함수에서 사용할 수 있습니다. 에러 시 예외를 설정하고 -1을, 성공하면 0을 반환합니다.

This is a convenience function that calls PyLong_FromLong() and PyModule_AddObjectRef(); see their documentation for details.

int PyModule_AddStringConstant(PyObject *module, const char *name, const char *value)¶

Part of the 안정 ABI.

module에 문자열 상수를 name으로 추가합니다. 이 편의 함수는 모듈의 초기화 함수에서 사용할 수 있습니다. 문자열 value는 NULL로 끝나야 합니다. 에러 시 예외를 설정하고 -1을, 성공 시 0을 반환합니다.

This is a convenience function that calls PyUnicode_InternFromString() and PyModule_AddObjectRef(); see their documentation for details.

PyModule_AddIntMacro(module, macro)¶: module에 int 상수를 추가합니다. 이름과 값은 macro에서 취합니다. 예를 들어 PyModule_AddIntMacro(module, AF_INET)은 AF_INET 값을 가진 int 상수 AF_INET을 module에 추가합니다. 에러 시 예외를 설정하고 -1을, 성공하면 0을 반환합니다.

PyModule_AddStringMacro(module, macro)¶: module에 문자열 상수를 추가합니다.

int PyModule_AddType(PyObject *module, PyTypeObject *type)¶: Part of the 안정 ABI 버전 3.10 이후로.
module에 형 객체를 추가합니다. 내부적으로 PyType_Ready()를 호출하여 형 객체를 파이널라이즈합니다. 형 객체의 이름은 점 뒤 tp_name의 마지막 구성 요소에서 가져옵니다. 에러가 발생하면 예외를 설정하고 -1을, 성공하면 0을 반환합니다.

Added in version 3.9.

int PyModule_AddFunctions(PyObject *module, PyMethodDef *functions)¶

Part of the 안정 ABI 버전 3.7 이후로.

Add the functions from the NULL terminated functions array to module. Refer to the PyMethodDef documentation for details on individual entries (due to the lack of a shared module namespace, module level “functions” implemented in C typically receive the module as their first parameter, making them similar to instance methods on Python classes).

This function is called automatically when creating a module from PyModuleDef (such as when using Multi-phase initialization, PyModule_Create, or PyModule_FromDefAndSpec). Some module authors may prefer defining functions in multiple PyMethodDef arrays; in that case they should call this function directly.

The functions array must be statically allocated (or otherwise guaranteed to outlive the module object).

Added in version 3.5.

int PyModule_SetDocString(PyObject *module, const char *docstring)¶: Part of the 안정 ABI 버전 3.7 이후로.
Set the docstring for module to docstring. This function is called automatically when creating a module from PyModuleDef (such as when using Multi-phase initialization, PyModule_Create, or PyModule_FromDefAndSpec).

Added in version 3.5.

int PyUnstable_Module_SetGIL(PyObject *module, void *gil)¶: 이것은 불안정 API. It may change without warning in minor releases.

Indicate that module does or does not support running without the global interpreter lock (GIL), using one of the values from Py_mod_gil. It must be called during module’s initialization function when using Legacy single-phase initialization. If this function is not called during module initialization, the import machinery assumes the module does not support running without the GIL. This function is only available in Python builds configured with --disable-gil. Return -1 with an exception set on error, 0 on success.

Added in version 3.13.

Module lookup (single-phase initialization)¶

The legacy single-phase initialization initialization scheme creates singleton modules that can be looked up in the context of the current interpreter. This allows the module object to be retrieved later with only a reference to the module definition.

이 함수들은 다단계 초기화를 사용하여 만들어진 모듈에서는 작동하지 않습니다. 단일 정의에서 그러한 모듈이 여러 개 만들어질 수 있기 때문입니다.

PyObject *PyState_FindModule(PyModuleDef *def)¶: 반환값: 빌린 참조. Part of the 안정 ABI.
현재 인터프리터에 대해 def에서 만들어진 모듈 객체를 반환합니다. 이 메서드를 사용하려면 먼저 모듈 객체가 PyState_AddModule()로 인터프리터 상태에 연결되어 있어야 합니다. 해당 모듈 객체를 찾을 수 없거나 인터프리터 상태에 아직 연결되지 않았으면, NULL을 반환합니다.

int PyState_AddModule(PyObject *module, PyModuleDef *def)¶

Part of the 안정 ABI 버전 3.3 이후로.

함수에 전달된 모듈 객체를 인터프리터 상태에 연결합니다. 이는 PyState_FindModule()을 통해 모듈 객체에 액세스 할 수 있도록 합니다.

단단계 초기화를 사용하여 만든 모듈에만 효과가 있습니다.

Python calls PyState_AddModule automatically after importing a module that uses single-phase initialization, so it is unnecessary (but harmless) to call it from module initialization code. An explicit call is needed only if the module’s own init code subsequently calls PyState_FindModule. The function is mainly intended for implementing alternative import mechanisms (either by calling it directly, or by referring to its implementation for details of the required state updates).

If a module was attached previously using the same def, it is replaced by the new module.

The caller must have an attached thread state.

에러 시 예외를 설정하고 -1을, 성공 시 0을 반환합니다.

Added in version 3.3.

int PyState_RemoveModule(PyModuleDef *def)¶

Part of the 안정 ABI 버전 3.3 이후로.

def에서 만들어진 모듈 객체를 인터프리터 상태에서 제거합니다. 에러 시 예외를 설정하고 -1을, 성공 시 0을 반환합니다.

The caller must have an attached thread state.

Added in version 3.3.

모듈 객체¶

Module definition¶

Metadata slots¶

Feature slots¶

Creation and initialization slots¶

Module state¶

Slots for defining module state¶

Module token¶

Creating extension modules dynamically¶

Module definition struct¶

지원 함수¶

Module lookup (single-phase initialization)¶

목차

이전 항목

다음 항목

This page