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)을 반환 값으로 해서, 현재의 함수 호출을 떠난다.

returnfinally 절을 가진 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 tryfinally 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 tryfinally 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 는 문법적으로 forwhile 루프에 중첩되어서만 나타날 수 있다. 하지만 그 루프 안의 함수나 클래스 정의에 중첩되지는 않는다.

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

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

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

6.11. continue

continue_stmt ::=  "continue"

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

continuefinally 절을 가진 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.