对象中的访问属性函数

"""
基于对象使用，访问对象内成员变量的函数
hasattr    判断属性是否存在
getattr    得到属性值，没有则报错
setattr    设置属性值，有则改无则增
delattr    删除属性
"""
​
# 创造一个学生类
class Student:
    def __init__(self,name,age,sex):
        self.name = name
        self.age =age
        self.sex = sex
    def sport(self):
        print(f'{self.name}同学是一个{self.sex}生，现在准备去操场运动')
​
    def sing(self):
        print(f'{self.name}同学今年{self.age}岁了,现在准备高歌一曲')
​
stu = Student('张三', 29, '男')
print(stu.name)
# print(stu.hobby)  # 不存在这个成员变量，报错
​
# getattr函数，平常打印输出对象中的成员变量一样，不存在则报错
print(getattr(stu, 'name'))
# print(getattr(stu, 'hobby'))
​
​
# hasattr函数，判断是否存在，结果为布尔值
print(hasattr(stu, 'hobby'))  # False
print(hasattr(stu, 'name'))  # True
​
# setattr函数，设置属性值
setattr(stu,'sex','女')
setattr(stu,'hobby', '跳舞')
print(stu.sex)
print(stu.hobby)
​
# delattr函数，删除存在的成员变量
delattr(stu,'hobbby')
# print(stu.hobby)  # 删除之后就不存在了
​
# 1.使用条件判断成员变量的值是否存在
# 存在则输出
if hasattr(stu,'height'):  # 判断成员变量 身高
    print(getattr(stu, 'height'))
# 不存在则设置新成员变量
else:
    setattr(stu,'height','180')
print(stu.height)

判断对象关系的方法

"""
is         判断对象是否属于该类，不考虑继承关系
isinstance 判断对象是否是后面的类的实例化对象，考虑继承关系
issubclass 判断第一个类继承于后面类，考虑继承关系
type也可以判断，但是只能判断单个类
​
"""
​
​
class common_phone:
    pass
class smart_phone(common_phone):
    pass
# 实例化对象
nokia = common_phone()
Huawei = smart_phone()
# 判断Huawei 是否属于普通手机类
print(type(Huawei) is common_phone)  # False
​
# type可以判断，仅限单个类判断
print(type(Huawei) == smart_phone)
​
# 判断对象是否是后面的类的实例化对象，考虑继承关系
print(isinstance(Huawei,common_phone)) # True
​
# 判断前面类是否继承了后面类
print(issubclass(smart_phone,common_phone))

python底层代码讲解

class Student:
    def __init__(self,name,age,sex):
        self.name = name
        self.age =age
        self.sex = sex
    def sport(self):
        print(f'{self.name}同学是一个{self.sex}生，现在准备去操场运动')
​
    def sing(self):
        print(f'{self.name}同学今年{self.age}岁了,现在准备高歌一曲')
​
stu1 = Student('小红','18','女')
print(stu1.name)  # 查看对象中成员变量的值
print(stu1.__getattribute__('name'))  # 实际调用了内置底层的方法实现

魔术方法

"""
魔术方法：
对于学习的__init__构造方法，就是python内置的方法之一
这些内置的类方法，各自有各自特殊的功能，这些内置方法我们称为：魔术方法
    调用：不需要手动调用，特定常见自动执行
    定义：__方法名__
"""
​
class Test:
    # __new__ 魔术方法：用于创建对象时自动操作的一些功能
    # def __new__(cls, *args, **kwargs):
    #     """
    #     cls代指当前的class类
    #     self代指当前的对象
    #     当子类和父类重名时，覆盖了父类的功能
    #     使用super()以重新调用父类功能
    #     """
    #     print('对象已被创建')
    #     return super().__new__(cls)  # 重新调用父类功能
    def __init__(self,whether,temperature):
        self.whether = whether
        self.temperature = temperature
        print('对象内的参数已被创建')   # 当创建对象传参数时会自动执行
        
    # __str__ 魔术方法：修改打印实例化对象时的内容
    def __str__(self):
        return f'这是str魔术方法的内容，此实例化对象,whether={self.whether},temperature={self.temperature}'
    
    # __repr__ 魔术方法：修改直接引用对象的样子
    def __repr__(self):
        return f'这是repr魔术方法的内容，此实例化对象,whether={self.whether},temperature={self.temperature}'
​
    # __del__ 魔术方法：当删除对象中的参数时，自动调用里面的功能
    def __del__(self):
        print('对象中的参数删除成功')
​
demo1 = Test('sunday', 37)
print(demo1)  # 直接打印对象，返回的是内存地址
print(str(demo1))
delattr(demo1,'whether')

单例模式

"""
只能存在一个实例对象
如果创造了第二个实例对象，
那么第一个实例对象的内容将被覆盖，
以此类推...
​
多个实例对象的内容都将是最后创建对象的内容
"""
class Student:
    def __new__(cls,**args,**kwargs):
        is not hasattr(cls,'_instance'):
            cls._instance = super().__new__(cls)
        return cls._instance
    def __init__(self,name,age):
        self.name = name
        self.age = age
        
stu1 = Student('张三','35')
stu2 = Student('李四','37')
​
print(stu1.name) # 使用单例模式后，打印的内容都为最后对象里面定义的值
print(stu2.name)
​
print(stu1.age) # 使用单例模式后，打印的内容都为最后对象里面定义的值
print(stu2.age)