struct.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2021, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
# 
# Translators:
# Shengjing Zhu <zsj950618@gmail.com>, 2019
# dannyvi <dannyvis@icloud.com>, 2019
# Alpha Du <alphanow@gmail.com>, 2019
# Pandaaaa906 <ye.pandaaaa906@gmail.com>, 2019
# nick <2330458484@qq.com>, 2019
# ppcfish <ppcfish@gmail.com>, 2019
# 1lin24 <1lin24@sina.com>, 2019
# Freesand Leo <yuqinju@163.com>, 2020
# 
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.7\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2021-01-01 16:02+0000\n"
"PO-Revision-Date: 2019-09-01 03:14+0000\n"
"Last-Translator: Freesand Leo <yuqinju@163.com>, 2020\n"
"Language-Team: Chinese (China) (https://www.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/struct.rst:2
msgid ":mod:`struct` --- Interpret bytes as packed binary data"
msgstr ":mod:`struct` --- 将字节串解读为打包的二进制数据"

#: ../../library/struct.rst:7
msgid "**Source code:** :source:`Lib/struct.py`"
msgstr "**源代码：** :source:`Lib/struct.py`"

#: ../../library/struct.rst:15
msgid ""
"This module performs conversions between Python values and C structs "
"represented as Python :class:`bytes` objects.  This can be used in handling "
"binary data stored in files or from network connections, among other "
"sources.  It uses :ref:`struct-format-strings` as compact descriptions of "
"the layout of the C structs and the intended conversion to/from Python "
"values."
msgstr ""
"此模块可以执行 Python 值和以 Python :class:`bytes` 对象表示的 C 结构之间的转换。 "
"这可以被用来处理存储在文件中或是从网络连接等其他来源获取的二进制数据。 它使用 :ref:`struct-format-strings` 作为 C "
"结构布局的精简描述以及与 Python 值的双向转换。"

#: ../../library/struct.rst:23
msgid ""
"By default, the result of packing a given C struct includes pad bytes in "
"order to maintain proper alignment for the C types involved; similarly, "
"alignment is taken into account when unpacking.  This behavior is chosen so "
"that the bytes of a packed struct correspond exactly to the layout in memory"
" of the corresponding C struct.  To handle platform-independent data formats"
" or omit implicit pad bytes, use ``standard`` size and alignment instead of "
"``native`` size and alignment: see :ref:`struct-alignment` for details."
msgstr ""
"默认情况下，打包给定 C 结构的结果会包含填充字节以使得所涉及的 C 类型保持正确的对齐；类似地，对齐在解包时也会被纳入考虑。 "
"选择此种行为的目的是使得被打包结构的字节能与相应 C 结构在内存中的布局完全一致。 要处理平台独立的数据格式或省略隐式的填充字节，请使用 "
"``standard`` 大小和对齐而不是 ``native`` 大小和对齐：详情参见 :ref:`struct-alignment`。"

#: ../../library/struct.rst:31
msgid ""
"Several :mod:`struct` functions (and methods of :class:`Struct`) take a "
"*buffer* argument.  This refers to objects that implement the "
":ref:`bufferobjects` and provide either a readable or read-writable buffer."
"  The most common types used for that purpose are :class:`bytes` and "
":class:`bytearray`, but many other types that can be viewed as an array of "
"bytes implement the buffer protocol, so that they can be read/filled without"
" additional copying from a :class:`bytes` object."
msgstr ""
"某些 :mod:`struct` 的函数（以及 :class:`Struct` 的方法）接受一个 *buffer* 参数。 这将指向实现了 "
":ref:`bufferobjects` 并提供只读或是可读写缓冲的对象。 用于此目的的最常见类型为 :class:`bytes` 和 "
":class:`bytearray`，但许多其他可被视为字节数组的类型也实现了缓冲协议，因此它们无需额外从 :class:`bytes` "
"对象复制即可被读取或填充。"

#: ../../library/struct.rst:40
msgid "Functions and Exceptions"
msgstr "函数和异常"

#: ../../library/struct.rst:42
msgid "The module defines the following exception and functions:"
msgstr "此模块定义了下列异常和函数："

#: ../../library/struct.rst:47
msgid ""
"Exception raised on various occasions; argument is a string describing what "
"is wrong."
msgstr "会在多种场合下被引发的异常；其参数为一个描述错误信息的字符串。"

#: ../../library/struct.rst:53
msgid ""
"Return a bytes object containing the values *v1*, *v2*, ... packed according"
" to the format string *format*.  The arguments must match the values "
"required by the format exactly."
msgstr ""
"返回一个 bytes 对象，其中包含根据格式字符串 *format* 打包的值 *v1*, *v2*, ... "
"参数个数必须与格式字符串所要求的值完全匹配。"

#: ../../library/struct.rst:60
msgid ""
"Pack the values *v1*, *v2*, ... according to the format string *format* and "
"write the packed bytes into the writable buffer *buffer* starting at "
"position *offset*.  Note that *offset* is a required argument."
msgstr ""
"根据格式字符串 *format* 打包 *v1*, *v2*, ... 等值并将打包的字节串写入可写缓冲区 *buffer* 从 *offset* "
"开始的位置。 请注意 *offset* 是必需的参数。"

#: ../../library/struct.rst:67
msgid ""
"Unpack from the buffer *buffer* (presumably packed by ``pack(format, ...)``)"
" according to the format string *format*.  The result is a tuple even if it "
"contains exactly one item.  The buffer's size in bytes must match the size "
"required by the format, as reflected by :func:`calcsize`."
msgstr ""
"根据格式字符串 *format* 从缓冲区 *buffer* 解包（假定是由 ``pack(format, ...)`` 打包）。 "
"结果为一个元组，即使其只包含一个条目。 缓冲区的字节大小必须匹配格式所要求的大小，如 :func:`calcsize` 所示。"

#: ../../library/struct.rst:75
msgid ""
"Unpack from *buffer* starting at position *offset*, according to the format "
"string *format*.  The result is a tuple even if it contains exactly one "
"item.  The buffer's size in bytes, minus *offset*, must be at least the size"
" required by the format, as reflected by :func:`calcsize`."
msgstr ""
"对 *buffer* 从 *offset* 开始的位置根据格式字符串 *format* 进行解包。 结果为一个元组，即使其只包含一个条目。 "
"缓冲区的字节大小减去 *offset* 必须匹配格式所要求的大小，如 :func:`calcsize` 所示。"

#: ../../library/struct.rst:83
msgid ""
"Iteratively unpack from the buffer *buffer* according to the format string "
"*format*.  This function returns an iterator which will read equally-sized "
"chunks from the buffer until all its contents have been consumed.  The "
"buffer's size in bytes must be a multiple of the size required by the "
"format, as reflected by :func:`calcsize`."
msgstr ""
"根据格式字符串 *format* 以迭代方式从缓冲区 *buffer* 解包。 此函数返回一个迭代器，它将从缓冲区读取相同大小的块直至其内容全部耗尽。 "
"缓冲区的字节大小必须整数倍于格式所要求的大小，如 :func:`calcsize` 所示。"

#: ../../library/struct.rst:89
msgid "Each iteration yields a tuple as specified by the format string."
msgstr "每次迭代将产生一个如格式字符串所指定的元组。"

#: ../../library/struct.rst:96
msgid ""
"Return the size of the struct (and hence of the bytes object produced by "
"``pack(format, ...)``) corresponding to the format string *format*."
msgstr "返回与格式字符串 *format* 相对应的结构的大小（亦即 ``pack(format, ...)`` 所产生的字节串对象的大小）。"

#: ../../library/struct.rst:103
msgid "Format Strings"
msgstr "格式字符串"

#: ../../library/struct.rst:105
msgid ""
"Format strings are the mechanism used to specify the expected layout when "
"packing and unpacking data.  They are built up from :ref:`format-"
"characters`, which specify the type of data being packed/unpacked.  In "
"addition, there are special characters for controlling the :ref:`struct-"
"alignment`."
msgstr ""
"格式字符串是用来在打包和解包数据时指定预期布局的机制。 它们使用指定被打包/解包数据类型的 :ref:`format-characters` 进行构建。"
" 此外，还有一些特殊字符用来控制 :ref:`struct-alignment`。"

#: ../../library/struct.rst:114
msgid "Byte Order, Size, and Alignment"
msgstr "字节顺序，大小和对齐方式"

#: ../../library/struct.rst:116
msgid ""
"By default, C types are represented in the machine's native format and byte "
"order, and properly aligned by skipping pad bytes if necessary (according to"
" the rules used by the C compiler)."
msgstr "默认情况下，C类型以机器的本机格式和字节顺序表示，并在必要时通过跳过填充字节进行正确对齐（根据C编译器使用的规则）。"

#: ../../library/struct.rst:127
msgid ""
"Alternatively, the first character of the format string can be used to "
"indicate the byte order, size and alignment of the packed data, according to"
" the following table:"
msgstr "或者，根据下表，格式字符串的第一个字符可用于指示打包数据的字节顺序，大小和对齐方式："

#: ../../library/struct.rst:132
msgid "Character"
msgstr "字符"

#: ../../library/struct.rst:132
msgid "Byte order"
msgstr "字节顺序"

#: ../../library/struct.rst:132
msgid "Size"
msgstr "大小"

#: ../../library/struct.rst:132
msgid "Alignment"
msgstr "对齐方式"

#: ../../library/struct.rst:134
msgid "``@``"
msgstr "``@``"

#: ../../library/struct.rst:134 ../../library/struct.rst:134
#: ../../library/struct.rst:134 ../../library/struct.rst:136
msgid "native"
msgstr "按原字节"

#: ../../library/struct.rst:136
msgid "``=``"
msgstr "``=``"

#: ../../library/struct.rst:136 ../../library/struct.rst:138
#: ../../library/struct.rst:140 ../../library/struct.rst:142
msgid "standard"
msgstr "标准"

#: ../../library/struct.rst:136 ../../library/struct.rst:138
#: ../../library/struct.rst:140 ../../library/struct.rst:142
msgid "none"
msgstr "无"

#: ../../library/struct.rst:138
msgid "``<``"
msgstr "``<``"

#: ../../library/struct.rst:138
msgid "little-endian"
msgstr "小端"

#: ../../library/struct.rst:140
msgid "``>``"
msgstr "``>``"

#: ../../library/struct.rst:140
msgid "big-endian"
msgstr "大端"

#: ../../library/struct.rst:142
msgid "``!``"
msgstr "``!``"

#: ../../library/struct.rst:142
msgid "network (= big-endian)"
msgstr "网络（=大端）"

#: ../../library/struct.rst:145
msgid "If the first character is not one of these, ``'@'`` is assumed."
msgstr "如果第一个字符不是其中之一，则假定为 ``'@'`` 。"

#: ../../library/struct.rst:147
msgid ""
"Native byte order is big-endian or little-endian, depending on the host "
"system. For example, Intel x86 and AMD64 (x86-64) are little-endian; "
"Motorola 68000 and PowerPC G5 are big-endian; ARM and Intel Itanium feature "
"switchable endianness (bi-endian). Use ``sys.byteorder`` to check the "
"endianness of your system."
msgstr ""
"本机字节顺序可能为大端或是小端，取决于主机系统的不同。 例如， Intel x86 和 AMD64 (x86-64) 是小端的；Motorola "
"68000 和 PowerPC G5 是大端的；ARM 和 Intel Itanium 具有可切换的字节顺序（双端）。 请使用 "
"``sys.byteorder`` 来检查你的系统字节顺序。"

#: ../../library/struct.rst:153
msgid ""
"Native size and alignment are determined using the C compiler's ``sizeof`` "
"expression.  This is always combined with native byte order."
msgstr "本机大小和对齐方式是使用 C 编译器的 ``sizeof`` 表达式来确定的。 这总是会与本机字节顺序相绑定。"

#: ../../library/struct.rst:156
msgid ""
"Standard size depends only on the format character;  see the table in the "
":ref:`format-characters` section."
msgstr "标准大小仅取决于格式字符；请参阅 :ref:`format-characters` 部分中的表格。"

#: ../../library/struct.rst:159
msgid ""
"Note the difference between ``'@'`` and ``'='``: both use native byte order,"
" but the size and alignment of the latter is standardized."
msgstr "请注意 ``'@'`` 和 ``'='`` 之间的区别：两个都使用本机字节顺序，但后者的大小和对齐方式是标准化的。"

#: ../../library/struct.rst:162
msgid ""
"The form ``'!'`` is available for those poor souls who claim they can't "
"remember whether network byte order is big-endian or little-endian."
msgstr "格式 ``'!'`` 适合给那些宣称他们记不得网络字节顺序是大端还是小端的可怜人使用。"

#: ../../library/struct.rst:165
msgid ""
"There is no way to indicate non-native byte order (force byte-swapping); use"
" the appropriate choice of ``'<'`` or ``'>'``."
msgstr "没有什么方式能指定非本机字节顺序（强制字节对调）；请正确选择使用 ``'<'`` 或 ``'>'``。"

#: ../../library/struct.rst:168 ../../library/struct.rst:247
msgid "Notes:"
msgstr "注释:"

#: ../../library/struct.rst:170
msgid ""
"Padding is only automatically added between successive structure members. No"
" padding is added at the beginning or the end of the encoded struct."
msgstr "填充只会在连续结构成员之间自动添加。 填充不会添加到已编码结构的开头和末尾。"

#: ../../library/struct.rst:173
msgid ""
"No padding is added when using non-native size and alignment, e.g. with '<',"
" '>', '=', and '!'."
msgstr "当使用非本机大小和对齐方式即 '<', '>', '=', and '!' 时不会添加任何填充。"

#: ../../library/struct.rst:176
msgid ""
"To align the end of a structure to the alignment requirement of a particular"
" type, end the format with the code for that type with a repeat count of "
"zero.  See :ref:`struct-examples`."
msgstr ""
"要将结构的末尾对齐到符合特定类型的对齐要求，请以该类型代码加重复计数的零作为格式结束。 参见 :ref:`struct-examples`。"

#: ../../library/struct.rst:184
msgid "Format Characters"
msgstr "格式字符"

#: ../../library/struct.rst:186
msgid ""
"Format characters have the following meaning; the conversion between C and "
"Python values should be obvious given their types.  The 'Standard size' "
"column refers to the size of the packed value in bytes when using standard "
"size; that is, when the format string starts with one of ``'<'``, ``'>'``, "
"``'!'`` or ``'='``.  When using native size, the size of the packed value is"
" platform-dependent."
msgstr ""
"格式字符具有以下含义；C 和 Python 值之间的按其指定类型的转换应当是相当明显的。 "
"‘标准大小’列是指当使用标准大小时以字节表示的已打包值大小；也就是当格式字符串以 ``'<'``, ``'>'``, ``'!'`` 或 ``'='``"
" 之一开头的情况。 当使用本机大小时，已打包值的大小取决于具体的平台。"

#: ../../library/struct.rst:194
msgid "Format"
msgstr "格式"

#: ../../library/struct.rst:194
msgid "C Type"
msgstr "C 类型"

#: ../../library/struct.rst:194
msgid "Python type"
msgstr "Python 类型"

#: ../../library/struct.rst:194
msgid "Standard size"
msgstr "标准大小"

#: ../../library/struct.rst:194
msgid "Notes"
msgstr "注释"

#: ../../library/struct.rst:196
msgid "``x``"
msgstr "``x``"

#: ../../library/struct.rst:196
msgid "pad byte"
msgstr "填充字节"

#: ../../library/struct.rst:196
msgid "no value"
msgstr "无"

#: ../../library/struct.rst:198
msgid "``c``"
msgstr "``c``"

#: ../../library/struct.rst:198
msgid ":c:type:`char`"
msgstr ":c:type:`char`"

#: ../../library/struct.rst:198
msgid "bytes of length 1"
msgstr "长度为 1 的字节串"

#: ../../library/struct.rst:198 ../../library/struct.rst:200
#: ../../library/struct.rst:202 ../../library/struct.rst:204
msgid "1"
msgstr "1"

#: ../../library/struct.rst:200
msgid "``b``"
msgstr "``b``"

#: ../../library/struct.rst:200
msgid ":c:type:`signed char`"
msgstr ":c:type:`signed char`"

#: ../../library/struct.rst:200 ../../library/struct.rst:202
#: ../../library/struct.rst:206 ../../library/struct.rst:208
#: ../../library/struct.rst:210 ../../library/struct.rst:212
#: ../../library/struct.rst:214 ../../library/struct.rst:216
#: ../../library/struct.rst:218 ../../library/struct.rst:220
#: ../../library/struct.rst:223 ../../library/struct.rst:225
#: ../../library/struct.rst:237
msgid "integer"
msgstr "整数"

#: ../../library/struct.rst:200
msgid "\\(1), \\(2)"
msgstr "\\(1), \\(2)"

#: ../../library/struct.rst:202
msgid "``B``"
msgstr "``B``"

#: ../../library/struct.rst:202
msgid ":c:type:`unsigned char`"
msgstr ":c:type:`unsigned char`"

#: ../../library/struct.rst:202 ../../library/struct.rst:206
#: ../../library/struct.rst:208 ../../library/struct.rst:210
#: ../../library/struct.rst:212 ../../library/struct.rst:214
#: ../../library/struct.rst:216 ../../library/struct.rst:218
#: ../../library/struct.rst:220
msgid "\\(2)"
msgstr "\\(2)"

#: ../../library/struct.rst:204
msgid "``?``"
msgstr "``?``"

#: ../../library/struct.rst:204
msgid ":c:type:`_Bool`"
msgstr ":c:type:`_Bool`"

#: ../../library/struct.rst:204
msgid "bool"
msgstr "bool"

#: ../../library/struct.rst:204
msgid "\\(1)"
msgstr "\\(1)"

#: ../../library/struct.rst:206
msgid "``h``"
msgstr "``h``"

#: ../../library/struct.rst:206
msgid ":c:type:`short`"
msgstr ":c:type:`short`"

#: ../../library/struct.rst:206 ../../library/struct.rst:208
#: ../../library/struct.rst:227
msgid "2"
msgstr "2"

#: ../../library/struct.rst:208
msgid "``H``"
msgstr "``H``"

#: ../../library/struct.rst:208
msgid ":c:type:`unsigned short`"
msgstr ":c:type:`unsigned short`"

#: ../../library/struct.rst:210
msgid "``i``"
msgstr "``i``"

#: ../../library/struct.rst:210
msgid ":c:type:`int`"
msgstr ":c:type:`int`"

#: ../../library/struct.rst:210 ../../library/struct.rst:212
#: ../../library/struct.rst:214 ../../library/struct.rst:216
#: ../../library/struct.rst:229
msgid "4"
msgstr "4"

#: ../../library/struct.rst:212
msgid "``I``"
msgstr "``I``"

#: ../../library/struct.rst:212
msgid ":c:type:`unsigned int`"
msgstr ":c:type:`unsigned int`"

#: ../../library/struct.rst:214
msgid "``l``"
msgstr "``l``"

#: ../../library/struct.rst:214
msgid ":c:type:`long`"
msgstr ":c:type:`long`"

#: ../../library/struct.rst:216
msgid "``L``"
msgstr "``L``"

#: ../../library/struct.rst:216
msgid ":c:type:`unsigned long`"
msgstr ":c:type:`unsigned long`"

#: ../../library/struct.rst:218
msgid "``q``"
msgstr "``q``"

#: ../../library/struct.rst:218
msgid ":c:type:`long long`"
msgstr ":c:type:`long long`"

#: ../../library/struct.rst:218 ../../library/struct.rst:220
#: ../../library/struct.rst:231
msgid "8"
msgstr "8"

#: ../../library/struct.rst:220
msgid "``Q``"
msgstr "``Q``"

#: ../../library/struct.rst:220
msgid ":c:type:`unsigned long long`"
msgstr ":c:type:`unsigned long long`"

#: ../../library/struct.rst:223
msgid "``n``"
msgstr "``n``"

#: ../../library/struct.rst:223
msgid ":c:type:`ssize_t`"
msgstr ":c:type:`ssize_t`"

#: ../../library/struct.rst:223 ../../library/struct.rst:225
msgid "\\(3)"
msgstr "\\(3)"

#: ../../library/struct.rst:225
msgid "``N``"
msgstr "``N``"

#: ../../library/struct.rst:225
msgid ":c:type:`size_t`"
msgstr ":c:type:`size_t`"

#: ../../library/struct.rst:227
msgid "``e``"
msgstr "``e``"

#: ../../library/struct.rst:227
msgid "\\(6)"
msgstr "\\(6)"

#: ../../library/struct.rst:227 ../../library/struct.rst:229
#: ../../library/struct.rst:231
msgid "float"
msgstr "浮点数"

#: ../../library/struct.rst:227 ../../library/struct.rst:229
#: ../../library/struct.rst:231
msgid "\\(4)"
msgstr "\\(4)"

#: ../../library/struct.rst:229
msgid "``f``"
msgstr "``f``"

#: ../../library/struct.rst:229
msgid ":c:type:`float`"
msgstr ":c:type:`float`"

#: ../../library/struct.rst:231
msgid "``d``"
msgstr "``d``"

#: ../../library/struct.rst:231
msgid ":c:type:`double`"
msgstr ":c:type:`double`"

#: ../../library/struct.rst:233
msgid "``s``"
msgstr "``s``"

#: ../../library/struct.rst:233 ../../library/struct.rst:235
msgid ":c:type:`char[]`"
msgstr ":c:type:`char[]`"

#: ../../library/struct.rst:233 ../../library/struct.rst:235
msgid "bytes"
msgstr "字节串"

#: ../../library/struct.rst:235
msgid "``p``"
msgstr "``p``"

#: ../../library/struct.rst:237
msgid "``P``"
msgstr "``P``"

#: ../../library/struct.rst:237
msgid ":c:type:`void \\*`"
msgstr ":c:type:`void \\*`"

#: ../../library/struct.rst:237
msgid "\\(5)"
msgstr "\\(5)"

#: ../../library/struct.rst:240
msgid "Added support for the ``'n'`` and ``'N'`` formats."
msgstr "增加了对 ``'n'`` 和 ``'N'`` 格式的支持"

#: ../../library/struct.rst:243
msgid "Added support for the ``'e'`` format."
msgstr "添加了对 ``'e'`` 格式的支持。"

#: ../../library/struct.rst:252
msgid ""
"The ``'?'`` conversion code corresponds to the :c:type:`_Bool` type defined "
"by C99. If this type is not available, it is simulated using a "
":c:type:`char`. In standard mode, it is always represented by one byte."
msgstr ""
"``'?'`` 转换码对应于 C99 定义的 :c:type:`_Bool` 类型。 如果此类型不可用，则使用 :c:type:`char` 来模拟。 "
"在标准模式下，它总是以一个字节表示。"

#: ../../library/struct.rst:257
msgid ""
"When attempting to pack a non-integer using any of the integer conversion "
"codes, if the non-integer has a :meth:`__index__` method then that method is"
" called to convert the argument to an integer before packing."
msgstr ""
"当尝试使用任何整数转换码打包一个非整数时，如果该非整数具有 :meth:`__index__` 方法，则会在打包之前调用该方法将参数转换为一个整数。"

#: ../../library/struct.rst:261
msgid "Use of the :meth:`__index__` method for non-integers is new in 3.2."
msgstr "为非整数使用 :meth:`__index__` 方法是 3.2 版的新增特性。"

#: ../../library/struct.rst:265
msgid ""
"The ``'n'`` and ``'N'`` conversion codes are only available for the native "
"size (selected as the default or with the ``'@'`` byte order character). For"
" the standard size, you can use whichever of the other integer formats fits "
"your application."
msgstr ""
"``'n'`` 和 ``'N'`` 转换码仅对本机大小可用（选择为默认或使用 ``'@'`` 字节顺序字符）。 "
"对于标准大小，你可以使用适合你的应用的任何其他整数格式。"

#: ../../library/struct.rst:271
msgid ""
"For the ``'f'``, ``'d'`` and ``'e'`` conversion codes, the packed "
"representation uses the IEEE 754 binary32, binary64 or binary16 format (for "
"``'f'``, ``'d'`` or ``'e'`` respectively), regardless of the floating-point "
"format used by the platform."
msgstr ""
"对于 ``'f'``, ``'d'`` 和 ``'e'`` 转换码，打包表示形式将使用 IEEE 754 binary32, binary64 或 "
"binary16 格式 (分别对应于 ``'f'``, ``'d'`` 或 ``'e'``)，无论平台使用何种浮点格式。"

#: ../../library/struct.rst:277
msgid ""
"The ``'P'`` format character is only available for the native byte ordering "
"(selected as the default or with the ``'@'`` byte order character). The byte"
" order character ``'='`` chooses to use little- or big-endian ordering based"
" on the host system. The struct module does not interpret this as native "
"ordering, so the ``'P'`` format is not available."
msgstr ""
"``'P'`` 格式字符仅对本机字节顺序可用（选择为默认或使用 ``'@'`` 字节顺序字符）。 字节顺序字符 ``'='`` "
"选择使用基于主机系统的小端或大端排序。 struct 模块不会将其解读为本机排序，因此 ``'P'`` 格式将不可用。"

#: ../../library/struct.rst:284
msgid ""
"The IEEE 754 binary16 \"half precision\" type was introduced in the 2008 "
"revision of the `IEEE 754 standard <ieee 754 standard_>`_. It has a sign "
"bit, a 5-bit exponent and 11-bit precision (with 10 bits explicitly stored),"
" and can represent numbers between approximately ``6.1e-05`` and ``6.5e+04``"
" at full precision. This type is not widely supported by C compilers: on a "
"typical machine, an unsigned short can be used for storage, but not for math"
" operations. See the Wikipedia page on the `half-precision floating-point "
"format <half precision format_>`_ for more information."
msgstr ""
"IEEE 754 binary16 \"半精度\" 类型是在 `IEEE 754 标准 <ieee 754 standard_>`_ 的 2008 "
"修订版中引入的。 它包含一个符号位，5 个指数位和 11 个精度位（明确存储 10 位），可以完全精确地表示大致范围在 ``6.1e-05`` 和 "
"``6.5e+04`` 之间的数字。 此类型并不被 C 编译器广泛支持：在一台典型的机器上，可以使用 unsigned short "
"进行存储，但不会被用于数学运算。 请参阅维基百科页面 `half-precision floating-point format <half "
"precision format_>`_ 了解详情。"

#: ../../library/struct.rst:294
msgid ""
"A format character may be preceded by an integral repeat count.  For "
"example, the format string ``'4h'`` means exactly the same as ``'hhhh'``."
msgstr "格式字符之前可以带有整数重复计数。 例如，格式字符串 ``'4h'`` 的含义与 ``'hhhh'`` 完全相同。"

#: ../../library/struct.rst:297
msgid ""
"Whitespace characters between formats are ignored; a count and its format "
"must not contain whitespace though."
msgstr "格式之间的空白字符会被忽略；但是计数及其格式字符中不可有空白字符。"

#: ../../library/struct.rst:300
msgid ""
"For the ``'s'`` format character, the count is interpreted as the length of "
"the bytes, not a repeat count like for the other format characters; for "
"example, ``'10s'`` means a single 10-byte string, while ``'10c'`` means 10 "
"characters. If a count is not given, it defaults to 1.  For packing, the "
"string is truncated or padded with null bytes as appropriate to make it fit."
" For unpacking, the resulting bytes object always has exactly the specified "
"number of bytes.  As a special case, ``'0s'`` means a single, empty string "
"(while ``'0c'`` means 0 characters)."
msgstr ""
"对于 ``'s'`` 格式字符，计数会被解析为字节的长度，而不是像其他格式字符那样的重复计数；例如，``'10s'`` 表示一个 10 字节的字节串，而"
" ``'10c'`` 表示 10 个字符。 如果未给出计数，则默认值为 1。 对于打包操作，字节串会被适当地截断或填充空字节以符合要求。 "
"对于解包操作，结果字节对象总是恰好具有指定数量的字节。 作为特殊情况，``'0s'`` 表示一个空字符串（而 ``'0c'`` 表示 0 个字符）。"

#: ../../library/struct.rst:309
msgid ""
"When packing a value ``x`` using one of the integer formats (``'b'``, "
"``'B'``, ``'h'``, ``'H'``, ``'i'``, ``'I'``, ``'l'``, ``'L'``, ``'q'``, "
"``'Q'``), if ``x`` is outside the valid range for that format then "
":exc:`struct.error` is raised."
msgstr ""
"当使用某一种整数格式 (``'b'``, ``'B'``, ``'h'``, ``'H'``, ``'i'``, ``'I'``, ``'l'``, "
"``'L'``, ``'q'``, ``'Q'``) 打包值 ``x`` 时，如果 ``x`` 在该格式的有效范围之外则将引发 "
":exc:`struct.error`。"

#: ../../library/struct.rst:314
msgid ""
"In 3.0, some of the integer formats wrapped out-of-range values and raised "
":exc:`DeprecationWarning` instead of :exc:`struct.error`."
msgstr ""
"在 3.0 中，某些包装了超范围值的整数格式会引发 :exc:`DeprecationWarning` 而不是 :exc:`struct.error`。"

#: ../../library/struct.rst:318
msgid ""
"The ``'p'`` format character encodes a \"Pascal string\", meaning a short "
"variable-length string stored in a *fixed number of bytes*, given by the "
"count. The first byte stored is the length of the string, or 255, whichever "
"is smaller.  The bytes of the string follow.  If the string passed in to "
":func:`pack` is too long (longer than the count minus 1), only the leading "
"``count-1`` bytes of the string are stored.  If the string is shorter than "
"``count-1``, it is padded with null bytes so that exactly count bytes in all"
" are used.  Note that for :func:`unpack`, the ``'p'`` format character "
"consumes ``count`` bytes, but that the string returned can never contain "
"more than 255 bytes."
msgstr ""
"``'p'`` 格式字符用于编码“Pascal 字符串”，即存储在由计数指定的 *固定长度字节* 中的可变长度短字符串。 "
"所存储的第一个字节为字符串长度或 255 中的较小值。 之后是字符串对应的字节。 如果传入 :func:`pack` 的字符串过长（超过计数值减 "
"1），则只有字符串前 ``count-1`` 个字节会被存储。 如果字符串短于 ``count-1``，则会填充空字节以使得恰好使用了 count "
"个字节。 请注意对于 :func:`unpack`，``'p'`` 格式字符会消耗 ``count`` 个字节，但返回的字符串永远不会包含超过 255 "
"个字节。"

#: ../../library/struct.rst:331
msgid ""
"For the ``'?'`` format character, the return value is either :const:`True` "
"or :const:`False`. When packing, the truth value of the argument object is "
"used. Either 0 or 1 in the native or standard bool representation will be "
"packed, and any non-zero value will be ``True`` when unpacking."
msgstr ""
"对于 ``'?'`` 格式字符，返回值为 :const:`True` 或 :const:`False`。 在打包时将会使用参数对象的逻辑值。 "
"以本机或标准 bool 类型表示的 0 或 1 将被打包，任何非零值在解包时将为 ``True``。"

#: ../../library/struct.rst:341
msgid "Examples"
msgstr "例子"

#: ../../library/struct.rst:344
msgid ""
"All examples assume a native byte order, size, and alignment with a big-"
"endian machine."
msgstr "所有示例都假定使用一台大端机器的本机字节顺序、大小和对齐方式。"

#: ../../library/struct.rst:347
msgid "A basic example of packing/unpacking three integers::"
msgstr "打包/解包三个整数的基础示例::"

#: ../../library/struct.rst:357
msgid ""
"Unpacked fields can be named by assigning them to variables or by wrapping "
"the result in a named tuple::"
msgstr "解包的字段可通过将它们赋值给变量或将结果包装为一个具名元组来命名::"

#: ../../library/struct.rst:368
msgid ""
"The ordering of format characters may have an impact on size since the "
"padding needed to satisfy alignment requirements is different::"
msgstr "格式字符的顺序可能对大小产生影响，因为满足对齐要求所需的填充是不同的::"

#: ../../library/struct.rst:380
msgid ""
"The following format ``'llh0l'`` specifies two pad bytes at the end, "
"assuming longs are aligned on 4-byte boundaries::"
msgstr "以下格式 ``'llh0l'`` 指定在末尾有两个填充字节，假定 long 类型按 4 个字节的边界对齐::"

#: ../../library/struct.rst:386
msgid ""
"This only works when native size and alignment are in effect; standard size "
"and alignment does not enforce any alignment."
msgstr "这仅当本机大小和对齐方式生效时才会起作用；标准大小和对齐方式并不会强制进行任何对齐。"

#: ../../library/struct.rst:393
msgid "Module :mod:`array`"
msgstr "模块 :mod:`array`"

#: ../../library/struct.rst:393
msgid "Packed binary storage of homogeneous data."
msgstr "被打包为二进制存储的同质数据。"

#: ../../library/struct.rst:395
msgid "Module :mod:`xdrlib`"
msgstr "模块 :mod:`xdrlib`"

#: ../../library/struct.rst:396
msgid "Packing and unpacking of XDR data."
msgstr "打包和解包 XDR 数据。"

#: ../../library/struct.rst:402
msgid "Classes"
msgstr "类"

#: ../../library/struct.rst:404
msgid "The :mod:`struct` module also defines the following type:"
msgstr ":mod:`struct` 模块还定义了以下类型："

#: ../../library/struct.rst:409
msgid ""
"Return a new Struct object which writes and reads binary data according to "
"the format string *format*.  Creating a Struct object once and calling its "
"methods is more efficient than calling the :mod:`struct` functions with the "
"same format since the format string only needs to be compiled once."
msgstr ""
"返回一个新的 Struct 对象，它会根据格式字符串 *format* 来写入和读取二进制数据。 一次性地创建 Struct "
"对象并调用其方法相比使用同样的格式调用 :mod:`struct` 函数更为高效，因为这样格式字符串只需被编译一次。"

#: ../../library/struct.rst:416
msgid ""
"The compiled versions of the most recent format strings passed to "
":class:`Struct` and the module-level functions are cached, so programs that "
"use only a few format strings needn't worry about reusing a single "
":class:`Struct` instance."
msgstr ""
"传递给 :class:`Struct` 和模块层级函数的已编译版最新格式字符串会被缓存，因此只使用少量格式字符串的程序无需担心重用单独的 "
":class:`Struct` 实例。"

#: ../../library/struct.rst:421
msgid "Compiled Struct objects support the following methods and attributes:"
msgstr "已编译的 Struct 对象支持以下方法和属性："

#: ../../library/struct.rst:425
msgid ""
"Identical to the :func:`pack` function, using the compiled format. "
"(``len(result)`` will equal :attr:`size`.)"
msgstr "等价于 :func:`pack` 函数，使用了已编译的格式。 (``len(result)`` 将等于 :attr:`size`。)"

#: ../../library/struct.rst:431
msgid ""
"Identical to the :func:`pack_into` function, using the compiled format."
msgstr "等价于 :func:`pack_into` 函数，使用了已编译的格式。"

#: ../../library/struct.rst:436
msgid ""
"Identical to the :func:`unpack` function, using the compiled format. The "
"buffer's size in bytes must equal :attr:`size`."
msgstr "等价于 :func:`unpack` 函数，使用了已编译的格式。 缓冲区的字节大小必须等于 :attr:`size`。"

#: ../../library/struct.rst:442
msgid ""
"Identical to the :func:`unpack_from` function, using the compiled format. "
"The buffer's size in bytes, minus *offset*, must be at least :attr:`size`."
msgstr ""
"等价于 :func:`unpack_from` 函数，使用了已编译的格式。 缓冲区的字节大小减去 *offset* 必须至少为 "
":attr:`size`。"

#: ../../library/struct.rst:449
msgid ""
"Identical to the :func:`iter_unpack` function, using the compiled format. "
"The buffer's size in bytes must be a multiple of :attr:`size`."
msgstr "等价于 :func:`iter_unpack` 函数，使用了已编译的格式。 缓冲区的大小必须为 :attr:`size` 的整数倍。"

#: ../../library/struct.rst:456
msgid "The format string used to construct this Struct object."
msgstr "用于构造此 Struct 对象的格式字符串。"

#: ../../library/struct.rst:458
msgid "The format string type is now :class:`str` instead of :class:`bytes`."
msgstr "格式字符串类型现在是 :class:`str` 而不再是 :class:`bytes`。"

#: ../../library/struct.rst:463
msgid ""
"The calculated size of the struct (and hence of the bytes object produced by"
" the :meth:`pack` method) corresponding to :attr:`format`."
msgstr "计算出对应于 :attr:`format` 的结构大小（亦即 :meth:`pack` 方法所产生的字节串对象的大小）。"