枚举enum
# -*- coding:utf-8 -*-
from enum import Enum
"""
python的枚举是类的形式展现
大写表示常量
枚举类下的常量无法改变值,一般类下的变量可以改变其值
枚举类型不支持大小的比较,可以做等值比较,不同枚举类型不可以做等值比较
"""
class VIP(Enum):
YELLOW = 1
GREEN = 2
BLACK = 3
RED = 4
print(VIP.YELLOW)
"""
VIP.YELLOW
print(type(VIP.YELLOW))
<enum 'VIP'> : 类型
"""
print(VIP.YELLOW.value)
"""
1
print(type(VIP.YELLOW.value))
<class 'str'> : 字符串类型
"""
print(VIP.YELLOW.name)
"""
YELLOW
"""
#------------------------>遍历枚举类
for v in VIP.__members__:
print(v)
"""
YELLOW
GREEN
BLACK
RED
"""
#------------------------>对比，枚举类和常用类
class Common():
YELLOW = 1
print(Common.YELLOW)
"""
1
"""函数式编程
函数式编程(全新的思维领域，可以添加到项目中，不建议全部改为此思维):
map
reduce
filter
lambda命令式编程:
def
if else
for
函数式编程:(优势)不用调用全局变量
闭包: (闭包的概念 , 面试)
a = 1
a = '2'
a = def
int a = 1
另外一个函数的参数,传递到另外的函数里
把一个函数当做另外一个函数的返回结果
函数：只是一段可执行的代码,并不是对象，不可实例化
在python中一切皆对象，对象可以实例化
闭包
被封装函数+内部环境变量,返回函数形成闭包
def curve_pre():
a = 3
def curve(x):
return a*x*x
#返回一个函数,所以f也为函数
return curve
#a = 25 此处给a赋值无效,函数内的变量a作用域只在函数内
#函数curve与curve_pre形成闭包后做了封闭，不受外部变量的影响
f = curve_pre()
print(f(2))
"""
使用闭包要注意一些什么
"""
def f1():
a = 10
def f2():
#被认为局部变量，此时不是闭包了,内部函数需要去引用外部函数的变量才是闭包
a = 20
print(a) #20
print(a) #10
f2()
#内部函数变量为局部变量，不会影响外部变量
print(a) #10
return f2
#由于函数内部没有返回值,所以f为空值
f = f1()
print(f())
"""
None
"""
def f1():
a = 10
def f2():
#内部函数需要引用外部函数的变量才能形成闭包
return a
return f2
f = f1()
print(f.__closure__)
"""
(<cell at 0x7f6196e20cc8: int object at 0xe4a080>,) 输出值表明此实例为闭包
"""
"""
闭包案例:旅行者行程的叠加
关键字global 让函数内部变量定义为全局变量
"""
#非闭包的函数方法实现案例
origin = 0
def Distance(step):
#未定义会报错，下一句的origin变量未定义
global origin
new_pos = origin + step
origin = new_pos
return new_pos
print(Distance(2))
print(Distance(3))
print(Distance(5))
#闭包的函数方法实现案例
origin = 0
def factory(pos):
def go(step):
#关键字nonlocal强制声明pos不是一个局部变量
nonlocal pos
new_pos = pos + step
pos = new_pos
return new_pos
return go
tourist = factory(origin)
print(tourist(2))
print(tourist.__closure__[0].cell_contents)
print(tourist(3))
print(tourist.__closure__[0].cell_contents)
print(tourist(5))
print(tourist.__closure__[0].cell_contents)
"""
2
2
5
5
10
10
"""
"""
print(tourist.__closure__[0].cell_contents):从闭包中获取pos的值
输出结果表明确实是闭包起了作用
"""
函数式编程-匿名函数
"""一般函数"""
def add(x,y):
return x+y
"""
匿名函数:
lambda parameter _list: expression
lambda: 声明匿名函数的关键字
parameter _list 对应匿名函数的参数
expression 对应函数内容
:后面不能添加表达式 eg： : a=x+y 是错的
"""
f = lambda x,y: x+y
print(f(1,2))
"""
三元表达式:
条件为真时返回的结果 if 条件判断 else 条件为假时的返回结果
"""
x = 2
y = 3
r = x if x>y else y
print(r)函数式编程-map()
list_x = [1,2,3,4,5,6,7,8,9,10]
def square(x):
return x * x
"""
map类将列表的每一个元素映射到函数中
相当于执行for循环
"""
r = map(square,list_x)
print(list(r))
"""
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
"""
list_x = [1,2,3,4,5,6,7,8,9,10]
r = map(lambda x: x*x,list_x)
print(list(r))
"""
[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
"""
#------------------------->
list_x = [1,2,3,4,5,6,7,8]
list_y = [1,2,3,4,5,6,7,8]
r = map(lambda x,y : x*x+y,list_x,list_y)
print(list(r))
"""
[2, 6, 12, 20, 30, 42, 56, 72]
"""函数式编程-reduce()
"""
和map类不同的是,reduce是一个函数
reduce连续计算,连续调用lambda
reduce调用过程:
1. ((((((1+2)+3)+4)+5)+6)+7)+8
2. 第一次调用x=1 y=2
3. 第二次调用x=(1+2) y=3
4. 一次类推
reduce是做连续计算的，而非连续相加或相乘
"""
from functools import reduce
list_x = [1,2,3,4,5,6,7,8]
r = reduce(lambda x,y : x+y,list_x)
print(r)
"""
reduce用法,使用的应用场景
行走者,计算总路程
(x,y)
(0,0)坐标0,0开始
[(1,3),(2,-2),(-2,3)......]
"""
"""
reduce()第三个参数的问题
"""
list_x = ['1','2','3','4','5']
r = reduce(lambda x,y : x+y,list_x,'aaa')
print(r)
"""执行结果：aaa12345"""函数式编程-filter()
"""
filter()过滤器
如果结果为True则保留，如果为False则剔除
"""
list_a = [1,0,1,0,0,1]
r = filter(lambda x : True if x==1 else False,list_a)
print(list(r))
"""执行结果:[1, 1, 1]"""
"""
filter应用,例如判断一个句子是否以指定字母开头等等
"""