# SOME DESCRIPTIVE TITLE.

# Copyright (C) 2001-2021, Python Software Foundation

# This file is distributed under the same license as the Python package.

# FIRST AUTHOR <EMAIL@ADDRESS>, YEAR.

#

# Translators:

# mollinaca, 2020

# tomo, 2021

#

#, fuzzy

msgid ""

msgstr ""

"Project-Id-Version: Python 3.8\n"

"Report-Msgid-Bugs-To: \n"

"POT-Creation-Date: 2021-05-03 17:16+0000\n"

"PO-Revision-Date: 2020-05-30 12:15+0000\n"

"Last-Translator: tomo, 2021\n"

"Language-Team: Japanese (https://www.transifex.com/python-doc/teams/5390/"

"ja/)\n"

"Language: ja\n"

"MIME-Version: 1.0\n"

"Content-Type: text/plain; charset=UTF-8\n"

"Content-Transfer-Encoding: 8bit\n"

"Plural-Forms: nplurals=1; plural=0;\n"

#: ../../reference/datamodel.rst:6

msgid "Data model"

msgstr "データモデル"

#: ../../reference/datamodel.rst:12

msgid "Objects, values and types"

msgstr "オブジェクト、値、および型"

#: ../../reference/datamodel.rst:18

msgid ""

":dfn:`Objects` are Python's abstraction for data. All data in a Python "

"program is represented by objects or by relations between objects. (In a "

"sense, and in conformance to Von Neumann's model of a \"stored program "

"computer\", code is also represented by objects.)"

msgstr ""

"Python における :dfn:`オブジェクト (object)` とは、データを抽象的に表したもの"

"です。Python プログラムにおけるデータは全て、オブジェクトまたはオブジェクト間"

"の関係として表されます。(ある意味では、プログラムコードもまたオブジェクトとし"

"て表されます。これはフォン・ノイマン: Von Neumann の \"プログラム記憶方式コン"

"ピュータ: stored program computer\" のモデルに適合します。)"

#: ../../reference/datamodel.rst:35

msgid ""

"Every object has an identity, a type and a value. An object's *identity* "

"never changes once it has been created; you may think of it as the object's "

"address in memory. The ':keyword:`is`' operator compares the identity of "

"two objects; the :func:`id` function returns an integer representing its "

"identity."

msgstr ""

"すべての属性は、同一性 (identity)、型、値をもっています。 *同一性* は生成され"

"たあとは変更されません。これはオブジェクトのアドレスのようなものだと考えられ"

"るかもしれません。 ':keyword:`is`' 演算子は2つのオブジェクトの同一性を比較し"

"ます。 :func:`id` 関数は同一性を表す整数を返します。"

#: ../../reference/datamodel.rst:42

msgid "For CPython, ``id(x)`` is the memory address where ``x`` is stored."

msgstr ""

"CPython では、``id(x)`` は ``x`` が格納されているメモリ上のアドレスを返しま"

"す。"

#: ../../reference/datamodel.rst:44

msgid ""

"An object's type determines the operations that the object supports (e.g., "

"\"does it have a length?\") and also defines the possible values for objects "

"of that type. The :func:`type` function returns an object's type (which is "

"an object itself). Like its identity, an object's :dfn:`type` is also "

"unchangeable. [#]_"

msgstr ""

"オブジェクトの型はオブジェクトがサポートする操作 (例: :func:`len` をサポート"

"するか) と、オブジェクトが取りうる値を決定します。 :func:`type` 関数はオブ"

"ジェクトの型 (型自体もオブジェクトです) を返します。同一性と同じく、オブジェ"

"クトの型(:dfn:`type`) も変更不可能です。 [#]_"

#: ../../reference/datamodel.rst:50

msgid ""

"The *value* of some objects can change. Objects whose value can change are "

"said to be *mutable*; objects whose value is unchangeable once they are "

"created are called *immutable*. (The value of an immutable container object "

"that contains a reference to a mutable object can change when the latter's "

"value is changed; however the container is still considered immutable, "

"because the collection of objects it contains cannot be changed. So, "

"immutability is not strictly the same as having an unchangeable value, it is "

"more subtle.) An object's mutability is determined by its type; for "

"instance, numbers, strings and tuples are immutable, while dictionaries and "

"lists are mutable."

msgstr ""

"オブジェクトによっては *値* を変更することが可能です。値を変更できるオブジェ"

"クトのことを *mutable* と呼びます。生成後に値を変更できないオブジェクトのこと"

"を *immutable* と呼びます。(mutable なオブジェクトへの参照を格納している "

"immutableなコンテナオブジェクトの値は、その格納しているオブジェクトの値が変化"

"した時に変化しますが、コンテナがどのオブジェクトを格納しているのかが変化しな"

"いのであれば immutable だと考えることができます。したがって、immutable かどう"

"かは値が変更可能かどうかと完全に一致するわけではありません) オブジェクトが "

"mutable かどうかはその型によって決まります。例えば、数値型、文字列型とタプル"

"型のインスタンスは immutable で、dict や list は mutable です。"

#: ../../reference/datamodel.rst:65

msgid ""

"Objects are never explicitly destroyed; however, when they become "

"unreachable they may be garbage-collected. An implementation is allowed to "

"postpone garbage collection or omit it altogether --- it is a matter of "

"implementation quality how garbage collection is implemented, as long as no "

"objects are collected that are still reachable."

msgstr ""

"オブジェクトを明示的に破壊することはできません; しかし、オブジェクトに到達不"

"能 (unreachable) になると、ガベージコレクション (garbage-collection) によって"

"処理されます。実装では、ごみ収集を遅らせたり、全く行わないようにすることがで"

"きます --- 到達可能なオブジェクトをごみ収集処理してしまわないかぎり、どう実装"

"するかは実装品質の問題です。"

#: ../../reference/datamodel.rst:73

msgid ""

"CPython currently uses a reference-counting scheme with (optional) delayed "

"detection of cyclically linked garbage, which collects most objects as soon "

"as they become unreachable, but is not guaranteed to collect garbage "

"containing circular references. See the documentation of the :mod:`gc` "

"module for information on controlling the collection of cyclic garbage. "

"Other implementations act differently and CPython may change. Do not depend "

"on immediate finalization of objects when they become unreachable (so you "

"should always close files explicitly)."

msgstr ""

"現在の CPython 実装では参照カウント(reference-counting) 方式を使っており、(オ"

"プションとして) 循環参照を行っているごみオブジェクトを遅延検出します。この実"

"装ではほとんどのオブジェクトを到達不能になると同時に処理することができます"

"が、循環参照を含むごみオブジェクトの収集が確実に行われるよう保証しているわけ"

"ではありません。循環参照を持つごみオブジェクト収集の制御については、 :mod:"

"`gc` モジュールを参照してください。 CPython以外の実装は別の方式を使っており、"

"CPythonも将来は別の方式を使うかもしれません。オブジェクトが到達不能になったと"

"きに即座に終了処理されることに頼らないでください (ですからファイルは必ず明示"

"的に閉じてください)。"

#: ../../reference/datamodel.rst:82

msgid ""

"Note that the use of the implementation's tracing or debugging facilities "

"may keep objects alive that would normally be collectable. Also note that "

"catching an exception with a ':keyword:`try`...\\ :keyword:`except`' "

"statement may keep objects alive."

msgstr ""

"実装のトレース機能やデバッグ機能を使えば、通常は収集されてしまうようなオブ"

"ジェクトを生存させることがあるので注意してください。また、 ':keyword:`try`..."

"\\ :keyword:`except`' 文を使って例外を捕捉できるようにすると、オブジェクトを"

"生存させることがあります。"

#: ../../reference/datamodel.rst:87

msgid ""

"Some objects contain references to \"external\" resources such as open files "

"or windows. It is understood that these resources are freed when the object "

"is garbage-collected, but since garbage collection is not guaranteed to "

"happen, such objects also provide an explicit way to release the external "

"resource, usually a :meth:`close` method. Programs are strongly recommended "

"to explicitly close such objects. The ':keyword:`try`...\\ :keyword:"

"`finally`' statement and the ':keyword:`with`' statement provide convenient "

"ways to do this."

msgstr ""

"オブジェクトには、開かれたファイルやウィンドウといった、 \"外部 (external) の"

"\" リソースへの参照を含むものがあります。これらのリソースは、オブジェクトがご"

"み収集された際に解放されるものと理解されていますが、ごみ収集が行われる保証は"

"ないので、こうしたオブジェクトは外部リソースを明示的に解放する方法、大抵は :"

"meth:`close` メソッドも提供しています。こうしたオブジェクトは明示的に close "

"するよう強く奨めます。この操作をする際には、':keyword:`try`...\\ :keyword:"

"`finally`' 文や、 ':keyword:`with`' 文を使うと便利です。"

#: ../../reference/datamodel.rst:97

msgid ""

"Some objects contain references to other objects; these are called "

"*containers*. Examples of containers are tuples, lists and dictionaries. "

"The references are part of a container's value. In most cases, when we talk "

"about the value of a container, we imply the values, not the identities of "

"the contained objects; however, when we talk about the mutability of a "

"container, only the identities of the immediately contained objects are "

"implied. So, if an immutable container (like a tuple) contains a reference "

"to a mutable object, its value changes if that mutable object is changed."

msgstr ""

"他のオブジェクトに対する参照をもつオブジェクトもあります; これらは *コンテナ "

"(container)* と呼ばれます。コンテナオブジェクトの例として、タプル、リスト、お"

"よび辞書が挙げられます。オブジェクトへの参照自体がコンテナの値の一部です。ほ"

"とんどの場合、コンテナの値というと、コンテナに入っているオブジェクトの値のこ"

"とを指し、それらオブジェクトのアイデンティティではありません; しかしながら、"

"コンテナの変更可能性について述べる場合、今まさにコンテナに入っているオブジェ"

"クトのアイデンティティのことを指します。したがって、 (タプルのように) 変更不"

"能なオブジェクトが変更可能なオブジェクトへの参照を含む場合、その値が変化する"

"のは変更可能なオブジェクトが変更された時、ということになります。"

#: ../../reference/datamodel.rst:106

msgid ""

"Types affect almost all aspects of object behavior. Even the importance of "

"object identity is affected in some sense: for immutable types, operations "

"that compute new values may actually return a reference to any existing "

"object with the same type and value, while for mutable objects this is not "

"allowed. E.g., after ``a = 1; b = 1``, ``a`` and ``b`` may or may not refer "

"to the same object with the value one, depending on the implementation, but "

"after ``c = []; d = []``, ``c`` and ``d`` are guaranteed to refer to two "

"different, unique, newly created empty lists. (Note that ``c = d = []`` "

"assigns the same object to both ``c`` and ``d``.)"

msgstr ""

"型はオブジェクトの動作のほとんど全てに影響します。オブジェクトのアイデンティ"

"ティが重要かどうかでさえ、ある意味では型に左右されます: 変更不能な型では、新"

"たな値を計算するような操作を行うと、実際には同じ型と値を持った既存のオブジェ"

"クトへの参照を返すことがありますが、変更可能なオブジェクトではそのような動作"

"は起こりえません。例えば、 ``a = 1; b = 1`` とすると、 ``a`` と ``b`` は値 1 "

"を持つ同じオブジェクトを参照するときもあるし、そうでないときもあります。これ"

"は実装に依存します。しかし、 ``c = []; d = []`` とすると、 ``c`` と ``d`` は"

"それぞれ二つの異なった、互いに一意な、新たに作成された空のリストを参照するこ"

"とが保証されています。 (``c = d = []`` とすると、 ``c`` と ``d`` の両方に同じ"

"オブジェクトを代入します)"

#: ../../reference/datamodel.rst:120

msgid "The standard type hierarchy"

msgstr "標準型の階層"

#: ../../reference/datamodel.rst:129

msgid ""

"Below is a list of the types that are built into Python. Extension modules "

"(written in C, Java, or other languages, depending on the implementation) "

"can define additional types. Future versions of Python may add types to the "

"type hierarchy (e.g., rational numbers, efficiently stored arrays of "

"integers, etc.), although such additions will often be provided via the "

"standard library instead."

msgstr ""

"以下は Python に組み込まれている型のリストです。(実装によって、C、Java、また"

"はその他の言語で書かれた) 拡張モジュールで、その他の型が定義されていることが"

"あります。新たな型 (有理数や、整数を効率的に記憶する配列、など) の追加は、た"

"いてい標準ライブラリを通して提供されますが、将来のバージョンの Python では、"

"型の階層構造にこのような追加がなされるかもしれません。"

#: ../../reference/datamodel.rst:140

msgid ""

"Some of the type descriptions below contain a paragraph listing 'special "

"attributes.' These are attributes that provide access to the implementation "

"and are not intended for general use. Their definition may change in the "

"future."

msgstr ""

"以下に説明する型のいくつかには、 '特殊属性 (special attribute)' を列挙した段"

"落があります。これらの属性は実装へのアクセス手段を提供するもので、一般的な用"

"途に利用するためのものではありません。特殊属性の定義は将来変更される可能性が"

"あります。"

#: ../../reference/datamodel.rst:150

msgid "None"

msgstr "None"

#: ../../reference/datamodel.rst:147

msgid ""

"This type has a single value. There is a single object with this value. "

"This object is accessed through the built-in name ``None``. It is used to "

"signify the absence of a value in many situations, e.g., it is returned from "

"functions that don't explicitly return anything. Its truth value is false."

msgstr ""

"この型には単一の値しかありません。この値を持つオブジェクトはただ一つしか存在"

"しません。このオブジェクトは組み込み名 ``None`` でアクセスされます。このオブ"

"ジェクトは、様々な状況で値が存在しないことをしめします。例えば、明示的に値を"

"返さない関数は ``None`` を返します。 ``None`` の真値 (truth value) は偽 "

"(false) です。"

#: ../../reference/datamodel.rst:165

msgid "NotImplemented"

msgstr "NotImplemented"

#: ../../reference/datamodel.rst:155

msgid ""

"This type has a single value. There is a single object with this value. "

"This object is accessed through the built-in name ``NotImplemented``. "

"Numeric methods and rich comparison methods should return this value if they "

"do not implement the operation for the operands provided. (The interpreter "

"will then try the reflected operation, or some other fallback, depending on "

"the operator.) Its truth value is true."

msgstr ""

"この型には単一の値しかありません。この値を持つオブジェクトはただ一つしか存在"

"しません。このオブジェクトは組み込み名 ``NotImplemented`` でアクセスされま"

"す。数値演算に関するメソッドや拡張比較 (rich comparison) メソッドは、被演算子"

"が該当する演算を行うための実装をもたない場合、この値を返すべきです。(演算子に"

"よっては、インタプリタが関連のある演算を試したり、他の代替操作を行います。) "

"真値は真 (true) です。"

#: ../../reference/datamodel.rst:162

msgid "See :ref:`implementing-the-arithmetic-operations` for more details."

msgstr ""

"詳細は :ref:`implementing-the-arithmetic-operations` を参照してください。"

#: ../../reference/datamodel.rst:174

msgid "Ellipsis"

msgstr "Ellipsis"

#: ../../reference/datamodel.rst:172

msgid ""

"This type has a single value. There is a single object with this value. "

"This object is accessed through the literal ``...`` or the built-in name "

"``Ellipsis``. Its truth value is true."

msgstr ""

"この型には単一の値しかありません。この値を持つオブジェクトはただ一つしか存在"

"しません。このオブジェクトはリテラル ``...`` または組み込み名 ``Ellipsis`` で"

"アクセスされます。真理値は真 (true)です。"

#: ../../reference/datamodel.rst:261

msgid ":class:`numbers.Number`"

msgstr ":class:`numbers.Number`"

#: ../../reference/datamodel.rst:179

msgid ""

"These are created by numeric literals and returned as results by arithmetic "

"operators and arithmetic built-in functions. Numeric objects are immutable; "

"once created their value never changes. Python numbers are of course "

"strongly related to mathematical numbers, but subject to the limitations of "

"numerical representation in computers."

msgstr ""

"数値リテラルによって作成されたり、算術演算や組み込みの算術関数によって返され"

"るオブジェクトです。数値オブジェクトは変更不能です; 一度値が生成されると、二"

"度と変更されることはありません。Python の数値オブジェクトはいうまでもなく数学"

"で言うところの数値と強く関係していますが、コンピュータ内で数値を表現する際に"

"伴う制限を受けています。"

#: ../../reference/datamodel.rst:185

msgid ""

"The string representations of the numeric classes, computed by :meth:"

"`__repr__` and :meth:`__str__`, have the following properties:"

msgstr ""

"meth:`__repr__` と :meth:`__str__` から計算された数値クラスの文字列表現には"

"次のような特性があります:"

#: ../../reference/datamodel.rst:189

msgid ""

"They are valid numeric literals which, when passed to their class "

"constructor, produce an object having the value of the original numeric."

msgstr ""

"その文字列は、クラスコンストラクタに渡したときに、元の数値の値を持つオブジェ"

"クトを生成する有効な数値リテラルです。"

#: ../../reference/datamodel.rst:193

msgid "The representation is in base 10, when possible."

msgstr "できるなら、10進法で表現されます。"

#: ../../reference/datamodel.rst:195

msgid ""

"Leading zeros, possibly excepting a single zero before a decimal point, are "

"not shown."

msgstr "小数点の前にある 1 つのゼロを除いて、下に連なるゼロは表示されません。"

#: ../../reference/datamodel.rst:198

msgid ""

"Trailing zeros, possibly excepting a single zero after a decimal point, are "

"not shown."

msgstr "小数点の後にある 1 つのゼロを除いて、下に連なるゼロは表示されません。"

#: ../../reference/datamodel.rst:201

msgid "A sign is shown only when the number is negative."

msgstr "符号は数値が負数のときのみ表示されます。"

#: ../../reference/datamodel.rst:203

msgid ""

"Python distinguishes between integers, floating point numbers, and complex "

"numbers:"

msgstr "Python は整数、浮動小数点数、複素数の間で区別を行っています:"

#: ../../reference/datamodel.rst:236

msgid ":class:`numbers.Integral`"

msgstr ":class:`numbers.Integral` (整数)"

#: ../../reference/datamodel.rst:209

msgid ""

"These represent elements from the mathematical set of integers (positive and "

"negative)."

msgstr ""

"整数型は、整数(正の数および負の数)を表す数学的集合内における要素を表現する型"

"です。"

#: ../../reference/datamodel.rst:212

msgid "There are two types of integers:"

msgstr "整数には 2 種類あります:"

#: ../../reference/datamodel.rst:219

msgid "Integers (:class:`int`)"

msgstr "整数 (:class:`int`)"

#: ../../reference/datamodel.rst:215

msgid ""

"These represent numbers in an unlimited range, subject to available "

"(virtual) memory only. For the purpose of shift and mask operations, a "

"binary representation is assumed, and negative numbers are represented in a "

"variant of 2's complement which gives the illusion of an infinite string of "

"sign bits extending to the left."

msgstr ""

"無制限の範囲の数を表現しますが、利用可能な (仮想) メモリサイズの制限のみを受"

"けます。シフト演算やマスク演算のために2進数表現を持つと想定されます。負の数は"

"符号ビットが左に無限に延びているような錯覚を与える 2 の補数表現の変型で表され"

"ます。"

#: ../../reference/datamodel.rst:231

msgid "Booleans (:class:`bool`)"

msgstr "ブール値 (:class:`bool`)"

#: ../../reference/datamodel.rst:227

msgid ""

"These represent the truth values False and True. The two objects "

"representing the values ``False`` and ``True`` are the only Boolean objects. "

"The Boolean type is a subtype of the integer type, and Boolean values behave "

"like the values 0 and 1, respectively, in almost all contexts, the exception "

"being that when converted to a string, the strings ``\"False\"`` or "

"``\"True\"`` are returned, respectively."

msgstr ""

"真偽値の False と True を表します。``False`` と ``True`` を表す 2 つのオブ"

"ジェクトのみがブール値オブジェクトです。ブール型は整数型の派生型であり、ほと"

"んどの状況でそれぞれ 0 と 1 のように振る舞いますが、例外として文字列に変換さ"

"れたときはそれぞれ ``\"False\"`` および ``\"True\"`` という文字列が返されま"

"す。"

#: ../../reference/datamodel.rst:235

msgid ""

"The rules for integer representation are intended to give the most "

"meaningful interpretation of shift and mask operations involving negative "

"integers."

msgstr ""

"整数表現に関する規則は、負の整数を含むシフト演算やマスク演算において、最も有"

"意義な解釈ができるように意図されています。"

#: ../../reference/datamodel.rst:251

msgid ":class:`numbers.Real` (:class:`float`)"

msgstr ":class:`numbers.Real` (:class:`float`) (実数)"

#: ../../reference/datamodel.rst:245

msgid ""

"These represent machine-level double precision floating point numbers. You "

"are at the mercy of the underlying machine architecture (and C or Java "

"implementation) for the accepted range and handling of overflow. Python does "

"not support single-precision floating point numbers; the savings in "

"processor and memory usage that are usually the reason for using these are "

"dwarfed by the overhead of using objects in Python, so there is no reason to "

"complicate the language with two kinds of floating point numbers."

msgstr ""

"この型は計算機レベルの倍精度浮動小数点数を表現します。表現可能な値の範囲や"

"オーバーフローの扱いは計算機のアーキテクチャ（および、CやJavaによる実装）に従"

"います。Pythonは単精度浮動小数点数をサポートしません。一般的に単精度浮動小数"

"点数を使う理由はプロセッサーとメモリの使用を節約するためと説明されます。しか"

"し、こうした節約はPythonでオブジェクトを扱う際のオーバーヘッドに比べれば微々"

"たるものです。また、2種類の浮動小数点数型を持つことで複雑になる理由はありませ"

"ん。"

#: ../../reference/datamodel.rst:261

msgid ":class:`numbers.Complex` (:class:`complex`)"

msgstr ":class:`numbers.Complex` (:class:`complex`)"

#: ../../reference/datamodel.rst:258

msgid ""

"These represent complex numbers as a pair of machine-level double precision "

"floating point numbers. The same caveats apply as for floating point "

"numbers. The real and imaginary parts of a complex number ``z`` can be "

"retrieved through the read-only attributes ``z.real`` and ``z.imag``."

msgstr ""

"この型は、計算機レベルで倍精度とされている浮動小数点を 2 つ一組にして複素数を"

"表現します。浮動小数点について述べたのと同じ性質が当てはまります。複素数 "

"``z`` の実数部および虚数部は、それぞれ読み出し専用属性 ``z.real`` および ``z."

"imag`` で取り出すことができます。"

#: ../../reference/datamodel.rst:378

msgid "Sequences"

msgstr "シーケンス型 (sequence)"

#: ../../reference/datamodel.rst:271

msgid ""

"These represent finite ordered sets indexed by non-negative numbers. The "

"built-in function :func:`len` returns the number of items of a sequence. "

"When the length of a sequence is *n*, the index set contains the numbers 0, "

"1, ..., *n*-1. Item *i* of sequence *a* is selected by ``a[i]``."

msgstr ""

"この型は、有限の順序集合 (ordered set) を表現します。要素は非負の整数でインデ"

"クス化されています。組み込み関数 :func:`len` を使うと、シーケンスの要素数を返"

"します。シーケンスの長さが *n* の場合、インデクスは 0, 1, ..., *n* -1 からな"

"る集合です。シーケンス *a* の要素 *i* は ``a[i]`` で選択します。"

#: ../../reference/datamodel.rst:278

msgid ""

"Sequences also support slicing: ``a[i:j]`` selects all items with index *k* "

"such that *i* ``<=`` *k* ``<`` *j*. When used as an expression, a slice is "

"a sequence of the same type. This implies that the index set is renumbered "

"so that it starts at 0."

msgstr ""

"シーケンスはスライス操作 (slice) もサポートしています: ``a[i:j]`` とすると、 "

"*i* ``<=`` *k* ``<`` *j* であるインデクス *k* をもつ全ての要素を選択します。"

"式表現としてスライスを用いた場合、スライスは同じ型をもつ新たなシーケンスを表"

"します。新たなシーケンス内では、インデクス集合が 0 から始まるようにインデクス"

"の値を振りなおします。"

#: ../../reference/datamodel.rst:283

msgid ""

"Some sequences also support \"extended slicing\" with a third \"step\" "

"parameter: ``a[i:j:k]`` selects all items of *a* with index *x* where ``x = "

"i + n*k``, *n* ``>=`` ``0`` and *i* ``<=`` *x* ``<`` *j*."

msgstr ""

"シーケンスによっては、第三の \"ステップ (step)\" パラメタを持つ \"拡張スライ"

"ス (extended slice)\" もサポートしています: ``a[i:j:k]`` は、 ``x = i + "

"n*k``, *n* ``>=`` ``0`` かつ *i* ``<=`` *x* ``<`` *j* であるようなインデクス "

"*x* を持つような *a* 全ての要素を選択します。"

#: ../../reference/datamodel.rst:287

msgid "Sequences are distinguished according to their mutability:"

msgstr "シーケンスは、変更可能なものか、そうでないかで区別されています:"

#: ../../reference/datamodel.rst:344

msgid "Immutable sequences"

msgstr "変更不能なシーケンス (immutable sequence)"

#: ../../reference/datamodel.rst:294

msgid ""

"An object of an immutable sequence type cannot change once it is created. "

"(If the object contains references to other objects, these other objects may "

"be mutable and may be changed; however, the collection of objects directly "

"referenced by an immutable object cannot change.)"

msgstr ""

"変更不能なシーケンス型のオブジェクトは、一度生成されるとその値を変更すること"

"ができません。 (オブジェクトに他のオブジェクトへの参照が入っている場合、参照"

"されているオブジェクトは変更可能なオブジェクトでもよく、その値は変更される可"

"能性があります; しかし、変更不能なオブジェクトが直接参照しているオブジェクト"

"の集合自体は、変更することができません。)"

#: ../../reference/datamodel.rst:299

msgid "The following types are immutable sequences:"

msgstr "以下の型は変更不能なシーケンス型です:"

#: ../../reference/datamodel.rst:322

msgid "Strings"

msgstr "文字列型 (string)"

#: ../../reference/datamodel.rst:312

msgid ""

"A string is a sequence of values that represent Unicode code points. All the "

"code points in the range ``U+0000 - U+10FFFF`` can be represented in a "

"string. Python doesn't have a :c:type:`char` type; instead, every code "

"point in the string is represented as a string object with length ``1``. "

"The built-in function :func:`ord` converts a code point from its string form "

"to an integer in the range ``0 - 10FFFF``; :func:`chr` converts an integer "

"in the range ``0 - 10FFFF`` to the corresponding length ``1`` string "

"object. :meth:`str.encode` can be used to convert a :class:`str` to :class:"

"`bytes` using the given text encoding, and :meth:`bytes.decode` can be used "

"to achieve the opposite."

msgstr ""

"文字列はUnicodeコードポイントを表現する値の配列です。文字列中のどのコードポイ"

"ントも ``U+0000 - U+10FFFF`` の範囲で表現されることができます。Pythonは :c:"

"type:`char` 型を持ちません。代わりに、文字列中のどのコードポイントも長さ "

"''1'' の文字列オブジェクトとして表現することができます。組み込み関数 :func:"

"`ord` は文字列形式を0 - 10FFFFの範囲の整数に変換します。また、組み込み関数 :"

"func:`chr` は ``0 - 10FFFF`` の範囲の整数を対応する長さ ``1`` の文字列に変換"

"します。:meth:`str.encode` はテキストエンコーディングを使うことで :class:"

"`str` を :class:`bytes` に変換するために使うことができます。また、:meth:"

"`bytes.decode` によりその逆が実行することができます。"

#: ../../reference/datamodel.rst:335

msgid "Tuples"

msgstr "タプル型 (tuple)"

#: ../../reference/datamodel.rst:330

msgid ""

"The items of a tuple are arbitrary Python objects. Tuples of two or more "

"items are formed by comma-separated lists of expressions. A tuple of one "

"item (a 'singleton') can be formed by affixing a comma to an expression (an "

"expression by itself does not create a tuple, since parentheses must be "

"usable for grouping of expressions). An empty tuple can be formed by an "

"empty pair of parentheses."

msgstr ""

"タプルの要素は任意の Python オブジェクトです。二つ以上の要素からなるタプル"

"は、個々の要素を表現する式をカンマで区切って構成します。単一の要素からなるタ"

"プル (単集合 'singleton') を作るには、要素を表現する式の直後にカンマをつけま"

"す (単一の式だけではタプルを形成しません。これは、式をグループ化するのに丸括"

"弧を使えるようにしなければならないからです)。要素の全くない丸括弧の対を作ると"

"空のタプルになります。"

#: ../../reference/datamodel.rst:344

msgid "Bytes"

msgstr "bytes"

#: ../../reference/datamodel.rst:340

msgid ""

"A bytes object is an immutable array. The items are 8-bit bytes, "

"represented by integers in the range 0 <= x < 256. Bytes literals (like "

"``b'abc'``) and the built-in :func:`bytes()` constructor can be used to "

"create bytes objects. Also, bytes objects can be decoded to strings via "

"the :meth:`~bytes.decode` method."

msgstr ""

"bytes オブジェクトは不変な配列です。要素は 8-bit バイトで、 0 <= x < 256 の範"

"囲の整数で表現されます。 (``b'abc'`` のような) bytes リテラルや組み込みの :"

"func:`bytes()` コンストラクタを使って bytes オブジェクトを作成できます。ま"

"た、 bytes オブジェクトは :meth:`~bytes.decode` メソッドを通して文字列にデ"

"コードできます。"

#: ../../reference/datamodel.rst:378

msgid "Mutable sequences"

msgstr "変更可能なシーケンス型 (mutable sequence)"

#: ../../reference/datamodel.rst:354

msgid ""

"Mutable sequences can be changed after they are created. The subscription "

"and slicing notations can be used as the target of assignment and :keyword:"

"`del` (delete) statements."

msgstr ""

"変更可能なシーケンスは、作成した後で変更することができます。変更可能なシーケ"

"ンスでは、添字表記やスライス表記を使って指定された要素に代入を行うことがで"

"き、 :keyword:`del` (delete) 文を使って要素を削除することができます。"

#: ../../reference/datamodel.rst:358

msgid "There are currently two intrinsic mutable sequence types:"

msgstr ""

"Python に最初から組み込まれている変更可能なシーケンス型は、今のところ二つで"

"す:"

#: ../../reference/datamodel.rst:365

msgid "Lists"

msgstr "リスト型 (list)"

#: ../../reference/datamodel.rst:363

msgid ""

"The items of a list are arbitrary Python objects. Lists are formed by "

"placing a comma-separated list of expressions in square brackets. (Note that "

"there are no special cases needed to form lists of length 0 or 1.)"

msgstr ""

"リストの要素は任意の Python オブジェクトにできます。リストは、角括弧の中にカ"

"ンマで区切られた式を並べて作ります。 (長さが 0 や 1 のシーケンスを作るために"

"特殊な場合分けは必要ないことに注意してください。)"

#: ../../reference/datamodel.rst:373

msgid "Byte Arrays"

msgstr "バイト配列"

#: ../../reference/datamodel.rst:370

msgid ""

"A bytearray object is a mutable array. They are created by the built-in :"

"func:`bytearray` constructor. Aside from being mutable (and hence "

"unhashable), byte arrays otherwise provide the same interface and "

"functionality as immutable :class:`bytes` objects."

msgstr ""

"bytearray オブジェクトは変更可能な配列です。組み込みの :func:`bytearray` コン"

"ストラクタによって作成されます。変更可能なことを除けば (つまりハッシュ化でき"

"ない)、 byte array は変更不能な :class:`bytes` オブジェクトと同じインター"

"フェースと機能を提供します。"

#: ../../reference/datamodel.rst:377

msgid ""

"The extension module :mod:`array` provides an additional example of a "

"mutable sequence type, as does the :mod:`collections` module."

msgstr ""

"拡張モジュール :mod:`array` や、 :mod:`collections` モジュールには、さらなる"

"ミュータブルなシーケンス型の例があります。"

#: ../../reference/datamodel.rst:412

msgid "Set types"

msgstr "集合型"

#: ../../reference/datamodel.rst:385

msgid ""

"These represent unordered, finite sets of unique, immutable objects. As "

"such, they cannot be indexed by any subscript. However, they can be iterated "

"over, and the built-in function :func:`len` returns the number of items in a "

"set. Common uses for sets are fast membership testing, removing duplicates "

"from a sequence, and computing mathematical operations such as intersection, "

"union, difference, and symmetric difference."

msgstr ""

"集合型は、順序のない、ユニークで不変なオブジェクトの有限集合を表現します。そ"

"のため、(配列の)添字を使ったインデックスアクセスはできません。ただし、イテ"

"レートは可能で、組み込み関数 :func:`len` は集合の要素数を返します。集合型の一"

"般的な使い方は、集合に属しているかの高速なテスト、シーケンスからの重複の排"

"除、共通集合・和集合・差・対称差といった数学的な演算の計算です。"

#: ../../reference/datamodel.rst:392

msgid ""

"For set elements, the same immutability rules apply as for dictionary keys. "

"Note that numeric types obey the normal rules for numeric comparison: if two "

"numbers compare equal (e.g., ``1`` and ``1.0``), only one of them can be "

"contained in a set."

msgstr ""

"集合の要素には、辞書のキーと同じ普遍性に関するルールが適用されます。数値型は"

"通常の数値比較のルールに従うことに注意してください。もし2つの数値の比較結果が"

"同値である(例えば、 ``1`` と ``1.0``)なら、そのうちの1つのみを集合に含めるこ"

"とができます。"

#: ../../reference/datamodel.rst:397

msgid "There are currently two intrinsic set types:"

msgstr "現在、2つの組み込み集合型があります:"

#: ../../reference/datamodel.rst:404

msgid "Sets"

msgstr "集合型"

#: ../../reference/datamodel.rst:402

msgid ""

"These represent a mutable set. They are created by the built-in :func:`set` "

"constructor and can be modified afterwards by several methods, such as :meth:"

"`~set.add`."

msgstr ""

"可変な集合型です。組み込みの :func:`set` コンストラクタで作成され、後から :"

"meth:`~set.add` などのいくつかのメソッドで更新できます。"

#: ../../reference/datamodel.rst:412

msgid "Frozen sets"

msgstr "Frozen set 型"

#: ../../reference/datamodel.rst:409

msgid ""

"These represent an immutable set. They are created by the built-in :func:"

"`frozenset` constructor. As a frozenset is immutable and :term:`hashable`, "

"it can be used again as an element of another set, or as a dictionary key."

msgstr ""

"不変な集合型です。組み込みの :func:`frozenset` コンストラクタによって作成され"

"ます。 frozenset は不変で :term:`ハッシュ可能 <hashable>` なので、別の集合型"

"の要素になったり、辞書のキーにすることができます。"

#: ../../reference/datamodel.rst:459

msgid "Mappings"

msgstr "マッピング型 (mapping)"

#: ../../reference/datamodel.rst:420

msgid ""

"These represent finite sets of objects indexed by arbitrary index sets. The "

"subscript notation ``a[k]`` selects the item indexed by ``k`` from the "

"mapping ``a``; this can be used in expressions and as the target of "

"assignments or :keyword:`del` statements. The built-in function :func:`len` "

"returns the number of items in a mapping."

msgstr ""

"任意のインデクス集合でインデクス化された、オブジェクトからなる有限の集合を表"

"現します。添字表記 ``a[k]`` は、 ``k`` でインデクス指定された要素を ``a`` か"

"ら選択します; 選択された要素は式の中で使うことができ、代入や :keyword:`del` "

"文の対象にすることができます。組み込み関数 :func:`len` は、マッピング内の要素"

"数を返します。"

#: ../../reference/datamodel.rst:426

msgid "There is currently a single intrinsic mapping type:"

msgstr ""

"Python に最初から組み込まれているマッピング型は、今のところ一つだけです:"

#: ../../reference/datamodel.rst:459

msgid "Dictionaries"

msgstr "辞書型 (dictionary)"

#: ../../reference/datamodel.rst:431

msgid ""

"These represent finite sets of objects indexed by nearly arbitrary values. "

"The only types of values not acceptable as keys are values containing lists "

"or dictionaries or other mutable types that are compared by value rather "

"than by object identity, the reason being that the efficient implementation "

"of dictionaries requires a key's hash value to remain constant. Numeric "

"types used for keys obey the normal rules for numeric comparison: if two "

"numbers compare equal (e.g., ``1`` and ``1.0``) then they can be used "

"interchangeably to index the same dictionary entry."

msgstr ""

"ほぼ任意の値でインデクスされたオブジェクトからなる有限の集合を表します。\n"

"キー (key) として使えない値の唯一の型は、リストや辞書、そしてオブジェクトの同"

"一性でなく値で比較されるその他の変更可能な型です。\n"

"これは、辞書型を効率的に実装する上で、キーのハッシュ値が不変である必要がある"

"ためです。\n"

"数値型をキーに使う場合、キー値は通常の数値比較における規則に従います: 二つの"

"値が等しくなる場合 (例えば ``1`` と ``1.0``)、互いに同じ辞書のエントリを表す"

"インデクスとして使うことができます。"

#: ../../reference/datamodel.rst:440

msgid ""

"Dictionaries preserve insertion order, meaning that keys will be produced in "

"the same order they were added sequentially over the dictionary. Replacing "

"an existing key does not change the order, however removing a key and re-"

"inserting it will add it to the end instead of keeping its old place."

msgstr ""

"辞書は挿入の順序を保持します。つまり、キーは辞書に追加された順番に生成されて"

"いきます。既存のキーを置き換えても、キーの順序は変わりません。キーを削除した"

"のちに再挿入すると、元の場所ではなく辞書の最後に追加されます。"

#: ../../reference/datamodel.rst:445

msgid ""

"Dictionaries are mutable; they can be created by the ``{...}`` notation (see "

"section :ref:`dict`)."

msgstr ""

"辞書は変更可能な型です; 辞書は ``{...}`` 表記で生成します (:ref:`dict` を参照"

"してください)。"

#: ../../reference/datamodel.rst:452

msgid ""

"The extension modules :mod:`dbm.ndbm` and :mod:`dbm.gnu` provide additional "

"examples of mapping types, as does the :mod:`collections` module."

msgstr ""

"拡張モジュール :mod:`dbm.ndbm` 、 :mod:`dbm.gnu` は、 :mod:`collections` モ"

"ジュールのように、別のマッピング型の例を提供しています。"

#: ../../reference/datamodel.rst:456

msgid ""

"Dictionaries did not preserve insertion order in versions of Python before "

"3.6. In CPython 3.6, insertion order was preserved, but it was considered an "

"implementation detail at that time rather than a language guarantee."

msgstr ""

"Pythonのバージョン3.6では、辞書は挿入順序を保持しませんでした。CPython 3.6で"

"は挿入順序は保持されましたが、それは策定された言語の仕様というより、その当時"

"の実装の細部とみなされていました。"

#: ../../reference/datamodel.rst:717

msgid "Callable types"

msgstr "呼び出し可能型 (callable type)"

#: ../../reference/datamodel.rst:468

msgid ""

"These are the types to which the function call operation (see section :ref:"

"`calls`) can be applied:"

msgstr "関数呼び出し操作 (:ref:`calls` 参照) を行うことができる型です:"

#: ../../reference/datamodel.rst:571

msgid "User-defined functions"

msgstr "ユーザ定義関数 (user-defined function)"

#: ../../reference/datamodel.rst:477

msgid ""

"A user-defined function object is created by a function definition (see "

"section :ref:`function`). It should be called with an argument list "

"containing the same number of items as the function's formal parameter list."

msgstr ""

"ユーザ定義関数オブジェクトは、関数定義を行うことで生成されます (:ref:"

"`function` 参照)。関数は、仮引数 (formal parameter) リストと同じ数の要素が"

"入った引数リストとともに呼び出されます。"

#: ../../reference/datamodel.rst:482

msgid "Special attributes:"

msgstr "特殊属性:"

#: ../../reference/datamodel.rst:500

msgid "Attribute"

msgstr "属性"

#: ../../reference/datamodel.rst:500

msgid "Meaning"

msgstr "意味"

#: ../../reference/datamodel.rst:502

msgid ":attr:`__doc__`"

msgstr ":attr:`__doc__`"

#: ../../reference/datamodel.rst:502

msgid ""

"The function's documentation string, or ``None`` if unavailable; not "

"inherited by subclasses."

msgstr ""

"関数のドキュメンテーション文字列で、ドキュメンテーションがない場合は "

"``None`` になります。サブクラスに継承されません。"

#: ../../reference/datamodel.rst:502 ../../reference/datamodel.rst:507

#: ../../reference/datamodel.rst:510 ../../reference/datamodel.rst:515

#: ../../reference/datamodel.rst:519 ../../reference/datamodel.rst:525

#: ../../reference/datamodel.rst:535 ../../reference/datamodel.rst:546

#: ../../reference/datamodel.rst:553

msgid "Writable"

msgstr "書き込み可能"

#: ../../reference/datamodel.rst:507

msgid ":attr:`~definition.\\ __name__`"

msgstr ":attr:`~definition.\\ __name__`"

#: ../../reference/datamodel.rst:507

msgid "The function's name."

msgstr "関数の名前です。"

#: ../../reference/datamodel.rst:510

msgid ":attr:`~definition.\\ __qualname__`"

msgstr ":attr:`~definition.\\ __qualname__`"

#: ../../reference/datamodel.rst:510

msgid "The function's :term:`qualified name`."

msgstr "関数の :term:`qualified name` です。"

#: ../../reference/datamodel.rst:515

msgid ":attr:`__module__`"

msgstr ":attr:`__module__`"

#: ../../reference/datamodel.rst:515

msgid ""

"The name of the module the function was defined in, or ``None`` if "

"unavailable."

msgstr ""

"関数が定義されているモジュールの名前です。モジュール名がない場合は ``None`` "

"になります。"

#: ../../reference/datamodel.rst:519

msgid ":attr:`__defaults__`"

msgstr ":attr:`__defaults__`"

#: ../../reference/datamodel.rst:519

msgid ""

"A tuple containing default argument values for those arguments that have "

"defaults, or ``None`` if no arguments have a default value."

msgstr ""

"デフォルト値を持つ引数に対するデフォルト値が収められたタプルで、デフォルト値"

"を持つ引数がない場合には ``None`` になります"

#: ../../reference/datamodel.rst:525

msgid ":attr:`__code__`"

msgstr ":attr:`__code__`"

#: ../../reference/datamodel.rst:525

msgid "The code object representing the compiled function body."

msgstr "コンパイルされた関数本体を表現するコードオブジェクトです。"

#: ../../reference/datamodel.rst:528

msgid ":attr:`__globals__`"

msgstr ":attr:`__globals__`"

#: ../../reference/datamodel.rst:528

msgid ""

"A reference to the dictionary that holds the function's global variables --- "

"the global namespace of the module in which the function was defined."

msgstr ""

"関数のグローバル変数の入った辞書 (への参照) です --- この辞書は、関数が定義さ"

"れているモジュールのグローバルな名前空間を決定します。"

#: ../../reference/datamodel.rst:528 ../../reference/datamodel.rst:539

msgid "Read-only"

msgstr "読み出し専用"

#: ../../reference/datamodel.rst:535

msgid ":attr:`~object.__dict__`"

msgstr ":attr:`~object.__dict__`"

#: ../../reference/datamodel.rst:535

msgid "The namespace supporting arbitrary function attributes."

msgstr "任意の関数属性をサポートするための名前空間が収められています。"

#: ../../reference/datamodel.rst:539

msgid ":attr:`__closure__`"

msgstr ":attr:`__closure__`"

#: ../../reference/datamodel.rst:539

msgid ""

"``None`` or a tuple of cells that contain bindings for the function's free "

"variables. See below for information on the ``cell_contents`` attribute."

msgstr ""

"``None`` または関数の個々の自由変数 (引数以外の変数) に対して値を束縛している"

"セル (cell) 群からなるタプルになります。\n"

"``cell_contents`` 属性についての情報は下を参照してください。"

#: ../../reference/datamodel.rst:546

msgid ":attr:`__annotations__`"

msgstr ":attr:`__annotations__`"

#: ../../reference/datamodel.rst:546

msgid ""

"A dict containing annotations of parameters. The keys of the dict are the "

"parameter names, and ``'return'`` for the return annotation, if provided."

msgstr ""

"パラメータの注釈が入った辞書です。辞書のキーはパラメータ名で、返り値の注釈が"

"ある場合は、``'return'`` がそのキーとなります。"

#: ../../reference/datamodel.rst:553

msgid ":attr:`__kwdefaults__`"

msgstr ":attr:`__kwdefaults__`"

#: ../../reference/datamodel.rst:553

msgid "A dict containing defaults for keyword-only parameters."

msgstr "キーワード専用パラメータのデフォルト値を含む辞書です。"

#: ../../reference/datamodel.rst:557

msgid ""

"Most of the attributes labelled \"Writable\" check the type of the assigned "

"value."

msgstr ""

"「書き込み可能」とラベルされている属性のほとんどは、代入された値の型をチェッ"

"クします。"

#: ../../reference/datamodel.rst:559

msgid ""

"Function objects also support getting and setting arbitrary attributes, "

"which can be used, for example, to attach metadata to functions. Regular "

"attribute dot-notation is used to get and set such attributes. *Note that "

"the current implementation only supports function attributes on user-defined "

"functions. Function attributes on built-in functions may be supported in the "

"future.*"

msgstr ""

"関数オブジェクトはまた、任意の属性を設定したり取得したりできます。この機能"

"は、例えば関数にメタデータを付与したい場合などに使えます。関数の get や set "

"には、通常のドット表記を使います。 *現在の実装では、ユーザ定義の関数でのみ属"

"性をサポートしているので注意して下さい。組み込み関数の属性は将来サポートする"

"予定です。*"

#: ../../reference/datamodel.rst:565

msgid ""

"A cell object has the attribute ``cell_contents``. This can be used to get "

"the value of the cell, as well as set the value."

msgstr ""

"セルオブジェクトは属性 ``cell_contents`` を持っています。\n"

"これはセルの値を設定するのに加えて、セルの値を得るのにも使えます。"

#: ../../reference/datamodel.rst:568

msgid ""

"Additional information about a function's definition can be retrieved from "

"its code object; see the description of internal types below. The :data:"

"`cell <types.CellType>` type can be accessed in the :mod:`types` module."

msgstr ""

"関数定義に関するその他の情報は関数のコードオブジェクトから得られます。後述の"

"内部型 (internal type) に関する説明を参照してください。\n"

":data:`cell <types.CellType>` 型には :mod:`types` モジュールからアクセスでき"

"ます。"

#: ../../reference/datamodel.rst:634

msgid "Instance methods"

msgstr "インスタンスメソッド"

#: ../../reference/datamodel.rst:579

msgid ""