# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2017, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, 2017.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-10-11 20:40+0000\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: Dong-gweon Oh <flowdas@gmail.com>\n"
"Language-Team: Korean (https://python.flowdas.com)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.17.0\n"

#: ../../c-api/buffer.rst:11
msgid "Buffer Protocol"
msgstr "버퍼 프로토콜"

#: ../../c-api/buffer.rst:18
msgid ""
"Certain objects available in Python wrap access to an underlying memory "
"array or *buffer*.  Such objects include the built-in :class:`bytes` and "
":class:`bytearray`, and some extension types like :class:`array.array`. "
"Third-party libraries may define their own types for special purposes, "
"such as image processing or numeric analysis."
msgstr ""
"파이썬에서 사용할 수 있는 어떤 객체는 하부 메모리 배열 또는 *버퍼*\\에 대한 액세스를 감쌉니다. 이러한 객체에는 내장 "
":class:`bytes` 와 :class:`bytearray`, 그리고 :class:`array.array`\\와 같은 일부 "
"확장형이 포함됩니다. 제삼자 라이브러리도 이미지 처리나 수치 해석과 같은 특수한 용도로 자체 형을 정의할 수 있습니다."

#: ../../c-api/buffer.rst:24
msgid ""
"While each of these types have their own semantics, they share the common"
" characteristic of being backed by a possibly large memory buffer.  It is"
" then desirable, in some situations, to access that buffer directly and "
"without intermediate copying."
msgstr ""
"이러한 형은 각각 고유의 의미가 있지만, (아마도) 큰 메모리 버퍼에 의해 뒷받침되는 공통된 특징을 공유합니다. 어떤 상황에서는 "
"중간 복사 없이 직접 버퍼에 액세스하는 것이 바람직합니다."

#: ../../c-api/buffer.rst:29
#, fuzzy
msgid ""
"Python provides such a facility at the C and Python level in the form of "
"the :ref:`buffer protocol <bufferobjects>`.  This protocol has two sides:"
msgstr ""
"파이썬은 C 수준에서 :ref:`버퍼 프로토콜 <bufferobjects>` 형식으로 이러한 기능을 제공합니다. 이 프로토콜에는 두"
" 가지 측면이 있습니다:"

#: ../../c-api/buffer.rst:34
#, fuzzy
msgid ""
"on the producer side, a type can export a \"buffer interface\" which "
"allows objects of that type to expose information about their underlying "
"buffer. This interface is described in the section :ref:`buffer-structs`;"
" for Python see :ref:`python-buffer-protocol`."
msgstr ""
"생산자 측에서는, 형이 \"버퍼 인터페이스\"를 내보낼 수 있는데, 그 형의 객체가 하부 버퍼의 정보를 노출할 수 있게 합니다. 이"
" 인터페이스는 :ref:`buffer-structs` 절에서 설명됩니다."

#: ../../c-api/buffer.rst:39
#, fuzzy
msgid ""
"on the consumer side, several means are available to obtain a pointer to "
"the raw underlying data of an object (for example a method parameter). "
"For Python see :class:`memoryview`."
msgstr ""
"소비자 측에서는, 객체의 원시 하부 데이터에 대한 포인터를 얻기 위해 여러 가지 방법을 사용할 수 있습니다 (예를 들어 메서드 매개"
" 변수)."

#: ../../c-api/buffer.rst:43
msgid ""
"Simple objects such as :class:`bytes` and :class:`bytearray` expose their"
" underlying buffer in byte-oriented form.  Other forms are possible; for "
"example, the elements exposed by an :class:`array.array` can be multi-"
"byte values."
msgstr ""
":class:`bytes` 와 :class:`bytearray`\\와 같은 간단한 객체는 하부 버퍼를 바이트 지향 형식으로 "
"노출합니다. 다른 형태도 가능합니다; 예를 들어, :class:`array.array`\\에 의해 노출되는 요소는 멀티 바이트 값이"
" 될 수 있습니다."

#: ../../c-api/buffer.rst:47
msgid ""
"An example consumer of the buffer interface is the "
":meth:`~io.BufferedIOBase.write` method of file objects: any object that "
"can export a series of bytes through the buffer interface can be written "
"to a file.  While :meth:`!write` only needs read-only access to the "
"internal contents of the object passed to it, other methods such as "
":meth:`~io.BufferedIOBase.readinto` need write access to the contents of "
"their argument.  The buffer interface allows objects to selectively allow"
" or reject exporting of read-write and read-only buffers."
msgstr ""
"버퍼 인터페이스의 소비자 예는 파일 객체의 :meth:`~io.BufferedIOBase.write` 메서드입니다: 버퍼 "
"인터페이스를 통해 일련의 바이트를 내보낼 수 있는 모든 객체는 파일에 기록될 수 있습니다. :meth:`!write`\\가 전달된 "
"객체의 내부 내용에 대한 읽기 전용 액세스만 필요하지만, :meth:`~io.BufferedIOBase.readinto`\\와 같은"
" 다른 메서드는 인자의 내용에 쓰기 액세스가 필요합니다. 버퍼 인터페이스는 객체가 읽기-쓰기와 읽기 전용 버퍼를 선택적으로 "
"허용하거나 거부할 수 있도록 합니다."

#: ../../c-api/buffer.rst:55
msgid ""
"There are two ways for a consumer of the buffer interface to acquire a "
"buffer over a target object:"
msgstr "버퍼 인터페이스의 소비자가 대상 객체에 대해 버퍼를 얻는 방법에는 두 가지가 있습니다:"

#: ../../c-api/buffer.rst:58
msgid "call :c:func:`PyObject_GetBuffer` with the right parameters;"
msgstr "올바른 매개 변수로 :c:func:`PyObject_GetBuffer`\\를 호출합니다;"

#: ../../c-api/buffer.rst:60
msgid ""
"call :c:func:`PyArg_ParseTuple` (or one of its siblings) with one of the "
"``y*``, ``w*`` or ``s*`` :ref:`format codes <arg-parsing>`."
msgstr ""
"``y*``, ``w*`` 또는 ``s*`` :ref:`형식 코드 <arg-parsing>` 중 하나를 사용하여 "
":c:func:`PyArg_ParseTuple`\\(또는 그 형제 중 하나)을 호출합니다."

#: ../../c-api/buffer.rst:63
msgid ""
"In both cases, :c:func:`PyBuffer_Release` must be called when the buffer "
"isn't needed anymore.  Failure to do so could lead to various issues such"
" as resource leaks."
msgstr ""
"두 경우 모두, 버퍼가 더는 필요하지 않으면 :c:func:`PyBuffer_Release`\\를 호출해야 합니다. 그렇게 하지 "
"않으면 자원 누수와 같은 다양한 문제가 발생할 수 있습니다."

#: ../../c-api/buffer.rst:69
msgid ""
"The buffer protocol is now accessible in Python, see :ref:`python-buffer-"
"protocol` and :class:`memoryview`."
msgstr ""

#: ../../c-api/buffer.rst:75
msgid "Buffer structure"
msgstr "버퍼 구조체"

#: ../../c-api/buffer.rst:77
msgid ""
"Buffer structures (or simply \"buffers\") are useful as a way to expose "
"the binary data from another object to the Python programmer.  They can "
"also be used as a zero-copy slicing mechanism.  Using their ability to "
"reference a block of memory, it is possible to expose any data to the "
"Python programmer quite easily.  The memory could be a large, constant "
"array in a C extension, it could be a raw block of memory for "
"manipulation before passing to an operating system library, or it could "
"be used to pass around structured data in its native, in-memory format."
msgstr ""
"버퍼 구조체(또는 단순히 \"버퍼\")는 다른 객체의 바이너리 데이터를 파이썬 프로그래머에게 노출하는 방법으로 유용합니다. 또한, "
"복사 없는(zero-copy) 슬라이싱 메커니즘으로 사용할 수 있습니다. 메모리 블록을 참조하는 능력을 사용해서, 임의의 데이터를 "
"파이썬 프로그래머에게 아주 쉽게 노출할 수 있습니다. 메모리는 C 확장의 큰 상수 배열일 수 있으며, 운영 체제 라이브러리로 "
"전달되기 전에 조작하기 위한 원시 메모리 블록일 수도 있고, 네이티브 인 메모리(in-memory) 형식으로 구조화된 데이터를 "
"전달하는 데 사용될 수도 있습니다."

#: ../../c-api/buffer.rst:86
msgid ""
"Contrary to most data types exposed by the Python interpreter, buffers "
"are not :c:type:`PyObject` pointers but rather simple C structures.  This"
" allows them to be created and copied very simply.  When a generic "
"wrapper around a buffer is needed, a :ref:`memoryview <memoryview-"
"objects>` object can be created."
msgstr ""
"파이썬 인터프리터가 노출하는 대부분의 데이터형과 달리, 버퍼는 :c:type:`PyObject` 포인터가 아니라 단순한 C "
"구조체입니다. 이를 통해 매우 간단하게 만들고 복사할 수 있습니다. 버퍼를 감싸는 일반 래퍼가 필요할 때는, :ref:`메모리 뷰 "
"<memoryview-objects>` 객체를 만들 수 있습니다."

#: ../../c-api/buffer.rst:92
msgid ""
"For short instructions how to write an exporting object, see :ref:`Buffer"
" Object Structures <buffer-structs>`. For obtaining a buffer, see "
":c:func:`PyObject_GetBuffer`."
msgstr ""
"제공하는(exporting) 객체를 작성하는 간단한 지침은 :ref:`버퍼 객체 구조체 <buffer-structs>`\\를 "
"참조하십시오. 버퍼를 얻으려면, :c:func:`PyObject_GetBuffer`\\를 참조하십시오."

#: ../../c-api/buffer.rst:100
msgid ""
"A pointer to the start of the logical structure described by the buffer "
"fields. This can be any location within the underlying physical memory "
"block of the exporter. For example, with negative "
":c:member:`~Py_buffer.strides` the value may point to the end of the "
"memory block."
msgstr ""
"버퍼 필드에 의해 기술된 논리적 구조의 시작을 가리키는 포인터. 이것은 제공자(exporter)의 하부 물리적 메모리 블록 내의 "
"모든 위치일 수 있습니다. 예를 들어, 음의 :c:member:`~Py_buffer.strides`\\를 사용하면 값이 메모리 "
"블록의 끝을 가리킬 수 있습니다."

#: ../../c-api/buffer.rst:105
msgid ""
"For :term:`contiguous` arrays, the value points to the beginning of the "
"memory block."
msgstr ":term:`연속 <contiguous>` 배열의 경우, 값은 메모리 블록의 시작을 가리킵니다."

#: ../../c-api/buffer.rst:110
msgid ""
"A new reference to the exporting object. The reference is owned by the "
"consumer and automatically released (i.e. reference count decremented) "
"and set to ``NULL`` by :c:func:`PyBuffer_Release`. The field is the "
"equivalent of the return value of any standard C-API function."
msgstr ""
"제공하는(exporting) 객체에 대한 새 참조. 참조는 소비자가 소유하고, :c:func:`PyBuffer_Release`\\에"
" 의해 자동으로 해제되고 (즉 참조 횟수가 감소합니다) ``NULL``\\로 설정됩니다. 이 필드는 표준 C-API 함수의 반환 "
"값과 동등합니다."

#: ../../c-api/buffer.rst:117
msgid ""
"As a special case, for *temporary* buffers that are wrapped by "
":c:func:`PyMemoryView_FromBuffer` or :c:func:`PyBuffer_FillInfo` this "
"field is ``NULL``. In general, exporting objects MUST NOT use this "
"scheme."
msgstr ""
"특수한 경우로, :c:func:`PyMemoryView_FromBuffer` 나 "
":c:func:`PyBuffer_FillInfo`\\로 감싸진 *임시(temporary)* 버퍼의 경우, 이 필드는 "
"``NULL``\\입니다. 일반적으로, 제공하는(exporting) 객체는 이 체계를 사용하지 않아야 합니다."

#: ../../c-api/buffer.rst:124
msgid ""
"``product(shape) * itemsize``. For contiguous arrays, this is the length "
"of the underlying memory block. For non-contiguous arrays, it is the "
"length that the logical structure would have if it were copied to a "
"contiguous representation."
msgstr ""
"``product(shape) * itemsize``. 연속 배열의 경우, 하부 메모리 블록의 길이입니다. 불연속 배열의 경우, "
"연속 표현으로 복사된다면 논리적 구조체가 갖게 될 길이입니다."

#: ../../c-api/buffer.rst:129
msgid ""
"Accessing ``((char *)buf)[0] up to ((char *)buf)[len-1]`` is only valid "
"if the buffer has been obtained by a request that guarantees contiguity. "
"In most cases such a request will be :c:macro:`PyBUF_SIMPLE` or "
":c:macro:`PyBUF_WRITABLE`."
msgstr ""
"``((char *)buf)[0] 에서 ((char *)buf)[len-1]`` 범위의 액세스는 연속성을 보장하는 요청으로 버퍼가 "
"확보된 경우에만 유효합니다. 대부분 이러한 요청은 :c:macro:`PyBUF_SIMPLE` 또는 "
":c:macro:`PyBUF_WRITABLE`\\입니다."

#: ../../c-api/buffer.rst:135
msgid ""
"An indicator of whether the buffer is read-only. This field is controlled"
" by the :c:macro:`PyBUF_WRITABLE` flag."
msgstr "버퍼가 읽기 전용인지를 나타내는 표시기입니다. 이 필드는 :c:macro:`PyBUF_WRITABLE` 플래그로 제어됩니다."

#: ../../c-api/buffer.rst:140
msgid ""
"Item size in bytes of a single element. Same as the value of "
":func:`struct.calcsize` called on non-``NULL`` "
":c:member:`~Py_buffer.format` values."
msgstr ""
"단일 요소의 항목 크기(바이트)입니다. ``NULL``\\이 아닌 :c:member:`~Py_buffer.format` 값에 호출된"
" :func:`struct.calcsize` 값과 같습니다."

#: ../../c-api/buffer.rst:143
msgid ""
"Important exception: If a consumer requests a buffer without the "
":c:macro:`PyBUF_FORMAT` flag, :c:member:`~Py_buffer.format` will be set "
"to  ``NULL``,  but :c:member:`~Py_buffer.itemsize` still has the value "
"for the original format."
msgstr ""
"중요한 예외: 소비자가 :c:macro:`PyBUF_FORMAT` 플래그 없이 버퍼를 요청하면, "
":c:member:`~Py_buffer.format`\\은 ``NULL``\\로 설정되지만, "
":c:member:`~Py_buffer.itemsize`\\는 여전히 원래 형식의 값을 갖습니다."

#: ../../c-api/buffer.rst:148
msgid ""
"If :c:member:`~Py_buffer.shape` is present, the equality ``product(shape)"
" * itemsize == len`` still holds and the consumer can use "
":c:member:`~Py_buffer.itemsize` to navigate the buffer."
msgstr ""
":c:member:`~Py_buffer.shape`\\이 있으면, ``product(shape) * itemsize == len``"
" 동치가 계속 성립하고 소비자는 :c:member:`~Py_buffer.itemsize`\\를 사용하여 버퍼를 탐색할 수 있습니다."

#: ../../c-api/buffer.rst:152
msgid ""
"If :c:member:`~Py_buffer.shape` is ``NULL`` as a result of a "
":c:macro:`PyBUF_SIMPLE` or a :c:macro:`PyBUF_WRITABLE` request, the "
"consumer must disregard :c:member:`~Py_buffer.itemsize` and assume "
"``itemsize == 1``."
msgstr ""
":c:macro:`PyBUF_SIMPLE` 이나 :c:macro:`PyBUF_WRITABLE` 요청의 결과로 "
":c:member:`~Py_buffer.shape`\\이 ``NULL``\\이면, 소비자는 "
":c:member:`~Py_buffer.itemsize`\\를 무시하고 ``itemsize == 1``\\로 가정해야 합니다."

#: ../../c-api/buffer.rst:158
msgid ""
"A *NULL* terminated string in :mod:`struct` module style syntax "
"describing the contents of a single item. If this is ``NULL``, ``\"B\"`` "
"(unsigned bytes) is assumed."
msgstr ""
"단일 항목의 내용을 설명하는 :mod:`struct` 모듈 스타일 문법의 *NULL* 종료 문자열. 이것이 ``NULL``\\이면,"
" ``\"B\"``\\(부호 없는 바이트)를 가정합니다."

#: ../../c-api/buffer.rst:162
msgid "This field is controlled by the :c:macro:`PyBUF_FORMAT` flag."
msgstr "이 필드는 :c:macro:`PyBUF_FORMAT` 플래그로 제어됩니다."

#: ../../c-api/buffer.rst:166
msgid ""
"The number of dimensions the memory represents as an n-dimensional array."
" If it is ``0``, :c:member:`~Py_buffer.buf` points to a single item "
"representing a scalar. In this case, :c:member:`~Py_buffer.shape`, "
":c:member:`~Py_buffer.strides` and :c:member:`~Py_buffer.suboffsets` MUST"
" be ``NULL``. The maximum number of dimensions is given by "
":c:macro:`PyBUF_MAX_NDIM`."
msgstr ""
"메모리가 n 차원 배열로 나타내는 차원 수. ``0``\\이면, :c:member:`~Py_buffer.buf`\\는 스칼라를 "
"나타내는 단일 항목을 가리 킵니다. 이 경우, :c:member:`~Py_buffer.shape`, "
":c:member:`~Py_buffer.strides` 및 :c:member:`~Py_buffer.suboffsets`\\는 반드시"
" ``NULL`` 이어야 합니다. 최대 차원 수는 :c:macro:`PyBUF_MAX_NDIM`\\으로 지정됩니다."

#: ../../c-api/buffer.rst:174
msgid ""
"An array of :c:type:`Py_ssize_t` of length :c:member:`~Py_buffer.ndim` "
"indicating the shape of the memory as an n-dimensional array. Note that "
"``shape[0] * ... * shape[ndim-1] * itemsize`` MUST be equal to "
":c:member:`~Py_buffer.len`."
msgstr ""
"n-차원 배열로 메모리의 모양을 나타내는 길이 :c:member:`~Py_buffer.ndim`\\의 "
":c:type:`Py_ssize_t` 배열. ``shape[0] * ... * shape[ndim-1] * itemsize``\\는"
" :c:member:`~Py_buffer.len`\\과 같아야 합니다."

#: ../../c-api/buffer.rst:179
msgid ""
"Shape values are restricted to ``shape[n] >= 0``. The case ``shape[n] == "
"0`` requires special attention. See `complex arrays`_ for further "
"information."
msgstr ""
"모양 값은 ``shape[n] >= 0``\\로 제한됩니다. ``shape[n] == 0``\\인 경우는 특별한 주의가 필요합니다."
" 자세한 정보는 `복잡한 배열 <complex arrays_>`_\\을 참조하십시오."

#: ../../c-api/buffer.rst:183
msgid "The shape array is read-only for the consumer."
msgstr "shape 배열은 소비자에게 읽기 전용입니다."

#: ../../c-api/buffer.rst:187
msgid ""
"An array of :c:type:`Py_ssize_t` of length :c:member:`~Py_buffer.ndim` "
"giving the number of bytes to skip to get to a new element in each "
"dimension."
msgstr ""
"각 차원에서 새 요소를 가져오기 위해 건너뛸 바이트 수를 제공하는 길이 :c:member:`~Py_buffer.ndim`\\의 "
":c:type:`Py_ssize_t` 배열."

#: ../../c-api/buffer.rst:191
msgid ""
"Stride values can be any integer. For regular arrays, strides are usually"
" positive, but a consumer MUST be able to handle the case ``strides[n] <="
" 0``. See `complex arrays`_ for further information."
msgstr ""
"스트라이드 값은 임의의 정수일 수 있습니다. 일반 배열의 경우, 스트라이드는 보통 양수이지만, 소비자는 ``strides[n] <="
" 0``\\인 경우를 처리할 수 있어야 합니다. 자세한 내용은 `복잡한 배열 <complex arrays_>`_\\을 참조하십시오."

#: ../../c-api/buffer.rst:195
msgid "The strides array is read-only for the consumer."
msgstr "strides 배열은 소비자에게 읽기 전용입니다."

#: ../../c-api/buffer.rst:199
msgid ""
"An array of :c:type:`Py_ssize_t` of length :c:member:`~Py_buffer.ndim`. "
"If ``suboffsets[n] >= 0``, the values stored along the nth dimension are "
"pointers and the suboffset value dictates how many bytes to add to each "
"pointer after de-referencing. A suboffset value that is negative "
"indicates that no de-referencing should occur (striding in a contiguous "
"memory block)."
msgstr ""
"길이 :c:member:`~Py_buffer.ndim`\\의 :c:type:`Py_ssize_t` 배열. "
"``suboffsets[n] >= 0`` 면, n 번째 차원을 따라 저장된 값은 포인터이고 서브 오프셋 값은 역참조(de-"
"referencing) 후 각 포인터에 더할 바이트 수를 나타냅니다. 음의 서브 오프셋 값은 역참조(de-referencing)가 "
"발생하지 않아야 함을 나타냅니다 (연속 메모리 블록에서의 스트라이드)."

#: ../../c-api/buffer.rst:206
msgid ""
"If all suboffsets are negative (i.e. no de-referencing is needed), then "
"this field must be ``NULL`` (the default value)."
msgstr "모든 서브 오프셋이 음수면 (즉, 역참조가 필요하지 않으면), 이 필드는 ``NULL``\\(기본값) 이어야 합니다."

#: ../../c-api/buffer.rst:209
msgid ""
"This type of array representation is used by the Python Imaging Library "
"(PIL). See `complex arrays`_ for further information how to access "
"elements of such an array."
msgstr ""
"이 유형의 배열 표현은 파이썬 이미징 라이브러리(PIL)에서 사용됩니다. 이러한 배열 요소에 액세스하는 방법에 대한 자세한 내용은 "
"`복잡한 배열 <complex arrays_>`_\\을 참조하십시오."

#: ../../c-api/buffer.rst:213
msgid "The suboffsets array is read-only for the consumer."
msgstr "suboffsets 배열은 소비자에게 읽기 전용입니다."

#: ../../c-api/buffer.rst:217
msgid ""
"This is for use internally by the exporting object. For example, this "
"might be re-cast as an integer by the exporter and used to store flags "
"about whether or not the shape, strides, and suboffsets arrays must be "
"freed when the buffer is released. The consumer MUST NOT alter this "
"value."
msgstr ""
"이것은 제공하는(exporting) 객체에 의해 내부적으로 사용됩니다. 예를 들어, 이것은 제공자(exporter)가 정수로 다시 "
"캐스팅할 수 있으며, 버퍼가 해제될 때 shape, strides 및 suboffsets 배열을 해제해야 하는지에 대한 플래그를 "
"저장하는 데 사용됩니다. 소비자가 이 값을 변경해서는 안 됩니다."

#: ../../c-api/buffer.rst:224
msgid "Constants:"
msgstr "상수:"

#: ../../c-api/buffer.rst:228
msgid ""
"The maximum number of dimensions the memory represents. Exporters MUST "
"respect this limit, consumers of multi-dimensional buffers SHOULD be able"
" to handle up to :c:macro:`!PyBUF_MAX_NDIM` dimensions. Currently set to "
"64."
msgstr ""
"메모리가 나타내는 최대 차원 수 입니다. 제공자는 이 제한을 존중해야 하며, 다차원 버퍼의 소비자는 "
":c:macro:`!PyBUF_MAX_NDIM` 차원까지 처리할 수 있어야 합니다. 현재 64로 설정되었습니다."

#: ../../c-api/buffer.rst:237
msgid "Buffer request types"
msgstr "버퍼 요청 유형"

#: ../../c-api/buffer.rst:239
msgid ""
"Buffers are usually obtained by sending a buffer request to an exporting "
"object via :c:func:`PyObject_GetBuffer`. Since the complexity of the "
"logical structure of the memory can vary drastically, the consumer uses "
"the *flags* argument to specify the exact buffer type it can handle."
msgstr ""
"버퍼는 대개 :c:func:`PyObject_GetBuffer`\\를 통해 제공하는(exporting) 객체로 버퍼 요청을 보내서 "
"얻습니다. 메모리의 논리적 구조의 복잡성이 크게 다를 수 있으므로, 소비자는 처리할 수 있는 정확한 버퍼 유형을 지정하기 위해 "
"*flags* 인자를 사용합니다."

#: ../../c-api/buffer.rst:244
msgid ""
"All :c:type:`Py_buffer` fields are unambiguously defined by the request "
"type."
msgstr "모든 :c:type:`Py_buffer` 필드는 요청 유형에 의해 모호하지 않게 정의됩니다."

#: ../../c-api/buffer.rst:248
msgid "request-independent fields"
msgstr "요청 독립적 필드"

#: ../../c-api/buffer.rst:249
msgid ""
"The following fields are not influenced by *flags* and must always be "
"filled in with the correct values: :c:member:`~Py_buffer.obj`, "
":c:member:`~Py_buffer.buf`, :c:member:`~Py_buffer.len`, "
":c:member:`~Py_buffer.itemsize`, :c:member:`~Py_buffer.ndim`."
msgstr ""
"다음 필드는 *flags*\\의 영향을 받지 않고 항상 올바른 값으로 채워져야 합니다: "
":c:member:`~Py_buffer.obj`, :c:member:`~Py_buffer.buf`, "
":c:member:`~Py_buffer.len`, :c:member:`~Py_buffer.itemsize`, "
":c:member:`~Py_buffer.ndim`."

#: ../../c-api/buffer.rst:254
msgid "readonly, format"
msgstr "readonly, format"

#: ../../c-api/buffer.rst:258
msgid ""
"Controls the :c:member:`~Py_buffer.readonly` field. If set, the exporter "
"MUST provide a writable buffer or else report failure. Otherwise, the "
"exporter MAY provide either a read-only or writable buffer, but the "
"choice MUST be consistent for all consumers. For example, "
":c:expr:`PyBUF_SIMPLE | PyBUF_WRITABLE` can be used to request a simple "
"writable buffer."
msgstr ""
":c:member:`~Py_buffer.readonly` 필드를 제어합니다. 설정되면, 제공자는 반드시 쓰기 가능한 버퍼를 "
"제공하거나 실패를 보고해야 합니다. 그렇지 않으면, 제공자는 읽기 전용 버퍼나 쓰기 가능 버퍼를 제공할 수 있지만, 모든 소비자에 "
"대해 일관성을 유지해야 합니다. 예를 들어, 간단한 쓰기 가능 버퍼를 요청하려면 :c:expr:`PyBUF_SIMPLE | "
"PyBUF_WRITABLE`\\을 사용할 수 있습니다."

#: ../../c-api/buffer.rst:266
msgid ""
"Controls the :c:member:`~Py_buffer.format` field. If set, this field MUST"
" be filled in correctly. Otherwise, this field MUST be ``NULL``."
msgstr ""
":c:member:`~Py_buffer.format` 필드를 제어합니다. 설정되면, 이 필드를 올바르게 채워야 합니다. 그렇지 "
"않으면, 이 필드는 반드시 ``NULL`` 이어야 합니다."

#: ../../c-api/buffer.rst:270
msgid ""
":c:macro:`PyBUF_WRITABLE` can be \\|'d to any of the flags in the next "
"section. Since :c:macro:`PyBUF_SIMPLE` is defined as 0, "
":c:macro:`PyBUF_WRITABLE` can be used as a stand-alone flag to request a "
"simple writable buffer."
msgstr ""
":c:macro:`PyBUF_WRITABLE`\\은 다음 섹션의 모든 플래그와 \\| 될 수 있습니다. "
":c:macro:`PyBUF_SIMPLE`\\이 0으로 정의되므로, :c:macro:`PyBUF_WRITABLE`\\은 독립형 "
"플래그로 사용되어 간단한 쓰기 가능한 버퍼를 요청할 수 있습니다."

#: ../../c-api/buffer.rst:274
msgid ""
":c:macro:`PyBUF_FORMAT` must be \\|'d to any of the flags except "
":c:macro:`PyBUF_SIMPLE`, because the latter already implies format ``B`` "
"(unsigned bytes). :c:macro:`!PyBUF_FORMAT` cannot be used on its own."
msgstr ""
":c:macro:`PyBUF_FORMAT`\\은 :c:macro:`PyBUF_SIMPLE`\\을 제외한 임의의 플래그와 \\| "
"되어야 합니다. PyBUF_SIMPLE 은 이미 형식 ``B``\\(부호 없는 바이트)를 의미하기 때문입니다. "
":c:macro:`!PyBUF_FORMAT`\\은 단독으로 사용할 수 없습니다."

#: ../../c-api/buffer.rst:280
msgid "shape, strides, suboffsets"
msgstr "shape, strides, suboffsets"

#: ../../c-api/buffer.rst:282
msgid ""
"The flags that control the logical structure of the memory are listed in "
"decreasing order of complexity. Note that each flag contains all bits of "
"the flags below it."
msgstr ""
"메모리의 논리 구조를 제어하는 플래그는 복잡도가 감소하는 순서로 나열됩니다. 각 플래그는 그 아래에 있는 플래그의 모든 비트를 "
"포함합니다."

#: ../../c-api/buffer.rst:289 ../../c-api/buffer.rst:313
#: ../../c-api/buffer.rst:338
msgid "Request"
msgstr "요청"

#: ../../c-api/buffer.rst:289 ../../c-api/buffer.rst:313
#: ../../c-api/buffer.rst:338
msgid "shape"
msgstr "shape"

#: ../../c-api/buffer.rst:289 ../../c-api/buffer.rst:313
#: ../../c-api/buffer.rst:338
msgid "strides"
msgstr "strides"

#: ../../c-api/buffer.rst:289 ../../c-api/buffer.rst:313
#: ../../c-api/buffer.rst:338
msgid "suboffsets"
msgstr "suboffsets"

#: ../../c-api/buffer.rst:291 ../../c-api/buffer.rst:293
#: ../../c-api/buffer.rst:295 ../../c-api/buffer.rst:315
#: ../../c-api/buffer.rst:317 ../../c-api/buffer.rst:319
#: ../../c-api/buffer.rst:321 ../../c-api/buffer.rst:340
#: ../../c-api/buffer.rst:342 ../../c-api/buffer.rst:344
#: ../../c-api/buffer.rst:346 ../../c-api/buffer.rst:348
#: ../../c-api/buffer.rst:350 ../../c-api/buffer.rst:352
#: ../../c-api/buffer.rst:354
msgid "yes"
msgstr "yes"

#: ../../c-api/buffer.rst:291 ../../c-api/buffer.rst:340
#: ../../c-api/buffer.rst:342
msgid "if needed"
msgstr "필요하면"

#: ../../c-api/buffer.rst:293 ../../c-api/buffer.rst:295
#: ../../c-api/buffer.rst:297 ../../c-api/buffer.rst:315
#: ../../c-api/buffer.rst:317 ../../c-api/buffer.rst:319
#: ../../c-api/buffer.rst:321 ../../c-api/buffer.rst:344
#: ../../c-api/buffer.rst:346 ../../c-api/buffer.rst:348
#: ../../c-api/buffer.rst:350 ../../c-api/buffer.rst:352
#: ../../c-api/buffer.rst:354
msgid "NULL"
msgstr "NULL"

#: ../../c-api/buffer.rst:304
msgid "contiguity requests"
msgstr "연속성 요청"

#: ../../c-api/buffer.rst:306
msgid ""
"C or Fortran :term:`contiguity <contiguous>` can be explicitly requested,"
" with and without stride information. Without stride information, the "
"buffer must be C-contiguous."
msgstr ""
"C 나 포트란 :term:`연속성 <contiguous>`\\을 명시적으로 요청할 수 있는데, 스트라이드 정보를 포함하기도 그렇지 "
"않기도 합니다. 스트라이드 정보가 없으면, 버퍼는 C-연속이어야 합니다."

#: ../../c-api/buffer.rst:313 ../../c-api/buffer.rst:338
msgid "contig"
msgstr "연속성"

#: ../../c-api/buffer.rst:315 ../../c-api/buffer.rst:321
#: ../../c-api/buffer.rst:352 ../../c-api/buffer.rst:354
msgid "C"
msgstr "C"

#: ../../c-api/buffer.rst:317
msgid "F"
msgstr "F"

#: ../../c-api/buffer.rst:319
msgid "C or F"
msgstr "C 또는 F"

#: ../../c-api/buffer.rst:321
msgid ":c:macro:`PyBUF_ND`"
msgstr ":c:macro:`PyBUF_ND`"

#: ../../c-api/buffer.rst:326
msgid "compound requests"
msgstr "복합 요청"

#: ../../c-api/buffer.rst:328
msgid ""
"All possible requests are fully defined by some combination of the flags "
"in the previous section. For convenience, the buffer protocol provides "
"frequently used combinations as single flags."
msgstr ""
"모든 가능한 요청은 앞 절의 플래그 조합에 의해 완전히 정의됩니다. 편의상, 버퍼 프로토콜은 자주 사용되는 조합을 단일 플래그로 "
"제공합니다."

#: ../../c-api/buffer.rst:332
msgid ""
"In the following table *U* stands for undefined contiguity. The consumer "
"would have to call :c:func:`PyBuffer_IsContiguous` to determine "
"contiguity."
msgstr ""
"다음 표에서 *U*\\는 정의되지 않은 연속성을 나타냅니다. 소비자는 연속성을 판단하기 위해 "
":c:func:`PyBuffer_IsContiguous`\\를 호출해야 합니다."

#: ../../c-api/buffer.rst:338
msgid "readonly"
msgstr "readonly"

#: ../../c-api/buffer.rst:338
msgid "format"
msgstr "format"

#: ../../c-api/buffer.rst:340 ../../c-api/buffer.rst:342
#: ../../c-api/buffer.rst:344 ../../c-api/buffer.rst:346
#: ../../c-api/buffer.rst:348 ../../c-api/buffer.rst:350
msgid "U"
msgstr "U"

#: ../../c-api/buffer.rst:340 ../../c-api/buffer.rst:344
#: ../../c-api/buffer.rst:348 ../../c-api/buffer.rst:352
msgid "0"
msgstr "0"

#: ../../c-api/buffer.rst:342 ../../c-api/buffer.rst:346
#: ../../c-api/buffer.rst:350 ../../c-api/buffer.rst:354
msgid "1 or 0"
msgstr "1 또는 0"

#: ../../c-api/buffer.rst:359
msgid "Complex arrays"
msgstr "복잡한 배열"

#: ../../c-api/buffer.rst:362
msgid "NumPy-style: shape and strides"
msgstr "NumPy-스타일: shape과 strides"

#: ../../c-api/buffer.rst:364
msgid ""
"The logical structure of NumPy-style arrays is defined by "
":c:member:`~Py_buffer.itemsize`, :c:member:`~Py_buffer.ndim`, "
":c:member:`~Py_buffer.shape` and :c:member:`~Py_buffer.strides`."
msgstr ""
"NumPy 스타일 배열의 논리적 구조는 :c:member:`~Py_buffer.itemsize`, "
":c:member:`~Py_buffer.ndim`, :c:member:`~Py_buffer.shape` 및 "
":c:member:`~Py_buffer.strides`\\로 정의됩니다."

#: ../../c-api/buffer.rst:367
msgid ""
"If ``ndim == 0``, the memory location pointed to by "
":c:member:`~Py_buffer.buf` is interpreted as a scalar of size "
":c:member:`~Py_buffer.itemsize`. In that case, both "
":c:member:`~Py_buffer.shape` and :c:member:`~Py_buffer.strides` are "
"``NULL``."
msgstr ""
"``ndim == 0``\\이면, :c:member:`~Py_buffer.buf`\\가 가리키는 메모리 위치가 "
":c:member:`~Py_buffer.itemsize` 크기의 스칼라로 해석됩니다. 이 경우, "
":c:member:`~Py_buffer.shape` 과 :c:member:`~Py_buffer.strides`\\는 모두 "
"``NULL``\\입니다."

#: ../../c-api/buffer.rst:371
msgid ""
"If :c:member:`~Py_buffer.strides` is ``NULL``, the array is interpreted "
"as a standard n-dimensional C-array. Otherwise, the consumer must access "
"an n-dimensional array as follows:"
msgstr ""
":c:member:`~Py_buffer.strides`\\가 ``NULL``\\이면, 배열은 표준 n-차원 C 배열로 해석됩니다. "
"그렇지 않으면, 소비자는 다음과 같이 n-차원 배열에 액세스해야 합니다:"

#: ../../c-api/buffer.rst:375
msgid ""
"ptr = (char *)buf + indices[0] * strides[0] + ... + indices[n-1] * "
"strides[n-1];\n"
"item = *((typeof(item) *)ptr);"
msgstr ""
"ptr = (char *)buf + indices[0] * strides[0] + ... + indices[n-1] * "
"strides[n-1];\n"
"item = *((typeof(item) *)ptr);"

#: ../../c-api/buffer.rst:381
msgid ""
"As noted above, :c:member:`~Py_buffer.buf` can point to any location "
"within the actual memory block. An exporter can check the validity of a "
"buffer with this function:"
msgstr ""
"위에서 언급했듯이, :c:member:`~Py_buffer.buf`\\는 실제 메모리 블록 내의 모든 위치를 가리킬 수 있습니다. "
"제공자(exporter)는 이 함수로 버퍼의 유효성을 검사 할 수 있습니다:"

#: ../../c-api/buffer.rst:385
#, python-format
msgid ""
"def verify_structure(memlen, itemsize, ndim, shape, strides, offset):\n"
"    \"\"\"Verify that the parameters represent a valid array within\n"
"       the bounds of the allocated memory:\n"
"           char *mem: start of the physical memory block\n"
"           memlen: length of the physical memory block\n"
"           offset: (char *)buf - mem\n"
"    \"\"\"\n"
"    if offset % itemsize:\n"
"        return False\n"
"    if offset < 0 or offset+itemsize > memlen:\n"
"        return False\n"
"    if any(v % itemsize for v in strides):\n"
"        return False\n"
"\n"
"    if ndim <= 0:\n"
"        return ndim == 0 and not shape and not strides\n"
"    if 0 in shape:\n"
"        return True\n"
"\n"
"    imin = sum(strides[j]*(shape[j]-1) for j in range(ndim)\n"
"               if strides[j] <= 0)\n"
"    imax = sum(strides[j]*(shape[j]-1) for j in range(ndim)\n"
"               if strides[j] > 0)\n"
"\n"
"    return 0 <= offset+imin and offset+imax+itemsize <= memlen"
msgstr ""
"def verify_structure(memlen, itemsize, ndim, shape, strides, offset):\n"
"    \"\"\"매개 변수가 할당된 메모리 범위 내에서 유효한 배열을 나타내는지 확인합니다:\n"
"           char *mem: 물리적 메모리 블록의 시작\n"
"           memlen: 물리적 메모리 블록의 길이\n"
"           offset: (char *)buf - mem\n"
"    \"\"\"\n"
"    if offset % itemsize:\n"
"        return False\n"
"    if offset < 0 or offset+itemsize > memlen:\n"
"        return False\n"
"    if any(v % itemsize for v in strides):\n"
"        return False\n"
"\n"
"    if ndim <= 0:\n"
"        return ndim == 0 and not shape and not strides\n"
"    if 0 in shape:\n"
"        return True\n"
"\n"
"    imin = sum(strides[j]*(shape[j]-1) for j in range(ndim)\n"
"               if strides[j] <= 0)\n"
"    imax = sum(strides[j]*(shape[j]-1) for j in range(ndim)\n"
"               if strides[j] > 0)\n"
"\n"
"    return 0 <= offset+imin and offset+imax+itemsize <= memlen"

#: ../../c-api/buffer.rst:415
msgid "PIL-style: shape, strides and suboffsets"
msgstr "PIL-스타일: shape, strides 및 suboffsets"

#: ../../c-api/buffer.rst:417
msgid ""
"In addition to the regular items, PIL-style arrays can contain pointers "
"that must be followed in order to get to the next element in a dimension."
" For example, the regular three-dimensional C-array ``char v[2][2][3]`` "
"can also be viewed as an array of 2 pointers to 2 two-dimensional arrays:"
" ``char (*v[2])[2][3]``. In suboffsets representation, those two pointers"
" can be embedded at the start of :c:member:`~Py_buffer.buf`, pointing to "
"two ``char x[2][3]`` arrays that can be located anywhere in memory."
msgstr ""
"일반 항목 외에도, PIL 스타일 배열에는 차원의 다음 요소를 가져오기 위해 따라야 하는 포인터가 포함될 수 있습니다. 예를 들어,"
" 일반 3-차원 C 배열 ``char v[2][2][3]``\\는 2개의 2-차원 배열을 가리키는 2개의 포인터 배열로 볼 수도 "
"있습니다: ``char (*v[2])[2][3]``. suboffsets 표현에서, 이 두 포인터는 "
":c:member:`~Py_buffer.buf`\\의 시작 부분에 임베드 될 수 있는데, 메모리의 어느 위치 에나 배치될 수 있는 "
"두 개의 ``char x[2][3]`` 배열을 가리킵니다."

#: ../../c-api/buffer.rst:426
msgid ""
"Here is a function that returns a pointer to the element in an N-D array "
"pointed to by an N-dimensional index when there are both non-``NULL`` "
"strides and suboffsets::"
msgstr ""
"다음은 ``NULL``\\이 아닌 strides와 suboffsets가 있을 때, N-차원 인덱스가 가리키는 N-차원 배열의 요소에"
" 대한 포인터를 반환하는 함수입니다::"

#: ../../c-api/buffer.rst:430
msgid ""
"void *get_item_pointer(int ndim, void *buf, Py_ssize_t *strides,\n"
"                       Py_ssize_t *suboffsets, Py_ssize_t *indices) {\n"
"    char *pointer = (char*)buf;\n"
"    int i;\n"
"    for (i = 0; i < ndim; i++) {\n"
"        pointer += strides[i] * indices[i];\n"
"        if (suboffsets[i] >=0 ) {\n"
"            pointer = *((char**)pointer) + suboffsets[i];\n"
"        }\n"
"    }\n"
"    return (void*)pointer;\n"
"}"
msgstr ""
"void *get_item_pointer(int ndim, void *buf, Py_ssize_t *strides,\n"
"                       Py_ssize_t *suboffsets, Py_ssize_t *indices) {\n"
"    char *pointer = (char*)buf;\n"
"    int i;\n"
"    for (i = 0; i < ndim; i++) {\n"
"        pointer += strides[i] * indices[i];\n"
"        if (suboffsets[i] >=0 ) {\n"
"            pointer = *((char**)pointer) + suboffsets[i];\n"
"        }\n"
"    }\n"
"    return (void*)pointer;\n"
"}"

#: ../../c-api/buffer.rst:445
msgid "Buffer-related functions"
msgstr "버퍼 관련 함수"

#: ../../c-api/buffer.rst:449
msgid ""
"Return ``1`` if *obj* supports the buffer interface otherwise ``0``.  "
"When ``1`` is returned, it doesn't guarantee that "
":c:func:`PyObject_GetBuffer` will succeed.  This function always "
"succeeds."
msgstr ""
"*obj*\\가 버퍼 인터페이스를 지원하면 ``1``\\을 반환하고, 그렇지 않으면 ``0``\\을 반환합니다. ``1``\\이 "
"반환될 때, :c:func:`PyObject_GetBuffer`\\가 성공할 것이라고 보장하지는 않습니다. 이 함수는 항상 "
"성공합니다."

#: ../../c-api/buffer.rst:456
msgid ""
"Send a request to *exporter* to fill in *view* as specified by  *flags*. "
"If the exporter cannot provide a buffer of the exact type, it MUST raise "
":exc:`BufferError`, set ``view->obj`` to ``NULL`` and return ``-1``."
msgstr ""
"*flags*\\에 지정된 대로 *view*\\를 채우도록 *exporter*\\에게 요청을 보냅니다. 제공자(exporter)가 "
"정확한 유형의 버퍼를 제공할 수 없다면, :exc:`BufferError`\\를 일으키고, ``view->obj``\\를 "
"``NULL``\\로 설정하고, ``-1``\\를 반환해야 합니다."

#: ../../c-api/buffer.rst:461
msgid ""
"On success, fill in *view*, set ``view->obj`` to a new reference to "
"*exporter* and return 0. In the case of chained buffer providers that "
"redirect requests to a single object, ``view->obj`` MAY refer to this "
"object instead of *exporter* (See :ref:`Buffer Object Structures <buffer-"
"structs>`)."
msgstr ""
"성공하면, *view*\\를 채우고, ``view->obj``\\를 *exporter*\\에 대한 새 참조로 설정하고, 0을 "
"반환합니다. 요청을 단일 객체로 리디렉션하는 연결된(chained) 버퍼 공급자의 경우, ``view->obj``\\는 "
"*exporter* 대신 이 객체를 참조할 수 있습니다 (:ref:`버퍼 객체 구조체 <buffer-structs>`\\를 "
"보세요)."

#: ../../c-api/buffer.rst:466
msgid ""
"Successful calls to :c:func:`PyObject_GetBuffer` must be paired with "
"calls to :c:func:`PyBuffer_Release`, similar to :c:func:`malloc` and "
":c:func:`free`. Thus, after the consumer is done with the buffer, "
":c:func:`PyBuffer_Release` must be called exactly once."
msgstr ""
":c:func:`PyObject_GetBuffer`\\에 대한 성공적인 호출은 :c:func:`PyBuffer_Release`\\에"
" 대한 호출과 쌍을 이루어야 합니다, :c:func:`malloc`\\과 :c:func:`free`\\와 유사합니다. 따라서, "
"소비자가 버퍼로 작업한 후에는, :c:func:`PyBuffer_Release`\\를 정확히 한 번 호출해야 합니다."

#: ../../c-api/buffer.rst:474
msgid ""
"Release the buffer *view* and release the :term:`strong reference` (i.e. "
"decrement the reference count) to the view's supporting object, "
"``view->obj``. This function MUST be called when the buffer is no longer "
"being used, otherwise reference leaks may occur."
msgstr ""
"버퍼 *view*\\를 해제하고 뷰의 지원 객체인 ``view->obj``\\에 대한 :term:`강한 참조 <strong "
"reference>`\\를 해제합니다 (즉 참조 횟수를 감소시킵니다). 버퍼가 더는 사용되지 않을 때, 이 함수를 반드시 호출해야 "
"합니다. 그렇지 않으면 참조 누수가 발생할 수 있습니다."

#: ../../c-api/buffer.rst:479
msgid ""
"It is an error to call this function on a buffer that was not obtained "
"via :c:func:`PyObject_GetBuffer`."
msgstr ":c:func:`PyObject_GetBuffer`\\를 통해 얻지 않은 버퍼에 이 함수를 호출하는 것은 에러입니다."

#: ../../c-api/buffer.rst:485
msgid ""
"Return the implied :c:member:`~Py_buffer.itemsize` from "
":c:member:`~Py_buffer.format`. On error, raise an exception and return "
"-1."
msgstr ""
":c:member:`~Py_buffer.format`\\이 암시하는 :c:member:`~Py_buffer.itemsize`\\를 "
"반환합니다. 에러가 발생하면, 예외를 발생시키고 -1을 반환합니다."

#: ../../c-api/buffer.rst:493
msgid ""
"Return ``1`` if the memory defined by the *view* is C-style (*order* is "
"``'C'``) or Fortran-style (*order* is ``'F'``) :term:`contiguous` or "
"either one (*order* is ``'A'``).  Return ``0`` otherwise.  This function "
"always succeeds."
msgstr ""
"*view*\\로 정의된 메모리가 C 스타일(*order*\\가 ``'C'``)이나 포트란 스타일(*order*\\가 "
"``'F'``) :term:`연속 <contiguous>`\\이거나 둘 중 하나(*order*\\가 ``'A'``)면 "
"``1``\\을 반환합니다. 그렇지 않으면 ``0``\\을 반환합니다. 이 함수는 항상 성공합니다."

#: ../../c-api/buffer.rst:500
msgid ""
"Get the memory area pointed to by the *indices* inside the given *view*. "
"*indices* must point to an array of ``view->ndim`` indices."
msgstr ""
"주어진 *view* 내부의 *indices*\\가 가리키는 메모리 영역을 가져옵니다. *indices*\\는 "
"``view->ndim`` 인덱스의 배열을 가리켜야 합니다."

#: ../../c-api/buffer.rst:506
msgid ""
"Copy contiguous *len* bytes from *buf* to *view*. *fort* can be ``'C'`` "
"or ``'F'`` (for C-style or Fortran-style ordering). ``0`` is returned on "
"success, ``-1`` on error."
msgstr ""
"*buf*\\에 있는 연속된 *len* 바이트를 *view*\\로 복사합니다. *fort*\\는 ``'C'`` 또는 "
"``'F'``\\(C 스타일 또는 포트란 스타일 순서)일 수 있습니다. 성공하면 ``0``\\이 반환되고, 에러가 있으면 "
"``-1``\\이 반환됩니다."

#: ../../c-api/buffer.rst:513
msgid ""
"Copy *len* bytes from *src* to its contiguous representation in *buf*. "
"*order* can be ``'C'`` or ``'F'`` or ``'A'`` (for C-style or Fortran-"
"style ordering or either one). ``0`` is returned on success, ``-1`` on "
"error."
msgstr ""
"*src*\\에 있는 *len* 바이트를 *buf*\\에 연속 표현으로 복사합니다. *order*\\는 ``'C'`` 또는 "
"``'F'`` 또는 ``'A'``\\(C 스타일 또는 포트란 스타일 순서 또는 둘 중 하나)일 수 있습니다. 성공하면 "
"``0``\\이 반환되고, 에러가 있으면 ``-1``\\이 반환됩니다."

#: ../../c-api/buffer.rst:517
msgid "This function fails if *len* != *src->len*."
msgstr "이 함수는 *len* != *src->len*\\이면 실패합니다."

#: ../../c-api/buffer.rst:522
msgid ""
"Copy data from *src* to *dest* buffer. Can convert between C-style and or"
" Fortran-style buffers."
msgstr ""

#: ../../c-api/buffer.rst:525
msgid "``0`` is returned on success, ``-1`` on error."
msgstr ""

#: ../../c-api/buffer.rst:529
msgid ""
"Fill the *strides* array with byte-strides of a :term:`contiguous` "
"(C-style if *order* is ``'C'`` or Fortran-style if *order* is ``'F'``) "
"array of the given shape with the given number of bytes per element."
msgstr ""
"*strides* 배열을 주어진 요소당 바이트 수와 주어진 shape 으로 :term:`연속 <contiguous>` "
"(*order*\\가 ``'C'``\\면 C 스타일, *order*\\가 ``'F'``\\면 포트란 스타일) 배열의 바이트 "
"스트라이드로 채웁니다."

#: ../../c-api/buffer.rst:536
msgid ""
"Handle buffer requests for an exporter that wants to expose *buf* of size"
" *len* with writability set according to *readonly*. *buf* is interpreted"
" as a sequence of unsigned bytes."
msgstr ""
"*readonly*\\에 따라 쓰기 가능성이 설정된 *len* 크기의 *buf*\\를 노출하려는 제공자(exporter)에 대한 "
"버퍼 요청을 처리합니다. *buf*\\는 부호 없는 바이트의 시퀀스로 해석됩니다."

#: ../../c-api/buffer.rst:540
msgid ""
"The *flags* argument indicates the request type. This function always "
"fills in *view* as specified by flags, unless *buf* has been designated "
"as read-only and :c:macro:`PyBUF_WRITABLE` is set in *flags*."
msgstr ""
"*flags* 인자는 요청 유형을 나타냅니다. 이 함수는 *buf*\\가 읽기 전용으로 지정되고 "
":c:macro:`PyBUF_WRITABLE`\\이 *flags*\\에 설정되어 있지 않으면, 항상 플래그가 지정하는 대로 "
"*view*\\를 채웁니다."

#: ../../c-api/buffer.rst:544
msgid ""
"On success, set ``view->obj`` to a new reference to *exporter* and return"
" 0. Otherwise, raise :exc:`BufferError`, set ``view->obj`` to ``NULL`` "
"and return ``-1``;"
msgstr ""
"성공하면, ``view->obj``\\를 *exporter*\\에 대한 새 참조로 설정하고, 0을 반환합니다. 그렇지 않으면, "
":exc:`BufferError`\\를 일으키고, ``view->obj``\\를 ``NULL``\\로 설정한 다음 ``-1``\\을"
" 반환합니다."

#: ../../c-api/buffer.rst:548
msgid ""
"If this function is used as part of a :ref:`getbufferproc <buffer-"
"structs>`, *exporter* MUST be set to the exporting object and *flags* "
"must be passed unmodified. Otherwise, *exporter* MUST be ``NULL``."
msgstr ""
"이 함수가 :ref:`getbufferproc <buffer-structs>`\\의 일부로 사용되면, *exporter*\\가 "
"제공하는(exporting) 객체로 설정되어야 하고, *flags*\\는 수정되지 않은 채로 전달되어야 합니다. 그렇지 않으면 "
"*exporter*\\가 ``NULL``\\이어야 합니다."

#: ../../c-api/buffer.rst:3
msgid "buffer protocol"
msgstr "버퍼 프로토콜"

#: ../../c-api/buffer.rst:3
msgid "buffer interface"
msgstr "버퍼 인터페이스"

#: ../../c-api/buffer.rst:3
msgid "(see buffer protocol)"
msgstr "(버퍼 프로토콜을 보십시오)"

#: ../../c-api/buffer.rst:3
msgid "buffer object"
msgstr "버퍼 객체"

#: ../../c-api/buffer.rst:32
msgid "PyBufferProcs (C type)"
msgstr "PyBufferProcs (C 형)"

#: ../../c-api/buffer.rst:301
msgid "contiguous"
msgstr "연속"

#: ../../c-api/buffer.rst:301
msgid "C-contiguous"
msgstr "C-연속"

#: ../../c-api/buffer.rst:301
msgid "Fortran contiguous"
msgstr "포트란 연속"