十一、python的高级语法与用法

一、枚举其实是一个类

现实世界中的“类型”，在计算机世界中如何描述？

常见的

1）用1、2、3..等数字表示类型

2）较好的做法是用字典表示

3）最好的是使用枚举

 # coding=utf-8
 from enum import Enum

 class VIP(Enum):  # 继承Enum类
     YELLOW = 1  # 枚举类型建议使用大小
     GREEN = 2
     BLACK = 3
     RED = 4

 print(VIP.YELLOW)

1、python中，枚举的本质是类

2、使用时需要继承Enum类

3、类中定义一组常量，建议使用全大写字母表示

4、数字1、2、3其实没有意义，枚举的意义重在标识，不在取值。

二、枚举与普通类相比的优势

如果不使用枚举，如何表示类型

1）使用模块中的全局变量

yellow=1

green=2

2) 字典

{‘yellow’:1,'green':2}

3) 普通类

class TypeDiamond():

　　yellow=1

　　green=2

缺点：

1）可变，即可以在代码中轻易改变

2）没有防止相同标签的功能

现实中的‘类型’一旦定义不应该被轻易更改，但字典可以通过赋值改变类型，同样普通类也可以轻易改变类型。

字典和普通类允许变量（类型）相同

{‘yellow’:1,'yellow:2}

在python中没有真正的常量，在枚举中定义的类型不能被更改，且不能取相同的标记。

1）枚举的保护性

2）枚举的防重性

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

1、获取某个枚举标签的值.value

2、获取某个枚举标签的名字.name

3、通过枚举标签的名称获取枚举的类型

4、枚举可遍历

 # 获取枚举标签的值
 print(VIP.YELLOW.value)
 # 获取枚举标签的名字
 print(VIP.YELLOW.name)
 # 获取枚举类型
 print(VIP.YELLOW)
 for v in VIP:
     print(v)

1                           枚举值
YELLOW              枚举名称
VIP.YELLOW　　 枚举类型

四、枚举之间的比较

枚举支持的比较

1）等值比较

res=VIP.YELLOW==VIP.GREEN
print(res)

打印结果：False

2）身份比较

res=VIP.YELLOW is VIP.YELLOW
print(res)

打印结果：True

枚举不支持的比较

1）名称和值的比较

class VIP(Enum):
    YELLOW = 1  # 枚举类型建议使用大小
    GREEN = 2
    BLACK = 3
    RED = 4

res=VIP.YELLOW ==1
print(res)

打印结果：False

2）大小比较

res=VIP.YELLOW <VIP.GREEN
print(res)

报错：TypeError: '<' not supported between instances of 'VIP' and 'VIP'

3）枚举类之间的比较

class VIP(Enum):
    YELLOW = 1  # 枚举类型建议使用大小
    GREEN = 2
    BLACK = 3
    RED = 4

class VIP1(Enum):
    YELLOW = 1  # 枚举类型建议使用大小
    GREEN = 2
    BLACK = 3
    RED = 4

res=VIP.YELLOW ==VIP1.YELLOW
print(res)

打印结果：False

五、枚举注意事项
1、不能使用相同的标签
2、取值可以相同，但会作为别名，不能作为独立的枚举类型
3、枚举的遍历，取值相等时，不打印（无法访问）别名

 # coding=utf-8
 from enum import Enum

 class VIP(Enum):
     YELLOW = 1  # 枚举类型建议使用大小
     YELLOW2 = 1
     BLACK = 3
     RED = 4

 for v in VIP:
     print(v)

4、如何遍历（访问）别名？VIP.__members__

 # coding=utf-8
 from enum import Enum

 class VIP(Enum):
     YELLOW = 1  # 枚举类型建议使用大小
     YELLOW2 = 1
     BLACK = 3
     RED = 4

 for v in VIP.__members__:
     print(v)

六、枚举的转换

1、将枚举类型转化为数字

实际编码过程中，推荐：在代码中定义枚举类型，数据库中存储枚举值，通过枚举名称访问数据库中的枚举值

if a==VIP.YELLOW:#不推荐使用a==1

　　print(...)

if a==VIP.GREEN:#不推荐使用a==2

　　print(...)

2、将数字转化为枚举类型

a=1

print(VIP(a))

 # coding=utf-8
 from enum import Enum

 class VIP(Enum):
     YELLOW = 1  # 枚举类型建议使用大小
     YELLOW2 = 1
     BLACK = 3
     RED = 4

 a=1
 print(VIP(a))

七、枚举小结

1、IntEunm类

枚举值可以是int类型，也可以是str类型，如果明确了是int类型，可以使用IntEunm类，该类限制了枚举值只能是int

 #coding=utf-8
 from enum import IntEnum

 class VIP(IntEnum):
     YELLOW = 'a' # 枚举类型建议使用大小
     YELLOW2 = 1
     BLACK = 3
     RED = 4

2、限制别名（不能取相同值）

 #coding=utf-8
 from enum import IntEnum,unique

 @unique
 class VIP(IntEnum):
     YELLOW = 1 # 枚举类型建议使用大小
     YELLOW2 = 1
     BLACK = 3
     RED = 4

3、枚举在python中是单例模式，不能实例化

这里引入了设计模式的概念，其中单例模式是23种设计模式中的一种。

八、函数式编程、闭包导论

1、python支持函数式编程，该用的时候用

2、概念不重要，重要的是思维

3、函数：其他语言中函数是指一段可执行的代码，并不是对象，但在python中，函数就是对象，可实例化

#coding=utf-8

def a():
    pass

print(type(a))

python:一切皆对象

那么

• 函数可以赋值给变量
• 函数可作为另一个函数的参数
• 函数可作为另一个函数的返回结果

九、什么是闭包

闭包=函数+环境变量

环境变量：函数定义时用到的变量（在函数外）

 # coding=utf-8

 def curve_pre():  # 闭包
     a = 25  # 环境变量

     def curve(x):  # 函数
         return a * x * x  #引用环境变量a

     return curve  # 返回函数

 f = curve_pre()
 print(f(2))

结果：100

对a重新赋值，结果如何？

 # coding=utf-8

 def curve_pre():  # 闭包
     a = 25  # 环境变量

     def curve(x):  # 函数
         return a * x * x  #引用环境变量a

     return curve  # 返回函数

 a=10
 f=curve_pre()
 print(f(2))

结果仍然是：100

如何获取环境变量的值25

 # coding=utf-8

 def curve_pre():  # 闭包
     a = 25  # 环境变量

     def curve(x):  # 函数
         return a * x * x  #引用环境变量a

     return curve  # 返回函数

 f = curve_pre()
 #获取环境变量的值
 print(f.__closure__[0].cell_contents)

十、一个事例看闭包

闭包的意义：保存环境，现场

局部变量不影响外部的环境变量

 # coding=utf-8

 def f1():
     a = 10

     def f2():
         a = 20
         print(a)

     print(a)
     f2()
     print(a)

 f1()

打印结果：

10
20
10

十一、闭包的经典误区

代码1

 #coding=utf-8

 def f1():
     a=10
     def f2():
         a=20 #a出现在表达式的作为，会被当做局部变量

 f=f1()
 print(f.__closure__)

打印结果：

Traceback (most recent call last):
  File "E:/pyClass/eleven/c11.py", line 9, in <module>
    print(f.__closure__)
AttributeError: 'NoneType' object has no attribute '__closure__'

原因：

f1()不是闭包，因为没有返回？

代码2：加入返回

 # coding=utf-8

 def f1():
     a = 10

     def f2():
         a = 20  # a出现在表达式的作为，会被当做局部变量

     return f2

 f = f1()
 print(f.__closure__)

打印结果：None

原因：函数f2没有返回？

代码3：在f2中增加返回

 # coding=utf-8

 def f1():
     a = 10

     def f2():
         a = 20  # a出现在表达式的作为，会被当做局部变量
         return a
     return f2

 f = f1()
 print(f.__closure__)

打印结果：None

原因：f2中没有引用环境变量

代码4

 # coding=utf-8

 def f1():
     a = 10

     def f2():
         # a = 20  # a出现在表达式的作为，会被当做局部变量
         return a
     return f2

 f = f1()
 print(f.__closure__)

打印结果：(<cell at 0x00000000006CA5E8: int object at 0x000000001DCEB560>,)

总结

1）环境变量不能作为局部变量被赋值

2）需要返回函数

3）函数需要引用环境变量

十二、几个问题，用闭包解决

问题：计算旅行者当前位置，假设起点x=0，每走一步，x+1

问题关键：保存上次结果

起点：x=0

每走一步：x+1

3步：result=3

5步：result=8

6步：result=14

方法一：非闭包

 #coding=utf-8

 origin=0

 def go(step):
     new_pos=origin+step
     origin=new_pos
     return origin

 print(go(2))
 print(go(3))
 print(go(5))

报错信息：

Traceback (most recent call last):
  File "E:/pyClass/eleven/c12.py", line 10, in <module>
    print(go(2))
  File "E:/pyClass/eleven/c12.py", line 6, in go
    new_pos=origin+step
UnboundLocalError: local variable 'origin' referenced before assignment

原因：第7行中，origin出现在表达式左边，会被认为是局部变量，局部变量在6行中没有定义就使用，系统认为是错误的

尝试解决：

注释掉第7行，不再报错，但是打印结果

0

0

0

与预期不符

最终解决：使用global关键字，声明origin为全局变量

 #coding=utf-8

 origin=0
 def go(step):
     global origin
     new_pos=origin+step
     origin=new_pos
     return origin

 print(go(2))
 print(go(3))
 print(go(5))

打印结果

2
5
10
方法二：使用闭包

 # coding=utf-8

 origin = 0

 def factory(pos):
     def go(step):
         nonlocal pos  # 声明pos非局部变量
         new_pos = pos + step
         pos = new_pos
         return pos

     return go

 tourist = factory(origin)
 print("旅行者当前位置：%s" % (tourist(2)))
 print("origin变量的值：%s" % (origin))
 print("环境变量的值：%s" % (tourist.__closure__[0].cell_contents))
 print("旅行者当前位置：%s" % (tourist(3)))
 print("origin变量的值：%s" % (origin))
 print("环境变量的值：%s" % (tourist.__closure__[0].cell_contents))
 print("旅行者当前位置：%s" % (tourist(5)))
 print("origin变量的值：%s" % (origin))
 print("环境变量的值：%s" % (tourist.__closure__[0].cell_contents))

打印结果：

旅行者当前位置：2
origin变量的值：0
环境变量的值：2
旅行者当前位置：5
origin变量的值：0
环境变量的值：5
旅行者当前位置：10
origin变量的值：0
环境变量的值：10
总结

1）origin并没有被改变

2）pos环境变量被记住