三元函数与各种生成器与内置函数

三元表达式

• 三元表达式的雏形,减少代码行数

name = input('name>>:').strip()
if name == 'barry':
    print('认证成功')
else:
    print('认证失败')

name = input('name>>>:')
if name == 'barry':print('认证成功')
else:print('认证失败')

• 三元表达式

  其实就是一种偷懒的写法，将繁琐的代码精简

def func(a, b):
    if a > b:
        return a
    else:
        return b
res = func(5, 4)
print(res)

"""
三元表达式的语法结构
值1 if 条件 else 值2
如果条件成立，则使用if前面的值1
如果条件不成立，则使用else后面的值2
"""

def func(a, b):
    return a if a > b else b
res = func(5, 4)
print(res)

• 代码并不是精简的越少越好，要在保证代码的可读性来精简

"像下面的代码，运行起来并没有问题，可却变得难以看懂"

res = 1 if 3 > 2 else (4 if 0 else (5 if 6 == 7 else 8))
print(res)

各种生成器

• 如果我们要将数据容器的数据值进行修改，用我们的老办法会很麻烦

name_list = ['barry', 'tom', 'jerry']
new_list = []  # 定义一个新列表
for name in name_list:  # 将列表值循环取出
    new = name + '_NB'  # 将取出的值后面加上_NB
    new_list.append(new)  # 将改好的值追加到新列表中
print(new_list)
# run:['barry_NB', 'tom_NB', 'jerry_NB']

• 列表生成器

  如果用生成器，只需要一行代码

name_list = ['barry', 'tom', 'jerry']
new_set = [name + '_NB' for name in name_list]
# 先执行for，将数据值一个个取出来交给数据值交给for前面的代码
print(new_set)  # run:['barry_NB', 'tom_NB', 'jerry_NB']

• 字典生成器

new_dict = {i: 'barry' for i in range(5) if i == 3}
# 先执行for，将range创造的数据值一个个取出来在将数据值交给for后面的if判断，条件成立后在将数据值交给for前面的代码
print(new_dict)  # run:{3: 'barry'}

• 集合生成器

new_set = {i for i in range(6) if i == 5}
# 先执行for，将range创造的数据值一个个取出来在将数据值交给for后面的if判断，条件成立后在将数据值交给for前面的代码
print(new_set)  # run:{5}

匿名函数和内置函数

• 匿名函数

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

"""
匿名函数的语法结构
lambda 形参: 返回值
"""


res = lambda a: a+2
print(res(8))  # run:10

• max

  在无序的列表中取出最大的值

aa = [35, 3, 24, 354, 53, 24, 234, 132, 424, 45, 78, 711]
res = max(aa)  # 将列表里的最大值取出来
print(res)  # run:711

• max其实是相对于用for循环的方式将数据值依次取出，在进行对比

  而for循环用在字典时，会将k值取出进行对比，这时就要用到匿名函数

dic = {'barry': 9110, 'tom': 6666, 'jerry': 5555}
res = max(dic, key=lambda k: dic.get(k))
# 先将字典的k值取出在传给形参k，get会将k值对应的v值取出，在进行比较

重要的内置方法

• min

  用于取最小值

aa = [35, 3, 24, 354, 53, 24, 234, 132, 424, 45, 78, 711]
res = min(aa)  # 将列表里的最小值取出来
print(res)  # run:3

• map

  用于修改列表内部所有数据值

aa = [10, 20, 30, 40, 50]
res = map(lambda a: a+10, aa)
# 将列表的数据值循环取出传给形参a，在将a加上10后，将数据值返回
print(res)  # run:<map object at 0x000001B670D6F0D0>
# 要转化回列表在打印
print(list(res))  # run:[20, 30, 40, 50, 60]

• filter

  用于移除列表内指定数据值

aa = ['barry', 'tom', 'jerry']
res = filter(lambda a: a != 'tom', aa)
# 将列表的数据值循环取出传给形参a，在将是tom的数据值舍弃，将不是tom的数据值返回
print(list(res))  # run:['barry', 'jerry']

• sum

  用于求列表内部的数据值的和

reduce()
aa = [1, 2, 3, 4]
res = sum(aa)
print(res)  # run:10

• reduce

  将多个单独的数据值变为一个数据值

aa = [1, 2, 3, 4]
from functools import reduce
res = reduce(lambda x, y: x + y, aa, 10)
# reduce会将多个单独的数据值变为一个数据值
print(res)  # run:10

• zip

  将多个列表内的数据值一个对一个取出组成元组，将这些元组组成列表

aa = [1, 2, 3, 4]
bb = ['barry', 'tom', 'jerry']
res = zip(aa, bb)
将两个列表的数据值一个对一个取出组成元组，将这些元组组成列表
print(list(res))  # run:[(1, 'barry'), (2, 'tom'), (3, 'jerry')]

aa = [1, 2, 3, 4]
bb = [5, 6, 7]
cc = ['barry']
res = zip(aa, bb, cc)
# 如果列表数据值一个对一个有多余的数据值时，舍弃多余的数据值
print(list(res))  # run:[(1, 5, 'barry')]

描述多层装饰器的执行流程

首先我吗需要一个三重装饰器三重语法糖，如:
def info2(a2):
    def sre2(*args, **kwargs):
        a2(*args, **kwargs) 
        return
    return sre2  
def info1(a1): 
    def sre1(*args, **kwargs):
        a1(*args, **kwargs)
        return
    return sre1
def info(a):
    def sre(*args, **kwargs):
        a(*args, **kwargs)
        return
    return sre
@info2  # func = info2(sre1)
@info1  # sre1 = info1(sre)
@info  # sre = info(func)
def func():
    return
func()
"""
以上述程序为例:
程序会先执行最下层的语法糖@info，也就是sre = info(func)，它会执行info函数并将func函数名传给形参a，在将返回值ser返回，因为上面还有语法糖，所以返回值会被@info1接收，随后执行@info1语法糖，也就是sre1 = info1(sre)，它会执行info1函数并将返回值ser传给形参a1，在将返回值ser1返回，返回值会被上面的@info2接收，随后执行@info2语法糖，也就是func = info2(sre1)，它会执行info2函数并将返回值ser1传给形参a2，在将返回值ser2返回，因为上面已经没有语法糖了，所以返回值会被func接收，之后调用下方的func，因为func现在是ser2，所以会调用ser2函数，而a2现在是ser1，所以会在调用ser1函数，又因为a1现在是ser，所以会调用ser函数，而a现在是func，所以会执行func函数，func函数结束后，在结束ser函数，在结束ser1函数，在结束ser2函数。
就此整个多层装饰器就执行结束了
"""

首先我们需要一个闭包两层的函数,如:
def outer(b):
    def info(a):
        def sre(*args, **kwargs):
            if b == 'list':
                print('使用列表数据进行用户数据对比')
                a(*args, **kwargs)
            elif b == 'dict':
                print('使用字典数据进行用户数据对比')
                a(*args, **kwargs)
            else:
                print('没有此功能')
        return sre
    return info
@outer('list')
def func():
    print('数据对比成功')
func()
"""
以上述程序为例:
程序会先执行outer('list')，它会执行outer函数并将list传给形参b，在将返回值info返回，返回值会被outer接收，随后执行语法糖@outer，也就是func = info(func)，它将执行info函数并将func传给形参a，在将返回值ser返回，返回值ser会被func接收，之后调用下方的func，因为func现在是ser，所以会调用ser函数，然后进行判断，b是不是list，如果是则执行下方代码，因为a现在是func，所有会执行func的函数，func函数结束后，ser函数结束，然后info函数结束后，在结束outer。
如果不是func，则会执行elif之后的判断是不是dlif，如果是则执行下方代码，因为a现在是func，所有会执行func的函数，func函数结束后，ser函数结束，然后info函数结束后，在结束outer。
如果也不是dlif，则会执行else下面代码，打印'没有此功能'。
就此整个有参装饰器就执行结束了
"""