Python学习--KeyError 详解

# 字典定义person = {    'name': 'Alice',    'age': 25,    'city': 'Beijing'}print(f"字典内容: {person}")print(f"存在的键: {list(person.keys())}")# 访问存在的键print(person['name'])  # Aliceprint(person['age'])   # 25# 访问不存在的键try:    print(person['email'])except KeyError as e:    print(f"错误: 键 {e} 不存在")

# 变量作为键名user_input = 'phone'user_data = {    'name': '张三',    'age': 30}try:    print(user_data[user_input])except KeyError as e:    print(f"键 '{user_input}' 不存在，可用键: {list(user_data.keys())}")

# 嵌套字典config = {    'database': {        'host': 'localhost',        'port': 3306    },    'cache': {        'type': 'redis'    }}# 访问存在的嵌套键print(config['database']['host'])  # localhost# 访问不存在的嵌套键try:    print(config['database']['password'])except KeyError as e:    print(f"嵌套键错误: {e}")# 访问不存在的顶级键try:    print(config['logging']['level'])except KeyError as e:    print(f"顶级键错误: {e}")

def dict_comprehension_error():    """字典推导式中的键错误"""    # 从现有字典创建新字典    original = {'a': 1, 'b': 2, 'c': 3}    # 错误：访问不存在的键    try:        new_dict = {k: original[k.upper()] for k in original}    except KeyError as e:        print(f"推导式错误: 键 {e} 不存在")    # 正确方式    new_dict = {k: v for k, v in original.items()}    print(f"正确方式: {new_dict}")dict_comprehension_error()

from collections import defaultdictdef defaultdict_misuse():    """defaultdict 的误用"""    # 创建默认值字典    dd = defaultdict(int)  # 默认值为 0    dd['a'] = 1    dd['b'] = 2    # 访问不存在的键会返回默认值，不会报错    print(dd['c'])  # 0（不会报错）    # 但普通字典会报错    normal_dict = {'a': 1, 'b': 2}    try:        print(normal_dict['c'])    except KeyError as e:        print(f"普通字典错误: {e}")    # 注意：defaultdict 会创建不存在的键    print(dd)  # defaultdict(<class 'int'>, {'a': 1, 'b': 2, 'c': 0})defaultdict_misuse()

import jsondef json_processing_error():    """JSON 数据处理中的键错误"""    json_data = '''    {        "user": {            "name": "Alice",            "age": 25        }    }    '''    data = json.loads(json_data)    # 访问存在的键    print(data['user']['name'])  # Alice    # 访问不存在的键    try:        print(data['user']['email'])    except KeyError as e:        print(f"JSON 数据错误: 缺少键 {e}")    # 安全访问嵌套 JSON    def safe_json_get(data, keys, default=None):        """安全获取嵌套 JSON 数据"""        current = data        for key in keys:            if isinstance(current, dict):                current = current.get(key)                if current is None:                    return default            else:                return default        return current    print(safe_json_get(data, ['user', 'email'], 'unknown@example.com'))json_processing_error()

def use_get_method():    """使用 get() 方法安全访问"""    user = {        'name': 'Bob',        'age': 30    }    # get() 方法：键不存在时返回 None    name = user.get('name')    email = user.get('email')    print(f"name: {name}")      # Bob    print(f"email: {email}")    # None    # 提供默认值    email = user.get('email', 'default@example.com')    phone = user.get('phone', 'unknown')    print(f"email: {email}")    # default@example.com    print(f"phone: {phone}")    # unknown    # 链式 get    config = {        'database': {            'host': 'localhost'        }    }    host = config.get('database', {}).get('host', '127.0.0.1')    port = config.get('database', {}).get('port', 3306)    print(f"host: {host}")  # localhost    print(f"port: {port}")  # 3306use_get_method()

def use_setdefault():    """使用 setdefault() 设置默认值"""    data = {'a': 1, 'b': 2}    # setdefault: 如果键存在返回其值，否则设置并返回默认值    value1 = data.setdefault('a', 100)    value2 = data.setdefault('c', 300)    print(f"value1: {value1}")  # 1    print(f"value2: {value2}")  # 300    print(f"data: {data}")      # {'a': 1, 'b': 2, 'c': 300}    # 实际应用：统计词频    text = "hello world hello python world hello"    word_count = {}    for word in text.split():        word_count[word] = word_count.setdefault(word, 0) + 1    print(f"词频统计: {word_count}")use_setdefault()

from collections import defaultdictdef use_defaultdict():    """使用 defaultdict 自动处理缺失键"""    # 默认值为 0    dd = defaultdict(int)    dd['a'] += 1    dd['b'] += 2    dd['c'] += 3    print(f"defaultdict(int): {dict(dd)}")    # 默认值为列表    dd_list = defaultdict(list)    dd_list['fruits'].append('apple')    dd_list['fruits'].append('banana')    dd_list['vegetables'].append('carrot')    print(f"defaultdict(list): {dict(dd_list)}")    # 默认值为自定义函数    def default_value():        return {'count': 0, 'total': 0}    dd_custom = defaultdict(default_value)    dd_custom['product1']['count'] += 1    dd_custom['product1']['total'] += 100    dd_custom['product2']['count'] += 1    print(f"defaultdict(custom): {dict(dd_custom)}")use_defaultdict()

def use_try_except():    """使用异常处理捕获 KeyError"""    config = {        'host': 'localhost',        'port': 8080    }    def get_config(key, default=None):        """安全获取配置"""        try:            return config[key]        except KeyError:            print(f"警告: 配置项 '{key}' 不存在，使用默认值 {default}")            return default    # 使用    host = get_config('host', '127.0.0.1')    port = get_config('port', 80)    timeout = get_config('timeout', 30)    print(f"host: {host}")       # localhost    print(f"port: {port}")       # 8080    print(f"timeout: {timeout}") # 30use_try_except()

def mutable_default_trap():    """可变默认值的陷阱"""    # 错误：使用可变对象作为默认值    def add_to_dict_bad(key, value, target={}):        target[key] = value        return target    d1 = add_to_dict_bad('a', 1)    d2 = add_to_dict_bad('b', 2)    print(f"d1: {d1}")  # {'a': 1, 'b': 2}    print(f"d2: {d2}")  # {'a': 1, 'b': 2}    print(f"d1 is d2: {d1 is d2}")  # True（共享同一个字典）    # 正确：使用 None 作为默认值    def add_to_dict_good(key, value, target=None):        if target is None:            target = {}        target[key] = value        return target    d3 = add_to_dict_good('a', 1)    d4 = add_to_dict_good('b', 2)    print(f"d3: {d3}")  # {'a': 1}    print(f"d4: {d4}")  # {'b': 2}    print(f"d3 is d4: {d3 is d4}")  # Falsemutable_default_trap()

def key_type_trap():    """键类型错误的陷阱"""    # 字典的键可以是不同类型    data = {        1: 'integer key',        '1': 'string key',        (1,): 'tuple key'    }    # 访问时类型必须匹配    print(data[1])      # integer key    print(data['1'])    # string key    # 错误：类型不匹配    try:        print(data['1'])  # 正确        print(data['1.0'])  # 不存在    except KeyError as e:        print(f"类型错误: 键 {e} 不存在")    # 从用户输入获取的键可能是字符串    user_input = "1"    try:        print(data[user_input])  # 正确，因为键是字符串    except KeyError:        print("键不存在")key_type_trap()

import threadingimport timedef concurrent_modification_trap():    """并发修改字典的陷阱"""    shared_dict = {'a': 1, 'b': 2, 'c': 3}    def modify_dict():        for i in range(100):            shared_dict[f'key_{i}'] = i            time.sleep(0.001)    def read_dict():        for _ in range(100):            try:                # 可能在迭代过程中字典被修改                for key in list(shared_dict.keys()):                    value = shared_dict[key]  # 可能引发 KeyError            except KeyError as e:                print(f"并发错误: {e}")    t1 = threading.Thread(target=modify_dict)    t2 = threading.Thread(target=read_dict)    t1.start()    t2.start()    t1.join()    t2.join()# concurrent_modification_trap()# 解决方案：使用锁class ThreadSafeDict:    """线程安全的字典"""    def __init__(self):        self._dict = {}        self._lock = threading.RLock()    def get(self, key, default=None):        with self._lock:            return self._dict.get(key, default)    def set(self, key, value):        with self._lock:            self._dict[key] = value    def delete(self, key):        with self._lock:            try:                del self._dict[key]                return True            except KeyError:                return False    def keys(self):        with self._lock:            return list(self._dict.keys())    def items(self):        with self._lock:            return list(self._dict.items())

def best_practice_get():    """使用 get 方法的最佳实践"""    user = {'name': 'Alice', 'age': 25}    # 不好的做法    try:        email = user['email']    except KeyError:        email = 'default@example.com'    # 好的做法    email = user.get('email', 'default@example.com')    # 链式获取    config = {        'database': {            'host': 'localhost'        }    }    # 不好的做法    try:        host = config['database']['host']    except KeyError:        host = '127.0.0.1'    # 好的做法    host = config.get('database', {}).get('host', '127.0.0.1')best_practice_get()

def best_practice_defaultdict():    """使用 defaultdict 的最佳实践"""    # 不好的做法    data = [('a', 1), ('b', 2), ('a', 3), ('b', 4), ('c', 5)]    grouped_bad = {}    for key, value in data:        if key not in grouped_bad:            grouped_bad[key] = []        grouped_bad[key].append(value)    # 好的做法    from collections import defaultdict    grouped_good = defaultdict(list)    for key, value in data:        grouped_good[key].append(value)    print(f"分组结果: {dict(grouped_good)}")best_practice_defaultdict()

def best_practice_setdefault():    """使用 setdefault 的最佳实践"""    # 不好的做法    word_count = {}    words = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']    for word in words:        if word in word_count:            word_count[word] += 1        else:            word_count[word] = 1    # 好的做法    word_count = {}    for word in words:        word_count[word] = word_count.setdefault(word, 0) + 1    print(f"词频统计: {word_count}")best_practice_setdefault()

from collections import ChainMapdef best_practice_chainmap():    """使用 ChainMap 合并多个字典"""    defaults = {        'host': 'localhost',        'port': 8080,        'debug': False,        'timeout': 30    }    user_config = {        'host': 'production.example.com',        'debug': True    }    # 合并配置，user_config 优先级更高    config = ChainMap(user_config, defaults)    # 访问配置    print(f"host: {config['host']}")        # production.example.com    print(f"port: {config['port']}")        # 8080    print(f"debug: {config['debug']}")      # True    print(f"timeout: {config['timeout']}")  # 30    # 修改会影响第一个字典    config['timeout'] = 60    print(f"user_config: {user_config}")  # {'host': 'production.example.com', 'debug': True, 'timeout': 60}best_practice_chainmap()