sorting.po

# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2025, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.
#
# Translators:
# Shin Saito, 2021
# tomo, 2022
# Takanori Suzuki <takanori@takanory.net>, 2023
# souma987, 2023
# Arihiro TAKASE, 2024
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.13\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-04-11 14:19+0000\n"
"PO-Revision-Date: 2021-06-28 00:53+0000\n"
"Last-Translator: Arihiro TAKASE, 2024\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"

#: ../../howto/sorting.rst:4
msgid "Sorting Techniques"
msgstr "ソートのテクニック"

#: ../../howto/sorting.rst:0
msgid "Author"
msgstr "著者"

#: ../../howto/sorting.rst:6
msgid "Andrew Dalke and Raymond Hettinger"
msgstr "Andrew Dalke and Raymond Hettinger"

#: ../../howto/sorting.rst:9
msgid ""
"Python lists have a built-in :meth:`list.sort` method that modifies the list "
"in-place.  There is also a :func:`sorted` built-in function that builds a "
"new sorted list from an iterable."
msgstr ""
"Python のリストにはリストをインプレースに変更する、組み込みメソッド :meth:"
"`list.sort` があります。他にもイテラブルからソートしたリストを作成する組み込"
"み関数 :func:`sorted` があります。"

#: ../../howto/sorting.rst:13
msgid ""
"In this document, we explore the various techniques for sorting data using "
"Python."
msgstr ""
"このドキュメントでは Python を使った様々なソートのテクニックを探索します。"

#: ../../howto/sorting.rst:17
msgid "Sorting Basics"
msgstr "ソートの基本"

#: ../../howto/sorting.rst:19
msgid ""
"A simple ascending sort is very easy: just call the :func:`sorted` function. "
"It returns a new sorted list:"
msgstr ""
"単純な昇順のソートはとても簡単です: :func:`sorted` 関数を呼ぶだけです。そうす"
"れば、新たにソートされたリストが返されます::"

#: ../../howto/sorting.rst:22
msgid ""
">>> sorted([5, 2, 3, 1, 4])\n"
"[1, 2, 3, 4, 5]"
msgstr ""

#: ../../howto/sorting.rst:27
msgid ""
"You can also use the :meth:`list.sort` method. It modifies the list in-place "
"(and returns ``None`` to avoid confusion). Usually it's less convenient "
"than :func:`sorted` - but if you don't need the original list, it's slightly "
"more efficient."
msgstr ""
":meth:`list.sort` メソッドを呼びだしても同じことができます。この方法はリスト"
"をインプレースに変更します (そして sorted との混乱を避けるため ``None`` を返"
"します)。多くの場合、こちらの方法は :func:`sorted` と比べると不便です - ただ"
"し、元々のリストが不要な場合には、わずかですがより効率的です。"

#: ../../howto/sorting.rst:32
msgid ""
">>> a = [5, 2, 3, 1, 4]\n"
">>> a.sort()\n"
">>> a\n"
"[1, 2, 3, 4, 5]"
msgstr ""

#: ../../howto/sorting.rst:39
msgid ""
"Another difference is that the :meth:`list.sort` method is only defined for "
"lists. In contrast, the :func:`sorted` function accepts any iterable."
msgstr ""
"違いは他にもあります、 :meth:`list.sort` メソッドはリストにのみ定義されていま"
"す。一方 :func:`sorted` 関数は任意のイテラブルを受け付けます。"

#: ../../howto/sorting.rst:42
msgid ""
">>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})\n"
"[1, 2, 3, 4, 5]"
msgstr ""

#: ../../howto/sorting.rst:48
msgid "Key Functions"
msgstr "Key 関数"

#: ../../howto/sorting.rst:50
msgid ""
"Both :meth:`list.sort` and :func:`sorted` have a *key* parameter to specify "
"a function (or other callable) to be called on each list element prior to "
"making comparisons."
msgstr ""
":meth:`list.sort` と :func:`sorted` には *key* パラメータがあります。 これは"
"比較を行う前にリストの各要素に対して呼び出される関数 (または呼び出し可能オブ"
"ジェクト) を指定するパラメータです。"

#: ../../howto/sorting.rst:54
msgid "For example, here's a case-insensitive string comparison:"
msgstr "例えば、大文字小文字を区別しない文字列比較の例:"

#: ../../howto/sorting.rst:56
msgid ""
">>> sorted(\"This is a test string from Andrew\".split(), key=str.casefold)\n"
"['a', 'Andrew', 'from', 'is', 'string', 'test', 'This']"
msgstr ""

#: ../../howto/sorting.rst:61
msgid ""
"The value of the *key* parameter should be a function (or other callable) "
"that takes a single argument and returns a key to use for sorting purposes. "
"This technique is fast because the key function is called exactly once for "
"each input record."
msgstr ""
"*key* パラメータの値は関数または呼び出し可能オブジェクトであって、単一の引数"
"をとり、ソートに利用されるキー値を返すものでなければいけません。この制約によ"
"りソートを高速に行えます、キー関数は各入力レコードに対してきっちり一回だけ呼"
"び出されるからです。"

#: ../../howto/sorting.rst:66
msgid ""
"A common pattern is to sort complex objects using some of the object's "
"indices as keys. For example:"
msgstr ""
"よくある利用パターンはいくつかの要素から成る対象をインデクスのどれかをキーと"
"してソートすることです。例えば:"

#: ../../howto/sorting.rst:69
msgid ""
">>> student_tuples = [\n"
"...     ('john', 'A', 15),\n"
"...     ('jane', 'B', 12),\n"
"...     ('dave', 'B', 10),\n"
"... ]\n"
">>> sorted(student_tuples, key=lambda student: student[2])   # sort by age\n"
"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"
msgstr ""

#: ../../howto/sorting.rst:79
msgid ""
"The same technique works for objects with named attributes. For example:"
msgstr ""
"同じテクニックは名前づけされた属性 (named attributes) を使うことでオブジェク"
"トに対しても動作します。例えば:"

#: ../../howto/sorting.rst:81
msgid ""
">>> class Student:\n"
"...     def __init__(self, name, grade, age):\n"
"...         self.name = name\n"
"...         self.grade = grade\n"
"...         self.age = age\n"
"...     def __repr__(self):\n"
"...         return repr((self.name, self.grade, self.age))\n"
"\n"
">>> student_objects = [\n"
"...     Student('john', 'A', 15),\n"
"...     Student('jane', 'B', 12),\n"
"...     Student('dave', 'B', 10),\n"
"... ]\n"
">>> sorted(student_objects, key=lambda student: student.age)   # sort by "
"age\n"
"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"
msgstr ""

#: ../../howto/sorting.rst:99
msgid ""
"Objects with named attributes can be made by a regular class as shown above, "
"or they can be instances of :class:`~dataclasses.dataclass` or a :term:"
"`named tuple`."
msgstr ""
"名前づけされた属性を持つオブジェクトは上で示したとおり通常のクラスから作れま"
"すし、:class:`~dataclasses.dataclass` や :term:`named tuple` のインスタンスで"
"もよいです。"

#: ../../howto/sorting.rst:104
msgid "Operator Module Functions and Partial Function Evaluation"
msgstr "operator モジュールの関数や partial 関数による評価"

#: ../../howto/sorting.rst:106
msgid ""
"The :term:`key function` patterns shown above are very common, so Python "
"provides convenience functions to make accessor functions easier and faster. "
"The :mod:`operator` module has :func:`~operator.itemgetter`, :func:"
"`~operator.attrgetter`, and a :func:`~operator.methodcaller` function."
msgstr ""
"上で示した :term:`key function` パターンは非常に一般的なので、Python はアクセ"
"サ関数を簡単に速く作れる便利な関数を提供しています。:mod:`operator` モジュー"
"ルに :func:`~operator.itemgetter`、:func:`~operator.attrgetter`、および :"
"func:`~operator.methodcaller` 関数があります。"

#: ../../howto/sorting.rst:111
msgid "Using those functions, the above examples become simpler and faster:"
msgstr "これらの関数を利用すると、上の例はもっと簡単で高速になります:"

#: ../../howto/sorting.rst:113
msgid ""
">>> from operator import itemgetter, attrgetter\n"
"\n"
">>> sorted(student_tuples, key=itemgetter(2))\n"
"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]\n"
"\n"
">>> sorted(student_objects, key=attrgetter('age'))\n"
"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"
msgstr ""

#: ../../howto/sorting.rst:123
msgid ""
"The operator module functions allow multiple levels of sorting. For example, "
"to sort by *grade* then by *age*:"
msgstr ""
"operator モジュールの関数は複数の段階でのソートを可能にします。例えば、 "
"*grade* でソートしてさらに *age* でソートする場合:"

#: ../../howto/sorting.rst:126
msgid ""
">>> sorted(student_tuples, key=itemgetter(1,2))\n"
"[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]\n"
"\n"
">>> sorted(student_objects, key=attrgetter('grade', 'age'))\n"
"[('john', 'A', 15), ('dave', 'B', 10), ('jane', 'B', 12)]"
msgstr ""

#: ../../howto/sorting.rst:134
msgid ""
"The :mod:`functools` module provides another helpful tool for making key-"
"functions.  The :func:`~functools.partial` function can reduce the `arity "
"<https://en.wikipedia.org/wiki/Arity>`_ of a multi-argument function making "
"it suitable for use as a key-function."
msgstr ""
":mod:`functools` モジュールには他にもキー関数を作るための便利なツールがありま"
"す。:func:`~functools.partial` 関数は複数引数の関数の `アリティ <https://en."
"wikipedia.org/wiki/Arity>`_ を減らし、キー関数に適したものにできます。"

#: ../../howto/sorting.rst:139
msgid ""
">>> from functools import partial\n"
">>> from unicodedata import normalize\n"
"\n"
">>> names = 'Zoë Åbjørn Núñez Élana Zeke Abe Nubia Eloise'.split()\n"
"\n"
">>> sorted(names, key=partial(normalize, 'NFD'))\n"
"['Abe', 'Åbjørn', 'Eloise', 'Élana', 'Nubia', 'Núñez', 'Zeke', 'Zoë']\n"
"\n"
">>> sorted(names, key=partial(normalize, 'NFC'))\n"
"['Abe', 'Eloise', 'Nubia', 'Núñez', 'Zeke', 'Zoë', 'Åbjørn', 'Élana']"
msgstr ""

#: ../../howto/sorting.rst:153
msgid "Ascending and Descending"
msgstr "昇順と降順"

#: ../../howto/sorting.rst:155
msgid ""
"Both :meth:`list.sort` and :func:`sorted` accept a *reverse* parameter with "
"a boolean value. This is used to flag descending sorts. For example, to get "
"the student data in reverse *age* order:"
msgstr ""
":meth:`list.sort` と :func:`sorted` の両方とも *reverse* パラメータを 真偽値"
"として受け付けます。このパラメータは降順ソートを行うかどうかの フラグとして利"
"用されます。 例えば、学生のデータを *age* の逆順で得たい場合:"

#: ../../howto/sorting.rst:159
msgid ""
">>> sorted(student_tuples, key=itemgetter(2), reverse=True)\n"
"[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]\n"
"\n"
">>> sorted(student_objects, key=attrgetter('age'), reverse=True)\n"
"[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]"
msgstr ""

#: ../../howto/sorting.rst:168
msgid "Sort Stability and Complex Sorts"
msgstr "ソートの安定性と複合的なソート"

#: ../../howto/sorting.rst:170
msgid ""
"Sorts are guaranteed to be `stable <https://en.wikipedia.org/wiki/"
"Sorting_algorithm#Stability>`_\\. That means that when multiple records have "
"the same key, their original order is preserved."
msgstr ""
"ソートは、 `安定 (stable) <https://en.wikipedia.org/wiki/"
"Sorting_algorithm#Stability>`_ であることが保証されています。これはレコードの"
"中に同じキーがある場合、元々の順序が維持されるということを意味します。"

#: ../../howto/sorting.rst:174
msgid ""
">>> data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)]\n"
">>> sorted(data, key=itemgetter(0))\n"
"[('blue', 1), ('blue', 2), ('red', 1), ('red', 2)]"
msgstr ""

#: ../../howto/sorting.rst:180
msgid ""
"Notice how the two records for *blue* retain their original order so that "
"``('blue', 1)`` is guaranteed to precede ``('blue', 2)``."
msgstr ""
"二つの *blue* のレコードが元々の順序を維持して、 ``('blue', 1)`` が "
"``('blue', 2)`` の前にあることに注意してください。"

#: ../../howto/sorting.rst:183
msgid ""
"This wonderful property lets you build complex sorts in a series of sorting "
"steps. For example, to sort the student data by descending *grade* and then "
"ascending *age*, do the *age* sort first and then sort again using *grade*:"
msgstr ""
"この素晴しい性質によって複数のソートを段階的に組み合わせることができます。例"
"えば、学生データを *grade* の降順にソートし、さらに *age* の昇順にソートした"
"い場合には、まず *age* でソートし、次に *grade* でもう一度ソートします:"

#: ../../howto/sorting.rst:187
msgid ""
">>> s = sorted(student_objects, key=attrgetter('age'))     # sort on "
"secondary key\n"
">>> sorted(s, key=attrgetter('grade'), reverse=True)       # now sort on "
"primary key, descending\n"
"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"
msgstr ""

#: ../../howto/sorting.rst:193
msgid ""
"This can be abstracted out into a wrapper function that can take a list and "
"tuples of field and order to sort them on multiple passes."
msgstr ""
"この処理は、リストおよびフィールド名とソート順序のタプルを複数受け取れるラッ"
"パー関数へ抽象化できます。"

#: ../../howto/sorting.rst:196
msgid ""
">>> def multisort(xs, specs):\n"
"...     for key, reverse in reversed(specs):\n"
"...         xs.sort(key=attrgetter(key), reverse=reverse)\n"
"...     return xs\n"
"\n"
">>> multisort(list(student_objects), (('grade', True), ('age', False)))\n"
"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"
msgstr ""

#: ../../howto/sorting.rst:206
msgid ""
"The `Timsort <https://en.wikipedia.org/wiki/Timsort>`_ algorithm used in "
"Python does multiple sorts efficiently because it can take advantage of any "
"ordering already present in a dataset."
msgstr ""
"Python では `Timsort <https://en.wikipedia.org/wiki/Timsort>`_ アルゴリズムが"
"利用されていて、効率良く複数のソートを行うことができます、これは現在のデータ"
"セット中のあらゆる順序をそのまま利用できるからです。"

#: ../../howto/sorting.rst:211
msgid "Decorate-Sort-Undecorate"
msgstr "デコレート - ソート - アンデコレート (DSU)"

#: ../../howto/sorting.rst:213
msgid "This idiom is called Decorate-Sort-Undecorate after its three steps:"
msgstr ""
"このイディオムは以下の3つのステップにちなんでデコレート-ソート-アンデコレー"
"ト (Decorate-Sort-Undecorate) と呼ばれています:"

#: ../../howto/sorting.rst:215
msgid ""
"First, the initial list is decorated with new values that control the sort "
"order."
msgstr ""
"まず、元となるリストをソートしたい順序を制御する新しい値でデコレートします。"

#: ../../howto/sorting.rst:217
msgid "Second, the decorated list is sorted."
msgstr "次に、デコレートしたリストをソートします。"

#: ../../howto/sorting.rst:219
msgid ""
"Finally, the decorations are removed, creating a list that contains only the "
"initial values in the new order."
msgstr ""
"最後に、デコレートを取り除き、新しい順序で元々の値のみを持つリストを作りま"
"す。"

#: ../../howto/sorting.rst:222
msgid ""
"For example, to sort the student data by *grade* using the DSU approach:"
msgstr "例えば、DSU アプローチを利用して学生データを *grade* でソートする場合:"

#: ../../howto/sorting.rst:224
msgid ""
">>> decorated = [(student.grade, i, student) for i, student in "
"enumerate(student_objects)]\n"
">>> decorated.sort()\n"
">>> [student for grade, i, student in decorated]               # undecorate\n"
"[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]"
msgstr ""

#: ../../howto/sorting.rst:231
msgid ""
"This idiom works because tuples are compared lexicographically; the first "
"items are compared; if they are the same then the second items are compared, "
"and so on."
msgstr ""
"このイディオムはタブルが辞書編集的に比較されるため正しく動作します; 最初の要"
"素が比較され、同じ場合には第二の要素が比較され、以下も同様に動きます。"

#: ../../howto/sorting.rst:235
msgid ""
"It is not strictly necessary in all cases to include the index *i* in the "
"decorated list, but including it gives two benefits:"
msgstr ""
"デコレートしたリストのインデクス *i* は全ての場合で含まれる必要はありません"
"が、そうすることで二つの利点があります:"

#: ../../howto/sorting.rst:238
msgid ""
"The sort is stable -- if two items have the same key, their order will be "
"preserved in the sorted list."
msgstr ""
"ソートが安定になります -- もし二つの要素が同じキーを持つ場合、それらの順序が"
"ソートされたリストでも維持されます。"

#: ../../howto/sorting.rst:241
msgid ""
"The original items do not have to be comparable because the ordering of the "
"decorated tuples will be determined by at most the first two items. So for "
"example the original list could contain complex numbers which cannot be "
"sorted directly."
msgstr ""
"元々の要素が比較可能な要素を持つとは限りません、なぜならデコレートされたタブ"
"ルの順序は多くの場合、最初の二つの要素で決定されるからです。例として元のリス"
"トは直接比較できない複素数を含むことができます。"

#: ../../howto/sorting.rst:246
msgid ""
"Another name for this idiom is `Schwartzian transform <https://en.wikipedia."
"org/wiki/Schwartzian_transform>`_\\, after Randal L. Schwartz, who "
"popularized it among Perl programmers."
msgstr ""
"このイディオムの別名に `Schwartzian transform <https://en.wikipedia.org/wiki/"
"Schwartzian_transform>`_ があります。これは Perl プログラマの間で有名な "
"Randal L. Schwartz にちなんでいます。"

#: ../../howto/sorting.rst:250
msgid ""
"Now that Python sorting provides key-functions, this technique is not often "
"needed."
msgstr ""
"いまや Python のソートは key 関数による方法を提供しているので、このテクニック"
"は不要でしょう。"

#: ../../howto/sorting.rst:253
msgid "Comparison Functions"
msgstr "比較関数"

#: ../../howto/sorting.rst:255
msgid ""
"Unlike key functions that return an absolute value for sorting, a comparison "
"function computes the relative ordering for two inputs."
msgstr ""
"ソートのための絶対的な値を返すキー関数と違って、2つの入力を受け取り、その相対"
"的な順序を計算するような関数を比較関数といいます。"

#: ../../howto/sorting.rst:258
msgid ""
"For example, a `balance scale <https://upload.wikimedia.org/wikipedia/"
"commons/1/17/Balance_à_tabac_1850.JPG>`_ compares two samples giving a "
"relative ordering: lighter, equal, or heavier. Likewise, a comparison "
"function such as ``cmp(a, b)`` will return a negative value for less-than, "
"zero if the inputs are equal, or a positive value for greater-than."
msgstr ""
"例えば、 `天秤 <https://upload.wikimedia.org/wikipedia/commons/1/17/"
"Balance_à_tabac_1850.JPG>`_ は2つのサンプルを比較し、より軽いか、同じか、より"
"重いかの相対的な順序を与えます。同じように、 ``cmp(a, b)`` などの比較関数はよ"
"り小さいときは負の値を、入力が等しい場合は 0 を、より大きい場合は正の値を返し"
"ます。"

#: ../../howto/sorting.rst:265
msgid ""
"It is common to encounter comparison functions when translating algorithms "
"from other languages.  Also, some libraries provide comparison functions as "
"part of their API.  For example, :func:`locale.strcoll` is a comparison "
"function."
msgstr ""
"他のプログラミング言語で書かれたアルゴリズムを Python に書き直すときに比較関"
"数を目にすることがよくあります。また、その API の一部として比較関数を提供して"
"いるライブラリもあります。例えば、 :func:`locale.strcoll` は比較関数です。"

#: ../../howto/sorting.rst:269
msgid ""
"To accommodate those situations, Python provides :class:`functools."
"cmp_to_key` to wrap the comparison function to make it usable as a key "
"function::"
msgstr ""
"このような場合に対処するため、Python は比較関数をラップしてキー関数として使え"
"るようにする関数 :class:`functools.cmp_to_key` を提供しています。"

#: ../../howto/sorting.rst:273
msgid "sorted(words, key=cmp_to_key(strcoll))  # locale-aware sort order"
msgstr ""

#: ../../howto/sorting.rst:276
msgid "Odds and Ends"
msgstr "残りのはしばし"

#: ../../howto/sorting.rst:278
msgid ""
"For locale aware sorting, use :func:`locale.strxfrm` for a key function or :"
"func:`locale.strcoll` for a comparison function.  This is necessary because "
"\"alphabetical\" sort orderings can vary across cultures even if the "
"underlying alphabet is the same."
msgstr ""
"ロケールに対応したソートを行うには、キー関数に :func:`locale.strxfrm` を使う"
"か、比較関数に :func:`locale.strcoll` を使ってください。これが必要なのは、同"
"じアルファベットを使っていたとしても、文化が違えば \"アルファベット順\" の意"
"味するものが変わることがあるからです。"

#: ../../howto/sorting.rst:283
msgid ""
"The *reverse* parameter still maintains sort stability (so that records with "
"equal keys retain the original order). Interestingly, that effect can be "
"simulated without the parameter by using the builtin :func:`reversed` "
"function twice:"
msgstr ""
"*reverse* パラメータはソートの安定性を保ちます (ですから、レコードのキーが等"
"しい場合元々の順序が維持されます)。面白いことにこの影響はパラメータ無しで :"
"func:`reversed` 関数を二回使うことで模倣することができます:"

#: ../../howto/sorting.rst:288
msgid ""
">>> data = [('red', 1), ('blue', 1), ('red', 2), ('blue', 2)]\n"
">>> standard_way = sorted(data, key=itemgetter(0), reverse=True)\n"
">>> double_reversed = list(reversed(sorted(reversed(data), "
"key=itemgetter(0))))\n"
">>> assert standard_way == double_reversed\n"
">>> standard_way\n"
"[('red', 1), ('red', 2), ('blue', 1), ('blue', 2)]"
msgstr ""

#: ../../howto/sorting.rst:297
msgid ""
"The sort routines use ``<`` when making comparisons between two objects. So, "
"it is easy to add a standard sort order to a class by defining an :meth:"
"`~object.__lt__` method:"
msgstr ""
"ソート関数は、2つのオブジェクトを比較する際 ``<`` を用います。したがって、ク"
"ラスに標準のソート順序を追加することは :meth:`~object.__lt__` メソッドを定義"
"することで達成できます。"

#: ../../howto/sorting.rst:301
msgid ""
">>> Student.__lt__ = lambda self, other: self.age < other.age\n"
">>> sorted(student_objects)\n"
"[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]"
msgstr ""

#: ../../howto/sorting.rst:307
msgid ""
"However, note that ``<`` can fall back to using :meth:`~object.__gt__` if :"
"meth:`~object.__lt__` is not implemented (see :func:`object.__lt__` for "
"details on the mechanics).  To avoid surprises, :pep:`8` recommends that all "
"six comparison methods be implemented. The :func:`~functools.total_ordering` "
"decorator is provided to make that task easier."
msgstr ""
"ただし、``<`` は :meth:`~object.__lt__` が実装されていなければ :meth:"
"`~object.__gt__` を使って代替することに注意してください (この技法について詳し"
"くは :func:`object.__lt__` を参照してください)。驚きを防ぐため、:pep:`8` は6"
"つの比較メソッドを全て実装することを推奨しています。この作業を簡単にするた"
"め、:func:`~functools.total_ordering` デコレータが提供されています。"

#: ../../howto/sorting.rst:314
msgid ""
"Key functions need not depend directly on the objects being sorted. A key "
"function can also access external resources. For instance, if the student "
"grades are stored in a dictionary, they can be used to sort a separate list "
"of student names:"
msgstr ""
"key 関数はソートするオブジェクトに依存する必要はありません。 key 関数は外部リ"
"ソースにアクセスすることもできます。例えば学生の成績が辞書に保存されている場"
"合、それを利用して別の学生の名前のリストをソートすることができます:"

#: ../../howto/sorting.rst:319
msgid ""
">>> students = ['dave', 'john', 'jane']\n"
">>> newgrades = {'john': 'F', 'jane':'A', 'dave': 'C'}\n"
">>> sorted(students, key=newgrades.__getitem__)\n"
"['jane', 'dave', 'john']"
msgstr ""

#: ../../howto/sorting.rst:327
msgid "Partial Sorts"
msgstr "部分的なソート"

#: ../../howto/sorting.rst:329
msgid ""
"Some applications require only some of the data to be ordered.  The standard "
"library provides several tools that do less work than a full sort:"
msgstr ""
"アプリケーションには、データの一部のみが整列されていればよいものがあります。"
"標準ライブラリは完全なソートより少ない作業をするいくつかのツールを提供しま"
"す。"

#: ../../howto/sorting.rst:332
msgid ""
":func:`min` and :func:`max` return the smallest and largest values, "
"respectively.  These functions make a single pass over the input data and "
"require almost no auxiliary memory."
msgstr ""
":func:`min` と :func:`max` はそれぞれ最小値と最大値を返します。これらの関数は"
"入力データを一度だけ通過し、補助的なメモリをほとんど要求しません。"

#: ../../howto/sorting.rst:336
msgid ""
":func:`heapq.nsmallest` and :func:`heapq.nlargest` return the *n* smallest "
"and largest values, respectively.  These functions make a single pass over "
"the data keeping only *n* elements in memory at a time.  For values of *n* "
"that are small relative to the number of inputs, these functions make far "
"fewer comparisons than a full sort."
msgstr ""
":func:`heapq.nsmallest` と :func:`heapq.nlargest` はそれぞれ最小と最大の値 "
"*n* 個を返します。これらの関数はデータを一度だけ通過し、一度に *n* 要素だけを"
"記憶します。入力の数に対して小さい *n* の値では、これらの関数は完全なソートよ"
"り比較の回数がはるかに少なくなります。"

#: ../../howto/sorting.rst:342
msgid ""
":func:`heapq.heappush` and :func:`heapq.heappop` create and maintain a "
"partially sorted arrangement of data that keeps the smallest element at "
"position ``0``.  These functions are suitable for implementing priority "
"queues which are commonly used for task scheduling."
msgstr ""
":func:`heapq.heappush` と :func:`heapq.heappop` は最小の要素がつねに位置 "
"``0`` になる、部分的にソートされたデータの配列を作り維持します。これらの関数"
"はタスクスケジューリングに一般的に使われる優先度キューを実装するのに適してい"
"ます。"