Python教程

[2022.7.7]python多种审生成式和多种内置函数

本文主要是介绍[2022.7.7]python多种审生成式和多种内置函数,对大家解决编程问题具有一定的参考价值,需要的程序猿们随着小编来一起学习吧!

学习内容概要

  • 三元表达式

  • 各种生成式

  • 匿名函数

  • 重要内置函数

  • 常见内置函数

    内容详细

    三元表达式

    """减少代码量的便捷写入方式"""
    习题演练:
    1.获取用户输入的用户名 如果是make就打印很好 否则打印不好
    #之前的学习 写入方式为
    while 1:
        username = input('username>>>:').strip()
        if username =='make':
            print('很好')
        else:
            print('不好')
    """
    上述是在之前学习中 使用的方式 给人一种需求简单 但是代码却很多的感觉   接下来我们可以用三元表达式的方式 写入一下
    """
    username = input('username>>>:').strip()
    res = print('很好') if username =='make'else print ('不好')
    # 同样的需求 上面需要多行代码 下面则两行代码就可以实现功能
    
    2.编写一个函数 比较两个参数的大小 返回小的那个一个值
    def func(a,b):
        if a < b:
          return a
        else:
          return b
    res = func(1,2)
    print(res)  # 1
    # 用三元表达式也可以写成
    def func(a,b):
    	return a if a < b else b
    res = func(1,2)
    prinr(res)
    
    """在三元表达式中 只能判断 if ...else... 这一种情况  仅限于二选一的情况 并且不建议用于嵌套使用
    如果判断情况较多 也不建议使用三元表达式
    """
    
    """
    三元表达式语法结构
    	值1 if 条件 else 值2
    如果if后面的条件成立 则使用if前面的值
    如果if后面的条件不成立 则使用else后面的值
    """
    

    各种生成式

    """把可变类型 用简单便捷的方式 表现出我们想要达到的效果 """
    1.1.列表生成式
        name_list = ['jason', 'kevin', 'oscar', 'jerry', 'tony']
        # 给上述列表中所有的数据值加上 666 的后缀
    方式一:
    
    xin_list = []
    for name in name_list:
        xin_name = name +'666'
        xin_list.append(xin_name)
    print(new_list)  # ['jason666', 'kevin666', 'oscar666', 'jerry666', 'tony666']
    
    
    方式二:
    """  列表生成式  """
    
    xin_list = [name + '666' for name in name_list]
    print(xin_list)  # ['jason666', 'kevin666', 'oscar666', 'jerry666', 'tony666']
    
    
    #上述方法中用到 for 循环  运算顺序是  (先执行for循环体 在执行fro循环前面的条件代码)
    
    xin_list = [name + '666' for name in name_list if name != 'tony']
    print(xin_list
          
    # 同样上述生成式还支持使用 if 判断 一样的顺序 先执行for循环 然后把例表里的数据值 交给if判断 最后执行for循环前面的条件代码
    """
    以上述模板方式 推写出 字典 集合 生成式
    """
    2.字典生成式
    new_dict = {i: 'tony' for i in range(10) if i == 9}
    print(new_dict)  # {9: 'tony'}
          
    # 先循环 i 打印 0~10(顾头不顾尾) 然后 if 判断 i == 9 时 执行 for 循环前面的代码条件
    
    3.集合生成式
    new_set = {i for i in range(10) if i == 9}
    print(new_set)
     # 先循环 i 打印 0~10(顾头不顾尾) 然后 if 判断 i == 9 时 执行 for 循环前面的代码条件
    

    匿名函数

    匿名函数就是没有函数名的函数
    
    语法结构
    	lambda 形参: 返回值
    具体表现
    	(lambda x: x + 1)(123)  直接调用
        res = lambda x: x + 1  命名调用
    	 print(res(123))
    应用场景
    	匿名函数通常都需要配合其他函数一起使用 用于减少代码
    

    匿名集合内置函数使用

    1.max()  #求最大值
    # 计算列表里数据值相加之和
    l1 = [23,312,123,434,43,5546,74,5456,345,24,54,776,767,768,435,435,23412,334,5345,456,34,57,868,79,6969,679]
    res = max(l1)
    print(res)  # 23412
    """用法非常简单 便捷"""
    # 字典是否能使用 示例:
    #     'make': 1230,
    #     'tony': 4632,
    #     'jason': 8832,
    #     'lili': 2314
    # }
    # res = max(dict)
    # print(res)  # tony 打印出是tony  但是实际最大值是jason 因为解释器是按照此顺序大小 用首字母 来比对的
    A-Z   65-90
    a-z   97-122
    # 所以针对自字典 不能直接按照列表方式比对
    # def func(k):
    #     return dict.get(k)
    # res = max(dict, key=lambda k: dict.get(k))
    # print(res)  # jason
    #可以用定义一个函数 然后返回字典的k值 用res接收 max 相当于for循环一样 把字典里的k值一个一个调出来 用后面的lambda 去做v的比对 然后比对出最大的 
    
    # def func(k):
    #     return dict.get(k)
    # res = max(dict,key= func)
    # print(res)
    # 用函数直接比对也是可以的  
    

    重要内置函数

    min()  最小值
    # 具体表现
    l1 = [11, 22, 33, 44, 55, 66]
    res = min(l1)
    print(res)  # 11
    """
    顾名思义就是最小的数据值
    """
    
    
    map()  映射
    # l1 = [11, 22, 33, 44, 55, 66]
    # 需求:将列表中所有的数据值自增20
    
    
    # 方式1:for循环
    # new_list = []
    # for i in l1:
    #     a = i+20
    #     new_list.append(a)
    # print(new_list)  # [31, 42, 53, 64, 75, 86]
    
    # 方式2:列表生成式
    new_list =[a + 20 for a in l1]
    print(new_list)  # [31, 42, 53, 64, 75, 86]
    # 方式3:map函数
    #  lambda后面的x是形参 x+20 是返回值
    # res = map(lambda x: x + 20, l1)
    
    # print(res)  # <map object at 0x018DB2F8>
    # print(list(res))  # [31, 42, 53, 64, 75, 86]  用list做整型的转换
    
    
    filter()
    具体表现:
    l1 =  ['jason', 'kevin', 'oscar', 'tony']
    需求:移除数据值里面的tony
    # 方式1:for循环
    # print(l1)
    # for name in l1:
    #     if name == 'tony':
    #         l1.remove('tony')
    # print(l1)  # ['jason', 'kevin', 'oscar']
    
    # 方式2:列表生成式
    xin_l1 = [name for name in l1 if name !='tony']
    print(xin_l1)  # ['jason', 'kevin', 'oscar']
    # 方式3:filter()
    lambda后面的a是形参  a != 'tony'是返回值
    res = filter(lambda a: a != 'tony', l1)
    print(res)  # <filter object at 0x0166F520>
    print(list(res))  # ['jason', 'kevin', 'oscar']
    
    
    reduce()
    具体表现:
    # 方式1:for循环
    l2 = [5, 10, 15, 20]
    需求:求列表中所有数据值的和
    a= 0
    for i in l2:
        a += i
    print(a)  # 50
    
    # 方式2:sum()
    res = sum(l2)
    print(res)  # 50
    
    # 方式3:reduce()
    """比较特殊 在调用时 需要加下面这句话"""
    # from functools import reduce
    具体表现:
    res = reduce(lambda x, y: x + y, l2)  # 50
    print(res)
    """将多个单体 变成一个整体 化多为整"""
    # 还可以在后面继续添加数据值(整型)
    res = reduce(lambda x, y: x + y, l2,50)
    print(res)  # 100
    
    
    
    zip()
    具体表现:
    h1 = [1,2,3]
    h2 = ['make1','make2','make3']
    res = zip(h1,h2)
    print(res)
    print(list(res))  # [(1, 'make1'), (2, 'make2'), (3, 'make3')]
    """
    把两个列表里的数据值 整合到一个列表中 并且用元组的方式一一对应排序 
    """
    表现二:
    h1 = [1,2,3,4,5,6]
    h2 = ['make1','make2','make3']
    h3 = ['lala1','lala2','laal3','lala4','lala5']
    res = zip(h1,h2,h3)
    print(res)
    print(list(res))  # [(1, 'make1', 'lala1'), (2, 'make2', 'lala2'), (3, 'make3', 'laal3')]
    """
    多个列表同时整合时 列表里的数据值 参差不同时  按照最少列表里的数据值去比对
    """
    

    两种装饰器的执行流程

    1.多层装饰器
    def outter1(func1):# func1 = wrapper2函数名
        print('加载了outter1')  # 1.第三个打印
        def wrapper1(*args, **kwargs):
            print('执行了wrapper1') # 2.第四个打印
            res1 = func1(*args, **kwargs)
            return res1
        return wrapper1
    
    def outter2(func2): # func2 = wrapper3函数名
        print('加载了outter2') # 3.第二个打印
        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
    
    # index = weapper1 所以可以写成 index = outter1(wrapper2)
    @outter1# index = outter1(wrapper2)
    @outter2 #wrapper2= outter2(wrapper3)
    @outter3 # wrapper3 = outter3(index)
    def index():
        print('from index') # 第七个打印
    index()  # 加载了outter3
    加载了outter2
    加载了outter1
    执行了wrapper1
    执行了wrapper2
    执行了wrapper3
    from index 
    
    2.有参装饰器
    
    def outer(condition,type_user):  #这里可以添加需要添加的形参 本来也可以用*args **kwargs 但是下面局部名称空间中 已经有了这个名字 解释器接收不了  可以改用*h **k 代替使用
        def login_auth(func_name):  # 这里不能再填写其他形参,因为这里填写的是被装饰对象函数名
            def inner(*args, **kwargs):  # 这里应该填写被装饰对象需要传入的参数(其他的不能填写)
                username = input('username>>>:').strip()
                password = input('password>>>:').strip()
                
                if type_user =='make':print('高级用户')
                if condition == '列表':
                    print('使用列表作为数据来源 比对用户数据')
                elif condition == '字典':
                    print('使用字典作为数据来源 比对用户数据')
                elif condition == '文件':
                    print('使用文件作为数据来源 比对用户数据')
                else:
                    print('目前只有以上方式 其他不具备')
            return inner
        return login_auth
    @outer('文件','jason')  # 函数名加() 执行优先级最高 outer() 上来就先执行了 返回了login_auth这个函数名 然后@符号加上login_auth 就回到了 语法糖 index = login_auth(index)然后正常的走流程就可以调用了
    def index():
        print('from index')
    index()
    
这篇关于[2022.7.7]python多种审生成式和多种内置函数的文章就介绍到这儿,希望我们推荐的文章对大家有所帮助,也希望大家多多支持为之网!