python - 함수 - 파이썬 클래스 전역변수




함수에서 전역 변수 사용 (12)

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

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


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

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

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

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

같은 이름의 지역 변수

같은 이름의 로컬 변수를 만들면 전역 변수에 그림자가 생깁니다.

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

자신이하는 일을 정확하게 알고 그럴 필요가없는 한, 전역 변수와 같은 이름의 로컬 변수를 사용하지 않도록주의해야합니다. 나는 그런 이유를 아직 겪지 않았다.


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

globals()['your_global_var'] = 42

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

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

.....


답은 항상 간단합니다.

다음은 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()

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


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

이 예제에서 runner는 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()

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

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]

상황을 정확히 이해하고 있다면, 파이썬이 로컬 (함수) 및 전역 (모듈) 네임 스페이스를 처리하는 방법의 결과로 볼 수 있습니다.

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

# sample.py
myGlobal = 5

def func1():
    myGlobal = 42

def func2():
    print myGlobal

func1()
func2()

이미 언급했듯이 func1() ' global '선언을 추가하면 func2() 가 42를 인쇄합니다.

def func1():
    global myGlobal
    myGlobal = 42

여기에서는 파이썬이 명시 적으로 달리 언급하지 않는 한, 함수 내의 어느 곳 으로든 할당 된 이름이 그 함수에 국한된다고 가정합니다. 이름에서 읽는 것만으로 이름이 로컬에 존재하지 않으면 포함 된 범위 (예 : 모듈의 전역 범위)에서 이름을 찾으려고 시도합니다.

따라서 myGlobal 이라는 이름에 42를 할당하면 Python은 동일한 이름의 전역 변수를 음영 처리하는 로컬 변수를 만듭니다. 그 지역은 범위를 벗어나서 func1() 반환 될 때 garbage-collected 됩니다; 한편 func2() 는 (수정되지 않은) 전역 이름 이외의 것을 결코 볼 수 없습니다. 이 네임 스페이스 결정은 런타임이 아닌 컴파일 타임에 발생합니다. 파이썬이 func1() 을 할당하기 전에 func1() 내의 myGlobal 값을 읽는다면 UnboundLocalError 얻습니다. 로컬 변수이지만 아직 관련 값이 없습니다. 그러나 ' global '문을 사용하면 Python에 로컬로 할당하는 대신 다른 곳에서 이름을 찾아야한다고 말할 수 있습니다.

(이 동작은 로컬 네임 스페이스 최적화를 통해 주로 시작된 것으로 믿습니다.이 동작이 없으면 Python의 VM은 새 이름이 함수 내부에 할당 될 때마다 적어도 세 가지 이름 조회를 수행해야합니다 (이름이 ' t는 모듈 / 내장 레벨에서 이미 존재합니다), 이는 매우 일반적인 작업을 상당히 늦출 것입니다.)


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

식별자가 미리 정의 된 전역을 참조 할 때 명시 적으로 지정하지 않아도된다면 식별자가 새로운 지역 변수 일 때 명시 적으로 지정해야합니다 (예 : 'var'명령과 같은 것 자바 스크립트에서 본). 지역 변수는 심각하고 중요한 시스템에서 전역 변수보다 더 일반적이므로 대부분의 경우 Python의 시스템이 더 적합합니다.

추측을 시도한 언어가 있을 수 있습니다. 존재하는 경우 전역 변수를 사용하고 그렇지 않은 경우 로컬 변수를 작성합니다. 그러나 이것은 매우 오류가 발생하기 쉽습니다. 예를 들어, 다른 모듈을 가져 오면 우연히 그 이름으로 전역 변수가 삽입되어 프로그램의 동작이 변경 될 수 있습니다.


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

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

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

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


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

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

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

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

또한 전역 변수는 유용하다. 특히 OOP가 과도한 작은 스크립트의 경우에는 그렇지 않다.


namespaces 의 개념을 탐구하고 싶을 수 있습니다. 파이썬에서이 module글로벌 데이터를위한 자연스러운 장소입니다.

각 모듈에는 모듈에 정의 된 모든 함수에 의해 전역 기호 테이블로 사용되는 자체 전용 기호 테이블이 있습니다. 따라서 모듈 작성자는 사용자의 전역 변수와의 우발적 인 충돌을 걱정하지 않고 모듈의 전역 변수를 사용할 수 있습니다. 다른 한편, 당신이 무엇을하고 있는지 안다면, 함수의 참조를 위해 사용 된 것과 같은 표기법을 사용하여 모듈의 전역 변수를 modname.itemname 있습니다 : 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




scope