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