python学习Day19

Day 19

今日内容概要

• 三元表达式
• 各种生成式
• 匿名函数
• 重要内置函数
• 常见内置函数

今日内容详细

1.三元表达式

'主要用来精简代码行数'
当'二选一'的时候可以采用三元表达式,但是不建议嵌套使用

在python中不是越精简越好,在精简过程中要保证代码的可读性

三元表达式语法结构：
	值1 if 条件 else 值2
如果if后面的条件成立 则执行值1
如果if后面的条件不成立 则执行值2
eg:
print('哈哈' if 0 else '嘿嘿')#嘿嘿
print('嚯嚯' if 1 else '哼哼')#嚯嚯

1.获取用户输入的用户名 如果是jason就打印欢迎 
原始方法：
username = input('name>>>:').strip()
if username == 'jason':print('欢迎')
else:print('滚蛋')
————————————————————————————————————————————
使用三元表达式：
name = input('name:').strip()
print('欢迎') if name=='jason' else print('滚蛋')

2.编写一个函数比较两个数的大小，返回较大的数
原始方法：
def max(a,b):
    if a>b:
        return a
    else:
        return b
res=max(1,10)
print(res)#10
————————————————————————————————————————————
使用三元表达式：
def max(a,b):
    return a if a>b else b#如果成立则返回a 否则返回b
res=max(1,10)#返回值要用一个变量名接收
print(res)

2.各种生成式

'生成式只能出现for或for和if'

1.列表生成式：

eg:给列表中所有数据值加上_NB后缀
原方式一：
list = ['jason', 'kevin', 'oscar']
#1.定义一个新列表用来接收列表里的数据
new_list=[]
#2.循环原列表中所有数据值
for name in list:
    #3.拼接_NB后缀
    new_name = name + '_NB'
    #4.追加到新列表中
    new_list.append(new_name)
print(new_list)
————————————————————————————————————————————
列表生成式：
list = ['jason', 'kevin', 'oscar']
new_list= [name+'_NB'for name in list]#先执行for循环然后拿到值后执行前面的加后缀,然后再放在列表中
print(new_list)#['jason_NB', 'kevin_NB', 'oscar_NB']

变形：(可加if判断)
new_list= [name+'_NB'for name in list if name!='jason']#先执行for循环然后拿到值后去if判断,当成立时则放在前面加后缀然后放入列表中,不成立的值会丢掉
print(new_list)#['kevin_NB', 'oscar_NB']

2.字典生成式：
new_dict = {i: 'jason' for i in range(10) if i == 6}
print(new_dict)#{6:'jason'}
#和列表一样先执行for然后看后面有没有if 没有则执行前面的操作

3.集合生成式：
new_set = {i for i in range(10) if i == 6}
print(new_set)#{6}

需注意：
'没有元组生成式',元组这个操作是今后的迭代器也叫生成器

3.匿名函数

1.匿名函数就是没有函数名的函数

2.语法结构：
	lambda 匿名函数的形参 : 匿名函数的返回值(写什么返什么)
    
3.调用方式：
 1)直接调用
	print((lambda x: x+1) (123))#124
 2)命名调用
	res = lambda x: x
	print(res(123))#123
    
4.应用场景：
	匿名函数通常是'配合内置函数一起使用'，用来减少代码

4.匿名集合内置函数使用

max()#求最大值
eg:取最大值
l1=[1,3,5,2,1,6,8]
res = max(l1)
print(res)#8
______________________________________________
求以下薪资最高的值:
    
用匿名函数做：
dic={'jason':100,'cat':2000,'zero':600}
res = max(dic,key=lambda k:dic.get(k))
print(res)
#max()底层就是for循环,如果不加key就会直接拿K键去比较。如果加了key就会每一次拿着for循环出来的结果交给匿名函数后面的形参k,冒号后面的就是匿名函数的返回值，找到对应的v值去做比较判断大小

不用匿名函数做：
dic={'jason':100,'cat':2000,'zero':600}
def index(k):
    return dic.get(k)
res = max(dic, key=index)
print(res)  # cat

5.重要内置函数

1.max()求最大值
2.min()求最小值#方法同max
3.map()映射#把一个东西经过处理变成另一个东西,过程就是映射
4.filter()过滤
5.reduce()将多个单体变成一个整体
6.zip()拼接多个数据值

_____________________________________________________
eg:map()将列表中的所有数据值自增10
    
l1=[1,2,3,4]
方式1：用for循环
方式2：列表生成式
方式3：map()：
res = map(lambda x:x+20,l1)
print(res)#结果是一个迭代器,需要把res转成列表
print(list(res))#[21, 22, 23, 24, 25]
#map()底层也是for循环,循环l1列表把取的值赋给匿名函数的形参,冒号后是返回值+20，再返回到列表中

不用匿名函数做：
def index(a):
    return a+20
res = map(index,l1)
print(list(res))#[21, 22, 23, 24, 25]
______________________________________________________

eg:filter()移除列表中的jason
    
l1=['jason','cat','tony']
方式1：for循环
方式2：列表生成式
方式3：filter():
res = filter(lambda a:a !='jason',l1)
print(list(res))#['cat','tony']
#filter()底层也是for循环,循环l1中的每一个数据值交给匿名函数的形参，冒号后面是返回值，把不等于jason的放在列表中

不用匿名函数做：
def index(a):
    return a != 'jason'
res = filter(index,l1)
print(list(res))#['cat','tony']
__________________________________________________

eg:reduce()求列表中的和
    
l1=[1,2,3]
方式1：for循环
方式2:sum()
   res = sum(l1)
   print(res)#6
方式3：ruduce()：
from functools import reduce#需先定义才能使用
res = reduce(lambda x,y:x+y,l1)
print(res)#6
#ruduce会先在列表中取两个值给匿名函数的形参,返回值会把x+y，然后再在列表中取一个值把刚刚的x+y与新取的值相加
'注意：'
1)
res = reduce(lambda x,y:x+y,l1,100)#最后还可以再加一个值，用来得出结果后再加100
print(res)#106
2)ruduce不单单可以处理数字，还可以处理字符串
——————————————————————————————————————————————————

eg:zip()把两个列表的值一一对应组成元组：
1)个数相同
n1=[1,2]
n2=['cat','oscat']
res = zip(n1,n2)
print(list(res))#[(1,'cat'),(2,'oscat')]

2)个数相同,字符串字母相同
n1=[1,2,3]
n2=['cat']
res = zip(n1,n2)
print(list(res))#[(1,'c'),(2,'a'),(3,'t')]

3)个数不相同#当个数不相同时只会按照最短的数据来连,后面的都不连了
n1=[1,2,3]
n2=[9,8,7,6,5]
res=zip(n1,n2)
print(list(res))#[(1,9),(2,8),(3,7)]

作业

每个人将多层装饰器及有参装饰器的执行流程用文字具体描述出来
1.整理今日内容及博客
2.复习之前知识点准备考试

def outter1(func1): # func1=wrapper2函数名
    print('加载了outter1')
    def wrapper1(*args, **kwargs):
        print('执行了wrapper1')
        res1 = func1(*args, **kwargs)
        return res1
    return wrapper1
def outter2(func2): #func2=wrapper3函数名
    print('加载了outter2')
    def wrapper2(*args, **kwargs):
        print('执行了wrapper2')
        res2 = func2(*args, **kwargs)
        return res2
    return wrapper2
def outter3(func3): #func3=真正的index函数
    print('加载了outter3')
    def wrapper3(*args, **kwargs):
        print('执行了wrapper3')
        res3 = func3(*args, **kwargs)
        return res3
    return wrapper3
@outter1 # index=outter1(wrapper2)   index现在就是wrapper1
@outter2 # wrapper2=outter2(wrapper3)
@outter3 #3. wrapper3=outter3(真正的index函数名)
# index = outer1(outer2(outer3(index)))
def index():
    print('from index')

index()

#1.如果看到多个语法糖叠加在一个函数上，先看离函数最近的语法糖。
#2.语法糖的功能会将紧挨着的下面的函数名当作参数自动传给@符号后面的函数名加括号调用。语法糖叠加在一起只有到最后一步才会用和真正装饰的函数名同名的来赋值
#3.outter3(真正的index函数名) 函数名加括号值执行优先级最高，所以先执行上面的outter3。此时定义阶段outter3后面括号里的func3=真正的index函数
#4.执行outter3下面的打印语句'加载了outter3'
#5.然后在outter3内部定义了一个wrapper3函数，函数在定义阶段不执行函数体代码 然后执行下面的返回值(返回了wrapper3)
#6.由于@outter3上还有语法糖 所以就变成了wrapper3=outter3(真正的index函数)
#7.此时由于语法糖@outter2下面的wrapper3是一个函数名，语法糖会将紧挨着的下面的函数名当作参数自动传给@符号后面的函数名加括号调用
#  所以就变成了调用outter2,把wrapper3当作参数传进去就变成了outter2(wrapper3) 函数名加括号执行优先级最高，所以先执行上面的outter2。
#  此时定义阶段outter2后面括号里的func2=wrapper2
#8.执行outter2下面的打印语句'加载了outter2'
#9.然后在outter2内部定义了一个wrapper2函数，函数在定义阶段不执行函数体代码 然后执行下面的返回值(返回了wrapper2)
#10.由于@outter2上还有语法糖 所以就变成了wrapper2=outter2(wrapper3函数名)
#11.此时由于语法糖outter1下面的wrapper2是一个函数名，语法糖会将紧挨着的下面的函数名当作参数自动传给@符号后面的函数名加括号调用
#  所以就变成了调用outter1,把wrapper2当作参数传进去就变成了outter1(wrapper2) 函数名加括号执行优先级最高，所以先执行上面的outter1。
#  此时定义阶段outter1后面括号里的func1=wrapper1
#12.执行outter1下面的打印语句'加载了outter1'
#13.然后在outter1内部顶一个一个wrapper1函数，函数在定义阶段不执行函数体代码 然后执行下面的返回值（返回了wrapper1)
#14.由于@outter1上面没有语法糖了 所以就用一个和真正装饰的函数名同名的index来接收outter1(wrapper2)的返回值。此时index就=wrapper1

#1.当调用index()时由于此时index就是wrapper1()函数名，所以先去执行wrapper1()函数下的打印'执行了wrapper1'。
#2.然后往下走遇到了res1 = func1(*args, **kwargs)，有赋值符号有函数名() 先走函数名()，由于现在的func1就是wrapper2()函数名，所以直接跳到下面的wrapper2()函数处
#3.执行wrapper2()函数下的打印'执行了wrapper2'
#4.然后往下走遇到了res2=func2(*args, **kwargs),有赋值符号有函数名() 先走函数名()，由于现在的func2就是wrapper3()函数名，所以直接跳到下面的wrapper3()函数处
#5.执行wrapper3()函数下打印'执行了wrapper3'
#6.然后往下走遇到了res3=func3(*args, **kwargs),有赋值符号有函数名() 先走函数名()，由于现在的func3就是真正的index()函数，所以直接跳到最下面的index()函数处
#7.执行index()函数下打印'from index'