类的重载与枚举类

##类的重载

class  色魔:
    def __init__(self,name):
        self.name=name
    def __str__(self): #重载了，转化为str打印的函数
        print("str call")
        return "我是一个色魔，我的名字叫%s"  % self.name

lianghuafeng=色魔("lianghuafeng") #对象的本质是一个地址
print(lianghuafeng)


mylist=[1,2,3]
print(mylist)

打印出来可以知道对象的本质是地址

类的重载repr

我们转化为str打印重载，当repr与str共用时候，地址就可以隐藏起来，一旦没有共用，那么print(repr(lianghuafeng))会打印出地址

class  色魔:
    def __init__(self,name):
        self.name=name
    def __str__(self): #重载了，转化为str打印的函数
        return "我是一个色魔，我的名字叫%s"  % self.name
    __repr__=__str__  #共用
    #def __repr__(self): #一般不用repr,repr保存地址，隐藏地址这么办
        #return "查看你妹的地址"

lianghuafeng=色魔("lianghuafeng") #对象的本质是一个地址
print(str(lianghuafeng))
print(repr(lianghuafeng))
print(lianghuafeng)

类的重载__iter__

当作类的循环，重载iter，重载next，我们在调用文件的时候，就可以利用这个异常比如长度大于多少等等来触发异常从而帅选数据。

class  王涛的女神备胎:
    def __init__(self):
        self.num=1
    def __iter__(self):
        return self
    def __next__(self):
        if  self.num>108:
            raise StopIteration  #触发异常
        self.num+=1
        return "备胎一共有"+str(self.num)+"个"

for  i  in   王涛的女神备胎(): #当作类来循环，重载iter,重载next
    print (i)

#for  line  in   file

类的重载item

一个切片的操作，对集合里的数据进行选择

#mylist=[1,2,3]
#mylist[1]
class  凤姐的备胎集合:
    def __getitem__(self,n):
        blist=["王涛","王毅","李培伦","王前程"]
        if  n>=len(blist)   or n<0:
            return None
        else:
            return blist[n]

fb=凤姐的备胎集合()
print(fb[2])
print(fb[10])
print(fb[1:3])

类的重载item切片

getitem、setitem、delitem分开看不难，连在一起就比较复杂，单个看getitem获得属性使用isinstance去判断是否为整数类型，如果是那么就选择。setitem赋值，两个参数n,data 将第n个赋值data。del第几个就删掉。len，bool同理

class  凤姐的备胎集合:
    def __init__(self):
       #self.blist=["王涛","王毅","李培伦","王前程"]
        self.blist=[]
    def __getitem__(self,n):
       #print(type(n)) #获取类型
       if  isinstance(n,int): #整数
            if  n>=len(self.blist)   or n<0:
                return None
            else:
                return self.blist[n]
       if  isinstance(n,slice):#切片
           return  self.blist[n]
    def __setitem__(self,n,data):  #重载了赋值
        if  n==2:
            return 
        self.blist[n]=data
    def __delitem__(self,n):
        if  n==1:
            return 
        del  self.blist[n]
    def __len__(self):
        return len(self.blist)
        #return 0
    def __bool__(self):
        print(self.blist)
        return  (len(self.blist)!=0)
        
fb=凤姐的备胎集合()
'''
print(fb[1:3])
fb[3]="逗逼"
del  fb[1]
print(fb[1])
print(fb[:])
print(len(fb))
#fb=None
print(bool(fb)) #fb首先是一个地址
print(bool(fb))
'''
print("王毅" in  fb)

类的重载call

想到了装饰器，将函数调用，把self.name放入call函数中

class  夏冰泡妞:
    def __init__(self,name):
        self.name=name
    def __call__(self): #重载对象当作一个函数调用
        print("夏冰泡妞想泡"+self.name)


xiabing=夏冰泡妞("芙蓉姐姐")
xiabing()

对象比大小

比大小是对其数值进行

class QQ:
    def __init__(self, QQ,password):
        self.QQ=QQ
        self.password=password

    #def __lt__(self,Value): #写好了用于排序
        #return self.QQ <Value.QQ
    def __str__(self):
        return  str(self.QQ)+" # "+self.password


qq3=QQ(200000,"c1234567")
qq2=QQ(300000,"a1234567")
qq1=QQ(1100000,"b1234567")


#print(qq1<qq2)

list=[qq1,qq2,qq3]
list.sort()
#list.sort(key=lambda x:x.QQ)
for qq in list:
    print(qq)

我们会用到以下的一些比较的函数都是缩写

#print(cmp(80,100)) #python3被放弃
import operator
a=10
b=20
print(operator.lt(a,b)) #lt  等价 <
print(operator.le(a,b)) #le  等价于<=
print(operator.ge(a,b)) # ge  等价 >=
print(operator.gt(a,b))#  gt  等价 >
print(operator.eq(a,b))# eq   等价    ==
print(operator.ne(a,b))#   ne  等价   !=

属性的重载

可以看到我们对没有的属性进行了赋值，一旦出现没有的比如tall那么就可以避免报错

class 备胎:
    def __init__(self,name,score):
        self.name=name
        self.score=score
    def __getattr__(self,attr): #屏蔽没有这个属性，抓取一个属性
        if attr=="tall":
            return 180
        else:
            print("属性不存在")



    def  __setattr__(self,attr,data): #重写方法设置一个属性
        print("call")  #记录下动态绑定的
        if  attr=="tall":
           object.__setattr__(self,attr,180) #重载不变
        else:
           object.__setattr__(self,attr,data)



    def  __delattr__(self,attr):  #重写方法删除一个属性
        if attr!="money":
            object.__delattr__()

       

wt=备胎("王涛",88)
print(wt.name)
print(wt.tall)
wt.tall=200
print(wt.tall)
wt.money=100000
print(wt.money)
del wt.money
print("money",wt.money)

btlist=[]
btlist.append(wt)
print(btlist)

参数星星星

*arg 其实输出后我们会发现是元组的形式
**args输出后会发现变成了字典的形式

'''
def  go(*arg): #可变参数，  *args==tuple
    print(arg)
    for  value  in  arg:
        print (value)


go(1)
go(1,2)
go(1,2,3)
'''



def gogo(**args):# **args=  dict  
    print(args)
    for key  in  args:
        print(key,args[key])


gogo(a=1,b=2,c=3)

统计对象数量

运行的结果发现：先是构造了两次再删除

num=0   #标记数量

class  猥琐男:
    def __init__(self):
       global num
       num+=1
       print("构造了一次",num)
    def __del__(self):
        global num
        num-=1
        print("删除了1次",num)
        
wangtao=猥琐男()
wangyi=猥琐男()
lipeilun=猥琐男()
print(wangtao)
print(wangyi)
print(lipeilun)

预览对象

正常而言，对象是地址。那么预览对象就是__str__输出地址

num=0   #标记数量

class  猥琐男:
    def __init__(self,name):
       global num
       num+=1
       print("构造了一次",num)
       self.name=name
    def __del__(self):
        global num
        num-=1
        print("删除了1次",num)
    def __str__(self):
        return "地址"+str(id(self))+"猥琐男"+self.name
        
wangtao=猥琐男("王涛")
wangyi=猥琐男("王毅")
lipeilun=猥琐男("李培伦")
print(wangtao)
print(wangyi)
print(lipeilun)