day44.5 面向对象高级

1 new方法和init方法

class Car:
    pass

class Foo():

    def __new__(cls, *args, **kwargs):
        obj=Car()
        return obj

    def __init__(self, name):
        self.name = name
        print('我是init')


f=Foo('lqz')
print(f.name)

2 getattr setattr 方法

class Foo:
    def __init__(self, name):
        self.name = name
    def __getattr__(self, item):
        print(item)
        return 99

    def __setattr__(self, key, value):
        if key == 'age':
            if isinstance(value,int):

                # 往对象中放属性,反射
                # setattr(self,key,value)  # setattr本质还是调用了self.key=value
                # self.age = value           # 这两种方式都不可以
                # 可以使用的方式
                # self.__dict__[key] = value   # 这种方式解决递归问题
                # 普通函数，有几个参数，就传几个参数
                object.__setattr__(self,key,value)
            else:
                raise Exception('不让放')
    def printsize(self):
        print(self.__size)


f = Foo('lqz')
print(f.__dict__)
 print(f.name)
 f.age = '19'  # 放的age必须是数字
 f.age = 19  # 放的age必须是数字
 print(f.age)


 object.__setattr__(f,'_Foo__size',178)

 # print(f.size)
 f.printsize()
 print(f._Foo__size)


print(f.name)
# print(f.xxx)
# print(f.xx)


 class Foo:
     def __init__(self, name):
         self.name = name
    def __getattr__(self, item):
         # print(item)
         return 99
 f=Foo('lqz')
 print(f.name)  # 属性不在对象中，才触发
 f.age=100
 print(f.age)

3. getitem setitem 方法

# 不继承字典，还支持[]赋值取值
class Foo:
    def __setitem__(self, key, value):
        setattr(self, key, value)
        # object.__setattr__(self,key,value)

    def __getitem__(self, item):
        return getattr(self, item)


f = Foo()
f.name = 'lqz'
print(f.name)
print(f['name'])
f['age'] = 19
print(f.age)
print(f['age'])

4.面向对象高级

class A:
    __slots__ = ['name', 'age']

a1 = A()
# print(a1.__dict__)  # AttributeError: 'A' object has no attribute '__dict__'
a1.name = '张三'
a1.age = 24
print(a1.age)
# a1.hobby = '泡妞'  # AttributeError: 'A' object has no attribute 'hobby'
a1.size=179
print(a1.__slots__)


__call__

class Foo():
    def __call__(self, *args, **kwargs):
        print('我被执行了')

# Foo() 会触发元类的 __call__方法
f = Foo()
f()


class A:
    """我是A类的描述信息啊手动阀手动阀"""
    pass

print(A.__doc__)




class A:
    def __enter__(self):
        print('进入with语句块时执行此方法，此方法如果有返回值会赋值给as声明的变量')
        return 'oo'

    def __exit__(self, exc_type, exc_val, exc_tb):
        print('退出with代码块时执行此方法')
        print('1', exc_type)
        print('2', exc_val)
        print('3', exc_tb)

with A() as f:
    print(f)

print('嘿嘿嘿')


len([1,2,3])
len('ssss')

class A:
    def __init__(self):
        self.x = 1
        self.y = 2
        self.z = 3

    def __len__(self):
        return len(self.__dict__)

a = A()
print(len(a))



class A:
    def __init__(self):
        self.x = 1
        self.y = 2
        self.z = 3

    def __hash__(self):
        return hash(str(self.x) + str(self.x))
a = A()
# print(hash('sdfasdfasdf'))
# print(hash([1,2,3]))
print(hash(a))


python的函数传参是值传递还是引用传递？
什么是值，什么是引用（地址）？一切皆对象，一切都是地址（python中压根就没有值类型）
可变类型和不可变类型

# 对象 == 比较时触发执行

class A:
    def __init__(self,x,y):
        self.x = x
        self.y = y

    def __eq__(self,obj):
        # 打印出比较的第二个对象的x值
        print(obj.x)
        if self.x +self.y == obj.x+obj.y:
            return True
        else:
            return False

a = A(1,2)
b = A(2,2)
print(a == b)


type 类，继承object，是所有类的类，包括自己
object类：谁都没继承，它是由type实例化得到的，是所有类的父类，包括type