Python学习--TypeError 详解

def invalid_operations():    """不同类型之间的无效操作"""    # 字符串和整数相加    try:        result = "Hello" + 123    except TypeError as e:        print(f"错误: {e}")  # can only concatenate str (not "int") to str    # 列表和整数相加    try:        result = [1, 2, 3] + 4    except TypeError as e:        print(f"错误: {e}")  # can only concatenate list (not "int") to list    # 数字和字符串相乘    try:        result = "abc" * "3"    except TypeError as e:        print(f"错误: {e}")  # can't multiply sequence by non-int of type 'str'invalid_operations()

def non_callable():    """调用不可调用对象"""    # 整数不可调用    x = 10    try:        x()    except TypeError as e:        print(f"错误: {e}")  # 'int' object is not callable    # 列表不可调用    my_list = [1, 2, 3]    try:        my_list()    except TypeError as e:        print(f"错误: {e}")  # 'list' object is not callable    # 字符串不可调用    name = "Alice"    try:        name()    except TypeError as e:        print(f"错误: {e}")  # 'str' object is not callablenon_callable()

def argument_count():    """参数数量错误"""    def greet(name):        return f"Hello, {name}"    # 参数太少    try:        greet()    except TypeError as e:        print(f"错误: {e}")  # missing 1 required positional argument: 'name'    # 参数太多    try:        greet("Alice", "Bob")    except TypeError as e:        print(f"错误: {e}")  # takes 1 positional argument but 2 were givenargument_count()

def keyword_arguments():    """关键字参数错误"""    def person_info(name, age):        return f"{name} is {age} years old"    # 错误的关键字参数    try:        person_info(name="Alice", years=25)    except TypeError as e:        print(f"错误: {e}")  # got an unexpected keyword argument 'years'    # 正确的调用    print(person_info(name="Alice", age=25))  # Alice is 25 years oldkeyword_arguments()

def iteration_errors():    """迭代非可迭代对象"""    # 整数不可迭代    try:        for i in 123:            print(i)    except TypeError as e:        print(f"错误: {e}")  # 'int' object is not iterable    # 浮点数不可迭代    try:        for i in 3.14:            print(i)    except TypeError as e:        print(f"错误: {e}")  # 'float' object is not iterable    # None 不可迭代    try:        for i in None:            print(i)    except TypeError as e:        print(f"错误: {e}")  # 'NoneType' object is not iterableiteration_errors()

def indexing_errors():    """索引非序列对象"""    # 整数不可索引    x = 123    try:        print(x[0])    except TypeError as e:        print(f"错误: {e}")  # 'int' object is not subscriptable    # 浮点数不可索引    y = 3.14    try:        print(y[0])    except TypeError as e:        print(f"错误: {e}")  # 'float' object is not subscriptable    # 字典可以使用键索引，但不能用数字索引    d = {'a': 1, 'b': 2}    try:        print(d[0])  # KeyError，不是 TypeError    except KeyError:        print("键不存在")indexing_errors()

def conversion_errors():    """类型转换错误"""    # 字符串转整数（包含非数字字符）    try:        num = int("abc")    except ValueError as e:        print(f"ValueError: {e}")  # 这是 ValueError    # 列表转整数（不合适的类型）    try:        num = int([1, 2, 3])    except TypeError as e:        print(f"TypeError: {e}")  # int() argument must be a string, a bytes-like object or a number, not 'list'    # 字典转整数    try:        num = int({'a': 1})    except TypeError as e:        print(f"TypeError: {e}")  # int() argument must be a string...conversion_errors()

class MyClass:    def __init__(self, value):        self.value = valuedef operator_overload_errors():    """运算符重载问题"""    obj1 = MyClass(10)    obj2 = MyClass(20)    # 自定义类默认不支持加法    try:        result = obj1 + obj2    except TypeError as e:        print(f"错误: {e}")  # unsupported operand type(s) for +: 'MyClass' and 'MyClass'    # 实现 __add__ 方法后可以工作    class MyClassWithAdd:        def __init__(self, value):            self.value = value        def __add__(self, other):            return MyClassWithAdd(self.value + other.value)    obj3 = MyClassWithAdd(10)    obj4 = MyClassWithAdd(20)    result = obj3 + obj4    print(f"结果值: {result.value}")  # 30operator_overload_errors()

def builtin_function_errors():    """内置函数参数类型错误"""    # len() 需要序列类型    try:        length = len(123)    except TypeError as e:        print(f"len() 错误: {e}")  # object of type 'int' has no len()    # max() 需要可迭代对象    try:        maximum = max(123)    except TypeError as e:        print(f"max() 错误: {e}")  # 'int' object is not iterable    # sorted() 需要可迭代对象    try:        sorted_result = sorted(123)    except TypeError as e:        print(f"sorted() 错误: {e}")  # 'int' object is not iterablebuiltin_function_errors()

def type_checking():    """使用 isinstance() 进行类型检查"""    def add_numbers(a, b):        """安全加法，只处理数字类型"""        if not isinstance(a, (int, float)):            raise TypeError(f"a 必须是数字，得到 {type(a).__name__}")        if not isinstance(b, (int, float)):            raise TypeError(f"b 必须是数字，得到 {type(b).__name__}")        return a + b    # 测试    print(add_numbers(10, 20))      # 30    print(add_numbers(10.5, 20.5))  # 31.0    try:        print(add_numbers("10", 20))    except TypeError as e:        print(f"错误: {e}")    # 更灵活的处理    def safe_add(a, b):        """尝试转换类型"""        try:            return a + b        except TypeError:            try:                return float(a) + float(b)            except (TypeError, ValueError):                return None    print(safe_add(10, 20))      # 30    print(safe_add("10", "20"))  # 30.0    print(safe_add("abc", 20))   # Nonetype_checking()

def catch_type_error():    """使用 try-except 捕获 TypeError"""    def process_data(data):        """处理数据，兼容多种类型"""        try:            # 尝试作为可迭代对象处理            return [x.upper() for x in data]        except TypeError:            # 如果不是可迭代对象，返回字符串的大写形式            try:                return str(data).upper()            except Exception:                return None    # 测试    print(process_data(["hello", "world"]))  # ['HELLO', 'WORLD']    print(process_data("hello"))              # HELLO    print(process_data(123))                  # 123    print(process_data(None))                 # Nonecatch_type_error()

from typing import Union, List, Anydef type_annotations():    """使用类型注解"""    def process_items(items: Union[List, str, int]) -> List[str]:        """处理不同类型的输入"""        result = []        try:            if isinstance(items, (list, tuple)):                for item in items:                    result.append(str(item))            elif isinstance(items, (str, int, float)):                result.append(str(items))            else:                raise TypeError(f"不支持的类型: {type(items).__name__}")        except TypeError as e:            print(f"处理错误: {e}")            result = []        return result    # 测试    print(process_items([1, 2, 3]))     # ['1', '2', '3']    print(process_items("hello"))       # ['hello']    print(process_items(123))           # ['123']    print(process_items(None))          # 处理错误: 不支持的类型: NoneTypetype_annotations()

def none_type_trap():    """None 类型导致的 TypeError"""    data = None    # 错误：对 None 调用方法    try:        result = data.upper()    except AttributeError as e:        print(f"AttributeError: {e}")  # 'NoneType' object has no attribute 'upper'    # 错误：对 None 进行迭代    try:        for item in data:            print(item)    except TypeError as e:        print(f"TypeError: {e}")  # 'NoneType' object is not iterable    # 错误：对 None 进行索引    try:        print(data[0])    except TypeError as e:        print(f"TypeError: {e}")  # 'NoneType' object is not subscriptable    # 解决方案：检查 None    if data is not None:        print(data.upper())    else:        print("数据为空")    # 或使用默认值    safe_data = data or ""    print(safe_data.upper())  # 空字符串none_type_trap()

def parameter_type_trap():    """函数参数类型混淆"""    # 错误：位置参数和关键字参数混淆    def func(a, b, c):        return a + b + c    try:        result = func(a=1, 2, c=3)  # 位置参数不能在关键字参数之后    except SyntaxError:        print("语法错误")    # 错误：可变参数的误用    def process(*args, **kwargs):        return args, kwargs    try:        process(1, 2, name="Alice", 3)  # 关键字参数不能在位置参数之后    except SyntaxError:        print("语法错误")    # 正确用法    def safe_process(*args, **kwargs):        return args, kwargs    print(safe_process(1, 2, 3, name="Alice"))  # 正常parameter_type_trap()

def class_instance_trap():    """类实例类型混淆"""    class Dog:        def bark(self):            return "Woof!"    class Cat:        def meow(self):            return "Meow!"    def make_sound(animal):        """不安全的类型处理"""        return animal.bark()  # 假设所有动物都会 bark    dog = Dog()    cat = Cat()    print(make_sound(dog))  # Woof!    try:        print(make_sound(cat))  # Cat 没有 bark 方法    except AttributeError as e:        print(f"错误: {e}")    # 解决方案：使用鸭子类型或类型检查    def safe_make_sound(animal):        if hasattr(animal, 'bark'):            return animal.bark()        elif hasattr(animal, 'meow'):            return animal.meow()        else:            raise TypeError(f"{type(animal).__name__} 不会发出声音")    print(safe_make_sound(dog))  # Woof!    print(safe_make_sound(cat))  # Meow!class_instance_trap()

def best_practice_type_check():    """类型检查最佳实践"""    def process_data(data):        """处理数据，先检查类型"""        # 检查类型        if isinstance(data, (list, tuple)):            return [str(x) for x in data]        elif isinstance(data, dict):            return {str(k): str(v) for k, v in data.items()}        elif isinstance(data, (str, int, float)):            return str(data)        else:            raise TypeError(f"不支持的类型: {type(data).__name__}")    # 测试    print(process_data([1, 2, 3]))           # ['1', '2', '3']    print(process_data({'a': 1, 'b': 2}))    # {'a': '1', 'b': '2'}    print(process_data("hello"))             # hello    print(process_data(123))                 # 123best_practice_type_check()

def best_practice_duck_typing():    """鸭子类型最佳实践"""    # 鸭子类型：如果它走起来像鸭子，叫起来像鸭子，那么它就是鸭子    def process_iterable(iterable):        """处理任何可迭代对象"""        try:            return [str(x) for x in iterable]        except TypeError:            raise TypeError(f"{type(iterable).__name__} 不是可迭代对象")    # 测试各种可迭代对象    print(process_iterable([1, 2, 3]))        # ['1', '2', '3']    print(process_iterable((1, 2, 3)))       # ['1', '2', '3']    print(process_iterable("hello"))         # ['h', 'e', 'l', 'l', 'o']    print(process_iterable(range(3)))        # ['0', '1', '2']    try:        process_iterable(123)                 # 整数不可迭代    except TypeError as e:        print(f"错误: {e}")best_practice_duck_typing()

from functools import singledispatchdef best_practice_singledispatch():    """使用 singledispatch 实现多类型处理"""    @singledispatch    def process(value):        """默认处理器"""        raise TypeError(f"不支持的类型: {type(value).__name__}")    @process.register(str)    def _(value):        return f"字符串处理: {value.upper()}"    @process.register(int)    @process.register(float)    def _(value):        return f"数字处理: {value * 2}"    @process.register(list)    @process.register(tuple)    def _(value):        return f"序列处理: 长度 {len(value)}"    @process.register(dict)    def _(value):        return f"字典处理: 键数量 {len(value)}"    # 测试    print(process("hello"))        # 字符串处理: HELLO    print(process(42))             # 数字处理: 84    print(process(3.14))           # 数字处理: 6.28    print(process([1, 2, 3]))      # 序列处理: 长度 3    print(process({'a': 1}))       # 字典处理: 键数量 1    try:        process(None)              # 不支持的类型    except TypeError as e:        print(f"错误: {e}")best_practice_singledispatch()

from collections.abc import Iterable, Mapping, Sequencedef best_practice_protocols():    """使用协议和抽象基类"""    def process_container(container):        """处理容器类型"""        if isinstance(container, Mapping):            return f"映射: {len(container)} 个键值对"        elif isinstance(container, Sequence):            return f"序列: 长度 {len(container)}"        elif isinstance(container, Iterable):            return f"可迭代对象"        else:            raise TypeError(f"{type(container).__name__} 不是容器类型")    # 测试    print(process_container([1, 2, 3]))        # 序列: 长度 3    print(process_container((1, 2)))           # 序列: 长度 2    print(process_container("hello"))          # 序列: 长度 5    print(process_container({'a': 1, 'b': 2})) # 映射: 2 个键值对    print(process_container(range(5)))         # 序列: 长度 5    try:        process_container(123)                 # 不是容器类型    except TypeError as e:        print(f"错误: {e}")best_practice_protocols()