# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2017, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR <EMAIL@ADDRESS>, 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 <flowdas@gmail.com>\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:`정수 나눗셈 <floor division>` 으로 (소수부 "
"없이) 정수 결과를 얻으려면 ``//`` 연산자를 사용하면 됩니다; 나머지를 얻으려면 ``%`` 를 사용할 수 있습니다::"

#: ../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 <typesnumeric>`, 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:`복소수 "
"<typesnumeric>` 에 대한 지원도 내장하고 있는데, 허수부를 가리키는데 ``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:`불변 <immutable>` 이라고 합니다. 그래서 문자열의 인덱스로 참조한 "
"위치에 대입하려고 하면 에러를 일으킵니다::"

#: ../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:`시퀀스 <sequence>` 형들)처럼 리스트는 인덱싱하고 슬라이싱할 수 있습니다::"

#: ../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 "
"<shallow_vs_deep_copy>` of the list::"
msgstr ""
"모든 슬라이스 연산은 요청한 항목들을 포함하는 새 리스트를 돌려줍니다. 이는 다음과 같은 슬라이스가 리스트의 새로운 :ref:`얕은"
" 복사본 <shallow_vs_deep_copy>`\\을 돌려준다는 뜻입니다::"

#: ../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:`불변 <immutable>` 인 문자열과는 달리, 리스트는 :term:`가변 <mutable>` 입니다. 즉 내용을 "
"변경할 수 있습니다::"

#: ../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 <https://en.wikipedia.org/wiki/Fibonacci_number>`_ "
"as follows::"
msgstr ""
"물론, 2 에 2를 더하는 것보다는 더 복잡한 방법으로 파이썬을 사용할 수 있습니다. 예를 들어, 다음처럼 `피보나치 수열 "
"<https://en.wikipedia.org/wiki/Fibonacci_number>`_\\의 앞부분을 계산할 수 있습니다::"

#: ../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`` 에 동시에 값 0과1이 대입됩니다. 마지막 줄에서 다시"
" 사용되는데, 대입이 어느 하나라도 이루어지기 전에 우변의 표현식들이 모두 계산됩니다. 우변의 표현식은 왼쪽부터 오른쪽으로 가면서 "
"순서대로 계산됩니다."

#: ../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: ``<`` (less than), ``>`` (greater than), ``==`` (equal to), ``<=`` "
"(less than or 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`` 과 같은 특수 문자들은 작은따옴표(``'...'``)와 큰따옴표(``\"...\"``)에서 "
"같은 의미가 있습니다. 둘 간의 유일한 차이는 작은따옴표 안에서 ``\"`` 를 이스케이핑할 필요가 없고 (하지만 ``\\'`` 는"
" 이스케이핑 시켜야 합니다), 그 역도 성립한다는 것입니다."