# 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"

#: ../../tutorial/stdlib2.rst:5
msgid "Brief Tour of the Standard Library --- Part II"
msgstr "표준 라이브러리 둘러보기 --- 2부"

#: ../../tutorial/stdlib2.rst:7
msgid ""
"This second tour covers more advanced modules that support professional "
"programming needs.  These modules rarely occur in small scripts."
msgstr ""
"이 두 번째 둘러보기는 전문 프로그래밍 요구 사항을 지원하는 고급 모듈을 다루고 있습니다. 이러한 모듈은 작은 스크립트에서는 거의 "
"사용되지 않습니다."

#: ../../tutorial/stdlib2.rst:14
msgid "Output Formatting"
msgstr "출력 포매팅"

#: ../../tutorial/stdlib2.rst:16
msgid ""
"The :mod:`reprlib` module provides a version of :func:`repr` customized "
"for abbreviated displays of large or deeply nested containers::"
msgstr ""
":mod:`reprlib` 모듈은 크거나 깊게 중첩된 컨테이너의 축약 된 디스플레이를 위해 커스터마이즈된 :func:`repr` 의"
" 버전을 제공합니다::"

#: ../../tutorial/stdlib2.rst:19
#, python-brace-format
msgid ""
">>> import reprlib\n"
">>> reprlib.repr(set('supercalifragilisticexpialidocious'))\n"
"\"{'a', 'c', 'd', 'e', 'f', 'g', ...}\""
msgstr ""
">>> import reprlib\n"
">>> reprlib.repr(set('supercalifragilisticexpialidocious'))\n"
"\"{'a', 'c', 'd', 'e', 'f', 'g', ...}\""

#: ../../tutorial/stdlib2.rst:23
msgid ""
"The :mod:`pprint` module offers more sophisticated control over printing "
"both built-in and user defined objects in a way that is readable by the "
"interpreter. When the result is longer than one line, the \"pretty "
"printer\" adds line breaks and indentation to more clearly reveal data "
"structure::"
msgstr ""
":mod:`pprint` 모듈은 인터프리터가 읽을 수 있는 방식으로 내장 객체나 사용자 정의 객체를 인쇄하는 것을 보다 정교하게 "
"제어할 수 있게 합니다. 결과가 한 줄보다 길면 \"예쁜 프린터\"가 줄 바꿈과 들여쓰기를 추가하여 데이터 구조를 보다 명확하게 "
"나타냅니다::"

#: ../../tutorial/stdlib2.rst:28
msgid ""
">>> import pprint\n"
">>> t = [[[['black', 'cyan'], 'white', ['green', 'red']], [['magenta',\n"
"...     'yellow'], 'blue']]]\n"
"...\n"
">>> pprint.pprint(t, width=30)\n"
"[[[['black', 'cyan'],\n"
"   'white',\n"
"   ['green', 'red']],\n"
"  [['magenta', 'yellow'],\n"
"   'blue']]]"
msgstr ""
">>> import pprint\n"
">>> t = [[[['black', 'cyan'], 'white', ['green', 'red']], [['magenta',\n"
"...     'yellow'], 'blue']]]\n"
"...\n"
">>> pprint.pprint(t, width=30)\n"
"[[[['black', 'cyan'],\n"
"   'white',\n"
"   ['green', 'red']],\n"
"  [['magenta', 'yellow'],\n"
"   'blue']]]"

#: ../../tutorial/stdlib2.rst:39
msgid ""
"The :mod:`textwrap` module formats paragraphs of text to fit a given "
"screen width::"
msgstr ":mod:`textwrap` 모듈은 텍스트의 문단을 주어진 화면 너비에 맞게 포맷합니다::"

#: ../../tutorial/stdlib2.rst:42
msgid ""
">>> import textwrap\n"
">>> doc = \"\"\"The wrap() method is just like fill() except that it "
"returns\n"
"... a list of strings instead of one big string with newlines to separate"
"\n"
"... the wrapped lines.\"\"\"\n"
"...\n"
">>> print(textwrap.fill(doc, width=40))\n"
"The wrap() method is just like fill()\n"
"except that it returns a list of strings\n"
"instead of one big string with newlines\n"
"to separate the wrapped lines."
msgstr ""
">>> import textwrap\n"
">>> doc = \"\"\"The wrap() method is just like fill() except that it "
"returns\n"
"... a list of strings instead of one big string with newlines to separate"
"\n"
"... the wrapped lines.\"\"\"\n"
"...\n"
">>> print(textwrap.fill(doc, width=40))\n"
"The wrap() method is just like fill()\n"
"except that it returns a list of strings\n"
"instead of one big string with newlines\n"
"to separate the wrapped lines."

#: ../../tutorial/stdlib2.rst:53
msgid ""
"The :mod:`locale` module accesses a database of culture specific data "
"formats. The grouping attribute of locale's format function provides a "
"direct way of formatting numbers with group separators::"
msgstr ""
":mod:`locale` 모듈은 문화권 특정 데이터 포맷의 데이터베이스에 액세스합니다. locale의 format 함수의 "
"grouping 어트리뷰트는 그룹 구분 기호로 숫자를 포매팅하는 직접적인 방법을 제공합니다::"

#: ../../tutorial/stdlib2.rst:57
#, python-format
msgid ""
">>> import locale\n"
">>> locale.setlocale(locale.LC_ALL, 'English_United States.1252')\n"
"'English_United States.1252'\n"
">>> conv = locale.localeconv()          # get a mapping of conventions\n"
">>> x = 1234567.8\n"
">>> locale.format_string(\"%d\", x, grouping=True)\n"
"'1,234,567'\n"
">>> locale.format_string(\"%s%.*f\", (conv['currency_symbol'],\n"
"...                      conv['frac_digits'], x), grouping=True)\n"
"'$1,234,567.80'"
msgstr ""
">>> import locale\n"
">>> locale.setlocale(locale.LC_ALL, 'English_United States.1252')\n"
"'English_United States.1252'\n"
">>> conv = locale.localeconv()          # 관례의 매핑을 얻습니다\n"
">>> x = 1234567.8\n"
">>> locale.format_string(\"%d\", x, grouping=True)\n"
"'1,234,567'\n"
">>> locale.format_string(\"%s%.*f\", (conv['currency_symbol'],\n"
"...                      conv['frac_digits'], x), grouping=True)\n"
"'$1,234,567.80'"

#: ../../tutorial/stdlib2.rst:72
msgid "Templating"
msgstr "템플릿"

#: ../../tutorial/stdlib2.rst:74
msgid ""
"The :mod:`string` module includes a versatile :class:`~string.Template` "
"class with a simplified syntax suitable for editing by end-users.  This "
"allows users to customize their applications without having to alter the "
"application."
msgstr ""
":mod:`string` 모듈은 다재다능한 :class:`~string.Template` 클래스를 포함하고 있는데, 최종 사용자가 "
"편집하기에 적절한 단순한 문법을 갖고 있습니다. 따라서 사용자는 응용 프로그램을 변경하지 않고도 응용 프로그램을 커스터마이즈할 수 "
"있습니다."

#: ../../tutorial/stdlib2.rst:78
msgid ""
"The format uses placeholder names formed by ``$`` with valid Python "
"identifiers (alphanumeric characters and underscores).  Surrounding the "
"placeholder with braces allows it to be followed by more alphanumeric "
"letters with no intervening spaces.  Writing ``$$`` creates a single "
"escaped ``$``::"
msgstr ""
"형식은 ``$`` 와 유효한 파이썬 식별자 (영숫자와 밑줄)로 만들어진 자리표시자 이름을 사용합니다. 중괄호를 사용하여 자리표시자를"
" 둘러싸면 공백없이 영숫자가 뒤따르도록 할 수 있습니다. ``$$`` 을 쓰면 하나의 이스케이프 된 ``$`` 를 만듭니다::"

#: ../../tutorial/stdlib2.rst:83
#, python-brace-format
msgid ""
">>> from string import Template\n"
">>> t = Template('${village}folk send $$10 to $cause.')\n"
">>> t.substitute(village='Nottingham', cause='the ditch fund')\n"
"'Nottinghamfolk send $10 to the ditch fund.'"
msgstr ""
">>> from string import Template\n"
">>> t = Template('${village}folk send $$10 to $cause.')\n"
">>> t.substitute(village='Nottingham', cause='the ditch fund')\n"
"'Nottinghamfolk send $10 to the ditch fund.'"

#: ../../tutorial/stdlib2.rst:88
msgid ""
"The :meth:`~string.Template.substitute` method raises a :exc:`KeyError` "
"when a placeholder is not supplied in a dictionary or a keyword argument."
"  For mail-merge style applications, user supplied data may be incomplete"
" and the :meth:`~string.Template.safe_substitute` method may be more "
"appropriate --- it will leave placeholders unchanged if data is missing::"
msgstr ""
":meth:`~string.Template.substitute` 메서드는 자리표시자가 딕셔너리나 키워드 인자로 제공되지 않을 때 "
":exc:`KeyError` 를 일으킵니다. 메일 병합 스타일 응용 프로그램의 경우 사용자가 제공한 데이터가 불완전할 수 있으며 "
":meth:`~string.Template.safe_substitute` 메서드가 더 적절할 수 있습니다. 데이터가 누락 된 경우 "
"자리표시자를 변경하지 않습니다::"

#: ../../tutorial/stdlib2.rst:94
msgid ""
">>> t = Template('Return the $item to $owner.')\n"
">>> d = dict(item='unladen swallow')\n"
">>> t.substitute(d)\n"
"Traceback (most recent call last):\n"
"  ...\n"
"KeyError: 'owner'\n"
">>> t.safe_substitute(d)\n"
"'Return the unladen swallow to $owner.'"
msgstr ""
">>> t = Template('Return the $item to $owner.')\n"
">>> d = dict(item='unladen swallow')\n"
">>> t.substitute(d)\n"
"Traceback (most recent call last):\n"
"  ...\n"
"KeyError: 'owner'\n"
">>> t.safe_substitute(d)\n"
"'Return the unladen swallow to $owner.'"

#: ../../tutorial/stdlib2.rst:103
msgid ""
"Template subclasses can specify a custom delimiter.  For example, a batch"
" renaming utility for a photo browser may elect to use percent signs for "
"placeholders such as the current date, image sequence number, or file "
"format::"
msgstr ""
"Template 서브 클래스는 사용자 정의 구분자를 지정할 수 있습니다. 예를 들어 사진 브라우저를 위한 일괄 이름 바꾸기 "
"유틸리티는 현재 날짜, 이미지 시퀀스 번호 또는 파일 형식과 같은 자리표시자에 백분율 기호를 사용하도록 선택할 수 있습니다::"

#: ../../tutorial/stdlib2.rst:107
#, python-brace-format, python-format
msgid ""
">>> import time, os.path\n"
">>> photofiles = ['img_1074.jpg', 'img_1076.jpg', 'img_1077.jpg']\n"
">>> class BatchRename(Template):\n"
"...     delimiter = '%'\n"
"...\n"
">>> fmt = input('Enter rename style (%d-date %n-seqnum %f-format):  ')\n"
"Enter rename style (%d-date %n-seqnum %f-format):  Ashley_%n%f\n"
"\n"
">>> t = BatchRename(fmt)\n"
">>> date = time.strftime('%d%b%y')\n"
">>> for i, filename in enumerate(photofiles):\n"
"...     base, ext = os.path.splitext(filename)\n"
"...     newname = t.substitute(d=date, n=i, f=ext)\n"
"...     print('{0} --> {1}'.format(filename, newname))\n"
"\n"
"img_1074.jpg --> Ashley_0.jpg\n"
"img_1076.jpg --> Ashley_1.jpg\n"
"img_1077.jpg --> Ashley_2.jpg"
msgstr ""
">>> import time, os.path\n"
">>> photofiles = ['img_1074.jpg', 'img_1076.jpg', 'img_1077.jpg']\n"
">>> class BatchRename(Template):\n"
"...     delimiter = '%'\n"
"...\n"
">>> fmt = input('Enter rename style (%d-date %n-seqnum %f-format):  ')\n"
"Enter rename style (%d-date %n-seqnum %f-format):  Ashley_%n%f\n"
"\n"
">>> t = BatchRename(fmt)\n"
">>> date = time.strftime('%d%b%y')\n"
">>> for i, filename in enumerate(photofiles):\n"
"...     base, ext = os.path.splitext(filename)\n"
"...     newname = t.substitute(d=date, n=i, f=ext)\n"
"...     print('{0} --> {1}'.format(filename, newname))\n"
"\n"
"img_1074.jpg --> Ashley_0.jpg\n"
"img_1076.jpg --> Ashley_1.jpg\n"
"img_1077.jpg --> Ashley_2.jpg"

#: ../../tutorial/stdlib2.rst:126
msgid ""
"Another application for templating is separating program logic from the "
"details of multiple output formats.  This makes it possible to substitute"
" custom templates for XML files, plain text reports, and HTML web "
"reports."
msgstr ""
"템플릿의 또 다른 응용은 다중 출력 형식의 세부 사항에서 프로그램 논리를 분리하는 것입니다. 이렇게 하면 XML 파일, 일반 텍스트"
" 보고서 및 HTML 웹 보고서에 대한 커스텀 템플릿을 치환할 수 있습니다."

#: ../../tutorial/stdlib2.rst:134
msgid "Working with Binary Data Record Layouts"
msgstr "바이너리 데이터 레코드 배치 작업"

#: ../../tutorial/stdlib2.rst:136
msgid ""
"The :mod:`struct` module provides :func:`~struct.pack` and "
":func:`~struct.unpack` functions for working with variable length binary "
"record formats.  The following example shows how to loop through header "
"information in a ZIP file without using the :mod:`zipfile` module.  Pack "
"codes ``\"H\"`` and ``\"I\"`` represent two and four byte unsigned "
"numbers respectively.  The ``\"<\"`` indicates that they are standard "
"size and in little-endian byte order::"
msgstr ""
":mod:`struct` 모듈은 가변 길이 바이너리 레코드 형식으로 작업하기 위한 :func:`~struct.pack` 과 "
":func:`~struct.unpack` 함수를 제공합니다. 다음 예제는 :mod:`zipfile` 모듈을 사용하지 않고 ZIP "
"파일의 헤더 정보를 루핑하는 법을 보여줍니다. 팩 코드 ``\"H\"`` 와 ``\"I\"`` 는 각각 2바이트와 4바이트의 부호 "
"없는 숫자를 나타냅니다. ``\"<\"`` 는 표준 크기이면서 리틀 엔디안 바이트 순서를 가짐을 나타냅니다::"

#: ../../tutorial/stdlib2.rst:144
msgid ""
"import struct\n"
"\n"
"with open('myfile.zip', 'rb') as f:\n"
"    data = f.read()\n"
"\n"
"start = 0\n"
"for i in range(3):                      # show the first 3 file headers\n"
"    start += 14\n"
"    fields = struct.unpack('<IIIHH', data[start:start+16])\n"
"    crc32, comp_size, uncomp_size, filenamesize, extra_size = fields\n"
"\n"
"    start += 16\n"
"    filename = data[start:start+filenamesize]\n"
"    start += filenamesize\n"
"    extra = data[start:start+extra_size]\n"
"    print(filename, hex(crc32), comp_size, uncomp_size)\n"
"\n"
"    start += extra_size + comp_size     # skip to the next header"
msgstr ""
"import struct\n"
"\n"
"with open('myfile.zip', 'rb') as f:\n"
"    data = f.read()\n"
"\n"
"start = 0\n"
"for i in range(3):                      # 처음 3개의 파일 헤더를 보여줍니다\n"
"    start += 14\n"
"    fields = struct.unpack('<IIIHH', data[start:start+16])\n"
"    crc32, comp_size, uncomp_size, filenamesize, extra_size = fields\n"
"\n"
"    start += 16\n"
"    filename = data[start:start+filenamesize]\n"
"    start += filenamesize\n"
"    extra = data[start:start+extra_size]\n"
"    print(filename, hex(crc32), comp_size, uncomp_size)\n"
"\n"
"    start += extra_size + comp_size     # 다음 헤더로 건너뜁니다"

#: ../../tutorial/stdlib2.rst:167
msgid "Multi-threading"
msgstr "다중 스레딩"

#: ../../tutorial/stdlib2.rst:169
msgid ""
"Threading is a technique for decoupling tasks which are not sequentially "
"dependent.  Threads can be used to improve the responsiveness of "
"applications that accept user input while other tasks run in the "
"background.  A related use case is running I/O in parallel with "
"computations in another thread."
msgstr ""
"스레딩은 차례로 종속되지 않는 작업을 분리하는 기술입니다. 스레드는 다른 작업이 백그라운드에서 실행되는 동안 사용자 입력을 받는 "
"응용 프로그램의 응답을 향상하는 데 사용할 수 있습니다. 관련된 사용 사례는 다른 스레드의 계산과 병렬로 I/O를 실행하는 "
"경우입니다."

#: ../../tutorial/stdlib2.rst:174
msgid ""
"The following code shows how the high level :mod:`threading` module can "
"run tasks in background while the main program continues to run::"
msgstr ""
"다음 코드는 메인 프로그램이 계속 실행되는 동안 고수준 :mod:`threading` 모듈이 백그라운드에서 작업을 어떻게 수행할 수"
" 있는지 보여줍니다::"

#: ../../tutorial/stdlib2.rst:177
msgid ""
"import threading, zipfile\n"
"\n"
"class AsyncZip(threading.Thread):\n"
"    def __init__(self, infile, outfile):\n"
"        threading.Thread.__init__(self)\n"
"        self.infile = infile\n"
"        self.outfile = outfile\n"
"\n"
"    def run(self):\n"
"        f = zipfile.ZipFile(self.outfile, 'w', zipfile.ZIP_DEFLATED)\n"
"        f.write(self.infile)\n"
"        f.close()\n"
"        print('Finished background zip of:', self.infile)\n"
"\n"
"background = AsyncZip('mydata.txt', 'myarchive.zip')\n"
"background.start()\n"
"print('The main program continues to run in foreground.')\n"
"\n"
"background.join()    # Wait for the background task to finish\n"
"print('Main program waited until background was done.')"
msgstr ""
"import threading, zipfile\n"
"\n"
"class AsyncZip(threading.Thread):\n"
"    def __init__(self, infile, outfile):\n"
"        threading.Thread.__init__(self)\n"
"        self.infile = infile\n"
"        self.outfile = outfile\n"
"\n"
"    def run(self):\n"
"        f = zipfile.ZipFile(self.outfile, 'w', zipfile.ZIP_DEFLATED)\n"
"        f.write(self.infile)\n"
"        f.close()\n"
"        print('Finished background zip of:', self.infile)\n"
"\n"
"background = AsyncZip('mydata.txt', 'myarchive.zip')\n"
"background.start()\n"
"print('The main program continues to run in foreground.')\n"
"\n"
"background.join()    # 백그라운드 작업이 끝날 때까지 기다립니다\n"
"print('Main program waited until background was done.')"

#: ../../tutorial/stdlib2.rst:198
msgid ""
"The principal challenge of multi-threaded applications is coordinating "
"threads that share data or other resources.  To that end, the threading "
"module provides a number of synchronization primitives including locks, "
"events, condition variables, and semaphores."
msgstr ""
"다중 스레드 응용 프로그램의 가장 큰 문제점은 데이터 또는 다른 자원을 공유하는 스레드를 조정하는 것입니다. 이를 위해 "
"threading 모듈은 록, 이벤트, 조건 변수 및 세마포어를 비롯한 많은 수의 동기화 기본 요소를 제공합니다."

#: ../../tutorial/stdlib2.rst:203
msgid ""
"While those tools are powerful, minor design errors can result in "
"problems that are difficult to reproduce.  So, the preferred approach to "
"task coordination is to concentrate all access to a resource in a single "
"thread and then use the :mod:`queue` module to feed that thread with "
"requests from other threads. Applications using :class:`~queue.Queue` "
"objects for inter-thread communication and coordination are easier to "
"design, more readable, and more reliable."
msgstr ""
"이러한 도구는 강력하지만, 사소한 설계 오류로 인해 재현하기 어려운 문제가 발생할 수 있습니다. 따라서, 작업 조정에 대한 선호되는"
" 접근 방식은 자원에 대한 모든 액세스를 단일 스레드에 집중시킨 다음 :mod:`queue` 모듈을 사용하여 해당 스레드에 다른 "
"스레드의 요청을 제공하는 것입니다. 스레드 간 통신 및 조정을 위한 :class:`~queue.Queue` 객체를 사용하는 응용 "
"프로그램은 설계하기 쉽고, 읽기 쉽고, 신뢰성이 높습니다."

#: ../../tutorial/stdlib2.rst:214
msgid "Logging"
msgstr "로깅"

#: ../../tutorial/stdlib2.rst:216
msgid ""
"The :mod:`logging` module offers a full featured and flexible logging "
"system. At its simplest, log messages are sent to a file or to "
"``sys.stderr``::"
msgstr ""
":mod:`logging` 모듈은 완전한 기능을 갖춘 유연한 로깅 시스템을 제공합니다. 가장 단순한 경우, 로그 메시지는 파일이나 "
"``sys.stderr`` 로 보내집니다::"

#: ../../tutorial/stdlib2.rst:219
#, python-format
msgid ""
"import logging\n"
"logging.debug('Debugging information')\n"
"logging.info('Informational message')\n"
"logging.warning('Warning:config file %s not found', 'server.conf')\n"
"logging.error('Error occurred')\n"
"logging.critical('Critical error -- shutting down')"
msgstr ""
"import logging\n"
"logging.debug('Debugging information')\n"
"logging.info('Informational message')\n"
"logging.warning('Warning:config file %s not found', 'server.conf')\n"
"logging.error('Error occurred')\n"
"logging.critical('Critical error -- shutting down')"

#: ../../tutorial/stdlib2.rst:226
msgid "This produces the following output:"
msgstr "그러면 다음과 같은 결과가 출력됩니다:"

#: ../../tutorial/stdlib2.rst:228
msgid ""
"WARNING:root:Warning:config file server.conf not found\n"
"ERROR:root:Error occurred\n"
"CRITICAL:root:Critical error -- shutting down"
msgstr ""
"WARNING:root:Warning:config file server.conf not found\n"
"ERROR:root:Error occurred\n"
"CRITICAL:root:Critical error -- shutting down"

#: ../../tutorial/stdlib2.rst:234
msgid ""
"By default, informational and debugging messages are suppressed and the "
"output is sent to standard error.  Other output options include routing "
"messages through email, datagrams, sockets, or to an HTTP Server.  New "
"filters can select different routing based on message priority: "
":const:`~logging.DEBUG`, :const:`~logging.INFO`, "
":const:`~logging.WARNING`, :const:`~logging.ERROR`, and "
":const:`~logging.CRITICAL`."
msgstr ""
"기본적으로 정보 및 디버깅 메시지는 표시되지 않고 출력은 표준 에러로 보내집니다. 다른 출력 옵션에는 전자 메일, 데이터 그램, "
"소켓 또는 HTTP 서버를 통한 메시지 라우팅이 포함됩니다. 새로운 필터는 메시지 우선순위에 따라 다른 라우팅을 선택할 수 "
"있습니다: :const:`~logging.DEBUG`, :const:`~logging.INFO`, "
":const:`~logging.WARNING`, :const:`~logging.ERROR` , 그리고 "
":const:`~logging.CRITICAL`."

#: ../../tutorial/stdlib2.rst:241
msgid ""
"The logging system can be configured directly from Python or can be "
"loaded from a user editable configuration file for customized logging "
"without altering the application."
msgstr ""
"로깅 시스템은 파이썬에서 직접 구성하거나, 응용 프로그램을 변경하지 않고 사용자 정의 로깅을 위해 사용자가 편집할 수 있는 설정 "
"파일에서 로드 할 수 있습니다."

#: ../../tutorial/stdlib2.rst:249
msgid "Weak References"
msgstr "약한 참조"

#: ../../tutorial/stdlib2.rst:251
msgid ""
"Python does automatic memory management (reference counting for most "
"objects and :term:`garbage collection` to eliminate cycles).  The memory "
"is freed shortly after the last reference to it has been eliminated."
msgstr ""
"파이썬은 자동 메모리 관리 (대부분 객체에 대한 참조 횟수 추적 및 순환을 제거하기 위한 :term:`가비지 수거 <garbage "
"collection>`)를 수행합니다. 메모리는 마지막 참조가 제거된 직후에 해제됩니다."

#: ../../tutorial/stdlib2.rst:255
msgid ""
"This approach works fine for most applications but occasionally there is "
"a need to track objects only as long as they are being used by something "
"else. Unfortunately, just tracking them creates a reference that makes "
"them permanent. The :mod:`weakref` module provides tools for tracking "
"objects without creating a reference.  When the object is no longer "
"needed, it is automatically removed from a weakref table and a callback "
"is triggered for weakref objects.  Typical applications include caching "
"objects that are expensive to create::"
msgstr ""
"이 접근법은 대부분의 응용 프로그램에서 잘 작동하지만, 때로는 다른 것들에 의해 사용되는 동안에만 객체를 추적해야 할 필요가 "
"있습니다. 불행하게도, 단지 그것들을 추적하는 것만으로도 그들을 영구적으로 만드는 참조를 만듭니다. :mod:`weakref` "
"모듈은 참조를 만들지 않고 객체를 추적할 수 있는 도구를 제공합니다. 객체가 더 필요하지 않으면 weakref 테이블에서 객체가 "
"자동으로 제거되고 weakref 객체에 대한 콜백이 트리거됩니다. 일반적인 응용에는 만드는 데 비용이 많이 드는 개체 캐싱이 "
"포함됩니다::"

#: ../../tutorial/stdlib2.rst:263
msgid ""
">>> import weakref, gc\n"
">>> class A:\n"
"...     def __init__(self, value):\n"
"...         self.value = value\n"
"...     def __repr__(self):\n"
"...         return str(self.value)\n"
"...\n"
">>> a = A(10)                   # create a reference\n"
">>> d = weakref.WeakValueDictionary()\n"
">>> d['primary'] = a            # does not create a reference\n"
">>> d['primary']                # fetch the object if it is still alive\n"
"10\n"
">>> del a                       # remove the one reference\n"
">>> gc.collect()                # run garbage collection right away\n"
"0\n"
">>> d['primary']                # entry was automatically removed\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"    d['primary']                # entry was automatically removed\n"
"  File \"C:/python313/lib/weakref.py\", line 46, in __getitem__\n"
"    o = self.data[key]()\n"
"KeyError: 'primary'"
msgstr ""
">>> import weakref, gc\n"
">>> class A:\n"
"...     def __init__(self, value):\n"
"...         self.value = value\n"
"...     def __repr__(self):\n"
"...         return str(self.value)\n"
"...\n"
">>> a = A(10)                   # 참조를 만듭니다\n"
">>> d = weakref.WeakValueDictionary()\n"
">>> d['primary'] = a            # 참조를 만들지 않습니다\n"
">>> d['primary']                # 객체가 아직 살아있다면 가져옵니다\n"
"10\n"
">>> del a                       # 참조 하나를 지웁니다\n"
">>> gc.collect()                # 당장 가비지 수집을 실행합니다\n"
"0\n"
">>> d['primary']                # 항목이 저절로 삭제되었습니다\n"
"Traceback (most recent call last):\n"
"  File \"<stdin>\", line 1, in <module>\n"
"    d['primary']                # 항목이 저절로 삭제되었습니다\n"
"  File \"C:/python313/lib/weakref.py\", line 46, in __getitem__\n"
"    o = self.data[key]()\n"
"KeyError: 'primary'"

#: ../../tutorial/stdlib2.rst:290
msgid "Tools for Working with Lists"
msgstr "리스트 작업 도구"

#: ../../tutorial/stdlib2.rst:292
msgid ""
"Many data structure needs can be met with the built-in list type. "
"However, sometimes there is a need for alternative implementations with "
"different performance trade-offs."
msgstr ""
"내장 리스트 형으로 많은 데이터 구조 요구를 충족시킬 수 있습니다. 그러나 때로는 다른 성능 상충 관계가 있는 대안적 구현이 필요할"
" 수도 있습니다."

#: ../../tutorial/stdlib2.rst:296
msgid ""
"The :mod:`array` module provides an :class:`~array.array` object that is "
"like a list that stores only homogeneous data and stores it more "
"compactly.  The following example shows an array of numbers stored as two"
" byte unsigned binary numbers (typecode ``\"H\"``) rather than the usual "
"16 bytes per entry for regular lists of Python int objects::"
msgstr ""
":mod:`array` 모듈은 :class:`~array.array` 객체를 제공합니다. 이 객체는 등질적인 데이터만을 저장하고 "
"보다 조밀하게 저장하는 리스트와 같습니다. 다음 예제는 파이썬 int 객체의 일반 리스트의 경우처럼 항목당 16바이트를 사용하는 "
"대신에, 2바이트의 부호 없는 이진 숫자 (형 코드 ``\"H\"``)로 저장된 숫자 배열을 보여줍니다::"

#: ../../tutorial/stdlib2.rst:302
msgid ""
">>> from array import array\n"
">>> a = array('H', [4000, 10, 700, 22222])\n"
">>> sum(a)\n"
"26932\n"
">>> a[1:3]\n"
"array('H', [10, 700])"
msgstr ""
">>> from array import array\n"
">>> a = array('H', [4000, 10, 700, 22222])\n"
">>> sum(a)\n"
"26932\n"
">>> a[1:3]\n"
"array('H', [10, 700])"

#: ../../tutorial/stdlib2.rst:309
msgid ""
"The :mod:`collections` module provides a :class:`~collections.deque` "
"object that is like a list with faster appends and pops from the left "
"side but slower lookups in the middle. These objects are well suited for "
"implementing queues and breadth first tree searches::"
msgstr ""
":mod:`collections` 모듈은 :class:`~collections.deque` 객체를 제공합니다. 이 객체는 왼쪽에서 "
"더 빠르게 추가/팝하지만 중간에서의 조회는 더 느려진 리스트와 같습니다. 이 객체는 대기열 및 넓이 우선 트리 검색을 구현하는 데 "
"적합합니다::"

#: ../../tutorial/stdlib2.rst:314
msgid ""
">>> from collections import deque\n"
">>> d = deque([\"task1\", \"task2\", \"task3\"])\n"
">>> d.append(\"task4\")\n"
">>> print(\"Handling\", d.popleft())\n"
"Handling task1"
msgstr ""
">>> from collections import deque\n"
">>> d = deque([\"task1\", \"task2\", \"task3\"])\n"
">>> d.append(\"task4\")\n"
">>> print(\"Handling\", d.popleft())\n"
"Handling task1"

#: ../../tutorial/stdlib2.rst:322
msgid ""
"unsearched = deque([starting_node])\n"
"def breadth_first_search(unsearched):\n"
"    node = unsearched.popleft()\n"
"    for m in gen_moves(node):\n"
"        if is_goal(m):\n"
"            return m\n"
"        unsearched.append(m)"
msgstr ""
"unsearched = deque([starting_node])\n"
"def breadth_first_search(unsearched):\n"
"    node = unsearched.popleft()\n"
"    for m in gen_moves(node):\n"
"        if is_goal(m):\n"
"            return m\n"
"        unsearched.append(m)"

#: ../../tutorial/stdlib2.rst:330
msgid ""
"In addition to alternative list implementations, the library also offers "
"other tools such as the :mod:`bisect` module with functions for "
"manipulating sorted lists::"
msgstr ""
"대안적 리스트 구현 외에도 라이브러리는 정렬된 리스트를 조작하는 함수들이 있는 :mod:`bisect` 모듈과 같은 다른 도구를 "
"제공합니다::"

#: ../../tutorial/stdlib2.rst:334
msgid ""
">>> import bisect\n"
">>> scores = [(100, 'perl'), (200, 'tcl'), (400, 'lua'), (500, 'python')]"
"\n"
">>> bisect.insort(scores, (300, 'ruby'))\n"
">>> scores\n"
"[(100, 'perl'), (200, 'tcl'), (300, 'ruby'), (400, 'lua'), (500, "
"'python')]"
msgstr ""
">>> import bisect\n"
">>> scores = [(100, 'perl'), (200, 'tcl'), (400, 'lua'), (500, 'python')]"
"\n"
">>> bisect.insort(scores, (300, 'ruby'))\n"
">>> scores\n"
"[(100, 'perl'), (200, 'tcl'), (300, 'ruby'), (400, 'lua'), (500, "
"'python')]"

#: ../../tutorial/stdlib2.rst:340
msgid ""
"The :mod:`heapq` module provides functions for implementing heaps based "
"on regular lists.  The lowest valued entry is always kept at position "
"zero.  This is useful for applications which repeatedly access the "
"smallest element but do not want to run a full list sort::"
msgstr ""
":mod:`heapq` 모듈은 일반 리스트를 기반으로 힙을 구현하는 함수를 제공합니다. 가장 값이 작은 항목은 항상 위치 0에 "
"유지됩니다. 이것은 가장 작은 요소에 반복적으로 액세스하지만, 전체 목록 정렬을 실행하지 않으려는 응용에 유용합니다::"

#: ../../tutorial/stdlib2.rst:345
msgid ""
">>> from heapq import heapify, heappop, heappush\n"
">>> data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]\n"
">>> heapify(data)                      # rearrange the list into heap "
"order\n"
">>> heappush(data, -5)                 # add a new entry\n"
">>> [heappop(data) for i in range(3)]  # fetch the three smallest entries"
"\n"
"[-5, 0, 1]"
msgstr ""
">>> from heapq import heapify, heappop, heappush\n"
">>> data = [1, 3, 5, 7, 9, 2, 4, 6, 8, 0]\n"
">>> heapify(data)                      # 리스트를 힙 순서로 재배치합니다\n"
">>> heappush(data, -5)                 # 새 항목을 추가합니다\n"
">>> [heappop(data) for i in range(3)]  # 가장 작은 세 개의 항목을 가져옵니다\n"
"[-5, 0, 1]"

#: ../../tutorial/stdlib2.rst:356
msgid "Decimal Floating-Point Arithmetic"
msgstr "10진 부동 소수점 산술"

#: ../../tutorial/stdlib2.rst:358
msgid ""
"The :mod:`decimal` module offers a :class:`~decimal.Decimal` datatype for"
" decimal floating-point arithmetic.  Compared to the built-in "
":class:`float` implementation of binary floating point, the class is "
"especially helpful for"
msgstr ""
":mod:`decimal` 모듈은 10진 부동 소수점 산술을 위한 :class:`~decimal.Decimal` 데이터형을 "
"제공합니다. 내장 :class:`float` 이진 부동 소수점 구현과 비교할 때, 클래스는 특히 다음과 같은 것들에 유용합니다"

#: ../../tutorial/stdlib2.rst:362
msgid ""
"financial applications and other uses which require exact decimal "
"representation,"
msgstr "정확한 10진수 표현이 필요한 금융 응용 및 기타 용도,"

#: ../../tutorial/stdlib2.rst:364
msgid "control over precision,"
msgstr "정밀도 제어,"

#: ../../tutorial/stdlib2.rst:365
msgid "control over rounding to meet legal or regulatory requirements,"
msgstr "법적 또는 규제 요구 사항을 충족하는 반올림 제어,"

#: ../../tutorial/stdlib2.rst:366
msgid "tracking of significant decimal places, or"
msgstr "유효숫자 추적, 또는"

#: ../../tutorial/stdlib2.rst:367
msgid ""
"applications where the user expects the results to match calculations "
"done by hand."
msgstr "사용자가 결과가 손으로 계산한 것과 일치 할 것으로 기대하는 응용."

#: ../../tutorial/stdlib2.rst:370
msgid ""
"For example, calculating a 5% tax on a 70 cent phone charge gives "
"different results in decimal floating point and binary floating point. "
"The difference becomes significant if the results are rounded to the "
"nearest cent::"
msgstr ""
"예를 들어, 70센트 전화 요금에 대해 5% 세금을 계산하면, 십진 부동 소수점 및 이진 부동 소수점에 다른 결과가 나타납니다. "
"결과를 가장 가까운 센트로 반올림하면 차이가 드러납니다::"

#: ../../tutorial/stdlib2.rst:374
msgid ""
">>> from decimal import *\n"
">>> round(Decimal('0.70') * Decimal('1.05'), 2)\n"
"Decimal('0.74')\n"
">>> round(.70 * 1.05, 2)\n"
"0.73"
msgstr ""
">>> from decimal import *\n"
">>> round(Decimal('0.70') * Decimal('1.05'), 2)\n"
"Decimal('0.74')\n"
">>> round(.70 * 1.05, 2)\n"
"0.73"

#: ../../tutorial/stdlib2.rst:380
msgid ""
"The :class:`~decimal.Decimal` result keeps a trailing zero, automatically"
" inferring four place significance from multiplicands with two place "
"significance.  Decimal reproduces mathematics as done by hand and avoids "
"issues that can arise when binary floating point cannot exactly represent"
" decimal quantities."
msgstr ""
":class:`~decimal.Decimal` 결과는 끝에 붙는 0을 유지하며, 두 개의 유효숫자를 가진 피승수로부터 네 자리의 "
"유효숫자를 자동으로 추론합니다. Decimal은 손으로 한 수학을 재현하고 이진 부동 소수점이 십진수를 정확하게 표현할 수 없을 때"
" 발생할 수 있는 문제를 피합니다."

#: ../../tutorial/stdlib2.rst:386
msgid ""
"Exact representation enables the :class:`~decimal.Decimal` class to "
"perform modulo calculations and equality tests that are unsuitable for "
"binary floating point::"
msgstr ""
"정확한 표현은 :class:`~decimal.Decimal` 클래스가 이진 부동 소수점에 적합하지 않은 모듈로 계산과 동등성 검사를"
" 수행할 수 있도록 합니다::"

#: ../../tutorial/stdlib2.rst:390
msgid ""
">>> Decimal('1.00') % Decimal('.10')\n"
"Decimal('0.00')\n"
">>> 1.00 % 0.10\n"
"0.09999999999999995\n"
"\n"
">>> sum([Decimal('0.1')]*10) == Decimal('1.0')\n"
"True\n"
">>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 == 1.0\n"
"False"
msgstr ""
">>> Decimal('1.00') % Decimal('.10')\n"
"Decimal('0.00')\n"
">>> 1.00 % 0.10\n"
"0.09999999999999995\n"
"\n"
">>> sum([Decimal('0.1')]*10) == Decimal('1.0')\n"
"True\n"
">>> 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 + 0.1 == 1.0\n"
"False"

#: ../../tutorial/stdlib2.rst:400
msgid ""
"The :mod:`decimal` module provides arithmetic with as much precision as "
"needed::"
msgstr ":mod:`decimal` 모듈은 필요한 만큼의 정밀도로 산술을 제공합니다::"

#: ../../tutorial/stdlib2.rst:402
msgid ""
">>> getcontext().prec = 36\n"
">>> Decimal(1) / Decimal(7)\n"
"Decimal('0.142857142857142857142857142857142857')"
msgstr ""
">>> getcontext().prec = 36\n"
">>> Decimal(1) / Decimal(7)\n"
"Decimal('0.142857142857142857142857142857142857')"