类的总复习

类的封装

一.用途与意义
1.数据的重用
2.数据的封装权限
二.属性
1.私有属性：私有设计密码权限
三.私有方法
1.私有设计密码权限
2.方法小结：

class  色狼:
    def __init__(self,name):  #各自独有，不加@classmethod  #类属性方法
        self.name=name
        print(self.name)
    def  setname(self,name):   #类属性方法
        self.name=name
    @classmethod  #method     #类通用方法
    def love(self):  #共有的    加@classmethod
        print("爱美女")
    @staticmethod  #静态方法，不带self.  #类静态方法
    def lovedo():
        print("爱上了美女")

def  printobjid(obj): #外部类方法
    print(id(obj))
    #hasattr检查一下是否有这个方法或者属性，
    obj.lovedo()

print(type(色狼.setname))
print(type(色狼.love)) #classmethod   方法 @staticmethod一样，函数
print(type(色狼.lovedo))
print(type(printobjid))

四.修改方法可以修改行为，劫持

import os 
#os.system("notepad")
#print("noteapad")
#print=os.system
#print("calc")

def go():
    print("comecome")
class 王栋:
    def  go(self):
        print("gogogogo")

xiaowang=王栋()
xiaowang.go()
xiaowang.go=go #修改行为，
xiaowang.go()

五.类的重载
1.对于±*/针对当前类型做出一种新的解释

本质 def __add__(self,otherhouse): #对新的类型做出一种解释
        return  housearea(self.area+otherhouse.area)
h3=h1+h2  #对已有的类型做出新的解释
#h3=h1.__add__(h2) #函数

六.类的基本属性

class  美女演员的干爹:
    '''
    hello ,我是土豪
    '''
    def  __init__(self):
        self.money=1000000000000
        self.car="兰博基尼"
        self.livein="长安街1号18号别墅"
    def  buy(self):
        print("买买买买")
    def do  (self):
        print("土豪房地产开发商")
    def 潜规则(self):
        print("潜规则干女儿")
print(美女演员的干爹.__doc__)#类的说明
print(美女演员的干爹.__name__)#类的名称
print(美女演员的干爹.__module__)#从哪里开始执行
print(美女演员的干爹.__bases__)#父类
print(美女演员的干爹.__dict__)#字典

七.self
self就是地址，自己

class 于前鹏:
    def  __init__(self):
        print(id(self),"self  id")#查看self的地址
  
xiaoyu=于前鹏()
print(id(xiaoyu),"xiaoyu id") #self抽象概念，

dayu=于前鹏()
print(id(dayu),"dayu id")

八.装饰器@property
简化私有变量的权限设计，设计两个方法解释私有变量像公有变量访问

'''

class  Bankmoney:
    def  __init__(self,name,money,addmoney):
        self.name=name
        self.__money=money   #money有上限，下限
        self.__addmoney=addmoney
    def  getaddmoney(self):
        return self.__addmoney
    def  addmoney(self):
        if not isinstance(addmoney,int): #严格的判断，防止意外
            return "数据非法"
        if addmoney<0 or addmoney>1000000000000000:
            return "数据越界"
        self.__money+=self.__addmoney

    def  go(self,a):#函数只能存在一个，重名，后来覆盖前面
        print(a)
    def  go(self,a,b):
        print(a,b)
my=Bankmoney("haipeng",100000,1000000)
#my.go(1)
my.go(2,3)
'''
class  Bankmoney:
    @property #属性，方法名字当作属性
    def addmoney(self): #返回值
        print("调用抓取")
        return self.__addmoney  #私有变量

    @addmoney.setter  #设置
    def addmoney(self,value):
         print("调用赋值")
         if not isinstance(value,int): #严格的判断，防止意外
            raise  "类型异常"
         if value<0 or value>1000000000000000:
            raise  "大小异常"
         self.__addmoney=value

#设计两个方法，实现了私有变量像公有变量一样访问
mybank=Bankmoney()
mybank.addmoney=100000 # def addmoney(self,value):
print (mybank.addmoney)#def addmoney(self):

#print(mybank.__addmoney)
 

类的继承

一.用途意义
1.继承代码重用
二.继承父类的属性方法,子类与父类重名,子类覆盖父类
三.多继承
1.继承多个父类的属性方法

美女演员(美女演员的干爹,美女演员亲爹):#方法，前者覆盖后者

 美女演员亲爹.__init__(self)  #属性，后来覆盖前者
        美女演员的干爹.__init__(self)

四.print(xw.__wife)#私有变量不可以继承
1.强行继承

print(xw._dawang__wife)

2.super,节约内存父类反复初始化

'''
class 爷:
    def __init__(self):
        print("爷构造了一次")

class 大儿子(爷):
    def __init__(self):
        爷.__init__(self)
        print("大儿子构造了一次")

class 二儿子(爷):
    def __init__(self):
        爷.__init__(self)
        print("二儿子构造了一次")

class 小儿子(爷):
    def __init__(self):
        爷.__init__(self)
        print("小儿子构造了一次")

class  媳妇(大儿子,二儿子,小儿子):
    def __init__(self):
        大儿子.__init__(self)
        二儿子.__init__(self)
        小儿子.__init__(self)


xf=媳妇()
'''

class 爷:
    def __init__(self):
        print("爷构造了一次")

class 大儿子(爷):
    def __init__(self):
        super().__init__()
        print("大儿子构造了一次")

class 二儿子(爷):
    def __init__(self):
        super().__init__()
        print("二儿子构造了一次")

class 小儿子(爷):
    def __init__(self):
        super().__init__()
        print("小儿子构造了一次")

class  媳妇(大儿子,二儿子,小儿子):
    def __init__(self):
        super().__init__() #父类初始化，多继承多个父类
xf=媳妇()

类的多态 软件可拓展性，接口不变

class sever:
    def make(self):
        print("先森你好，你需要什么东东")

class makeapple(sever):
    def make (self):
        print("生产苹果")

class makeorange(sever):
    def make(self):
        print("生产橘子")

class makeshit(sever):
    def make(self):
        print("生产shit")


def makesever(obj):#接口不变
    obj.make()

m1=sever()
makesever(m1)
m2=makeapple()
makesever(m2)
m3= makeorange()
makesever(m3)
m4= makeshit()
makesever(m4)

类型识别

isinstance无法识别出子类与父类，type识别会更加精确。

a=10
print(isinstance(a,int))#判断类型
b="123"
print(isinstance(b,str))
c=1
print(isinstance(c,(str,float))) #判断属于类型之一

class father:
    pass
class son(father):
    pass
print(isinstance(father(),father))
print(type(father())==father)
print(isinstance(son(),father))#isinstall,根据父类区别，不能识别父类与子类
print(type(son())==father)#精确识别type

类的动态操作

一.动态给一个对象增加属性，方法属性–动态绑定

class  王毅:
    pass
wangyi=王毅()
wangyi.tall=2.92  #动态增加属性,仅仅适用于当前对象
wangyi.love=lambda :print("喜欢泡妞") #属性，类方法包含self
print(wangyi.tall)
wangyi.love()

xiaowangyi=王毅()
#print(xiaowangyi.tall)
#xiaowangyi.love()

二.方法–动态绑定
types.MethodType将方法跟对象绑定

import types  #类型的模块

class  周资源:
    pass

def  彩票中奖(self):
    print("被调用")
    self.女神的备胎数量=0
    
xiaozhou= 周资源()
xiaozhou.女神的备胎数量=99
print(xiaozhou.女神的备胎数量)

xiaozhou.中奖=types.MethodType(彩票中奖,xiaozhou)#绑定方法给一个对象
xiaozhou.中奖()  #动态增加属性,仅仅适用于当前对象

print(xiaozhou.女神的备胎数量)

dazhou=周资源()
dazhou.中奖()

三.动态判断一个对象有没有属性（hasattr），设置属性（setattr），获取属性（getattr）

class  胡自强:
    def  __init__(self):
        self.lovestr="""妞的存在就是被泡，
        你不泡自有人取你而代之，
        如果反正是被泡，不如被我泡"""
    def  lovedo(self):
        print("喜欢凤姐")

xiaohu=胡自强()
print(xiaohu.lovestr)
print(hasattr(xiaohu,"lovestr"))#判断xiaohu有没有lovestr这个属性
setattr(xiaohu,"lovestr","有妞不泡，天理不容")#设置xiaohu的lovestr这个属性，
print(xiaohu.lovestr)
print(getattr(xiaohu,"lovestr"))#读取xiaohu这个对象属性
print(getattr(xiaohu,"lovegirl","凤姐"))#获取属性，存在就返回属性，不存在返回默认值
#print(setattr(xiaohu,"age",100)) #没有这个属性，就创造一个，有这个属性覆盖
#print(xiaohu.age)

四.类的动态操作
动态判断哪一个对象有没有方法，设置方法，获取方法

import types
class  胡自强:
    def  __init__(self):
        self.lovestr="""妞的存在就是被泡，
        你不泡自有人取你而代之，
        如果反正是被泡，不如被我泡"""
    def  lovedo(self):
        print("喜欢凤姐")

def lovedo(self):
    print("喜欢上了凤姐")

xiaohu=胡自强()
xiaohu.lovedo()
print(dir(xiaohu))
print(hasattr(xiaohu,"lovedo"))#方法存在
print(getattr(xiaohu,"lovedo"))#抓取到了方法
#print(setattr(xiaohu,"lovedo",lovedo)) #setattr无法绑定方法，“”self,“”
#绑定用xiaozhou.中奖=types.MethodType(彩票中奖,xiaozhou)#绑定方法给一个对象
xiaohu.lovedo=types.MethodType(lovedo,xiaohu) #动态方法

xiaohu.lovedo()

五.对象属性与类属性

#动态解释
#num=1   #新建一个变量，存储常量1的地址
#num=1
#num=2  #新建一个变量，存储常量1的地址,再存储为常量2的地址
class  梁华锋:
    def __init__(self):
        self.name="小梁"  #类属性

xiaoliang=梁华锋()
xiaoliang.name="daliang" #类属性
xiaoliang.备胎数量=10  #对象属性，

六.限制动态绑定

class 王前程:
    __slots__=("name","love")    # __slots__   元组

xiaowang=王前程()
xiaowang.name=王前程.__name__
xiaowang.love="芙蓉姐姐"
xiaowang.loveother="凤姐" #限制你不能乱绑定

print(xiaowang.love)
print(xiaowang.name)

类识别

isinstance无法识别子类与父类，精确的是type

a=10
print(isinstance(a,int))#判断类型
b="123"
print(isinstance(b,str))
c=1
print(isinstance(c,(str,float))) #判断属于类型之一

class father:
    pass
class son(father):
    pass
print(isinstance(father(),father))
print(type(father())==father)
print(isinstance(son(),father))#isinstall,根据父类区别，不能识别父类与子类
print(type(son())==father)#精确识别type