함수에서 전역 변수 사용

질문자 :user46646

함수에서 전역 변수를 생성하거나 사용하려면 어떻게 해야 합니까?

한 함수에서 전역 변수를 생성하면 다른 함수에서 그 전역 변수를 어떻게 사용할 수 있습니까? 접근이 필요한 함수의 지역 변수에 전역 변수를 저장해야 합니까?

당신은 그것을 선언하여 다른 함수 내에서 전역 변수를 사용할 수 있습니다 global 에 값을 할당 각 함수 내 :

 globvar = 0 def set_globvar_to_one(): global globvar # Needed to modify global copy of globvar globvar = 1 def print_globvar(): print(globvar) # No need for global declaration to read value of globvar set_globvar_to_one() print_globvar() # Prints 1

global 키워드를 명시적으로 요구하여 이것이 바로 여러분이 갖고 있는 것이 무엇인지 확실히 알고 싶어하기 때문이라고 생각합니다.

모듈 간에 전역 변수를 공유하려면 다른 답변을 참조하십시오.

Paul Stephenson

내가 당신의 상황을 올바르게 이해하고 있다면, 당신이 보고 있는 것은 Python이 로컬(함수) 및 글로벌(모듈) 네임스페이스를 처리하는 방법의 결과입니다.

다음과 같은 모듈이 있다고 가정해 보겠습니다.

 # sample.py myGlobal = 5 def func1(): myGlobal = 42 def func2(): print myGlobal func1() func2()

이것이 42를 인쇄할 것으로 예상할 수 있지만 대신 5를 인쇄합니다. 이미 언급했듯이 func1() global ' 선언을 func2() 는 42를 인쇄합니다.

 def func1(): global myGlobal myGlobal = 42

여기서 무슨 일이 일어나고 있는지 파이썬은 에 할당된 이름이 함수 내 어느 곳에서나 명시적으로 달리 언급되지 않는 한 해당 함수에 대해 지역적이라고 가정합니다. 이름에서 읽기만 하고 이름이 로컬에 존재하지 않는 경우 포함하는 범위(예: 모듈의 전역 범위)에서 이름을 조회하려고 시도합니다.

myGlobal 이라는 이름에 42를 할당하면 Python은 동일한 이름의 전역 변수를 숨기는 지역 변수를 생성합니다. 해당 로컬은 범위를 벗어나 func1() 반환될 때 가비지 수집됩니다. 한편, func2() 는 (수정되지 않은) 전역 이름 이외의 다른 것을 볼 수 없습니다. 이 네임스페이스 결정은 런타임이 아니라 컴파일 타임에 발생합니다. 할당하기 전에 func1() 내부 myGlobal UnboundLocalError 가 발생합니다. Python이 이미 다음과 같아야 한다고 결정했기 때문입니다. 지역 변수이지만 아직 연관된 값이 없습니다. global ' 문을 사용하여 로컬에서 이름을 할당하는 대신 다른 곳에서 이름을 찾아야 한다고 Python에 알립니다.

(이 동작은 주로 로컬 네임스페이스의 최적화를 통해 시작되었다고 생각합니다. 이 동작이 없으면 Python의 VM은 함수 내부에 새 이름이 할당될 때마다 최소 3번의 이름 조회를 수행해야 합니다. t는 이미 모듈/내장 수준에 존재함), 이는 매우 일반적인 작업을 상당히 느리게 합니다.)

Jeff Shannon

네임스페이스 의 개념을 탐색할 수 있습니다. Python에서 모듈 은 전역 데이터를 위한 자연스러운 장소입니다.

각 모듈에는 모듈에 정의된 모든 함수에 의해 전역 기호 테이블로 사용되는 고유한 개인 기호 테이블이 있습니다. 따라서 모듈 작성자는 사용자의 전역 변수와 우발적인 충돌에 대해 걱정하지 않고 모듈의 전역 변수를 사용할 수 있습니다. 다른 한편으로, 당신이 무엇을 하고 있는지 알고 있다면 모듈의 전역 변수를 모듈의 함수를 참조하는 데 사용되는 것과 같은 표기법인 modname.itemname 있습니다.

모듈 내 전역의 특정 사용은 여기에 설명되어 있습니다. 모듈 간에 전역 변수를 공유하려면 어떻게 해야 합니까? , 그리고 완성도를 위해 콘텐츠가 여기에 공유됩니다.

단일 프로그램 내에서 모듈 간에 정보를 공유하는 일반적인 방법은 특수 구성 모듈(종종 config 또는 cfg 라고 함)을 만드는 것입니다. 애플리케이션의 모든 모듈에서 구성 모듈을 가져오기만 하면 됩니다. 그러면 모듈을 전역 이름으로 사용할 수 있습니다. 각 모듈의 인스턴스가 하나만 있기 때문에 모듈 개체에 대한 변경 사항은 모든 곳에 반영됩니다. 예를 들어:

파일: config.py

 x = 0 # Default value of the 'x' configuration setting

파일: mod.py

 import config config.x = 1

파일: main.py

 import config import mod print config.x

gimel

Python은 로컬과 전역 사이에서 변수를 로드해야 하는 범위를 결정하기 위해 간단한 경험적 방법을 사용합니다. 변수 이름이 할당의 왼쪽에 나타나지만 전역으로 선언되지 않은 경우 지역으로 간주됩니다. 할당의 왼쪽에 나타나지 않으면 전역으로 간주됩니다.

 >>> import dis >>> def foo(): ... global bar ... baz = 5 ... print bar ... print baz ... print quux ... >>> dis.disassemble(foo.func_code) 3 0 LOAD_CONST 1 (5) 3 STORE_FAST 0 (baz) 4 6 LOAD_GLOBAL 0 (bar) 9 PRINT_ITEM 10 PRINT_NEWLINE 5 11 LOAD_FAST 0 (baz) 14 PRINT_ITEM 15 PRINT_NEWLINE 6 16 LOAD_GLOBAL 1 (quux) 19 PRINT_ITEM 20 PRINT_NEWLINE 21 LOAD_CONST 0 (None) 24 RETURN_VALUE >>>

foo() 할당의 왼쪽에 나타나는 baz가 유일한 LOAD_FAST 변수인 방법을 확인하십시오.

SingleNegationElimination

함수에서 전역 변수를 참조하려면 global 키워드를 사용하여 전역 변수를 선언할 수 있습니다. 모든 경우에 사용할 필요는 없습니다(여기에서 누군가가 잘못 주장한 것처럼) - 표현식에서 참조된 이름이 로컬 범위 또는 이 함수가 정의된 함수의 범위에서 찾을 수 없는 경우 전역 범위에서 조회됩니다. 변수.

그러나 함수에서 전역으로 선언되지 않은 새 변수에 할당하면 암시적으로 지역으로 선언되며 동일한 이름을 가진 기존 전역 변수를 덮어쓸 수 있습니다.

또한 다른 방식으로 주장하는 일부 OOP 열성자들과 달리 전역 변수는 유용합니다.

J S

한 함수에서 전역 변수를 생성하면 다른 함수에서 그 변수를 어떻게 사용할 수 있습니까?

다음 함수를 사용하여 전역을 만들 수 있습니다.

 def create_global_variable(): global global_variable # must declare it to be a global first # modifications are thus reflected on the module's global scope global_variable = 'Foo'

함수를 작성한다고 해서 실제로 코드가 실행되는 것은 아닙니다. 그래서 우리는 create_global_variable 함수를 호출합니다:

 >>> create_global_variable()

수정 없이 전역 사용

가리키는 개체를 변경하지 않으려는 한 그냥 사용할 수 있습니다.

예를 들어,

 def use_global_variable(): return global_variable + '!!!'

이제 전역 변수를 사용할 수 있습니다.

 >>> use_global_variable() 'Foo!!!'

함수 내부에서 전역 변수 수정

전역 변수가 다른 객체를 가리키도록 하려면 global 키워드를 다시 사용해야 합니다.

 def change_global_variable(): global global_variable global_variable = 'Bar'

이 함수를 작성한 후 실제로 변경하는 코드는 여전히 실행되지 않았습니다.

 >>> use_global_variable() 'Foo!!!'

따라서 함수를 호출한 후:

 >>> change_global_variable()

전역 변수가 변경되었음을 알 수 있습니다. global_variable 이름은 이제 'Bar' 가리킵니다.

 >>> use_global_variable() 'Bar!!!'

파이썬의 "전역"은 진정한 전역이 아니며 모듈 수준에서만 전역입니다. 따라서 전역 모듈에 작성된 함수에서만 사용할 수 있습니다. 함수는 작성된 모듈을 기억하므로 다른 모듈로 내보낼 때 전역 변수를 찾기 위해 생성된 모듈을 계속 찾습니다.

같은 이름의 지역 변수

같은 이름의 지역 변수를 생성하면 전역 변수를 덮어씁니다:

 def use_local_with_same_name_as_global(): # bad name for a local variable, though. global_variable = 'Baz' return global_variable + '!!!' >>> use_local_with_same_name_as_global() 'Baz!!!'

그러나 이름이 잘못된 지역 변수를 사용해도 전역 변수는 변경되지 않습니다.

 >>> use_global_variable() 'Bar!!!'

당신이 하고 있는 일을 정확히 알고 있고 그렇게 해야 할 아주 좋은 이유가 없다면 전역 변수와 같은 이름을 가진 지역 변수를 사용하는 것을 피해야 합니다. 나는 아직 그런 이유를 만나지 못했다.

우리는 수업에서 같은 행동을 얻습니다.

댓글에 다음과 같이 묻습니다.

클래스 내부의 함수 내부에 전역 변수를 만들고 다른 클래스 내부의 다른 함수 내부에서 해당 변수를 사용하려면 어떻게 해야 합니까?

여기에서는 일반 함수에서와 마찬가지로 메서드에서도 동일한 동작을 수행한다는 것을 보여줍니다.

 class Foo: def foo(self): global global_variable global_variable = 'Foo' class Bar: def bar(self): return global_variable + '!!!' Foo().foo()

그리고 지금:

 >>> Bar().bar() 'Foo!!!'

그러나 모듈 네임스페이스를 어지럽히는 것을 피하기 위해 전역 변수를 사용하는 대신 클래스 속성을 사용하는 것이 좋습니다. self 인수를 사용하지 않습니다. cls 인수에서 class 속성을 변경하는 경우 편리함) 또는 정적 메서드( self 또는 cls )일 수 있습니다.

Aaron Hall

이미 존재하는 답변 외에도 더 혼란스럽게 만들기 위해 다음을 수행합니다.

Python에서 함수 내에서만 참조되는 변수는 암시적으로 global 입니다. 변수에 함수 본문 내 임의의 위치에 새 값이 할당되면 로컬 로 간주됩니다. 함수 내에서 변수에 새 값이 할당된 경우 해당 변수는 암시적으로 지역적이며 명시적으로 '전역'으로 선언해야 합니다.

처음에는 약간 놀랍지만 잠시 고려하면 이를 설명합니다. 한편으로 할당된 변수에 대한 전역 요구는 의도하지 않은 부작용에 대한 막대를 제공합니다. 반면에 모든 전역 참조에 대해 전역이 필요한 경우 항상 전역을 사용하게 됩니다. 내장 함수 또는 가져온 모듈의 구성 요소에 대한 모든 참조를 전역으로 선언해야 합니다. 이 어수선함은 부작용을 식별하기 위한 전역 선언의 유용성을 무효화합니다.

출처: Python의 지역 및 전역 변수에 대한 규칙은 무엇입니까? .

Rauni Lillemets

병렬 실행을 사용하면 무슨 일이 일어나고 있는지 이해하지 못하면 전역 변수로 인해 예기치 않은 결과가 발생할 수 있습니다. 다음은 다중 처리 내에서 전역 변수를 사용하는 예입니다. 각 프로세스가 자체 변수 복사본으로 작동한다는 것을 분명히 알 수 있습니다.

 import multiprocessing import os import random import sys import time def worker(new_value): old_value = get_value() set_value(random.randint(1, 99)) print('pid=[{pid}] ' 'old_value=[{old_value:2}] ' 'new_value=[{new_value:2}] ' 'get_value=[{get_value:2}]'.format( pid=str(os.getpid()), old_value=old_value, new_value=new_value, get_value=get_value())) def get_value(): global global_variable return global_variable def set_value(new_value): global global_variable global_variable = new_value global_variable = -1 print('before set_value(), get_value() = [%s]' % get_value()) set_value(new_value=-2) print('after set_value(), get_value() = [%s]' % get_value()) processPool = multiprocessing.Pool(processes=5) processPool.map(func=worker, iterable=range(15))

산출:

 before set_value(), get_value() = [-1] after set_value(), get_value() = [-2] pid=[53970] old_value=[-2] new_value=[ 0] get_value=[23] pid=[53971] old_value=[-2] new_value=[ 1] get_value=[42] pid=[53970] old_value=[23] new_value=[ 4] get_value=[50] pid=[53970] old_value=[50] new_value=[ 6] get_value=[14] pid=[53971] old_value=[42] new_value=[ 5] get_value=[31] pid=[53972] old_value=[-2] new_value=[ 2] get_value=[44] pid=[53973] old_value=[-2] new_value=[ 3] get_value=[94] pid=[53970] old_value=[14] new_value=[ 7] get_value=[21] pid=[53971] old_value=[31] new_value=[ 8] get_value=[34] pid=[53972] old_value=[44] new_value=[ 9] get_value=[59] pid=[53973] old_value=[94] new_value=[10] get_value=[87] pid=[53970] old_value=[21] new_value=[11] get_value=[21] pid=[53971] old_value=[34] new_value=[12] get_value=[82] pid=[53972] old_value=[59] new_value=[13] get_value=[ 4] pid=[53973] old_value=[87] new_value=[14] get_value=[70]

Bohdan

답은 항상 간단하다는 것이 밝혀졌습니다.

main 정의에 표시하는 간단한 방법이 있는 작은 샘플 모듈입니다.

 def five(enterAnumber,sumation): global helper helper = enterAnumber + sumation def isTheNumber(): return helper

main 정의에서 표시하는 방법입니다.

 import TestPy def main(): atest = TestPy atest.five(5,8) print(atest.isTheNumber()) if __name__ == '__main__': main()

이 간단한 코드는 그렇게 작동하며 실행됩니다. 도움이 되기를 바랍니다.

user2876408

당신이 말하는 것은 다음과 같은 방법을 사용하는 것입니다.

 globvar = 5 def f(): var = globvar print(var) f() # Prints 5

그러나 더 좋은 방법은 다음과 같이 전역 변수를 사용하는 것입니다.

 globvar = 5 def f(): global globvar print(globvar) f() #prints 5

둘 다 동일한 출력을 제공합니다.

gxyd

사용하려는 모든 함수에서 전역 변수를 참조해야 합니다.

다음과 같이:

 var = "test" def printGlobalText(): global var #wWe are telling to explicitly use the global version var = "global from printGlobalText fun." print "var from printGlobalText: " + var def printLocalText(): #We are NOT telling to explicitly use the global version, so we are creating a local variable var = "local version from printLocalText fun" print "var from printLocalText: " + var printGlobalText() printLocalText() """ Output Result: var from printGlobalText: global from printGlobalText fun. var from printLocalText: local version from printLocalText [Finished in 0.1s] """

Mohamed El-Saka

실제로 전역을 로컬 변수에 저장하는 것이 아니라 원래 전역 참조가 참조하는 동일한 개체에 대한 로컬 참조를 만드는 것뿐입니다. Python의 거의 모든 것은 객체를 참조하는 이름이며 일반적인 작업에서는 아무 것도 복사되지 않습니다.

식별자가 미리 정의된 전역 변수를 참조할 때를 명시적으로 지정할 필요가 없다면 식별자가 대신 새 지역 변수인 경우를 명시적으로 지정해야 할 것입니다(예: 'var' 명령 JavaScript에서 볼 수 있음). 지역 변수는 심각하고 사소한 시스템에서 전역 변수보다 더 일반적이기 때문에 대부분의 경우 Python의 시스템이 더 합리적입니다.

추측을 시도하는 언어가 있을 수 있습니다. 존재하는 경우 전역 변수를 사용하거나 존재하지 않는 경우 지역 변수를 생성할 수 있습니다. 그러나 이는 오류가 발생하기 쉽습니다. 예를 들어, 다른 모듈을 가져오면 실수로 해당 이름의 전역 변수가 도입되어 프로그램의 동작이 변경될 수 있습니다.

Kylotan

이 시도:

 def x1(): global x x += 1 print('x1: ', x) def x2(): global x x = x+1 print('x2: ', x) x = 5 print('x: ', x) x1() x2() # Output: # x: 5 # x1: 6 # x2: 7

Sagar Mehta

같은 이름의 지역 변수가 있는 경우 globals() 함수 를 사용할 수 있습니다.

 globals()['your_global_var'] = 42

Martin Thoma

계속해서 추가 기능으로 파일을 사용하여 로컬로 선언된 모든 전역 변수를 포함하고 다음으로 import as .

파일 initval.py :

 Stocksin = 300 Prices = []

파일 getstocks.py :

 import initval as iv def getmystocks(): iv.Stocksin = getstockcount() def getmycharts(): for ic in range(iv.Stocksin):

user5473311

전역 배열의 명시적 요소에 쓰는 것은 분명히 전역 선언을 필요로 하지 않지만 "도매"에 쓰는 것은 요구 사항이 있습니다.

 import numpy as np hostValue = 3.14159 hostArray = np.array([2., 3.]) hostMatrix = np.array([[1.0, 0.0],[ 0.0, 1.0]]) def func1(): global hostValue # mandatory, else local. hostValue = 2.0 def func2(): global hostValue # mandatory, else UnboundLocalError. hostValue += 1.0 def func3(): global hostArray # mandatory, else local. hostArray = np.array([14., 15.]) def func4(): # no need for globals hostArray[0] = 123.4 def func5(): # no need for globals hostArray[1] += 1.0 def func6(): # no need for globals hostMatrix[1][1] = 12. def func7(): # no need for globals hostMatrix[0][0] += 0.33 func1() print "After func1(), hostValue = ", hostValue func2() print "After func2(), hostValue = ", hostValue func3() print "After func3(), hostArray = ", hostArray func4() print "After func4(), hostArray = ", hostArray func5() print "After func5(), hostArray = ", hostArray func6() print "After func6(), hostMatrix = \n", hostMatrix func7() print "After func7(), hostMatrix = \n", hostMatrix

Mike Lampton

변경 사항을 표시하려는 클래스 네임스페이스를 참조하십시오.

이 예에서 runner는 config.xml 파일에서 max를 사용하고 있습니다. 러너가 사용할 때 테스트에서 max 값을 변경하고 싶습니다.

메인/config.py

 max = 15000

메인/러너.py

 from main import config def check_threads(): return max < thread_count

테스트/runner_test.py

 from main import runner # <----- 1. add file from main.runner import check_threads class RunnerTest(unittest): def test_threads(self): runner.max = 0 # <----- 2. set global check_threads()

llewellyn falco

다른 답변에서 본 적이 없기 때문에 이것을 추가하고 있으며 비슷한 문제로 어려움을 겪고 있는 사람에게 유용할 수 있습니다. globals() 함수는 "마법처럼" 코드의 나머지 부분에 사용할 수 있는 데이터를 만들 수 있는 변경 가능한 전역 기호 사전을 반환합니다. 예를 들어:

 from pickle import load def loaditem(name): with open(r"C:\pickle\file\location"+"\{}.dat".format(name), "rb") as openfile: globals()[name] = load(openfile) return True

그리고

 from pickle import dump def dumpfile(name): with open(name+".dat", "wb") as outfile: dump(globals()[name], outfile) return True

전역 네임스페이스 안팎으로 변수를 덤프/로드할 수 있습니다. 매우 편리하고 번거롭거나 소란이 없습니다. 확실히 Python 3 전용입니다.

Rafaël Dera

전역은 괜찮습니다 - 다중 처리 제외

한편으로는 Windows/Mac OS, 다른 한편으로는 Linux와 같이 서로 다른 플랫폼/환경에서 멀티프로세싱과 관련된 전역은 번거롭습니다.

얼마 전에 내가 겪었던 문제를 지적하는 간단한 예를 통해 이것을 보여 드리겠습니다.

Windows/MacO 및 Linux에서 상황이 다른 이유를 이해하려면 새 프로세스를 시작하는 기본 메커니즘이 ...

• Windows/MacO는 '스폰'입니다.
• 리눅스는 '포크'다

그들은 메모리 할당 초기화가 다릅니다 ... (하지만 여기에서는 다루지 않습니다).

문제/예제를 살펴보겠습니다.

 import multiprocessing counter = 0 def do(task_id): global counter counter +=1 print(f'task {task_id}: counter = {counter}') if __name__ == '__main__': pool = multiprocessing.Pool(processes=4) task_ids = list(range(4)) pool.map(do, task_ids)

창

이것을 Windows에서 실행하면(MacOS에서도 가정합니다) 다음과 같은 출력을 얻습니다.

 task 0: counter = 1 task 1: counter = 2 task 2: counter = 3 task 3: counter = 4

리눅스

Linux에서 이것을 실행하면 대신 다음을 얻습니다.

 task 0: counter = 1 task 1: counter = 1 task 2: counter = 1 task 3: counter = 1

thomas

변수를 전역으로 선언하는 두 가지 방법이 있습니다.

1. 함수 내부에 변수를 할당하고 전역 라인을 사용합니다.

 def declare_a_global_variable(): global global_variable_1 global_variable_1 = 1 # Note to use the function to global variables declare_a_global_variable()

2. 함수 외부에 변수 할당:

 global_variable_2 = 2

이제 다른 함수에서 선언된 전역 변수를 사용할 수 있습니다.

 def declare_a_global_variable(): global global_variable_1 global_variable_1 = 1 # Note to use the function to global variables declare_a_global_variable() global_variable_2 = 2 def print_variables(): print(global_variable_1) print(global_variable_2) print_variables() # prints 1 & 2

참고 1:

update_variables() 와 같은 다른 함수 내에서 전역 변수를 변경하려면 변수를 할당하기 전에 해당 함수에서 전역 줄을 사용해야 합니다.

 global_variable_1 = 1 global_variable_2 = 2 def update_variables(): global global_variable_1 global_variable_1 = 11 global_variable_2 = 12 # will update just locally for this function update_variables() print(global_variable_1) # prints 11 print(global_variable_2) # prints 2

노트 2:

함수 내에서 전역 줄을 사용하지 않는 동안 목록 및 사전 변수에 대한 참고 1에 대한 예외가 있습니다.

 # declaring some global variables variable = 'peter' list_variable_1 = ['a','b'] list_variable_2 = ['c','d'] def update_global_variables(): """without using global line""" variable = 'PETER' # won't update in global scope list_variable_1 = ['A','B'] # won't update in global scope list_variable_2[0] = 'C' # updated in global scope surprisingly this way list_variable_2[1] = 'D' # updated in global scope surprisingly this way update_global_variables() print('variable is: %s'%variable) # prints peter print('list_variable_1 is: %s'%list_variable_1) # prints ['a', 'b'] print('list_variable_2 is: %s'%list_variable_2) # prints ['C', 'D']

Mohsen Haddadi

이 답변을 받았지만 한 줄을 선호하므로 다시 솔루션을 제공합니다. 이것은 함수 내에서 전역 변수를 생성하려는 경우입니다.

 def someFunc(): x=20 globals()['y']=50 someFunc() # invoking function so that variable Y is created globally print(y) # output 50 print(x) #NameError: name 'x' is not defined as x was defined locally within function

Pavn

출처 : 여기를 클릭하세요

출처 : http:www.stackoverflow.com/questions/423379/using-global-variables-in-a-function