zoukankan      html  css  js  c++  java
  • day09-Python运维开发基础(函数收集参数、命名关键字参数与返回值、函数名的特殊使用及 全局/局部变量详解)

    1. 函数收集参数、命名关键字参数与返回值、函数名的特殊使用

    # ### 默认形参 和 关键字实参
    # 默认形参和 关键字实参 在写法上是一样
    
    # 函数的定义处
    """默认形参在函数的定义处"""
    def wangzhe_GameTeam(top="常远",middle="邹永林",bottom="朱京城",jungle="林明辉",support="李诗韵"):
        print("上路选手:{who}".format(who=top))
        print("中路选手:{who}".format(who=middle))
        print("下路选手:{who}".format(who=bottom))
        print("打野选手:{who}".format(who=jungle))
        print("辅助选手:{who}".format(who=support))
        
    # 函数的调用处
    # wangzhe_GameTeam()
    """关键字实参在函数的调用处"""
    wangzhe_GameTeam(support="王文",top="桂晓斌",middle="李德亮",bottom="钟志红",jungle="陈佳琪")
    默认形参与关键字实参 示例代码
    # ### 收集参数
    """
    收集参数:
        (1) 普通收集参数        
            # 语法:
            def func(*args):
                code1...
            *args 是普通收集参数 专门用来收集那些多余的,没人要的普通实参,形成元组
            args => arguments
    """
    # 基本语法
    def func(a,b,c,*args):
        print(a,b,c)
        print(args)
        
    func(1,2,3,4,5,6,7,8,9)
    
    
    # 计算任意个数的累加和
    def func(*args):
        # print(args)
        total = 0
        for i in args:
            total += i
        print(total)
        
    func(1,2,3,4,5,6,7,10)
        
    
    """
    (2) 关键字收集参数
        # 语法:
        def func(**kwargs):
            code1 ... 
            
        **kwargs 是关键字收集参数 专门用来收集那些多余的,没人要的关键字实参,形成字典
        kwargs => keyword arguments
    """
    # 基本语法
    def func(a,b,c,**kwargs):
        print(a,b,c)
        print(kwargs)
        
    func(a=1,b=2,c=3,d=4,e=5,f=6)
    
    
    # 任意字符串的拼接
    """
    班长:黄乐锡
    班花:李诗韵
    吃瓜群众:林明辉,李德亮
    """
    
    def func(**kwargs):
        # {'monitor': '黄乐锡', 'classflower': '李诗韵', 'eatgua1': '林明辉', 'eatgua2': '李德亮'}
        dic = {"monitor":"班长","classflower":"班花"}
        strvar1 = ""
        strvar2 = ""
        print(kwargs)
        for k,v in kwargs.items():
            # print(i)
            if k in dic:
                strvar1 += dic[k] + ":" + v + "
    "
                # strvar1 = strvar1 + dic[k] + ":" + v + "
    "
                # 班长:黄乐锡 + 
     + 班花:李诗韵 + 
    
            else:
                strvar2 +=  v + "   "
    
        print(strvar1)
        print("吃瓜群众:",strvar2)
        
    func(monitor="黄乐锡",classflower="李诗韵",eatgua1="林明辉",eatgua2="李德亮")
    
    # keys values items
    收集参数 示例代码
    # ### 命名关键字参数
    """
    # 命名关键字参数 的两种形式
    (1) 在参数的前面有一个*号 例:def func(a,b,*,c)
    (2) 在普通收集参数 和 关键字收集参数 之间 例: def func(*args,c,**kwargs)
    
    如果是命名关键字形参: 要求在调用时,必须使用关键字实参
    """
    # 基本定义1
    def func(a,b,*,c,d):
        print(a,b)
        print(c,d)
        
    func(1,2,c=3,d=4)
    
    # 基本定义2
    def func(*args,c,**kwargs):
        print(args)   # (1,2,3,4,6)
        print(kwargs) # {"a":1,"b":2,"d":4}
        print(c)      # c = 3
        
    func(1,2,3,4,6,a=1,b=2,c=3,d=4)
    
    # * 和 ** 的魔术用法
    # 在函数的调用处, * 和 ** 可以进行解包操作
    def func(a,b,*,c,d):
        print(a,b)
        print(c,d)
    
    # (1)在列表或者元组前面加上一个*的用法
    # lst = [1,2]
    # func(*lst,c=3,d=4) # func(1,2,c=3,d=4)
    # (2)在字典前面加上**的用法
    # dic = {"c":3,"d":4}
    # func(1,2,**dic) # func(1,2,c=3,d=4)
    # (3)终极写法
    lst = [1,2]
    dic = {"c":3,"d":4}
    func(*lst,**dic)
    
    """
    * 和 ** 的用法
    在定义处: *和** 是收集参数,*收集数据变成元组 ,**收集数据变成字典,是打包操作
    在调用处: *和** 是解包操作,*一般加在列表或者元组前,**一般加在字典前面,用来解包操作
    """
    
    """
    参数的顺序:
    普通形参 -> 默认形参 -> 普通收集参数 ->  命名关键字参数 -> 关键字收集参数
    
    用收集参数,可以收集所有种类的参数
    def func(*args,**kwargs)
    """
    def f1(a, b, c=0, *args, **kw):
        print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
    
    def f2(a, b, c=0, *, d, **kw):
        print('a =', a, 'b =', b, 'c =', c, 'd =', d, 'kw =', kw)
    
    # 以上两个函数 打印结果
    #(一)
    # f1(1, 2) # a=1,b=2,c=0,args=(),kw={}
    # f1(1, 2, c=3) # a=1,b=2,c=3,args=(),kw={}
    # f1(1, 2, 3, 'a', 'b') #a=1,b=2,c=3,args=("a","b"),kw={}
    # f1(1, 2, 3, 'a', 'b', x=99) #a=1,b=2,c=3,args=("a","b"),kw = {"x":99}
    # f2(1, 2, d=99, ext=None) #a=1,b=2,c=0,d=99,kw={"ext":None}
    
    #(二)
    # args = (1, 2, 3, 4)
    # kw = {'d': 99, 'x': '#'}
    # f1(*args, **kw) #f1(1,2,3,4,d=99,x=#) a=1,b=2,c=3,args=(4,),kw={d:99,x:"#"}
    
    #(三)
    # myargs = (1, 2, 3)
    # mykw = {'d': 88, 'x': '#'}
    # f2(*myargs, **mykw) #f2(1,2,3,d=88,x='#') a=1,b=2,c=3,d=88,kw={x:#}
    
    #(四)
    def f1(a, b, c=0, *args,d,**kw):
        print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'kw =', kw)
        print(d)
    
    f1(1,2,3, 'a', 'b',d=67, x=99,y=77)
    # a=1,b=2,c=3,args=(a,b),kw={x:99,y:77}
    # d = 67
    命名关键字参数 示例代码
    # ### 函数的返回值 return
    """
    return 自定义返回值 ,把值返回到函数的调用处
    (1) return 后面除了可以接6大标准数据类型之外,还可以跟上类对象或函数 如果不写return ,默认返回的是None
    (2) return 执行之后,意味着函数终止,后面的代码不执行
    """
    
    res = print(1234)
    print(res)
    
    # (1)return 第一个注意点
    def func():
        # return 1
        # return 5.78
        # return True
        # return 3+4j
        # return [1,2,3]
        pass
        
    res = func()
    print(res)
    
    # (2)return 第二个注意点
    def func():
        print(1)
        print(2)
        return 3
        print(4)
        print(5)
    res = func()
    print(res)
    
    # 注意点:如果遇到了return ,意味着函数终止不执行;
    def func():
        for i in range(10):
            if i == 5:
                return "我出来了"
            print(i)
    print("<====>")
    res = func()
    print(res)
    
    # (3)模拟计算器操作
    # + - * /
    def calc(sign,num1,num2):
        if sign == "+":
            res = num1 + num2
        elif sign == "-":
            res = num1 - num2
        elif sign == "*":
            res = num1 * num2
        elif sign == "/":
            if num2 == 0:
                return "除数不能为0"
            res = num1 / num2
        else:
            return "这个值我不会算,老弟"
            
        return res
            
    
    res = calc("/",2,0)
    print(res)
    函数的返回值 示例代码
    # ### 函数名的使用
    
    # 1.函数名是个特殊的变量,可以当做变量赋值
    def func():
        print("我是func")
    
    # 动态创建
    """
    func_new = 1
    print(func_new , type(func_new))
    func_new = func
    print(func_new , type(func_new))
    func_new()
    """
    # 动态销毁函数
    # del  func_new
    # func_new()
    
    # 2.函数名可以作为容器类型数据的元素
    def func1():
        print("我是func1 ... ")
    
    def func2():
        print("我是func2 ... ")
    
    def func3():
        print("我是func3 ... ")
        
    lst = [func1,func2,func3]
    for i in lst:
        i()
        
    # 3.函数名可以作为函数的参数
    # 函数的定义处
    def func4(func):
        func()
    
    def func5():
        print("我是func5 函数 ... ")
    
    # 函数的调用处
    func4(func5)
    
    # 4.函数名可作为函数的返回值
    def func6(func):
        return func
        
    def func7():
        print("我是func7 函数 ...")
    
    # 函数的调用处
    func_new = func6(func7) # func_new = func
    func_new()
    
    
    # __doc__ 或者help查看文档
    def chao_egg(something):
        """
        功能:炒鸡蛋的过程
        参数:something 炒菜的名称
        返回值:    返回做完的状态
        """
        print("我要做的是:{}".format(something))
        print("第一步.开火洗锅倒油,")
        print("第二步.打鸡蛋,搅拌,扔锅里")
        print("第三步.放调料,放盐,放糖,放西红柿")
        return "ok"
    chao_egg("西红柿炒鸡蛋")
    # 方法一
    help(chao_egg)
    # 方法二
    res = chao_egg.__doc__
    print(res)
    函数名的使用 示例代码

    2. 全局变量与局部变量

     

    # ### 全局变量 和 局部变量
    """
    局部变量:在函数内部的变量就是局部变量
    全局变量:在函数外部,或者在函数内部使用global关键字声明的变量就是全局变量
    
    作用域: 作用的范围
    
    如果是局部变量,作用域只限定在函数的内部;
    如果是全局变量,作用域横跨整个文件
    
    生命周期: 变量作用的时间
        内建命名空间 > 全局命名空间 > 局部命名空间
        内置函数(关键字) > 全局变量 > 局部变量
    """
    
    # (1)局部变量
    def func():
        a = 10
        # 获取局部变量
        print(a)
        # 修改局部变量
        a = 8
        print(a)
    
    func()
    
    # (2)全局变量
    b = 90
    # 获取全局变量
    print(b)
    # 修改全局变量
    b = 91
    print(b)
    
    # (3) 可以在函数内部利用global进行全局变量的修改
    def func2():
        # 一般把global写在函数内部的第一行
        global b
        b += 10
        print(b)
    
    func2()
    print(b)
    
    
    # (4) 可以利用global在函数内部定义一个全局变量
    def func3():
        global d
        d = 110
    func3()
    print(d)
    
    """
    global :
        1.如果函数外存在当前这个变量,利用global可以在函数内部对全局变量进行修改
        2.如果函数外不存在当前这个变量,利用global可以在函数内部定义一个全局变量;
    """
    全局变量与局部变量 示例代码

    day09

  • 相关阅读:
    Jenkins 完成安装环境配置
    Jenkins中文社区的所有镜像地址
    VueX源码分析(3)
    VueX源码分析(2)
    VueX源码分析(1)
    Element表单验证(2)
    Element表单验证(1)
    配置淘宝镜像,不使用怪异的cnpm
    React动态import()
    cnpm 莫名奇妙bug 莫名奇妙的痛
  • 原文地址:https://www.cnblogs.com/reachos/p/12144941.html
Copyright © 2011-2022 走看看