Python学习--NameError 详解

def undefined_variable():    """访问未定义的变量"""    # 正确：定义了变量    name = "Alice"    print(name)  # Alice    # 错误：使用未定义的变量    try:        print(age)    except NameError as e:        print(f"错误: {e}")  # name 'age' is not definedundefined_variable()

def undefined_function():    """调用未定义的函数"""    # 正确：定义了函数    def greet():        return "Hello"    print(greet())  # Hello    # 错误：调用未定义的函数    try:        say_hello()    except NameError as e:        print(f"错误: {e}")  # name 'say_hello' is not definedundefined_function()

def unimported_module():    """使用未导入的模块"""    # 正确：导入模块    import math    print(math.sqrt(16))  # 4.0    # 错误：使用未导入的模块    try:        print(np.array([1, 2, 3]))    except NameError as e:        print(f"错误: {e}")  # name 'np' is not defined    # 正确：导入并使用别名    import numpy as np    # print(np.array([1, 2, 3]))  # 需要安装 numpyunimported_module()

def scope_issues():    """作用域导致的 NameError"""    # 全局变量    global_var = "I'm global"    def outer_function():        # 外部函数变量        outer_var = "I'm outer"        def inner_function():            # 内部函数变量            inner_var = "I'm inner"            # 可以访问：全局、外部、内部变量            print(global_var)  # 正常            print(outer_var)   # 正常            print(inner_var)   # 正常        inner_function()        # 错误：无法访问内部函数的变量        try:            print(inner_var)        except NameError as e:            print(f"错误: {e}")  # name 'inner_var' is not defined    outer_function()    # 错误：无法访问函数内的局部变量    try:        print(outer_var)    except NameError as e:        print(f"错误: {e}")  # name 'outer_var' is not definedscope_issues()

def order_issues():    """变量使用顺序导致的 NameError"""    # 错误：先使用后定义    try:        print(x)        x = 10    except NameError as e:        print(f"错误: {e}")  # name 'x' is not defined    # 正确：先定义后使用    y = 20    print(y)  # 20    # 特殊情况：在函数内部    def test():        try:            print(z)  # 这里会报错            z = 30        except NameError as e:            print(f"函数内错误: {e}")    test()order_issues()

def conditional_issues():    """条件语句中的变量作用域"""    # 变量只在某些分支中定义    condition = False    if condition:        message = "条件为真"    # 错误：message 可能未定义    try:        print(message)    except NameError as e:        print(f"错误: {e}")  # name 'message' is not defined    # 正确：确保变量在所有分支中都定义    if condition:        result = "真"    else:        result = "假"    print(result)  # 假    # 使用默认值    if condition:        data = "有数据"    else:        data = None    print(data)  # Noneconditional_issues()

def loop_issues():    """循环中的变量作用域"""    # 在 Python 中，循环变量会泄露到外部作用域    for i in range(3):        pass    print(f"循环后 i = {i}")  # 2（i 仍然存在）    # 但如果是空循环，变量不会定义    for j in []:        pass    try:        print(j)    except NameError as e:        print(f"错误: {e}")  # name 'j' is not defined    # 列表推导式中的变量不会泄露    squares = [x**2 for x in range(3)]    try:        print(x)    except NameError as e:        print(f"推导式变量: {e}")  # name 'x' is not definedloop_issues()

def exception_issues():    """异常处理中的变量作用域"""    try:        result = 10 / 0    except ZeroDivisionError as e:        print(f"捕获异常: {e}")        # e 只在 except 块中可用    # 错误：e 在 except 块外不可用    try:        print(e)    except NameError as e:        print(f"except 块外: {e}")    # 正确：保存异常信息    try:        result = 10 / 0    except ZeroDivisionError as e:        error_info = str(e)    print(f"保存的异常: {error_info}")exception_issues()

def use_globals_locals():    """使用 globals() 和 locals() 检查变量"""    name = "Alice"    age = 25    # 检查全局变量    if 'name' in globals():        print(f"全局变量 name: {globals()['name']}")    # 检查局部变量    if 'age' in locals():        print(f"局部变量 age: {locals()['age']}")    # 安全访问函数    def safe_get(var_name, default=None):        """安全获取变量值"""        if var_name in locals():            return locals()[var_name]        elif var_name in globals():            return globals()[var_name]        return default    print(safe_get('name', 'unknown'))    # Alice    print(safe_get('city', 'Beijing'))    # Beijinguse_globals_locals()

def catch_name_error():    """使用 try-except 捕获 NameError"""    def safe_execute(func, *args, default=None):        """安全执行函数"""        try:            return func(*args)        except NameError as e:            print(f"函数未定义: {e}")            return default    # 定义函数    def add(a, b):        return a + b    # 调用存在的函数    print(safe_execute(add, 10, 20))  # 30    # 调用不存在的函数    print(safe_execute(multiply, 10, 20, default=0))  # 0catch_name_error()

def dynamic_import():    """动态导入模块避免 NameError"""    def safe_import(module_name):        """安全导入模块"""        try:            module = __import__(module_name)            return module        except ImportError:            print(f"模块 '{module_name}' 不存在")            return None    # 导入标准库    math = safe_import('math')    if math:        print(math.sqrt(25))  # 5.0    # 导入不存在的模块    numpy = safe_import('numpy')    if numpy is None:        print("使用纯 Python 实现")        # 使用备选方案        def sqrt(x):            return x ** 0.5        print(sqrt(25))dynamic_import()

def spelling_trap():    """变量名拼写错误"""    user_name = "Alice"    # 错误：拼写错误    try:        print(usre_name)    except NameError as e:        print(f"拼写错误: {e}")    # 正确：使用正确的变量名    print(user_name)    # 使用 IDE 的自动补全可以减少此类错误    # 使用有意义的变量名    # 使用 linter 工具检查spelling_trap()

def import_alias_trap():    """模块导入别名混淆"""    # 正确导入    import datetime as dt    # 错误：使用了错误的别名    try:        print(datetime.datetime.now())    except NameError as e:        print(f"错误: {e}")  # name 'datetime' is not defined    # 正确：使用定义的别名    print(dt.datetime.now())    # 或者导入整个模块    import datetime    print(datetime.datetime.now())import_alias_trap()

def class_vs_instance_trap():    """类属性和实例属性混淆"""    class Person:        species = "Homo sapiens"  # 类属性        def __init__(self, name):            self.name = name  # 实例属性    p = Person("Alice")    # 正确访问    print(p.name)        # 实例属性    print(p.species)     # 类属性    print(Person.species) # 类属性    # 错误：访问不存在的属性    try:        print(Person.name)    except AttributeError as e:        print(f"错误: {e}")  # AttributeError, not NameError    # NameError 示例    try:        print(age)    except NameError as e:        print(f"NameError: {e}")class_vs_instance_trap()

def global_variable_trap():    """全局变量修改陷阱"""    counter = 0    def increment_bad():        # 错误：这里创建了一个局部变量，而不是修改全局变量        counter += 1  # UnboundLocalError    def increment_good():        global counter        counter += 1    # increment_bad()  # UnboundLocalError    increment_good()    print(counter)  # 1    # 对于可变对象    items = []    def add_item(item):        items.append(item)  # 正确：修改列表对象    add_item(10)    print(items)  # [10]global_variable_trap()

def best_practice_define_first():    """先定义后使用"""    # 错误示例    def bad_example(condition):        if condition:            result = "True"        # result 可能在条件为假时未定义        return result  # NameError if condition is False    # 正确示例    def good_example(condition):        result = None  # 先定义默认值        if condition:            result = "True"        return result    print(good_example(True))   # True    print(good_example(False))  # Nonebest_practice_define_first()

def best_practice_default():    """使用默认值避免 NameError"""    # 使用字典存储变量    context = {}    def get_var(name, default=None):        return context.get(name, default)    # 设置变量    context['name'] = 'Alice'    # 安全获取    name = get_var('name', 'Unknown')    age = get_var('age', 0)    print(f"Name: {name}, Age: {age}")    # 使用 locals() 和 globals()    x = 10    y = 20    def safe_get(var_name, default=None):        if var_name in locals():            return locals()[var_name]        if var_name in globals():            return globals()[var_name]        return default    print(safe_get('x', 0))      # 10    print(safe_get('z', 100))    # 100best_practice_default()

def best_practice_dict():    """使用字典管理动态变量"""    class VariableScope:        """变量作用域管理"""        def __init__(self):            self._variables = {}        def set(self, name, value):            """设置变量"""            self._variables[name] = value        def get(self, name, default=None):            """获取变量"""            return self._variables.get(name, default)        def has(self, name):            """检查变量是否存在"""            return name in self._variables        def __getattr__(self, name):            """通过属性访问"""            if name in self._variables:                return self._variables[name]            raise AttributeError(f"变量 '{name}' 不存在")        def __setattr__(self, name, value):            """通过属性设置"""            if name == '_variables':                super().__setattr__(name, value)            else:                self._variables[name] = value    # 使用    scope = VariableScope()    scope.set('name', 'Alice')    scope.age = 25    print(scope.get('name'))     # Alice    print(scope.get('city', 'Beijing'))  # Beijing    print(scope.name)            # Alice    print(scope.age)             # 25    try:        print(scope.email)    except AttributeError as e:        print(f"错误: {e}")best_practice_dict()

from typing import Optionaldef best_practice_type_hints():    """使用类型提示避免 NameError"""    class User:        def __init__(self, name: str, age: Optional[int] = None):            self.name = name            self.age = age        def get_info(self) -> str:            """获取用户信息"""            info = f"Name: {self.name}"            if self.age is not None:                info += f", Age: {self.age}"            return info    user = User("Alice", 25)    print(user.get_info())    # IDE 会提示变量名错误    # print(user.namee)  # IDE 会高亮显示错误best_practice_type_hints()