it-swarm-ko.tech

함수에서 전역 변수 사용

함수에서 전역 변수를 만들거나 사용할 수 있습니까?

한 함수에서 전역 변수를 만드는 경우 다른 변수에서 전역 변수를 어떻게 사용할 수 있습니까? 글로벌 변수를 액세스가 필요한 함수의 로컬 변수에 저장해야합니까?

2782
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 키워드를 명시 적으로 요구함으로써 당신이 실제로 무엇을하는지 알고 싶어합니다.

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

3855
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

여기서 진행되는 것은 Python은 에 할당 된 이름 이 함수 내 어디에서나 해당 함수의 로컬 이름이라고 가정합니다. 달리 명시하지 않는 한. 이름에서 읽기 만 있고 이름이 로컬에 존재하지 않으면 포함 범위에서 이름을 찾으려고 시도합니다 (예 : 모듈의 전역 범위).

myGlobal 이름에 42를 할당하면 Python은 같은 이름의 전역 변수를 가리는 로컬 변수를 만듭니다. 해당 지역이 범위를 벗어나고 func1()이 반환 될 때 garbage-collected 입니다. 한편, func2()은 (수정되지 않은) 글로벌 이름 이외의 다른 것을 볼 수 없습니다. 이 네임 스페이스 결정은 런타임이 아닌 컴파일 타임에 발생합니다. 할당하기 전에 func1() 내부에서 myGlobal 값을 읽으면 UnboundLocalError Python은 (는) 이미 지역 변수 여야한다고 결정했지만 아직 관련 값이 없습니다. 그러나 'global'문을 사용하면 Python에 로컬에 할당하는 대신 이름을 다른 곳에서 찾아야한다고 알립니다.

(이 동작은 로컬 네임 스페이스의 최적화를 통해 주로 발생했다고 생각합니다.이 동작이 없으면 Python의 VM은 함수 내부에 새 이름이 할당 될 때마다 적어도 세 개의 이름 조회를 수행해야합니다 ( 이름이 모듈/내장 레벨에 존재하지 않는지 확인하십시오.)

732
Jeff Shannon

네임 스페이스 의 개념을 탐색하고자 할 수 있습니다. 파이썬에서 module global data의 자연스러운 장소입니다.

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

Global-in-a-module의 특정 사용법은 여기에 설명되어 있습니다 - how-do-i-share-global-variables-across-modules , 그리고 내용을 완전하게하기 위해 여기에서 공유됩니다 :

단일 프로그램 내에서 정보를 모듈간에 공유하는 표준 방법은 특별한 구성 모듈 (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
195
gimel

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

>>> 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 변수 인 방법을보십시오.

함수의 전역 변수를 참조하려면 global 키워드를 사용하여 어떤 변수가 전역 변수인지 선언 할 수 있습니다. 모든 경우에 이것을 사용할 필요는 없습니다 (여기에 잘못 주장하는 사람처럼) - 표현식에서 참조 된 이름이이 함수가 정의 된 함수의 로컬 범위 나 범위에서 발견되지 않으면 전역 적으로 조회됩니다 변수.

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

또한 전역 변수는 특히 OOP가 과도한 작은 스크립트에 대해 달리 주장하는 일부 OOP zealots와는 달리 유용합니다.

54
J S

이미 존재하는 해답 이외에 더 혼란스럽게 만들기 위해서 :

파이썬에서 함수 내에서만 참조되는 변수는 암시 적으로 전역입니다. 변수가 함수 본문 내에서 새 값으로 지정되면 local으로 간주됩니다. 함수 내에서 변수에 새로운 값이 할당되면 변수는 암시 적으로 지역 변수이므로 명시 적으로 '전역'으로 선언해야합니다.

처음에는 약간 놀랍지 만 잠시 생각해 보면이 사실이 설명됩니다. 한편으로는 할당 된 변수에 대해 전역 변수를 요구하면 의도하지 않은 부작용을 막을 수 있습니다. 다른 한편, 모든 글로벌 레퍼런스에 글로벌이 필요한 경우, 글로벌을 항상 사용하게 될 것입니다. 내장 함수 또는 가져온 모듈의 구성 요소에 대한 모든 참조를 전역으로 선언해야합니다. 이 혼란은 부작용을 확인하기위한 전역 적 선언의 유용성을 무너 뜨릴 것입니다.

출처 : 파이썬에서 지역 변수와 전역 변수에 대한 규칙은 무엇입니까?.

42
Rauni Lillemets

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

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

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!!!'

자신이하는 일을 정확하게 알고 그럴 이유가없는 한 전역 변수와 같은 이름의 로컬 변수를 사용하지 않는 것이 좋습니다. 나는 그런 이유를 아직 겪지 않았다.

37
Aaron Hall

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

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]
31
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 __== '__main__':
    main()

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

22
user2876408

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

globvar = 5

def f():
    var = globvar
    print(var)

f()  # Prints 5

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

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

둘 다 같은 결과를냅니다.

21
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]
"""
20
Mohamed El-Saka

실제로 전역 변수를 로컬 변수에 저장하지 않고 원본 전역 참조가 참조하는 것과 동일한 객체에 대한 로컬 참조를 만듭니다. Python의 거의 모든 것이 객체를 참조하는 이름이며, 일반적인 작업에서는 아무것도 복사되지 않는다는 것을 기억하십시오.

식별자가 미리 정의 된 전역 변수를 참조하는 시점을 명시 적으로 지정할 필요가 없다면 식별자가 새로운 지역 변수 일 때 명시 적으로 지정해야합니다 (예 : 'var'명령 자바 스크립트에서 보임). 지역 변수는 모든 중대하고 사소한 시스템에서 전역 변수보다 더 일반적이므로 대부분의 경우 Python의 시스템이 더 적합합니다.

You could 추측하려고 시도한 언어가있을 경우 전역 변수를 사용하거나 그렇지 않은 경우 지역 변수를 작성합니다. 그러나 이것은 매우 오류가 발생하기 쉽습니다. 예를 들어 다른 모듈을 가져 오면 그 이름으로 전역 변수가 부주의하게 프로그램의 동작을 변경시킬 수 있습니다.

18
Kylotan

이 시도:

def x1():
    global x
    x = 6

def x2():
    global x
    x = x+1
    print x

x = 5
x1()
x2()  # output --> 7
15
Sagar Mehta

다음에 추가 할 때와 같이 파일을 사용하여 로컬로 선언 된 모든 전역 변수를 포함하고 '다음으로 가져 오기'를 수행하십시오.

Initval.py 파일

Stocksin = 300
Prices = []

파일 getstocks.py

import  initval as  iv

Def   getmystocks (): 
     iv.Stocksin  = getstockcount ()


Def getmycharts ():
    For ic in range (0,iv.Stocksin):

.....

12
user5473311

같은 이름의 로컬 변수가있는 경우 globals() 함수 를 사용하는 것이 좋습니다.

globals()['your_global_var'] = 42
12
Martin Thoma

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

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
11
Mike Lampton

나는 이것을 다른 어떤 대답에서도 보지 못했기 때문에 이것을 덧붙이고 있는데, 누군가 비슷한 것으로 고민하는 데 유용 할 수 있습니다. 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

전역 네임 스페이스에서 변수를 덤프 /로드 할 수 있습니다. 슈퍼 편리한, 아니 muss, 아니 호들갑. 파이썬 3에서만 가능합니다.

5
Rafaël Dera

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

이 예제에서 러너는 파일 config에서 max 를 사용하고 있습니다. 러너가 그것을 사용할 때 max 의 값을 바꾸기 위해 테스트를하고 싶습니다.

main/config.py

max = 15000

main/runner.py

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

tests/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()
5
llewellyn falco