6. 단순문(Simple statements)
****************************

Simple statements are comprised within a single logical line. Several
simple statements may occur on a single line separated by semicolons.
The syntax for simple statements is:

   simple_stmt ::= expression_stmt
                   | assert_stmt
                   | assignment_stmt
                   | augmented_assignment_stmt
                   | pass_stmt
                   | del_stmt
                   | print_stmt
                   | return_stmt
                   | yield_stmt
                   | raise_stmt
                   | break_stmt
                   | continue_stmt
                   | import_stmt
                   | future_stmt
                   | global_stmt
                   | exec_stmt


6.1. 표현식 문
==============

표현식 문은 값을 계산하고 출력하거나, (보통) 프로시저(procedure) (의미
없는 결과를 돌려주는 함수; 파이썬에서 프로시저는 "None" 값을 돌려준다)
를 호출하기 위해 (대부분 대화형으로) 사용된다. 표현식 문의 다른 사용도
허락되고 때때로 쓸모가 있다.

   expression_stmt ::= expression_list

표현식 문은 (하나의 표현식일 수 있는) 표현식 목록의 값을 구한다.

In interactive mode, if the value is not "None", it is converted to a
string using the built-in "repr()" function and the resulting string
is written to standard output (see section The print statement) on a
line by itself.  (Expression statements yielding "None" are not
written, so that procedure calls do not cause any output.)


6.2. 대입문
===========

대입문은 이름을 값에 (재)연결하고 가변 객체의 어트리뷰트나 항목들을 수
정한다.

   assignment_stmt ::= (target_list "=")+ (expression_list | yield_expression)
   target_list     ::= target ("," target)* [","]
   target          ::= identifier
              | "(" target_list ")"
              | "[" [target_list] "]"
              | attributeref
              | subscription
              | slicing

(See section 프라이머리 for the syntax definitions for the last three
symbols.)

대입문은 표현식 목록 (이것이 하나의 표현식일 수도, 쉼표로 분리된 목록
일 수도 있는데, 후자의 경우는 튜플이 만들어진다는 것을 기억하라) 의 값
을 구하고, 왼쪽에서 오른쪽으로, 하나의 결과 객체를 타깃 목록의 각각에
대입한다.

대입은 타깃 (목록)의 형태에 따라 재귀적으로 정의된다. 타깃이 가변 객체
의 일부 (어트리뷰트 참조나 서브스크립션이나 슬라이싱) 면, 가변 객체가
최종적으로 대입을 수행해야만 하고, 그것이 올바른지 아닌지를 결정하고,
대입이 받아들여질 수 없으면 예외를 일으킬 수 있다. 다양한 형들이 주시
하는 규칙들과 발생하는 예외들은 그 객체 형의 정의에서 주어진다 (표준형
계층 섹션을 보라).

Assignment of an object to a target list is recursively defined as
follows.

* If the target list is a single target: The object is assigned to
  that target.

* If the target list is a comma-separated list of targets: The
  object must be an iterable with the same number of items as there
  are targets in the target list, and the items are assigned, from
  left to right, to the corresponding targets.

하나의 타깃에 대한 객체의 대입은 다음과 같이 재귀적으로 정의된다.

* 타깃이 식별자 (이름) 면:

  * If the name does not occur in a "global" statement in the
    current code block: the name is bound to the object in the current
    local namespace.

  * Otherwise: the name is bound to the object in the current global
    namespace.

  그 이름이 이미 연결되어 있으면 재연결된다. 이것은 기존에 연결되어 있
  던 객체의 참조 횟수가 0이 되도록 만들어서, 객체가 점유하던 메모리가
  반납되고 파괴자(destructor) (갖고 있다면) 가 호출되도록 만들 수 있다
  .

* If the target is a target list enclosed in parentheses or in
  square brackets: The object must be an iterable with the same number
  of items as there are targets in the target list, and its items are
  assigned, from left to right, to the corresponding targets.

* 타깃이 어트리뷰트 참조면: 참조의 프라이머리 표현식의 값을 구한다.
  이 것은 대입 가능한 어트리뷰트를 가진 객체를 주어야 하는데, 그렇지
  않으 면 "TypeError" 가 일어난다. 그에 그 객체에 주어진 어트리뷰트로
  객체 를 대입하도록 요청한다; 대입을 수행할 수 없다면 예외 (보통
  "AttributeError" 이지만, 꼭 그럴 필요는 없다) 를 일으킨다.

  주의 사항: 객체가 클래스 인스턴스이고 어트리뷰트 참조가 대입 연산자
  의 양쪽에서 모두 등장하면, RHS 표현식, "a.x" 는 인스턴스 어트리뷰트
  나 (인스턴스 어트리뷰트가 없다면) 클래스 어트리뷰트를 액세스할 수 있
  다. LHS 타깃 "a.x" 는 항상 필요하면 만들어서라도 항상 인스턴스 어트
  리뷰트를 설정한다. 그래서, 두 "a.x" 가 같은 어트리뷰트를 가리키는 것
  은 필요조건이 아니다: RHS 표현식이 클래스 어트리뷰트를 가리킨다면,
  LHS 는 대입의 타깃으로 새 인스턴스 어트리뷰트를 만든다:

     class Cls:
         x = 3             # class variable
     inst = Cls()
     inst.x = inst.x + 1   # writes inst.x as 4 leaving Cls.x as 3

  이 설명이 "property()" 로 만들어진 프로퍼티(property)와 같은 디스크
  립터 어트리뷰트에 적용될 필요는 없다.

* If the target is a subscription: The primary expression in the
  reference is evaluated.  It should yield either a mutable sequence
  object (such as a list) or a mapping object (such as a dictionary).
  Next, the subscript expression is evaluated.

  If the primary is a mutable sequence object (such as a list), the
  subscript must yield a plain integer.  If it is negative, the
  sequence's length is added to it. The resulting value must be a
  nonnegative integer less than the sequence's length, and the
  sequence is asked to assign the assigned object to its item with
  that index.  If the index is out of range, "IndexError" is raised
  (assignment to a subscripted sequence cannot add new items to a
  list).

  프라이머리가 (딕셔너리 같은) 매핑 객체면, 서브 스크립트는 매핑의 키
  형과 호환되는 형이어야 하고, 매핑에 그 서브 스크립트를 객체에 매핑하
  는 키/데이터 쌍을 만들도록 요청한다. 이때 같은 킷값을 갖는 기존의 키
  /값 쌍을 대체할 수도 있고, (같은 값의 키가 존재하지 않는 경우) 새 키
  /값 쌍을 삽입할 수도 있다.

* If the target is a slicing: The primary expression in the
  reference is evaluated.  It should yield a mutable sequence object
  (such as a list).  The assigned object should be a sequence object
  of the same type.  Next, the lower and upper bound expressions are
  evaluated, insofar they are present; defaults are zero and the
  sequence's length.  The bounds should evaluate to (small) integers.
  If either bound is negative, the sequence's length is added to it.
  The resulting bounds are clipped to lie between zero and the
  sequence's length, inclusive.  Finally, the sequence object is asked
  to replace the slice with the items of the assigned sequence.  The
  length of the slice may be different from the length of the assigned
  sequence, thus changing the length of the target sequence, if the
  object allows it.

현재 구현에서, 타깃의 문법은 표현식과 같게 유지되고, 잘못된 문법은 코
드 생성 단계에서 거부되기 때문에 에러 메시지가 덜 상세해지는 결과를 낳
고 있다.

WARNING: Although the definition of assignment implies that overlaps
between the left-hand side and the right-hand side are 'safe' (for
example "a, b = b, a" swaps two variables), overlaps *within* the
collection of assigned-to variables are not safe!  For instance, the
following program prints "[0, 2]":

   x = [0, 1]
   i = 0
   i, x[i] = 1, 2
   print x


6.2.1. 증분 대입문(Augmented assignment statements)
---------------------------------------------------

증분 대입문은 한 문장에서 이항 연산과 대입문을 합치는 것이다:

   augmented_assignment_stmt ::= augtarget augop (expression_list | yield_expression)
   augtarget                 ::= identifier | attributeref | subscription | slicing
   augop                     ::= "+=" | "-=" | "*=" | "/=" | "//=" | "%=" | "**="
             | ">>=" | "<<=" | "&=" | "^=" | "|="

(See section 프라이머리 for the syntax definitions for the last three
symbols.)

증분 대입은 타깃 (일반 대입문과는 달리 언 패킹이 될 수 없다) 과 표현식
목록의 값을 구하고, 둘을 피연산자로 삼아 대입의 형에 맞는 이항 연산을
수행한 후, 원래의 타깃에 그 결과를 대입한다. 타깃은 오직 한 번만 값이
구해진다.

"x += 1" 과 같은 증분 대입 표현은 "x = x + 1" 처럼 다시 쓸 수 있는데,
정확히 같은 효과는 아니지만 비슷한 결과를 준다. 증분 버전에서는, "x"
의 값을 오직 한 번만 구한다. 또한, 가능할 때, 실제 연산은 *제자리(in-
place)* 에서 수행되는데, 새 객체를 만들고 그것을 타깃에 대입하기보다는
, 예전 객체를 수정한다는 의미다.

하나의 문장에서 튜플과 다중 타깃으로 대입하는 것을 예외로 하면, 증분
대입문에 의한 대입은 일반 대입과 같은 방법으로 처리된다. 마찬가지로, *
제자리* 동작의 가능성을 예외로 하면, 증분 대입 때문에 수행되는 이진 연
산은 일반 이진 연산과 같다.

어트리뷰트 참조인 타깃의 경우, 일반 대입처럼 클래스와 인스턴스 어트리
뷰트에 관한 경고 가 적용된다.


6.3. "assert" 문
================

assert 문은 프로그램에 디버깅 어서션(debugging assertion)을 삽입하는
편리한 방법이다:

   assert_stmt ::= "assert" expression ["," expression]

간단한 형태, "assert expression" 은 다음과 동등하다

   if __debug__:
       if not expression: raise AssertionError

확장된 형태, "assert expression1, expression2" 는 다음과 동등하다

   if __debug__:
       if not expression1: raise AssertionError(expression2)

이 동등성 들은 "__debug__" 과 "AssertionError" 가 같은 이름의 내장 변
수들을 가리킨다고 가정한다. 현재 구현에서, 내장 변수 "__debug__" 은 일
반적인 상황에서 "True" 이고, 최적화가 요청되었을 때 (명령행 옵션 -O)
"False" 다. 현재의 코드 생성기는 컴파일 시점에 최적화가 요청되면
assert 문을 위한 코드를 만들지 않는다. 에러 메시지에 실패한 표현식의
소스 코드를 포함할 필요가 없음에 주의하라; 그것은 스택 트레이스의 일부
로 출력된다.

"__debug__" 에 대한 대입은 허락되지 않는다. 이 내장 변수의 값은 인터프
리터가 시작할 때 결정된다.


6.4. "pass" 문
==============

   pass_stmt ::= "pass"

"pass" 는 널(null) 연산이다 --- 실행될 때, 아무런 일도 일어나지 않는다
. 문법적으로 문장이 필요하기는 하지만 할 일은 없을 때, 자리를 채우는
용도로 쓸모가 있다, 예를 들어:

   def f(arg): pass    # a function that does nothing (yet)

   class C: pass       # a class with no methods (yet)


6.5. "del" 문
=============

   del_stmt ::= "del" target_list

삭제는 대입이 정의된 방식과 아주 비슷하게 재귀적으로 정의된다. 전체 세
부 사항들을 나열하는 대신, 여기 몇 가지 힌트가 있다.

타깃 목록의 삭제는 각 타깃을 왼쪽에서 오른쪽으로 재귀적으로 삭제한다.

Deletion of a name removes the binding of that name  from the local or
global namespace, depending on whether the name occurs in a "global"
statement in the same code block.  If the name is unbound, a
"NameError" exception will be raised.

It is illegal to delete a name from the local namespace if it occurs
as a free variable in a nested block.

어트리뷰트 참조, 서브스크립션, 슬라이싱의 삭제는 관련된 프라이머리 객
체로 전달된다; 슬라이싱의 삭제는 일반적으로 우변 형의 빈 슬라이스를 대
입하는 것과 동등하다 (하지만 이것조차 슬라이싱 되는 객체가 판단한다).


6.6. The "print" statement
==========================

   print_stmt ::= "print" ([expression ("," expression)* [","]]
                  | ">>" expression [("," expression)+ [","]])

"print" evaluates each expression in turn and writes the resulting
object to standard output (see below).  If an object is not a string,
it is first converted to a string using the rules for string
conversions.  The (resulting or original) string is then written.  A
space is written before each object is (converted and) written, unless
the output system believes it is positioned at the beginning of a
line.  This is the case (1) when no characters have yet been written
to standard output, (2) when the last character written to standard
output is a whitespace character except "' '", or (3) when the last
write operation on standard output was not a "print" statement. (In
some cases it may be functional to write an empty string to standard
output for this reason.)

주석: Objects which act like file objects but which are not the
  built-in file objects often do not properly emulate this aspect of
  the file object's behavior, so it is best not to rely on this.

A "'\n'" character is written at the end, unless the "print" statement
ends with a comma.  This is the only action if the statement contains
just the keyword "print".

Standard output is defined as the file object named "stdout" in the
built-in module "sys".  If no such object exists, or if it does not
have a "write()" method, a "RuntimeError" exception is raised.

"print" also has an extended form, defined by the second portion of
the syntax described above. This form is sometimes referred to as
""print" chevron." In this form, the first expression after the ">>"
must evaluate to a "file-like" object, specifically an object that has
a "write()" method as described above.  With this extended form, the
subsequent expressions are printed to this file object.  If the first
expression evaluates to "None", then "sys.stdout" is used as the file
for output.


6.7. return 문
==============

   return_stmt ::= "return" [expression_list]

"return" 은 문법적으로 클래스 정의에 중첩된 경우가 아니라, 함수 정의에
만 중첩되어 나타날 수 있다.

표현식 목록이 있으면 값을 구하고, 그렇지 않으면 "None" 으로 치환된다.

"return" 은 표현식 목록 (또는 "None")을 반환 값으로 해서, 현재의 함수
호출을 떠난다.

"return" 이 "finally" 절을 가진 "try" 문에서 제어가 벗어나도록 만드는
경우, 함수로부터 진짜로 벗어나기 전에 그 "finally" 절이 실행된다.

In a generator function, the "return" statement is not allowed to
include an "expression_list".  In that context, a bare "return"
indicates that the generator is done and will cause "StopIteration" to
be raised.


6.8. yield 문
=============

   yield_stmt ::= yield_expression

The "yield" statement is only used when defining a generator function,
and is only used in the body of the generator function. Using a
"yield" statement in a function definition is sufficient to cause that
definition to create a generator function instead of a normal
function.

When a generator function is called, it returns an iterator known as a
generator iterator, or more commonly, a generator.  The body of the
generator function is executed by calling the generator's "next()"
method repeatedly until it raises an exception.

When a "yield" statement is executed, the state of the generator is
frozen and the value of "expression_list" is returned to "next()"'s
caller.  By "frozen" we mean that all local state is retained,
including the current bindings of local variables, the instruction
pointer, and the internal evaluation stack: enough information is
saved so that the next time "next()" is invoked, the function can
proceed exactly as if the "yield" statement were just another external
call.

As of Python version 2.5, the "yield" statement is now allowed in the
"try" clause of a "try" ...  "finally" construct.  If the generator is
not resumed before it is finalized (by reaching a zero reference count
or by being garbage collected), the generator-iterator's "close()"
method will be called, allowing any pending "finally" clauses to
execute.

"yield" 의 뜻에 대한 전체 세부 사항들은 일드 표현식(Yield expressions)
섹션을 참고하면 된다.

주석: In Python 2.2, the "yield" statement was only allowed when the
  "generators" feature has been enabled.  This "__future__" import
  statement was used to enable the feature:

     from __future__ import generators

더 보기:

  **PEP 255** - Simple Generators
     The proposal for adding generators and the "yield" statement to
     Python.

  **PEP 342** - Coroutines via Enhanced Generators
     The proposal that, among other generator enhancements, proposed
     allowing "yield" to appear inside a "try" ... "finally" block.


6.9. "raise" 문
===============

   raise_stmt ::= "raise" [expression ["," expression ["," expression]]]

If no expressions are present, "raise" re-raises the last exception
that was active in the current scope.  If no exception is active in
the current scope, a "TypeError" exception is raised indicating that
this is an error (if running under IDLE, a "Queue.Empty" exception is
raised instead).

Otherwise, "raise" evaluates the expressions to get three objects,
using "None" as the value of omitted expressions.  The first two
objects are used to determine the *type* and *value* of the exception.

If the first object is an instance, the type of the exception is the
class of the instance, the instance itself is the value, and the
second object must be "None".

If the first object is a class, it becomes the type of the exception.
The second object is used to determine the exception value: If it is
an instance of the class, the instance becomes the exception value. If
the second object is a tuple, it is used as the argument list for the
class constructor; if it is "None", an empty argument list is used,
and any other object is treated as a single argument to the
constructor.  The instance so created by calling the constructor is
used as the exception value.

If a third object is present and not "None", it must be a traceback
object (see section 표준형 계층), and it is substituted instead of the
current location as the place where the exception occurred.  If the
third object is present and not a traceback object or "None", a
"TypeError" exception is raised.  The three-expression form of "raise"
is useful to re-raise an exception transparently in an except clause,
but "raise" with no expressions should be preferred if the exception
to be re-raised was the most recently active exception in the current
scope.

예외에 대한 더 많은 정보를 예외 섹션에서 발견할 수 있고, 예외를 처리하
는 것에 대한 정보는 try 문 섹션에 있다.


6.10. break 문
==============

   break_stmt ::= "break"

"break" 는 문법적으로 "for" 나 "while" 루프에 중첩되어서만 나타날 수
있다. 하지만 그 루프 안의 함수나 클래스 정의에 중첩되지는 않는다.

가장 가까이서 둘러싸고 있는 루프를 종료하고, 그 루프가 "else" 절을 갖
고 있다면 건너뛴다(skip).

"for" 루프가 "break" 로 종료되면, 루프 제어 타깃은 현재값을 유지한다.

"break" 가 "finally" 절을 가 "try" 문에서 제어가 벗어나도록 만드는 경
우, 루프로부터 진짜로 벗어나기 전에 그 "finally" 절이 실행된다.


6.11. "continue" 문
===================

   continue_stmt ::= "continue"

"continue" 는 문법적으로 "for" 나 "while" 루프에 중첩되어서만 나타날
수 있다. 하지만 그 루프 안의 함수나 클래스 정의 또는 그 루프 내의
"finally" 에 중첩되지는 않는다. 가장 가까이서 둘러싸고 있는 루프가 다
음 사이클로 넘어가도록 만든다.

"continue" 가 "finally" 절을 가진 "try" 문에서 제어가 벗어나도록 만드
는 경우, 다음 루트 사이클을 시작하기 전에 그 "finally" 절이 실행된다.


6.12. 임포트("import") 문
=========================

   import_stmt     ::= "import" module ["as" name] ( "," module ["as" name] )*
                   | "from" relative_module "import" identifier ["as" name]
                   ( "," identifier ["as" name] )*
                   | "from" relative_module "import" "(" identifier ["as" name]
                   ( "," identifier ["as" name] )* [","] ")"
                   | "from" module "import" "*"
   module          ::= (identifier ".")* identifier
   relative_module ::= "."* module | "."+
   name            ::= identifier

Import statements are executed in two steps: (1) find a module, and
initialize it if necessary; (2) define a name or names in the local
namespace (of the scope where the "import" statement occurs). The
statement comes in two forms differing on whether it uses the "from"
keyword. The first form (without "from") repeats these steps for each
identifier in the list. The form with "from" performs step (1) once,
and then performs step (2) repeatedly.

To understand how step (1) occurs, one must first understand how
Python handles hierarchical naming of modules. To help organize
modules and provide a hierarchy in naming, Python has a concept of
packages. A package can contain other packages and modules while
modules cannot contain other modules or packages. From a file system
perspective, packages are directories and modules are files.

Once the name of the module is known (unless otherwise specified, the
term "module" will refer to both packages and modules), searching for
the module or package can begin. The first place checked is
"sys.modules", the cache of all modules that have been imported
previously. If the module is found there then it is used in step (2)
of import.

If the module is not found in the cache, then "sys.meta_path" is
searched (the specification for "sys.meta_path" can be found in **PEP
302**). The object is a list of *finder* objects which are queried in
order as to whether they know how to load the module by calling their
"find_module()" method with the name of the module. If the module
happens to be contained within a package (as denoted by the existence
of a dot in the name), then a second argument to "find_module()" is
given as the value of the "__path__" attribute from the parent package
(everything up to the last dot in the name of the module being
imported). If a finder can find the module it returns a *loader*
(discussed later) or returns "None".

If none of the finders on "sys.meta_path" are able to find the module
then some implicitly defined finders are queried. Implementations of
Python vary in what implicit meta path finders are defined. The one
they all do define, though, is one that handles "sys.path_hooks",
"sys.path_importer_cache", and "sys.path".

The implicit finder searches for the requested module in the "paths"
specified in one of two places ("paths" do not have to be file system
paths). If the module being imported is supposed to be contained
within a package then the second argument passed to "find_module()",
"__path__" on the parent package, is used as the source of paths. If
the module is not contained in a package then "sys.path" is used as
the source of paths.

Once the source of paths is chosen it is iterated over to find a
finder that can handle that path. The dict at
"sys.path_importer_cache" caches finders for paths and is checked for
a finder. If the path does not have a finder cached then
"sys.path_hooks" is searched by calling each object in the list with a
single argument of the path, returning a finder or raises
"ImportError". If a finder is returned then it is cached in
"sys.path_importer_cache" and then used for that path entry. If no
finder can be found but the path exists then a value of "None" is
stored in "sys.path_importer_cache" to signify that an implicit, file-
based finder that handles modules stored as individual files should be
used for that path. If the path does not exist then a finder which
always returns "None" is placed in the cache for the path.

If no finder can find the module then "ImportError" is raised.
Otherwise some finder returned a loader whose "load_module()" method
is called with the name of the module to load (see **PEP 302** for the
original definition of loaders). A loader has several responsibilities
to perform on a module it loads. First, if the module already exists
in "sys.modules" (a possibility if the loader is called outside of the
import machinery) then it is to use that module for initialization and
not a new module. But if the module does not exist in "sys.modules"
then it is to be added to that dict before initialization begins. If
an error occurs during loading of the module and it was added to
"sys.modules" it is to be removed from the dict. If an error occurs
but the module was already in "sys.modules" it is left in the dict.

The loader must set several attributes on the module. "__name__" is to
be set to the name of the module. "__file__" is to be the "path" to
the file unless the module is built-in (and thus listed in
"sys.builtin_module_names") in which case the attribute is not set. If
what is being imported is a package then "__path__" is to be set to a
list of paths to be searched when looking for modules and packages
contained within the package being imported. "__package__" is optional
but should be set to the name of package that contains the module or
package (the empty string is used for module not contained in a
package). "__loader__" is also optional but should be set to the
loader object that is loading the module.

If an error occurs during loading then the loader raises "ImportError"
if some other exception is not already being propagated. Otherwise the
loader returns the module that was loaded and initialized.

When step (1) finishes without raising an exception, step (2) can
begin.

The first form of "import" statement binds the module name in the
local namespace to the module object, and then goes on to import the
next identifier, if any.  If the module name is followed by "as", the
name following "as" is used as the local name for the module.

The "from" form does not bind the module name: it goes through the
list of identifiers, looks each one of them up in the module found in
step (1), and binds the name in the local namespace to the object thus
found.  As with the first form of "import", an alternate local name
can be supplied by specifying ""as" localname".  If a name is not
found, "ImportError" is raised.  If the list of identifiers is
replaced by a star ("'*'"), all public names defined in the module are
bound in the local namespace of the "import" statement..

The *public names* defined by a module are determined by checking the
module's namespace for a variable named "__all__"; if defined, it must
be a sequence of strings which are names defined or imported by that
module.  The names given in "__all__" are all considered public and
are required to exist.  If "__all__" is not defined, the set of public
names includes all names found in the module's namespace which do not
begin with an underscore character ("'_'"). "__all__" should contain
the entire public API. It is intended to avoid accidentally exporting
items that are not part of the API (such as library modules which were
imported and used within the module).

The "from" form with "*" may only occur in a module scope.  If the
wild card form of import --- "import *" --- is used in a function and
the function contains or is a nested block with free variables, the
compiler will raise a "SyntaxError".

임포트할 모듈을 지정할 때 모듈의 절대 이름(absolute name)을 지정할 필
요는 없다. 모듈이나 패키지가 다른 패키지 안에 포함될 때, 같은 상위 패
키지 내에서는 그 패키지 이름을 언급할 필요 없이 상대 임포트(relative
import)를 할 수 있다. "from" 뒤에 지정되는 패키지나 모듈 앞에 붙이는
점으로, 정확한 이름을 지정하지 않고도 현재 패키지 계층을 얼마나 거슬러
올라가야 하는지 지정할 수 있다. 하나의 점은 이 임포트를 하는 모듈이 존
재하는 현재 패키지를 뜻한다. 두 개의 점은 한 패키지 수준을 거슬러 올라
가는 것을 뜻한다. 세 개의 점은 두 개의 수준을, 등등이다. 그래서 "pkg"
패키지에 있는 모듈에서 "from . import mod" 를 실행하면, "pkg.mod" 를
임포트하게 된다. "pkg.subpkg1" 안에서 "from ..subpkg2 import mod" 를
실행하면 "pkg.subpkg2.mod" 를 임포트하게 된다. 상대 임포트에 대한 규격
은 **PEP 328** 안에 들어있다.

"importlib.import_module()" is provided to support applications that
determine which modules need to be loaded dynamically.


6.12.1. 퓨처 문
---------------

A *future statement* is a directive to the compiler that a particular
module should be compiled using syntax or semantics that will be
available in a specified future release of Python.  The future
statement is intended to ease migration to future versions of Python
that introduce incompatible changes to the language.  It allows use of
the new features on a per-module basis before the release in which the
feature becomes standard.

   future_statement ::= "from" "__future__" "import" feature ["as" name]
                        ("," feature ["as" name])*
                        | "from" "__future__" "import" "(" feature ["as" name]
                        ("," feature ["as" name])* [","] ")"
   feature          ::= identifier
   name             ::= identifier

퓨처 문은 모듈의 거의 처음에 나와야 한다. 퓨처 문 앞에 나올 수 있는 줄
들은:

* 모듈 독스트링(docstring) (있다면),

* 주석

* 빈 줄, 그리고

* 다른 퓨처 문들

The features recognized by Python 2.6 are "unicode_literals",
"print_function", "absolute_import", "division", "generators",
"nested_scopes" and "with_statement".  "generators", "with_statement",
"nested_scopes" are redundant in Python version 2.6 and above because
they are always enabled.

퓨처 문은 구체적으로는 컴파일 시점에 인식되고 다뤄진다: 핵심 구성물들
의 의미에 대한 변경은 종종 다른 코드 생성을 통해 구현된다. 새 기능이
호환되지 않는 (새로운 예약어처럼) 새로운 문법을 도입하는 경우조차 가능
한데, 이 경우는 컴파일러가 모듈을 다르게 파싱할 수 있다. 그런 결정들은
실행 시점으로 미뤄질 수 없다..

배포마다, 컴파일러는 어떤 기능 이름들이 정의되어 있는지 알고, 만약 퓨
처 문이 알지 못하는 기능을 포함하고 있으면 컴파일 시점 에러를 일으킨다
.

직접적인 실행 시점의 개념은 다른 임포트 문들과 같다: 표준 모듈
"__future__", 후에 설명한다, 다 있고, 퓨처 문이 실행되는 시점에 일반적
인 방법으로 임포트된다.

흥미로운 실행 시점의 개념들은 퓨처 문에 의해 활성화되는 구체적인 기능
들에 달려있다.

이런 문장에는 아무것도 특별한 것이 없음에 주의해야 한다:

   import __future__ [as name]

이것은 퓨처 문이 아니다; 아무런 특별한 개념이나 문법적인 제약이 없는
평범한 임포트 문일 뿐이다.

Code compiled by an "exec" statement or calls to the built-in
functions "compile()" and "execfile()" that occur in a module "M"
containing a future statement will, by default, use the new  syntax or
semantics associated with the future statement.  This can, starting
with Python 2.2 be controlled by optional arguments to "compile()" ---
see the documentation of that function for details.

대화형 인터프리터 프롬프트에서 입력된 퓨처 문은 인터프리터 세션의 남은
기간 효과를 발생시킨다. 인터프리터가 "-i", 실행할 스크립트 이름이 전달
된다, 옵션으로 시작하고, 그 스크립트가 퓨처 문을 포함하면, 스크립트가
실행된 이후에 시작되는 대화형 세션에서도 효과를 유지한다.

더 보기:

  **PEP 236** - 백 투 더 __future__
     __future__ 메커니즘에 대한 최초의 제안.


6.13. "global" 문
=================

   global_stmt ::= "global" identifier ("," identifier)*

"global" 문은 현재 코드 블록 전체에 적용되는 선언이다. 나열된 식별자들
이 전역으로 해석되어야 한다는 뜻이다. global 선언 없이 자유 변수들이
전역을 가리킬 수 있기는 하지만, "global" 없이 전역 변수에 값을 대입하
는 것은 불가능하다.

"global" 문에 나열된 이름들은 같은 코드 블록에서 "global" 문 앞에 등장
할 수 없다.

Names listed in a "global" statement must not be defined as formal
parameters or in a "for" loop control target, "class" definition,
function definition, or "import" statement.

**CPython implementation detail:** The current implementation does not
enforce the latter two restrictions, but programs should not abuse
this freedom, as future implementations may enforce them or silently
change the meaning of the program.

**Programmer's note:** "global" is a directive to the parser.  It
applies only to code parsed at the same time as the "global"
statement. In particular, a "global" statement contained in an "exec"
statement does not affect the code block *containing* the "exec"
statement, and code contained in an "exec" statement is unaffected by
"global" statements in the code containing the "exec" statement.  The
same applies to the "eval()", "execfile()" and "compile()" functions.


6.14. The "exec" statement
==========================

   exec_stmt ::= "exec" or_expr ["in" expression ["," expression]]

This statement supports dynamic execution of Python code.  The first
expression should evaluate to either a Unicode string, a *Latin-1*
encoded string, an open file object, a code object, or a tuple.  If it
is a string, the string is parsed as a suite of Python statements
which is then executed (unless a syntax error occurs). [1] If it is an
open file, the file is parsed until EOF and executed. If it is a code
object, it is simply executed.  For the interpretation of a tuple, see
below.  In all cases, the code that's executed is expected to be valid
as file input (see section 파일 입력).  Be aware that the "return" and
"yield" statements may not be used outside of function definitions
even within the context of code passed to the "exec" statement.

In all cases, if the optional parts are omitted, the code is executed
in the current scope.  If only the first expression after "in" is
specified, it should be a dictionary, which will be used for both the
global and the local variables.  If two expressions are given, they
are used for the global and local variables, respectively. If
provided, *locals* can be any mapping object. Remember that at module
level, globals and locals are the same dictionary. If two separate
objects are given as *globals* and *locals*, the code will be executed
as if it were embedded in a class definition.

The first expression may also be a tuple of length 2 or 3.  In this
case, the optional parts must be omitted.  The form "exec(expr,
globals)" is equivalent to "exec expr in globals", while the form
"exec(expr, globals, locals)" is equivalent to "exec expr in globals,
locals".  The tuple form of "exec" provides compatibility with Python
3, where "exec" is a function rather than a statement.

버전 2.4으로 변경: Formerly, *locals* was required to be a dictionary.

As a side effect, an implementation may insert additional keys into
the dictionaries given besides those corresponding to variable names
set by the executed code.  For example, the current implementation may
add a reference to the dictionary of the built-in module "__builtin__"
under the key "__builtins__" (!).

**Programmer's hints:** dynamic evaluation of expressions is supported
by the built-in function "eval()".  The built-in functions "globals()"
and "locals()" return the current global and local dictionary,
respectively, which may be useful to pass around for use by "exec".

-[ Footnotes ]-

[1] Note that the parser only accepts the Unix-style end of line
    convention. If you are reading the code from a file, make sure to
    use *universal newlines* mode to convert Windows or Mac-style
    newlines.
