파이썬에서 전역()을 사용하는 이유는 무엇입니까?

Question

파이썬에서 globals()가 작동하는 이유는 무엇입니까? 이미 전역 변수 인 사전 만 반환하므로 어디서든 사용할 수 있습니다 ... 나는 호기심에서 벗어나 파이썬을 배우려고합니다.

def F(): 
    global x 
    x = 1 

def G(): 
    print(globals()["x"]) #will return value of global 'x', which is 1 

def H(): 
    print(x) #will also return value of global 'x', which, also, is 1 

F() 
G() 
H() 

여기에 요점이 실제로 표시되지 않습니까? 내가 로컬 및 글로벌 변수가 있다면 나는 그것을 필요 만 시간은 그들

def F(): 
    global x 
    x = 1 

def G(): 
    x = 5 
    print(x) #5 
    print(globals()["x"]) #1 

F() 
G() 

의 모두에 대해 같은 이름이었다하지만 당신은 같은 이름을 가진 두 개의 변수를 가진, 그리고 사용할 필요의 문제로 실행해서는 안됩니다 그것들은 모두 같은 범위 안에 있습니다.

Answer 1

파이썬은 프로그래머에게 실행 환경을 검사하는 많은 도구를 제공합니다. globals()은 그 중 하나 일 뿐이며 디버깅 세션에서 전역 범위에 실제로 포함 된 개체를 확인하는 데 매우 유용 할 수 있습니다.

locals()을 사용하여 함수에 정의 된 변수를 확인하거나 dir을 사용하여 모듈의 내용이나 객체의 속성을 확인하는 것과 같은 이유가 있습니다.

C++ 배경에서 볼 때 이러한 것들은 불필요한 것으로 이해할 수 있습니다. 정적으로 링크 된 정적 유형 환경에서는 절대적으로 그렇습니다. 이 경우 컴파일 타임에 정확히 어떤 변수가 전역인지, 객체의 구성원이 무엇인지, 그리고 다른 컴파일 단위에서 어떤 이름을 내 보냈는 지 알 수 있습니다.

그러나 동적 언어에서는 이러한 사항이 수정되지 않습니다. 코드를 가져 오는 방법이나 런타임 중에 변경 될 수 있습니다. 이런 이유로 최소한 디버거에서 이러한 종류의 정보에 액세스하는 것은 매우 중요합니다.

Answer 2

globals()은 eval()에 유용합니다. 범위의 변수를 나타내는 일부 코드를 평가하려는 경우 변수는 전역 또는 지역에 있습니다.

---

는 eval() 내장 함수는 주어진 파이썬 코드의 문자열을 해석합니다, 조금 확장합니다. eval(codeString, globals, locals), 그리고 당신과 같이 사용할 것이다 : 서명은

def foo(): 
    x = 2 
    y = eval("x + 1", globals(), locals()) 
    print("y=" + y) # should be 3 

이 작동, 인터프리터는 변수의 locals() DICT에서 x의 값을 가져옵니다 때문이다. 물론 eval에 변수의 사전을 제공 할 수 있습니다.

Answer 3

당신은 eval, execfile 및 __import__ 명령에 globals() 및 locals()의 결과를 전달할 수 있습니다. 이렇게하면 해당 명령이 작동 할 수있는 제한된 환경이 만들어집니다.

따라서 이러한 기능은 현재 컨텍스트와 잠재적으로 다른 환경을 제공함으로써 이익을 얻는 다른 기능을 지원하기 위해 존재합니다. 예를 들어, globals()을 호출 한 다음 해당 함수 중 하나를 호출하기 전에 일부 변수를 제거하거나 추가 할 수 있습니다.

Answer 4

함수의 문자열 이름을 사용하여 함수를 호출해야하는 경우에도 유용합니다. 예 :

def foo(): 
    pass 

function_name_as_string = 'foo' 

globals()[function_name_as_string]() # foo(). 

Answer 5

'선언적 비단뱀'에서 유용 할 수 있습니다.예를 들어 아래의 FooDef 및 BarDef은 일련의 데이터 구조를 정의하는 데 사용되는 클래스로, 일부 패키지가 입력 또는 구성으로 사용합니다. 이렇게하면 입력 내용에 많은 유연성을 부여 할 수 있으며 파서를 작성할 필요가 없습니다. 이 구성 파일이 Foo_other의 구성의 일부인 이름의 목록을 구축하기 위해 루프를 사용하는

# FooDef, BarDef are classes 

Foo_one = FooDef("This one", opt1 = False, valence = 3) 
Foo_two = FooDef("The other one", valence = 6, parent = Foo_one) 

namelist = [] 
for i in range(6): 
    namelist.append("nm%03d"%i) 

Foo_other = FooDef("a third one", string_list = namelist) 

Bar_thing = BarDef((Foo_one, Foo_two), method = 'depth-first') 

참고. 그래서,이 설정 언어는 매우 강력한 '선처리 프로세서'와 함께 사용 가능한 런타임 라이브러리를 제공합니다. 예를 들어 구성을 생성 할 때 복잡한 로그를 찾거나 zip 파일에서 항목을 추출하고 base64를 디코드하려는 경우 (이 방법은 물론 권장되지 않습니다. 당신이 원하는 경우, 이러한 패키지를 사용하는 경우 globals()가 유용합니다, 그래서

conf_globals = {} # make a namespace 
# Give the config file the classes it needs 
conf_globals['FooDef']= mypkgconfig.FooDef # both of these are based ... 
conf_globals['BarDef']= mypkgconfig.BarDef # ... on .DefBase 

fname = "user.conf" 
try: 
    exec open(fname) in conf_globals 
except Exception: 
    ...as needed... 
# now find all the definitions in there 
# (I'm assuming the names they are defined with are 
# significant to interpreting the data; so they 
# are stored under those keys here). 

defs = {} 
for nm,val in conf_globals.items(): 
    if isinstance(val,mypkgconfig.DefBase): 
     defs[nm] = val 

, 마지막 지점에 도착 : 신뢰할 수없는 소스 ...)

패키지는 다음과 같은 것을 사용하여 구성을 읽고 절차 적으로 일련의 정의를 작성하십시오 :

for idx in range(20): 
    varname = "Foo_%02d" % i 
    globals()[varname]= FooDef("one of several", id_code = i+1, scale_ratio = 2**i) 

,

이

Foo_00 = FooDef("one of several", id_code = 1, scale_ratio=1) 
Foo_01 = FooDef("one of several", id_code = 2, scale_ratio=2) 
Foo_02 = FooDef("one of several", id_code = 3, scale_ratio=4) 
... 17 more ... 

에게 파이썬 모듈에서 정의의 무리를 수집하여 그 입력을 획득하고 패키지의 일례를 작성 동등하면 PLY (파이썬 렉스-은 yacc) http://www.dabeaz.com/ply/하다 -이 경우에 객체는 대부분 함수 객체이지만 함수 객체의 메타 데이터 (이름, 문서 문자열 및 정의 순서)도 입력의 일부를 형성합니다. globals()을 사용하는 것은 좋은 사례가 아닙니다. 또한 '구성'에 의해 가져옵니다. 후자는 일반적인 파이썬 스크립트입니다.

필자가 작업 한 몇 개의 프로젝트에서 '선언적 python'을 사용했으며, 구성을 작성할 때 globals()을 사용할 기회가있었습니다. 당신은 이것이 구성 '언어'가 디자인 된 방식의 약점 때문이라고 확실히 말할 수 있습니다. 이 방법으로 globals()을 사용하더라도 매우 명확한 결과가 나오지 않습니다. 거의 동일한 진술을 12 개 이상 작성하는 것보다 유지하기가 더 쉬운 결과 일뿐입니다.

또한 자신의 이름에 따라, 구성 파일 내에서 변수의 의미를 부여하는 데 사용할 수 있습니다 :

# All variables above here starting with Foo_k_ are collected 
# in Bar_klist 
# 
foo_k = [ v for k,v in globals().items() if k.startswith('Foo_k_')] 
Bar_klist = BarDef(foo_k , method = "kset") 

이 방법은 테이블과 구조의 많은 영역을 정의하는 파이썬 모듈이 유용 할 수있다, 참조를 유지 관리 할 필요없이 항목을 데이터에 더 쉽게 추가 할 수 있습니다.