# Copyright (C) 2001-2022, Python Software Foundation
# This file is distributed under the same license as the Python package.
#
# Translators:
# Matt Wang , 2022
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.12\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2023-07-22 00:04+0000\n"
"PO-Revision-Date: 2022-10-16 03:20+0800\n"
"Last-Translator: Matt Wang \n"
"Language-Team: Chinese - TAIWAN (https://github.com/python/python-docs-zh-"
"tw)\n"
"Language: zh_TW\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=1; plural=0;\n"
"X-Generator: Poedit 3.1.1\n"
#: ../../c-api/call.rst:6
msgid "Call Protocol"
msgstr " (Call Protocol)"
#: ../../c-api/call.rst:8
msgid ""
"CPython supports two different calling protocols: *tp_call* and vectorcall."
msgstr "CPython *tp_call* vectorcall"
#: ../../c-api/call.rst:12
msgid "The *tp_call* Protocol"
msgstr "*tp_call* "
#: ../../c-api/call.rst:14
msgid ""
"Instances of classes that set :c:member:`~PyTypeObject.tp_call` are "
"callable. The signature of the slot is::"
msgstr ""
" :c:member:`~PyTypeObject.tp_call` "
"(slot) \n"
"\n"
"::"
#: ../../c-api/call.rst:19
msgid ""
"A call is made using a tuple for the positional arguments and a dict for the "
"keyword arguments, similarly to ``callable(*args, **kwargs)`` in Python "
"code. *args* must be non-NULL (use an empty tuple if there are no arguments) "
"but *kwargs* may be *NULL* if there are no keyword arguments."
msgstr ""
" tuple dict "
" Python ``callable(*args, **kwargs)``*args* "
"NULL tuple*kwargs* "
" *NULL*"
#: ../../c-api/call.rst:25
msgid ""
"This convention is not only used by *tp_call*: :c:member:`~PyTypeObject."
"tp_new` and :c:member:`~PyTypeObject.tp_init` also pass arguments this way."
msgstr ""
" *tp_call* :c:member:`~PyTypeObject.tp_new` :c:"
"member:`~PyTypeObject.tp_init` "
#: ../../c-api/call.rst:29
msgid ""
"To call an object, use :c:func:`PyObject_Call` or another :ref:`call API "
"`."
msgstr ""
" :c:func:`PyObject_Call` \\ :ref:` API ` "
""
#: ../../c-api/call.rst:36
msgid "The Vectorcall Protocol"
msgstr "Vectorcall "
#: ../../c-api/call.rst:40
msgid ""
"The vectorcall protocol was introduced in :pep:`590` as an additional "
"protocol for making calls more efficient."
msgstr ""
"Vectorcall :pep:`590` "
#: ../../c-api/call.rst:43
msgid ""
"As rule of thumb, CPython will prefer the vectorcall for internal calls if "
"the callable supports it. However, this is not a hard rule. Additionally, "
"some third-party extensions use *tp_call* directly (rather than using :c:"
"func:`PyObject_Call`). Therefore, a class supporting vectorcall must also "
"implement :c:member:`~PyTypeObject.tp_call`. Moreover, the callable must "
"behave the same regardless of which protocol is used. The recommended way to "
"achieve this is by setting :c:member:`~PyTypeObject.tp_call` to :c:func:"
"`PyVectorcall_Call`. This bears repeating:"
msgstr ""
"CPython "
"vectorcall "
"*tp_call*\\ :c:func:`PyObject_Call` "
"vectorcall :c:member:`~PyTypeObject.tp_call`"
" :c:"
"member:`~PyTypeObject.tp_call` :c:func:`PyVectorcall_Call`"
""
#: ../../c-api/call.rst:57
msgid ""
"A class supporting vectorcall **must** also implement :c:member:"
"`~PyTypeObject.tp_call` with the same semantics."
msgstr ""
" vectorcall \\ ****\\ :c:member:"
"`~PyTypeObject.tp_call`"
#: ../../c-api/call.rst:62
msgid ""
"The :c:macro:`Py_TPFLAGS_HAVE_VECTORCALL` flag is now removed from a class "
"when the class's :py:meth:`~object.__call__` method is reassigned. (This "
"internally sets :c:member:`~PyTypeObject.tp_call` only, and thus may make it "
"behave differently than the vectorcall function.) In earlier Python "
"versions, vectorcall should only be used with :c:macro:`immutable "
"` or static types."
msgstr ""
#: ../../c-api/call.rst:69
msgid ""
"A class should not implement vectorcall if that would be slower than "
"*tp_call*. For example, if the callee needs to convert the arguments to an "
"args tuple and kwargs dict anyway, then there is no point in implementing "
"vectorcall."
msgstr ""
" vectorcall *tp_call* vectorcall"
" args tuple kwargs dict"
" vectorcall "
#: ../../c-api/call.rst:74
msgid ""
"Classes can implement the vectorcall protocol by enabling the :c:macro:"
"`Py_TPFLAGS_HAVE_VECTORCALL` flag and setting :c:member:`~PyTypeObject."
"tp_vectorcall_offset` to the offset inside the object structure where a "
"*vectorcallfunc* appears. This is a pointer to a function with the following "
"signature:"
msgstr ""
" :c:macro:`Py_TPFLAGS_HAVE_VECTORCALL` :c:member:"
"`~PyTypeObject.tp_vectorcall_offset` *vectorcallfunc* "
" offset vectorcall "
#: ../../c-api/call.rst:82
msgid "*callable* is the object being called."
msgstr "*callable* "
#: ../../c-api/call.rst:84
msgid ""
"*args* is a C array consisting of the positional arguments followed by the"
msgstr "*args* C (array)"
#: ../../c-api/call.rst:84
msgid ""
"values of the keyword arguments. This can be *NULL* if there are no "
"arguments."
msgstr " *NULL*"
#: ../../c-api/call.rst:88
msgid "*nargsf* is the number of positional arguments plus possibly the"
msgstr "*nargsf* "
#: ../../c-api/call.rst:87
msgid ""
":c:macro:`PY_VECTORCALL_ARGUMENTS_OFFSET` flag. To get the actual number of "
"positional arguments from *nargsf*, use :c:func:`PyVectorcall_NARGS`."
msgstr ""
":c:macro:`PY_VECTORCALL_ARGUMENTS_OFFSET` *nargsf* "
" :c:func:`PyVectorcall_NARGS`"
#: ../../c-api/call.rst:94
msgid "*kwnames* is a tuple containing the names of the keyword arguments;"
msgstr "*kwnames* tuple"
#: ../../c-api/call.rst:91
msgid ""
"in other words, the keys of the kwargs dict. These names must be strings "
"(instances of ``str`` or a subclass) and they must be unique. If there are "
"no keyword arguments, then *kwnames* can instead be *NULL*."
msgstr ""
" kwargs ``str`` "
") *kwnames* "
"*NULL* "
#: ../../c-api/call.rst:98
msgid ""
"If this flag is set in a vectorcall *nargsf* argument, the callee is allowed "
"to temporarily change ``args[-1]``. In other words, *args* points to "
"argument 1 (not 0) in the allocated vector. The callee must restore the "
"value of ``args[-1]`` before returning."
msgstr ""
" vectorcall *nargsf* "
"``args[-1]`` *args* 1 0"
" ``args[-1]`` "
#: ../../c-api/call.rst:103
msgid ""
"For :c:func:`PyObject_VectorcallMethod`, this flag means instead that "
"``args[0]`` may be changed."
msgstr ""
" :c:func:`PyObject_VectorcallMethod` "
"``args[0]`` "
#: ../../c-api/call.rst:106
msgid ""
"Whenever they can do so cheaply (without additional allocation), callers are "
"encouraged to use :c:macro:`PY_VECTORCALL_ARGUMENTS_OFFSET`. Doing so will "
"allow callables such as bound methods to make their onward calls (which "
"include a prepended *self* argument) very efficiently."
msgstr ""
""
" :c:macro:`PY_VECTORCALL_ARGUMENTS_OFFSET` bound method"
" *self* "
""
#: ../../c-api/call.rst:111
msgid ""
"To call an object that implements vectorcall, use a :ref:`call API ` function as with any other callable. :c:func:`PyObject_Vectorcall` "
"will usually be most efficient."
msgstr ""
" vectorcall \\ :ref:`"
" API` :c:func:`PyObject_Vectorcall` "
#: ../../c-api/call.rst:118
msgid ""
"In CPython 3.8, the vectorcall API and related functions were available "
"provisionally under names with a leading underscore: "
"``_PyObject_Vectorcall``, ``_Py_TPFLAGS_HAVE_VECTORCALL``, "
"``_PyObject_VectorcallMethod``, ``_PyVectorcall_Function``, "
"``_PyObject_CallOneArg``, ``_PyObject_CallMethodNoArgs``, "
"``_PyObject_CallMethodOneArg``. Additionally, ``PyObject_VectorcallDict`` "
"was available as ``_PyObject_FastCallDict``. The old names are still defined "
"as aliases of the new, non-underscored names."
msgstr ""
" CPython 3.8 vectorcall API "
"``_PyObject_Vectorcall````_Py_TPFLAGS_HAVE_VECTORCALL``"
"``_PyObject_VectorcallMethod````_PyVectorcall_Function``"
"``_PyObject_CallOneArg````_PyObject_CallMethodNoArgs``"
"``_PyObject_CallMethodOneArg````PyObject_VectorcallDict`` "
"``_PyObject_FastCallDict`` "
""
#: ../../c-api/call.rst:130
msgid "Recursion Control"
msgstr ""
#: ../../c-api/call.rst:132
msgid ""
"When using *tp_call*, callees do not need to worry about :ref:`recursion "
"`: CPython uses :c:func:`Py_EnterRecursiveCall` and :c:func:"
"`Py_LeaveRecursiveCall` for calls made using *tp_call*."
msgstr ""
" *tp_call* \\ :ref:` `CPython "
" *tp_call* :c:func:`Py_EnterRecursiveCall` :c:func:"
"`Py_LeaveRecursiveCall`"
#: ../../c-api/call.rst:137
msgid ""
"For efficiency, this is not the case for calls done using vectorcall: the "
"callee should use *Py_EnterRecursiveCall* and *Py_LeaveRecursiveCall* if "
"needed."
msgstr ""
" vectorcall "
"*Py_EnterRecursiveCall* *Py_LeaveRecursiveCall*"
#: ../../c-api/call.rst:143
msgid "Vectorcall Support API"
msgstr "Vectorcall API"
#: ../../c-api/call.rst:147
msgid ""
"Given a vectorcall *nargsf* argument, return the actual number of arguments. "
"Currently equivalent to::"
msgstr ""
" vectorcall *nargsf* \n"
"\n"
"::"
#: ../../c-api/call.rst:153
msgid ""
"However, the function ``PyVectorcall_NARGS`` should be used to allow for "
"future extensions."
msgstr " ``PyVectorcall_NARGS`` "
#: ../../c-api/call.rst:160
msgid ""
"If *op* does not support the vectorcall protocol (either because the type "
"does not or because the specific instance does not), return *NULL*. "
"Otherwise, return the vectorcall function pointer stored in *op*. This "
"function never raises an exception."
msgstr ""
" *op* vectorcall "
"*NULL* *op* vectorcall "
""
#: ../../c-api/call.rst:165
msgid ""
"This is mostly useful to check whether or not *op* supports vectorcall, "
"which can be done by checking ``PyVectorcall_Function(op) != NULL``."
msgstr ""
" *op* vectorcall "
"``PyVectorcall_Function(op) != NULL`` "
#: ../../c-api/call.rst:172
msgid ""
"Call *callable*'s :c:type:`vectorcallfunc` with positional and keyword "
"arguments given in a tuple and dict, respectively."
msgstr ""
" *callable* :c:type:`vectorcallfunc` "
"tuple dict "
#: ../../c-api/call.rst:175
msgid ""
"This is a specialized function, intended to be put in the :c:member:"
"`~PyTypeObject.tp_call` slot or be used in an implementation of ``tp_call``. "
"It does not check the :c:macro:`Py_TPFLAGS_HAVE_VECTORCALL` flag and it does "
"not fall back to ``tp_call``."
msgstr ""
" :c:member:`~PyTypeObject.tp_call` "
" ``tp_call`` :c:macro:`Py_TPFLAGS_HAVE_VECTORCALL` "
" (fall back) ``tp_call``"
#: ../../c-api/call.rst:186
msgid "Object Calling API"
msgstr " API"
#: ../../c-api/call.rst:188
msgid ""
"Various functions are available for calling a Python object. Each converts "
"its arguments to a convention supported by the called object either "
"*tp_call* or vectorcall. In order to do as little conversion as possible, "
"pick one that best fits the format of data you have available."
msgstr ""
" Python "
" *tp_call* vectorcall"
""
#: ../../c-api/call.rst:194
msgid ""
"The following table summarizes the available functions; please see "
"individual documentation for details."
msgstr ""
#: ../../c-api/call.rst:198
msgid "Function"
msgstr ""
#: ../../c-api/call.rst:198
msgid "callable"
msgstr "callable"
#: ../../c-api/call.rst:198
msgid "args"
msgstr "args"
#: ../../c-api/call.rst:198
msgid "kwargs"
msgstr "kwargs"
#: ../../c-api/call.rst:200
msgid ":c:func:`PyObject_Call`"
msgstr ":c:func:`PyObject_Call`"
#: ../../c-api/call.rst:200 ../../c-api/call.rst:202 ../../c-api/call.rst:204
#: ../../c-api/call.rst:206 ../../c-api/call.rst:208 ../../c-api/call.rst:212
#: ../../c-api/call.rst:220 ../../c-api/call.rst:222
msgid "``PyObject *``"
msgstr "``PyObject *``"
#: ../../c-api/call.rst:200
msgid "tuple"
msgstr "tuple"
#: ../../c-api/call.rst:200 ../../c-api/call.rst:222
msgid "dict/``NULL``"
msgstr "dict/``NULL``"
#: ../../c-api/call.rst:202
msgid ":c:func:`PyObject_CallNoArgs`"
msgstr ":c:func:`PyObject_CallNoArgs`"
#: ../../c-api/call.rst:202 ../../c-api/call.rst:204 ../../c-api/call.rst:206
#: ../../c-api/call.rst:208 ../../c-api/call.rst:210 ../../c-api/call.rst:212
#: ../../c-api/call.rst:214 ../../c-api/call.rst:216 ../../c-api/call.rst:218
msgid "---"
msgstr "---"
#: ../../c-api/call.rst:204
msgid ":c:func:`PyObject_CallOneArg`"
msgstr ":c:func:`PyObject_CallOneArg`"
#: ../../c-api/call.rst:204 ../../c-api/call.rst:218
msgid "1 object"
msgstr ""
#: ../../c-api/call.rst:206
msgid ":c:func:`PyObject_CallObject`"
msgstr ":c:func:`PyObject_CallObject`"
#: ../../c-api/call.rst:206
msgid "tuple/``NULL``"
msgstr "tuple/``NULL``"
#: ../../c-api/call.rst:208
msgid ":c:func:`PyObject_CallFunction`"
msgstr ":c:func:`PyObject_CallFunction`"
#: ../../c-api/call.rst:208 ../../c-api/call.rst:210
msgid "format"
msgstr "format"
#: ../../c-api/call.rst:210
msgid ":c:func:`PyObject_CallMethod`"
msgstr ":c:func:`PyObject_CallMethod`"
#: ../../c-api/call.rst:210
msgid "obj + ``char*``"
msgstr " + ``char*``"
#: ../../c-api/call.rst:212
msgid ":c:func:`PyObject_CallFunctionObjArgs`"
msgstr ":c:func:`PyObject_CallFunctionObjArgs`"
#: ../../c-api/call.rst:212 ../../c-api/call.rst:214
msgid "variadic"
msgstr ""
#: ../../c-api/call.rst:214
msgid ":c:func:`PyObject_CallMethodObjArgs`"
msgstr ":c:func:`PyObject_CallMethodObjArgs`"
#: ../../c-api/call.rst:214 ../../c-api/call.rst:216 ../../c-api/call.rst:218
msgid "obj + name"
msgstr " + "
#: ../../c-api/call.rst:216
msgid ":c:func:`PyObject_CallMethodNoArgs`"
msgstr ":c:func:`PyObject_CallMethodNoArgs`"
#: ../../c-api/call.rst:218
msgid ":c:func:`PyObject_CallMethodOneArg`"
msgstr ":c:func:`PyObject_CallMethodOneArg`"
#: ../../c-api/call.rst:220
msgid ":c:func:`PyObject_Vectorcall`"
msgstr ":c:func:`PyObject_Vectorcall`"
#: ../../c-api/call.rst:220 ../../c-api/call.rst:222 ../../c-api/call.rst:224
msgid "vectorcall"
msgstr "vectorcall"
#: ../../c-api/call.rst:222
msgid ":c:func:`PyObject_VectorcallDict`"
msgstr ":c:func:`PyObject_VectorcallDict`"
#: ../../c-api/call.rst:224
msgid ":c:func:`PyObject_VectorcallMethod`"
msgstr ":c:func:`PyObject_VectorcallMethod`"
#: ../../c-api/call.rst:224
msgid "arg + name"
msgstr " + "
#: ../../c-api/call.rst:230
msgid ""
"Call a callable Python object *callable*, with arguments given by the tuple "
"*args*, and named arguments given by the dictionary *kwargs*."
msgstr ""
" Python *callable* tuple *args* "
" *kwargs* "
#: ../../c-api/call.rst:233
msgid ""
"*args* must not be *NULL*; use an empty tuple if no arguments are needed. If "
"no named arguments are needed, *kwargs* can be *NULL*."
msgstr ""
"*args* *NULL* tuple"
" *kwargs* *NULL*"
#: ../../c-api/call.rst:236 ../../c-api/call.rst:248 ../../c-api/call.rst:259
#: ../../c-api/call.rst:270 ../../c-api/call.rst:282 ../../c-api/call.rst:302
#: ../../c-api/call.rst:321 ../../c-api/call.rst:335 ../../c-api/call.rst:344
#: ../../c-api/call.rst:356 ../../c-api/call.rst:369 ../../c-api/call.rst:403
msgid ""
"Return the result of the call on success, or raise an exception and return "
"*NULL* on failure."
msgstr " *NULL*"
#: ../../c-api/call.rst:239
msgid ""
"This is the equivalent of the Python expression: ``callable(*args, "
"**kwargs)``."
msgstr " Python ``callable(*args, **kwargs)``"
#: ../../c-api/call.rst:245
msgid ""
"Call a callable Python object *callable* without any arguments. It is the "
"most efficient way to call a callable Python object without any argument."
msgstr ""
" Python *callable* "
"Python "
#: ../../c-api/call.rst:256
msgid ""
"Call a callable Python object *callable* with exactly 1 positional argument "
"*arg* and no keyword arguments."
msgstr ""
" Python *callable* *arg* "
""
#: ../../c-api/call.rst:267
msgid ""
"Call a callable Python object *callable*, with arguments given by the tuple "
"*args*. If no arguments are needed, then *args* can be *NULL*."
msgstr ""
" Python *callable* tuple *args* "
" *args* *NULL*"
#: ../../c-api/call.rst:273 ../../c-api/call.rst:285
msgid "This is the equivalent of the Python expression: ``callable(*args)``."
msgstr " Python ``callable(*args)``"
#: ../../c-api/call.rst:278
msgid ""
"Call a callable Python object *callable*, with a variable number of C "
"arguments. The C arguments are described using a :c:func:`Py_BuildValue` "
"style format string. The format can be *NULL*, indicating that no arguments "
"are provided."
msgstr ""
" Python *callable* C C "
" :c:func:`Py_BuildValue` *NULL*"
""
#: ../../c-api/call.rst:287
msgid ""
"Note that if you only pass :c:expr:`PyObject *` args, :c:func:"
"`PyObject_CallFunctionObjArgs` is a faster alternative."
msgstr ""
" :c:expr:`PyObject *` :c:func:"
"`PyObject_CallFunctionObjArgs` "
#: ../../c-api/call.rst:290
msgid "The type of *format* was changed from ``char *``."
msgstr " *format* ``char *`` "
#: ../../c-api/call.rst:296
msgid ""
"Call the method named *name* of object *obj* with a variable number of C "
"arguments. The C arguments are described by a :c:func:`Py_BuildValue` "
"format string that should produce a tuple."
msgstr ""
" *obj* *name* method C C "
" :c:func:`Py_BuildValue` tuple"
#: ../../c-api/call.rst:300
msgid "The format can be *NULL*, indicating that no arguments are provided."
msgstr " *NULL*"
#: ../../c-api/call.rst:305
msgid ""
"This is the equivalent of the Python expression: ``obj.name(arg1, "
"arg2, ...)``."
msgstr " Python ``obj.name(arg1, arg2, ...)``"
#: ../../c-api/call.rst:308
msgid ""
"Note that if you only pass :c:expr:`PyObject *` args, :c:func:"
"`PyObject_CallMethodObjArgs` is a faster alternative."
msgstr ""
" :c:expr:`PyObject *` :c:func:"
"`PyObject_CallMethodObjArgs` "
#: ../../c-api/call.rst:311
msgid "The types of *name* and *format* were changed from ``char *``."
msgstr "*name* *format* ``char *`` "
#: ../../c-api/call.rst:317
msgid ""
"Call a callable Python object *callable*, with a variable number of :c:expr:"
"`PyObject *` arguments. The arguments are provided as a variable number of "
"parameters followed by *NULL*."
msgstr ""
" Python *callable* :c:expr:`PyObject *` "
" *NULL* "
#: ../../c-api/call.rst:324
msgid ""
"This is the equivalent of the Python expression: ``callable(arg1, "
"arg2, ...)``."
msgstr " Python ``callable(arg1, arg2, ...)``"
#: ../../c-api/call.rst:330
msgid ""
"Call a method of the Python object *obj*, where the name of the method is "
"given as a Python string object in *name*. It is called with a variable "
"number of :c:expr:`PyObject *` arguments. The arguments are provided as a "
"variable number of parameters followed by *NULL*."
msgstr ""
" Python *obj* method method *name* "
"Python :c:expr:`PyObject *` "
" *NULL* "
#: ../../c-api/call.rst:341
msgid ""
"Call a method of the Python object *obj* without arguments, where the name "
"of the method is given as a Python string object in *name*."
msgstr ""
" Python *obj* method method "
"*name* Python "
#: ../../c-api/call.rst:352
msgid ""
"Call a method of the Python object *obj* with a single positional argument "
"*arg*, where the name of the method is given as a Python string object in "
"*name*."
msgstr ""
" *arg* Python *obj* method method "
" *name* Python "
#: ../../c-api/call.rst:364
msgid ""
"Call a callable Python object *callable*. The arguments are the same as for :"
"c:type:`vectorcallfunc`. If *callable* supports vectorcall_, this directly "
"calls the vectorcall function stored in *callable*."
msgstr ""
" Python *callable* :c:type:`vectorcallfunc` "
" *callable* vectorcall_ *callable* "
" vectorcall "
#: ../../c-api/call.rst:376
msgid ""
"Call *callable* with positional arguments passed exactly as in the "
"vectorcall_ protocol, but with keyword arguments passed as a dictionary "
"*kwdict*. The *args* array contains only the positional arguments."
msgstr ""
" vectorcall_ *callable*"
" *kwdict* *args* "
#: ../../c-api/call.rst:380
msgid ""
"Regardless of which protocol is used internally, a conversion of arguments "
"needs to be done. Therefore, this function should only be used if the caller "
"already has a dictionary ready to use for the keyword arguments, but not a "
"tuple for the positional arguments."
msgstr ""
""
" tuple "
#: ../../c-api/call.rst:390
msgid ""
"Call a method using the vectorcall calling convention. The name of the "
"method is given as a Python string *name*. The object whose method is called "
"is *args[0]*, and the *args* array starting at *args[1]* represents the "
"arguments of the call. There must be at least one positional argument. "
"*nargsf* is the number of positional arguments including *args[0]*, plus :c:"
"macro:`PY_VECTORCALL_ARGUMENTS_OFFSET` if the value of ``args[0]`` may "
"temporarily be changed. Keyword arguments can be passed just like in :c:func:"
"`PyObject_Vectorcall`."
msgstr ""
" vectorcall methodmethod Python "
"*name* method *args[0]* *args* "
"*args[1]* *nargsf* "
" *args[0]* ``args[0]`` "
" :c:macro:`PY_VECTORCALL_ARGUMENTS_OFFSET` :c:func:"
"`PyObject_Vectorcall` "
#: ../../c-api/call.rst:399
msgid ""
"If the object has the :c:macro:`Py_TPFLAGS_METHOD_DESCRIPTOR` feature, this "
"will call the unbound method object with the full *args* vector as arguments."
msgstr ""
" :c:macro:`Py_TPFLAGS_METHOD_DESCRIPTOR` *args* "
" unbound method"
#: ../../c-api/call.rst:410
msgid "Call Support API"
msgstr " API"
#: ../../c-api/call.rst:414
msgid ""
"Determine if the object *o* is callable. Return ``1`` if the object is "
"callable and ``0`` otherwise. This function always succeeds."
msgstr ""
" *o* ``1`` "
"``0``"
#~ msgid "This function is not part of the :ref:`limited API `."
#~ msgstr " :ref:`limited API ` "