Python12Python的高级语法与用法

Q：枚举

A：

what

枚举本质是一个类 enum

why

数字代表类型不够直观
字典由于可变和没有防止相同标签的功能，所以不是最优代表类型的数据类型

how

枚举的一般使用方法

from enum import Enum       #先调用一个模块

class 类名1(Enum):       #定义一个类是枚举类型
    变量1 = 数值1       #数值不可相同
    变量2 = 数值2
    。。。          #以此类推
#表示类型，打印（print）出来的值依然是类名1.变量1
#枚举数值不可更改，不可以有相同变量名
#类型是一个类型enum '类名1'
print(类名1.变量1)
print(类名1.变量1.value)       #获取数值
print(类名1.变量1.name)       #获取标签名，是一个字符串
print(类名1['变量1'])       #获取枚举类型，是一个字符串
for a in 类名1:       #枚举可以遍历
    print(a)
#枚举的比较运算，枚举类型不可以比较大小，身份比较可以，等值比较可以
b = 类名1.变量1 == 类名1.变量2
c = 类名1.变量1 is 类名2.变量2

见举例1

from enum import IntEnum       #先调用一个模块，可以强制枚举数值为数值


@unique       #装饰器代表数值只能唯一
class 类名1(IntEnum):
    变量1 = 数值1
    变量2 = 数值2

how much

枚举内部的变量名类似常量尽量全体大写
枚举数值，尽量选择数字作为枚举数值
用枚举类型的标签，对应数据库的数值；
例：a = = 类名1.变量1做判断，而不是a == 数值做判断 类名1(数值/变量)转换成枚举类型
枚举不可以实例化
不能有两个相同的标签，可以不同标签是相同数值，相同数值相当于别名
用于别名的标签，会造成一般遍历是不可打印出来，遍历方法：

for a in 类名1.__members__.items():
for a in 类名1.__members__:

得到的结果，见举例2

举例1：枚举的一般使用方法

from enum import Enum


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


print(VIP.YELLOW)
print(VIP.YELLOW.value)
print(VIP.YELLOW.name)
print(VIP['YELLOW'])
print(type(VIP.YELLOW))
print(type(VIP.YELLOW.name))

for v in VIP:
    print(v)

输出
VIP.YELLOW
1
YELLOW
VIP.YELLOW
<enum ‘VIP’>
<class ‘str’>
VIP.YELLOW
VIP.GREEN
VIP.BLACK
VIP.RED

举例2：枚举别名的遍历

from enum import Enum


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


for a in VIP.__members__.items():
    print(a)
for a in VIP.__members__:
    print(a)

输出
(‘YELLOW’, <VIP.YELLOW: 1>)
(‘GREEN’, <VIP.GREEN: 2>)
(‘BLACK’, <VIP.BLACK: 3>)
(‘RED’, <VIP.RED: 4>)
YELLOW
GREEN
BLACK
RED

Q：闭包

A：

what

函数和它在定义时的环境变量，不受其他变量赋值影响

why

闭包保存的是一个环境，一个现场

how

'''
函数包函数时，被包函数不能在外部调用
可以定义一个变量为它赋值一个函数
可以返回一个函数
'''
def 函数1():
    环境变量1 = 。。。
    def 函数2():
        pass
    return 函数2

#外部调用类2()报错
a = 函数1()
#调用函数
a()
#a.__closure__表示闭包位置
#a.__closure__[0].cell_contents保存环境变量

见举例1/2

#闭包的使用，定义一个非局部变量
a = 。。。         #定义一个变量
def 函数1(b):
    def 函数2(c):
        nonlocal b         #定义一个非局部变量
        d = b + c
        b = d
        return d
    return 函数2
#实例化
f = 函数1(a)

见举例3

how much

闭包外部更改环境变量取值，环境变量不变
闭包内部的函数赋值更改环境变量取值，环境变量不变，局部变量
定义了局部变量的类似函数结构不是闭包，闭包必须引用外部的环境变量

举例1：函数包函数

def curve_pre():
#环境变量在外部
    a = 25
    def curve(x):
        return a*x*x
    return curve

#a = 10外部定义不影响内部取值25
f = curve_pre()
print(f(2))
print(f.__closure__)
print(f.__closure__[0].cell_contents)

输出
100
(<cell at 0x040BB650: int object at 0x6D3465E0>,)
25

举例2：定义了局部变量的类似函数结构不是闭包

def f1():
    a = 10
    def f2():
#闭包内部的函数赋值不影响a的原始赋值，一个局部变量
        a = 20
        print(a)
    print(a)
    f2()
    print(a)

f1()

输出
10
20
10

举例3：闭包的使用
非闭包：

origin = 0

def go(step):
#声明一个全局变量
    global 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(5))

输出
2
5
10