# 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-04-17 23:44+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"

#: ../../library/asyncio-eventloop.rst:8

msgid "Event Loop"

msgstr "이벤트 루프"

#: ../../library/asyncio-eventloop.rst:10

msgid ""

"**Source code:** :source:`Lib/asyncio/events.py`, "

":source:`Lib/asyncio/base_events.py`"

msgstr ""

"**소스 코드:** :source:`Lib/asyncio/events.py`, "

":source:`Lib/asyncio/base_events.py`"

#: ../../library/asyncio-eventloop.rst:16

msgid "Preface"

msgstr "머리말"

#: ../../library/asyncio-eventloop.rst:17

msgid ""

"The event loop is the core of every asyncio application. Event loops run "

"asynchronous tasks and callbacks, perform network IO operations, and run "

"subprocesses."

msgstr ""

"이벤트 루프는 모든 asyncio 응용 프로그램의 핵심입니다. 이벤트 루프는 비동기 태스크 및 콜백을 실행하고 네트워크 IO 연산을"

" 수행하며 자식 프로세스를 실행합니다."

#: ../../library/asyncio-eventloop.rst:21

msgid ""

"Application developers should typically use the high-level asyncio "

"functions, such as :func:`asyncio.run`, and should rarely need to "

"reference the loop object or call its methods. This section is intended "

"mostly for authors of lower-level code, libraries, and frameworks, who "

"need finer control over the event loop behavior."

msgstr ""

"응용 프로그램 개발자는 일반적으로 :func:`asyncio.run`\\과 같은 고수준의 asyncio 함수를 사용해야 하며, 루프"

" 객체를 참조하거나 메서드를 호출할 필요가 거의 없습니다. 이 절은 주로 이벤트 루프 동작을 세부적으로 제어해야 하는 저수준 코드,"

" 라이브러리 및 프레임워크의 작성자를 대상으로 합니다."

#: ../../library/asyncio-eventloop.rst:28

msgid "Obtaining the Event Loop"

msgstr "이벤트 루프 얻기"

#: ../../library/asyncio-eventloop.rst:29

msgid ""

"The following low-level functions can be used to get, set, or create an "

"event loop:"

msgstr "다음 저수준 함수를 사용하여 이벤트 루프를 가져오거나 설정하거나 만들 수 있습니다.:"

#: ../../library/asyncio-eventloop.rst:34

msgid "Return the running event loop in the current OS thread."

msgstr "현재 OS 스레드에서 실행 중인 이벤트 루프를 반환합니다."

#: ../../library/asyncio-eventloop.rst:36

msgid "Raise a :exc:`RuntimeError` if there is no running event loop."

msgstr "실행 중인 이벤트 루프가 없으면 :exc:`RuntimeError`\\를 발생시킵니다."

#: ../../library/asyncio-eventloop.rst:38

msgid "This function can only be called from a coroutine or a callback."

msgstr "이 함수는 코루틴이나 콜백에서만 호출할 수 있습니다."

#: ../../library/asyncio-eventloop.rst:44

msgid "Get the current event loop."

msgstr "현재의 이벤트 루프를 가져옵니다."

#: ../../library/asyncio-eventloop.rst:46

msgid ""

"When called from a coroutine or a callback (e.g. scheduled with call_soon"

" or similar API), this function will always return the running event "

"loop."

msgstr ""

#: ../../library/asyncio-eventloop.rst:50

msgid ""

"If there is no running event loop set, the function will return the "

"result of the ``get_event_loop_policy().get_event_loop()`` call."

msgstr ""

#: ../../library/asyncio-eventloop.rst:53

msgid ""

"Because this function has rather complex behavior (especially when custom"

" event loop policies are in use), using the :func:`get_running_loop` "

"function is preferred to :func:`get_event_loop` in coroutines and "

"callbacks."

msgstr ""

"이 함수는 (특히 사용자 정의 이벤트 루프 정책을 사용할 때) 다소 복잡한 동작을 하므로, 코루틴과 콜백에서 "

":func:`get_event_loop`\\보다 :func:`get_running_loop` 함수를 사용하는 것이 좋습니다."

#: ../../library/asyncio-eventloop.rst:58

msgid ""

"As noted above, consider using the higher-level :func:`asyncio.run` "

"function, instead of using these lower level functions to manually create"

" and close an event loop."

msgstr ""

"위에서 언급된 바와 같이, 이 저수준 함수를 사용하여 수동으로 이벤트 루프를 만들고 닫는 대신, 고수준 "

":func:`asyncio.run` 함수를 사용하는 것을 고려하십시오."

#: ../../library/asyncio-eventloop.rst:62

msgid ""

"Deprecation warning is emitted if there is no current event loop. In some"

" future Python release this will become an error."

msgstr ""

#: ../../library/asyncio-eventloop.rst:68

msgid "Set *loop* as the current event loop for the current OS thread."

msgstr "*loop*\\를 현재 OS 스레드의 현재 이벤트 루프로 설정합니다."

#: ../../library/asyncio-eventloop.rst:72

msgid "Create and return a new event loop object."

msgstr "새 이벤트 루프 객체를 만들고 반환합니다."

#: ../../library/asyncio-eventloop.rst:74

msgid ""

"Note that the behaviour of :func:`get_event_loop`, "

":func:`set_event_loop`, and :func:`new_event_loop` functions can be "

"altered by :ref:`setting a custom event loop policy <asyncio-policies>`."

msgstr ""

":func:`get_event_loop`, :func:`set_event_loop` 및 :func:`new_event_loop` "

"함수의 동작은 :ref:`사용자 정의 이벤트 루프 정책 설정 <asyncio-policies>`\\에 의해 변경될 수 있음에 "

"유의하십시오."

#: ../../library/asyncio-eventloop.rst:80

msgid "Contents"

msgstr "목차"

#: ../../library/asyncio-eventloop.rst:81

msgid "This documentation page contains the following sections:"

msgstr "이 설명서 페이지는 다음과 같은 절로 구성됩니다:"

#: ../../library/asyncio-eventloop.rst:83

msgid ""

"The `Event Loop Methods`_ section is the reference documentation of the "

"event loop APIs;"

msgstr "`이벤트 루프 메서드 <Event Loop Methods_>`_ 절은 이벤트 루프 API의 레퍼런스 설명서입니다."

#: ../../library/asyncio-eventloop.rst:86

msgid ""

"The `Callback Handles`_ section documents the :class:`Handle` and "

":class:`TimerHandle` instances which are returned from scheduling methods"

" such as :meth:`loop.call_soon` and :meth:`loop.call_later`;"

msgstr ""

"`콜백 핸들 <Callback Handles_>`_ 절은 :meth:`loop.call_soon` 및 "

":meth:`loop.call_later`\\와 같은 예약 메서드에서 반환된 :class:`Handle` 및 "

":class:`TimerHandle` 인스턴스를 설명합니다."

#: ../../library/asyncio-eventloop.rst:90

msgid ""

"The `Server Objects`_ section documents types returned from event loop "

"methods like :meth:`loop.create_server`;"

msgstr ""

"`서버 객체 <Server Objects_>`_ 절은 :meth:`loop.create_server`\\와 같은 이벤트 루프 "

"메서드에서 반환되는 형을 설명합니다."

#: ../../library/asyncio-eventloop.rst:93

msgid ""

"The `Event Loop Implementations`_ section documents the "

":class:`SelectorEventLoop` and :class:`ProactorEventLoop` classes;"

msgstr ""

"`이벤트 루프 구현 <Event Loop Implementations_>`_ 절은 :class:`SelectorEventLoop` "

"및 :class:`ProactorEventLoop` 클래스를 설명합니다."

#: ../../library/asyncio-eventloop.rst:96

msgid "The `Examples`_ section showcases how to work with some event loop APIs."

msgstr "`예제 <Examples_>`_ 절에서는 일부 이벤트 루프 API로 작업하는 방법을 보여줍니다."

#: ../../library/asyncio-eventloop.rst:103

msgid "Event Loop Methods"

msgstr "이벤트 루프 메서드"

#: ../../library/asyncio-eventloop.rst:105

msgid "Event loops have **low-level** APIs for the following:"

msgstr "이벤트 루프에는 다음과 같은 **저수준** API가 있습니다:"

#: ../../library/asyncio-eventloop.rst:113

msgid "Running and stopping the loop"

msgstr "루프 실행 및 중지"

#: ../../library/asyncio-eventloop.rst:117

msgid "Run until the *future* (an instance of :class:`Future`) has completed."

msgstr "*future*\\(:class:`Future`\\의 인스턴스)가 완료할 때까지 실행합니다."

#: ../../library/asyncio-eventloop.rst:120

msgid ""

"If the argument is a :ref:`coroutine object <coroutine>` it is implicitly"

" scheduled to run as a :class:`asyncio.Task`."

msgstr ""

"인자가 :ref:`코루틴 객체 <coroutine>` 면, :class:`asyncio.Task`\\로 실행되도록 묵시적으로 예약 "

"됩니다."

#: ../../library/asyncio-eventloop.rst:123

msgid "Return the Future's result or raise its exception."

msgstr "퓨처의 결과를 반환하거나 퓨처의 예외를 일으킵니다."

#: ../../library/asyncio-eventloop.rst:127

msgid "Run the event loop until :meth:`stop` is called."

msgstr ":meth:`stop`\\가 호출될 때까지 이벤트 루프를 실행합니다."

#: ../../library/asyncio-eventloop.rst:129

msgid ""

"If :meth:`stop` is called before :meth:`run_forever` is called, the loop "

"will poll the I/O selector once with a timeout of zero, run all callbacks"

" scheduled in response to I/O events (and those that were already "

"scheduled), and then exit."

msgstr ""

":meth:`run_forever` 가 호출되기 전에 :meth:`stop` 이 호출되었으면, 루프는 시간제한 0으로 I/O "

"셀렉터를 한 번 폴링하고, I/O 이벤트에 따라 예약된 모든 콜백(과 이미 예약된 것들)을 실행한 다음 종료합니다."

#: ../../library/asyncio-eventloop.rst:134

msgid ""

"If :meth:`stop` is called while :meth:`run_forever` is running, the loop "

"will run the current batch of callbacks and then exit. Note that new "

"callbacks scheduled by callbacks will not run in this case; instead, they"

" will run the next time :meth:`run_forever` or :meth:`run_until_complete`"

" is called."

msgstr ""

"만약 :meth:`stop` 이 :meth:`run_forever` 가 실행 중일 때 호출되면, 루프는 현재 걸려있는 콜백들을 "

"실행한 다음 종료합니다. 콜백에 의해 예약되는 새 콜백은 이 경우 실행되지 않습니다; 대신 그것들은 다음에 "

":meth:`run_forever`\\나 :meth:`run_until_complete`\\가 호출될 때 실행됩니다."

#: ../../library/asyncio-eventloop.rst:142

msgid "Stop the event loop."

msgstr "이벤트 루프를 중지합니다."

#: ../../library/asyncio-eventloop.rst:146

msgid "Return ``True`` if the event loop is currently running."

msgstr "이벤트 루프가 현재 실행 중이면 ``True`` 를 반환합니다."

#: ../../library/asyncio-eventloop.rst:150

msgid "Return ``True`` if the event loop was closed."

msgstr "이벤트 루프가 닫혔으면 ``True`` 를 반환합니다."

#: ../../library/asyncio-eventloop.rst:154

msgid "Close the event loop."

msgstr "이벤트 루프를 닫습니다."

#: ../../library/asyncio-eventloop.rst:156

msgid ""

"The loop must not be running when this function is called. Any pending "

"callbacks will be discarded."

msgstr "이 함수를 호출할 때 루프는 반드시 실행 중이지 않아야 합니다. 계류 중인 모든 콜백을 버립니다."

#: ../../library/asyncio-eventloop.rst:159

msgid ""

"This method clears all queues and shuts down the executor, but does not "

"wait for the executor to finish."

msgstr "이 메서드는 모든 큐를 비우고 실행기를 종료하지만, 실행기가 완료할 때까지 기다리지 않습니다."

#: ../../library/asyncio-eventloop.rst:162

msgid ""

"This method is idempotent and irreversible. No other methods should be "

"called after the event loop is closed."

msgstr "이 메서드는 멱등적(itempotent)이고 되돌릴 수 없습니다. 이벤트 루프가 닫힌 후에 다른 메서드를 호출해서는 안 됩니다."

#: ../../library/asyncio-eventloop.rst:168

msgid ""

"Schedule all currently open :term:`asynchronous generator` objects to "

"close with an :meth:`~agen.aclose` call. After calling this method, the "

"event loop will issue a warning if a new asynchronous generator is "

"iterated. This should be used to reliably finalize all scheduled "

"asynchronous generators."

msgstr ""

"현재 열려있는 :term:`비동기 제너레이터 <asynchronous generator>` 객체를 모두 "

":meth:`~agen.aclose` 호출로 닫도록 예약 합니다. 이 메서드를 호출한 후에는, 새 비동기 생성기가 이터레이트 되면 "

"이벤트 루프에서 경고를 보냅니다. 예약된 모든 비동기 제너레이터를 신뢰성 있게 종료하는 데 사용해야 합니다."

#: ../../library/asyncio-eventloop.rst:174

msgid ""

"Note that there is no need to call this function when :func:`asyncio.run`"

" is used."

msgstr ":func:`asyncio.run`\\가 사용될 때 이 함수를 호출할 필요는 없다는 점에 유의하세요."

#: ../../library/asyncio-eventloop.rst:177

#: ../../library/asyncio-eventloop.rst:1301

#: ../../library/asyncio-eventloop.rst:1750

msgid "Example::"

msgstr "예::"

#: ../../library/asyncio-eventloop.rst:179

msgid ""

"try:\n"

" loop.run_forever()\n"

"finally:\n"

" loop.run_until_complete(loop.shutdown_asyncgens())\n"

" loop.close()"

msgstr ""

"try:\n"

" loop.run_forever()\n"

"finally:\n"

" loop.run_until_complete(loop.shutdown_asyncgens())\n"

" loop.close()"

#: ../../library/asyncio-eventloop.rst:190

msgid ""

"Schedule the closure of the default executor and wait for it to join all "

"of the threads in the :class:`~concurrent.futures.ThreadPoolExecutor`. "

"Once this method has been called, using the default executor with "

":meth:`loop.run_in_executor` will raise a :exc:`RuntimeError`."

msgstr ""

"기본 실행기의 닫힘을 예약하고 :class:`~concurrent.futures.ThreadPoolExecutor`\\의 모든 "

"스레드가 조인(join)될 때까지 기다립니다. 이 메서드가 호출된 후, :meth:`loop.run_in_executor`\\로 "

"기본 실행기를 사용하면 :exc:`RuntimeError`\\가 발생합니다."

#: ../../library/asyncio-eventloop.rst:196

msgid ""

"The *timeout* parameter specifies the amount of time (in :class:`float` "

"seconds) the executor will be given to finish joining. With the default, "

"``None``, the executor is allowed an unlimited amount of time."

msgstr ""

#: ../../library/asyncio-eventloop.rst:201

msgid ""

"If the *timeout* is reached, a :exc:`RuntimeWarning` is emitted and the "

"default executor is terminated without waiting for its threads to finish "

"joining."

msgstr ""

#: ../../library/asyncio-eventloop.rst:207

msgid ""

"Do not call this method when using :func:`asyncio.run`, as the latter "

"handles default executor shutdown automatically."

msgstr ""

#: ../../library/asyncio-eventloop.rst:212

msgid "Added the *timeout* parameter."

msgstr "*timeout* 매개 변수가 추가되었습니다."

#: ../../library/asyncio-eventloop.rst:216

msgid "Scheduling callbacks"

msgstr "콜백 예약하기"

#: ../../library/asyncio-eventloop.rst:220

msgid ""

"Schedule the *callback* :term:`callback` to be called with *args* "

"arguments at the next iteration of the event loop."

msgstr ""

"이벤트 루프의 다음 이터레이션 때 *args* 인자로 호출할 *callback* :term:`콜백 <callback>`\\을 "

"예약합니다."

#: ../../library/asyncio-eventloop.rst:223

msgid ""

"Return an instance of :class:`asyncio.Handle`, which can be used later to"

" cancel the callback."

msgstr ":class:`asyncio.Handle` 인스턴스를 반환하는데, 나중에 콜백을 취소하는 데 사용할 수 있습니다."

#: ../../library/asyncio-eventloop.rst:226

msgid ""

"Callbacks are called in the order in which they are registered. Each "

"callback will be called exactly once."

msgstr "콜백은 등록된 순서대로 호출됩니다. 각 콜백은 정확히 한 번 호출됩니다."

#: ../../library/asyncio-eventloop.rst:229

msgid ""

"The optional keyword-only *context* argument specifies a custom "

":class:`contextvars.Context` for the *callback* to run in. Callbacks use "

"the current context when no *context* is provided."

msgstr ""

"선택적인 키워드 전용 *context* 인자는 *callback* 을 실행할 사용자 정의 "

":class:`contextvars.Context` 를 지정합니다. *context* 가 제공되지 않을 때, 콜백은 현재 컨텍스트를"

" 사용합니다."

#: ../../library/asyncio-eventloop.rst:233

msgid "Unlike :meth:`call_soon_threadsafe`, this method is not thread-safe."

msgstr ":meth:`call_soon_threadsafe`\\와 달리, 이 메서드는 스레드 안전하지 않습니다."

#: ../../library/asyncio-eventloop.rst:237

msgid ""

"A thread-safe variant of :meth:`call_soon`. When scheduling callbacks "

"from another thread, this function *must* be used, since "

":meth:`call_soon` is not thread-safe."

msgstr ""

"스레드 안전한 :meth:`call_soon` 변형입니다. :meth:`call_soon`\\은 스레드 안전하지 않기 때문에, 다른"

" 스레드에서 콜백을 예약할 때, *반드시* 이 함수를 사용해야 합니다."

#: ../../library/asyncio-eventloop.rst:241

msgid ""

"This function is safe to be called from a reentrant context or signal "

"handler, however, it is not safe or fruitful to use the returned handle "

"in such contexts."

msgstr ""

#: ../../library/asyncio-eventloop.rst:244

msgid ""

"Raises :exc:`RuntimeError` if called on a loop that's been closed. This "

"can happen on a secondary thread when the main application is shutting "

"down."

msgstr ""

#: ../../library/asyncio-eventloop.rst:248

msgid ""

"See the :ref:`concurrency and multithreading <asyncio-multithreading>` "

"section of the documentation."

msgstr "설명서의 :ref:`동시성과 다중 스레딩 <asyncio-multithreading>` 절을 참고하십시오."

#: ../../library/asyncio-eventloop.rst:251

#: ../../library/asyncio-eventloop.rst:301

#: ../../library/asyncio-eventloop.rst:321

msgid ""

"The *context* keyword-only parameter was added. See :pep:`567` for more "

"details."

msgstr "*context* 키워드 전용 매개 변수가 추가되었습니다. 자세한 정보는 :pep:`567`\\을 보십시오."

#: ../../library/asyncio-eventloop.rst:259

msgid ""

"Most :mod:`asyncio` scheduling functions don't allow passing keyword "

"arguments. To do that, use :func:`functools.partial`::"

msgstr ""

"대부분 :mod:`asyncio` 예약 함수는 키워드 인자 전달을 허용하지 않습니다. 그렇게 하려면 "

":func:`functools.partial`\\을 사용하십시오::"

#: ../../library/asyncio-eventloop.rst:262

msgid ""

"# will schedule \"print(\"Hello\", flush=True)\"\n"

"loop.call_soon(\n"

" functools.partial(print, \"Hello\", flush=True))"

msgstr ""

"# \"print(\"Hello\", flush=True)\" 를 예약합니다\n"

"loop.call_soon(\n"

" functools.partial(print, \"Hello\", flush=True))"

#: ../../library/asyncio-eventloop.rst:266

msgid ""

"Using partial objects is usually more convenient than using lambdas, as "

"asyncio can render partial objects better in debug and error messages."

msgstr ""

"asyncio는 디버그 및 오류 메시지에서 partial 객체를 더욱 잘 표시할 수 있으므로, partial 객체를 사용하는 것이 "

"람다를 사용하는 것보다 편리합니다."

#: ../../library/asyncio-eventloop.rst:274

msgid "Scheduling delayed callbacks"

msgstr "지연된 콜백 예약"

#: ../../library/asyncio-eventloop.rst:276

msgid ""

"Event loop provides mechanisms to schedule callback functions to be "

"called at some point in the future. Event loop uses monotonic clocks to "

"track time."

msgstr ""

"이벤트 루프는 콜백 함수가 미래의 어떤 시점에서 호출되도록 예약하는 메커니즘을 제공합니다. 이벤트 루프는 단조 시계를 사용하여 "

"시간을 추적합니다."

#: ../../library/asyncio-eventloop.rst:283

msgid ""

"Schedule *callback* to be called after the given *delay* number of "

"seconds (can be either an int or a float)."

msgstr "지정된 *delay* 초 (int 또는 float) 뒤에 *callback* 이 호출되도록 예약합니다."

#: ../../library/asyncio-eventloop.rst:286

#: ../../library/asyncio-eventloop.rst:318

msgid ""

"An instance of :class:`asyncio.TimerHandle` is returned which can be used"

" to cancel the callback."

msgstr ":class:`asyncio.TimerHandle` 의 인스턴스가 반환되는데, 콜백을 취소하는 데 사용할 수 있습니다."

#: ../../library/asyncio-eventloop.rst:289

msgid ""

"*callback* will be called exactly once. If two callbacks are scheduled "

"for exactly the same time, the order in which they are called is "

"undefined."

msgstr ""

"*callback* 은 정확히 한번 호출됩니다. 두 콜백이 정확히 같은 시간에 예약되면, 어떤 것이 먼저 호출되는지는 정의되지 "

"않습니다."

#: ../../library/asyncio-eventloop.rst:293

msgid ""

"The optional positional *args* will be passed to the callback when it is "

"called. If you want the callback to be called with keyword arguments use "

":func:`functools.partial`."

msgstr ""

"선택적 위치 *args* 는 호출 될 때 콜백에 전달됩니다. 콜백을 키워드 인자로 호출하고 싶으면 "

":func:`functools.partial` 를 사용하십시오."

#: ../../library/asyncio-eventloop.rst:297

msgid ""

"An optional keyword-only *context* argument allows specifying a custom "

":class:`contextvars.Context` for the *callback* to run in. The current "

"context is used when no *context* is provided."

msgstr ""

"선택적인 키워드 전용 *context* 인자는 *callback* 을 실행할 사용자 정의 "

":class:`contextvars.Context` 를 지정할 수 있게 합니다. *context* 가 제공되지 않을 때는 현재 "

"컨텍스트가 사용됩니다."

#: ../../library/asyncio-eventloop.rst:305

msgid ""

"In Python 3.7 and earlier with the default event loop implementation, the"

" *delay* could not exceed one day. This has been fixed in Python 3.8."

msgstr ""

"파이썬 3.7 및 이전 버전에서 기본 이벤트 루프 구현을 사용할 때, *delay*\\는 하루를 초과할 수 없었습니다. 이 문제는 "

"파이썬 3.8에서 수정되었습니다."

#: ../../library/asyncio-eventloop.rst:312

msgid ""

"Schedule *callback* to be called at the given absolute timestamp *when* "

"(an int or a float), using the same time reference as :meth:`loop.time`."

msgstr ""

"지정된 절대 타임스탬프 *when*\\(int 또는 float)에 *callback* 이 호출되도록 예약합니다. "

":meth:`loop.time` 과 같은 시간 참조를 사용하십시오."

#: ../../library/asyncio-eventloop.rst:316

msgid "This method's behavior is the same as :meth:`call_later`."

msgstr "이 메서드의 동작은 :meth:`call_later`\\와 같습니다."

#: ../../library/asyncio-eventloop.rst:325

msgid ""

"In Python 3.7 and earlier with the default event loop implementation, the"

" difference between *when* and the current time could not exceed one day."

" This has been fixed in Python 3.8."

msgstr ""

"파이썬 3.7 및 이전 버전에서 기본 이벤트 루프 구현을 사용할 때, *when*\\와 현재 시각의 차이는 하루를 초과할 수 "

"없었습니다. 이 문제는 파이썬 3.8에서 수정되었습니다."

#: ../../library/asyncio-eventloop.rst:332

msgid ""

"Return the current time, as a :class:`float` value, according to the "

"event loop's internal monotonic clock."

msgstr "이벤트 루프의 내부 단조 시계에 따라, :class:`float` 값으로 현재 시각을 반환합니다."

#: ../../library/asyncio-eventloop.rst:336

msgid ""

"In Python 3.7 and earlier timeouts (relative *delay* or absolute *when*) "

"should not exceed one day. This has been fixed in Python 3.8."

msgstr ""

"파이썬 3.7 및 이전 버전에서 제한 시간(상대적인 *delay* 나 절대적인 *when*)은 1일을 초과하지 않아야 했습니다. 이"

" 문제는 파이썬 3.8에서 수정되었습니다."

#: ../../library/asyncio-eventloop.rst:342

msgid "The :func:`asyncio.sleep` function."

msgstr ":func:`asyncio.sleep` 함수."

#: ../../library/asyncio-eventloop.rst:346

msgid "Creating Futures and Tasks"

msgstr "퓨처와 태스크 만들기"

#: ../../library/asyncio-eventloop.rst:350

msgid "Create an :class:`asyncio.Future` object attached to the event loop."

msgstr "이벤트 루프에 연결된 :class:`asyncio.Future` 객체를 만듭니다."

#: ../../library/asyncio-eventloop.rst:352

msgid ""

"This is the preferred way to create Futures in asyncio. This lets third-"

"party event loops provide alternative implementations of the Future "

"object (with better performance or instrumentation)."

msgstr ""

"이것이 asyncio에서 퓨처를 만드는 데 선호되는 방법입니다. 이렇게 하면 제삼자 이벤트 루프가 Future 객체의 다른 구현(더"

" 나은 성능이나 계측(instrumentation))을 제공할 수 있습니다"

#: ../../library/asyncio-eventloop.rst:360

msgid ""

"Schedule the execution of :ref:`coroutine <coroutine>` *coro*. Return a "

":class:`Task` object."

msgstr ":ref:`코루틴 <coroutine>` *coro*\\의 실행을 예약합니다. :class:`Task` 객체를 반환합니다."

#: ../../library/asyncio-eventloop.rst:363

msgid ""

"Third-party event loops can use their own subclass of :class:`Task` for "

"interoperability. In this case, the result type is a subclass of "

":class:`Task`."

msgstr ""

"제삼자 이벤트 루프는 상호 운용성을 위해 자신만의 :class:`Task` 의 서브 클래스를 사용할 수 있습니다. 이 경우, 결과 "

"형은 :class:`Task` 의 서브 클래스입니다."

#: ../../library/asyncio-eventloop.rst:367

msgid ""

"If the *name* argument is provided and not ``None``, it is set as the "

"name of the task using :meth:`Task.set_name`."

msgstr ""

"*name* 인자가 제공되고 ``None``\\이 아니면, :meth:`Task.set_name`\\을 사용하여 태스크의 이름으로 "

"설정됩니다."

#: ../../library/asyncio-eventloop.rst:370

msgid ""

"An optional keyword-only *context* argument allows specifying a custom "

":class:`contextvars.Context` for the *coro* to run in. The current "

"context copy is created when no *context* is provided."

msgstr ""

"선택적인 키워드 전용 *context* 인자는 *coro* 를 실행할 사용자 정의 "

":class:`contextvars.Context` 를 지정할 수 있게 합니다. *context* 가 제공되지 않을 때는 현재 "

"컨텍스트 사본이 만들어집니다."

#: ../../library/asyncio-eventloop.rst:374

msgid "Added the *name* parameter."

msgstr "*name* 매개 변수가 추가되었습니다."

#: ../../library/asyncio-eventloop.rst:377

msgid "Added the *context* parameter."

msgstr "*context* 매개 변수가 추가되었습니다."

#: ../../library/asyncio-eventloop.rst:382

msgid "Set a task factory that will be used by :meth:`loop.create_task`."

msgstr ":meth:`loop.create_task` 에 의해 사용되는 태스크 팩토리를 설정합니다."

#: ../../library/asyncio-eventloop.rst:385

msgid ""

"If *factory* is ``None`` the default task factory will be set. Otherwise,"

" *factory* must be a *callable* with the signature matching ``(loop, "

"coro, **kwargs)``, where *loop* is a reference to the active event loop, "

"and *coro* is a coroutine object. The callable must pass on all "

"*kwargs*, and return a :class:`asyncio.Task`-compatible object."

msgstr ""

"*factory* 가 ``None`` 이면 기본 태스크 팩토리가 설정됩니다. 그렇지 않으면, *factory* 는 반드시 *콜러블*"

" 이어야 하고, ``(loop, coro, **kwargs)`` 과 일치하는 서명을 가져야 합니다. 여기서 *loop* 는 활성 "

"이벤트 루프에 대한 참조가 되고, *coro* 는 코루틴 객체가 됩니다. 콜러블은 모든 *kwargs* 를 전달해야 하며, "

":class:`asyncio.Task` 호환 객체를 반환해야 합니다."

#: ../../library/asyncio-eventloop.rst:393

msgid "Return a task factory or ``None`` if the default one is in use."

msgstr "태스크 팩토리를 반환하거나, 기본값이 사용 중이면 ``None`` 을 반환합니다."

#: ../../library/asyncio-eventloop.rst:397

msgid "Opening network connections"

msgstr "네트워크 연결 열기"

#: ../../library/asyncio-eventloop.rst:409

msgid ""

"Open a streaming transport connection to a given address specified by "

"*host* and *port*."

msgstr "주어진 *host* 와 *port*\\로 지정된 주소로의 스트리밍 트랜스포트 연결을 엽니다."

#: ../../library/asyncio-eventloop.rst:412

msgid ""

"The socket family can be either :py:const:`~socket.AF_INET` or "

":py:const:`~socket.AF_INET6` depending on *host* (or the *family* "

"argument, if provided)."

msgstr ""

"소켓 패밀리는 *host*\\(또는 지정된 경우 *family*)에 따라 :py:const:`~socket.AF_INET` 또는 "

":py:const:`~socket.AF_INET6`\\일 수 있습니다."

#: ../../library/asyncio-eventloop.rst:416

msgid "The socket type will be :py:const:`~socket.SOCK_STREAM`."

msgstr "소켓 유형은 :py:const:`~socket.SOCK_STREAM`\\이 됩니다."

#: ../../library/asyncio-eventloop.rst:418

#: ../../library/asyncio-eventloop.rst:1211

#: ../../library/asyncio-eventloop.rst:1228

msgid ""

"*protocol_factory* must be a callable returning an :ref:`asyncio protocol"

" <asyncio-protocol>` implementation."

msgstr ""

"*protocol_factory* 는 반드시 :ref:`asyncio 프로토콜 <asyncio-protocol>` 구현을 반환하는 "

"콜러블이어야 합니다."

#: ../../library/asyncio-eventloop.rst:421

msgid ""

"This method will try to establish the connection in the background. When "

"successful, it returns a ``(transport, protocol)`` pair."

msgstr "이 메서드는 백그라운드에서 연결을 맺으려고 시도합니다. 성공하면, ``(transport, protocol)`` 쌍을 반환합니다."

#: ../../library/asyncio-eventloop.rst:424

msgid "The chronological synopsis of the underlying operation is as follows:"

msgstr "하부 연산의 시간순 개요는 다음과 같습니다:"

#: ../../library/asyncio-eventloop.rst:426

msgid ""

"The connection is established and a :ref:`transport <asyncio-transport>` "

"is created for it."

msgstr "연결이 맺어지고, 이를 위한 :ref:`트랜스포트(transport) <asyncio-transport>` 가 만들어집니다."

#: ../../library/asyncio-eventloop.rst:429

msgid ""

"*protocol_factory* is called without arguments and is expected to return "

"a :ref:`protocol <asyncio-protocol>` instance."

msgstr ""

"*protocol_factory* 가 인자 없이 호출되고, :ref:`프로토콜(protocol) <asyncio-protocol>`"

" 인스턴스를 반환할 것으로 기대됩니다."

#: ../../library/asyncio-eventloop.rst:432

msgid ""

"The protocol instance is coupled with the transport by calling its "

":meth:`~BaseProtocol.connection_made` method."

msgstr "프로토콜 인스턴스는 :meth:`connection_made` 메서드를 호출함으로써 트랜스포트와 연결됩니다."

#: ../../library/asyncio-eventloop.rst:435

msgid "A ``(transport, protocol)`` tuple is returned on success."

msgstr "성공하면 ``(transport, protocol)`` 튜플이 반환됩니다."

#: ../../library/asyncio-eventloop.rst:437

msgid "The created transport is an implementation-dependent bidirectional stream."

msgstr "만들어진 트랜스포트는 구현 의존적인 양방향 스트림입니다."

#: ../../library/asyncio-eventloop.rst:440

#: ../../library/asyncio-eventloop.rst:573

msgid "Other arguments:"

msgstr "다른 인자들:"

#: ../../library/asyncio-eventloop.rst:442

msgid ""

"*ssl*: if given and not false, a SSL/TLS transport is created (by default"

" a plain TCP transport is created). If *ssl* is a "

":class:`ssl.SSLContext` object, this context is used to create the "

"transport; if *ssl* is :const:`True`, a default context returned from "

":func:`ssl.create_default_context` is used."

msgstr ""

"*ssl*: 주어지고 거짓이 아니면, SSL/TLS 트랜스포트가 만들어집니다 (기본적으로는 평범한 TCP 트랜스포트가 "

"만들어집니다). *ssl* 이 :class:`ssl.SSLContext` 객체면, 트랜스포트를 만들 때 이 컨텍스트가 사용됩니다; "

"*ssl* 이 :const:`True` 면, :func:`ssl.create_default_context` 가 반환하는 기본 "

"컨텍스트가 사용됩니다."

#: ../../library/asyncio-eventloop.rst:448

msgid ":ref:`SSL/TLS security considerations <ssl-security>`"

msgstr ":ref:`SSL/TLS 보안 고려 사항 <ssl-security>`"

#: ../../library/asyncio-eventloop.rst:450

msgid ""

"*server_hostname* sets or overrides the hostname that the target server's"

" certificate will be matched against. Should only be passed if *ssl* is "

"not ``None``. By default the value of the *host* argument is used. If "

"*host* is empty, there is no default and you must pass a value for "

"*server_hostname*. If *server_hostname* is an empty string, hostname "

"matching is disabled (which is a serious security risk, allowing for "

"potential man-in-the-middle attacks)."

msgstr ""

"*server_hostname*\\는 대상 서버의 인증서가 일치될 호스트 이름을 설정하거나 대체합니다. *ssl*\\이 "

"``None``\\이 아닐 때만 전달되어야 합니다. 기본적으로 *host* 인자의 값이 사용됩니다. *host* 가 비어 있으면, "

"기본값이 없고 *server_hostname* 값을 전달해야 합니다. *server_hostname* 이 빈 문자열이면, 호스트 "

"이름 일치가 비활성화됩니다 (이것은 심각한 보안 위험으로, 잠재적인 중간자 공격을 허용하게 됩니다)."

#: ../../library/asyncio-eventloop.rst:458

msgid ""

"*family*, *proto*, *flags* are the optional address family, protocol and "

"flags to be passed through to getaddrinfo() for *host* resolution. If "

"given, these should all be integers from the corresponding :mod:`socket` "

"module constants."

msgstr ""

"*family*, *proto*, *flags* 는 *host* 결정을 위해 getaddrinfo() 에 전달할 선택적 주소 "

"패밀리, 프로토콜, 플래그입니다. 주어지면, 이것들은 모두 해당하는 :mod:`socket` 모듈 상수에 대응하는 정수여야 합니다."

#: ../../library/asyncio-eventloop.rst:463

msgid ""

"*happy_eyeballs_delay*, if given, enables Happy Eyeballs for this "

"connection. It should be a floating-point number representing the amount "

"of time in seconds to wait for a connection attempt to complete, before "

"starting the next attempt in parallel. This is the \"Connection Attempt "

"Delay\" as defined in :rfc:`8305`. A sensible default value recommended "

"by the RFC is ``0.25`` (250 milliseconds)."

msgstr ""

"주어지면, *happy_eyeballs_delay*\\는 이 연결에 대해 Happy Eyeballs를 활성화합니다. 다음 시도를 "

"병렬로 시작하기 전에, 연결 시도가 완료되기를 기다리는 시간(초)을 나타내는 부동 소수점 숫자여야 합니다. 이것은 "

":rfc:`8305`\\에 정의된 \"연결 시도 지연(Connection Attempt Delay)\" 입니다. RFC에서 권장하는"

" 적절한 기본값은 ``0.25``\\(250밀리 초)입니다."

#: ../../library/asyncio-eventloop.rst:471

msgid ""

"*interleave* controls address reordering when a host name resolves to "

"multiple IP addresses. If ``0`` or unspecified, no reordering is done, "

"and addresses are tried in the order returned by :meth:`getaddrinfo`. If "

"a positive integer is specified, the addresses are interleaved by address"

" family, and the given integer is interpreted as \"First Address Family "

"Count\" as defined in :rfc:`8305`. The default is ``0`` if "

"*happy_eyeballs_delay* is not specified, and ``1`` if it is."

msgstr ""

"*interleave*\\는 호스트 이름이 여러 IP 주소로 해석될 때 주소 재정렬을 제어합니다. ``0``\\이거나 지정되지 "

"않으면, 재정렬이 수행되지 않고, 주소는 :meth:`getaddrinfo`\\에 의해 반환된 순서대로 시도됩니다. 양의 정수가 "

"지정되면, 주소는 주소 패밀리에 의해 인터리브 되고, 주어진 정수는 :rfc:`8305`\\에 정의된 대로 \"첫 번째 주소 패밀리"

" 수(First Address Family Count)\"로 해석됩니다. 기본값은 *happy_eyeballs_delay*\\가 "

"지정되지 않으면 ``0``\\이고, 지정되면 ``1``\\입니다."

#: ../../library/asyncio-eventloop.rst:480

msgid ""

"*sock*, if given, should be an existing, already connected "

":class:`socket.socket` object to be used by the transport. If *sock* is "

"given, none of *host*, *port*, *family*, *proto*, *flags*, "

"*happy_eyeballs_delay*, *interleave* and *local_addr* should be "

"specified."

msgstr ""

"*sock* 이 주어지면, 트랜스포트가 사용할, 기존의 이미 연결된 :class:`socket.socket` 객체여야 합니다. "

"*sock* 이 주어지면, *host*, *port*, *family*, *proto*, *flags*, "

"*happy_eyeballs_delay*, *interleave*, *local_addr* 를 지정해서는 안 됩니다."

#: ../../library/asyncio-eventloop.rst:488

#: ../../library/asyncio-eventloop.rst:604

#: ../../library/asyncio-eventloop.rst:852

msgid ""

"The *sock* argument transfers ownership of the socket to the transport "

"created. To close the socket, call the transport's "

":meth:`~asyncio.BaseTransport.close` method."

msgstr ""

#: ../../library/asyncio-eventloop.rst:492

msgid ""

"*local_addr*, if given, is a ``(local_host, local_port)`` tuple used to "

"bind the socket locally. The *local_host* and *local_port* are looked up"

" using ``getaddrinfo()``, similarly to *host* and *port*."

msgstr ""

"*local_addr* 이 주어지면, 소켓을 로컬에 바인드 하는데 사용되는 ``(local_host, local_port)`` "

"튜플이어야 합니다. *local_host* 와 *local_port* 는 *host* 및 *port* 와 유사하게 "

"``getaddrinfo()`` 를 사용하여 조회됩니다."

#: ../../library/asyncio-eventloop.rst:496

#: ../../library/asyncio-eventloop.rst:948

msgid ""

"*ssl_handshake_timeout* is (for a TLS connection) the time in seconds to "

"wait for the TLS handshake to complete before aborting the connection. "

"``60.0`` seconds if ``None`` (default)."

msgstr ""

"*ssl_handshake_timeout* 은 (TLS 연결의 경우) 연결을 중단하기 전에 TLS 핸드 셰이크가 완료될 때까지 "

"대기하는 시간(초)입니다. ``None`` (기본값) 이면 ``60.0`` 초가 사용됩니다."

#: ../../library/asyncio-eventloop.rst:500

#: ../../library/asyncio-eventloop.rst:759

#: ../../library/asyncio-eventloop.rst:863

#: ../../library/asyncio-eventloop.rst:952

msgid ""

"*ssl_shutdown_timeout* is the time in seconds to wait for the SSL "

"shutdown to complete before aborting the connection. ``30.0`` seconds if "

"``None`` (default)."

msgstr ""

"*ssl_shutdown_timeout* 은 연결을 중단하기 전에 SSL 종료가 완료될 때까지 대기하는 시간(초)입니다. "

"``None`` (기본값) 이면 ``30.0`` 초가 사용됩니다."

#: ../../library/asyncio-eventloop.rst:504

msgid ""

"*all_errors* determines what exceptions are raised when a connection "

"cannot be created. By default, only a single ``Exception`` is raised: the"

" first exception if there is only one or all errors have same message, or"

" a single ``OSError`` with the error messages combined. When "

"``all_errors`` is ``True``, an ``ExceptionGroup`` will be raised "

"containing all exceptions (even if there is only one)."

msgstr ""

#: ../../library/asyncio-eventloop.rst:514

#: ../../library/asyncio-eventloop.rst:771

msgid "Added support for SSL/TLS in :class:`ProactorEventLoop`."

msgstr ":class:`ProactorEventLoop`\\에 SSL/TLS에 대한 지원이 추가되었습니다."

#: ../../library/asyncio-eventloop.rst:518

msgid ""

"The socket option :ref:`socket.TCP_NODELAY <socket-unix-constants>` is "

"set by default for all TCP connections."

msgstr ""

"소켓 옵션 :ref:`socket.TCP_NODELAY <socket-unix-constants>`\\는 기본적으로 모든 TCP "

"연결에 대해 설정됩니다."

#: ../../library/asyncio-eventloop.rst:523

#: ../../library/asyncio-eventloop.rst:873

msgid "Added the *ssl_handshake_timeout* parameter."

msgstr "*ssl_handshake_timeout* 매개 변수를 추가했습니다."

#: ../../library/asyncio-eventloop.rst:527

msgid "Added the *happy_eyeballs_delay* and *interleave* parameters."

msgstr "*happy_eyeballs_delay*\\와 *interleave* 매개 변수가 추가되었습니다."

#: ../../library/asyncio-eventloop.rst:529

msgid ""

"Happy Eyeballs Algorithm: Success with Dual-Stack Hosts. When a server's "

"IPv4 path and protocol are working, but the server's IPv6 path and "

"protocol are not working, a dual-stack client application experiences "

"significant connection delay compared to an IPv4-only client. This is "

"undesirable because it causes the dual-stack client to have a worse user "

"experience. This document specifies requirements for algorithms that "

"reduce this user-visible delay and provides an algorithm."

msgstr ""

"Happy Eyeballs 알고리즘: 듀얼 스택 호스트의 성공. 서버의 IPv4 경로와 프로토콜이 작동하지만, 서버의 IPv6 "

"경로와 프로토콜은 작동하지 않을 때, 이중 스택 클라이언트 응용 프로그램은 IPv4 전용 클라이언트와 비교하여 상당한 연결 지연이 "

"발생합니다. 이중 스택 클라이언트의 사용자 환경이 더 나빠지기 때문에 바람직하지 않습니다. 이 문서는 이런 사용자가 볼 수 있는 "

"지연을 줄이고 알고리즘에 대한 요구 사항을 지정하고 알고리즘을 제공합니다."

#: ../../library/asyncio-eventloop.rst:538

msgid "For more information: https://datatracker.ietf.org/doc/html/rfc6555"

msgstr "자세한 정보: https://datatracker.ietf.org/doc/html/rfc6555"

#: ../../library/asyncio-eventloop.rst:542

#: ../../library/asyncio-eventloop.rst:668

#: ../../library/asyncio-eventloop.rst:785

#: ../../library/asyncio-eventloop.rst:825

#: ../../library/asyncio-eventloop.rst:877

#: ../../library/asyncio-eventloop.rst:960

msgid "Added the *ssl_shutdown_timeout* parameter."

msgstr "*ssl_shutdown_timeout* 매개 변수를 추가했습니다."

#: ../../library/asyncio-eventloop.rst:544

msgid "*all_errors* was added."

msgstr ""

#: ../../library/asyncio-eventloop.rst:549

msgid ""

"The :func:`open_connection` function is a high-level alternative API. It"

" returns a pair of (:class:`StreamReader`, :class:`StreamWriter`) that "

"can be used directly in async/await code."

msgstr ""

":func:`open_connection` 함수는 고수준 대안 API입니다. async/await 코드에서 직접 사용할 수 있는 "

"(:class:`StreamReader`, :class:`StreamWriter`) 쌍을 반환합니다."

#: ../../library/asyncio-eventloop.rst:560

msgid "Create a datagram connection."

msgstr "데이터 그램 연결을 만듭니다."

#: ../../library/asyncio-eventloop.rst:562

msgid ""

"The socket family can be either :py:const:`~socket.AF_INET`, "

":py:const:`~socket.AF_INET6`, or :py:const:`~socket.AF_UNIX`, depending "

"on *host* (or the *family* argument, if provided)."

msgstr ""

"소켓 패밀리는 *host*\\(또는 주어지면 *family*)에 따라 :py:const:`~socket.AF_INET`, "

":py:const:`~socket.AF_INET6` 또는 :py:const:`~socket.AF_UNIX`\\일 수 있습니다."

#: ../../library/asyncio-eventloop.rst:566

msgid "The socket type will be :py:const:`~socket.SOCK_DGRAM`."

msgstr "소켓 유형은 :py:const:`~socket.SOCK_DGRAM`\\이 됩니다."

#: ../../library/asyncio-eventloop.rst:568

#: ../../library/asyncio-eventloop.rst:695

#: ../../library/asyncio-eventloop.rst:844

msgid ""

"*protocol_factory* must be a callable returning a :ref:`protocol "

"<asyncio-protocol>` implementation."

msgstr ""

"*protocol_factory* 는 반드시 :ref:`프로토콜 <asyncio-protocol>` 구현을 반환하는 콜러블이어야 "

"합니다."

#: ../../library/asyncio-eventloop.rst:571

#: ../../library/asyncio-eventloop.rst:650

msgid "A tuple of ``(transport, protocol)`` is returned on success."

msgstr "성공하면 ``(transport, protocol)`` 튜플이 반환됩니다."

#: ../../library/asyncio-eventloop.rst:575

msgid ""

"*local_addr*, if given, is a ``(local_host, local_port)`` tuple used to "

"bind the socket locally. The *local_host* and *local_port* are looked up"

" using :meth:`getaddrinfo`."

msgstr ""

"*local_addr* 이 주어지면, 소켓을 로컬에 바인드 하는 데 사용되는 ``(local_host, local_port)`` "

"튜플입니다. *local_host* 와 *local_port* 는 :meth:`getaddrinfo`\\를 사용하여 조회됩니다."

#: ../../library/asyncio-eventloop.rst:579

msgid ""

"*remote_addr*, if given, is a ``(remote_host, remote_port)`` tuple used "

"to connect the socket to a remote address. The *remote_host* and "

"*remote_port* are looked up using :meth:`getaddrinfo`."

msgstr ""

"*remote_addr* 이 주어지면, 소켓을 원격 주소에 연결하는 데 사용되는 ``(remote_host, "

"remote_port)`` 튜플입니다. *remote_host* 와 *remote_port* 는 "

":meth:`getaddrinfo`\\를 사용하여 조회됩니다."

#: ../../library/asyncio-eventloop.rst:583

msgid ""

"*family*, *proto*, *flags* are the optional address family, protocol and "

"flags to be passed through to :meth:`getaddrinfo` for *host* resolution. "

"If given, these should all be integers from the corresponding "

":mod:`socket` module constants."

msgstr ""

"*family*, *proto*, *flags* 는 *host* 결정을 위해 :meth:`getaddrinfo` 에 전달할 선택적 "

"주소 패밀리, 프로토콜, 플래그입니다. 주어지면, 이것들은 모두 해당하는 :mod:`socket` 모듈 상수에 대응하는 정수여야 "

"합니다."

#: ../../library/asyncio-eventloop.rst:588

msgid ""

"*reuse_port* tells the kernel to allow this endpoint to be bound to the "

"same port as other existing endpoints are bound to, so long as they all "

"set this flag when being created. This option is not supported on Windows"

" and some Unixes. If the :ref:`socket.SO_REUSEPORT <socket-unix-"

"constants>` constant is not defined then this capability is unsupported."

msgstr ""

"*reuse_port* 는 모두 만들 때 이 플래그를 설정하는 한, 이 말단이 다른 기존 말단이 바인드 된 것과 같은 포트에 바인드"

" 되도록 허용하도록 커널에 알려줍니다. 이 옵션은 윈도우나 일부 유닉스에서는 지원되지 않습니다. "

":ref:`socket.SO_REUSEPORT <socket-unix-constants>` 상수가 정의되어 있지 않으면, 이 기능은"

" 지원되지 않는 것입니다."

#: ../../library/asyncio-eventloop.rst:594

msgid ""

"*allow_broadcast* tells the kernel to allow this endpoint to send "

"messages to the broadcast address."

msgstr "*allow_broadcast* 는 이 말단이 브로드캐스트 주소로 메시지를 보낼 수 있도록 커널에 알립니다."

#: ../../library/asyncio-eventloop.rst:597

msgid ""

"*sock* can optionally be specified in order to use a preexisting, already"

" connected, :class:`socket.socket` object to be used by the transport. If"

" specified, *local_addr* and *remote_addr* should be omitted (must be "

":const:`None`)."

msgstr ""

"*sock* 은 트랜스포트가 사용할 소켓 객체로, 기존의 이미 연결된 :class:`socket.socket` 객체를 사용하기 위해"

" 선택적으로 지정할 수 있습니다. 지정되면 *local_addr* 과 *remote_addr* 를 생략해야 합니다 (반드시 "

":const:`None` 이어야 합니다)."

#: ../../library/asyncio-eventloop.rst:608

msgid ""

"See :ref:`UDP echo client protocol <asyncio-udp-echo-client-protocol>` "

"and :ref:`UDP echo server protocol <asyncio-udp-echo-server-protocol>` "

"examples."

msgstr ""

":ref:`UDP 메아리 클라이언트 프로토콜 <asyncio-udp-echo-client-protocol>` 과 :ref:`UDP "

"메아리 서버 프로토콜 <asyncio-udp-echo-server-protocol>` 예제를 참고하세요."

#: ../../library/asyncio-eventloop.rst:611

msgid ""