当前位置:   article > 正文

Python魔法之旅-魔法方法(10)

Python魔法之旅-魔法方法(10)

目录

一、概述

1、定义

2、作用

二、应用场景

1、构造和析构

2、操作符重载

3、字符串和表示

4、容器管理

5、可调用对象

6、上下文管理

7、属性访问和描述符

8、迭代器和生成器

9、数值类型

10、复制和序列化

11、自定义元类行为

12、自定义类行为

13、类型检查和转换

14、自定义异常

三、学习方法

1、理解基础

2、查阅文档

3、编写示例

4、实践应用

5、阅读他人代码

6、参加社区讨论

7、持续学习

8、练习与总结

9、注意兼容性

10、避免过度使用

四、魔法方法

32、__index__方法

32-1、语法

32-2、参数

32-3、功能

32-4、返回值

32-5、说明

32-6、用法

33、__init__方法

33-1、语法

33-2、参数

33-3、功能

33-4、返回值

33-5、说明

33-6、用法

34、__init_subclass__方法

34-1、语法

34-2、参数

34-3、功能

34-4、返回值

34-5、说明

34-6、用法

五、推荐阅读

1、Python筑基之旅

2、Python函数之旅

3、Python算法之旅

4、博客个人主页

一、概述

1、定义

        魔法方法(Magic Methods/Special Methods,也称特殊方法或双下划线方法)是Python中一类具有特殊命名规则的方法,它们的名称通常以双下划线(`__`)开头和结尾

        魔法方法用于在特定情况下自动被Python解释器调用,而不需要显式地调用它们,它们提供了一种机制,让你可以定义自定义类时具有与内置类型相似的行为。

2、作用

        魔法方法允许开发者重载Python中的一些内置操作或函数的行为,从而为自定义的类添加特殊的功能

二、应用场景

1、构造和析构

1-1、__init__(self, [args...]):在创建对象时初始化属性。
1-2、__new__(cls, [args...]):在创建对象时控制实例的创建过程(通常与元类一起使用)。
1-3、__del__(self):在对象被销毁前执行清理操作,如关闭文件或释放资源。

2、操作符重载

2-1、__add__(self, other)、__sub__(self, other)、__mul__(self, other)等:自定义对象之间的算术运算。
2-2、__eq__(self, other)、__ne__(self, other)、__lt__(self, other)等:定义对象之间的比较操作。

3、字符串和表示

3-1、__str__(self):定义对象的字符串表示,常用于print()函数。
3-2、__repr__(self):定义对象的官方字符串表示,用于repr()函数和交互式解释器。

4、容器管理

4-1、__getitem__(self, key)、__setitem__(self, key, value)、__delitem__(self, key):用于实现类似列表或字典的索引访问、设置和删除操作。
4-2、__len__(self):返回对象的长度或元素个数。

5、可调用对象

5-1、__call__(self, [args...]):允许对象像函数一样被调用。

6、上下文管理

6-1、__enter__(self)、__exit__(self, exc_type, exc_val, exc_tb):用于实现上下文管理器,如with语句中的对象。

7、属性访问和描述符

7-1、__getattr__, __setattr__, __delattr__:这些方法允许对象在访问或修改不存在的属性时执行自定义操作。
7-2、描述符(Descriptors)是实现了__get__, __set__, 和__delete__方法的对象,它们可以控制对另一个对象属性的访问。

8、迭代器和生成器

8-1、__iter__和__next__:这些方法允许对象支持迭代操作,如使用for循环遍历对象。
8-2、__aiter__, __anext__:这些是异步迭代器的魔法方法,用于支持异步迭代。

9、数值类型

9-1、__int__(self)、__float__(self)、__complex__(self):定义对象到数值类型的转换。
9-2、__index__(self):定义对象用于切片时的整数转换。

10、复制和序列化

10-1、__copy__和__deepcopy__:允许对象支持浅复制和深复制操作。
10-2、__getstate__和__setstate__:用于自定义对象的序列化和反序列化过程。

11、自定义元类行为

11-1、__metaclass__(Python 2)或元类本身(Python 3):允许自定义类的创建过程,如动态创建类、修改类的定义等。

12、自定义类行为

12-1、__init__和__new__:用于初始化对象或控制对象的创建过程。
12-2、__init_subclass__:在子类被创建时调用,允许在子类中执行一些额外的操作。

13、类型检查和转换

13-1、__instancecheck__和__subclasscheck__:用于自定义isinstance()和issubclass()函数的行为。

14、自定义异常

14-1、你可以通过继承内置的Exception类来创建自定义的异常类,并定义其特定的行为。

三、学习方法

        要学好Python的魔法方法,你可以遵循以下方法及步骤:

1、理解基础

        首先确保你对Python的基本语法、数据类型、类和对象等概念有深入的理解,这些是理解魔法方法的基础。

2、查阅文档

        仔细阅读Python官方文档中关于魔法方法的部分,文档会详细解释每个魔法方法的作用、参数和返回值。你可以通过访问Python的官方网站或使用help()函数在Python解释器中查看文档。

3、编写示例

        为每个魔法方法编写简单的示例代码,以便更好地理解其用法和效果,通过实际编写和运行代码,你可以更直观地感受到魔法方法如何改变对象的行为。

4、实践应用

        在实际项目中尝试使用魔法方法。如,你可以创建一个自定义的集合类,使用__getitem__、__setitem__和__delitem__方法来实现索引操作。只有通过实践应用,你才能更深入地理解魔法方法的用途和重要性。

5、阅读他人代码

        阅读开源项目或他人编写的代码,特别是那些使用了魔法方法的代码,这可以帮助你学习如何在实际项目中使用魔法方法。通过分析他人代码中的魔法方法使用方式,你可以学习到一些新的技巧和最佳实践。

6、参加社区讨论

        参与Python社区的讨论,与其他开发者交流关于魔法方法的使用经验和技巧,在社区中提问或回答关于魔法方法的问题,这可以帮助你更深入地理解魔法方法并发现新的应用场景。

7、持续学习

        Python语言和其生态系统不断发展,新的魔法方法和功能可能会不断被引入,保持对Python社区的关注,及时学习新的魔法方法和最佳实践。

8、练习与总结

        多做练习,通过编写各种使用魔法方法的代码来巩固你的理解,定期总结你学到的知识和经验,形成自己的知识体系。

9、注意兼容性

        在使用魔法方法时,要注意不同Python版本之间的兼容性差异,确保你的代码在不同版本的Python中都能正常工作。

10、避免过度使用

        虽然魔法方法非常强大,但过度使用可能会导致代码难以理解和维护,在编写代码时,要权衡使用魔法方法的利弊,避免滥用。

        总之,学好Python的魔法方法需要不断地学习、实践和总结,只有通过不断地练习和积累经验,你才能更好地掌握这些强大的工具,并在实际项目中灵活运用它们。

四、魔法方法

32、__index__方法

32-1、语法
  1. __index__(self, /)
  2. Return self converted to an integer, if self is suitable for use as an index into a list
32-2、参数

32-2-1、self(必须)一个对实例对象本身的引用,在类的所有方法中都会自动传递。 

32-2-2、/(可选)这是从Python 3.8开始引入的参数注解语法,它表示这个方法不接受任何位置参数(positional-only parameters)之后的关键字参数(keyword arguments)。

32-3、功能

        用于那些希望表现得像整数,但实际上不是整数的对象。

32-4、返回值

        返回一个整数,该整数代表该对象在整数上下文中的值。

32-5、说明

        __index__方法与__int__方法不同

32-5-1、__int__ 方法用于将对象转换为整数,但并不保证转换后的整数适合用作索引(例如,它可能返回一个负数或超出索引范围的数);而__index__方法应该只返回那些可以用作索引的有效整数。

32-5-2、__index__ 方法通常只在需要整数索引的上下文中被调用,比如列表索引、切片操作等;在其他上下文中,可能需要使用__int__或其他转换方法。

32-6、用法
  1. # 032、__index__方法:
  2. # 1、自定义整数类型
  3. class MyInt:
  4. def __init__(self, value):
  5. self.value = value
  6. def __index__(self):
  7. return self.value
  8. def __repr__(self):
  9. return f"MyInt({self.value})"
  10. if __name__ == '__main__':
  11. lst = [1, 2, 3, 4, 5]
  12. idx = MyInt(2)
  13. print(lst[idx]) # 输出 3
  14. # 2、自定义时间索引
  15. from datetime import datetime, timedelta
  16. class TimeIndex:
  17. def __init__(self, hours):
  18. self.hours = hours
  19. def __index__(self):
  20. return self.hours * 60 * 60 # 转换为秒
  21. if __name__ == '__main__':
  22. now = datetime.now()
  23. # 手动调用 TimeIndex 对象的 __index__ 方法来获取秒数
  24. seconds = TimeIndex(2).__index__()
  25. delta = timedelta(seconds=seconds)
  26. future_time = now + delta
  27. print(future_time) # 输出类似于 2024-06-02 09:49:54.742039
  28. # 3、自定义进度条(简化示例)
  29. class ProgressBar:
  30. def __init__(self, total):
  31. self.total = total
  32. self.current = 0
  33. def update(self, value):
  34. self.current = value
  35. def __index__(self):
  36. return self.current
  37. if __name__ == '__main__':
  38. bar = ProgressBar(100)
  39. for i in range(101):
  40. bar.update(i)
  41. print(f"Progress: {i} / {bar.__index__() + 1}")
  42. # 4、自定义范围
  43. class MyRange:
  44. def __init__(self, start, end):
  45. self.start = start
  46. self.end = end
  47. def __index__(self):
  48. return self.end - self.start # 返回范围的大小
  49. if __name__ == '__main__':
  50. rng = MyRange(10, 20)
  51. print(f"Range size: {rng.__index__()}") # 输出:Range size: 10
  52. # 5、自定义列表索引
  53. class WeightedList:
  54. def __init__(self, elements, weights):
  55. self.elements = elements
  56. self.weights = weights
  57. def __getitem__(self, index):
  58. # 这里假设我们使用累积权重作为索引
  59. cumulative_weights = [sum(self.weights[:i + 1]) for i in range(len(self.weights))]
  60. if isinstance(index, int):
  61. for i, cw in enumerate(cumulative_weights):
  62. if index < cw:
  63. return self.elements[i]
  64. raise IndexError("Index out of range")
  65. elif hasattr(index, "__index__"):
  66. # 如果index有__index__方法,我们用它来获取整数值
  67. index_val = index.__index__()
  68. return self.__getitem__(index_val)
  69. else:
  70. raise TypeError("Unsupported index type")
  71. class WeightedIndex:
  72. def __init__(self, value):
  73. self.value = value
  74. def __index__(self):
  75. # 假设我们根据某种规则将value转换为索引
  76. # 这里只是一个示例,实际应用中规则可能更复杂
  77. return self.value * 2 # 例如,我们想要索引是权重的两倍
  78. if __name__ == '__main__':
  79. wl = WeightedList(['a', 'b', 'c'], [1, 3, 2])
  80. print(wl[WeightedList.WeightedIndex(1)]) # 假设我们想要索引为权重的两倍,所以这里会返回'b'
  81. # 6、自定义时间步索引
  82. class TimeStep:
  83. def __init__(self, step_number):
  84. self.step_number = step_number
  85. def __index__(self):
  86. return self.step_number
  87. if __name__ == '__main__':
  88. time_steps = [TimeStep(0), TimeStep(1), TimeStep(2)]
  89. for ts in time_steps:
  90. print(f"Time step: {ts.__index__()}")
  91. # 7、图形元素索引
  92. class GraphElement:
  93. def __init__(self, id):
  94. self.id = id
  95. def __index__(self):
  96. # 假设我们直接使用元素的id作为索引
  97. return self.id
  98. if __name__ == '__main__':
  99. elements = [GraphElement(1), GraphElement(2), GraphElement(3)]
  100. for elem in elements:
  101. print(f"Element index: {elem.__index__()}")

33、__init__方法

33-1、语法
  1. __init__(self, /, *args, **kwargs)
  2. Initialize self. See help(type(self)) for accurate signature
33-2、参数

33-2-1、self(必须)一个对实例对象本身的引用,在类的所有方法中都会自动传递。 

33-2-2、/(可选)这是从Python 3.8开始引入的参数注解语法,它表示这个方法不接受任何位置参数(positional-only parameters)之后的关键字参数(keyword arguments)。

33-2-3、*args(可选)一个非关键字可变位置参数列表,它允许你在调用构造函数时传入任意数量的位置参数,这些参数会作为元组(tuple)传递给__init__方法。

33-2-4、**kwargs(可选)一个非关键字可变关键字参数字典,它允许你在调用构造函数时传入任意数量的关键字参数,这些参数会作为字典(dictionary)传递给__init__方法。

33-3、功能

        初始化新创建的对象的状态。

33-4、返回值

        没有特定的返回值(或更准确地说是返回None)。

33-5、说明

        无

33-6、用法
  1. # 033、__init__方法:
  2. # 1、基础示例
  3. class Person:
  4. def __init__(self, name, age):
  5. self.name = name
  6. self.age = age
  7. # 2、设置默认值
  8. class Car:
  9. def __init__(self, color='red', brand='Toyota'):
  10. self.color = color
  11. self.brand = brand
  12. # 3、列表初始化
  13. class Playlist:
  14. def __init__(self, songs):
  15. self.songs = songs
  16. # 4、字典初始化
  17. class UserInfo:
  18. def __init__(self, details):
  19. self.details = details
  20. # 5、使用*args(可变位置参数)
  21. class VariableArguments:
  22. def __init__(self, *args):
  23. self.args = args
  24. # 6、使用kwargs(可变关键字参数)
  25. class KeywordArguments:
  26. def __init__(self, **kwargs):
  27. self.kwargs = kwargs
  28. # 7、结合*args和kwargs**
  29. class CombinedArguments:
  30. def __init__(self, name, *args, **kwargs):
  31. self.name = name
  32. self.args = args
  33. self.kwargs = kwargs
  34. # 8、属性验证(例如,确保年龄为正数)
  35. class ValidatedPerson:
  36. def __init__(self, name, age):
  37. if age < 0:
  38. raise ValueError("Age cannot be negative")
  39. self.name = name
  40. self.age = age
  41. # 9、文件处理(初始化时打开文件)
  42. class LogFile:
  43. def __init__(self, filename):
  44. self.file = open(filename, 'a')
  45. def __del__(self):
  46. self.file.close()
  47. # 10、数据库连接(初始化时连接到数据库)
  48. import sqlite3
  49. class Database:
  50. def __init__(self, db_name):
  51. self.connection = sqlite3.connect(db_name)
  52. self.cursor = self.connection.cursor()
  53. def __del__(self):
  54. self.connection.close()
  55. # 11、计算属性(在初始化时计算某些值)
  56. class Circle:
  57. def __init__(self, radius):
  58. self.radius = radius
  59. self.diameter = 2 * radius
  60. self.area = 3.14159 * radius ** 2
  61. # 12、使用私有属性和getter/setter
  62. class SecretAgent:
  63. def __init__(self, code_name):
  64. self._code_name = code_name
  65. @property
  66. def code_name(self):
  67. return self._code_name
  68. @code_name.setter
  69. def code_name(self, new_name):
  70. if new_name.isalpha():
  71. self._code_name = new_name
  72. else:
  73. raise ValueError("Code name must be alphabetic")
  74. # 13、带有日志记录的初始化
  75. import logging
  76. class LoggedClass:
  77. def __init__(self, name):
  78. self.name = name
  79. logging.info(f'Object of {self.__class__.__name__} with name {name} created.')
  80. # 14、设置对象的状态
  81. class Light:
  82. OFF = 0
  83. ON = 1
  84. def __init__(self, status=OFF):
  85. if status not in [self.OFF, self.ON]:
  86. raise ValueError('Invalid status')
  87. self.status = status
  88. # 15、绑定回调函数
  89. class Button:
  90. def __init__(self, on_press=None):
  91. self.on_press = on_press
  92. def press(self):
  93. if self.on_press:
  94. self.on_press()
  95. # 16、处理继承中的初始化
  96. class Parent:
  97. def __init__(self, parent_attr):
  98. self.parent_attr = parent_attr
  99. class Child(Parent):
  100. def __init__(self, parent_attr, child_attr):
  101. super().__init__(parent_attr) # Call parent's __init__
  102. self.child_attr = child_attr
  103. # 17、使用枚举类型
  104. from enum import Enum
  105. class Color(Enum):
  106. RED = 1
  107. GREEN = 2
  108. BLUE = 3
  109. class LightBulb:
  110. def __init__(self, color: Color):
  111. if not isinstance(color, Color):
  112. raise ValueError('Color must be an instance of Color Enum')
  113. self.color = color
  114. # 18、配置文件的加载
  115. import configparser
  116. class ConfiguredClass:
  117. def __init__(self, config_file):
  118. config = configparser.ConfigParser()
  119. config.read(config_file)
  120. self.setting1 = config.get('section1', 'setting1')
  121. self.setting2 = config.getint('section2', 'setting2')
  122. # 19、使用@property装饰器进行初始化
  123. class PropertyExample:
  124. def __init__(self):
  125. self._value = None
  126. @property
  127. def value(self):
  128. return self._value
  129. @value.setter
  130. def value(self, new_value):
  131. if new_value < 0:
  132. raise ValueError('Value must be non-negative')
  133. self._value = new_value
  134. if __name__ == '__main__':
  135. obj = PropertyExample()
  136. obj.value = 10 # 这里实际上在setter中进行了初始化
  137. # 20、依赖注入
  138. class Service:
  139. def __init__(self, dependency):
  140. self.dependency = dependency
  141. if __name__ == '__main__':
  142. dependency = SomeDependency()
  143. service = Service(dependency)

34、__init_subclass__方法

34-1、语法
  1. __init_subclass__(cls, **kwargs):
  2. super().__init_subclass__(**kwargs) # 调用父类的__init_subclass__方法
34-2、参数

34-2-1、cls(必须)一个对子类本身的引用,它是一个类对象。

34-2、**kwargs(可选)一个可变关键字参数字典,允许你在定义子类时传递任意数量的关键字参数给__init_subclass__方法。这些关键字参数在子类的类定义中通过元类(如果有的话)或直接在类定义中通过metaclass=SomeMetaClass(arg1=value1, arg2=value2, ...)的方式传递。

34-3、功能

        在子类被创建时自动调用,用于在子类定义完成后执行一些初始化操作。

34-4、返回值

        没有特定的返回值(或更准确地说是返回None)。

34-5、说明

        __init_subclass__并不是在所有情况下都会自动被调用,它只在通过class语句显式地定义子类时才会被调用,而不是在通过继承或元类编程间接地创建子类时。

34-6、用法
  1. # 034、__init_subclass__方法:
  2. # 1、添加类属性
  3. class Base:
  4. def __init_subclass__(cls, **kwargs):
  5. cls.subclass_attr = kwargs.get('subclass_attr', 'default')
  6. class SubclassA(Base, subclass_attr='A-specific'):
  7. pass
  8. print(SubclassA.subclass_attr) # 输出 'A-specific'
  9. # 2、注册子类
  10. class Registry:
  11. subclasses = []
  12. def __init_subclass__(cls, **kwargs):
  13. super().__init_subclass__(**kwargs)
  14. cls.subclasses.append(cls)
  15. class RegisteredA(Registry):
  16. pass
  17. class RegisteredB(Registry):
  18. pass
  19. print(Registry.subclasses) # 输出 [<class '__main__.RegisteredA'>, <class '__main__.RegisteredB'>]
  20. # 3、动态设置元类
  21. class MetaBase(type):
  22. pass
  23. class MetaA(MetaBase):
  24. pass
  25. # 注意这里我们使用了 metaclass 关键字来指定元类
  26. class Base(metaclass=MetaBase):
  27. def __init_subclass__(cls, **kwargs):
  28. super().__init_subclass__(**kwargs)
  29. # 这里我们不需要做任何额外的事情,因为元类已经在类定义时指定了
  30. # 这里我们不再使用 meta=MetaA,而是直接在类定义时指定元类
  31. class SubclassWithMeta(Base, metaclass=MetaA):
  32. pass
  33. print(type(SubclassWithMeta)) # 应该输出 <class '__main__.MetaA'>
  34. # 4、设置类级别的变量
  35. class Base:
  36. def __init_subclass__(cls, **kwargs):
  37. super().__init_subclass__(**kwargs)
  38. # 注意:这里我们不会从 kwargs 获取 class_var,因为我们不能直接传递它
  39. class SubclassB(Base):
  40. # 我们不能直接在这里设置 class_var,因为它是类变量,不是 __init_subclass__ 的参数
  41. pass
  42. # 在类定义之后,我们直接设置 class_var
  43. SubclassB.class_var = 42
  44. print(SubclassB.class_var) # 输出 42
  45. # 5、验证子类属性
  46. class Base:
  47. def __init_subclass__(cls, **kwargs):
  48. super().__init_subclass__(**kwargs)
  49. if not hasattr(cls, 'required_attr'):
  50. raise TypeError(f"{cls.__name__} must have a 'required_attr' attribute")
  51. class SubclassD(Base):
  52. required_attr = True
  53. # 下面的类会抛出TypeError,因为它没有'required_attr'
  54. # class SubclassE(Base):
  55. # pass
  56. # TypeError: SubclassE must have a 'required_attr' attribute
  57. # 6、设置默认属性值
  58. class Base:
  59. default_value = None
  60. def __init_subclass__(cls, **kwargs):
  61. super().__init_subclass__(**kwargs)
  62. if not hasattr(cls, 'default_value'):
  63. cls.default_value = 'default from Base'
  64. class SubclassF(Base):
  65. pass
  66. print(SubclassF.default_value) # 输出 'default from Base'
  67. # 7、实现接口检查
  68. class Interface:
  69. pass
  70. class Base:
  71. def __init_subclass__(cls, **kwargs):
  72. super().__init_subclass__(**kwargs)
  73. if not issubclass(cls, Interface):
  74. raise TypeError(f"{cls.__name__} must implement {Interface.__name__} interface")
  75. # 下面的类会抛出TypeError,因为它没有实现Interface
  76. # class SubclassG(Base):
  77. # pass
  78. class SubclassH(Base, Interface):
  79. pass
  80. # 8、添加类方法
  81. class Base:
  82. def __init_subclass__(cls, **kwargs):
  83. super().__init_subclass__(**kwargs)
  84. def subclass_method(self):
  85. return f"I'm a method from {cls.__name__}"
  86. setattr(cls, 'subclass_method', classmethod(subclass_method))
  87. class SubclassC(Base):
  88. pass
  89. print(SubclassC.subclass_method()) # 输出 "I'm a method from SubclassC"
  90. # 9、设置继承顺序
  91. class Base:
  92. _order = []
  93. def __init_subclass__(cls, order=None, **kwargs):
  94. super().__init_subclass__(**kwargs)
  95. if order is not None:
  96. Base._order.append((order, cls))
  97. # 按照指定的顺序排序
  98. Base._order.sort(key=lambda x: x[0])
  99. class SubclassI(Base, order=1):
  100. pass
  101. class SubclassJ(Base, order=2):
  102. pass
  103. class SubclassK(Base, order=0):
  104. pass
  105. # 打印按照顺序排列的子类
  106. for _, cls in Base._order:
  107. print(cls.__name__) # 输出 SubclassK, SubclassI, SubclassJ
  108. # 10、添加装饰器到所有子类方法
  109. def my_decorator(func):
  110. def wrapper(*args, **kwargs):
  111. print(f"Calling {func.__name__} with decorator")
  112. return func(*args, **kwargs)
  113. return wrapper
  114. class Base:
  115. def __init_subclass__(cls, **kwargs):
  116. super().__init_subclass__(**kwargs)
  117. for name, method in vars(cls).items():
  118. if callable(method) and not name.startswith("__"):
  119. setattr(cls, name, my_decorator(method))
  120. class SubclassL(Base):
  121. def method(self):
  122. print("SubclassL method called")
  123. SubclassL().method() # 输出 "Calling method with decorator" 和 "SubclassL method called"
  124. # 11、根据子类名称动态添加方法
  125. class Base:
  126. def __init_subclass__(cls, **kwargs):
  127. super().__init_subclass__(**kwargs)
  128. def dynamic_method(self):
  129. return f"This is a dynamic method for {cls.__name__}"
  130. setattr(cls, f"dynamic_{cls.__name__.lower()}", dynamic_method)
  131. class SubclassN(Base):
  132. pass
  133. print(SubclassN().dynamic_subclassn()) # 输出 "This is a dynamic method for SubclassN"

五、推荐阅读

1、Python筑基之旅

2、Python函数之旅

3、Python算法之旅

4、博客个人主页

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/小小林熬夜学编程/article/detail/724556
推荐阅读
相关标签
  

闽ICP备14008679号