三元表达式，生成式，匿名函数，内置函数

今日作业

• 多层装饰器

def outter1(func1):
    print('加载了outter1')
    def wrapper1(*args, **kwargs):
        print('执行了wrapper1')
        res1 = func1(*args, **kwargs)
        return res1
    return wrapper1

def outter2(func2):
    print('加载了outter2')
    def wrapper2(*args, **kwargs):
        print('执行了wrapper2')
        res2 = func2(*args, **kwargs)
        return res2
    return wrapper2

def outter3(func3):
    print('加载了outter3')
    def wrapper3(*args, **kwargs):
        print('执行了wrapper3')
        res3 = func3(*args, **kwargs)
        return res3
    return wrapper3


@outter1
@outter2
@outter3
def index():
    print('from index')

index()

代码流程叙述：
4.接收函数名index为实参，传给形参func2；5.接收到参数并且调用函数；6.打印出加载了outter2，然后执行同级的7；7.返回函数名wrapper2；8.接收到函数名，并以wrapper2为实参传给func1；然后调用函数outter1，打印出加载了outter1，不会执行wrapper1函数，因为并没有调用，然后走11返回出wrapper1，这个时候才会用一个index来接收这个返回值；到12加括号，其实是wrapper1()，调用这个函数，到了13，开始调用，然后往下打印出执行了wrapper1，然后到15，先看赋值符号的右边，因为func1其实是第8步传进来的wrapper2，然后16调用函数wrapper2，打印出执行了wrapper2；接下来，第18步中的func2才是正在的index，因为是第4步中，当成参数传进来的；然后加括号调用，走19，打印出from index。

• 有参装饰器

def outer(condition,type_user):
    def login_auth(func_name):  # 这里不能再填写其他形参
        def inner(*args, **kwargs):  # 这里不能再填写非被装饰对象所需的参数
            username = input('username>>>:').strip()
            password = input('password>>>:').strip()
            # 应该根据用户的需求执行不同的代码
            if type_user =='jason':print('VIP')
            if condition == '列表':
                print('使用列表作为数据来源 比对用户数据')
            elif condition == '字典':
                print('使用字典作为数据来源 比对用户数据')
            elif condition == '文件':
                print('使用文件作为数据来源 比对用户数据')
            else:
                print('去你妹的 我目前只有上面几种方式')
        return inner
    return login_auth
    
@outer('文件','jason')
def index():
    print('from index')
index()

代码执行流程概述：
先1但是不会调用，只是在全局中产生一个名称空间，再走到2，2没有@，是后面outer(参数)，优先级最高，然后把参数传进去，并且调用函数outer()；然后4不会执行，只是在outer的局部空间产生一个名字，然后走5，返回login_auth,再到6@，组合为@login_auth，这后面的顺序其实就是之前装饰器的顺序了；然后接收到真正的index为参数，传给func_name，然后调用函数login_auth()；走8，不执行，又在login_auth局部空间中一个名字，然后走9返回inner，用一个变量名index接收，然后到10调用函数inner，然后走11.记住，真正的index是6中传给了func_name，后面加括号就可以调用函数index了。

今日内容

三元表达式

• 理解

  我的理解是将if判断由几行代码，减少到一步执行。
  

注意：三元表达式仅限于二选一的情况，并且不建议嵌套。
就是如果满足就走这，不满足就走那

• 语法结构

  值1 if 条件 else 值2
  理解：如果条件成立则输出if左边的值
  如果条件不成立则输出if右边的值
  

举例说明

eg：

age = input('请输入你的年龄：')
res = '猜错啦' if age != '18' else '猜对啦'
print(res)
输出结果：
请输入你的年龄：18
猜对啦

请输入你的年龄：21
猜错啦

各种生成式

• 作用

  为了让代码块编写的时候更加快速，提高编码的效率，
  但是不是越简略的代码越牛逼。
  

数据类型	生成格式
列表	[ 元素 for循环 (if 判断语句)]
字典	{ K:V for 循环 (if 判断语句)}
集合	{ 元素 for 循环 (if 判断语句)}

元组没有生成式

列表生成式

举例说明

eg：

l1 = ['jason', 'kevin', 'tony']
res = [name + '_DS' for name in l1]
print(res)  # ['jason_DS', 'kevin_DS', 'tony_DS']

l1 = ['jason', 'kevin', 'tony']
res = [name + '_DS' for name in l1 if name == 'jason']
print(res)  # ['jason_DS']

特别提醒：列表生成式中值允许出现for和if 不能出现else 因为会产生歧义(for和if都能结合else)

字典生成式

举例说明

eg:

l1 = ['jason', 'kevin', 'tony']
for k in range(len(l1)):
    i1 = l1[k]
    res = {i: f'{i1}' for i in range(1)}
    print(res)

输出结果:
{0: 'jason'}
{0: 'kevin'}
{0: 'tony'}

集合生成式

举例说明

eg：

res = {i for i in range(3)}
print(res)  # {0, 1, 2}

匿名函数

• 理解

  匿名函数就是没有名字的函数
  

• 语法结构

  lambda 形参：返回值

• 匿名函数的调用

  直接赋值给一个变量，然后和一般函数一样调用
  

• 具体案例

print((lambda x: x + 1)(123))  # 124 直接调用

res = (lambda x: x + 1)
print(res(123))  # 124 命名调用，123 相当是实参传值给形参x

匿名以及内置函数的使用

• max()

  找最大值
  

eg：

l1 = [22, 44, 56, 786, 43, 854, 75812, 6567, 435, 76235, 567, 52356, 76354, 54, 2, 5342]
res = max(l1)
print(res)  # 76354

但是如果是字典，情况就会有所不同
eg：

dic = {
    'jason': 100,
    'aj': 123,
    'Bason': 9999999,
    'zero': 888
}

res = max(dic)
print(res)  # zero

这里我们就会发现情况是不对的，因为这里比大小是比的K值，是字符串，然后比的其实是大小写字母
A-Z 65-90
a-z 97-122

所以才会输出结果是zero，说明这个方法是不对的

正确的写法

dic = {
    'jason': 100,
    'aj': 123,
    'Bason': 9999999,
    'zero': 888
}

res = max(dic, key=lambda k: dic.get(k))
print(res)  # Bason

代码解释：
key=lambda k: dic.get(k)这个可以看作是上面匿名函数的命名调用，这里k是dic每次for循环时传出来键值对的K值传给k做参数，而dic.get(k)是每次循环后取得字典中每个K值对应得V值作为返回值,然后把每次的返回值拿来作比较，但是运行完后还会根据“记忆”，找到最大值对应的K值，然后输出出来。key就可以看作是传的函数名

匿名函数是没有return的，可以没有参数，也可以有一个或者多个

重要的内置函数

函数名	作用
min()	求最小值
map()	根据提供的函数对指定序列做映射。
filter()	函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
reduce()	函数会对参数序列中元素进行累积。
zip()	函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

• min()

举例说明

eg:

l1 = [12, 345, 563, 23, 234, 123, 445, 123, 54, 3424, 432.32]
res = min(l1)
print(res)  # 12

• map()

举例说明

eg:

l1 = [11, 22, 33, 44, 55, 66]
res = map(lambda x: x + 20, l1)  # x为参数，x+20为返回值
print(list(res))  # [31, 42, 53, 64, 75, 86]

l1 = [11, 22, 33, 44, 55, 66]

def index(x):
    return x - 20

res = map(index, l1)
print(list(res))  # [-9, 2, 13, 24, 35, 46]

• filter()
  

举例说明

eg：

l1 = ['jason', 'kevin', 'tony']
res = filter(lambda x: x != 'jason', l1)
print(list(res))  # ['kevin', 'tony'] 过滤掉'jason',组成新的列表

l1 = ['jason', 'kevin', 'tony']


def index(x):
    return x != 'jason'


res = filter(index, l1)
print(list(res))  # ['kevin', 'tony'] 过滤掉'jason',组成新的列表

注意: Python2.7 返回列表，Python3.x 返回迭代器对象

• reduce()

首先如果用for循环来做，列表求和

eg：

l1 = [324, 4543, 123, 3543, 211, 423, 985, 66]
sum = 0
for i in l1:
    sum = sum + i

print(sum)  # 10218 利用全局变量名

利用内置函数，要先引入模块

eg：

from functools import reduce

l1 = [324, 4543, 123, 3543, 211, 423, 985, 66]
res = reduce(lambda x, y : x + y, l1, 100)  # 这里100是先算完，再加上这个100
print(res)  # 10318

• zip()

举例说明

eg:

l1 = [1, 2, 3]
l2 = ['jason', 'kevin', 'tony']
res = zip(l1, l2)  # 将两个列表分组合并
print(list(res))
输出结果：
[(1, 'jason'), (2, 'kevin'), (3, 'tony')]

如果个数不对应的时候，是满足有几对就输出几对

eg：

l1 = [1, 2, 3, 4, 5]
l2 = ['jason', 'kevin', 'tony']
res = zip(l1, l2)
print(list(res))  # [(1, 'jason'), (2, 'kevin'), (3, 'tony')]