Mundo ng Python Programming

Epektibong Paggamit ng Global sa Python at Mga Patnubay

Mga Function, Klase, at Estruktura
目次

1. Ano ang global variable?

Pangunahing konsepto ng global variable

Sa Python, ang global variable ay variable na maaaring ma-access sa buong programa. Ito ay tinutukoy sa labas ng mga function at klase, at ginagamit upang magbahagi ng data sa pagitan ng iba’t ibang function at module. Gayunpaman, ang labis na paggamit ng global variable ay maaaring magdulot ng hindi inaasahang bug, kaya dapat mag-ingat sa paggamit nito.
# Halimbawa ng global variable
global_var = "global variable"

def show_global():
    print(global_var)

show_global()  # Output: global variable
Ang global variable ay tinutukoy sa labas ng mga function at klase, at maaaring ma-refer mula sa anumang bahagi ng programa. Gayunpaman, kung babaguhin ito, kailangan ng espesyal na pag-iingat.

Pagkakaiba sa local variable

Hindi tulad ng global variable, ang local variable ay tinutukoy sa loob ng isang function, at ang saklaw nito ay limitado lamang sa function na iyon. Ang local variable ay winawasak kapag natapos na ang function, at hindi maaaring ma-access mula sa ibang function o mula sa labas.
def example_func():
    local_var = "local variable"
    print(local_var)

example_func()  # Output: local variable
# print(local_var)  # Error: Ang local variable ay hindi ma-access mula sa labas ng function
Sa pamamagitan ng pag-unawa sa pagkakaiba ng local at global variable, at ang tamang paggamit ng mga ito, mapapabuti ang maintainability ng code.

2. Paggamit ng Global na Variable sa Loob ng Function

Pag-refer at Pagbabago ng Global na Variable

Ang global na variable ay maaaring i-refer kahit sa loob ng function, ngunit upang baguhin ang halaga nito sa loob ng function, kinakailangan ang global na keyword. Kung hindi ito gagamitin, isang lokal na variable na may parehong pangalan ang malilikha sa loob ng function, at hindi maaapektuhan ang global na variable. <>counter = 0 # Global na variable def increase_counter(): global counter counter += 1 increase_counter() print(counter) # Output: 1

Pagpapakilala sa Keyword na nonlocal

Ang nonlocal na keyword ay ginagamit upang baguhin ang lokal na variable sa labas sa loob ng nested na function. Ito ay kapaki-pakinabang kapag gumagamit ng closure o sa mga kaso kung saan kailangang panatilihin ang estado sa loob ng function.
def outer_func():
    outer_var = "labas"

    def inner_func():
        nonlocal outer_var
        outer_var = "binagong labas"

    inner_func()
    print(outer_var)

outer_func()  # Output: binagong labas
Sa pamamagitan ng paggamit ng nonlocal, maaaring ma-access at manipulahin ng panloob na function ang lokal na variable sa labas.
年収訴求

3. Mga Paalala sa Paggamit ng Global na Variable

Mga Panganib ng Labis na Paggamit ng Global na Variable

Ang mga global na variable ay napaka-kapaki-pakinabang, ngunit kung labis na gagamitin, maaaring magdulot ng hindi inaasahang epekto sa buong programa. Lalo na kapag maraming function ang nagbabago ng parehong global na variable, nagiging mahirap subaybayan kung aling function ang kailan at paano binago ang halaga.
counter = 0

def increment():
    global counter
    counter += 1

def decrement():
    global counter
    counter -= 1

increment()
decrement()
print(counter)  # Output: 0
Sa ganitong paraan, kapag binabago ang mga global na variable sa maraming lugar, mas nagiging madali ang paglitaw ng mga bug, kaya inirerekomenda na iwasan ang paggamit nito hangga’t maaari at pamahalaan ang data sa ibang paraan.

Paghawak ng Error at Debug

Maaaring magkaroon ng hindi inaasahang mga error kapag gumagamit ng global na variable. Sa pamamagitan ng pagdagdag ng paghawak ng error at paggamit ng logging module, matutukoy kung saan naganap ang error, at magiging mas madali ang pag-debug.
import logging

logging.basicConfig(level=logging.DEBUG)

counter = 0

def increment():
    global counter
    try:
        counter += 1
        logging.debug(f"counter incremented: {counter}")
    except Exception as e:
        logging.error(f"Error: {e}")

increment()
Sa pamamagitan ng pamamaraang ito, maitatala kung saan ginawa ang pagbabago sa global na variable at kung anong mga error ang naganap.

4. Mga Best Practice sa Global Variable

Pagbabawas ng Paggamit ng Global Variable

Inirerekomenda na i-minimize ang paggamit ng global variable hangga’t maaari. Sa halip, sa pamamagitan ng paggamit ng mga argumento ng function at mga return value para magpalitan ng data, mapapalinaw ang daloy ng data at maiiwasan ang hindi sinasadyang pagbabago.
def add_points(score, points):
    return score + points

current_score = 0
current_score = add_points(current_score, 10)
print(current_score)  # Output: 10
Sa ganitong paraan, sa pamamagitan ng paggamit ng mga argumento at return value ng function, maaari mong pamahalaan ang data nang hindi umaasa sa global variable.

Pamamahala ng Estado Gamit ang Klase

Sa pamamagitan ng paggamit ng klase, maaari mong pamahalaan ang estado nang hindi gumagamit ng global variable. Ang klase ay isang epektibong paraan upang i-encapsulate ang data at gawing malinaw ang scope.
class Game:
    def __init__(self):
        self.score = 0

    def add_points(self, points):
        self.score += points

game = Game()
game.add_points(10)
print(game.score)  # Output: 10
Sa paggamit ng klase, maaari mong i-encapsulate ang estado sa bawat instance, at maiwasan ang hindi sinasadyang pagbabago mula sa ibang bahagi.
RUNTEQ（ランテック）｜超実戦型エンジニア育成スクール

5. Praktikal na mga Halimbawa at Aplikasyon

Halimbawa ng Paggamit sa Pagbuo ng Laro

Sa pagbuo ng laro, madalas gamitin ang global na variable para pamahalaan ang score at estado ng buhay, ngunit sa malalaking proyekto ay inirerekomenda ang paggamit ng mga klase o database para sa pamamahala.
score = 0  # Global na variable

def increase_score(points):
    global score
    score += points

increase_score(10)
print(f"Score ng manlalaro: {score}")  # Output: Score ng manlalaro: 10

Global na Variable para sa Pamamahala ng Settings

Ang mga setting na ginagamit sa buong aplikasyon (hal., debug mode at bersyon) ay madalas ituring na global na variable, ngunit maaaring pamahalaan nang mas epektibo sa pamamagitan ng pagsasama nito sa mga configuration file o environment variable.
config = {
    'debug': True,
    'version': '1.0'
}

def print_config():
    print(f"Debug mode: {config['debug']}, Bersyon: {config['version']}")

print_config()  # Output: Debug mode: True, Bersyon: 1.0

6. Buod at Susunod na Hakbang

Ang mga global na variable ay kapaki-pakinabang sa mga simpleng senaryo, ngunit kapag labis na ginagamit ay nagiging kumplikado ang code at nagiging sanhi ng mga bug. Ang paggamit ng mga argumento ng function, mga return value, at mga klase ay makakatulong upang limitahan ang paggamit ng mga global na variable, na nagdudulot ng mas epektibo at ligtas na disenyo ng programa.

Mga Paksa na Dapat Matutunan Sunod

Bilang susunod na hakbang, inirerekomenda na pag-aralan ang closure, module scope, object-oriented programming (OOP). Sa ganitong paraan, makakalikha ka ng mas kumplikadong programa nang hindi umaasa sa mga global na variable.

Mga Panlabas na Mapagkukunan at Sanggunian

  • Opisyal na Dokumentasyon ng Python Nagbibigay ito ng detalyadong paliwanag tungkol sa scope ng Python, closure, at OOP. Lalo na, nakakatulong ito sa pag-unawa sa LEGB rule (local, enclosing, global, built-in). Opisyal na Dokumentasyon ng Python
侍エンジニア塾