# 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: 2025-10-11 20:40+0000\n"

"PO-Revision-Date: YEAR-MO-DA HO:MI+ZONE\n"

"Last-Translator: Editorial (https://python.flowdas.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.17.0\n"

#: ../../reference/lexical_analysis.rst:6

msgid "Lexical analysis"

msgstr "어휘 분석"

#: ../../reference/lexical_analysis.rst:10

#, fuzzy

msgid ""

"A Python program is read by a *parser*. Input to the parser is a stream "

"of :term:`tokens <token>`, generated by the *lexical analyzer* (also "

"known as the *tokenizer*). This chapter describes how the lexical "

"analyzer produces these tokens."

msgstr ""

"파이썬 프로그램은 *파서(parser)* 에 의해 읽힙니다. 파서의 입력은 *어휘 분석기(lexical analyzer)* "

"(*토큰화기(tokenizer)* 라고도 합니다) 가 만들어내는 :term:`토큰 <token>` 의 스트림입니다. 이 장에서는 "

"어휘 분석기가 어떻게 파일을 토큰들로 분해하는지 설명합니다."

#: ../../reference/lexical_analysis.rst:15

msgid ""

"The lexical analyzer determines the program text's :ref:`encoding "

"<encodings>` (UTF-8 by default), and decodes the text into :ref:`source "

"characters <lexical-source-character>`. If the text cannot be decoded, a "

":exc:`SyntaxError` is raised."

msgstr ""

#: ../../reference/lexical_analysis.rst:20

msgid ""

"Next, the lexical analyzer uses the source characters to generate a "

"stream of tokens. The type of a generated token generally depends on the "

"next source character to be processed. Similarly, other special behavior "

"of the analyzer depends on the first source character that hasn't yet "

"been processed. The following table gives a quick summary of these source"

" characters, with links to sections that contain more information."

msgstr ""

#: ../../reference/lexical_analysis.rst:30

#, fuzzy

msgid "Character"

msgstr "해시 문자"

#: ../../reference/lexical_analysis.rst:31

msgid "Next token (or other relevant documentation)"

msgstr ""

#: ../../reference/lexical_analysis.rst:33

#: ../../reference/lexical_analysis.rst:266

msgid "space"

msgstr "스페이스"

#: ../../reference/lexical_analysis.rst:34

#: ../../reference/lexical_analysis.rst:266

msgid "tab"

msgstr "탭"

#: ../../reference/lexical_analysis.rst:35

msgid "formfeed"

msgstr ""

#: ../../reference/lexical_analysis.rst:36

msgid ":ref:`Whitespace <whitespace>`"

msgstr ""

#: ../../reference/lexical_analysis.rst:38

msgid "CR, LF"

msgstr ""

#: ../../reference/lexical_analysis.rst:39

#, fuzzy

msgid ":ref:`New line <line-structure>`"

msgstr "줄 구조(line structure)"

#: ../../reference/lexical_analysis.rst:40

msgid ":ref:`Indentation <indentation>`"

msgstr ""

#: ../../reference/lexical_analysis.rst:42

#, fuzzy

msgid "backslash (``\\``)"

msgstr "역 슬래시 (``\\``)"

#: ../../reference/lexical_analysis.rst:43

#, fuzzy

msgid ":ref:`Explicit line joining <explicit-joining>`"

msgstr "명시적인 줄 결합"

#: ../../reference/lexical_analysis.rst:44

msgid "(Also significant in :ref:`string escape sequences <escape-sequences>`)"

msgstr ""

#: ../../reference/lexical_analysis.rst:46

#, fuzzy

msgid "hash (``#``)"

msgstr "역 슬래시 (``\\``)"

#: ../../reference/lexical_analysis.rst:47

msgid ":ref:`Comment <comments>`"

msgstr ""

#: ../../reference/lexical_analysis.rst:49

#, fuzzy

msgid "quote (``'``, ``\"``)"

msgstr "작은따옴표 (``'``)"

#: ../../reference/lexical_analysis.rst:50

#, fuzzy

msgid ":ref:`String literal <strings>`"

msgstr "문자열 리터럴"

#: ../../reference/lexical_analysis.rst:52

msgid "ASCII letter (``a``-``z``, ``A``-``Z``)"

msgstr ""

#: ../../reference/lexical_analysis.rst:53

#, fuzzy

msgid "non-ASCII character"

msgstr "해시 문자"

#: ../../reference/lexical_analysis.rst:54

#: ../../reference/lexical_analysis.rst:58

#, fuzzy

msgid ":ref:`Name <identifiers>`"

msgstr "_, 식별자"

#: ../../reference/lexical_analysis.rst:55

msgid "Prefixed :ref:`string or bytes literal <strings>`"

msgstr ""

#: ../../reference/lexical_analysis.rst:57

#, fuzzy

msgid "underscore (``_``)"

msgstr "_ (밑줄)"

#: ../../reference/lexical_analysis.rst:59

msgid "(Can also be part of :ref:`numeric literals <numbers>`)"

msgstr ""

#: ../../reference/lexical_analysis.rst:61

msgid "number (``0``-``9``)"

msgstr ""

#: ../../reference/lexical_analysis.rst:62

#: ../../reference/lexical_analysis.rst:65

#, fuzzy

msgid ":ref:`Numeric literal <numbers>`"

msgstr "숫자 리터럴"

#: ../../reference/lexical_analysis.rst:64

#, fuzzy

msgid "dot (``.``)"

msgstr "큰따옴표 (``\"``)"

#: ../../reference/lexical_analysis.rst:66

msgid ":ref:`Operator <operators>`"

msgstr ""

#: ../../reference/lexical_analysis.rst:68

msgid "question mark (``?``)"

msgstr ""

#: ../../reference/lexical_analysis.rst:69

msgid "dollar (``$``)"

msgstr ""

#: ../../reference/lexical_analysis.rst:74

#, fuzzy

msgid "backquote (``​`​``)"

msgstr "큰따옴표 (``\"``)"

#: ../../reference/lexical_analysis.rst:75

#, fuzzy

msgid "control character"

msgstr "역 슬래시 문자"

#: ../../reference/lexical_analysis.rst:76

msgid "Error (outside string literals and comments)"

msgstr ""

#: ../../reference/lexical_analysis.rst:78

msgid "other printing character"

msgstr ""

#: ../../reference/lexical_analysis.rst:79

msgid ":ref:`Operator or delimiter <operators>`"

msgstr ""

#: ../../reference/lexical_analysis.rst:81

msgid "end of file"

msgstr ""

#: ../../reference/lexical_analysis.rst:82

msgid ":ref:`End marker <endmarker-token>`"

msgstr ""

#: ../../reference/lexical_analysis.rst:88

msgid "Line structure"

msgstr "줄 구조(Line structure)"

#: ../../reference/lexical_analysis.rst:92

msgid "A Python program is divided into a number of *logical lines*."

msgstr "파이썬 프로그램은 여러 개의 *논리적인 줄(logical lines)* 들로 나뉩니다."

#: ../../reference/lexical_analysis.rst:98

msgid "Logical lines"

msgstr "논리적인 줄"

#: ../../reference/lexical_analysis.rst:102

#, fuzzy

msgid ""

"The end of a logical line is represented by the token "

":data:`~token.NEWLINE`. Statements cannot cross logical line boundaries "

"except where :data:`!NEWLINE` is allowed by the syntax (e.g., between "

"statements in compound statements). A logical line is constructed from "

"one or more *physical lines* by following the :ref:`explicit <explicit-"

"joining>` or :ref:`implicit <implicit-joining>` *line joining* rules."

msgstr ""

"논리적인 줄의 끝은 NEWLINE 토큰으로 표현됩니다. 문법이 허락하지 않는 이상 (예를 들어 복합문에서 문장들 사이) 문장은 "

"논리적인 줄 간의 경계를 가로지를 수 없습니다. 논리적인 줄은 명시적이거나 묵시적인 *줄 결합(line joining)* 규칙에 "

"따라 하나 이상의 *물리적인 줄(physical lines)* 들로 구성됩니다."

#: ../../reference/lexical_analysis.rst:113

msgid "Physical lines"

msgstr "물리적인 줄"

#: ../../reference/lexical_analysis.rst:115

msgid ""

"A physical line is a sequence of characters terminated by one the "

"following end-of-line sequences:"

msgstr ""

#: ../../reference/lexical_analysis.rst:118

msgid "the Unix form using ASCII LF (linefeed),"

msgstr ""

#: ../../reference/lexical_analysis.rst:119

msgid ""

"the Windows form using the ASCII sequence CR LF (return followed by "

"linefeed),"

msgstr ""

#: ../../reference/lexical_analysis.rst:120

msgid "the '`Classic Mac OS`__' form using the ASCII CR (return) character."

msgstr ""

#: ../../reference/lexical_analysis.rst:124

msgid ""

"Regardless of platform, each of these sequences is replaced by a single "

"ASCII LF (linefeed) character. (This is done even inside :ref:`string "

"literals <strings>`.) Each line can use any of the sequences; they do not"

" need to be consistent within a file."

msgstr ""

#: ../../reference/lexical_analysis.rst:130

msgid ""

"The end of input also serves as an implicit terminator for the final "

"physical line."

msgstr ""

#: ../../reference/lexical_analysis.rst:133

msgid "Formally:"

msgstr ""

#: ../../reference/lexical_analysis.rst:144

msgid "Comments"

msgstr "주석"

#: ../../reference/lexical_analysis.rst:149

msgid ""

"A comment starts with a hash character (``#``) that is not part of a "

"string literal, and ends at the end of the physical line. A comment "

"signifies the end of the logical line unless the implicit line joining "

"rules are invoked. Comments are ignored by the syntax."

msgstr ""

"주석은 문자열 리터럴에 포함되지 않는 해시 문자(``#``)로 시작하고 물리적인 줄의 끝에서 끝납니다. 묵시적인 줄 결합 규칙이 "

"유효하지 않은 이상, 주석은 논리적인 줄을 종료시킵니다. 주석은 문법이 무시합니다."

#: ../../reference/lexical_analysis.rst:158

msgid "Encoding declarations"

msgstr "인코딩 선언"

#: ../../reference/lexical_analysis.rst:163

msgid ""

"If a comment in the first or second line of the Python script matches the"

" regular expression ``coding[=:]\\s*([-\\w.]+)``, this comment is "

"processed as an encoding declaration; the first group of this expression "

"names the encoding of the source code file. The encoding declaration must"

" appear on a line of its own. If it is the second line, the first line "

"must also be a comment-only line. The recommended forms of an encoding "

"expression are ::"

msgstr ""

"파이썬 스크립트의 첫 번 째나 두 번째 줄에 있는 주석이 정규식 ``coding[=:]\\s*([-\\w.]+)`` 과 매치되면, "

"이 주석은 인코딩 선언으로 처리됩니다. 이 정규식의 첫 번째 그룹은 소스 코드 파일의 인코딩 이름을 지정합니다. 인코딩 선언은 줄 "

"전체에 홀로 나와야 합니다. 만약 두 번째 줄이라면, 첫 번째 줄 역시 주석만 있어야 합니다. 인코딩 선언의 권장 형태는 두 "

"개입니다. 하나는 ::"

#: ../../reference/lexical_analysis.rst:170

msgid "# -*- coding: <encoding-name> -*-"

msgstr "# -*- coding: <encoding-name> -*-"

#: ../../reference/lexical_analysis.rst:172

msgid "which is recognized also by GNU Emacs, and ::"

msgstr "인데 GNU Emacs에서도 인식됩니다. 다른 하나는 ::"

#: ../../reference/lexical_analysis.rst:174

msgid "# vim:fileencoding=<encoding-name>"

msgstr "# vim:fileencoding=<encoding-name>"

#: ../../reference/lexical_analysis.rst:176

msgid "which is recognized by Bram Moolenaar's VIM."

msgstr "인데 Bram Moolenaar 의 VIM에서 인식됩니다."

#: ../../reference/lexical_analysis.rst:178

#, fuzzy

msgid ""

"If no encoding declaration is found, the default encoding is UTF-8. If "

"the implicit or explicit encoding of a file is UTF-8, an initial UTF-8 "

"byte-order mark (``b'\\xef\\xbb\\xbf'``) is ignored rather than being a "

"syntax error."

msgstr ""

"인코딩 선언이 발견되지 않으면 기본 인코딩은 UTF-8입니다. 파일의 묵시적 또는 명시적 인코딩이 UTF-8이면, 초기 바이트 순서"

" 표시자(b'\\xef\\xbb\\xbf')는 문법 에러로 처리되지 않고 무시됩니다."

#: ../../reference/lexical_analysis.rst:182

msgid ""

"If an encoding is declared, the encoding name must be recognized by "

"Python (see :ref:`standard-encodings`). The encoding is used for all "

"lexical analysis, including string literals, comments and identifiers."

msgstr ""

"인코딩이 선언되면, 인코딩 이름은 파이썬이 인식할 수 있어야 합니다 (:ref:`standard-encodings`\\를 "

"참조하세요). 인코딩은 문자열 리터럴, 주석, 식별자를 포함한 모든 어휘 분석에서 모두 사용됩니다."

#: ../../reference/lexical_analysis.rst:189

msgid ""

"All lexical analysis, including string literals, comments and "

"identifiers, works on Unicode text decoded using the source encoding. Any"

" Unicode code point, except the NUL control character, can appear in "

"Python source."

msgstr ""

#: ../../reference/lexical_analysis.rst:203

msgid "Explicit line joining"

msgstr "명시적인 줄 결합"

#: ../../reference/lexical_analysis.rst:207

msgid ""

"Two or more physical lines may be joined into logical lines using "

"backslash characters (``\\``), as follows: when a physical line ends in a"

" backslash that is not part of a string literal or comment, it is joined "

"with the following forming a single logical line, deleting the backslash "

"and the following end-of-line character. For example::"

msgstr ""

"둘 이상의 물리적인 줄은 역 슬래시 문자(``\\``)를 사용해서 논리적인 줄로 결합할 수 있습니다: 물리적인 줄이 문자열 "

"리터럴이나 주석의 일부가 아닌 역 슬래시 문자로 끝나면, 역 슬래시와 뒤따르는 개행 문자가 제거된 채로, 현재 만들어지고 있는 "

"논리적인 줄에 합쳐집니다. 예를 들어::"

#: ../../reference/lexical_analysis.rst:213

msgid ""

"if 1900 < year < 2100 and 1 <= month <= 12 \\\n"

" and 1 <= day <= 31 and 0 <= hour < 24 \\\n"

" and 0 <= minute < 60 and 0 <= second < 60: # Looks like a valid date"

"\n"

" return 1"

msgstr ""

"if 1900 < year < 2100 and 1 <= month <= 12 \\\n"

" and 1 <= day <= 31 and 0 <= hour < 24 \\\n"

" and 0 <= minute < 60 and 0 <= second < 60: # 유효한 날짜처럼 보입니다\n"

" return 1"

#: ../../reference/lexical_analysis.rst:218

msgid ""

"A line ending in a backslash cannot carry a comment. A backslash does "

"not continue a comment. A backslash does not continue a token except for"

" string literals (i.e., tokens other than string literals cannot be split"

" across physical lines using a backslash). A backslash is illegal "

"elsewhere on a line outside a string literal."

msgstr ""

"역 슬래시로 끝나는 줄은 주석이 포함될 수 없습니다. 역 슬래시는 주석을 결합하지 못합니다. 역 슬래시는 문자열 리터럴을 제외한 "

"어떤 토큰도 결합하지 못합니다 (즉, 문자열 리터럴 이외의 어떤 토큰도 역 슬래시를 사용해서 두 줄에 나누어 기록할 수 "

"없습니다.). 문자열 리터럴 밖에 있는 역 슬래시가 앞에서 언급한 장소 이외의 곳에 등장하는 것은 문법에 어긋납니다."

#: ../../reference/lexical_analysis.rst:228

msgid "Implicit line joining"

msgstr "묵시적인 줄 결합"

#: ../../reference/lexical_analysis.rst:230

msgid ""

"Expressions in parentheses, square brackets or curly braces can be split "

"over more than one physical line without using backslashes. For example::"

msgstr ""

"괄호(``()``), 대괄호(``[]``), 중괄호(``{}``)가 사용되는 표현은 역 슬래시 없이도 여러 개의 물리적인 줄로 나눌"

" 수 있습니다. 예를 들어::"

#: ../../reference/lexical_analysis.rst:233

msgid ""

"month_names = ['Januari', 'Februari', 'Maart', # These are the\n"

" 'April', 'Mei', 'Juni', # Dutch names\n"

" 'Juli', 'Augustus', 'September', # for the months\n"

" 'Oktober', 'November', 'December'] # of the year"

msgstr ""

"month_names = ['Januari', 'Februari', 'Maart', # 이것들은\n"

" 'April', 'Mei', 'Juni', # 일년을 이루는\n"

" 'Juli', 'Augustus', 'September', # 달들의\n"

" 'Oktober', 'November', 'December'] # 네덜란드 이름입니다"

#: ../../reference/lexical_analysis.rst:238

msgid ""

"Implicitly continued lines can carry comments. The indentation of the "

"continuation lines is not important. Blank continuation lines are "

"allowed. There is no NEWLINE token between implicit continuation lines. "

"Implicitly continued lines can also occur within triple-quoted strings "

"(see below); in that case they cannot carry comments."

msgstr ""

"묵시적으로 이어지는 줄들은 주석을 포함할 수 있습니다. 이어지는 줄들의 들여쓰기는 중요하지 않습니다. 중간에 빈 줄이 들어가도 "

"됩니다. 묵시적으로 줄 결합하는 줄 들 간에는 NEWLINE 토큰이 만들어지지 않습니다. 묵시적으로 이어지는 줄들은 삼중 따옴표 된"

" 문자열들에서도 등장할 수 있는데 (아래를 보라), 이 경우는 주석이 포함될 수 없습니다."

#: ../../reference/lexical_analysis.rst:248

msgid "Blank lines"

msgstr "빈 줄"

#: ../../reference/lexical_analysis.rst:252

#, fuzzy

msgid ""

"A logical line that contains only spaces, tabs, formfeeds and possibly a "

"comment, is ignored (i.e., no :data:`~token.NEWLINE` token is generated)."

" During interactive input of statements, handling of a blank line may "

"differ depending on the implementation of the read-eval-print loop. In "

"the standard interactive interpreter, an entirely blank logical line "

"(that is, one containing not even whitespace or a comment) terminates a "

"multi-line statement."

msgstr ""

"스페이스, 탭, 폼 피드(formfeed) 와 주석만으로 구성된 논리적인 줄은 무시됩니다. (즉 NEWLINE 토큰이 만들어지지 "

"않습니다.) 대화형으로 문장이 입력되는 도중에는 빈 줄의 처리가 REPL 구현에 따라 달라질 수 있습니다. 표준 대화형 "

"인터프리터에서는, 완전히 빈 줄(즉 공백이나 주석조차 없는 것)은 다중 행 문장을 종료시킵니다."

#: ../../reference/lexical_analysis.rst:264

msgid "Indentation"

msgstr "들여쓰기"

#: ../../reference/lexical_analysis.rst:268

msgid ""

"Leading whitespace (spaces and tabs) at the beginning of a logical line "

"is used to compute the indentation level of the line, which in turn is "

"used to determine the grouping of statements."

msgstr ""

"논리적인 줄의 제일 앞에 오는 공백(스페이스와 탭)은 줄의 들여쓰기 수준을 계산하는 데 사용되고, 이는 다시 문장들의 묶음을 "

"결정하는 데 사용되게 됩니다."

#: ../../reference/lexical_analysis.rst:272

msgid ""

"Tabs are replaced (from left to right) by one to eight spaces such that "

"the total number of characters up to and including the replacement is a "

"multiple of eight (this is intended to be the same rule as used by Unix)."

" The total number of spaces preceding the first non-blank character then"

" determines the line's indentation. Indentation cannot be split over "

"multiple physical lines using backslashes; the whitespace up to the first"

" backslash determines the indentation."

msgstr ""

"탭은 (왼쪽에서 오른쪽으로) 1~8개의 스페이스로 변환되는데, 치환된 후의 총 스페이스 문자 수가 8의 배수가 되도록 맞춥니다. "

"(유닉스에서 사용되는 규칙에 맞추려는 것입니다.) 첫 번째 비 공백 문자 앞에 나오는 공백의 총수가 줄의 들여쓰기를 결정합니다. "

"들여쓰기는 역 슬래시를 사용해서 여러 개의 물리적인 줄로 나눠질 수 없습니다; 첫 번째 역 슬래시 이전의 공백이 들여쓰기를 "

"결정합니다."

#: ../../reference/lexical_analysis.rst:280

msgid ""

"Indentation is rejected as inconsistent if a source file mixes tabs and "

"spaces in a way that makes the meaning dependent on the worth of a tab in"

" spaces; a :exc:`TabError` is raised in that case."

msgstr ""

"소스 파일이 탭과 스페이스를 섞어 쓰는 경우, 탭이 몇 개의 스페이스에 해당하는지에 따라 다르게 해석될 수 있으면 "

":exc:`TabError` 를 일으킵니다."

#: ../../reference/lexical_analysis.rst:284

msgid ""

"**Cross-platform compatibility note:** because of the nature of text "

"editors on non-UNIX platforms, it is unwise to use a mixture of spaces "

"and tabs for the indentation in a single source file. It should also be "

"noted that different platforms may explicitly limit the maximum "

"indentation level."

msgstr ""

"**크로스-플랫폼 호환성 유의 사항:** UNIX 이외의 플랫폼에서 편집기들이 동작하는 방식 때문에, 하나의 파일 내에서 들여쓰기를"

" 위해 탭과 스페이스를 섞어 쓰는 것은 현명한 선택이 아닙니다. 다른 플랫폼들에서는 최대 들여쓰기 수준에 제한이 있을 수도 있다는 "

"점도 주의해야 합니다."

#: ../../reference/lexical_analysis.rst:289

msgid ""

"A formfeed character may be present at the start of the line; it will be "

"ignored for the indentation calculations above. Formfeed characters "

"occurring elsewhere in the leading whitespace have an undefined effect "

"(for instance, they may reset the space count to zero)."

msgstr ""

"폼 피드 문자는 줄의 처음에 나올 수 있습니다; 앞서 설명한 들여쓰기 수준 계산에서는 무시됩니다. 선행 공백의 다른 곳에 등장하는 "

"폼 피드 문자는 정의되지 않은 효과를 줍니다 (가령, 스페이스 수가 0으로 초기화될 수 있습니다)."

#: ../../reference/lexical_analysis.rst:296

#, fuzzy

msgid ""

"The indentation levels of consecutive lines are used to generate "

":data:`~token.INDENT` and :data:`~token.DEDENT` tokens, using a stack, as"

" follows."

msgstr "연속된 줄의 들여쓰기 수준은, 스택을 사용해서, 다음과 같은 방법으로 INDENT와 DEDENT 토큰을 만드는 데 사용됩니다."

#: ../../reference/lexical_analysis.rst:300

#, fuzzy

msgid ""

"Before the first line of the file is read, a single zero is pushed on the"

" stack; this will never be popped off again. The numbers pushed on the "

"stack will always be strictly increasing from bottom to top. At the "

"beginning of each logical line, the line's indentation level is compared "

"to the top of the stack. If it is equal, nothing happens. If it is "

"larger, it is pushed on the stack, and one :data:`!INDENT` token is "

"generated. If it is smaller, it *must* be one of the numbers occurring "

"on the stack; all numbers on the stack that are larger are popped off, "

"and for each number popped off a :data:`!DEDENT` token is generated. At "

"the end of the file, a :data:`!DEDENT` token is generated for each number"

" remaining on the stack that is larger than zero."

msgstr ""

"파일의 첫 줄을 읽기 전에 0하나를 스택에 넣습니다(push); 이 값은 다시 꺼내는(pop) 일이 없습니다. 스택에 넣는 값은 "

"항상 스택의 아래에서 위로 올라갈 때 단조 증가합니다. 각 논리적인 줄의 처음에서 줄의 들여쓰기 수준이 스택의 가장 위에 있는 값과"

" 비교됩니다. 같다면 아무런 일도 일어나지 않습니다. 더 크다면 그 값을 스택에 넣고 하나의 INDENT 토큰을 만듭니다. 더 "

"작다면 이 값은 스택에 있는 값 중 하나여야만 합니다. 이 값보다 큰 모든 스택의 값들을 꺼내고(pop), 꺼낸 횟수만큼의 "

"DEDENT 토큰을 만듭니다. 파일의 끝에서, 스택에 남아있는 0보다 큰 값의 개수만큼 DEDENT 토큰을 만듭니다."

#: ../../reference/lexical_analysis.rst:311

msgid ""

"Here is an example of a correctly (though confusingly) indented piece of "

"Python code::"

msgstr "여기에 (혼란스럽다 할지라도) 올바르게 들여쓰기 된 파이썬 코드 조각이 있습니다::"

#: ../../reference/lexical_analysis.rst:314

msgid ""

"def perm(l):\n"

" # Compute the list of all permutations of l\n"

" if len(l) <= 1:\n"

" return [l]\n"

" r = []\n"

" for i in range(len(l)):\n"

" s = l[:i] + l[i+1:]\n"

" p = perm(s)\n"

" for x in p:\n"

" r.append(l[i:i+1] + x)\n"

" return r"

msgstr ""

"def perm(l):\n"

" # l 의 모든 순열의 리스트를 계산합니다\n"

" if len(l) <= 1:\n"

" return [l]\n"

" r = []\n"

" for i in range(len(l)):\n"

" s = l[:i] + l[i+1:]\n"

" p = perm(s)\n"

" for x in p:\n"

" r.append(l[i:i+1] + x)\n"

" return r"

#: ../../reference/lexical_analysis.rst:326

msgid "The following example shows various indentation errors::"

msgstr "다음 예는 여러 가지 들여쓰기 에러를 보여줍니다::"

#: ../../reference/lexical_analysis.rst:328

msgid ""

" def perm(l): # error: first line indented\n"

"for i in range(len(l)): # error: not indented\n"

" s = l[:i] + l[i+1:]\n"

" p = perm(l[:i] + l[i+1:]) # error: unexpected indent\n"

" for x in p:\n"

" r.append(l[i:i+1] + x)\n"

" return r # error: inconsistent dedent"

msgstr ""

"def perm(l): # 에러: 첫 줄을 들여쓰기 했습니다\n"

"for i in range(len(l)): # 에러: 들여쓰지 않았습니다\n"

" s = l[:i] + l[i+1:]\n"

" p = perm(l[:i] + l[i+1:]) # 에러: 예기치 않은 들여쓰기\n"

" for x in p:\n"

" r.append(l[i:i+1] + x)\n"

" return r # 에러: 일관성 없는 내어쓰기"

#: ../../reference/lexical_analysis.rst:336

msgid ""

"(Actually, the first three errors are detected by the parser; only the "

"last error is found by the lexical analyzer --- the indentation of "

"``return r`` does not match a level popped off the stack.)"

msgstr ""

"(사실, 처음 세 개의 에러는 파서가 감지합니다. 단지 마지막 에러만 어휘 분석기가 감지합니다. --- ``return r`` 의 "

"들여쓰기가 스택에 있는 값과 일치하지 않습니다.)"

#: ../../reference/lexical_analysis.rst:344

msgid "Whitespace between tokens"

msgstr "토큰 사이의 공백"

#: ../../reference/lexical_analysis.rst:346

#, fuzzy

msgid ""

"Except at the beginning of a logical line or in string literals, the "

"whitespace characters space, tab and formfeed can be used interchangeably"

" to separate tokens. Whitespace is needed between two tokens only if "

"their concatenation could otherwise be interpreted as a different token. "

"For example, ``ab`` is one token, but ``a b`` is two tokens. However, "

"``+a`` and ``+ a`` both produce two tokens, ``+`` and ``a``, as ``+a`` is"

" not a valid token."

msgstr ""

"논리적인 줄의 처음과 문자열 리터럴을 제외하고, 공백 문자인 스페이스, 탭, 폼 피드는 토큰을 분리하기 위해 섞어 쓸 수 있습니다."

" 두 토큰을 붙여 쓸 때 다른 토큰으로 해석될 수 있는 경우만 토큰 사이에 공백이 필요합니다. (예를 들어, ab 는 하나의 "

"토큰이지만, a b 는 두 개의 토큰입니다.)"

#: ../../reference/lexical_analysis.rst:357

msgid "End marker"

msgstr ""

#: ../../reference/lexical_analysis.rst:359

msgid ""

"At the end of non-interactive input, the lexical analyzer generates an "

":data:`~token.ENDMARKER` token."

msgstr ""

#: ../../reference/lexical_analysis.rst:366

msgid "Other tokens"

msgstr "다른 토큰들"

#: ../../reference/lexical_analysis.rst:368

#, fuzzy

msgid ""

"Besides :data:`~token.NEWLINE`, :data:`~token.INDENT` and "

":data:`~token.DEDENT`, the following categories of tokens exist: "

"*identifiers* and *keywords* (:data:`~token.NAME`), *literals* (such as "

":data:`~token.NUMBER` and :data:`~token.STRING`), and other symbols "

"(*operators* and *delimiters*, :data:`~token.OP`). Whitespace characters "

"(other than logical line terminators, discussed earlier) are not tokens, "

"but serve to delimit tokens. Where ambiguity exists, a token comprises "

"the longest possible string that forms a legal token, when read from left"

" to right."

msgstr ""

"NEWLINE, INDENT, DEDENT 와는 별도로, 다음과 같은 유형의 토큰들이 존재합니다: *식별자(identifier)*,"

" *키워드(keyword)*, *리터럴(literal)*, *연산자(operator)*, *구분자(delimiter)*. (앞에서 "

"살펴본 줄 종료 이외의) 공백 문자들은 토큰이 아니지만, 토큰을 분리하는 역할을 담당합니다. 모호할 경우, 왼쪽에서 오른쪽으로 읽을"

" 때, 하나의 토큰은 올바르고 가능한 한 최대 길이의 문자열로 구성되는 것을 선호합니다."

#: ../../reference/lexical_analysis.rst:382

#, fuzzy

msgid "Names (identifiers and keywords)"

msgstr "식별자와 키워드"

#: ../../reference/lexical_analysis.rst:386

msgid ""

":data:`~token.NAME` tokens represent *identifiers*, *keywords*, and *soft"

" keywords*."

msgstr ""

#: ../../reference/lexical_analysis.rst:389

#, fuzzy

msgid ""

"Within the ASCII range (U+0001..U+007F), the valid characters for names "

"include the uppercase and lowercase letters (``A-Z`` and ``a-z``), the "

"underscore ``_`` and, except for the first character, the digits ``0`` "

"through ``9``."

msgstr ""

"ASCII 범위 (U+0001..U+007F) 내에서, 올바른 식별자 문자에는 ``A`` 에서 ``Z`` 범위의 대문자와 소문자, "

"밑줄 ``_``, 첫 문자를 제외하고, 숫자 ``0`` 에서 ``9``\\까지가 포함됩니다. 파이썬 3.0은 ASCII 범위 밖의 "

"문자들을 도입합니다 (:pep:`3131` 참조). 이 문자들의 경우, :mod:`unicodedata` 모듈에 포함된 버전의 "

"유니코드 문자 데이터베이스에 따라 분류됩니다."

#: ../../reference/lexical_analysis.rst:394

msgid ""

"Names must contain at least one character, but have no upper length "

"limit. Case is significant."

msgstr ""

#: ../../reference/lexical_analysis.rst:397

msgid ""

"Besides ``A-Z``, ``a-z``, ``_`` and ``0-9``, names can also use \"letter-"

"like\" and \"number-like\" characters from outside the ASCII range, as "

"detailed below."

msgstr ""

#: ../../reference/lexical_analysis.rst:400

#, fuzzy

msgid ""

"All identifiers are converted into the `normalization form`_ NFKC while "

"parsing; comparison of identifiers is based on NFKC."

msgstr "모든 식별자는 파서에 의해 NFKC 정규화 형식으로 변환되고, 식별자의 비교는 NFKC 에 기반을 둡니다."

#: ../../reference/lexical_analysis.rst:403

msgid ""

"Formally, the first character of a normalized identifier must belong to "

"the set ``id_start``, which is the union of:"

msgstr ""

#: ../../reference/lexical_analysis.rst:406

msgid "Unicode category ``<Lu>`` - uppercase letters (includes ``A`` to ``Z``)"

msgstr ""

#: ../../reference/lexical_analysis.rst:407

msgid "Unicode category ``<Ll>`` - lowercase letters (includes ``a`` to ``z``)"

msgstr ""

#: ../../reference/lexical_analysis.rst:408

#, fuzzy

msgid "Unicode category ``<Lt>`` - titlecase letters"

msgstr "*Lt* - titlecase letters"

#: ../../reference/lexical_analysis.rst:409

#, fuzzy

msgid "Unicode category ``<Lm>`` - modifier letters"

msgstr "*Lm* - modifier letters"

#: ../../reference/lexical_analysis.rst:410

msgid "Unicode category ``<Lo>`` - other letters"

msgstr ""

#: ../../reference/lexical_analysis.rst:411

#, fuzzy

msgid "Unicode category ``<Nl>`` - letter numbers"

msgstr "*Nl* - letter numbers"

#: ../../reference/lexical_analysis.rst:412

#, fuzzy, python-brace-format

msgid "{``\"_\"``} - the underscore"

msgstr "_ (밑줄)"

#: ../../reference/lexical_analysis.rst:413

#, fuzzy

msgid ""

"``<Other_ID_Start>`` - an explicit set of characters in `PropList.txt`_ "

"to support backwards compatibility"

msgstr ""

"*Other_ID_Start* - 하위 호환성 지원을 위해 `PropList.txt "

"<https://www.unicode.org/Public/15.1.0/ucd/PropList.txt>`_ 에서 명시적으로 나열된 "

"문자들"

#: ../../reference/lexical_analysis.rst:416

msgid ""

"The remaining characters must belong to the set ``id_continue``, which is"

" the union of:"

msgstr ""

#: ../../reference/lexical_analysis.rst:419

msgid "all characters in ``id_start``"

msgstr ""

#: ../../reference/lexical_analysis.rst:420

msgid "Unicode category ``<Nd>`` - decimal numbers (includes ``0`` to ``9``)"

msgstr ""

#: ../../reference/lexical_analysis.rst:421

#, fuzzy

msgid "Unicode category ``<Pc>`` - connector punctuations"

msgstr "*Pc* - connector punctuations"

#: ../../reference/lexical_analysis.rst:422

#, fuzzy

msgid "Unicode category ``<Mn>`` - nonspacing marks"

msgstr "*Mn* - nonspacing marks"

#: ../../reference/lexical_analysis.rst:423

#, fuzzy

msgid "Unicode category ``<Mc>`` - spacing combining marks"

msgstr "*Mc* - spacing combining marks"

#: ../../reference/lexical_analysis.rst:424

#, fuzzy

msgid ""

"``<Other_ID_Continue>`` - another explicit set of characters in "

"`PropList.txt`_ to support backwards compatibility"

msgstr ""

"*Other_ID_Start* - 하위 호환성 지원을 위해 `PropList.txt "

"<https://www.unicode.org/Public/15.1.0/ucd/PropList.txt>`_ 에서 명시적으로 나열된 "

"문자들"

#: ../../reference/lexical_analysis.rst:427

msgid ""

"Unicode categories use the version of the Unicode Character Database as "

"included in the :mod:`unicodedata` module."

msgstr ""

#: ../../reference/lexical_analysis.rst:430

#, fuzzy

msgid ""

"These sets are based on the Unicode standard annex `UAX-31`_. See also "

":pep:`3131` for further details."

msgstr ""

"파이썬에서 식별자의 문법은 유니코드 표준 부속서 UAX-31 에 기반을 두는데, 여기에 덧붙이거나 바꾼 내용은 아래에서 정의합니다."

" 좀 더 상세한 내용은 :pep:`3131` 에서 찾을 수 있습니다."

#: ../../reference/lexical_analysis.rst:433

#, fuzzy

msgid ""

"Even more formally, names are described by the following lexical "

"definitions:"

msgstr "문자열 리터럴은 다음과 같은 어휘 정의로 기술됩니다:"

#: ../../reference/lexical_analysis.rst:447

msgid ""

"A non-normative listing of all valid identifier characters as defined by "

"Unicode is available in the `DerivedCoreProperties.txt`_ file in the "

"Unicode Character Database."

msgstr ""

#: ../../reference/lexical_analysis.rst:461

msgid "Keywords"

msgstr "키워드"

#: ../../reference/lexical_analysis.rst:467

#, fuzzy

msgid ""

"The following names are used as reserved words, or *keywords* of the "

"language, and cannot be used as ordinary identifiers. They must be "

"spelled exactly as written here:"

msgstr ""

"다음 식별자들은 예약어, 또는 언어의 키워드, 로 사용되고, 일반적인 식별자로 사용될 수 없습니다. 여기 쓰여 있는 것과 정확히 "

"같게 사용되어야 합니다:"

#: ../../reference/lexical_analysis.rst:471

msgid ""

"False await else import pass\n"

"None break except in raise\n"

"True class finally is return\n"

"and continue for lambda try\n"

"as def from nonlocal while\n"

"assert del global not with\n"

"async elif if or yield"

msgstr ""

"False await else import pass\n"

"None break except in raise\n"

"True class finally is return\n"

"and continue for lambda try\n"

"as def from nonlocal while\n"

"assert del global not with\n"

"async elif if or yield"

#: ../../reference/lexical_analysis.rst:485

msgid "Soft Keywords"

msgstr "소프트 키워드"

#: ../../reference/lexical_analysis.rst:491

msgid ""

"Some names are only reserved under specific contexts. These are known as "

"*soft keywords*:"

msgstr ""

#: ../../reference/lexical_analysis.rst:494

msgid ""

"``match``, ``case``, and ``_``, when used in the :keyword:`match` "

"statement."

msgstr ""

#: ../../reference/lexical_analysis.rst:495

msgid "``type``, when used in the :keyword:`type` statement."

msgstr ""

#: ../../reference/lexical_analysis.rst:497

msgid ""

"These syntactically act as keywords in their specific contexts, but this "

"distinction is done at the parser level, not when tokenizing."

msgstr ""

#: ../../reference/lexical_analysis.rst:500

msgid ""

"As soft keywords, their use in the grammar is possible while still "

"preserving compatibility with existing code that uses these names as "

"identifier names."

msgstr ""

#: ../../reference/lexical_analysis.rst:504

msgid "``type`` is now a soft keyword."

msgstr ""

#: ../../reference/lexical_analysis.rst:513

msgid "Reserved classes of identifiers"

msgstr "식별자의 예약 영역"

#: ../../reference/lexical_analysis.rst:515

msgid ""

"Certain classes of identifiers (besides keywords) have special meanings."

" These classes are identified by the patterns of leading and trailing "

"underscore characters:"

msgstr ""

"(키워드와는 별개로) 어떤 부류의 식별자들은 특별한 의미가 있습니다. 이 부류의 식별자들은 시작과 끝의 밑줄 문자 패턴으로 "

"구분됩니다:"

#: ../../reference/lexical_analysis.rst:519

msgid "``_*``"

msgstr "``_*``"

#: ../../reference/lexical_analysis.rst:520

msgid "Not imported by ``from module import *``."

msgstr "``from module import *`` 에 의해 임포트되지 않습니다."

#: ../../reference/lexical_analysis.rst:522

msgid "``_``"

msgstr "``_``"

#: ../../reference/lexical_analysis.rst:523

msgid ""

"In a ``case`` pattern within a :keyword:`match` statement, ``_`` is a "

":ref:`soft keyword <soft-keywords>` that denotes a :ref:`wildcard "

"<wildcard-patterns>`."

msgstr ""

#: ../../reference/lexical_analysis.rst:527

msgid ""

"Separately, the interactive interpreter makes the result of the last "

"evaluation available in the variable ``_``. (It is stored in the "

":mod:`builtins` module, alongside built-in functions like ``print``.)"

msgstr ""

"한편, 대화형 인터프리터는 마지막 평가 결과물을 변수 ``_``\\에 저장합니다. (``print`` 와 같은 내장 함수와 함께, "

":mod:`builtins` 모듈에 저장됩니다.)"

#: ../../reference/lexical_analysis.rst:532

msgid ""

"Elsewhere, ``_`` is a regular identifier. It is often used to name "

"\"special\" items, but it is not special to Python itself."

msgstr ""

#: ../../reference/lexical_analysis.rst:537

msgid ""

"The name ``_`` is often used in conjunction with internationalization; "

"refer to the documentation for the :mod:`gettext` module for more "

"information on this convention."

msgstr ""

"이름 ``_`` 은 종종 국제화(internationalization)와 관련되어 사용됩니다. 이 관례에 관해서는 "

":mod:`gettext` 모듈의 문서를 참조하십시오."

#: ../../reference/lexical_analysis.rst:541

msgid "It is also commonly used for unused variables."

msgstr ""

#: ../../reference/lexical_analysis.rst:543

msgid "``__*__``"

msgstr "``__*__``"

#: ../../reference/lexical_analysis.rst:544

msgid ""

"System-defined names, informally known as \"dunder\" names. These names "

"are defined by the interpreter and its implementation (including the "

"standard library). Current system names are discussed in the "

":ref:`specialnames` section and elsewhere. More will likely be defined in"

" future versions of Python. *Any* use of ``__*__`` names, in any "

"context, that does not follow explicitly documented use, is subject to "

"breakage without warning."

msgstr ""

"시스템 정의 이름, 비공식적으로 \"던더(dunder)\" 이름이라고 알려졌습니다. 이 이름들은 인터프리터와 그 구현(표준 "

"라이브러리를 포함합니다)이 정의합니다. 현재 정의된 시스템 이름은 :ref:`specialnames` 섹션과 그 외의 곳에서 "

"논의됩니다. 파이썬의 미래 버전에서는 더 많은 것들이 정의될 가능성이 큽니다. 어떤 문맥에서건, 명시적으로 문서로 만들어진 사용법을"

" 벗어나는 ``__*__`` 이름의 *모든* 사용은, 경고 없이 손상될 수 있습니다."

#: ../../reference/lexical_analysis.rst:551

msgid "``__*``"

msgstr "``__*``"

#: ../../reference/lexical_analysis.rst:552

msgid ""

"Class-private names. Names in this category, when used within the "

"context of a class definition, are re-written to use a mangled form to "

"help avoid name clashes between \"private\" attributes of base and "

"derived classes. See section :ref:`atom-identifiers`."

msgstr ""

"클래스-비공개 이름. 이 부류의 이름들을 클래스 정의 문맥에서 사용하면 뒤섞인 형태로 변형됩니다. 부모 클래스와 자식 클래스의 "

"\"비공개(private)\" 어트리뷰트 간의 이름 충돌을 피하기 위함입니다. :ref:`atom-identifiers` 섹션을 "

"보세요."

#: ../../reference/lexical_analysis.rst:561

msgid "Literals"

msgstr "리터럴"

#: ../../reference/lexical_analysis.rst:565

msgid "Literals are notations for constant values of some built-in types."

msgstr "리터럴(literal)은 몇몇 내장형들의 상숫값을 위한 표기법입니다."

#: ../../reference/lexical_analysis.rst:567

msgid ""

"In terms of lexical analysis, Python has :ref:`string, bytes <strings>` "

"and :ref:`numeric <numbers>` literals."

msgstr ""

#: ../../reference/lexical_analysis.rst:570

msgid ""

"Other \"literals\" are lexically denoted using :ref:`keywords <keywords>`"

" (``None``, ``True``, ``False``) and the special :ref:`ellipsis token "

"<lexical-ellipsis>` (``...``)."

msgstr ""

#: ../../reference/lexical_analysis.rst:581

msgid "String and Bytes literals"

msgstr "문자열과 바이트열 리터럴"