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 + "\n"
            # strvar1 = strvar1 + dic[k] + ":" + v + "\n"
            # 班长:黄乐锡 + \n + 班花:李诗韵 + \n
        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