Python高级语法与用法

#枚举其实是一个类

#枚举定义及特性
#什么是枚举：是一个被命名的整型常数的集合
#枚举类型就是为了保存一组常量，比如错误代码的清单，程序是不能轻易就改变代码的值，否则会产生严重的问题
from enum import  Enum            #enum相当于class
from enum import IntEnum,unique   #枚举类型的数值必须是int

class VIP(Enum):      #VIP（枚举名）是一个枚举（一个集合） 
    YELLOW = 1         #YELLOW是具体枚举类型，由枚举标签和值组成
    GREEN = 2         # 标签防止重复
    PINK = 3          #不会被改变 
    RED = 4
 #  RED = 4          #TypeError: Attempted to reuse key: 'RED'

print(VIP.GREEN)   #是一个枚举类型，type是enum ‘VIP’  
#VIP.GREEN = 3      #Cannot reassign members.   保护功能


#枚举的应用
#枚举可以分为：枚举的类型、枚举的标签、枚举的值
print(VIP.GREEN.value)      #值
print(VIP.GREEN.name)       #标签  type是class 'str'
print(VIP['GREEN'])

for v in VIP:               #VIP是枚举
    print(v)    #VIP.GREEN是枚举类型
    
#VIP的比较
#枚举类型间不可以做大小比较，可以做等值比较（==）、身份比较（is）
    
    
#枚举的注意事项
#@unique         防止value重复
class VIP(Enum):       
    YELLOW = 1        #枚举类型的数值可以相同
    GREEN = 1      #代表同一个枚举类型，第二个是第一个的别名，不代表一个独立的枚举类型
    PINK = 3          
    RED = 4
      
for v in VIP:               
    print(v)    #VIP.YELLOW, VIP.PINK, VIP.RED, 

for v in VIP.__members__.items():  #内置变量属性
    print(v ) 


for v in VIP.__members__:  #内置变量属性
    print(v) 


#根据数值找出枚举类型
a =1 
print(VIP(a))

#函数式编程、闭包

#%%
#python一切皆对象
#闭包是一种函数编程方式
#函数可以返回另一个函数

def curve(x,y):
    z1 = x + y
    w1 = x - y
    def curve_c(z,w):
        return z * w 
    return curve_c(z1,w1)   #返回的任然是一个值
print(curve(1,2))    

def curve1(x,y):
    z1 = x + y
    w1 = x - y
    def curve_c1(z,w):
        return z * w *z1 * w1
    return curve_c1   #返回是一个函数
r = curve1(1,2) 
print(r(3,3))

def test():
    print('Testing.')

f = curve
print(f(3,2))

t = test
t()
q = test()
print()

def curving_pre():       #是闭包
    a = 25              # 环境变量，具有记忆的功能,相当于函数内的全局变量
    def curving(x):
        #a = 25           #a定义在这就不叫环境变量了
        return a*x*x    
    return curving     #返回一个函数
w = curving_pre()
print(w.__closure__)
print(w.__closure__[0].cell_contents)  #huanjingbianliang
print(w(2))

#闭包：函数+环境变量  比如a

#闭包的意义在于其环境，函数里的函数必须要用到环境变量

def  f1():          #不是闭包
    a = 20              #由于外部的a没有被f2调用，因此就不是一个环境变量
    def f2():
        a = 10        #此为一个局部变量
        print(a)   
    print(a)
    f2()
    print(a)
#旅行者从0开始出发，走了几次，分别计算其总步数

class Travel():          #类方法
    steps = 0
    def add_steps(self,x):
       self.__class__.steps += x
       print(str(self.__class__.steps))
tra1 = Travel()       
tra1.add_steps(2)
tra1.add_steps(2)
tra1.add_steps(3)

Origin = 0           #非闭包方式
def steps(x):
    global Origin       #全局变量声明
    total_steps = Origin + x
    Origin = total_steps
    return Origin

print(steps(4545))
print(steps(3))
   
initial = 0          #闭包方法 、环境变量记住了上一次的行为
def steps(pos):     #闭包方法避免过多引用全局变量，因为全局变量会受多个函数的影响
    def add_steps(steps):
        nonlocal pos       #非局部变量申明
        new_pos = pos + steps
        pos = new_pos
        return new_pos
    return add_steps

tra2 = steps(initial) 
tra2(223)
print(tra2(33))