枚举

枚举类：
from enum import Enum  #导入枚举类

class VIP(Enum):
    YELLOW = 1
    GREEN = 2
    BLACK = 3
    RED = 4
 
print(VIP.YELLOW)

结果：VIP.YELLOW    #关注的是它的标签而不是数字

枚举和普通类相比有什么优势

三种其他的普通方法表示枚举：
1)
yellow = 1
green = 2
2)
{'yellow':1,'green':2}    
3)
class TypeDiamond():
    yellow = 1
    green = 2

特点：他们都是可变的，可以在代码中轻易的更改值，且没有防止相同标签的功能。

枚举的特点：
from enum import Enum

class VIP(Enum):
    YELLOW = 1
    YELLOW= 2   #不可重复，否则报错
    BLACK = 3
    RED = 4

VIP.YELLOW = 6    #枚举类内的数据不可更改，否则会报错

枚举类型、枚举名称与枚举值

获取枚举变量的数值：
from enum import Enum

class VIP(Enum):
    YELLOW = 1
    GREEN = 2
    BLACK = 3
    RED = 4
   
print(VIP.YELLOW.value)  #获取变量的数值
结果：1

print(VIP.YELLOW.name)  #获取变量的名称
结果：YELLOW   #str类型

print(VIP.YELLOW)   #获取枚举变量 
print(VIP['YELLOW'])
结果：VIP.YELLOW  #<enum 'VIP'>

print(type(VIP.YELLOW))  #获取获取变量类型
结果：<enum 'VIP'>


枚举是可以遍历的：
for v in VIP :
    print(v)
结果：
VIP.YELLOW
VIP.GREEN
VIP.BLACK
VIP.RED

枚举的比较运算

• 两个枚举之间可以使用等值比较(==)，但不能进行大小比较。
• 支持身份验证（is操作）：result = VIP.BLACK is VIP.GREEN

两个枚举类的变量之间也可以进行等值比较，不过结果是False:
from enum import Enum

class VIP(Enum):
    YELLOW = 1
    GREEN = 2
    BLACK = 3
    RED = 4

class VIP1(Enum):
    YELLOW = 1
    GREEN = 2
    BLACK = 3
    RED = 4

print(VIP.GREEN ==VIP1.GREEN)
结果：False

枚举注意事项

枚举的数值可以相同，在这种情况下，将第二种枚举类型看成别名。遍历时不会打印别名：
class VIP(Enum):
    YELLOW = 1
    GREEN = 1    #别名，不会报错
    BLACK = 3
    RED = 4

#把别名加入遍历循环：
for v in VIP.__members__.items() :  #获取枚举类成员的具体信息
    print(v)
结果：
('YELLOW', <VIP.YELLOW: 1>)
('GREEN', <VIP.GREEN: 1>)
('BLACK', <VIP.BLACK: 3>)
('RED', <VIP.RED: 4>)


遍历__members__:
for v in VIP.__members__:   #获取枚举类的成员
    print(v)
结果：
YELLOW
GREEN
BLACK
RED

枚举转换

在数据库里一般存储数值或者标签名字来代表枚举类型，推荐存储数值.数字占用的空间更小。但是不建议在代码中用数值代表枚举，可读性不强。

如何将数字转换成枚举类型：
from enum import Enum

a = 1
class VIP(Enum):
    YELLOW = 1
    GREEN = 2
    BLACK = 3
    RED = 4

print(VIP(a))    #转换枚举类型

结果：VIP.YELLOW

数字枚举

要求每个枚举类型都是数字的时候继承IntEnum：
from enum import IntEnum

class VIP(IntEnum):
    YELLOW = 1
    GREEN = 2
    BLACK = 3
    RED = 4

限制不同的枚举类型不能取相同的值：
from enum import IntEnum,unique

@unique    #装饰器
class VIP(IntEnum):
    YELLOW = 1
    GREEN = 2
    BLACK = 3
    RED = 4

枚举类型不能实例化，属于单例模式

进阶内容

业务逻辑的开发者，不要考虑太多的封装性
包和类库的开发者，要考虑封装性

一切皆对象

python中的函数是对象，一切皆对象。可以把函数赋值给变量：

a = 1
a = '2'
a = def

甚至可以把函数当作另外一个函数的参数传递或者当成返回值返回。

闭包

内部函数
def curve_pre():
    def curve():
        pass

curve()    #报错，因为curve()的作用域仅限于curve_pre()的内部


闭包
def curve_pre():
    a = 25 
    def curve(x): 
        return a * x * x  #局部变量找不到会到上一级找
    return curve #返回一个函数

f = curve_pre()
print(f(2)) #调用curve()函数
结果：100

外部变量不会影响到闭包
def curve_pre():
    a = 25   #局部变量在curve的外部
    def curve(x):   #接受抛物线的x值
        return a * x * x
    return curve   #返回一个函数

a = 10     #定义a = 10
f = curve_pre()
print(f(2)) #调用curve()函数

结果：100        #仍然是a = 25的取值，取得是定义时的环境变量，这就是闭包

• 函数及其外部环境变量所构成的整体叫做闭包
• 环境变量要在函数外部，但不能是全局变量。

错误的闭包示范（使用全局变量）
a = 25    #a定义为了全局变量
def curve_pre():
    def curve(x): #接受抛物线的x值
        return a * x * x
    return curve #返回一个函数

a = 10
f = curve_pre()
print(f(2)) #调用curve()函数

结果：40    #a的值被改变了

查看闭包：
f = curve_pre()
print(f.__closure__)  #闭包函数，如果不是闭包会报错
print(f.__closure__[0].cell_contents)

结果：
(<cell at 0x0031AAF0: int object at 0x0FF93A80>,)  #闭包的存储地址
25    #获取环境变量 a

闭包理解

个人理解：闭包就是一个封闭的环境，这里我们使用函数实现，当外部调用函数。外侧函数（变量+内函数），需要返回内函数。此时才可以调用这个闭包。
闭包函数和普通函数最大的区别就是返回值不是数值。

内函数，没有使用环境变量，会出错。
def f1():
    a = 10
    def f2():
        a = 20    #a被认为是一个局部变量了，就不认为是个环境变量了
        return a
    return f2
 
f = f1()
print(f.__closure__)    #没有__closure__属性
结果：None

正确的闭包示范：
def f1():
    a = 10
    def f2():
        return a
    return f2

f = f1()
print(f.__closure__)
结果：(<cell at 0x02F5AAF0: int object at 0x0FF93990>,)

环境变量不能当作一个变量去赋值，而是一定要去引用外函数的变量（这里与我们定义类时，十分相似）。

旅行者问题

x = 0 为起点，每次计算出旅行者当前所处的位置。

使用全局变量实现：
origin = 0

def go(step):
    global origin    #将origin变成全局变量
    new_pos = origin + step
    origin = new_pos  #如果不提前声明，这一步就会被当作命名新的局部变量，而上一步提前调用了局部变量，从而报错。
    return origin

print(go(2))
print(go(3))
print(go(6))
结果：
2
5
11

使用闭包实现：
origin = 0
def factory(pos):    #工厂模式
    def go(step):
        nonlocal pos #强制声明不是局部变量
        new_pos = pos + step
        pos = new_pos
        return new_pos
    return go

tourist = factory(origin)
print(tourist(2))
print(tourist(3))
print(tourist(6))
结果：
2
5
11
此时并没有改变全局变量origin的值