类的复习总结

枚举类

重载的定义概念

对象构造与销毁

1.构造 init
2.销毁 del

算数运算符

1.+:
add默认加法
+=:iadd
右边加法:radd

2.- * /:&:
__ add __:加运算
__ sub __:减运算
__ mul __:乘运算
__ div __:除运算
__ mod __:求余运算
__ pow __:乘方
　　　
3.类描述运算符:
__ str __:默认是地址,修改显示类的信息
__ repr __默认是地址,修改类的信息,repr

4.逻辑运算符:
1.__ or , and , not :对象逻辑运算,|代表 or ,&代表 and __
2.__ bool __:对象转化为True,False

5.__ call __:对象名当做函数名称
__ getitem __ 索引运算 X[key], X[i:j]
__ setitem __ 索引赋值语句 X[key], X[i:j]=sequence
__ delitem __ 索引和分片删除 del X[key], del X[i:j]
__ len __长度 len(X) 如果没有 __ bool __ , 真值测试

6.处理类中的列表
__ contains __成员关系测试 item in X(任何可迭代)

7 . 关系运算符,对象的排序
1.__ it __, __gt , le , ge , eq , ne __

8.迭代
__ iter , next __:生成器

9.with as自动打开关闭:
__ enter , exit __

非重点运算符

1.__ index __:hex(X) bin(X) oct(X)
2.__new __:软件测试，软件升级，新建其他对象
3.类的属性操作
__ getattr __:点号运算 X.undefined
__ setattr __:属性赋值语句 X.any=value
__ delattr __:属性删除 del X.any
__ getattribute __:属性获取 X.any
4.类对象操作
__ get __, __set __, __delete __
5. 函数参数
*arg 元组
** arg 字典

枚举类一个例子

我们主要是导入enum这个模块，@enum.unique#定义一个枚举的类型，有点类似装饰器的感觉，不然为啥导入这个模块还得@一下。enum定义下的对象要从小到大排序。

import enum  #枚举

@enum.unique#定义一个枚举的类型
class 象棋(enum.Enum): #枚举类，12月份，星期7天，
    未过河兵=1  #可以是实数，必须是有序，从小到大
    过河底兵=2
    过河兵=3
    士=4.5
    相=5
    马=10
    炮=11
    车=20
    帅=1000

棋子1=象棋.车
print(棋子1)
print(象棋.帅)
print(象棋.帅.value)
print(象棋.帅.value>棋子1.value)
#print(象棋.帅>棋子1)#重载
print(棋子1==象棋.车)
print(棋子1!=象棋.车)
for  name ,member in 象棋.__members__.items():
    print(name,member,member.value)

type动态创造类型

通过截图可知道，色狼动态创建了show与lovename，从结果来看色狼是属于type类型，王毅是对色狼的初始化，那么就是新建的一个类叫色狼，此时我们再给王毅增加一个money，可以知道穿建了一个原来没有的属性。

def  show(self,name):
    print("我是一个色狼我的名字是"+name)
def  love(self,name,lovename):
    print("我是一个色狼我的名字是"+name+"我爱"+lovename)
#'色狼'是类的名字，（object父类）  dict字典
色狼=type('色狼',(object,),dict(showname=show,lovename=love)) #创造一个类，
王毅=色狼()#初始化
王毅.showname("王毅") #调用了show方法
王毅.lovename("王毅","春哥")
王毅.money=3000
print(王毅.money)
print(type(色狼)) #动态类型
print(type(王毅))#动态创造了类型

MetaClass

通过截图来看，我们创造了一个ListMetaClass类，我们调用Mydict()会发现打印了Mylist跟Mydict。所以我发现只要元组metaclass是相同的，就会都被调用，也能发现我们调用Mydict最后出来的格式是{‘hello’: ‘world’}字典类型。同理Mylist出来的是一个list列表。

class  ListMetaClass(type):#继承动态类型
    #name类型名称，bases继承的父亲类，attr属性字典
    def __new__(cls,name,bases,attr):
        print(cls)#当前类的名称
        print(name)#类的名字
        print(bases)#继承的父亲类
        print(attr)#属性
        #attr["add"]=lambda  self,value:self.append(value);#添加
        attr["show"]=lambda self :print(self);#显示
        return  type.__new__(cls,name,bases,attr)


#继承list, 元类 metaclass=ListMetaClass
class Mylist(list,metaclass=ListMetaClass):
    pass

#继承dict, 元类 metaclass=ListMetaClass
class Mydict(dict,metaclass=ListMetaClass):
    pass

'''
ourlist=Mylist()
ourlist.add(11)
ourlist.add(12)
ourlist.add(13)
ourlist.add(14)
ourlist.show()
'''
mydict=Mydict()
mydict["hello"]="world"
mydict.show()