python学习笔记（十）枚举类

使用枚举类

定义常量
①用大写变量，好处简单，缺点本质仍是变量
②更好的是为这样的枚举类型定义一个class类型，然后，每个 常量都是class 的一个唯一实例。
python提供了Enum类来实现这个功能：

from enum import Enum
Month = Enum('Mouth', ('Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Aug', 'Sep', 'Oct', 'Nov', 'dec'))

#用for in 遍历 Munth这个枚举类
#__members__The special attribute members is an ordered dictionary mapping names to members.
# It includes all names defined in the enumeration, including the aliases
#特殊属性members是将名称映射到成员的有序字典。它包括枚举中定义的所有名称，包括别名.
for name, member in Month.__members__.items():  #可以直接使用Month.Jan来引用一个常量，或者枚举它的所有成员
    print(name, '=>', member, ',', member.value)
#value属性 是自动赋给成员的int常量，默认从1开始赋值

输出：

Jan => Mouth.Jan , 1
Feb => Mouth.Feb , 2
Mar => Mouth.Mar , 3
Apr => Mouth.Apr , 4
May => Mouth.May , 5
Jun => Mouth.Jun , 6
Aug => Mouth.Aug , 7
Sep => Mouth.Sep , 8
Oct => Mouth.Oct , 9
Nov => Mouth.Nov , 10
dec => Mouth.dec , 11

如果需要更精确 地控制 枚举 类型 ，可以从Enum派生出自定义类：

from enum import Enum,unique
#@unique装饰器可以帮助我们检查保证没有重复值
@unique
class Weekday(Enum):   #继承自Enum类 
    Sun = 0  #Sun的value被设定为0
    Mon = 1
    Tue = 2
    Wed = 3
    Thu = 4
    Fri = 5
    Sat = 6

#访问这种枚举类型可以有若干种方法
day1 = Weekday.Mon
print(day1)   #输出的是枚举实例元素名
#输出 Weekday.Mon
print(Weekday.Tue) #也是只输出枚举元素名 惊了
#输出 Weekday.Tue
print(Weekday['Tue'])   #还是只输出枚举元素名
#输出 Weekday.Tue
print(Weekday.Tue.value)    #必须要加.value才输出值啊 真麻烦
#输出 2
print(day1 == Weekday.Mon)  #枚举 实例 等于 第一个枚举元素
#输出 True
print(day1 == Weekday.Tue)  #确实 枚举类等于赋值 给他的那个枚举元素
#输出 False
print(Weekday(1))       #直接用类名加 值 就能 输出枚举元素名
#输出 Weekday.Mon
print(day1 == Weekday(1)) #相等 没啥好说的了
#输出  True
# Weekday(7)
for name, member in Weekday.__members__.items():
    print(name, '=>', member)
#输出
Sun => Weekday.Sun
Mon => Weekday.Mon
Tue => Weekday.Tue
Wed => Weekday.Wed
Thu => Weekday.Thu
Fri => Weekday.Fri
Sat => Weekday.Sat

既可以用成员名称引用枚举常量，又可以直接根据value的值获得枚举常量。

使用元类

type（）
动态语言和静态语言最大的不同，就是函数和类的定义，不是编译时定义的，而是运行时动态创建的。
比方说要定义一个Hello的class，就写一个hello.py模块

Python解释器载入hello模块时，就会依次执行该模块的所有语句，执行结果就是动态创建出一个Hello的class对象。

class Hello(object):  #简单定义一个类
    def hello(self, name = 'world'):
        print('Hello, %s.' % name)

from demo1 import Hello   #我的文件名是demo1 类名是Hello
h = Hello()  #新建实例
h.hello()
h.hellooo()       #调用类方法
print(type(Hello))  #Hello是一个class，它的类型就是type，
print(type(h))        #而h是一个实例，它的类型是class Hello

在本文件中导入了 本文件的模块，所以结果是两遍

输出：
Hello, world.
<class 'type'>
<class 'demo1.Hello'>
Hello, world.
<class 'type'>
<class 'demo1.Hello'>

type（）函数既可以查看一个类型或变量的类型，我们说class的定义是运行时动态创建的，而 创建class 的方法就是使用type（）函数。
type（）函数既可以返回一个对象的类型，又可以 创建出新的类型。
例：
通过type（）函数创建出Hello 类 ，而无需通过class Hello （object）定义。

def fn(self, name = 'world'):
    print('Hello, %s' % name)

Hello = type('Hello', (object,), dict(hello =  fn))
h = Hello()
h.hello()
print(type(Hello))
print(type(h))

要创建一个class对象，type（）函数依次传入3个函数：
1.class的名称。
2.继承的父类集合，注意python支持多重继承，如果只有一个父类，别忘了tuple的单元素写法，就是元素后面加个逗号；
3.class的方法名称与函数绑定，这里我们把函数fn绑定到方法名hello上。
通过 type（）函数创建的类 和直接 写class是完全一样的，因为python解释器遇到class定义时，仅仅是扫描一下class定义的语法，然后调用type（）函数创建出class 。
正常情况下，我们都用class XXX来定义类，但type（）函数也允许我们动态创建出类来 ，也就是说 ，动态语言本身支持运行期动态创建类，这和静态语言有非常大的不同，要在静态语言运行期创建类，必须构造源代码字符串再调用编译器，或者借助一些工具生成字节码实现，本质上都是动态编译，会非常复杂。