[python] 범위 지정 규칙에 대한 간단한 설명?

Python3 시간에 대한 완전한 대답은 없었으므로 여기서 대답했습니다. 여기에 설명 된 대부분의 내용은 4.2.2 Python 3 문서 이름 확인에 자세히 설명되어 있습니다.

다른 답변에서 제공하는 것처럼 로컬, 인클로저, 글로벌 및 내장에 대한 4 가지 기본 범위 인 LEGB가 있습니다. 이외에도 클래스 범위 내에 정의 된 메소드의 엔 클로징 범위를 포함하지 않는 특수 범위 인 클래스 본문이 있습니다 . 클래스 본문 내에서 할당하면 변수가 클래스 본문에 바인딩됩니다.

특히 및 이외의 블록 문 은 변수 범위를 만들지 않습니다 . 파이썬 2에서는리스트 이해가 변수 범위를 생성하지 않지만, 파이썬 3에서는리스트 이해 내의 루프 변수가 새로운 범위로 생성됩니다.defclass

학급의 특성을 보여주기 위해

x = 0
class X(object):
    y = x
    x = x + 1 # x is now a variable
    z = x

    def method(self):
        print(self.x) # -> 1
        print(x)      # -> 0, the global x
        print(y)      # -> NameError: global name 'y' is not defined

inst = X()
print(inst.x, inst.y, inst.z, x) # -> (1, 0, 1, 0)

따라서 함수 본문과 달리 변수를 클래스 본문에서 동일한 이름으로 다시 할당하여 동일한 이름의 클래스 변수를 얻을 수 있습니다. 이 이름에 대한 추가 조회는 대신 클래스 변수로 해석됩니다.

파이썬을 처음 접하는 많은 사람들에게 큰 놀라움 중 하나는 for루프가 변수 범위를 만들지 않는다는 것입니다. Python 2에서 목록 이해는 범위를 만들지 않습니다 (제너레이터와 dict 이해력이있는 동안!) 대신 함수 또는 전역 범위에서 값을 유출합니다.

>>> [ i for i in range(5) ]
>>> i
4

이해는 파이썬 2에서 람다 식 내에서 수정 가능한 변수를 만드는 교활한 (또는 끔찍한 경우) 방법으로 사용될 def수 있습니다. 파이썬에서 명령문으로 할당한다는 것은 람다에서 변수 할당이 허용되지 않지만 목록 이해는 표현식이라는 것을 의미합니다.

이 동작은 Python 3에서 수정되었습니다. 이해 표현식이나 생성기 누출 변수가 없습니다.

전역은 실제로 모듈 범위를 의미합니다. 주요 파이썬 모듈은 __main__; 가져온 모든 모듈은 sys.modules변수를 통해 액세스 할 수 있습니다 . 에 액세스 __main__하려면 sys.modules['__main__'], 또는 import __main__; 속성을 액세스하고 할당하는 것은 완벽하게 허용됩니다. 메인 모듈의 전역 범위에 변수로 표시됩니다.

이름이 현재 범위 (클래스 범위 제외)에 할당 된 경우 해당 범위에 속하는 것으로 간주되고, 그렇지 않으면 변수에 할당되는 모든 범위에 속하는 것으로 간주됩니다 (할당되지 않을 수 있음) 아직 또는 전혀) 또는 마지막으로 글로벌 범위. 변수가 로컬로 간주되지만 아직 설정되지 않았거나 삭제 된 경우 변수 값을 읽으면의 UnboundLocalError하위 클래스 인가 NameError됩니다.

x = 5
def foobar():
    print(x)  # causes UnboundLocalError!
    x += 1    # because assignment here makes x a local variable within the function

# call the function
foobar()

범위는 global 키워드를 사용하여 전역 (모듈 범위) 변수를 명시 적으로 수정한다고 선언 할 수 있습니다.

x = 5
def foobar():
    global x
    print(x)
    x += 1

foobar() # -> 5
print(x) # -> 6

둘러싸는 범위에서 음영 처리 된 경우에도 가능합니다.

x = 5
y = 13
def make_closure():
    x = 42
    y = 911
    def func():
        global x # sees the global value
        print(x, y)
        x += 1

    return func

func = make_closure()
func()      # -> 5 911
print(x, y) # -> 6 13

파이썬 2에서는 둘러싸는 범위에서 값을 수정하는 쉬운 방법이 없습니다. 일반적으로 이것은 길이가 1 인 목록과 같이 변경 가능한 값을 가짐으로써 시뮬레이션됩니다.

def make_closure():
    value = [0]
    def get_next_value():
        value[0] += 1
        return value[0]

    return get_next_value

get_next = make_closure()
print(get_next()) # -> 1
print(get_next()) # -> 2

그러나 파이썬 3에서는 nonlocal구조가 시작됩니다.

def make_closure():
    value = 0
    def get_next_value():
        nonlocal value
        value += 1
        return value
    return get_next_value

get_next = make_closure() # identical behavior to the previous example.

nonlocal설명서를 말한다

글로벌 명령문에 나열된 것과 달리 로컬이 아닌 명령문에 나열된 이름은 둘러싸는 범위의 기존 바인딩을 참조해야합니다 (새 바인딩을 작성해야하는 범위를 명확하게 판별 할 수 없음).

즉, nonlocal항상 이름이 바인딩 된 가장 바깥 쪽의 비전 역 범위를 가리 킵니다 (예 : for대상 변수, with절 또는 함수 매개 변수 로 사용됨 ).

현재 범위 또는 로컬 범위에 로컬로 간주되지 않는 변수는 전역 변수입니다. 전역 이름은 모듈 전역 사전에서 조회됩니다. 찾지 못하면 전역이 내장 모듈에서 조회됩니다. 모듈 이름이 python 2에서 python 3으로 변경되었습니다. 파이썬 2에서는 였고 __builtin__파이썬 3에서는 이제라고 builtins합니다. 내장 모듈의 속성에 할당하면, 모듈이 동일한 이름을 가진 고유 한 전역 변수로 음영 처리되지 않는 한 그 모듈은 읽을 수있는 전역 변수로 모든 모듈에 표시됩니다.

내장 모듈을 읽는 것도 유용 할 수 있습니다. 파일의 일부 부분에서 python 3 스타일 인쇄 기능을 원하지만 파일의 다른 부분에서는 여전히 print명령문을 사용한다고 가정하십시오 . Python 2.6-2.7에서는 다음을 사용하여 Python 3 print기능 을 사용할 수 있습니다 .

import __builtin__

print3 = __builtin__.__dict__['print']

는 from __future__ import print_function실제로 가져 오지 않습니다 print파이썬 2의 기능 어디서나 – 대신 단지에 대한 구문 분석 규칙을 비활성화 print처리, 현재 모듈에서 문 print다른 변수 식별자처럼, 따라서 수 있도록 print기능이 내장 매크로에서 조회 할.

답변

from __future__ import print_function  # for python 2 support

x = 100
print("1. Global x:", x)
class Test(object):
    y = x
    print("2. Enclosed y:", y)
    x = x + 1
    print("3. Enclosed x:", x)

    def method(self):
        print("4. Enclosed self.x", self.x)
        print("5. Global x", x)
        try:
            print(y)
        except NameError as e:
            print("6.", e)

    def method_local_ref(self):
        try:
            print(x)
        except UnboundLocalError as e:
            print("7.", e)
        x = 200 # causing 7 because has same name
        print("8. Local x", x)

inst = Test()
inst.method()
inst.method_local_ref()

1. Global x: 100
2. Enclosed y: 100
3. Enclosed x: 101
4. Enclosed self.x 101
5. Global x 100
6. global name 'y' is not defined
7. local variable 'x' referenced before assignment
8. Local x 200

x= 0
def fun1():
    x= 1
    def fun2():
        x= 2
        def fun3():
            return x
        return fun3()
    return fun2()
print fun1(), x

2 0

0 0