使用global关键字可在函数内修改全局变量，如声明global counter后可对全局counter进行递增操作。
在Python中，要在函数内部修改全局变量，最直接且推荐的方式是使用
global关键字明确声明该变量为全局变量。这样做告诉解释器，你不是要创建一个同名的局部变量，而是要操作外部作用域的那个全局变量。
解决方案
当你需要在函数内部对一个在函数外部定义（即全局作用域）的变量进行修改时，Python的默认行为是创建一个同名的局部变量。但如果你明确想改变全局变量的值，
global关键字就是你的通行证。
举个例子，假设我们有一个全局计数器：
counter = 0 # 这是一个全局变量
def increment_counter():
# 如果这里不加 global counter，那么 counter = 1 会创建一个局部变量
global counter
counter += 1
print(f"函数内部：计数器现在是 {counter}")
print(f"函数调用前：计数器是 {counter}")
increment_counter()
print(f"函数调用后：计数器是 {counter}")
# 再来一次
increment_counter()
print(f"第二次调用后：计数器是 {counter}")运行这段代码，你会看到
counter的值确实在函数调用后发生了变化。这背后其实是Python的作用域规则在起作用。当你
global counter的时候，Python就明白，哦，你指的是文件顶部的那个
counter，而不是要在这里搞个新的。我个人在写代码时，遇到需要修改全局变量的场景，往往会先停下来思考一下，是不是有更好的设计模式，因为
global虽然方便，但有时也会带来一些“副作用”。
立即学习“Python免费学习笔记（深入）”；
为什么不建议频繁修改全局变量？
我发现很多初学者，甚至一些有经验的开发者，都会时不时地滥用
global关键字。这就像是给了你一把万能钥匙，虽然能开所有门，但你可能会把家里的钥匙串弄得一团糟，分不清哪把是哪把。
最主要的原因是它会增加代码的耦合性和降低可维护性。当一个全局变量可以在程序的任何地方被修改时，追踪它的变化就成了一场噩梦。想象一下，你的程序突然出现了一个奇怪的bug，某个全局变量的值不对劲。你得翻遍所有可能修改它的函数，这比大海捞针还累。
而且，这还会让代码难以测试。如果你想测试一个依赖全局变量的函数，你每次测试前都得手动设置全局变量的状态，测试完可能还得清理，这不仅繁琐，还容易出错。我个人就遇到过因为全局变量状态不一致导致测试结果飘忽不定的情况，那种挫败感，啧啧。
从函数式编程的角度来看，全局变量也与“纯函数”的概念相悖。纯函数只依赖其输入参数，不产生副作用，这使得代码更容易理解和预测。而
global关键字的使用，本质上就是引入了副作用。
除了 global
关键字，还有其他管理全局状态的方法吗？
当然有，而且很多时候这些方法都比直接使用
global关键字更优雅、更安全。
一种非常常见且推荐的做法是将状态封装到类中。如果你需要一个在多个函数或方法之间共享和修改的状态，可以考虑创建一个类，将这些状态作为类的属性。这样，状态的修改就限制在了类的实例内部，通过实例方法来操作，清晰且可控。
class AppState:
def __init__(self):
self.counter = 0
self.config = {}
def increment_counter(self):
self.counter += 1
print(f"通过类方法：计数器现在是 {self.counter}")
def update_config(self, key, value):
self.config[key] = value
print(f"配置更新：{self.config}")
# 创建一个应用状态实例
app_state = AppState()
app_state.increment_counter()
app_state.update_config("theme", "dark")
print(f"当前计数器：{app_state.counter}")这种模式，特别是当你将
AppState实例作为参数传递给需要它的函数时，能够极大地提高代码的可读性和可维护性。
另一种方法是将“全局”变量作为参数传递。这听起来可能有点笨拙，但它明确地表示了函数对外部数据的依赖，强制你思考数据流向。
my_data = {"value": 10}
def process_data(data_dict):
data_dict["value"] += 5
print(f"函数内部处理：{data_dict['value']}")
print(f"处理前：{my_data['value']}")
process_data(my_data)
print(f"处理后：{my_data['value']}")这里
my_data虽然在全局，但
process_data函数是通过参数接收并修改它的，这比直接在函数内部
global my_data要清晰得多。
还有一种是使用模块级别变量作为配置。对于一些真正意义上的全局配置，比如数据库连接字符串、API密钥等，通常会创建一个独立的
config.py模块，将这些变量定义在其中。然后在需要的地方
import config。
# config.py 文件内容
DATABASE_URL = "sqlite:///my_database.db"
API_KEY = "your_secret_key"
# main.py 文件内容
import config
def connect_to_db():
print(f"正在连接到数据库：{config.DATABASE_URL}")
# 使用 config.DATABASE_URL 进行数据库连接操作
pass
connect_to_db()这种方式使得配置集中管理，修改方便，而且通过模块导入，其“全局性”也得到了很好的控制。
在哪些特定场景下使用 global
关键字是合理的？
尽管我们对
global关键字持谨慎态度，但它并非一无是处。在某些非常特定的场景下，它的使用不仅合理，甚至能简化代码。
我能想到的一个典型场景是实现简单的计数器或状态标志，尤其是在一些一次性脚本或者非常小的工具中。比如，你可能需要一个函数在每次被调用时都累加一个全局的执行次数，或者切换一个全局的布尔标志。
call_count = 0
def log_and_increment():
global call_count
call_count += 1
print(f"函数被调用了 {call_count} 次。")
log_and_increment()
log_and_increment()这种情况下，如果非要为此创建一个类或者传递参数，反而会显得过度设计，代码量和复杂度都会增加。
另一个可能是单例模式的简单实现。虽然Python有更高级的单例实现方式（比如通过元类或装饰器），但在某些简单场景下，
global变量可以用来存储单例实例，确保只创建一次。
_my_singleton_instance = None
class MySingleton:
def __init__(self):
print("MySingleton 实例被创建了！")
self.data = "我是一个单例"
def get_singleton_instance():
global _my_singleton_instance
if _my_singleton_instance is None:
_my_singleton_instance = MySingleton()
return _my_singleton_instance
# 第一次获取，会创建实例
instance1 = get_singleton_instance()
print(instance1.data)
# 第二次获取，不会再次创建
instance2 = get_singleton_instance()
print(instance2.data)
print(f"两个实例是同一个吗？{instance1 is instance2}")在这种情况下，
_my_singleton_instance作为一个全局变量，其存在就是为了管理单例的状态。
最后，在某些特定的框架或库设计中，可能也会用到
global变量来存储一些全局的上下文信息，比如一些配置对象或者线程局部存储（虽然Python有更专门的
threading.local）。但这通常是框架设计者深思熟虑后的选择，普通应用开发者应该尽量避免。
总而言之，
global关键字就像一把瑞士军刀，功能强大，但如果只是想削个苹果，用菜刀可能更合适。它不是不能用，而是要用得有理有据，知道自己在做什么，以及可能带来的后果。
