함수에 전역 변수 사용
함수 내에서 글로벌 변수를 작성하거나 사용하려면 어떻게 해야 합니까?
다른 함수의 한 함수에 정의된 글로벌 변수를 사용하려면 어떻게 해야 합니까?
할 경우 변수를 할 수 있습니다.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
globvar = 1하거나 글로벌 변경하는 Python은 변수를 Python과 함께 할 수 있습니다.global키워드를 지정합니다.
모듈 간에 글로벌 변수를 공유하는 경우 다른 답변을 참조하십시오.
제가 당신의 상황을 올바르게 이해하고 있다면, 당신이 보고 있는 것은 Python이 로컬(함수)과 글로벌(모듈) 네임스페이스를 어떻게 처리하느냐의 결과입니다.
예를 들어 다음과 같은 모듈이 있다고 가정합니다.
# sample.py
_my_global = 5
def func1():
_my_global = 42
def func2():
print _my_global
func1()
func2()
이것은 42 로 인쇄될 것으로 예상되지만, 대신에 5 로 인쇄됩니다. 것처럼 '우리'를global 」에의 선언func1() , , , 「 」func2()42를 합니다.
def func1():
global _my_global
_my_global = 42
여기서 일어나는 일은 Python이 함수의 어디에 할당되어 있는 이름은 특별히 지시하지 않는 한 해당 함수의 로컬 이름이라고 가정하는 것입니다.이름에서만 읽을 수 있고 이름이 로컬에 존재하지 않는 경우 포함된 범위(모듈의 글로벌 범위 등)에서 이름을 검색하려고 합니다.
하면 42가 할당됩니다._my_global따라서 Python은 같은 이름의 글로벌 변수를 음영으로 하는 로컬 변수를 만듭니다.이 로컬은 범위를 벗어나 가비지가 수집됩니다.func1(), 「」, 「」func2()는 (변경되지 않은) 글로벌 이름 이외에는 볼 수 없습니다.은 실행 이 아닌 에 이루어집니다.이.예를 들어, 다음의 값을 읽어낼 수 있습니다._my_global에 inside inside inside func1()과제를 하기 '어디서나', '어디서나', '어디서나'가 나옵니다.UnboundLocalErrorPython은 이미 로컬 변수여야 한다고 결정했지만 아직 연관된 값은 없습니다.'를 global 다른
(이 동작은 주로 로컬 네임스페이스의 최적화에 의해 발생했다고 생각합니다.이 동작이 없으면 Python의 VM은 함수 내부에 새로운 이름이 할당될 때마다 최소 3개의 이름 검색을 수행해야 합니다(모듈/빌트인레벨에서 이름이 이미 존재하지 않도록 하기 위해).이 경우 매우 느려집니다).공통 조작).
네임스페이스의 개념을 살펴볼 수 있습니다.Python에서 모듈은 글로벌 데이터의 자연스러운 장소입니다.
각 모듈에는 모듈에 정의된 모든 기능에 의해 글로벌 기호 테이블로 사용되는 자체 기호 테이블이 있습니다.따라서 모듈 작성자는 사용자의 글로벌 변수와의 우발적인 충돌을 걱정하지 않고 모듈에서 글로벌 변수를 사용할 수 있습니다. 있는 에는 모듈의 를 그 함수를 할 수 .
modname.itemname.
global-in-a-module의 구체적인 용도는 "모듈 간에 글로벌 변수를 공유하는 방법"에 설명되어 있습니다.완전성을 위해 내용은 다음과 같습니다.
단일 프로그램 내의 모듈 간에 정보를 공유하는 표준 방법은 특별한 구성 모듈(config 또는 cfg라고도 함)을 작성하는 것입니다.어플리케이션의 모든 모듈에 컨피규레이션모듈을 Import하기만 하면 모듈은 글로벌 이름으로 사용할 수 있습니다.각 모듈의 인스턴스는 1개뿐이므로 모듈개체에 대한 변경은 모든 곳에 반영됩니다.예를 들어 다음과 같습니다.
파일: config.화이
x = 0 # Default value of the 'x' configuration setting
파일: mod.py
import config
config.x = 1
파일: 메인.화이
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
>>>
「Baz」의 할당 되는 「해 주세요.foo()한 " " " 입니다LOAD_FAST★★★★★★ 。
함수의 글로벌 변수를 참조하려면 global 키워드를 사용하여 어떤 변수가 글로벌한지 선언할 수 있습니다.모든 경우에 사용할 필요는 없습니다(여기서 잘못 설명한 것처럼). 표현식에서 참조된 이름이 로컬 범위 또는 이 함수가 정의된 함수 범위에서 발견되지 않으면 글로벌 변수 중에서 검색됩니다.
단, 함수로 글로벌하게 선언되지 않은 새로운 변수에 할당하면 해당 변수는 암묵적으로 로컬로 선언되어 같은 이름의 기존 글로벌 변수가 가려질 수 있습니다.
또한 일부 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!!!'
함수 내부에서 전역 변수 수정
글로벌 변수를 다른 개체로 지정하려면 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!!!'
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!!!'
글로벌과 같은 이름의 로컬 변수를 사용하는 것은 자신이 무엇을 하고 있는지 정확히 알고 있고 그럴 만한 충분한 이유가 없는 한 피해야 합니다.나는 아직 그런 이유를 접하지 못했다.
우리는 수업에서 같은 행동을 한다.
팔로우 온 코멘트는 다음과 같이 질문합니다.
클래스 내의 함수 내에 글로벌 변수를 만들고 다른 클래스 내의 다른 함수 내에 해당 변수를 사용하려면 어떻게 해야 합니까?
여기에서는, 통상의 기능에서와 같은 동작을 수법에서도 볼 수법은 다음과 같습니다.
class Foo:
def foo(self):
global global_variable
global_variable = 'Foo'
class Bar:
def bar(self):
return global_variable + '!!!'
Foo().foo()
그리고 지금:
>>> Bar().bar()
'Foo!!!'
그러나 모듈 네임스페이스를 어지럽히지 않기 위해 글로벌 변수를 사용하는 대신 클래스 속성을 사용하는 것이 좋습니다. 우리는 ,, 에, 에, 에, 에, 델, 델, also, also, also, alsoself 수 인 클래스 를 "-"에서 ).cls 메서드(no "no" "no")self ★★★★★★★★★★★★★★★★★」cls를 참조해 주세요.
기존 답변에 더하여 이 문제를 더욱 혼란스럽게 합니다.
Python에서는 함수 내에서만 참조되는 변수는 암묵적으로 글로벌합니다.변수가 함수 본문 내의 임의의 위치에 새 값이 할당되면 해당 변수는 로컬로 간주됩니다.함수 내에 새로운 값이 할당된 경우 변수는 암묵적으로 로컬이므로 명시적으로 '글로벌'로 선언해야 합니다.
처음에는 조금 놀랐지만, 잠시 생각해 보면 알 수 있다.한편 할당된 변수에 대해 글로벌을 요구하면 의도하지 않은 부작용을 막을 수 있습니다.한편, 모든 글로벌 레퍼런스에 global이 필요한 경우에는 항상 global을 사용합니다.내장된 함수 또는 Import된 모듈의 컴포넌트에 대한 모든 참조를 글로벌하게 선언해야 합니다.이러한 혼란은 부작용을 식별하기 위한 글로벌 선언의 유용성을 무너뜨릴 것이다.
출처: Python의 로컬 변수와 글로벌 변수의 규칙은 무엇입니까?
병렬 실행 시 무슨 일이 일어나고 있는지 모를 경우 글로벌 변수가 예기치 않은 결과를 초래할 수 있습니다.다음은 다중 처리에서 전역 변수를 사용하는 예입니다.각 프로세스가 변수의 자체 복사본과 함께 작동하는 것을 명확하게 알 수 있습니다.
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
단, 글로벌 변수를 다음과 같이 사용하는 것이 좋습니다.
globvar = 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]
"""
이것을 시험해 보세요.
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
실제로 로컬 변수에 글로벌을 저장하는 것이 아니라 원래 글로벌 참조가 참조하는 동일한 개체에 대한 로컬 참조를 만드는 것입니다.Python의 거의 모든 것은 오브젝트를 가리키는 이름이며, 통상적인 조작에서는 아무것도 복사되지 않는다는 것을 기억하십시오.
식별자가 사전 정의된 글로벌을 참조할 시기를 명시적으로 지정할 필요가 없다면 식별자가 새로운 로컬 변수인 경우(예를 들어 JavaScript에서 볼 수 있는 'var' 명령어 등)를 명시적으로 지정해야 합니다.심각하거나 중요하지 않은 시스템에서는 로컬 변수가 글로벌 변수보다 더 일반적이기 때문에 대부분의 경우 Python의 시스템이 더 타당합니다.
글로벌 변수가 있는 경우 전역 변수를 사용하거나 존재하지 않는 경우 로컬 변수를 생성하여 추측을 시도하는 언어를 사용할 수 있습니다.그러나 이는 오류가 발생하기 쉽습니다.예를 들어 다른 모듈을 Import하면 실수로 해당 이름의 글로벌 변수가 발생하여 프로그램의 동작이 변경될 수 있습니다.
이름이 같은 로컬 변수가 있는 경우 함수를 사용할 수 있습니다.
globals()['your_global_var'] = 42
및 글로벌 하며, 그 다음에는 로컬로 선언된 모든 글로벌 변수를 합니다.import as:
파일 초기화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
다른 답변에서는 본 적이 없고 비슷한 것을 가지고 고민하는 사람에게 유용할 수 있기 때문에 덧붙입니다.함수는 코드의 나머지 부분에서 데이터를 "마술적으로" 사용할 수 있는 변환 가능한 글로벌 기호 사전을 반환합니다.예를 들어 다음과 같습니다.
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 만이 틀림없어요.
변경 내용을 표시할 클래스 네임스페이스를 참조합니다.
이 예에서는 runner가 파일Config에서 max를 사용하고 있습니다.나는 내 테스트에서 max 값을 runner가 사용하고 있을 때 변경하고 싶다.
메인/구성화이
max = 15000
메인/러너화이
from main import config
def check_threads():
return max < thread_count
tests/runner_test.화이
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()
전역은 정상입니다(멀티프로세싱 제외).
한쪽은 Windows/Mac OS, 다른 한쪽은 Linux와 같이 다른 플랫폼/환경에서의 멀티프로세싱과 관련된 글로벌한 작업은 번거롭다.
제가 얼마 전에 마주친 문제를 간단히 예를 들어 설명하겠습니다.
Windows/MacOs 및 Linux에서 다른 이유를 알고 싶다면 새로운 프로세스를 시작하는 기본 메커니즘을 알아야 합니다.
- Windows/MacO는 '스판'입니다.
- Linux는 '포크'
메모리 할당과 초기화가 다릅니다(단, 여기서는 설명하지 않습니다).
문제/예시를 살펴봅시다...
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
리눅스
리눅스에서 실행하면 대신 다음과 같은 메시지가 표시됩니다.
task 0: counter = 1
task 1: counter = 1
task 2: counter = 1
task 3: counter = 1
변수를 글로벌하게 선언하는 방법에는 다음 2가지가 있습니다.
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:
like like a like like like like like like like like like like like like like like like like like와 같이 다른 함수의 변수를 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']
답변은 되었지만, 저는 단일 라인을 선호하기 때문에 다시 솔루션을 제공합니다. 이것은 함수 내에 글로벌 변수를 만들고 싶은 경우입니다.
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
global_var = 10 # will be considered as a global variable
def func_1():
global global_var # access variable using variable keyword
global_var += 1
def func_2():
global global_var
global_var *= 2
print(f"func_2: {global_var}")
func_1()
func_2()
print("Global scope:", global_var) # will print 22
설명:
global_var는 글로벌 변수이며 모든 함수 및 클래스가 해당 변수에 액세스할 수 있습니다.
func_1()는 키워드를 하여 이 .global글로벌 스코프에 기술된 변수를 가리킵니다. 경우 변수 global을 합니다.global_var에 inside inside inside func_1는 함수 내에서만 사용할 수 있는 로컬 변수로 간주됩니다.그럼 안으로func_11번으로 하다
일이 func_2().
" " " 를 func_1 ★★★★★★★★★★★★★★★★★」func_2 「 」가 됩니다.global_var
다음과 같은 코드:
myVar = 12
def myFunc():
myVar += 12
키:
변수를 문자열 외부에 선언하면 글로벌 변수가 됩니다.
문자열 내에 변수를 선언하면 로컬 변수가 됩니다.
내에 키워드 ""를합니다.global선언할 변수 앞에 다음 명령을 입력합니다.
myVar = 124
def myFunc():
global myVar2
myVar2 = 100
myFunc()
print(myVar2)
그리고 서류에 100이 있습니다.
Initialized = 0 #Here This Initialized is global variable
def Initialize():
print("Initialized!")
Initialized = 1 #This is local variable and assigning 1 to local variable
while Initialized == 0:
여기에서는 글로벌 변수를 비교하고 있습니다.초기화된 값은 0입니다.루프 조건이 충족된 동안
Initialize()
함수가 호출됩니다.루프는 무한합니다.
#if we do Initialized=1 then loop will terminate
else:
print("Lets do something else now!")
언급URL : https://stackoverflow.com/questions/423379/using-global-variables-in-a-function
'programing' 카테고리의 다른 글
| 내가 왜 템플리팅 엔진을 쓰겠어?jsp include 및 jstl vs 타일, 프리마커, 속도, 시트메쉬 (0) | 2022.10.21 |
|---|---|
| 계속하기 전에 하나의 기능이 완료될 때까지 기다리는 올바른 방법입니까? (0) | 2022.10.21 |
| Google Invisible reCAPTCHA 배지를 숨기는 방법 (0) | 2022.10.20 |
| 팬더 컬럼의 값을 dict로 다시 매핑하고 NaNs를 보존합니다. (0) | 2022.10.20 |
| Data Transfer Object(DTO; 데이터 전송 객체)가 안티 패턴인 이유는 무엇입니까? (0) | 2022.10.20 |