类小结

Posted 2021-02-09 lmtlmt

# 反射
class A:
    def __init__(self,name):
        self.name = name
obj=A(‘李白‘)
setattr(obj,‘age‘,18)
print(obj.age)
ret = hasattr(obj,‘age‘)
print(ret)
ret = getattr(obj,‘age‘)
print(ret)
delattr(obj,‘age‘)
ret = hasattr(obj,‘age‘)
print(ret)

# 函数与方法的区别
# 函数是显式传递数据的
# 函数与对象 类无关

# 方法中的数据 则是隐式传递的
# 方法可以操作类内部的数据

class A:
    def __init__(self):
        self.a=1
        self.b=2
    #len(对象)就触发了__len__方法, print(len(对象))  打印len()方法的返回值
    def __len__(self):
        return len(self.__dict__)
    #hash(对象) 就触发了__hash__方法,print(hash(对象)),打印hash()方法的返回值
    def __hash__(self):
        pass
    # __str__方法 是打印对象时print(对象)  触发的 并且打印的是__str__方法的返回值
    def __str__(self):
        return ‘打印对象时,默认输出该方法的返回值‘
    #repr(对象) 并且打印print(repr(对象)   打印 出来的就是repr()方法的返回值
    def __repr__(self):
        return ‘输出repr返回值‘
    #构造方法 __new__的执行是由创建对象是触发的 对象=类名()
    #__call__ 是对象加括号  或者 类()()  触发的
    def __call__(self, *args, **kwargs):
        print(666)
    #a=A(),b=A()  a == b  打印print(a == b ) 时触发的 并且打印返回值
    def __eq__(self, other):
        if self.a == other.a  and self.b == other.b:
            return True
 #__del__   析构方法，当对象在内存中被释放时，自动触发执行

    #构造方法 在__innt__ 之前触发
    def __new__(cls, *args, **kwargs):
        print(‘ __new__‘)
        return object.__new__(A,*args,**kwargs)

a=A()
print(a)
repr(a)
print(repr(a))
b=A()
print(a == b)
print(a.b)

# 单列模式
class A:
    a=None
    def __new__(cls, *args, **kwargs):
        if not cls.a:
            obj = object.__new__(cls)
            cls.a=obj
        return cls.a
a=A()
b=A()
print(a,b)

#__item__系列
class A:
    def __init__(self,name):
        self.name =name
    def __getitem__(self, item):
        print(self.__dict__[item])
    def __setitem__(self, key, value):
        self.__dict__[key] = value
    def __delitem__(self, key):
        pass

isinstance(对象,类)  判断这个对象是不是这个类 或者这个类派生类的 实例化出来的对象
issubclass(对象1,对象2)  判断对象1 是不是对象2 的派生类
type() 判断对象所属的类
type(对象)

面向对象的 类空间问题已经类之间的关系
class A:
    def __init__(self):
        pass
    def func(self):
        A.age=self
    def foo(self):
        self.age =18
obj =A()
一 何处可以添加对象的属性

类的内部  通过对象调用方法obj.foo() 在方法中进行 对象点新的属性 obj.age =18
类的外部  对象点新的属性 如  obj.name = ‘李白‘
对象的属性不仅仅 在__init__中可以添加  在类外部  与内部都是可以添加的

二 何处可以添加 类的属性
类的内部   通过方法 类名点方法  A.func(666)
类的外部   类名点 属性   A.hp =88

对象 查找属性的顺序 : 先从对象空间去找 ----> 类空间去找 --->父类去找
类名查找顺序--->本类去找 ---> 父类去找

单向不可逆的  类名是找不到对象的属性的


类与类 的关系
 依赖关系  :把一个类的方法或者类名 传到另一个类的方法中
    关联关系
    组合关系  :三一样的  把一个类的对象封装到另一个类的对象属性中
    聚合关系
实现关系
继承关系


从类名的角度 去研究类
 类名操作静态属性
 第一种查看类的所有内容  类名.__dict__  只可以查看所有或者单个 但是不能 修该
__dict__只能查看不可以增删查

万能的点
del 类名点属性   只能这样删除
点可以增删查改


类名操作动态方法
需要传参


从对象的角度来研究类
    对象是类名加括号  然后生成一个对象

发生三步骤:
    1: 开辟一个内存空间,给对象  开辟一个对象空间
    2:触发__inint__方法 把对象空间传给self
    3: 在__nint__方法中给对象封装属性

类名点的__dict__  出来的字典是不可以进行除了看  其它操作
对象点的__dict__ 是可以进行其它操作的  同时也可以写到文件里边

对象查看对象的属性 可以对象点属性名  查看
对象调用类中的方法  不用传参的  而是 把对象自己传给self

from xxx import  xx
这样的会被覆盖