# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001 Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# python-doc bot, 2025
# Dmitry Luschan, 2026
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.15\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-08-11 14:51+0000\n"
"PO-Revision-Date: 2025-09-16 00:02+0000\n"
"Last-Translator: Dmitry Luschan, 2026\n"
"Language-Team: Russian (https://app.transifex.com/python-doc/teams/5390/"
"ru/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: ru\n"
"Plural-Forms: nplurals=4; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && "
"n%10<=4 && (n%100<12 || n%100>14) ? 1 : n%10==0 || (n%10>=5 && n%10<=9) || "
"(n%100>=11 && n%100<=14)? 2 : 3);\n"

msgid "Brief tour of the standard library --- part II"
msgstr "Краткий обзор стандартной библиотеки — часть II"

msgid ""
"This second tour covers more advanced modules that support professional "
"programming needs.  These modules rarely occur in small scripts."
msgstr ""
"Вторая часть обзора охватывает более продвинутые модули, ориентированные на "
"профессиональную разработку. Эти модули редко встречаются в небольших "
"скриптах."

msgid "Output formatting"
msgstr "Форматирование вывода"

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`, настроенную "
"для сокращенного отображения больших или глубоко вложенных контейнеров::"

msgid ""
">>> import reprlib\n"
">>> reprlib.repr(set('supercalifragilisticexpialidocious'))\n"
"\"{'a', 'c', 'd', 'e', 'f', 'g', ...}\""
msgstr ""
">>> import reprlib\n"
">>> reprlib.repr(set('суперкалифрагилистикэкспиалидошес'))\n"
"\"{'а', 'г', 'д', 'е', 'и', 'к', ...}\""

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` предлагает более тонкий контроль над печатью встроенных "
"и пользовательских объектов в виде, удобном для чтения интерпретатором. "
"Когда результат занимает более одной строки, «красивый принтер» добавляет "
"переносы строк и отступы, делая структуру данных более наглядной::"

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 = [[[['чёрный', 'бирюзовый'], 'белый', ['зелёный', 'красный']], "
"[['пурпурный',\n"
"...     'жёлтый'], 'синий']]]\n"
"...\n"
">>> pprint.pprint(t, width=30)\n"
"[[[['чёрный', 'бирюзовый'],\n"
"   'белый',\n"
"   ['зелёный', 'красный']],\n"
"  [['пурпурный', 'жёлтый'],\n"
"   'синий']]]"

msgid ""
"The :mod:`textwrap` module formats paragraphs of text to fit a given screen "
"width::"
msgstr ""
"Модуль :mod:`textwrap` форматирует абзацы текста, чтобы они помещались в "
"заданную ширину экрана::"

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 = \"\"\"Метод wrap() работает почти так же, как fill(),\n"
"... только возвращает список строк вместо одной длинной\n"
"... строки с переводами строки между частями текста.\"\"\"\n"
"...\n"
">>> print(textwrap.fill(doc, width=40))\n"
"Метод wrap() работает почти так же, как\n"
"fill(), только возвращает список строк\n"
"вместо одной длинной строки с переводами\n"
"строки между частями текста."

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` предоставляет доступ к базе данных региональных "
"форматов, специфичных для определённой культуры. У функции форматирования "
"этого модуля есть специальный параметр для добавления разделителей групп в "
"числах::"

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, 'ru_RU.UTF-8')\n"
"'ru_RU.UTF-8'\n"
">>> conv = locale.localeconv()          # получить таблицу настроек\n"
">>> x = 1234567.8\n"
">>> locale.format_string(\"%d\", x, grouping=True)\n"
"'1\\xa0234\\xa0567'\n"
">>> locale.format_string(\"%.*f %s\", (conv['frac_digits'],\n"
"...                      x, conv['currency_symbol']), grouping=True)\n"
"'1\\xa0234\\xa0567,80\\xa0₽'"

msgid "Templating"
msgstr "Шаблоны"

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` с упрощенным синтаксисом, подходящим для редактирования конечными "
"пользователями. Это позволяет пользователям настраивать свои приложения, без "
"изменения кода программы."

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 ""
"Формат использует имена заполнителей, начинающихся с ``$`` и представляющие "
"допустимые идентификаторы Python (буквы, цифры и подчёркивания). Окружение "
"заполнителя фигурными скобками позволяет использовать алфавитно-цифровые "
"символы сразу после него, без дополнительных пробелов. Написание ``$$`` "
"создает одиночный экранированный ``$``::"

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}цы шлют $$10 в $cause.')\n"
">>> t.substitute(village='Ноттингем', cause='фонд канавы')\n"
"'Ноттингемцы шлют $10 в фонд канавы.'"

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` может быть более подходящим — он оставит заполнители без "
"изменений, если данные отсутствуют::"

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('$item возвращается $owner.')\n"
">>> d = dict(item='Незагруженная ласточка')\n"
">>> t.substitute(d)\n"
"Traceback (most recent call last):\n"
"  ...\n"
"KeyError: 'owner'\n"
">>> t.safe_substitute(d)\n"
"'Незагруженная ласточка возвращается $owner.'"

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 могут задавать собственный разделитель. Например, утилита "
"пакетного переименования для браузера фотографий может использовать знак "
"процента для заполнителей, таких как текущая дата, номер изображения в "
"последовательности или формат файла::"

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('Введите стиль переименования (%d-дата %n-номер %f-формат):  "
"')\n"
"Введите стиль переименования (%d-дата %n-номер %f-формат):  Эшли_%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 --> Эшли_0.jpg\n"
"img_1076.jpg --> Эшли_1.jpg\n"
"img_1077.jpg --> Эшли_2.jpg"

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-страниц."

msgid "Working with binary data record layouts"
msgstr "Работа с записями бинарных данных"

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` для работы с записями переменной длины в бинарном формате. "
"Следующий пример показывает, как пройтись по заголовкам файлов в ZIP-архиве "
"без использования модуля :mod:`zipfile`. Коды упаковки ``\"H\"`` и ``\"I\"`` "
"обозначают двухбайтовые и четырехбайтовые беззнаковые числа соответственно. "
"Символ ``\"<\"`` указывает, что они имеют стандартный размер, а порядок "
"байтов — little-endian::"

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):                      # показать заголовки первых трёх "
"файлов\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     # перейти к следующему заголовку"

msgid "Multi-threading"
msgstr "Многопоточность"

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 ""
"Потоки — это техника разделения задач, которые не зависят друг от друга по "
"порядку выполнения. Потоки можно использовать для повышения отзывчивости "
"приложений, которые принимают пользовательский ввод, пока другие задачи "
"выполняются в фоновом режиме. Похожий сценарий — выполнение ввода/вывода "
"параллельно с вычислениями в другом потоке."

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` может "
"запускать задачи в фоновом режиме, в то время как основная программа "
"продолжает работать:"

msgid ""
"import threading, zipfile\n"
"\n"
"class AsyncZip(threading.Thread):\n"
"    def __init__(self, infile, outfile):\n"
"        super().__init__()\n"
"        self.infile = infile\n"
"        self.outfile = outfile\n"
"\n"
"    def run(self):\n"
"        with zipfile.ZipFile(self.outfile, 'w', zipfile.ZIP_DEFLATED) as f:\n"
"            f.write(self.infile)\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"
"        super().__init__()\n"
"        self.infile = infile\n"
"        self.outfile = outfile\n"
"\n"
"    def run(self):\n"
"        with zipfile.ZipFile(self.outfile, 'w', zipfile.ZIP_DEFLATED) as f:\n"
"            f.write(self.infile)\n"
"        print('Архивирование в фоне завершено:', self.infile)\n"
"\n"
"background = AsyncZip('mydata.txt', 'myarchive.zip')\n"
"background.start()\n"
"print('Основная программа продолжает выполняться на переднем плане.')\n"
"\n"
"background.join()    # Ждём, пока фоновая задача завершится\n"
"print('Основная программа дождалась окончания фоновой задачи.')"

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 предоставляет ряд примитивов синхронизации, включая блокировки, "
"события, условные переменные и семафоры."

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` для межпоточного взаимодействия и координации, легче "
"проектируются, более читабельны и надежны."

msgid "Logging"
msgstr "Логирование"

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``::"

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('Отладочная информация')\n"
"logging.info('Информационное сообщение')\n"
"logging.warning('Предупреждение: файл конфигурации %s не найден', 'server."
"conf')\n"
"logging.error('Произошла ошибка')\n"
"logging.critical('Критическая ошибка — завершение работы')"

msgid "This produces the following output:"
msgstr "Это приводит к следующему выводу:"

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:Предупреждение: файл конфигурации server.conf не найден\n"
"ERROR:root:Произошла ошибка\n"
"CRITICAL:root:Критическая ошибка — завершение работы"

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`."

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 ""
"Систему логирования можно настраивать непосредственно из Python или "
"загружать из конфигурационного файла, редактируемого пользователем, для её "
"конфигурации без изменения приложения."

msgid "Weak references"
msgstr "Слабые ссылки"

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 ""
"Python осуществляет автоматическое управление памятью (подсчёт ссылок для "
"большинства объектов и :term:`сбор мусора` для устранения циклов). Память "
"освобождается вскоре после удаления последней ссылки на неё."

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` предоставляет инструменты для "
"отслеживания объектов без создания ссылки. Когда объект больше не нужен, он "
"автоматически удаляется из таблицы слабых ссылок, и для объектов слабых "
"ссылок запускается обратный вызов. К типичным применениям этого относится "
"кэширование объектов, создание которых является затратным::"

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:/python315/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:/python315/lib/weakref.py\", line 46, in __getitem__\n"
"    o = self.data[key]()\n"
"KeyError: 'primary'"

msgid "Tools for working with lists"
msgstr "Инструменты для работы со списками"

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 ""
"Многие потребности в структурах данных можно удовлетворить с помощью "
"встроенного типа списка. Однако иногда возникает необходимость в "
"альтернативных реализациях с другим компромиссом в производительности."

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`, который "
"похож на список, но хранит только однородные данные и делает это более "
"компактно. В следующем примере показан массив чисел, хранящийся в виде "
"двухбайтовых беззнаковых двоичных чисел (код типа ``\"H\"``), вместо обычных "
"16 байтов на элемент для стандартных списков из объектов int в Python:"

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])"

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`, "
"который похож на список с более быстрым добавлением и извлечением данных с "
"левой стороны, но более медленным поиском в середине. Эти объекты хорошо "
"подходят для реализации очередей и поиска по дереву в ширину:"

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([\"задача1\", \"задача2\", \"задача3\"])\n"
">>> d.append(\"задача4\")\n"
">>> print(\"Обработка\", d.popleft())\n"
"Обработка задача1"

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

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` с функциями для "
"работы с отсортированными списками::"

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')]"

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` предоставляет функции для реализации кучи на основе "
"обычных списков. Запись с наименьшим значением всегда сохраняется в нулевой "
"позиции. Это полезно для приложений, которые неоднократно обращаются к "
"наименьшему элементу, но не хотят выполнять полную сортировку списка::"

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

msgid "Decimal floating-point arithmetic"
msgstr "Десятичная арифметика с плавающей точкой"

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` предлагает тип данных :class:`~decimal.Decimal` для "
"десятичной арифметики с плавающей точкой. По сравнению со встроенным типом :"
"class:`float`, реализующим двоичные числа с плавающей точкой, этот класс "
"особенно полезен для"

msgid ""
"financial applications and other uses which require exact decimal "
"representation,"
msgstr ""
"финансовых приложений и других случаев, требующих точного десятичного "
"представления,"

msgid "control over precision,"
msgstr "контроля точности,"

msgid "control over rounding to meet legal or regulatory requirements,"
msgstr ""
"контроля округления для соответствия законодательным или нормативным "
"требованиям,"

msgid "tracking of significant decimal places, or"
msgstr "отслеживания значащих десятичных разрядов или"

msgid ""
"applications where the user expects the results to match calculations done "
"by hand."
msgstr ""
"приложений, в которых пользователь ожидает, что результаты совпадут с "
"расчётами, выполненными вручную."

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 ""
"Например, расчёт налога в размере 5% от счёта за телефон на 70 центов даёт "
"разные результаты в десятичном и двоичном представлении чисел с плавающей "
"точкой. Разница становится значимой, если результаты округлить до цента:"

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"

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` сохраняет конечный ноль, автоматически "
"выводя точность до четырёх значащих цифр в дробной части на основе "
"множителей с двумя знаками в дробной части. Класс Decimal воспроизводит "
"математику так, как она выполняется вручную, и позволяет избежать проблем, "
"которые могут возникнуть, когда двоичные числа с плавающей точкой не могут "
"точно представить десятичные величины."

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` выполнять "
"вычисления по модулю и проверки равенства, которые непригодны для двоичных "
"чисел с плавающей точкой::"

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"

msgid ""
"The :mod:`decimal` module provides arithmetic with as much precision as "
"needed::"
msgstr ""
"Модуль :mod:`decimal` обеспечивает арифметические операции с необходимой "
"точностью::"

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')"