19.5.7笔记and作业

笔记
面向对象的三大特性，封装，继承，多态
封装

class A():
    __a=100
    def __init__(self,name,age):
        self.name=name
        self.__age=age
    def dayin(self):
        print(self.name,self.__age,A.__a)
zs=A('张三',19)
zs.dayin()###内部调用，可以使用
print(zs.__age)#不能调用，私有化封装

继承

class Shuiguo():
    def __init__(self,name,jiage):
        self.name=name
        self.jiage=jiage
    def dayin(self):
        print(self.name,self.jiage)
class Xigua(Shuiguo):
    def __init__(self,name,jiage,chandi,pingzhong):
        super().__init__(name,jiage)
        self.chandi=chandi
        self.pingzhong=pingzhong
    def showSelf(self):
        super().dayin()
        print(self.chandi,self.pingzhong)
xg=Xigua('西瓜',20,'新疆','甜瓜')
xg.showSelf()

多态

class Dog():
    def jiao(self):
        print('汪汪')
class Cat():
    def jiao(self):
        print('喵喵')
def jiao(x):
    x.jiao()
d=Dog()
c=Cat()
jiao(d)
jiao(c)

重载，override

class A():
    def func(self):
        print('哈哈')
class B(A):
    def func(self):##子类与父类拥有同名函数，子类函数将主函数覆盖
        super().func()
        print('嘿嘿')
zs=B()
zs.func()

魔术方法
__del__方法

class A():
    count=0
    def __init__(self,name):
        self.name=name
        A.count+=1
    def __del__(self):
        A.count-=1
        print('删除了',self.name,'还剩',self.count)
zs=A('张三')
ls=A('李四')
del zs
del ls

__call__方法

class A():
    count=0
    def __init__(self,name):
        self.name=name
        A.count+=1
    def __call__(self,x):
        print('我被调用了',x)
zs=A('张三')
zs.__call__(1)

class Feibo():

    def __init__(self):
        pass
    def __call__(self,n):
        a,b=1,1
        lb=[]
        if n==1:
            lb.append(1)
        elif n==2:
            lb.append(1)
            lb.append(1)
        else:
            x=1
            while x<=n:
                lb.append(a)
                a,b=b,a+b
                x+=1
            return lb
a=Feibo()
print(a(5))

__repr__方法

class Stu():
        def __init__(self,name,age):
            self.name=name
            self.age=age
        def __str__(self):
            return 'str我叫{},今年{}'.format(self.name,self.age)
        def __repr__(self):
            return 'repr姓名{},年龄{}'.format(self.name,self.age)
    zs=Stu('张三',19)
    x='%s'%(zs)##调用str
    y='%r'%(zs)##调用repr,当str没有的时候，默认调用repr，相当于是str的备胎
    print(x)
    print(y)

hastter(对象，‘属性’),判断对象调用的类中，是否含有这个属性，返回True或者False

   class A():
        count=0
        def __init__(self,name):
            self.name=name
    zs=A('张三')

 print(hasattr(zs,'name'))#True
 print(hasattr(zs,'count'))#True
 print(hasattr(zs,'age'))#False
zs.age=18##添加了age这个属性
print(zs.age)
print(hasattr(zs,'age'))

eg2:

class Stu():
    count=0
    def __init__(self,name):
        self.name=name
if not hasattr(Stu,'tax'):
    print('没有')
    Stu.tax=100
print(Stu.tax)

__new__和__init__的区别，__new__是造车，__init__是装饰车

> class Stu():
>     def __new__(cls, *args, **kwargs):
>         print('我在new',cls)##cls是Stu类
>     def __init__(self,name):
>         print('我在init')
>         self.name=name 
zs=Stu('张三')

单例模式

class Stu():
    def __new__(cls, *args, **kwargs):
        if not hasattr(cls,'inst'):
            cls.inst=object.__new__(cls)#cls指的是Stu这个类，object是没有父类，默认是基类
        return cls.inst
    def __init__(self,name):
        self.name=name
a=Stu('张三')##返回相同的inst，第一个name返回的是张三
b=Stu('李四')##返回相同的inst，李四将原来的张三覆盖，name相当于在inst中修改
print(a==b)###True
print(a is b)##True
print(id(a))
print(id(b))
print(a.name)##李四
print(b.name)##李四

==和is的区别,is是指id相同，==只是指内容相同

a=[1,2,23]
b=[1,2,23]
print(a==b)##True
print(id(a))
print(id(b))
print(a is b)##False

#__equal__方法

class A():
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __eq__(self, other):
        if self.name==other.name and self.age==other.age:
            print('年龄和名字相等')
            return True
        else:
            return False
a=A('张三',19)
b=A('李四',20)
c=A('张三',19)
print(a==b)
print(a==c)##True
print(a is b)##False,只是年龄和名字相等

eg:

class A():
    def __init__(self,name,age):
        self.name=name
        self.age=age
    def __eq__(self, other):
        print(self.__dict__)
        return self.__dict__==other.__dict__
a=A('张三',19)
b=A('李四',20)
c=A('张三',19)
lb=[]
if a not in lb:
    lb.append(a)
if b not in lb:
    lb.append(b)
if c not in lb:
    lb.append(c)
print(lb)

hash()函数

class Stu():
    def __init__(self,name,age):
        self.name=name
    def __eq__(self, other):
        return  self.__dict__==other.__dict__
    def __hash__(self):
        return hash(self.name)
a=Stu('张三',19)
b=Stu('李四',20)
c=Stu('张三',19)
d={a,b,c}
print(a)
print(b)
print(c)
print(d)

issubclass(子类，父类)，判断函数是不是另一函数的子类,#isinstance判断c是不是A的实例

#gatattr方法的使用(获取对象，属性)

class Teacher():
    dic={'name':'hehe','age':19}
    def __init__(self,name,age):
        self.name=name
        self.age=age
    @classmethod
    def func1(cls):
        print('呵呵')
    def func2(self):
        print('嘎嘎')
a=Teacher('张三',10)
d=getattr(Teacher,'dic')#获取dic，获取类属性的时候，（填类，‘属性’）
print(d)
e=getattr(a,'name')##获取张三,获取非类属性（a,'属性'）
print(e)
f=getattr(a,'func1')##获取呵呵
f()
g=getattr(a,'func2')##获取嘎嘎
g()

#setattr()方法

class A():
    pass
setattr(A,'count',100)
print(A.count)
a=A()
setattr(a,'count',200)
print(a.count)

delattr的用法,delatter(删除对象，‘删除对象的属性’)

class Teacher():
    Tax=100
    def __init__(self,name,age):
        self.name=name
        self.age=age
a=Teacher('张三',19)
delattr(Teacher,'Tax')#删除Teacher的Tax
delattr(a,'name')##删除a的name
print(a.age)
b=Teacher('李四',19)
print(b.name)

作业
1.魔术方法 eq 方法练习

class Myint(int):
    def __eq__(self, other):
        if self%6==0 and self%2==0:
            return True
        else:
            return False
no1=Myint(6)
no2=Myint(12)
result=no1==no2
print(result)

2. 魔术方法 hash 和 __eq__练习
   设计二维坐标类Point，比较2个坐标是否相等？

class Point(object):
    def __init__(self,x,y):
        self.x=x
        self.y=y
    def __hash__(self):
        return hash(self.x)
    def __eq__(self, other):
        return self.x==other.x and self.y==other.y
p1=Point(1,2)
p2=Point(1,2)
print(hash(p1))
print(hash(p2))
print(p1 is p2)
print(p1==p2)