# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2022, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR , YEAR.
#
# Translators:
# Rafael Fontenelle , 2022
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.10\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2022-12-30 14:59+0000\n"
"PO-Revision-Date: 2022-11-05 17:23+0000\n"
"Last-Translator: Rafael Fontenelle , 2022\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"
#: ../../tutorial/introduction.rst:5
msgid "An Informal Introduction to Python"
msgstr " Python "
#: ../../tutorial/introduction.rst:7
msgid ""
"In the following examples, input and output are distinguished by the "
"presence or absence of prompts (:term:`>>>` and :term:`...`): to repeat the "
"example, you must type everything after the prompt, when the prompt appears; "
"lines that do not begin with a prompt are output from the interpreter. Note "
"that a secondary prompt on a line by itself in an example means you must "
"type a blank line; this is used to end a multi-line command."
msgstr ""
" (:term:`>>>` :term:`...`) "
": "
" \n"
"\n"
""
" (:term:`...`) "
"\n"
"\n"
" "
""
#: ../../tutorial/introduction.rst:16
msgid ""
"You can toggle the display of prompts and output by clicking on ``>>>`` in "
"the upper-right corner of an example box. If you hide the prompts and "
"output for an example, then you can easily copy and paste the input lines "
"into your interpreter."
msgstr ""
" ``>>>`` "
""
"&"
#: ../../tutorial/introduction.rst:23
msgid ""
"Many of the examples in this manual, even those entered at the interactive "
"prompt, include comments. Comments in Python start with the hash character, "
"``#``, and extend to the end of the physical line. A comment may appear at "
"the start of a line or following whitespace or code, but not within a string "
"literal. A hash character within a string literal is just a hash character. "
"Since comments are to clarify code and are not interpreted by Python, they "
"may be omitted when typing in examples."
msgstr ""
""
" Python ``#`` "
""
""
""
"Python"
""
#: ../../tutorial/introduction.rst:31
msgid "Some examples::"
msgstr "::"
#: ../../tutorial/introduction.rst:42
msgid "Using Python as a Calculator"
msgstr "Python "
#: ../../tutorial/introduction.rst:44
msgid ""
"Let's try some simple Python commands. Start the interpreter and wait for "
"the primary prompt, ``>>>``. (It shouldn't take long.)"
msgstr ""
" Python "
" ``>>>`` ("
")"
#: ../../tutorial/introduction.rst:51
msgid "Numbers"
msgstr ""
#: ../../tutorial/introduction.rst:53
msgid ""
"The interpreter acts as a simple calculator: you can type an expression at "
"it and it will write the value. Expression syntax is straightforward: the "
"operators ``+``, ``-``, ``*`` and ``/`` work just like in most other "
"languages (for example, Pascal or C); parentheses (``()``) can be used for "
"grouping. For example::"
msgstr ""
": "
": ``+``, ``-``, ``*``, ``/`` "
"(Pascal C ) ; "
"(``()``) ::"
#: ../../tutorial/introduction.rst:68
msgid ""
"The integer numbers (e.g. ``2``, ``4``, ``20``) have type :class:`int`, the "
"ones with a fractional part (e.g. ``5.0``, ``1.6``) have type :class:"
"`float`. We will see more about numeric types later in the tutorial."
msgstr ""
" ( ``2`` ``4`` ``20``) :class:`int` "
" ( ``5.0`` ``1.6``) :class:`float` "
""
#: ../../tutorial/introduction.rst:72
msgid ""
"Division (``/``) always returns a float. To do :term:`floor division` and "
"get an integer result you can use the ``//`` operator; to calculate the "
"remainder you can use ``%``::"
msgstr ""
" (``/``) ``//`` :term:` "
"` ; ``%`` ::"
#: ../../tutorial/introduction.rst:86
msgid ""
"With Python, it is possible to use the ``**`` operator to calculate powers "
"[#]_::"
msgstr "Python ``**`` [#]_::"
#: ../../tutorial/introduction.rst:93
msgid ""
"The equal sign (``=``) is used to assign a value to a variable. Afterwards, "
"no result is displayed before the next interactive prompt::"
msgstr ""
" (``=``) "
"::"
#: ../../tutorial/introduction.rst:101
msgid ""
"If a variable is not \"defined\" (assigned a value), trying to use it will "
"give you an error::"
msgstr ""
" \"\" () "
"::"
#: ../../tutorial/introduction.rst:109
msgid ""
"There is full support for floating point; operators with mixed type operands "
"convert the integer operand to floating point::"
msgstr ""
"()"
"::"
#: ../../tutorial/introduction.rst:115
msgid ""
"In interactive mode, the last printed expression is assigned to the variable "
"``_``. This means that when you are using Python as a desk calculator, it "
"is somewhat easier to continue calculations, for example::"
msgstr ""
" ``_`` "
"Python "
"::"
#: ../../tutorial/introduction.rst:128
msgid ""
"This variable should be treated as read-only by the user. Don't explicitly "
"assign a value to it --- you would create an independent local variable with "
"the same name masking the built-in variable with its magic behavior."
msgstr ""
" --- "
""
""
#: ../../tutorial/introduction.rst:132
msgid ""
"In addition to :class:`int` and :class:`float`, Python supports other types "
"of numbers, such as :class:`~decimal.Decimal` and :class:`~fractions."
"Fraction`. Python also has built-in support for :ref:`complex numbers "
"`, and uses the ``j`` or ``J`` suffix to indicate the "
"imaginary part (e.g. ``3+5j``)."
msgstr ""
":class:`int` :class:`float` Python :class:`~decimal.Decimal` "
" :class:`~fractions.Fraction` :ref:`"
" ` ``j`` "
"``J`` (: ``3+5j``)"
#: ../../tutorial/introduction.rst:142
msgid "Strings"
msgstr " (string)"
#: ../../tutorial/introduction.rst:144
msgid ""
"Besides numbers, Python can also manipulate strings, which can be expressed "
"in several ways. They can be enclosed in single quotes (``'...'``) or "
"double quotes (``\"...\"``) with the same result [#]_. ``\\`` can be used "
"to escape quotes::"
msgstr ""
"Python "
" (``'...'``) (``\"...\"``) "
"[#]_ ``\\`` "
"::"
#: ../../tutorial/introduction.rst:162
msgid ""
"In the interactive interpreter, the output string is enclosed in quotes and "
"special characters are escaped with backslashes. While this might sometimes "
"look different from the input (the enclosing quotes could change), the two "
"strings are equivalent. The string is enclosed in double quotes if the "
"string contains a single quote and no double quotes, otherwise it is "
"enclosed in single quotes. The :func:`print` function produces a more "
"readable output, by omitting the enclosing quotes and by printing escaped "
"and special characters::"
msgstr ""
""
" "
"() 2 "
""
" :func:`print` "
":func:`print` "
"::"
#: ../../tutorial/introduction.rst:182
msgid ""
"If you don't want characters prefaced by ``\\`` to be interpreted as special "
"characters, you can use *raw strings* by adding an ``r`` before the first "
"quote::"
msgstr ""
"``\\`` "
"``r`` *raw strings* ::"
#: ../../tutorial/introduction.rst:192
msgid ""
"There is one subtle aspect to raw strings: a raw string may not end in an "
"odd number of ``\\`` characters; see :ref:`the FAQ entry ` for more information and workarounds."
msgstr ""
"raw: raw``\\`` "
" :ref:`the FAQ entry ` "
#: ../../tutorial/introduction.rst:197
msgid ""
"String literals can span multiple lines. One way is using triple-quotes: "
"``\"\"\"...\"\"\"`` or ``'''...'''``. End of lines are automatically "
"included in the string, but it's possible to prevent this by adding a ``\\`` "
"at the end of the line. The following example::"
msgstr ""
"1 "
"(``\"\"\"...\"\"\"`` ``'''...'''``) "
" ``\\`` "
"::"
#: ../../tutorial/introduction.rst:208
msgid ""
"produces the following output (note that the initial newline is not "
"included):"
msgstr ""
" ("
"):"
#: ../../tutorial/introduction.rst:216
msgid ""
"Strings can be concatenated (glued together) with the ``+`` operator, and "
"repeated with ``*``::"
msgstr ""
" ``+`` () ``*`` "
"::"
#: ../../tutorial/introduction.rst:223
msgid ""
"Two or more *string literals* (i.e. the ones enclosed between quotes) next "
"to each other are automatically concatenated. ::"
msgstr ""
" ** () "
" ::"
#: ../../tutorial/introduction.rst:229
msgid ""
"This feature is particularly useful when you want to break long strings::"
msgstr "::"
#: ../../tutorial/introduction.rst:236
msgid ""
"This only works with two literals though, not with variables or expressions::"
msgstr " 2 ::"
#: ../../tutorial/introduction.rst:250
msgid ""
"If you want to concatenate variables or a variable and a literal, use ``+``::"
msgstr "``+`` ::"
#: ../../tutorial/introduction.rst:255
msgid ""
"Strings can be *indexed* (subscripted), with the first character having "
"index 0. There is no separate character type; a character is simply a string "
"of size one::"
msgstr ""
" ** () "
" 0 ; "
" 1 ::"
#: ../../tutorial/introduction.rst:265
msgid ""
"Indices may also be negative numbers, to start counting from the right::"
msgstr ""
"::"
#: ../../tutorial/introduction.rst:274
msgid "Note that since -0 is the same as 0, negative indices start from -1."
msgstr "-0 0 -1 "
#: ../../tutorial/introduction.rst:276
msgid ""
"In addition to indexing, *slicing* is also supported. While indexing is "
"used to obtain individual characters, *slicing* allows you to obtain "
"substring::"
msgstr ""
"** "
"** ::"
#: ../../tutorial/introduction.rst:284
msgid ""
"Slice indices have useful defaults; an omitted first index defaults to zero, "
"an omitted second index defaults to the size of the string being sliced. ::"
msgstr ""
"; "
"0 "
" ::"
#: ../../tutorial/introduction.rst:294
msgid ""
"Note how the start is always included, and the end always excluded. This "
"makes sure that ``s[:i] + s[i:]`` is always equal to ``s``::"
msgstr ""
" "
"``s[:i] + s[i:]`` ``s`` ::"
#: ../../tutorial/introduction.rst:302
msgid ""
"One way to remember how slices work is to think of the indices as pointing "
"*between* characters, with the left edge of the first character numbered 0. "
"Then the right edge of the last character of a string of *n* characters has "
"index *n*, for example::"
msgstr ""
" * "
"(between)* 0 "
" *n* *n* "
"::"
#: ../../tutorial/introduction.rst:313
msgid ""
"The first row of numbers gives the position of the indices 0...6 in the "
"string; the second row gives the corresponding negative indices. The slice "
"from *i* to *j* consists of all characters between the edges labeled *i* and "
"*j*, respectively."
msgstr ""
"1 0 6 ; 2"
"*i* *j* "
" *i* *j* "
#: ../../tutorial/introduction.rst:318
msgid ""
"For non-negative indices, the length of a slice is the difference of the "
"indices, if both are within bounds. For example, the length of "
"``word[1:3]`` is 2."
msgstr ""
""
" "
"``word[1:3]`` 2 "
#: ../../tutorial/introduction.rst:322
msgid "Attempting to use an index that is too large will result in an error::"
msgstr "::"
#: ../../tutorial/introduction.rst:329
msgid ""
"However, out of range slice indexes are handled gracefully when used for "
"slicing::"
msgstr ""
""
"::"
#: ../../tutorial/introduction.rst:337
msgid ""
"Python strings cannot be changed --- they are :term:`immutable`. Therefore, "
"assigning to an indexed position in the string results in an error::"
msgstr ""
"Python -- :term:` ` "
"::"
#: ../../tutorial/introduction.rst:349
msgid "If you need a different string, you should create a new one::"
msgstr "::"
#: ../../tutorial/introduction.rst:356
msgid "The built-in function :func:`len` returns the length of a string::"
msgstr " :func:`len` (length) ::"
#: ../../tutorial/introduction.rst:367
msgid ":ref:`textseq`"
msgstr ":ref:`textseq`"
#: ../../tutorial/introduction.rst:366
msgid ""
"Strings are examples of *sequence types*, and support the common operations "
"supported by such types."
msgstr ""
" ** "
""
#: ../../tutorial/introduction.rst:371
msgid ":ref:`string-methods`"
msgstr ":ref:`string-methods`"
#: ../../tutorial/introduction.rst:370
msgid ""
"Strings support a large number of methods for basic transformations and "
"searching."
msgstr ""
""
""
#: ../../tutorial/introduction.rst:374
msgid ":ref:`f-strings`"
msgstr ":ref:`f-strings`"
#: ../../tutorial/introduction.rst:374
msgid "String literals that have embedded expressions."
msgstr ""
#: ../../tutorial/introduction.rst:377
msgid ":ref:`formatstrings`"
msgstr ":ref:`formatstrings`"
#: ../../tutorial/introduction.rst:377
msgid "Information about string formatting with :meth:`str.format`."
msgstr ""
":meth:`str.format` "
#: ../../tutorial/introduction.rst:380
msgid ":ref:`old-string-formatting`"
msgstr ":ref:`old-string-formatting`"
#: ../../tutorial/introduction.rst:380
msgid ""
"The old formatting operations invoked when strings are the left operand of "
"the ``%`` operator are described in more detail here."
msgstr ""
" ``%`` "
""
#: ../../tutorial/introduction.rst:387
msgid "Lists"
msgstr " (list)"
#: ../../tutorial/introduction.rst:389
msgid ""
"Python knows a number of *compound* data types, used to group together other "
"values. The most versatile is the *list*, which can be written as a list of "
"comma-separated values (items) between square brackets. Lists might contain "
"items of different types, but usually the items all have the same type. ::"
msgstr ""
"Python * (compound)* "
" * (list)* () "
""
" ::"
#: ../../tutorial/introduction.rst:398
msgid ""
"Like strings (and all other built-in :term:`sequence` types), lists can be "
"indexed and sliced::"
msgstr ""
" ( :term:` ` ) "
"::"
#: ../../tutorial/introduction.rst:408
msgid ""
"All slice operations return a new list containing the requested elements. "
"This means that the following slice returns a :ref:`shallow copy "
"` of the list::"
msgstr ""
""
" :ref:` ` "
"::"
#: ../../tutorial/introduction.rst:415
msgid "Lists also support operations like concatenation::"
msgstr "::"
#: ../../tutorial/introduction.rst:420
msgid ""
"Unlike strings, which are :term:`immutable`, lists are a :term:`mutable` "
"type, i.e. it is possible to change their content::"
msgstr ""
":term:` ` :term:` ` "
"::"
#: ../../tutorial/introduction.rst:430
msgid ""
"You can also add new items at the end of the list, by using the :meth:`~list."
"append` *method* (we will see more about methods later)::"
msgstr ""
":meth:`~list.append` ("
")::"
#: ../../tutorial/introduction.rst:438
msgid ""
"Assignment to slices is also possible, and this can even change the size of "
"the list or clear it entirely::"
msgstr ""
""
"::"
#: ../../tutorial/introduction.rst:457
msgid "The built-in function :func:`len` also applies to lists::"
msgstr " :func:`len` ::"
#: ../../tutorial/introduction.rst:463
msgid ""
"It is possible to nest lists (create lists containing other lists), for "
"example::"
msgstr " () ::"
#: ../../tutorial/introduction.rst:479
msgid "First Steps Towards Programming"
msgstr ""
#: ../../tutorial/introduction.rst:481
msgid ""
"Of course, we can use Python for more complicated tasks than adding two and "
"two together. For instance, we can write an initial sub-sequence of the "
"`Fibonacci series `_ as "
"follows::"
msgstr ""
"2 2 Python \n"
"`Fibonacci `_ "
"::"
#: ../../tutorial/introduction.rst:501
msgid "This example introduces several new features."
msgstr ""
#: ../../tutorial/introduction.rst:503
msgid ""
"The first line contains a *multiple assignment*: the variables ``a`` and "
"``b`` simultaneously get the new values 0 and 1. On the last line this is "
"used again, demonstrating that the expressions on the right-hand side are "
"all evaluated first before any of the assignments take place. The right-"
"hand side expressions are evaluated from the left to the right."
msgstr ""
" * (multiple assignment)* : "
"``a`` ``b`` 0 1 "
""
""
#: ../../tutorial/introduction.rst:509
msgid ""
"The :keyword:`while` loop executes as long as the condition (here: ``a < "
"10``) remains true. In Python, like in C, any non-zero integer value is "
"true; zero is false. The condition may also be a string or list value, in "
"fact any sequence; anything with a non-zero length is true, empty sequences "
"are false. The test used in the example is a simple comparison. The "
"standard comparison operators are written the same as in C: ```` (greater than), ``==`` (equal to), ``=`` (greater than or equal to) and ``!=`` (not equal to)."
msgstr ""
":keyword:`while` ( `` a < 10``) "
" () Python C "
""
" 1 "
""
" C : ```` "
"() ``==`` () ``=`` ("
") ``!=`` ()"
#: ../../tutorial/introduction.rst:518
msgid ""
"The *body* of the loop is *indented*: indentation is Python's way of "
"grouping statements. At the interactive prompt, you have to type a tab or "
"space(s) for each indented line. In practice you will prepare more "
"complicated input for Python with a text editor; all decent text editors "
"have an auto-indent facility. When a compound statement is entered "
"interactively, it must be followed by a blank line to indicate completion "
"(since the parser cannot guess when you have typed the last line). Note "
"that each line within a basic block must be indented by the same amount."
msgstr ""
" * (body)* * (indent, )* : "
" Python "
" () "
""
" "
""
""
""
""
#: ../../tutorial/introduction.rst:527
msgid ""
"The :func:`print` function writes the value of the argument(s) it is given. "
"It differs from just writing the expression you want to write (as we did "
"earlier in the calculator examples) in the way it handles multiple "
"arguments, floating point quantities, and strings. Strings are printed "
"without quotes, and a space is inserted between items, so you can format "
"things nicely, like this::"
msgstr ""
":func:`print` ("
") "
":func:`print` "
"::"
#: ../../tutorial/introduction.rst:538
msgid ""
"The keyword argument *end* can be used to avoid the newline after the "
"output, or end the output with a different string::"
msgstr ""
" *end* "
"::"
#: ../../tutorial/introduction.rst:550
msgid "Footnotes"
msgstr ""
#: ../../tutorial/introduction.rst:551
msgid ""
"Since ``**`` has higher precedence than ``-``, ``-3**2`` will be interpreted "
"as ``-(3**2)`` and thus result in ``-9``. To avoid this and get ``9``, you "
"can use ``(-3)**2``."
msgstr ""
"``**`` ``-`` ``-3**2`` ``-(3**2)`` "
" ``-9`` ``9`` ``(-3)**2`` "
""
#: ../../tutorial/introduction.rst:555
msgid ""
"Unlike other languages, special characters such as ``\\n`` have the same "
"meaning with both single (``'...'``) and double (``\"...\"``) quotes. The "
"only difference between the two is that within single quotes you don't need "
"to escape ``\"`` (but you have to escape ``\\'``) and vice versa."
msgstr ""
"``\\n`` (``'...'``) "
" (``\"...\"``) "
" ``\"`` ( ``\\'`` "
") "