# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2025, Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# Rafael Fontenelle <[email protected]>, 2025

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.12\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2025-07-25 16:03+0000\n"

"PO-Revision-Date: 2025-07-18 19:57+0000\n"

"Last-Translator: Rafael Fontenelle <[email protected]>, 2025\n"

"Language-Team: Chinese (China) (https://app.transifex.com/python-doc/teams/5390/zh_CN/)\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Language: zh_CN\n"

"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../library/ctypes.rst:2

msgid ":mod:`!ctypes` --- A foreign function library for Python"

msgstr ":mod:`!ctypes` --- Python 的外部函数库"

#: ../../library/ctypes.rst:9

msgid "**Source code:** :source:`Lib/ctypes`"

msgstr "**源代码:** :source:`Lib/ctypes`"

#: ../../library/ctypes.rst:13

msgid ""

":mod:`ctypes` is a foreign function library for Python. It provides C "

"compatible data types, and allows calling functions in DLLs or shared "

"libraries. It can be used to wrap these libraries in pure Python."

msgstr ""

":mod:`ctypes` 是 Python 的外部函数库。它提供了与 C 兼容的数据类型，并允许调用 DLL 或共享库中的函数。可使用该模块以纯 "

"Python 形式对这些库进行封装。"

#: ../../library/ctypes.rst:21

msgid "ctypes tutorial"

msgstr "ctypes 教程"

#: ../../library/ctypes.rst:23

msgid ""

"Note: The code samples in this tutorial use :mod:`doctest` to make sure that"

" they actually work. Since some code samples behave differently under "

"Linux, Windows, or macOS, they contain doctest directives in comments."

msgstr ""

"注：本教程中的示例代码使用 :mod:`doctest` 来保证它们能正确运行。 由于有些代码示例在 Linux, Windows 或 macOS "

"上的行为有所不同，它们在注释中包含了一些 doctest 指令。"

#: ../../library/ctypes.rst:27

msgid ""

"Note: Some code samples reference the ctypes :class:`c_int` type. On "

"platforms where ``sizeof(long) == sizeof(int)`` it is an alias to "

":class:`c_long`. So, you should not be confused if :class:`c_long` is "

"printed if you would expect :class:`c_int` --- they are actually the same "

"type."

msgstr ""

"注意：部分示例代码引用了 ctypes :class:`c_int` 类型。在 ``sizeof(long) == sizeof(int)`` "

"的平台上此类型是 :class:`c_long` 的一个别名。所以，在程序输出 :class:`c_long` 而不是你期望的 "

":class:`c_int` 时不必感到迷惑 --- 它们实际上是同一种类型。"

#: ../../library/ctypes.rst:35

msgid "Loading dynamic link libraries"

msgstr "载入动态连接库"

#: ../../library/ctypes.rst:37

msgid ""

":mod:`ctypes` exports the *cdll*, and on Windows *windll* and *oledll* "

"objects, for loading dynamic link libraries."

msgstr ""

":mod:`ctypes` 导出了 *cdll* 对象，在 Windows 系统中还导出了 *windll* 和 *oledll* "

"对象用于载入动态连接库。"

#: ../../library/ctypes.rst:40

msgid ""

"You load libraries by accessing them as attributes of these objects. *cdll* "

"loads libraries which export functions using the standard ``cdecl`` calling "

"convention, while *windll* libraries call functions using the ``stdcall`` "

"calling convention. *oledll* also uses the ``stdcall`` calling convention, "

"and assumes the functions return a Windows :c:type:`!HRESULT` error code. "

"The error code is used to automatically raise an :class:`OSError` exception "

"when the function call fails."

msgstr ""

"您可以通过访问这些对象的属性来加载库。 *cdll* 加载使用标准 ``cdecl`` 调用约定导出函数的库，而 *windll* 库则使用 "

"``stdcall`` 调用约定调用函数。 *oledll* 也使用 ``stdcall`` 调用约定，并假定函数返回 Windows "

":c:type:`!HRESULT` 错误代码。 当函数调用失败时会使用错误代码自动引发 :class:`OSError` 异常。"

#: ../../library/ctypes.rst:48

msgid ""

"Windows errors used to raise :exc:`WindowsError`, which is now an alias of "

":exc:`OSError`."

msgstr "原来在 Windows 下抛出的异常类型 :exc:`WindowsError` 现在是 :exc:`OSError` 的一个别名。"

#: ../../library/ctypes.rst:53

msgid ""

"Here are some examples for Windows. Note that ``msvcrt`` is the MS standard "

"C library containing most standard C functions, and uses the ``cdecl`` "

"calling convention::"

msgstr ""

"这是一些 Windows 下的例子。 请注意 ``msvcrt`` 是包含大部分 C 函数的 MS 标准 C 库，并会使用 ``cdecl`` "

"调用惯例::"

#: ../../library/ctypes.rst:57

msgid ""

">>> from ctypes import *\n"

">>> print(windll.kernel32)\n"

"<WinDLL 'kernel32', handle ... at ...>\n"

">>> print(cdll.msvcrt)\n"

"<CDLL 'msvcrt', handle ... at ...>\n"

">>> libc = cdll.msvcrt\n"

">>>"

msgstr ""

">>> from ctypes import *\n"

">>> print(windll.kernel32)\n"

"<WinDLL 'kernel32', handle ... at ...>\n"

">>> print(cdll.msvcrt)\n"

"<CDLL 'msvcrt', handle ... at ...>\n"

">>> libc = cdll.msvcrt\n"

">>>"

#: ../../library/ctypes.rst:65

msgid "Windows appends the usual ``.dll`` file suffix automatically."

msgstr "Windows 会自动添加通常的 ``.dll`` 文件扩展名。"

#: ../../library/ctypes.rst:68

msgid ""

"Accessing the standard C library through ``cdll.msvcrt`` will use an "

"outdated version of the library that may be incompatible with the one being "

"used by Python. Where possible, use native Python functionality, or else "

"import and use the ``msvcrt`` module."

msgstr ""

"通过 ``cdll.msvcrt`` 调用的标准 C 函数，可能会导致调用一个过时的，与当前 Python 所不兼容的函数。因此，请尽量使用标准的 "

"Python 函数，而不要使用 ``msvcrt`` 模块。"

#: ../../library/ctypes.rst:73

msgid ""

"On Linux, it is required to specify the filename *including* the extension "

"to load a library, so attribute access can not be used to load libraries. "

"Either the :meth:`~LibraryLoader.LoadLibrary` method of the dll loaders "

"should be used, or you should load the library by creating an instance of "

"CDLL by calling the constructor::"

msgstr ""

"在 Linux 中，要求指定文件名 *包括* 扩展名来加载库，因此不能使用属性访问的方式来加载库。 你应当使用 dll 加载器的 "

":meth:`~LibraryLoader.LoadLibrary` 方法，或是应当通过调用构造器创建 CDLL 的实例来加载库::"

#: ../../library/ctypes.rst:79

msgid ""

">>> cdll.LoadLibrary(\"libc.so.6\")\n"

"<CDLL 'libc.so.6', handle ... at ...>\n"

">>> libc = CDLL(\"libc.so.6\")\n"

">>> libc\n"

"<CDLL 'libc.so.6', handle ... at ...>\n"

">>>"

msgstr ""

">>> cdll.LoadLibrary(\"libc.so.6\")\n"

"<CDLL 'libc.so.6', handle ... at ...>\n"

">>> libc = CDLL(\"libc.so.6\")\n"

">>> libc\n"

"<CDLL 'libc.so.6', handle ... at ...>\n"

">>>"

#: ../../library/ctypes.rst:92

msgid "Accessing functions from loaded dlls"

msgstr "操作导入的动态链接库中的函数"

#: ../../library/ctypes.rst:94

msgid "Functions are accessed as attributes of dll objects::"

msgstr "通过操作dll对象的属性来操作这些函数。"

#: ../../library/ctypes.rst:96

msgid ""

">>> libc.printf\n"

"<_FuncPtr object at 0x...>\n"

">>> print(windll.kernel32.GetModuleHandleA)\n"

"<_FuncPtr object at 0x...>\n"

">>> print(windll.kernel32.MyOwnFunction)\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

" File \"ctypes.py\", line 239, in __getattr__\n"

" func = _StdcallFuncPtr(name, self)\n"

"AttributeError: function 'MyOwnFunction' not found\n"

">>>"

msgstr ""

">>> libc.printf\n"

"<_FuncPtr object at 0x...>\n"

">>> print(windll.kernel32.GetModuleHandleA)\n"

"<_FuncPtr object at 0x...>\n"

">>> print(windll.kernel32.MyOwnFunction)\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

" File \"ctypes.py\", line 239, in __getattr__\n"

" func = _StdcallFuncPtr(name, self)\n"

"AttributeError: function 'MyOwnFunction' not found\n"

">>>"

#: ../../library/ctypes.rst:108

msgid ""

"Note that win32 system dlls like ``kernel32`` and ``user32`` often export "

"ANSI as well as UNICODE versions of a function. The UNICODE version is "

"exported with a ``W`` appended to the name, while the ANSI version is "

"exported with an ``A`` appended to the name. The win32 ``GetModuleHandle`` "

"function, which returns a *module handle* for a given module name, has the "

"following C prototype, and a macro is used to expose one of them as "

"``GetModuleHandle`` depending on whether UNICODE is defined or not::"

msgstr ""

"请注意 win32 系统的动态库如 ``kernel32`` 和 ``user32`` 通常会同时导出一个函数的 ANSI 版本和 UNICODE "

"版本。 UNICODE 版本导出时会在名称后加上 ``W``，而 ANSI 版本导出时会在名称后加上 ``A``。 win32 "

"``GetModuleHandle`` 函数会为给定的模块名称返回一个 *模块句柄*，它具有以下的 C 原型，以及一个被用来根据是否定义了 "

"UNICODE 将其中之一暴露为 ``GetModuleHandle`` 的宏::"

#: ../../library/ctypes.rst:116

msgid ""

"/* ANSI version */\n"

"HMODULE GetModuleHandleA(LPCSTR lpModuleName);\n"

"/* UNICODE version */\n"

"HMODULE GetModuleHandleW(LPCWSTR lpModuleName);"

msgstr ""

"/* ANSI version */\n"

"HMODULE GetModuleHandleA(LPCSTR lpModuleName);\n"

"/* UNICODE version */\n"

"HMODULE GetModuleHandleW(LPCWSTR lpModuleName);"

#: ../../library/ctypes.rst:121

msgid ""

"*windll* does not try to select one of them by magic, you must access the "

"version you need by specifying ``GetModuleHandleA`` or ``GetModuleHandleW`` "

"explicitly, and then call it with bytes or string objects respectively."

msgstr ""

"*windll* 不会通过这样的魔法手段来帮你决定选择哪一种函数，你必须显式的调用 ``GetModuleHandleA`` 或 "

"``GetModuleHandleW``，并分别使用字节对象或字符串对象作参数。"

#: ../../library/ctypes.rst:125

msgid ""

"Sometimes, dlls export functions with names which aren't valid Python "

"identifiers, like ``\"??2@YAPAXI@Z\"``. In this case you have to use "

":func:`getattr` to retrieve the function::"

msgstr ""

"有时候，dlls的导出的函数名不符合 Python 的标识符规范，比如 ``\"??2@YAPAXI@Z\"``。此时，你必须使用 "

":func:`getattr` 方法来获得该函数。"

#: ../../library/ctypes.rst:129

msgid ""

">>> getattr(cdll.msvcrt, \"??2@YAPAXI@Z\")\n"

"<_FuncPtr object at 0x...>\n"

">>>"

msgstr ""

">>> getattr(cdll.msvcrt, \"??2@YAPAXI@Z\")\n"

"<_FuncPtr object at 0x...>\n"

">>>"

#: ../../library/ctypes.rst:133

msgid ""

"On Windows, some dlls export functions not by name but by ordinal. These "

"functions can be accessed by indexing the dll object with the ordinal "

"number::"

msgstr ""

"Windows 下，有些 dll 导出的函数没有函数名，而是通过其顺序号调用。对此类函数，你也可以通过 dll 对象的数值索引来操作这些函数。"

#: ../../library/ctypes.rst:136

msgid ""

">>> cdll.kernel32[1]\n"

"<_FuncPtr object at 0x...>\n"

">>> cdll.kernel32[0]\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

" File \"ctypes.py\", line 310, in __getitem__\n"

" func = _StdcallFuncPtr(name, self)\n"

"AttributeError: function ordinal 0 not found\n"

">>>"

msgstr ""

">>> cdll.kernel32[1]\n"

"<_FuncPtr object at 0x...>\n"

">>> cdll.kernel32[0]\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

" File \"ctypes.py\", line 310, in __getitem__\n"

" func = _StdcallFuncPtr(name, self)\n"

"AttributeError: function ordinal 0 not found\n"

">>>"

#: ../../library/ctypes.rst:150

msgid "Calling functions"

msgstr "调用函数"

#: ../../library/ctypes.rst:152

msgid ""

"You can call these functions like any other Python callable. This example "

"uses the ``rand()`` function, which takes no arguments and returns a pseudo-"

"random integer::"

msgstr ""

"你可以像任何其它 Python 可调用对象一样调用这些函数。 这个例子使用了 ``rand()`` 函数，它不接收任何参数并返回一个伪随机整数::"

#: ../../library/ctypes.rst:155

msgid ""

">>> print(libc.rand())\n"

"1804289383"

msgstr ""

">>> print(libc.rand())\n"

"1804289383"

#: ../../library/ctypes.rst:158

msgid ""

"On Windows, you can call the ``GetModuleHandleA()`` function, which returns "

"a win32 module handle (passing ``None`` as single argument to call it with a"

" ``NULL`` pointer)::"

msgstr ""

"在 Windows 上，你可以调用 ``GetModuleHandleA()`` 函数，它返回一个 win32 模块句柄 (将 ``None`` "

"作为唯一参数传入以使用 ``NULL`` 指针来调用它)::"

#: ../../library/ctypes.rst:161

msgid ""

">>> print(hex(windll.kernel32.GetModuleHandleA(None)))\n"

"0x1d000000\n"

">>>"

msgstr ""

">>> print(hex(windll.kernel32.GetModuleHandleA(None)))\n"

"0x1d000000\n"

">>>"

#: ../../library/ctypes.rst:165

msgid ""

":exc:`ValueError` is raised when you call an ``stdcall`` function with the "

"``cdecl`` calling convention, or vice versa::"

msgstr ""

"如果你用 ``cdecl`` 调用方式调用 ``stdcall`` 约定的函数，则会甩出一个异常 :exc:`ValueError`。反之亦然。"

#: ../../library/ctypes.rst:168

msgid ""

">>> cdll.kernel32.GetModuleHandleA(None)\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"ValueError: Procedure probably called with not enough arguments (4 bytes missing)\n"

">>>\n"

"\n"

">>> windll.msvcrt.printf(b\"spam\")\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"ValueError: Procedure probably called with too many arguments (4 bytes in excess)\n"

">>>"

msgstr ""

">>> cdll.kernel32.GetModuleHandleA(None)\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"ValueError: Procedure probably called with not enough arguments (4 bytes missing)\n"

">>>\n"

"\n"

">>> windll.msvcrt.printf(b\"spam\")\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"ValueError: Procedure probably called with too many arguments (4 bytes in excess)\n"

">>>"

#: ../../library/ctypes.rst:180

msgid ""

"To find out the correct calling convention you have to look into the C "

"header file or the documentation for the function you want to call."

msgstr "你必须阅读这些库的头文件或说明文档来确定它们的正确的调用协议。"

#: ../../library/ctypes.rst:183

msgid ""

"On Windows, :mod:`ctypes` uses win32 structured exception handling to "

"prevent crashes from general protection faults when functions are called "

"with invalid argument values::"

msgstr "在 Windows 中，:mod:`ctypes` 使用 win32 结构化异常处理来防止由于在调用函数时使用非法参数导致的程序崩溃。"

#: ../../library/ctypes.rst:187

msgid ""

">>> windll.kernel32.GetModuleHandleA(32)\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"OSError: exception: access violation reading 0x00000020\n"

">>>"

msgstr ""

">>> windll.kernel32.GetModuleHandleA(32)\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"OSError: exception: access violation reading 0x00000020\n"

">>>"

#: ../../library/ctypes.rst:193

msgid ""

"There are, however, enough ways to crash Python with :mod:`ctypes`, so you "

"should be careful anyway. The :mod:`faulthandler` module can be helpful in "

"debugging crashes (e.g. from segmentation faults produced by erroneous C "

"library calls)."

msgstr ""

"然而，总有许多办法，通过调用 :mod:`ctypes` 使得 Python 程序崩溃。因此，你必须小心使用。 :mod:`faulthandler` "

"模块可以用于帮助诊断程序崩溃的原因。（比如由于错误的C库函数调用导致的段错误）。"

#: ../../library/ctypes.rst:198

msgid ""

"``None``, integers, bytes objects and (unicode) strings are the only native "

"Python objects that can directly be used as parameters in these function "

"calls. ``None`` is passed as a C ``NULL`` pointer, bytes objects and strings"

" are passed as pointer to the memory block that contains their data "

"(:c:expr:`char *` or :c:expr:`wchar_t *`). Python integers are passed as "

"the platforms default C :c:expr:`int` type, their value is masked to fit "

"into the C type."

msgstr ""

"在原生 Python 对象中，``None``、整数、字节串以及（Unicode）字符串可以直接在这些函数调用中作为参数传递。 ``None`` 作为 "

"C 的 ``NULL`` 指针传递，字节串和字符串作为指向包含其数据的内存块的指针传递 (:c:expr:`char *` 或 "

":c:expr:`wchar_t *`)。 Python 整数以平台默认的 C 类型 :c:expr:`int` 传递，它们的值会被掩码化以适应 C "

"中的类型。"

#: ../../library/ctypes.rst:205

msgid ""

"Before we move on calling functions with other parameter types, we have to "

"learn more about :mod:`ctypes` data types."

msgstr "在我们开始调用函数前，我们必须先了解作为函数参数的 :mod:`ctypes` 数据类型。"

#: ../../library/ctypes.rst:212 ../../library/ctypes.rst:2237

msgid "Fundamental data types"

msgstr "基础数据类型"

#: ../../library/ctypes.rst:214

msgid ":mod:`ctypes` defines a number of primitive C compatible data types:"

msgstr ":mod:`ctypes` 定义了一些和C兼容的基本数据类型："

#: ../../library/ctypes.rst:217

msgid "ctypes type"

msgstr "ctypes 类型"

#: ../../library/ctypes.rst:217

msgid "C type"

msgstr "C 类型"

#: ../../library/ctypes.rst:217

msgid "Python type"

msgstr "Python 类型"

#: ../../library/ctypes.rst:219

msgid ":class:`c_bool`"

msgstr ":class:`c_bool`"

#: ../../library/ctypes.rst:219

msgid ":c:expr:`_Bool`"

msgstr ":c:expr:`_Bool`"

#: ../../library/ctypes.rst:219

msgid "bool (1)"

msgstr "bool (1)"

#: ../../library/ctypes.rst:221

msgid ":class:`c_char`"

msgstr ":class:`c_char`"

#: ../../library/ctypes.rst:221 ../../library/ctypes.rst:225

msgid ":c:expr:`char`"

msgstr ":c:expr:`char`"

#: ../../library/ctypes.rst:221

msgid "1-character bytes object"

msgstr "单字符字节串对象"

#: ../../library/ctypes.rst:223

msgid ":class:`c_wchar`"

msgstr ":class:`c_wchar`"

#: ../../library/ctypes.rst:223

msgid ":c:type:`wchar_t`"

msgstr ":c:type:`wchar_t`"

#: ../../library/ctypes.rst:223

msgid "1-character string"

msgstr "单字符字符串"

#: ../../library/ctypes.rst:225

msgid ":class:`c_byte`"

msgstr ":class:`c_byte`"

#: ../../library/ctypes.rst:225 ../../library/ctypes.rst:227

#: ../../library/ctypes.rst:229 ../../library/ctypes.rst:231

#: ../../library/ctypes.rst:233 ../../library/ctypes.rst:235

#: ../../library/ctypes.rst:237 ../../library/ctypes.rst:239

#: ../../library/ctypes.rst:241 ../../library/ctypes.rst:243

#: ../../library/ctypes.rst:246 ../../library/ctypes.rst:248

#: ../../library/ctypes.rst:251

msgid "int"

msgstr "int"

#: ../../library/ctypes.rst:227

msgid ":class:`c_ubyte`"

msgstr ":class:`c_ubyte`"

#: ../../library/ctypes.rst:227

msgid ":c:expr:`unsigned char`"

msgstr ":c:expr:`unsigned char`"

#: ../../library/ctypes.rst:229

msgid ":class:`c_short`"

msgstr ":class:`c_short`"

#: ../../library/ctypes.rst:229

msgid ":c:expr:`short`"

msgstr ":c:expr:`short`"

#: ../../library/ctypes.rst:231

msgid ":class:`c_ushort`"

msgstr ":class:`c_ushort`"

#: ../../library/ctypes.rst:231

msgid ":c:expr:`unsigned short`"

msgstr ":c:expr:`unsigned short`"

#: ../../library/ctypes.rst:233

msgid ":class:`c_int`"

msgstr ":class:`c_int`"

#: ../../library/ctypes.rst:233

msgid ":c:expr:`int`"

msgstr ":c:expr:`int`"

#: ../../library/ctypes.rst:235

msgid ":class:`c_uint`"

msgstr ":class:`c_uint`"

#: ../../library/ctypes.rst:235

msgid ":c:expr:`unsigned int`"

msgstr ":c:expr:`unsigned int`"

#: ../../library/ctypes.rst:237

msgid ":class:`c_long`"

msgstr ":class:`c_long`"

#: ../../library/ctypes.rst:237

msgid ":c:expr:`long`"

msgstr ":c:expr:`long`"

#: ../../library/ctypes.rst:239

msgid ":class:`c_ulong`"

msgstr ":class:`c_ulong`"

#: ../../library/ctypes.rst:239

msgid ":c:expr:`unsigned long`"

msgstr ":c:expr:`unsigned long`"

#: ../../library/ctypes.rst:241

msgid ":class:`c_longlong`"

msgstr ":class:`c_longlong`"

#: ../../library/ctypes.rst:241

msgid ":c:expr:`__int64` or :c:expr:`long long`"

msgstr ":c:expr:`__int64` 或 :c:expr:`long long`"

#: ../../library/ctypes.rst:243

msgid ":class:`c_ulonglong`"

msgstr ":class:`c_ulonglong`"

#: ../../library/ctypes.rst:243

msgid ":c:expr:`unsigned __int64` or :c:expr:`unsigned long long`"

msgstr ":c:expr:`unsigned __int64` 或 :c:expr:`unsigned long long`"

#: ../../library/ctypes.rst:246

msgid ":class:`c_size_t`"

msgstr ":class:`c_size_t`"

#: ../../library/ctypes.rst:246

msgid ":c:type:`size_t`"

msgstr ":c:type:`size_t`"

#: ../../library/ctypes.rst:248

msgid ":class:`c_ssize_t`"

msgstr ":class:`c_ssize_t`"

#: ../../library/ctypes.rst:248

msgid ":c:type:`ssize_t` or :c:expr:`Py_ssize_t`"

msgstr ":c:type:`ssize_t` 或 :c:expr:`Py_ssize_t`"

#: ../../library/ctypes.rst:251

msgid ":class:`c_time_t`"

msgstr ":class:`c_time_t`"

#: ../../library/ctypes.rst:251

msgid ":c:type:`time_t`"

msgstr ":c:type:`time_t`"

#: ../../library/ctypes.rst:253

msgid ":class:`c_float`"

msgstr ":class:`c_float`"

#: ../../library/ctypes.rst:253

msgid ":c:expr:`float`"

msgstr ":c:expr:`float`"

#: ../../library/ctypes.rst:253 ../../library/ctypes.rst:255

#: ../../library/ctypes.rst:257

msgid "float"

msgstr "float"

#: ../../library/ctypes.rst:255

msgid ":class:`c_double`"

msgstr ":class:`c_double`"

#: ../../library/ctypes.rst:255

msgid ":c:expr:`double`"

msgstr ":c:expr:`double`"

#: ../../library/ctypes.rst:257

msgid ":class:`c_longdouble`"

msgstr ":class:`c_longdouble`"

#: ../../library/ctypes.rst:257

msgid ":c:expr:`long double`"

msgstr ":c:expr:`long double`"

#: ../../library/ctypes.rst:259

msgid ":class:`c_char_p`"

msgstr ":class:`c_char_p`"

#: ../../library/ctypes.rst:259

msgid ":c:expr:`char *` (NUL terminated)"

msgstr ":c:expr:`char *` (以 NUL 结尾)"

#: ../../library/ctypes.rst:259

msgid "bytes object or ``None``"

msgstr "字节串对象或 ``None``"

#: ../../library/ctypes.rst:261

msgid ":class:`c_wchar_p`"

msgstr ":class:`c_wchar_p`"

#: ../../library/ctypes.rst:261

msgid ":c:expr:`wchar_t *` (NUL terminated)"

msgstr ":c:expr:`wchar_t *` (以 NUL 结尾)"

#: ../../library/ctypes.rst:261

msgid "string or ``None``"

msgstr "字符串或 ``None``"

#: ../../library/ctypes.rst:263

msgid ":class:`c_void_p`"

msgstr ":class:`c_void_p`"

#: ../../library/ctypes.rst:263

msgid ":c:expr:`void *`"

msgstr ":c:expr:`void *`"

#: ../../library/ctypes.rst:263

msgid "int or ``None``"

msgstr "int 或 ``None``"

#: ../../library/ctypes.rst:267

msgid "The constructor accepts any object with a truth value."

msgstr "构造函数接受任何具有真值的对象。"

#: ../../library/ctypes.rst:269

msgid ""

"All these types can be created by calling them with an optional initializer "

"of the correct type and value::"

msgstr "所有这些类型都可以通过使用正确类型和值的可选初始值调用它们来创建::"

#: ../../library/ctypes.rst:272

msgid ""

">>> c_int()\n"

"c_long(0)\n"

">>> c_wchar_p(\"Hello, World\")\n"

"c_wchar_p(140018365411392)\n"

">>> c_ushort(-3)\n"

"c_ushort(65533)\n"

">>>"

msgstr ""

">>> c_int()\n"

"c_long(0)\n"

">>> c_wchar_p(\"Hello, World\")\n"

"c_wchar_p(140018365411392)\n"

">>> c_ushort(-3)\n"

"c_ushort(65533)\n"

">>>"

#: ../../library/ctypes.rst:280

msgid ""

"Since these types are mutable, their value can also be changed afterwards::"

msgstr "由于这些类型是可变的，它们的值也可以在以后更改::"

#: ../../library/ctypes.rst:282

msgid ""

">>> i = c_int(42)\n"

">>> print(i)\n"

"c_long(42)\n"

">>> print(i.value)\n"

"42\n"

">>> i.value = -99\n"

">>> print(i.value)\n"

"-99\n"

">>>"

msgstr ""

">>> i = c_int(42)\n"

">>> print(i)\n"

"c_long(42)\n"

">>> print(i.value)\n"

"42\n"

">>> i.value = -99\n"

">>> print(i.value)\n"

"-99\n"

">>>"

#: ../../library/ctypes.rst:292

msgid ""

"Assigning a new value to instances of the pointer types :class:`c_char_p`, "

":class:`c_wchar_p`, and :class:`c_void_p` changes the *memory location* they"

" point to, *not the contents* of the memory block (of course not, because "

"Python bytes objects are immutable)::"

msgstr ""

"当给指针类型的对象 :class:`c_char_p`, :class:`c_wchar_p` 和 :class:`c_void_p` "

"等赋值时，将改变它们所指向的 *内存地址*，而 *不是* 它们所指向的内存区域的 *内容* (这是理所当然的，因为 Python 的 bytes "

"对象是不可变的)::"

#: ../../library/ctypes.rst:297

msgid ""

">>> s = \"Hello, World\"\n"

">>> c_s = c_wchar_p(s)\n"

">>> print(c_s)\n"

"c_wchar_p(139966785747344)\n"

">>> print(c_s.value)\n"

"Hello World\n"

">>> c_s.value = \"Hi, there\"\n"

">>> print(c_s) # the memory location has changed\n"

"c_wchar_p(139966783348904)\n"

">>> print(c_s.value)\n"

"Hi, there\n"

">>> print(s) # first object is unchanged\n"

"Hello, World\n"

">>>"

msgstr ""

">>> s = \"Hello, World\"\n"

">>> c_s = c_wchar_p(s)\n"

">>> print(c_s)\n"

"c_wchar_p(139966785747344)\n"

">>> print(c_s.value)\n"

"Hello World\n"

">>> c_s.value = \"Hi, there\"\n"

">>> print(c_s) # 内存分配已改变\n"

"c_wchar_p(139966783348904)\n"

">>> print(c_s.value)\n"

"Hi, there\n"

">>> print(s) # 第一个对象未改变\n"

"Hello, World\n"

">>>"

#: ../../library/ctypes.rst:312

msgid ""

"You should be careful, however, not to pass them to functions expecting "

"pointers to mutable memory. If you need mutable memory blocks, ctypes has a "

":func:`create_string_buffer` function which creates these in various ways. "

"The current memory block contents can be accessed (or changed) with the "

"``raw`` property; if you want to access it as NUL terminated string, use the"

" ``value`` property::"

msgstr ""

"但你要注意不能将它们传递给会改变指针所指内存的函数。如果你需要可改变的内存块，ctypes 提供了 "

":func:`create_string_buffer` 函数，它提供多种方式创建这种内存块。当前的内存块内容可以通过 ``raw`` "

"属性存取，如果你希望将它作为NUL结束的字符串，请使用 ``value`` 属性::"

#: ../../library/ctypes.rst:319

msgid ""

">>> from ctypes import *\n"

">>> p = create_string_buffer(3) # create a 3 byte buffer, initialized to NUL bytes\n"

">>> print(sizeof(p), repr(p.raw))\n"

"3 b'\\x00\\x00\\x00'\n"

">>> p = create_string_buffer(b\"Hello\") # create a buffer containing a NUL terminated string\n"

">>> print(sizeof(p), repr(p.raw))\n"

"6 b'Hello\\x00'\n"

">>> print(repr(p.value))\n"

"b'Hello'\n"

">>> p = create_string_buffer(b\"Hello\", 10) # create a 10 byte buffer\n"

">>> print(sizeof(p), repr(p.raw))\n"

"10 b'Hello\\x00\\x00\\x00\\x00\\x00'\n"

">>> p.value = b\"Hi\"\n"

">>> print(sizeof(p), repr(p.raw))\n"

"10 b'Hi\\x00lo\\x00\\x00\\x00\\x00\\x00'\n"

">>>"

msgstr ""

">>> from ctypes import *\n"

">>> p = create_string_buffer(3) # 创建一个 3 字节的缓冲区，初始化为 NUL 字节\n"

">>> print(sizeof(p), repr(p.raw))\n"

"3 b'\\x00\\x00\\x00'\n"

">>> p = create_string_buffer(b\"Hello\") # 创建一个包含以 NUL 结束的字符串的缓冲区\n"

">>> print(sizeof(p), repr(p.raw))\n"

"6 b'Hello\\x00'\n"

">>> print(repr(p.value))\n"

"b'Hello'\n"

">>> p = create_string_buffer(b\"Hello\", 10) # 创建一个 10 字节的缓冲区\n"

">>> print(sizeof(p), repr(p.raw))\n"

"10 b'Hello\\x00\\x00\\x00\\x00\\x00'\n"

">>> p.value = b\"Hi\"\n"

">>> print(sizeof(p), repr(p.raw))\n"

"10 b'Hi\\x00lo\\x00\\x00\\x00\\x00\\x00'\n"

">>>"

#: ../../library/ctypes.rst:336

msgid ""

"The :func:`create_string_buffer` function replaces the old :func:`!c_buffer`"

" function (which is still available as an alias). To create a mutable "

"memory block containing unicode characters of the C type :c:type:`wchar_t`, "

"use the :func:`create_unicode_buffer` function."

msgstr ""

":func:`create_string_buffer` 函数取代了旧了 :func:`!c_buffer` 函数（后者仍可作为别名使用）。 "

"要创建一个包含 C 类型 :c:type:`wchar_t` 的 unicode 字符的可变内存块，请使用 "

":func:`create_unicode_buffer` 函数。"

#: ../../library/ctypes.rst:345

msgid "Calling functions, continued"

msgstr "调用函数，继续"

#: ../../library/ctypes.rst:347

msgid ""

"Note that printf prints to the real standard output channel, *not* to "

":data:`sys.stdout`, so these examples will only work at the console prompt, "

"not from within *IDLE* or *PythonWin*::"

msgstr ""

"注意 printf 将打印到真正标准输出设备，而*不是* :data:`sys.stdout`，因此这些实例只能在控制台提示符下工作，而不能在 "

"*IDLE* 或 *PythonWin* 中运行。"

#: ../../library/ctypes.rst:351

msgid ""

">>> printf = libc.printf\n"

">>> printf(b\"Hello, %s\\n\", b\"World!\")\n"

"Hello, World!\n"

"14\n"

">>> printf(b\"Hello, %S\\n\", \"World!\")\n"

"Hello, World!\n"

"14\n"

">>> printf(b\"%d bottles of beer\\n\", 42)\n"

"42 bottles of beer\n"

"19\n"

">>> printf(b\"%f bottles of beer\\n\", 42.5)\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"ArgumentError: argument 2: TypeError: Don't know how to convert parameter 2\n"

">>>"

msgstr ""

#: ../../library/ctypes.rst:367

msgid ""

"As has been mentioned before, all Python types except integers, strings, and"

" bytes objects have to be wrapped in their corresponding :mod:`ctypes` type,"

" so that they can be converted to the required C data type::"

msgstr ""

"正如前面所提到过的，除了整数、字符串以及字节串之外，所有的 Python 类型都必须使用它们对应的 :mod:`ctypes` "

"类型包装，才能够被正确地转换为所需的C语言类型。"

#: ../../library/ctypes.rst:371

msgid ""

">>> printf(b\"An int %d, a double %f\\n\", 1234, c_double(3.14))\n"

"An int 1234, a double 3.140000\n"

"31\n"

">>>"

msgstr ""

">>> printf(b\"An int %d, a double %f\\n\", 1234, c_double(3.14))\n"

"An int 1234, a double 3.140000\n"

"31\n"

">>>"

#: ../../library/ctypes.rst:379

msgid "Calling variadic functions"

msgstr "调用可变函数"

#: ../../library/ctypes.rst:381

msgid ""

"On a lot of platforms calling variadic functions through ctypes is exactly "

"the same as calling functions with a fixed number of parameters. On some "

"platforms, and in particular ARM64 for Apple Platforms, the calling "

"convention for variadic functions is different than that for regular "

"functions."

msgstr ""

"在许多平台上通过 ctypes 调用可变函数与调用带有固定数量形参的函数是完全一样的。 在某些平台，特别是针对 Apple 平台的 ARM64 "

"上，可变函数的调用约定与常规函数则是不同的。"

#: ../../library/ctypes.rst:386

msgid ""

"On those platforms it is required to specify the :attr:`~_CFuncPtr.argtypes`"

" attribute for the regular, non-variadic, function arguments:"

msgstr "在这些平台上要求为常规、非可变函数参数指定 :attr:`~_CFuncPtr.argtypes` 属性："

#: ../../library/ctypes.rst:389

msgid "libc.printf.argtypes = [ctypes.c_char_p]"

msgstr "libc.printf.argtypes = [ctypes.c_char_p]"

#: ../../library/ctypes.rst:393

msgid ""

"Because specifying the attribute does not inhibit portability it is advised "

"to always specify :attr:`~_CFuncPtr.argtypes` for all variadic functions."

msgstr "因为指定该属性不会影响可移植性所以建议总是为所有可变函数指定 :attr:`~_CFuncPtr.argtypes`。"

#: ../../library/ctypes.rst:400

msgid "Calling functions with your own custom data types"

msgstr "使用自定义的数据类型调用函数"

#: ../../library/ctypes.rst:402

msgid ""

"You can also customize :mod:`ctypes` argument conversion to allow instances "

"of your own classes be used as function arguments. :mod:`ctypes` looks for "

"an :attr:`!_as_parameter_` attribute and uses this as the function argument."

" The attribute must be an integer, string, bytes, a :mod:`ctypes` instance, "

"or an object with an :attr:`!_as_parameter_` attribute::"

msgstr ""

"您也可以通过自定义 :mod:`ctypes` 参数转换方式来允许将你自己的类实例作为函数参数。 :mod:`ctypes` 会寻找 "

":attr:`!_as_parameter_` 属性并使用它作为函数参数。 属性必须是整数、字符串、字节串、:mod:`ctypes` 实例或者带有 "

":attr:`!_as_parameter_` 属性的对象::"

#: ../../library/ctypes.rst:408

msgid ""

">>> class Bottles:\n"

"... def __init__(self, number):\n"

"... self._as_parameter_ = number\n"

"...\n"

">>> bottles = Bottles(42)\n"

">>> printf(b\"%d bottles of beer\\n\", bottles)\n"

"42 bottles of beer\n"

"19\n"

">>>"

msgstr ""

">>> class Bottles:\n"

"... def __init__(self, number):\n"

"... self._as_parameter_ = number\n"

"...\n"

">>> bottles = Bottles(42)\n"

">>> printf(b\"%d bottles of beer\\n\", bottles)\n"

"42 bottles of beer\n"

"19\n"

">>>"

#: ../../library/ctypes.rst:418

msgid ""

"If you don't want to store the instance's data in the "

":attr:`!_as_parameter_` instance variable, you could define a "

":class:`property` which makes the attribute available on request."

msgstr ""

"如果你不想将实例数据存储在 :attr:`!_as_parameter_` 实例变量中，可以定义一个根据请求提供属性的 "

":class:`property`。"

#: ../../library/ctypes.rst:426

msgid "Specifying the required argument types (function prototypes)"

msgstr "指定必选参数的类型(函数原型)"

#: ../../library/ctypes.rst:428

msgid ""

"It is possible to specify the required argument types of functions exported "

"from DLLs by setting the :attr:`~_CFuncPtr.argtypes` attribute."

msgstr "可以通过设置 :attr:`~_CFuncPtr.argtypes` 属性来指定从 DLL 导出函数的必选参数类型。"

#: ../../library/ctypes.rst:431

msgid ""

":attr:`~_CFuncPtr.argtypes` must be a sequence of C data types (the "

":func:`!printf` function is probably not a good example here, because it "

"takes a variable number and different types of parameters depending on the "

"format string, on the other hand this is quite handy to experiment with this"

" feature)::"

msgstr ""

":attr:`~_CFuncPtr.argtypes` 必须是一个 C 数据类型的序列（这里 :func:`!printf` "

"函数可能不是一个好例子，因为它会根据格式字符串的不同接受可变数量和不同类型的形参，但另一方面这对尝试此功能来说也很方便）::"

#: ../../library/ctypes.rst:436

msgid ""

">>> printf.argtypes = [c_char_p, c_char_p, c_int, c_double]\n"

">>> printf(b\"String '%s', Int %d, Double %f\\n\", b\"Hi\", 10, 2.2)\n"

"String 'Hi', Int 10, Double 2.200000\n"

"37\n"

">>>"

msgstr ""

">>> printf.argtypes = [c_char_p, c_char_p, c_int, c_double]\n"

">>> printf(b\"String '%s', Int %d, Double %f\\n\", b\"Hi\", 10, 2.2)\n"

"String 'Hi', Int 10, Double 2.200000\n"

"37\n"

">>>"

#: ../../library/ctypes.rst:442

msgid ""

"Specifying a format protects against incompatible argument types (just as a "

"prototype for a C function), and tries to convert the arguments to valid "

"types::"

msgstr "指定数据类型可以防止不合理的参数传递（就像 C 函数的原型），并且会自动尝试将参数转换为需要的类型::"

#: ../../library/ctypes.rst:445

msgid ""

">>> printf(b\"%d %d %d\", 1, 2, 3)\n"

"Traceback (most recent call last):\n"

" File \"<stdin>\", line 1, in <module>\n"

"ArgumentError: argument 2: TypeError: wrong type\n"

">>> printf(b\"%s %d %f\\n\", b\"X\", 2, 3)\n"

"X 2 3.000000\n"

"13\n"

">>>"

msgstr ""

#: ../../library/ctypes.rst:454

msgid ""

"If you have defined your own classes which you pass to function calls, you "

"have to implement a :meth:`~_CData.from_param` class method for them to be "

"able to use them in the :attr:`~_CFuncPtr.argtypes` sequence. The "

":meth:`~_CData.from_param` class method receives the Python object passed to"

" the function call, it should do a typecheck or whatever is needed to make "

"sure this object is acceptable, and then return the object itself, its "

":attr:`!_as_parameter_` attribute, or whatever you want to pass as the C "

"function argument in this case. Again, the result should be an integer, "

"string, bytes, a :mod:`ctypes` instance, or an object with an "

":attr:`!_as_parameter_` attribute."