# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2017, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR , 2017.
#
msgid ""
msgstr ""
"Project-Id-Version: Python 3.6\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2019-10-15 07:19+0900\n"
"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"
"Last-Translator: Dong-gweon Oh \n"
"Language-Team: Korean (https://python.flowdas.com)\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: Babel 2.7.0\n"
#: ../Doc/tutorial/introduction.rst:5
msgid "An Informal Introduction to Python"
msgstr " "
#: ../Doc/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:`...`) : "
" ; "
" . ; "
" ."
#: ../Doc/tutorial/introduction.rst:16
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 ""
" ( ) . , "
"``#``, . , ."
" . . "
" , , ."
#: ../Doc/tutorial/introduction.rst:24
msgid "Some examples::"
msgstr " ::"
#: ../Doc/tutorial/introduction.rst:35
msgid "Using Python as a Calculator"
msgstr " "
#: ../Doc/tutorial/introduction.rst:37
msgid ""
"Let's try some simple Python commands. Start the interpreter and wait "
"for the primary prompt, ``>>>``. (It shouldn't take long.)"
msgstr ""
" . , ``>>>``, . ( "
" .)"
#: ../Doc/tutorial/introduction.rst:44
msgid "Numbers"
msgstr ""
#: ../Doc/tutorial/introduction.rst:46
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 ""
" : . . ``+``, ``-``, "
"``*``, ``/`` ( , C) ; (``()``) "
" . ::"
#: ../Doc/tutorial/introduction.rst:61
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` . "
"."
#: ../Doc/tutorial/introduction.rst:65
msgid ""
"Division (``/``) always returns a float. To do :term:`floor division` "
"and get an integer result (discarding any fractional result) you can use "
"the ``//`` operator; to calculate the remainder you can use ``%``::"
msgstr ""
" (``/``) float . :term:` ` ( "
") ``//`` ; ``%`` ::"
#: ../Doc/tutorial/introduction.rst:79
msgid ""
"With Python, it is possible to use the ``**`` operator to calculate "
"powers [#]_::"
msgstr " ``**`` [#]_::"
#: ../Doc/tutorial/introduction.rst:86
msgid ""
"The equal sign (``=``) is used to assign a value to a variable. "
"Afterwards, no result is displayed before the next interactive prompt::"
msgstr " (``=``) . ::"
#: ../Doc/tutorial/introduction.rst:94
msgid ""
"If a variable is not \"defined\" (assigned a value), trying to use it "
"will give you an error::"
msgstr " \"\" ( ) ::"
#: ../Doc/tutorial/introduction.rst:102
msgid ""
"There is full support for floating point; operators with mixed type "
"operands convert the integer operand to floating point::"
msgstr " ; ::"
#: ../Doc/tutorial/introduction.rst:108
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 ""
" , ``_`` . , "
" . ::"
#: ../Doc/tutorial/introduction.rst:121
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 ""
" . --- "
" , ."
#: ../Doc/tutorial/introduction.rst:125
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` , :class:`~decimal.Decimal` "
":class:`~fractions.Fraction` . :ref:` "
"` , ``j`` ``J`` "
"( ``3+5j``)."
#: ../Doc/tutorial/introduction.rst:135
msgid "Strings"
msgstr ""
#: ../Doc/tutorial/introduction.rst:137
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 ""
" , . (``'...'``) "
"(``\"...\"``) [#]_. ``\\`` "
" ::"
#: ../Doc/tutorial/introduction.rst:155
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 ""
" , , . "
" ( ), . "
" , . :func:`print` , "
" ::"
#: ../Doc/tutorial/introduction.rst:175
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"
" string)* ::"
#: ../Doc/tutorial/introduction.rst:185
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 ""
" . : "
"``\"\"\"...\"\"\"`` ``'''...'''``. . "
"``\\`` . ::"
#: ../Doc/tutorial/introduction.rst:196
msgid ""
"produces the following output (note that the initial newline is not "
"included):"
msgstr " ( ):"
#: ../Doc/tutorial/introduction.rst:204
msgid ""
"Strings can be concatenated (glued together) with the ``+`` operator, and"
" repeated with ``*``::"
msgstr " ``+`` , ``*`` ::"
#: ../Doc/tutorial/introduction.rst:211
msgid ""
"Two or more *string literals* (i.e. the ones enclosed between quotes) "
"next to each other are automatically concatenated. ::"
msgstr " * * (, ) . ::"
#: ../Doc/tutorial/introduction.rst:217
msgid "This feature is particularly useful when you want to break long strings::"
msgstr " :"
#: ../Doc/tutorial/introduction.rst:224
msgid ""
"This only works with two literals though, not with variables or "
"expressions::"
msgstr " ::"
#: ../Doc/tutorial/introduction.rst:238
msgid ""
"If you want to concatenate variables or a variable and a literal, use "
"``+``::"
msgstr " ``+`` ::"
#: ../Doc/tutorial/introduction.rst:243
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 ::"
#: ../Doc/tutorial/introduction.rst:253
msgid "Indices may also be negative numbers, to start counting from the right::"
msgstr " , ::"
#: ../Doc/tutorial/introduction.rst:262
msgid "Note that since -0 is the same as 0, negative indices start from -1."
msgstr "-0 0 , -1 ."
#: ../Doc/tutorial/introduction.rst:264
msgid ""
"In addition to indexing, *slicing* is also supported. While indexing is "
"used to obtain individual characters, *slicing* allows you to obtain "
"substring::"
msgstr ""
" *(slicing)* . , ** "
"(substring) ::"
#: ../Doc/tutorial/introduction.rst:272
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`` ::"
#: ../Doc/tutorial/introduction.rst:280
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 , "
" . ::"
#: ../Doc/tutorial/introduction.rst:290
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 ""
" ** . "
" 0. *n* *n* , ::"
#: ../Doc/tutorial/introduction.rst:301
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 ""
" 0...6 ; . *i* *j* "
" *i* *j* ."
#: ../Doc/tutorial/introduction.rst:306
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."
#: ../Doc/tutorial/introduction.rst:310
msgid "Attempting to use an index that is too large will result in an error::"
msgstr " ::"
#: ../Doc/tutorial/introduction.rst:317
msgid ""
"However, out of range slice indexes are handled gracefully when used for "
"slicing::"
msgstr ", ::"
#: ../Doc/tutorial/introduction.rst:325
msgid ""
"Python strings cannot be changed --- they are :term:`immutable`. "
"Therefore, assigning to an indexed position in the string results in an "
"error::"
msgstr ""
" --- :term:` ` . "
" ::"
#: ../Doc/tutorial/introduction.rst:337
msgid "If you need a different string, you should create a new one::"
msgstr " , ::"
#: ../Doc/tutorial/introduction.rst:344
msgid "The built-in function :func:`len` returns the length of a string::"
msgstr " :func:`len` ::"
#: ../Doc/tutorial/introduction.rst:355
msgid ":ref:`textseq`"
msgstr ":ref:`textseq`"
#: ../Doc/tutorial/introduction.rst:354
msgid ""
"Strings are examples of *sequence types*, and support the common "
"operations supported by such types."
msgstr " * * , ."
#: ../Doc/tutorial/introduction.rst:359
msgid ":ref:`string-methods`"
msgstr ":ref:`string-methods`"
#: ../Doc/tutorial/introduction.rst:358
msgid ""
"Strings support a large number of methods for basic transformations and "
"searching."
msgstr " ."
#: ../Doc/tutorial/introduction.rst:362
msgid ":ref:`f-strings`"
msgstr ":ref:`f-strings`"
#: ../Doc/tutorial/introduction.rst:362
msgid "String literals that have embedded expressions."
msgstr " "
#: ../Doc/tutorial/introduction.rst:365
msgid ":ref:`formatstrings`"
msgstr ":ref:`formatstrings`"
#: ../Doc/tutorial/introduction.rst:365
msgid "Information about string formatting with :meth:`str.format`."
msgstr ":meth:`str.format` ."
#: ../Doc/tutorial/introduction.rst:368
msgid ":ref:`old-string-formatting`"
msgstr ":ref:`old-string-formatting`"
#: ../Doc/tutorial/introduction.rst:368
msgid ""
"The old formatting operations invoked when strings are the left operand "
"of the ``%`` operator are described in more detail here."
msgstr " ``%`` ."
#: ../Doc/tutorial/introduction.rst:375
msgid "Lists"
msgstr ""
#: ../Doc/tutorial/introduction.rst:377
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 ""
" * (compound)* . "
" ** , () . "
" , . ::"
#: ../Doc/tutorial/introduction.rst:386
msgid ""
"Like strings (and all other built-in :term:`sequence` types), lists can "
"be indexed and sliced::"
msgstr "(, :term:` ` ) ::"
#: ../Doc/tutorial/introduction.rst:396
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:`"
" `\\ ::"
#: ../Doc/tutorial/introduction.rst:403
msgid "Lists also support operations like concatenation::"
msgstr " ::"
#: ../Doc/tutorial/introduction.rst:408
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:` ` . "
" ::"
#: ../Doc/tutorial/introduction.rst:418
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` * (method)* ( ) "
" ::"
#: ../Doc/tutorial/introduction.rst:426
msgid ""
"Assignment to slices is also possible, and this can even change the size "
"of the list or clear it entirely::"
msgstr " , , ::"
#: ../Doc/tutorial/introduction.rst:445
msgid "The built-in function :func:`len` also applies to lists::"
msgstr " :func:`len` ::"
#: ../Doc/tutorial/introduction.rst:451
msgid ""
"It is possible to nest lists (create lists containing other lists), for "
"example::"
msgstr " . ( ). ::"
#: ../Doc/tutorial/introduction.rst:467
msgid "First Steps Towards Programming"
msgstr " "
#: ../Doc/tutorial/introduction.rst:469
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 . , ` "
"`_\\ ::"
#: ../Doc/tutorial/introduction.rst:489
msgid "This example introduces several new features."
msgstr " ."
#: ../Doc/tutorial/introduction.rst:491
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 ""
" * * : ``a`` ``b`` 01 . "
" , . "
" ."
#: ../Doc/tutorial/introduction.rst:497
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``) . C 0 "
" , 0 . ( ) 0 "
" , . . C "
" : ```` (), ``==`` (), ``=`` "
"( ), ``!=`` ()."
#: ../Doc/tutorial/introduction.rst:506
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)* ** . . "
" (tab) (space) . "
" ; . "
" . ( .) "
" ."
#: ../Doc/tutorial/introduction.rst:515
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` . , , ( "
" ) . , "
" . ::"
#: ../Doc/tutorial/introduction.rst:526
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* ::"
#: ../Doc/tutorial/introduction.rst:538
msgid "Footnotes"
msgstr ""
#: ../Doc/tutorial/introduction.rst:539
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`` ."
#: ../Doc/tutorial/introduction.rst:543
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`` (``'...'``) (``\"...\"``) "
" . ``\"`` ( ``\\'`` "
" ), ."