issubclass()
在Python中，issubclass()是一个内置函数，用于检查一个类是否是另一个类的子类。如果是，则返回True；如果不是，则返回False。这个函数在面向对象编程中非常有用，尤其是在需要确定类与类之间的继承关系时。
以下是issubclass()的基本使用方式：
class Base:
pass
class Derived(Base):
pass
# 检查Derived是否是Base的子类
print(issubclass(Derived, Base)) # 输出: True
# 检查Base是否是Derived的子类
print(issubclass(Base, Derived)) # 输出: False
# 检查两个不相关的类
class Unrelated:
pass
print(issubclass(Unrelated, Base)) # 输出: False
在这个例子中，Derived类继承自Base类，所以issubclass(Derived, Base)返回True。相反，Base类不是Derived类的子类，所以issubclass(Base, Derived)返回False。Unrelated类与Base类没有继承关系，因此issubclass(Unrelated, Base)也返回False。
issubclass()还可以用来检查一个类是否是多个基类之一的子类，这在多重继承的情况下非常有用：
class AnotherBase:
pass
class MultiDerived(Base, AnotherBase):
pass
# 检查MultiDerived是否是Base或AnotherBase的子类
print(issubclass(MultiDerived, Base)) # 输出: True
print(issubclass(MultiDerived, AnotherBase)) # 输出: True
在这个例子中，MultiDerived类同时继承自Base和AnotherBase类，因此issubclass()对于这两个基类都返回True。
总的来说，issubclass()是一个在Python中确定类之间继承关系的强大工具。
isinstance()
在Python中，isinstance()是一个内置函数，用于检查一个对象是否是一个已知的类型（类或类型）。它返回True如果对象的类型与参数相同，否则返回False。isinstance()函数特别有用，因为它不仅检查对象是否是给定的类型，还会检查对象是否是该类型的子类。
下面是一些使用isinstance()的例子：
# 定义一个简单的类
class MyClass:
pass
# 创建一个对象
obj = MyClass()
# 检查obj是否是MyClass的实例
print(isinstance(obj, MyClass)) # 输出: True
# 检查obj是否是所有对象的基类type的实例
print(isinstance(obj, type)) # 输出: True
# 创建一个字符串对象
str_obj = "Hello, World!"
# 检查str_obj是否是str类型的实例
print(isinstance(str_obj, str)) # 输出: True
# 检查str_obj是否是MyClass的实例
print(isinstance(str_obj, MyClass)) # 输出: False
# 检查整数是否是int类型的实例
print(isinstance(123, int)) # 输出: True
# 检查整数是否是str类型的实例
print(isinstance(123, str)) # 输出: False
# 检查一个对象是否是多个类型之一
print(isinstance(123, (int, float))) # 输出: True
在上面的例子中，isinstance()函数用于检查obj是否是MyClass的实例，以及str_obj是否是str类型的实例。当我们试图检查str_obj是否是MyClass的实例时，isinstance()返回False，因为str_obj不是MyClass的实例。
此外，isinstance()还可以用于检查一个对象是否是多个类型之一，通过将类型作为元组传递给isinstance()函数。
isinstance()函数在处理继承关系时特别有用，因为它会考虑继承链。例如，如果有一个类Derived继承自Base，那么isinstance(derived_instance, Base)将返回True，因为Derived是Base的子类。
这个函数在编写灵活和可扩展的代码时非常有用，因为它允许你根据对象的类型来执行不同的操作，而不需要知道对象的确切类型。
hasattr()
在Python中，hasattr()是一个内置函数，用于检查一个对象是否具有给定的属性。它接受两个参数：一个是对象，另一个是要检查的属性名称（作为字符串）。如果对象具有该属性，hasattr()返回True，否则返回False。
下面是一个简单的例子，展示了如何使用hasattr()函数：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
# 创建一个Person对象
person = Person("Alice", 30)
# 检查对象是否有'name'属性
print(hasattr(person, 'name')) # 输出: True
# 检查对象是否有'age'属性
print(hasattr(person, 'age')) # 输出: True
# 检查对象是否有'height'属性，该属性在Person类中未定义
print(hasattr(person, 'height')) # 输出: False
# 检查对象是否有'__init__'方法，这是所有类都有的内置方法
print(hasattr(person, '__init__')) # 输出: False
# 注意：对于实例对象，内置方法（如__init__）不会显示为属性，所以返回False
# 如果要检查类是否具有某个方法，应该直接对类使用hasattr()
print(hasattr(Person, '__init__')) # 输出: True
在上面的例子中，我们定义了一个Person类，它有两个属性：name和age。我们创建了一个Person对象person，并使用hasattr()来检查这个对象是否具有name、age和height属性。由于height属性没有在Person类中定义，所以hasattr(person, ‘height’)返回False。
需要注意的是，hasattr()用于检查实例对象的属性时，不会显示内置方法（如__init__）作为属性，因为这些方法是与类关联的，而不是与实例对象关联的。如果要检查类是否具有某个方法，应该直接对该类使用hasattr()。
hasattr()函数在编写可扩展和灵活的代码时非常有用，因为它允许你在运行时检查对象是否具有某个属性或方法，从而可以编写更加通用的代码。
getattr()
getattr() 是 Python 的内置函数，用于获取对象的属性值。如果属性存在，则返回其值；如果属性不存在，则根据提供的默认值（如果提供的话）返回，或者如果未提供默认值，则抛出 AttributeError 异常。
下面是一个使用 getattr() 的例子：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
# 创建一个 Person 对象
person = Person("Alice", 30)
# 使用 getattr 获取属性
name = getattr(person, 'name')
age = getattr(person, 'age')
print(name) # 输出: Alice
print(age) # 输出: 30
# 尝试获取不存在的属性
# 默认情况下，这会抛出 AttributeError
try:
height = getattr(person, 'height')
except AttributeError:
height = None
print(height) # 输出: None
# 使用默认值
height = getattr(person, 'height', 170)
print(height) # 输出: 170
在这个例子中，getattr() 用于获取 person 对象的 name 和 age 属性。当我们尝试获取一个不存在的属性（如 height）时，getattr() 会抛出一个 AttributeError 异常。如果我们提供了一个默认值（在这个例子中是 170），那么当属性不存在时，getattr() 会返回这个默认值而不是抛出异常。
getattr() 在编写需要动态访问对象属性的代码时非常有用。它可以让你在运行时根据属性名称来获取属性值，而不是在编写代码时硬编码属性名称。这对于处理具有可变属性集合的对象或者需要根据外部输入访问不同属性的情况特别有用。
setattr()
setattr() 是 Python 的内置函数，用于设置对象的属性值。它接受三个参数：对象、属性名（以字符串形式给出）和要设置的新属性值。
以下是 setattr() 函数的一个基本示例：
class Person:
def __init__(self, name):
self.name = name
# 创建一个 Person 对象
person = Person("Alice")
# 使用 setattr() 设置属性
setattr(person, 'age', 30)
# 现在 person 对象有一个 'age' 属性，其值为 30
print(person.age) # 输出: 30
# 尝试设置一个不存在的属性
setattr(person, 'height', 170)
# 现在 person 对象还有一个 'height' 属性，其值为 170
print(person.height) # 输出: 170
# 更改已存在的属性的值
setattr(person, 'name', 'Bob')
# 'name' 属性的值已被更改为 'Bob'
print(person.name) # 输出: Bob
# 设置一个内置属性（通常不推荐这样做）
setattr(person, '__dict__', {'foo': 'bar'})
# 现在 person 对象有一个 '__dict__' 属性
print(person.__dict__) # 输出: {'foo': 'bar'}
在上面的例子中，我们创建了一个 Person 类，该类有一个 name 属性。我们使用 setattr() 函数为 person 对象添加了 age 和 height 属性，并更改了 name 属性的值。最后，我们还尝试设置了一个内置属性 dict，这通常不是一个好的做法，因为它会覆盖对象的默认字典属性。
需要注意的是，使用 setattr() 函数设置属性时要小心，尤其是当属性名是从外部输入或其他不可信的来源获得时。这可能会导致意外地覆盖对象的现有属性或设置不应该被公开的属性。
此外，setattr() 也可以用于设置对象的方法。例如，你可以使用 setattr() 动态地给对象添加一个新的方法。然而，这种做法通常也不是推荐的做法，因为它破坏了对象的封装性，并可能导致代码难以理解和维护。
delattr()
delattr() 是 Python 的内置函数，用于删除对象的属性。当你使用 delattr() 时，你需要提供两个参数：要删除属性的对象，以及要删除的属性的名称（作为字符串提供）。
下面是一个使用 delattr() 的例子：
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
# 创建一个 Person 对象
person = Person("Alice", 30)
# 打印对象的属性
print(person.name) # 输出: Alice
print(person.age) # 输出: 30
# 使用 delattr() 删除属性
delattr(person, 'age')
# 尝试访问已删除的属性会抛出 AttributeError
try:
print(person.age)
except AttributeError as e:
print(e) # 输出: 'Person' object has no attribute 'age'
# 删除不存在的属性会抛出 AttributeError
try:
delattr(person, 'height')
except AttributeError as e:
print(e) # 输出: 'Person' object has no attribute 'height'
# 如果你想要删除的属性可能不存在，可以先检查
if hasattr(person, 'name'):
delattr(person, 'name')
# 现在尝试访问 'name' 属性也会抛出 AttributeError
try:
print(person.name)
except AttributeError as e:
print(e) # 输出: 'Person' object has no attribute 'name'
在这个例子中，我们创建了一个 Person 对象，并为其设置了 name 和 age 属性。然后，我们使用 delattr() 函数删除了 age 属性，并尝试访问它，这会导致 AttributeError 异常。接下来，我们尝试删除一个不存在的属性 height，同样会引发异常。最后，我们删除了 name 属性。
delattr() 是一个强大的工具，但也需要谨慎使用，因为它会永久地从对象中删除属性。在删除属性之前，通常最好先使用 hasattr() 来检查属性是否存在，以避免意外地删除不存在的属性或覆盖重要的内置属性。
dir()
dir() 是 Python 的内置函数，用于返回一个对象的所有属性和方法的列表。当 dir() 调用时不带任何参数，它会返回当前局部和全局符号表中定义的名字。如果提供了一个对象作为参数，那么它会返回该对象的所有属性、方法和其他成员。
以下是一些 dir() 函数的使用示例：
# 使用 dir() 函数列出当前局部和全局变量的名称
print(dir())
# 创建一个简单的类
class MyClass:
def __init__(self):
self.my_attribute = 42
def my_method(self):
return "Hello, World!"
# 创建 MyClass 的实例
obj = MyClass()
# 使用 dir() 函数列出 obj 对象的所有属性和方法
print(dir(obj))
# 输出可能包括 ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'my_attribute', 'my_method']
# 使用 dir() 函数列出内建类型 int 的所有属性和方法
print(dir(int))
# 输出可能包括 ['__abs__', '__add__', '__and__', '__bool__', '__ceil__', '__class__', '__delattr__', '__dir__', '__divmod__', '__doc__', '__eq__', '__float__', '__floor__', '__floordiv__', '__format__', '__ge__', '__getattribute__', '__getnewargs__', '__gt__', '__hash__', '__index__', '__int__', '__invert__', '__le__', '__lshift__', '__lt__', '__mod__', '__mul__', '__ne__', '__neg__', '__new__', '__or__', '__pos__', '__pow__', '__radd__', '__rand__', '__rdivmod__', '__reduce__', '__reduce_ex__', '__repr__', '__rfloordiv__', '__rlshift__', '__rmod__', '__rmul__', '__ror__', '__rpow__', '__rrshift__', '__rshift__', '__rsub__', '__rtruediv__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__truediv__', '__trunc__', '__xor__', 'bit_length', 'conjugate', 'denominator', 'from_bytes', 'imag', 'numerator', 'real', 'to_bytes']
在上面的例子中，dir() 函数用于列出当前作用域中的变量、MyClass 实例的所有属性和方法，以及内建类型 int 的所有方法和属性。
dir() 函数对于探索对象的接口、调试以及编写通用代码时非常有用，因为它允许你查看对象的所有成员，包括那些可能不是通过常规文档或帮助系统直接可见的。
super()
super() 是 Python 中的一个内置函数，用于调用父类（或超类）的方法。它通常用在子类的方法中，以实现对父类方法的调用或覆盖。在面向对象编程中，super() 提供了一种动态地引用父类的方式，即使在多重继承的情况下也能正确地找到正确的父类。
super() 函数在类的方法内部使用，并且不接受任何参数（在 Python 2 中，需要显式地传递类名和实例，但在 Python 3 中，这些信息是自动传递的）。
以下是一个使用 super() 的例子：
class Parent:
def hello(self):
print("Hello from Parent")
class Child(Parent):
def hello(self):
super().hello() # 调用父类的 hello 方法
print("Hello from Child")
# 创建 Child 类的实例并调用 hello 方法
child = Child()
child.hello()
# 输出：
# Hello from Parent
# Hello from Child
在这个例子中，Child 类继承了 Parent 类，并覆盖了 hello 方法。在 Child 类的 hello 方法中，我们使用 super().hello() 来调用 Parent 类的 hello 方法。这样，当我们调用 child.hello() 时，会首先打印出 “Hello from Parent”，然后是 “Hello from Child”。
super() 的一个常见用途是在子类中调用父类的 init 方法，以确保父类的初始化代码被正确执行：
class Parent:
def __init__(self):
print("Parent __init__ called")
class Child(Parent):
def __init__(self):
super().__init__() # 调用父类的 __init__ 方法
print("Child __init__ called")
# 创建 Child 类的实例
child = Child()
# 输出：
# Parent __init__ called
# Child __init__ called
在这个例子中，当我们创建 Child 类的实例时，Child 类的 init 方法会首先调用 Parent 类的 init 方法，然后再执行 Child 类自己的初始化代码。
vars()
vars() 是 Python 的内置函数，用于返回一个对象的 dict 属性，该属性是一个字典，包含了对象的所有属性。如果对象没有 dict 属性，则 vars() 返回一个空字典。
vars() 在类的方法内部特别有用，因为它允许你访问和修改对象的属性。当在类的实例方法中使用时，vars() 返回的是该实例的属性字典。当在类级别（而不是实例级别）使用时，vars() 返回的是类的属性字典。
下面是一些使用 vars() 的例子：
# 使用 vars() 在类实例上
class Person:
def __init__(self, name, age):
self.name = name
self.age = age
person = Person("Alice", 30)
print(vars(person)) # 输出: {'name': 'Alice', 'age': 30}
# 修改实例属性
vars(person)['age'] = 31
print(person.age) # 输出: 31
# 使用 vars() 在类上
class MyClass:
class_variable = "This is a class variable"
print(vars(MyClass)) # 输出可能包括: {'__module__': '__main__', 'class_variable': 'This is a class variable', '__doc__': None, '__dict__': <attribute '__dict__' of 'MyClass' objects>, '__weakref__': <attribute '__weakref__' of 'MyClass' objects>, '__init__': <function MyClass.__init__ at 0x...>}
# 注意，这也会显示类的内置方法和属性
# 在类的实例方法中使用 vars()
class AnotherClass:
def __init__(self):
self.x = 10
def print_vars(self):
print(vars(self))
instance = AnotherClass()
instance.print_vars() # 输出: {'x': 10}
在这个例子中，vars() 被用来获取 Person 实例的属性，并且我们还展示了如何修改这些属性。当 vars() 在类级别被调用时，它返回类的属性字典，这包括了类的变量和方法。在类的实例方法中，vars() 返回的是该实例的属性字典。
注意，vars() 通常返回的对象内部属性的字典表示，并不保证返回的属性顺序与它们被定义时的顺序相同。此外，vars() 返回的字典是对象属性字典的浅拷贝，对返回字典的修改不会影响到原始对象，除非对象本身是可变的（如普通字典）。
扫一扫
1024
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
