bisect.po

# 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:
# Rafael Fontenelle <rffontenelle@gmail.com>, 2025
# python-doc bot, 2025
# Takanori Suzuki <takanori@takanory.net>, 2026
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.15\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2026-09-09 17:24+0000\n"
"PO-Revision-Date: 2025-09-16 00:00+0000\n"
"Last-Translator: Takanori Suzuki <takanori@takanory.net>, 2026\n"
"Language-Team: Japanese (https://app.transifex.com/python-doc/teams/5390/"
"ja/)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Language: ja\n"
"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../library/bisect.rst:2
msgid ":mod:`!bisect` --- Array bisection algorithm"
msgstr ":mod:`!bisect` --- 配列二分法アルゴリズム"

#: ../../library/bisect.rst:7
msgid "**Source code:** :source:`Lib/bisect.py`"
msgstr "**ソースコード:** :source:`Lib/bisect.py`"

#: ../../library/bisect.rst:11
msgid ""
"This module provides support for maintaining a list in sorted order without "
"having to sort the list after each insertion.  For long lists of items with "
"expensive comparison operations, this can be an improvement over linear "
"searches or frequent resorting."
msgstr ""
"このモジュールは、挿入のたびにリストをソートすることなく、ソートされた順序で"
"リストを維持するためのサポートを提供します。 コストのかかる比較演算を伴う長い"
"リストの場合、これは線形検索や頻繁な並べ替えよりも改善される可能性がありま"
"す。"

#: ../../library/bisect.rst:16
msgid ""
"The module is called :mod:`!bisect` because it uses a basic bisection "
"algorithm to do its work.  Unlike other bisection tools that search for a "
"specific value, the functions in this module are designed to locate an "
"insertion point. Accordingly, the functions never call an :meth:`~object."
"__eq__` method to determine whether a value has been found.  Instead, the "
"functions only call the :meth:`~object.__lt__` method and will return an "
"insertion point between values in an array."
msgstr ""

#: ../../library/bisect.rst:26
msgid ""
"The functions in this module are not thread-safe. If multiple threads "
"concurrently use :mod:`!bisect` functions on the same sequence, this may "
"result in undefined behaviour. Likewise, if the provided sequence is mutated "
"by a different thread while a :mod:`!bisect` function is operating on it, "
"the result is undefined. For example, using :py:func:`~bisect.insort_left` "
"on the same list from multiple threads may result in the list becoming "
"unsorted."
msgstr ""

#: ../../library/bisect.rst:36
msgid "The following functions are provided:"
msgstr "次の関数が用意されています:"

#: ../../library/bisect.rst:41
msgid ""
"Locate the insertion point for *x* in *a* to maintain sorted order. The "
"parameters *lo* and *hi* may be used to specify a subset of the list which "
"should be considered; by default the entire list is used.  If *x* is already "
"present in *a*, the insertion point will be before (to the left of) any "
"existing entries.  The return value is suitable for use as the first "
"parameter to ``list.insert()`` assuming that *a* is already sorted."
msgstr ""
"ソートされた順序を保ったまま *x* を *a* に挿入できる点を探し当てます。リスト"
"の中から検索する部分集合を指定するには、パラメータの *lo* と *hi* を使いま"
"す。デフォルトでは、リスト全体が使われます。*x* がすでに *a* に含まれている場"
"合、挿入点は既存のどのエントリーよりも前(左)になります。戻り値は、``list."
"insert()`` の第一引数として使うのに適しています。*a* はすでにソートされている"
"ものとします。"

#: ../../library/bisect.rst:48
msgid ""
"The returned insertion point *ip* partitions the array *a* into two slices "
"such that ``all(elem < x for elem in a[lo : ip])`` is true for the left "
"slice and ``all(elem >= x for elem in a[ip : hi])`` is true for the right "
"slice."
msgstr ""
"返された挿入点 *ip* パーティションは、左のスライスでは ``all(elem < x for "
"elem in a[lo : ip])`` が真となり、右のスライスでは ``all(elem >= x for elem "
"in a[ip : hi])`` が真となるように、配列 *a* を2つのスライスに分割します。"

#: ../../library/bisect.rst:53
msgid ""
"*key* specifies a :term:`key function` of one argument that is used to "
"extract a comparison key from each element in the array.  To support "
"searching complex records, the key function is not applied to the *x* value."
msgstr ""

#: ../../library/bisect.rst:57
msgid ""
"If *key* is ``None``, the elements are compared directly and no key function "
"is called."
msgstr ""

#: ../../library/bisect.rst:60 ../../library/bisect.rst:74
#: ../../library/bisect.rst:92 ../../library/bisect.rst:112
msgid "Added the *key* parameter."
msgstr "*key* パラメータが追加されました。"

#: ../../library/bisect.rst:67
msgid ""
"Similar to :py:func:`~bisect.bisect_left`, but returns an insertion point "
"which comes after (to the right of) any existing entries of *x* in *a*."
msgstr ""
":py:func:`~bisect.bisect_left` と似ていますが、 *a* に含まれる *x* のうち、ど"
"のエントリーよりも後ろ(右)にくるような挿入点を返します。"

#: ../../library/bisect.rst:70
msgid ""
"The returned insertion point *ip* partitions the array *a* into two slices "
"such that ``all(elem <= x for elem in a[lo : ip])`` is true for the left "
"slice and ``all(elem > x for elem in a[ip : hi])`` is true for the right "
"slice."
msgstr ""
"返された挿入点 *ip* パーティションは、左のスライスでは ``all(elem <= x for "
"elem in a[lo : ip])`` が真となり、右のスライスでは ``all(elem > x for elem "
"in a[ip : hi])`` が真となるように、配列 *a* を2つのスライスに分割します。"

#: ../../library/bisect.rst:80
msgid "Insert *x* in *a* in sorted order."
msgstr "*x* を *a* にソート順で挿入します。"

#: ../../library/bisect.rst:82
msgid ""
"This function first runs :py:func:`~bisect.bisect_left` to locate an "
"insertion point. Next, it runs the :meth:`~sequence.insert` method on *a* to "
"insert *x* at the appropriate position to maintain sort order."
msgstr ""

#: ../../library/bisect.rst:86 ../../library/bisect.rst:106
msgid ""
"To support inserting records in a table, the *key* function (if any) is "
"applied to *x* for the search step but not for the insertion step."
msgstr ""

#: ../../library/bisect.rst:89 ../../library/bisect.rst:109
msgid ""
"Keep in mind that the *O*\\ (log *n*) search is dominated by the slow *O*\\ "
"(*n*) insertion step."
msgstr ""

#: ../../library/bisect.rst:99
msgid ""
"Similar to :py:func:`~bisect.insort_left`, but inserting *x* in *a* after "
"any existing entries of *x*."
msgstr ""
":py:func:`~bisect.insort_left` と似ていますが、 *a* に含まれる *x* のうち、ど"
"のエントリーよりも後ろに *x* を挿入します。"

#: ../../library/bisect.rst:102
msgid ""
"This function first runs :py:func:`~bisect.bisect_right` to locate an "
"insertion point. Next, it runs the :meth:`~sequence.insert` method on *a* to "
"insert *x* at the appropriate position to maintain sort order."
msgstr ""

#: ../../library/bisect.rst:117
msgid "Performance Notes"
msgstr "パフォーマンスに関するメモ"

#: ../../library/bisect.rst:119
msgid ""
"When writing time sensitive code using *bisect()* and *insort()*, keep these "
"thoughts in mind:"
msgstr ""
"*bisect()* と *insort()* を使って時間的制約のあるコードを書くときは、以下のこ"
"とを念頭に置いてください:"

#: ../../library/bisect.rst:122
msgid ""
"Bisection is effective for searching ranges of values. For locating specific "
"values, dictionaries are more performant."
msgstr ""
"二分法は、値の範囲を検索するのに有効です。 特定の値を検索する場合は、辞書の方"
"が効率的です。"

#: ../../library/bisect.rst:125
msgid ""
"The *insort()* functions are *O*\\ (*n*) because the logarithmic search step "
"is dominated by the linear time insertion step."
msgstr ""

#: ../../library/bisect.rst:128
msgid ""
"The search functions are stateless and discard key function results after "
"they are used.  Consequently, if the search functions are used in a loop, "
"the key function may be called again and again on the same array elements. "
"If the key function isn't fast, consider wrapping it with :py:deco:"
"`functools.cache` to avoid duplicate computations.  Alternatively, consider "
"searching an array of precomputed keys to locate the insertion point (as "
"shown in the examples section below)."
msgstr ""

#: ../../library/bisect.rst:138
msgid ""
"`Sorted Collections <https://grantjenks.com/docs/sortedcollections/>`_ is a "
"high performance module that uses *bisect* to managed sorted collections of "
"data."
msgstr ""

#: ../../library/bisect.rst:142
msgid ""
"The `SortedCollection recipe <https://code.activestate.com/recipes/577197-"
"sortedcollection/>`_ uses bisect to build a full-featured collection class "
"with straight-forward search methods and support for a key-function.  The "
"keys are precomputed to save unnecessary calls to the key function during "
"searches."
msgstr ""
"bisect を利用して、直接の探索ができ、キー関数をサポートする、完全な機能を持つ"
"コレクションクラスを組み立てる `SortedCollection recipe <https://code."
"activestate.com/recipes/577197-sortedcollection/>`_\\ 。キーは、探索中に不必"
"要な呼び出しをさせないために、予め計算しておきます。"

#: ../../library/bisect.rst:150
msgid "Searching Sorted Lists"
msgstr "ソート済みリストの探索"

#: ../../library/bisect.rst:152
msgid ""
"The above `bisect functions`_ are useful for finding insertion points but "
"can be tricky or awkward to use for common searching tasks. The following "
"five functions show how to transform them into the standard lookups for "
"sorted lists::"
msgstr ""
"上記の `bisect 関数`_ は挿入点を見つけるには便利ですが、一般的な検索タスクに"
"使うには厄介であったり、使いにくい場合があります。 以下の5つの関数は、それら"
"をソートされたリストの標準的な検索に変換する方法を示しています::"

#: ../../library/bisect.rst:157
msgid ""
"def index(a, x):\n"
"    'Locate the leftmost value exactly equal to x'\n"
"    i = bisect_left(a, x)\n"
"    if i != len(a) and a[i] == x:\n"
"        return i\n"
"    raise ValueError\n"
"\n"
"def find_lt(a, x):\n"
"    'Find rightmost value less than x'\n"
"    i = bisect_left(a, x)\n"
"    if i:\n"
"        return a[i-1]\n"
"    raise ValueError\n"
"\n"
"def find_le(a, x):\n"
"    'Find rightmost value less than or equal to x'\n"
"    i = bisect_right(a, x)\n"
"    if i:\n"
"        return a[i-1]\n"
"    raise ValueError\n"
"\n"
"def find_gt(a, x):\n"
"    'Find leftmost value greater than x'\n"
"    i = bisect_right(a, x)\n"
"    if i != len(a):\n"
"        return a[i]\n"
"    raise ValueError\n"
"\n"
"def find_ge(a, x):\n"
"    'Find leftmost item greater than or equal to x'\n"
"    i = bisect_left(a, x)\n"
"    if i != len(a):\n"
"        return a[i]\n"
"    raise ValueError"
msgstr ""
"def index(a, x):\n"
"    'xにちょうど等しい左端の値を見つける'\n"
"    i = bisect_left(a, x)\n"
"    if i != len(a) and a[i] == x:\n"
"        return i\n"
"    raise ValueError\n"
"\n"
"def find_lt(a, x):\n"
"    'xより小さい右端の値を見つける'\n"
"    i = bisect_left(a, x)\n"
"    if i:\n"
"        return a[i-1]\n"
"    raise ValueError\n"
"\n"
"def find_le(a, x):\n"
"    'x以下の右端の値を見つける'\n"
"    i = bisect_right(a, x)\n"
"    if i:\n"
"        return a[i-1]\n"
"    raise ValueError\n"
"\n"
"def find_gt(a, x):\n"
"    'xより大きい左端の値を見つける'\n"
"    i = bisect_right(a, x)\n"
"    if i != len(a):\n"
"        return a[i]\n"
"    raise ValueError\n"
"\n"
"def find_ge(a, x):\n"
"    '左端の項目がx以上であることを確認する'\n"
"    i = bisect_left(a, x)\n"
"    if i != len(a):\n"
"        return a[i]\n"
"    raise ValueError"

#: ../../library/bisect.rst:194
msgid "Examples"
msgstr "使用例"

#: ../../library/bisect.rst:198
msgid ""
"The :py:func:`~bisect.bisect` function can be useful for numeric table "
"lookups. This example uses :py:func:`~bisect.bisect` to look up a letter "
"grade for an exam score (say) based on a set of ordered numeric breakpoints: "
"90 and up is an 'A', 80 to 89 is a 'B', and so on::"
msgstr ""
":py:func:`~bisect.bisect` 関数は数値テーブルの探索に役に立ちます。この例で"
"は、 :py:func:`~bisect.bisect` を使って、(たとえば)順序のついた数値の区切り点"
"の集合に基づいて、試験の成績の等級を表す文字を調べます。区切り点は 90 以上は "
"'A'、 80 から 89 は 'B'、などです::"

#: ../../library/bisect.rst:203
msgid ""
">>> def grade(score):\n"
"...     i = bisect([60, 70, 80, 90], score)\n"
"...     return \"FDCBA\"[i]\n"
"...\n"
">>> [grade(score) for score in [33, 99, 77, 70, 89, 90, 100]]\n"
"['F', 'A', 'C', 'C', 'B', 'A', 'A']"
msgstr ""

#: ../../library/bisect.rst:210
msgid ""
"The :py:func:`~bisect.bisect` and :py:func:`~bisect.insort` functions also "
"work with lists of tuples.  The *key* argument can serve to extract the "
"field used for ordering records in a table::"
msgstr ""
":py:func:`~bisect.bisect` と :py:func:`~bisect.insort` 関数もタプルのリストで"
"動作します。 引数 *key* はテーブルのレコードの順序付けに使用されるフィールド"
"を抽出します::"

#: ../../library/bisect.rst:214
msgid ""
">>> from collections import namedtuple\n"
">>> from operator import attrgetter\n"
">>> from bisect import bisect, insort\n"
">>> from pprint import pprint\n"
"\n"
">>> Movie = namedtuple('Movie', ('name', 'released', 'director'))\n"
"\n"
">>> movies = [\n"
"...     Movie('Jaws', 1975, 'Spielberg'),\n"
"...     Movie('Titanic', 1997, 'Cameron'),\n"
"...     Movie('The Birds', 1963, 'Hitchcock'),\n"
"...     Movie('Aliens', 1986, 'Cameron')\n"
"... ]\n"
"\n"
">>> # Find the first movie released after 1960\n"
">>> by_year = attrgetter('released')\n"
">>> movies.sort(key=by_year)\n"
">>> movies[bisect(movies, 1960, key=by_year)]\n"
"Movie(name='The Birds', released=1963, director='Hitchcock')\n"
"\n"
">>> # Insert a movie while maintaining sort order\n"
">>> romance = Movie('Love Story', 1970, 'Hiller')\n"
">>> insort(movies, romance, key=by_year)\n"
">>> pprint(movies)\n"
"[Movie(name='The Birds', released=1963, director='Hitchcock'),\n"
" Movie(name='Love Story', released=1970, director='Hiller'),\n"
" Movie(name='Jaws', released=1975, director='Spielberg'),\n"
" Movie(name='Aliens', released=1986, director='Cameron'),\n"
" Movie(name='Titanic', released=1997, director='Cameron')]"
msgstr ""

#: ../../library/bisect.rst:244
msgid ""
"If the key function is expensive, it is possible to avoid repeated function "
"calls by searching a list of precomputed keys to find the index of a record::"
msgstr ""
"キー関数がコストがかかる場合は、レコードのインデックスを見つけるために事前に"
"計算されたキーのリストを検索することにより、関数呼び出しの繰り返しを回避する"
"ことが可能です::"

#: ../../library/bisect.rst:247
msgid ""
">>> data = [('red', 5), ('blue', 1), ('yellow', 8), ('black', 0)]\n"
">>> data.sort(key=lambda r: r[1])       # Or use operator.itemgetter(1).\n"
">>> keys = [r[1] for r in data]         # Precompute a list of keys.\n"
">>> data[bisect_left(keys, 0)]\n"
"('black', 0)\n"
">>> data[bisect_left(keys, 1)]\n"
"('blue', 1)\n"
">>> data[bisect_left(keys, 5)]\n"
"('red', 5)\n"
">>> data[bisect_left(keys, 8)]\n"
"('yellow', 8)"
msgstr ""