함수에서 글로벌 변수를 사용합니다

StackOverflow https://stackoverflow.com/questions/423379

  •  05-07-2019
  •  | 
  •  

문제

함수에서 글로벌 변수를 작성하거나 사용하려면 어떻게해야합니까?

한 기능에서 글로벌 변수를 만들면 다른 기능에서 해당 글로벌 변수를 어떻게 사용할 수 있습니까? 액세스가 필요한 함수의 로컬 변수에 글로벌 변수를 저장해야합니까?

도움이 되었습니까?

해결책

다른 기능에서 글로벌 변수를 사용할 수 있습니다. 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

그 이유는 글로벌 변수가 너무 위험하기 때문에 Python은 당신이 당신이 global 예어.

모듈에서 글로벌 변수를 공유하려면 다른 답변을 참조하십시오.

다른 팁

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

다음과 같은 모듈이 있다고 가정 해보십시오.

# sample.py
myGlobal = 5

def func1():
    myGlobal = 42

def func2():
    print myGlobal

func1()
func2()

이것을 42 인쇄 할 것으로 기대할 수도 있지만 대신 인쇄 5. 이미 언급 된 바와 같이, A를 추가하면 'global'선언 func1(), 그 다음에 func2() 42 인쇄합니다.

def func1():
    global myGlobal
    myGlobal = 42

여기서 일어나는 것은 파이썬이 모든 이름이 할당, 함수 내 어디에서나 명시 적으로 말하지 않는 한 해당 기능에 국한적입니다. 만이라면 독서 이름에서 이름은 로컬로 존재하지 않으므로 포함 된 스코프 (예 : 모듈의 글로벌 범위)에서 이름을 찾으려고합니다.

이름에 42를 할당 할 때 myGlobal, 따라서 Python은 동일한 이름의 글로벌 변수를 어둡게하는 로컬 변수를 만듭니다. 그 지역은 범위를 벗어나고 있습니다 쓰레기 수집 언제 func1() 보고; 그 동안에, func2() (수정되지 않은) 글로벌 이름 이외의 다른 것을 볼 수 없습니다. 이 네임 스페이스 결정은 런타임이 아닌 컴파일 시간에 발생합니다. myGlobal 내부에 func1() 당신이 그것을 할당하기 전에, 당신은 얻을 것입니다 UnboundLocalError, Python은 이미 로컬 변수 여야한다고 결정했지만 아직 관련된 가치가 없었기 때문입니다. 그러나 ''를 사용함으로써global'진술, 당신은 Python에게 로컬로 할당하는 대신 다른 곳에서 다른 곳을 찾아야한다고 말합니다.

(이 동작은 로컬 네임 스페이스의 최적화를 통해 주로 시작되었다고 생각합니다.이 동작이 없으면 Python의 VM은 함수 내부에 새 이름이 할당 될 때마다 최소 3 개의 이름 조회를 수행해야합니다 (이름이하지 않았는지 확인하기 위해 '). t는 이미 모듈/내장 레벨에 존재하며, 이는 매우 일반적인 작업을 크게 느리게 할 것입니다.)

당신은 그 개념을 탐구하고 싶을 수도 있습니다 네임 스페이스. 파이썬에서 기준 치수 자연스러운 장소입니다 글로벌 데이터:

각 모듈에는 자체 개인 기호 테이블이 있으며 모듈에 정의 된 모든 기능에 의해 글로벌 심볼 테이블로 사용됩니다. 따라서 모듈의 저자는 사용자의 글로벌 변수와 우발적 인 충돌에 대해 걱정하지 않고 모듈에서 글로벌 변수를 사용할 수 있습니다. 반면에, 당신이 무엇을하고 있는지 알고 있다면 함수를 참조하는 데 사용되는 동일한 표기법으로 모듈의 글로벌 변수를 만질 수 있습니다. modname.itemname.

전 세계 모듈의 구체적인 사용이 여기에 설명되어 있습니다. 모듈에서 글로벌 변수를 어떻게 공유합니까?, 및 완전성을 위해 내용은 여기에서 공유됩니다.

단일 프로그램 내에서 모듈에서 정보를 공유하는 정식 방법은 특수 구성 모듈을 만드는 것입니다 (종종 호출 구성 또는 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

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(), 유일한 것입니다 LOAD_FAST 변하기 쉬운.

함수의 글로벌 변수를 참조하려면 글로벌 어떤 변수가 글로벌인지 선언하는 키워드. 모든 경우에 사용할 필요는 없습니다 (여기서 누군가가 잘못 주장하는 것처럼) - 표현식에 참조 된 이름을이 함수가 정의 된 함수의 로컬 범위 나 범위에서 찾을 수없는 경우 글로벌에서 찾아옵니다. 변수.

그러나 함수에서 글로벌로 선언되지 않은 새 변수에 할당하면 현지인으로 암시 적으로 선언되며 동일한 이름의 기존 글로벌 변수를 어둡게 할 수 있습니다.

또한 글로벌 변수는 유용하며, 특히 OOP가 과도한 소규모 스크립트의 경우 다른 주장을 주장하는 일부 OOP 열성과는 반대로 유용합니다.

이미 존재하는 답변 외에도 더 혼란스럽게 만듭니다.

파이썬에서 함수 내부에서만 참조되는 변수는 다음과 같습니다. 암시 적으로 글로벌. 변수에 기능 본문 내에서 새 값이 할당되면 현지의. 변수에 함수 내부에 새 값이 할당 된 경우 변수는 암시 적으로 로컬이며이를 '글로벌'으로 명시 적으로 선언해야합니다.

처음에는 약간 놀랍지 만 순간의 고려 사항은 이것을 설명합니다. 한편으로 할당 된 변수에 대해 글로벌을 요구하면 의도하지 않은 부작용에 대한 막대가 제공됩니다. 반면에, 글로벌이 모든 글로벌 참조에 필요한 경우 항상 글로벌을 사용하게 될 것입니다. 내장 함수 또는 가져온 모듈의 구성 요소에 대한 모든 참조를 전체적으로 선언해야합니다. 이 혼란은 부작용을 식별하기위한 글로벌 선언의 유용성을 물리 칠 것입니다.

원천: 파이썬의 로컬 및 글로벌 변수에 대한 규칙은 무엇입니까?.

한 기능에서 글로벌 변수를 만들면 다른 기능에서 해당 변수를 어떻게 사용할 수 있습니까?

다음 기능으로 글로벌을 만들 수 있습니다.

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

기능 내부에서 글로벌 변수를 수정합니다

다른 객체에서 글로벌 변수를 지적하려면 글로벌 키워드를 다시 사용해야합니다.

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

이 기능을 작성한 후에는 코드가 실제로 변경되지 않았습니다.

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

따라서 기능을 호출 한 후 :

>>> change_global_variable()

글로벌 변수가 변경되었음을 알 수 있습니다. 그만큼 global_variable 이제 이름은 다음을 가리 킵니다 'Bar':

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

Python의 "Global"은 진정으로 글로벌이 아니며 모듈 수준에 대한 글로벌 일뿐입니다. 따라서 글로벌 인 모듈에 작성된 기능 만 사용할 수 있습니다. 기능은 작성된 모듈을 기억하므로 다른 모듈로 내보낼 때는 여전히 전역 변수를 찾기 위해 생성 된 모듈을 살펴 봅니다.

이름이 같은 로컬 변수

동일한 이름의 로컬 변수를 만들면 글로벌 변수를 어둡게합니다.

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

당신이하고있는 일을 정확하게 알고 있지 않고 그렇게 할 좋은 이유가 없다면 글로벌과 동일한 이름의 로컬 변수를 사용하지 않아야합니다. 나는 아직 그런 이유를 발견하지 못했습니다.

병렬 실행을 통해 글로벌 변수는 무슨 일이 일어나고 있는지 이해하지 못하면 예상치 못한 결과를 초래할 수 있습니다. 다음은 멀티 프로세싱 내에서 글로벌 변수를 사용하는 예입니다. 각 프로세스가 자체 변수 사본과 함께 작동한다는 것을 분명히 알 수 있습니다.

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]

그것이 밝혀진 바와 같이 대답은 항상 간단합니다.

다음은 간단한 방법이있는 작은 샘플 모듈입니다. 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()

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

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

globvar = 5

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

f()  # Prints 5

그러나 더 좋은 방법은 다음과 같은 글로벌 변수를 사용하는 것입니다.

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

둘 다 같은 출력을 제공합니다.

사용하려는 모든 기능에서 글로벌 변수를 참조해야합니다.

다음과 같이 :

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]
"""

실제로 글로벌을 로컬 변수에 저장하는 것이 아니라 원래 글로벌 참조와 동일한 객체에 대한 로컬 참조를 만듭니다. Python의 거의 모든 것이 객체를 언급하는 이름이며 일반적인 작업에서 복사되지 않습니다.

식별자가 사전 정의 된 글로벌을 참조 할 때를 명시 적으로 지정할 필요가 없다면 식별자가 새로운 로컬 변수 일 때 (예 : 'var'명령과 같은 내용을 명시 적으로 지정해야 할 것입니다. JavaScript에서 볼 수 있습니다). 현지 변수는 심각하고 사소한 시스템의 글로벌 변수보다 일반적이므로 Python의 시스템은 대부분의 경우 더 의미가 있습니다.

너 ~할 수 있었다 존재하는 경우 글로벌 변수를 사용하거나 그렇지 않은 경우 로컬 변수를 생성하는 언어가 있습니다. 그러나 그것은 매우 오류가 발생하기 쉽습니다. 예를 들어, 다른 모듈을 가져 오면 해당 이름으로 글로벌 변수를 부주의하게 도입하여 프로그램의 동작을 변경할 수 있습니다.

이 시도:

def x1():
    global x
    x = 6

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

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

동일한 이름의 로컬 변수가있는 경우 globals() 기능.

globals()['your_global_var'] = 42

다음과 추가로 파일을 사용하여 로컬로 선언 된 모든 글로벌 변수를 포함합니다. 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):

글로벌 배열의 명백한 요소에 글을 쓰는 것은 분명히 글로벌 선언이 필요하지는 않지만 "도매"에 쓰는 것은 다음과 같은 요구 사항을 가지고 있습니다.

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

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

이 예에서는 러너가 사용 중입니다 맥스 파일 구성에서 내 테스트가 가치를 바꾸고 싶습니다 맥스 러너가 사용하는 경우.

main/config.py

max = 15000

메인/러너

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()

다른 답변에서 보지 못했기 때문에 이것을 추가하고 있으며 비슷한 일로 어려움을 겪고있는 사람에게 유용 할 수 있습니다. 그만큼 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

전역 네임 스페이스에서 변수를 덤프/로드 할 수 있습니다. 매우 편리하고, 무스, 소란도 없습니다. 확실히 파이썬 3 일뿐입니다.

라이센스 : CC-BY-SA ~와 함께 속성
제휴하지 않습니다 StackOverflow
scroll top