Python-VBA函数之旅-isinstance函数

目录

一、isinstance函数的常见应用场景：

二、isinstance函数使用注意事项：

三、如何用好isinstance函数？

1、isinstance函数：

1-1、Python：

1-2、VBA：

2、推荐阅读：

个人主页：神奇夜光杯-CSDN博客 

一、isinstance函数的常见应用场景：

        在Python中，isinstance()函数用于确定对象是否属于特定的类或类型，常见的应用场景有：

1、类型检查：当你需要根据对象的类型执行不同的操作时，isinstance()函数非常有用。例如，你可能需要根据变量的类型来格式化输出，或者根据类型执行不同的逻辑分支。

2、多态性支持：在面向对象的编程中，多态性允许使用父类引用处理子类对象；使用isinstance()函数可以确保即使子类有额外的行为或属性，代码也能正确处理它们。 

3、输入验证：在编写函数或方法时，你可能需要确保传入的参数是预期的类型。使用isinstance()可以在函数内部进行类型检查，并在传入错误类型时提供清晰的错误信息。

4、扩展性和灵活性：当你想让你的代码能够处理多种类型时，可以使用isinstance()函数来检查一个对象是否属于一系列类型中的任何一个，这使得代码更加灵活，能够处理更多种类的输入。

5、工厂模式：在工厂模式中，isinstance()函数可以用来确定应该创建哪种类型的对象；工厂函数接受一些参数，并使用isinstance()来确定应该返回哪种类型的对象实例。

6、类型安全的API设计：在设计API或库时，确保传入的参数类型正确是很重要的；使用isinstance()可以帮助你实现类型安全的接口，从而避免潜在的错误和异常。

7、与抽象基类(ABC)一起使用：在设计API或库时，确保传入的参数类型正确是很重要的，使用isinstance()函数可以帮助你实现类型安全的接口，从而避免潜在的错误和异常。

        总之，isinstance()函数在Python编程中是一个强大的工具，用于在运行时确定对象的类型，并根据需要执行相应的操作，它在类型检查、多态性实现、输入验证、扩展性和灵活性、工厂模式、设计类型安全的API及与抽象基类(ABC)一起使用等方面都有广泛的应用。

二、isinstance函数使用注意事项：

        在Python中，isinstance()函数是一个常用的工具，用于确定一个对象是否是一个已知的类型或类的实例。使用时，需注意以下几点：

1、类型元组：当你想检查对象是否属于多个类型之一时，可以传递一个类型元组给 isinstance()，确保元组中的类型是按照你的逻辑顺序排列的，因为一旦找到匹配的类型，isinstance()函数就会返回 True，并不会继续检查元组中的其他类型。

2、不要过度使用：尽管isinstance()函数很有用，但过度使用它可能会导致代码变得冗长和难以阅读。在某些情况下，使用更简洁的鸭子类型(duck typing)可能是更好的选择，即“如果它走起路来像鸭子，叫起来也像鸭子，那么它就是鸭子”。这意味着，如果对象有你需要的方法或属性，你就可以使用它，而不必关心它确切的类型。

3、继承关系：当使用isinstance()检查一个对象是否是一个类的实例时，它也会检查该对象是否是该类子类的实例，这是多态性的基础，但也要确保你了解类的继承关系，以避免意外的类型匹配。

4、自定义类的比较：如果你定义了自己的类，并且想要通过isinstance()检查对象是否是你的类的实例，确保你的类定义正确，并且没有意外地覆盖了 `__instancecheck__` 方法，该方法会影响 isinstance()的行为。通常，你不需要直接操作这个方法，除非你有特殊的类型检查需求。

5、避免与type()函数比较：isinstance()和type()都可以用来检查对象的类型，但isinstance()更为推荐，因为它可以处理继承关系；而type()只会检查对象是否直接是某个特定类的实例，不会考虑继承。

6、性能考虑：虽然isinstance()函数的性能通常不是问题，但在性能关键的应用程序中，频繁的类型检查可能会对性能产生轻微影响。在这种情况下，可以考虑使用其他设计策略来减少类型检查的需要，比如使用接口或协议来定义对象的行为。

7、版本兼容性：不同版本的Python可能对isinstance()的行为有细微的差别，特别是当涉及到内置类型或特殊的元类行为时，确保你的代码在目标Python版本上进行了充分的测试。

        总之，只有遵循这些注意事项，你才可以更安全、更有效地使用isinstance()函数来进行类型检查。

三、如何用好isinstance函数？

        要在Python中用好isinstance()函数，你需要理解其用途、语法以及一些常见的应用场景，相关参考建议如下：

1、明确使用场景：首先，你需要明确为什么要使用isinstance()函数。通常，这是为了确定一个对象是否属于特定的类型或类的实例，这在你需要基于对象的类型执行不同操作时特别有用。

2、理解语法：isinstance()函数接受两个参数：要检查的对象和要比较的类型(或类型元组)；如果对象是该类型的实例，则返回True，否则返回False。

3、处理继承关系：当使用isinstance()时，它会考虑继承关系，这意味着如果一个对象是一个类的子类实例，那么isinstance()也会返回True，这是多态性的一个体现，有助于编写更加灵活和可维护的代码。

4、检查多个类型：如果你想要检查对象是否属于多个可能的类型之一，可以将这些类型放在一个元组中，并将其作为第二个参数传递给isinstance()函数。

5、避免过度使用：虽然isinstance()在某些情况下很有用，但过度使用它可能会导致代码变得冗长和难以维护；在Python中，通常更倾向于使用鸭子类型(duck typing)，即如果对象具有你所需的方法或属性，就可以认为它是合适的类型，而无需显式检查其类型。

6、结合异常处理：如果你期望对象必须是特定类型，并且如果不是该类型则程序无法继续执行，可以结合使用isinstance()和异常处理来确保类型正确。

7、考虑使用抽象基类：对于更复杂的类型检查，可以考虑使用Python的`collections.abc`模块中定义的抽象基类(ABCs)，这些基类提供了更高级别的接口检查，而不仅仅是简单的类型匹配。

8、注意版本兼容性：不同的Python版本可能对isinstance()的行为略有不同，确保你的代码在目标Python版本上进行了充分的测试，并检查是否有任何与类型检查相关的已知变化。

9、代码清晰性：使用isinstance()时，确保你的代码清晰易读，避免在复杂的逻辑表达式中嵌套多个isinstance()调用，这可能会使代码难以理解；相反，考虑将类型检查逻辑分解为单独的函数或方法，以提高代码的可读性和可维护性。

        总之，只有通过遵循这些建议，你才能更有效地使用isinstance()函数来增强你的Python代码的类型安全性和灵活性。

1、isinstance函数：
1-1、Python：
  1. # 1.函数：isinstance
  2. # 2.功能：用于判断对象是否是类或者类型元组中任意类元素的实例
  3. # 3.语法：isinstance(object, classinfo)
  4. # 4.参数：
  5. # 4-1、object：实例对象
  6. # 4-2、classinfo：类名可以是直接或间接类名、基本类型或者由它们组成的元组
  7. # 5.返回值：如果对象的类型与classinfo类型相同则返回True；否则返回False
  8. # 6.说明：
  9. # 7.示例：
  10. # 利用dir()函数获取函数的相关内置属性和方法
  11. # ['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__',
  12. # '__getstate__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__name__',
  13. # '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__',
  14. # '__str__', '__subclasshook__', '__text_signature__']
  15. print(dir(isinstance))
  16.  
  17. # 利用help()函数获取函数的文档信息
  18. help(isinstance)
  19.  
  20. # 应用一：类型检查
  21. # 示例1：检查整数类型
  22. num = 123
  23. if isinstance(num, int):
  24.     print("num 是一个整数")
  25. else:
  26.     print("num 不是一个整数")
  27. # num 是一个整数
  28.  
  29. # 示例2：检查字符串类型
  30. text = "Hello, Python!"
  31. if isinstance(text, str):
  32.     print("text 是一个字符串")
  33. else:
  34.     print("text 不是一个字符串")
  35. # text 是一个字符串
  36.  
  37. # 示例3：检查列表类型
  38. my_list = [3, 5, 6, 8, 10, 11, 24]
  39. if isinstance(my_list, list):
  40.     print("my_list 是一个列表")
  41. else:
  42.     print("my_list 不是一个列表")
  43. # my_list 是一个列表
  44.  
  45. # 示例4：检查多个类型
  46. item = "Myelsa"
  47. if isinstance(item, (str, int)):
  48.     print("item 是字符串或整数")
  49. else:
  50.     print("item 不是字符串也不是整数")
  51. # item 是字符串或整数
  52.  
  53. # 示例5：自定义类型检查
  54. class MyClass:
  55.     pass
  56. obj = MyClass()
  57. if isinstance(obj, MyClass):
  58.     print("obj 是 MyClass 的一个实例")
  59. else:
  60.     print("obj 不是 MyClass 的一个实例")
  61. # obj 是 MyClass 的一个实例
  62.  
  63. # 应用二：多态性支持
  64. # 示例1：形状类与多态性
  65. class Shape:
  66.     def draw(self):
  67.         pass
  68. class Circle(Shape):
  69.     def draw(self):
  70.         print("Drawing a circle")
  71. class Rectangle(Shape):
  72.     def draw(self):
  73.         print("Drawing a rectangle")
  74. class Triangle(Shape):
  75.     def draw(self):
  76.         print("Drawing a triangle")
  77. def draw_shapes(shapes):
  78.     for shape in shapes:
  79.         if isinstance(shape, Circle):
  80.             print("Drawing a circle specifically")
  81.             shape.draw()
  82.         elif isinstance(shape, Rectangle):
  83.             print("Drawing a rectangle specifically")
  84.             shape.draw()
  85.         elif isinstance(shape, Triangle):
  86.             print("Drawing a triangle specifically")
  87.             shape.draw()
  88.         else:
  89.             print("Drawing a generic shape")
  90.             shape.draw()
  91. shapes = [Circle(), Rectangle(), Triangle()]
  92. draw_shapes(shapes)
  93. # Drawing a circle specifically
  94. # Drawing a circle
  95. # Drawing a rectangle specifically
  96. # Drawing a rectangle
  97. # Drawing a triangle specifically
  98. # Drawing a triangle
  99.  
  100. # 示例2：使用多态性处理不同数据类型的函数
  101. def process_data(data):
  102.     if isinstance(data, int):
  103.         print(f"Processing integer: {data}")
  104.         # 执行整数相关的操作
  105.     elif isinstance(data, str):
  106.         print(f"Processing string: {data}")
  107.         # 执行字符串相关的操作
  108.     elif isinstance(data, list):
  109.         print(f"Processing list: {data}")
  110.         # 执行列表相关的操作
  111.     else:
  112.         print(f"Unsupported data type: {type(data)}")
  113. process_data(42)
  114. process_data("Hello")
  115. process_data([1, 2, 3])
  116. process_data(3.14)
  117. # Processing integer: 42
  118. # Processing string: Hello
  119. # Processing list: [1, 2, 3]
  120. # Unsupported data type: 
  121.  
  122. # 应用三：输入验证
  123. # 示例1：验证整数输入
  124. def validate_integer_input(input_value):
  125.     if isinstance(input_value, int):
  126.         print("输入是一个整数")
  127.         return True
  128.     else:
  129.         print("输入不是一个整数，请重新输入")
  130.         return False
  131. # 测试函数
  132. user_input = input("请输入一个整数: ")
  133. try:
  134.     user_input = int(user_input)  # 尝试将输入转换为整数
  135.     if validate_integer_input(user_input):
  136.         # 如果验证通过，进行后续操作
  137.         pass  # 在这里添加你的代码
  138. except ValueError:
  139.     # 如果输入无法转换为整数，打印错误信息
  140.     print("无效的输入，请输入一个有效的整数")
  141. # 请输入一个整数: 1024
  142. # 输入是一个整数
  143.  
  144. # 示例2：验证字符串输入
  145. def validate_string_input(input_value):
  146.     if isinstance(input_value, str):
  147.         print("输入是一个字符串")
  148.         return True
  149.     else:
  150.         print("输入不是一个字符串，请重新输入")
  151.         return False
  152. # 测试函数
  153. user_input = input("请输入一个字符串: ")
  154. if validate_string_input(user_input):
  155.     # 如果验证通过，进行后续操作
  156.     pass  # 在这里添加你的代码
  157. # 请输入一个字符串: myelsa
  158. # 输入是一个字符串
  159.  
  160. # 示例3：验证列表输入，并检查元素类型
  161. def validate_list_input(input_value):
  162.     if isinstance(input_value, list):
  163.         for item in input_value:
  164.             if not isinstance(item, int):
  165.                 print("列表中包含非整数元素")
  166.                 return False
  167.         print("输入是一个整数列表")
  168.         return True
  169.     else:
  170.         print("输入不是一个列表，请重新输入")
  171.         return False
  172. # 测试函数
  173. user_input = input("请输入一个由整数组成的列表(用空格分隔): ")
  174. try:
  175.     user_input_list = list(map(int, user_input.split()))  # 将输入转换为整数列表
  176.     if validate_list_input(user_input_list):
  177.         # 如果验证通过，进行后续操作
  178.         pass  # 在这里添加你的代码
  179. except ValueError:
  180.     # 如果输入无法转换为整数列表，打印错误信息
  181.     print("无效的输入，请输入一个由整数组成的列表")
  182. # 请输入一个由整数组成的列表(用空格分隔): 3 5 6
  183. # 输入是一个整数列表
  184.  
  185. # 示例4：验证自定义类实例的输入
  186. class Person:
  187.     def __init__(self, name, age):
  188.         self.name = name
  189.         self.age = age
  190. def validate_person_input(input_value):
  191.     if isinstance(input_value, Person):
  192.         print("输入是一个 Person 类的实例")
  193.         return True
  194.     else:
  195.         print("输入不是一个 Person 类的实例，请重新输入")
  196.         return False
  197. # 测试函数
  198. user_name = input("请输入姓名: ")
  199. user_age = input("请输入年龄: ")
  200. try:
  201.     user_age = int(user_age)  # 尝试将年龄输入转换为整数
  202.     person = Person(user_name, user_age)
  203.     if validate_person_input(person):
  204.         # 如果验证通过，进行后续操作
  205.         pass  # 在这里添加你的代码
  206. except ValueError:
  207.     # 如果年龄输入无法转换为整数，打印错误信息
  208.     print("无效的输入，年龄必须是一个整数")
  209. # 请输入姓名: Myelsa
  210. # 请输入年龄: 18
  211. # 输入是一个 Person 类的实例
  212.  
  213. # 应用四：扩展性和灵活性
  214. # 示例1：处理不同数据类型的函数
  215. def process_data(data):
  216.     if isinstance(data, int):
  217.         print(f"Processing an integer: {data}")
  218.         # 执行整数相关的操作
  219.     elif isinstance(data, str):
  220.         print(f"Processing a string: {data}")
  221.         # 执行字符串相关的操作
  222.     elif isinstance(data, list):
  223.         print(f"Processing a list: {data}")
  224.         # 执行列表相关的操作
  225.     elif isinstance(data, (dict, set)):
  226.         print(f"Processing a collection: {data}")
  227.         # 执行集合或字典相关的操作
  228.     else:
  229.         print(f"Unsupported data type: {type(data)}")
  230. # 使用函数处理不同类型的数据
  231. process_data(42)
  232. process_data("Hello")
  233. process_data([1, 2, 3])
  234. process_data({"key": "value"})
  235. process_data({1, 2, 3})
  236. # Processing an integer: 42
  237. # Processing a string: Hello
  238. # Processing a list: [1, 2, 3]
  239. # Processing a collection: {'key': 'value'}
  240. # Processing a collection: {1, 2, 3}
  241.  
  242. # 示例2：插件式架构
  243. class PluginInterface:
  244.     def execute(self):
  245.         raise NotImplementedError("Subclasses must implement this method")
  246. class PluginA(PluginInterface):
  247.     def execute(self):
  248.         print("Plugin A is executing")
  249. class PluginB(PluginInterface):
  250.     def execute(self):
  251.         print("Plugin B is executing")
  252. def run_plugin(plugin):
  253.     if isinstance(plugin, PluginInterface):
  254.         plugin.execute()
  255.     else:
  256.         print("The provided plugin does not implement the required interface")
  257. # 创建插件实例并运行它们
  258. plugin_a = PluginA()
  259. plugin_b = PluginB()
  260. run_plugin(plugin_a)
  261. run_plugin(plugin_b)
  262. # Plugin A is executing
  263. # Plugin B is executing
  264.  
  265. # 示例3：工厂模式
  266. class Shape:
  267.     pass
  268. class Circle(Shape):
  269.     def draw(self):
  270.         print("Drawing a circle")
  271. class Rectangle(Shape):
  272.     def draw(self):
  273.         print("Drawing a rectangle")
  274. def create_shape(shape_type):
  275.     if isinstance(shape_type, str):
  276.         if shape_type == "circle":
  277.             return Circle()
  278.         elif shape_type == "rectangle":
  279.             return Rectangle()
  280.     else:
  281.         print("Invalid shape type")
  282.         return None
  283. # 使用工厂函数创建形状对象
  284. circle = create_shape("circle")
  285. rectangle = create_shape("rectangle")
  286. if circle:
  287.     circle.draw()
  288. if rectangle:
  289.     rectangle.draw()
  290. # Drawing a circle
  291. # Drawing a rectangle
  292.  
  293. # 应用五：类型安全的API设计
  294. # 示例1：简单的API函数
  295. def greet_person(name: str):
  296.     if not isinstance(name, str):
  297.         raise ValueError("Name must be a string")
  298.     print(f"Hello, {name}!")
  299. # 正确使用
  300. greet_person("Myelsa")
  301. # Hello, Myelsa!
  302. # 错误使用，会抛出异常
  303. greet_person(42)
  304. # ValueError: Name must be a string
  305.  
  306. # 示例2：带有多个参数和返回类型的API函数
  307. def calculate_area(shape: str, **kwargs) -> float:
  308.     if not isinstance(shape, str):
  309.         raise ValueError("Shape must be a string")
  310.     if shape == "circle":
  311.         if not all(isinstance(v, (int, float)) for k, v in kwargs.items()):
  312.             raise ValueError("Circle parameters must be numeric")
  313.         radius = kwargs.get("radius", 0)
  314.         return 3.14159 * radius ** 2
  315.     elif shape == "rectangle":
  316.         if not all(isinstance(v, (int, float)) for k, v in kwargs.items()):
  317.             raise ValueError("Rectangle parameters must be numeric")
  318.         length = kwargs.get("length", 0)
  319.         width = kwargs.get("width", 0)
  320.         return length * width
  321.     else:
  322.         raise ValueError("Invalid shape")
  323. # 正确使用
  324. area_circle = calculate_area("circle", radius=5)  # 输出圆的面积
  325. area_rectangle = calculate_area("rectangle", length=10, width=5)  # 输出矩形的面积
  326. # 错误使用，会抛出异常
  327. calculate_area("triangle", base=3, height=4)  # 抛出 ValueError: Invalid shape
  328. calculate_area("circle", radius="five")  # 抛出 ValueError: Circle parameters must be numeric
  329.  
  330. # 示例3：使用类进行API设计
  331. class BankAccount:
  332.     def __init__(self, name: str, balance: float):
  333.         if not isinstance(name, str):
  334.             raise ValueError("Name must be a string")
  335.         if not isinstance(balance, (int, float)):
  336.             raise ValueError("Balance must be a number")
  337.         self.name = name
  338.         self.balance = balance
  339.     def deposit(self, amount: float):
  340.         if not isinstance(amount, (int, float)):
  341.             raise ValueError("Deposit amount must be a number")
  342.         if amount < 0:
  343.             raise ValueError("Deposit amount must be positive")
  344.         self.balance += amount
  345.         print(f"Deposited {amount}. New balance: {self.balance}")
  346.     def withdraw(self, amount: float):
  347.         if not isinstance(amount, (int, float)):
  348.             raise ValueError("Withdraw amount must be a number")
  349.         if amount < 0:
  350.             raise ValueError("Withdraw amount must be positive")
  351.         if amount > self.balance:
  352.             raise ValueError("Insufficient funds")
  353.         self.balance -= amount
  354.         print(f"Withdrawn {amount}. New balance: {self.balance}")
  355. # 创建一个银行账户实例
  356. account = BankAccount("Alice", 1000.0)
  357. # 正确使用
  358. account.deposit(500.0)  # 存款
  359. account.withdraw(200.0)  # 取款
  360. # Deposited 500.0. New balance: 1500.0
  361. # Withdrawn 200.0. New balance: 1300.0
  362. # 错误使用，会抛出异常
  363. account.withdraw(-100.0)  # 抛出 ValueError: Withdraw amount must be positive
  364. account.withdraw(1500.0)  # 抛出 ValueError: Insufficient funds
  365.  
  366. # 应用六：与抽象基类(ABC)一起使用
  367. from abc import ABC, abstractmethod
  368. class Shape(ABC):
  369.     @abstractmethod
  370.     def area(self):
  371.         pass
  372. class Circle(Shape):
  373.     def __init__(self, radius):
  374.         self.radius = radius
  375.     def area(self):
  376.         return 3.14 * self.radius ** 2
  377. class Rectangle(Shape):
  378.     def __init__(self, length, width):
  379.         self.length = length
  380.         self.width = width
  381.     def area(self):
  382.         return self.length * self.width
  383. def check_shape(obj):
  384.     if isinstance(obj, Shape):
  385.         print("The object is an instance of Shape or one of its subclasses.")
  386.         try:
  387.             area = obj.area()
  388.             print(f"The area of the shape is: {area}")
  389.         except TypeError:
  390.             print("The shape object does not have a valid area method.")
  391.     else:
  392.         print("The object is not an instance of Shape or one of its subclasses.")
  393. # 测试 Circle 和 Rectangle
  394. circle = Circle(5)
  395. check_shape(circle)
  396. rectangle = Rectangle(10, 5)
  397. check_shape(rectangle)
  398. # 测试一个非 Shape 类的实例
  399. not_a_shape = "I'm not a shape"
  400. check_shape(not_a_shape)
  401. # The object is an instance of Shape or one of its subclasses.
  402. # The area of the shape is: 78.5
  403. # The object is an instance of Shape or one of its subclasses.
  404. # The area of the shape is: 50
  405. # The object is not an instance of Shape or one of its subclasses.
1-2、VBA：
略，待后补。
2、推荐阅读：

1、Python-VBA函数之旅-int()函数

Python算法之旅：Algorithm

Python函数之旅：Functions 

个人主页：神奇夜光杯-CSDN博客 
文章知识点与官方知识档案匹配，可进一步学习相关知识
算法技能树首页概览60609 人正在系统学习中
遨游码海，我心飞扬
微信名片
注：本文转载自blog.csdn.net的神奇夜光杯的文章"https://myelsa1024.blog.csdn.net/article/details/138149092"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！