python-函数（5）

AL_QX

已于 2022-07-11 14:44:43 修改

阅读量131

点赞数

文章标签： python 学习

于 2022-07-07 19:34:11 首次发布

本文链接：https://blog.csdn.net/AL_QX/article/details/125659118

版权

内容概览

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

三元表达式

对于简单的二选一判断一种简写的方式

"""
三元表达式的语法结构
值1 if 判断条件 else 值2
如果判断条件成立，返回值1
如果判断条件不成立，返回值2
"""
# 判断两个数字，返回更大的数字
# 不适用三元表达式：
def max_num(a, b):
    if a > b:
        return a

    else:
        return b


print(max_num(3, 6))


# 使用三元表达式：


def max_num(a, b): return a if a > b else b  # 如果a大于b，返回a，反之返回b


print(max_num(3, 6))

"""三元表达式不建议嵌套使用，会使代码的可读性降低"""

生成式

列表生成式

列表生成器就是使用for循环将数据值一个个拿出来，放到for循环前做处理，然后依次放到一个新列表中作为返回值

l1 = [1, 2, 3, 4, 5]
res = [i + 1 for i in l1]
print(res)  # [2, 3, 4, 5, 6]
# 还可以在for循环后加一个if判断
res = [i + 1 for i in l1 if i != 4]  # if判断成立才在for循环前做处理，判断不成立就不处理这个数据值，也就不会添加到新列表中
print(res)  # [2, 3, 4, 6] 
# 列表生成式中只能有for和if

字典生成式

字典生成器和列表生成器差不多，不过处理时要返回一个键值对，最外层用大括号括起来

res = {i: None for i in range(5)}
print(res)  # {0: None, 1: None, 2: None, 3: None, 4: None}
# 同样也可以添加if判断
res = {i: None for i in range(5) if i != 2}
print(res)  # {0: None, 1: None, 3: None, 4: None}

集合生成器

使用大括号括起来，拥有集合的特性，其余和列表一样

res = {i for i in range(10) if i != 4}
print(res)  # {0, 1, 2, 3, 5, 6, 7, 8, 9}

元组没有生成器，元组生成的是迭代器

匿名函数

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

# 语法结构
lambda x: x + 1
# lambda是关键字 x是形参，x + 1是返回值
# 匿名函数可以直接加括号调用，也可以赋值给变量进行调用
"""匿名函数一般是配合其他函数结合使用，起简化代码的作用"""

常用内置函数

"""最大/小值：max/min"""
l1 = [2, 5, 44, 57, 3, 29, 94, 7, 64]
print(max(l1))  # 94
"""
max相当于将传入的数据进行for循环，把循环出的数据值两两比较，把更大的和下一个数比较，返回最大的数据值
如果传入的数据是字典，因为循环只会返回k，而需要比较可能是v，这时就可以传入max一个函数，将循环后的数据值都会经过函数处理后再比较
"""
d1 = {'a': 23, 'b': 84, 'c': 42}
res = max(d1, key=lambda k: d1.get(k))
print(res)  # b 返回值是经过函数处理前的数据值

"""映射：map"""
l1 = [1, 2, 3, 4, 5]
res = map(lambda x: x+1, l1)
print(res)  # <map object at 0x000001AF711F1520>  返回值是一个迭代器对象，可以使用list转换成列表数据类型
print(list(res))  # [2, 3, 4, 5, 6]
"""map需要接收一个函数和一个容器类型数据，将数据值循环出来放入函数进行处理，返回一个可迭代对象"""

"""过滤：filter"""
l1 = [11, 22, 33, 44, 55]
res = filter(lambda s: s!= 33, l1)
print(list(res))  # [11, 22, 44, 55]
"""循环取值，放入函数过滤，将条件不成立的过滤掉，返回值是可迭代对象"""

"""reduce"""
from functools import reduce
l1 = [11, 22, 33, 44, 55]
res = reduce(lambda x, y: x + y, l1)
print(res)  # 165
"""会先取出两个数到函数进行处理，如果后边还有数，会将处理完的结果和后边的数在进行处理"""

"""zip"""
l1 = [1, 2, 3]
l2 = [4, 5, 6]
l3 = [7, 8, 9, 0]
res = zip(l1, l2, l3)
print(list(res))  # [(1, 4, 7), (2, 5, 8), (3, 6, 9)]
"""会将传入的多个数据下标相同的放入一个元组，多个元组存放在列表中，如果数据的长度不同，会舍弃多余的数据值"""

多层装饰器与有参装饰器运行流程

多层装饰器

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

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

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


@outer1
@outer2
@outer3
def index():
    print('from index')

res = index()

执行代码，首先定义outer1，outer2，outer3和index四个函数，然后执行到装饰器语法糖，先用outer3装饰index，将index当做参数传入outer3，然后打印加载了outer3，因为上边还有装饰器语法糖，所以返回值wrapper3继续被outer2装饰，wrapper3被当做参数传入outer2，打印加载了outer2，返回值继续被当做参数传入outer1，打印加载了outer1，因为是最后一个装饰器语法糖，所以将返回值赋值给最开始的被装饰函数名；
当执行index()时，实际调用的相当于wrapper1，打印执行了wrapper1，执行到func1函数时，传入的参数名是wrapper2，执行wrapper2，打印执行了wrapper2，func2传入的是wrapper3函数名，调用func2就执行了wrapper3函数，打印执行了wrapper3，wrapper3的func3传入的是原index函数名，调用func3等同于调用了原index函数，打印from index；
然后返回值res3返回给了res2，res2返回给了res1，res1再返回给res

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()

执行代码，首先定义函数outer、index，然后看装饰器语法糖，语法糖里调用了函数，优先执行函数，传入两个实参到outer函数，函数内定义了login_auth函数，然后返回login_auth函数名，返回值给到语法糖位置，@加上函数名，开始装饰下边最近函数，执行login_auth函数，将index传入login_auth，定义函数inner，返回inner函数名，将返回值赋值给index，接下来然后执行index函数，相当于执行了inner函数，获取用户输入的用户名和密码，按照通过outer传入的参数，使用if判断执行哪一段语句