day10 函数、函数的参数、默认形参和关键字实参、收集参数、命名关键字参数、

# ### 函数：功能（包裹一部分代码 实现某一个功能 达成某一个目的）

"""
特点：可以反复调用，提高代码的复用性，提高开发效率，便于维护管理
函数基本格式：
函数的定义：
def 函数名():
code1
code2

函数的调用：
函数名()
"""

# 定义函数
def func():
print("我是一个函数")

# 调用函数
func()

函数命名

"""
函数命名
字母数字下划线，首字符不能为数字
严格区分大小写，且不能使用关键字
函数命名有意义，且不能使用中文哦
"""

"""
驼峰命名法：
（1）大驼峰命名法：每个单词的首字符大写（类：面相对象）
wycar => MyCar mydesyk => MyDesk
（2）小驼峰命名法：除了第一个单词的首字符小写之外，剩下每个单词首字符大写
mycar => myCar mydesk => myDesk
mycar => my_car mydesk => my_desk
symmetric_differerce
"""

# 函数的定义处
def cfb_99():
	for i in range(1,10):
		for j in range(1,i+1):
			print("%d+%d=%2d"&(j,i,i*j),end="")
		print()
		
# 函数的调用处
for i in range(10):
	cfb_99()

 

# ### 函数的参数

"""
参数：
（1）形参：形式参数，在函数的定义处
（2）实参：实际参数，在函数的调用处

形参：普通形参（位置），默认形参，普通收集参数，命名关键字形参，关键字收集行参
实参：普通实参，关键字实参

遵循原则：
形参和实参一一对应
"""

1.普通形参

# 函数的定义处
"""hang,lie是函数的普通形参"""
def s_star(hang,kie):
	i=0
	while i < hang:
		j=0
		while j < lie:
			print("*",end="")
		print()
		i+=1
		
# 函数的调用处
"""10,10 是函数的实际参数"""
s_star(10,10)
s_star(3,8)

 

2.默认形参

# 函数的定义处
"""hang,lie身上有默认值，是默认形参"""
def s_star(hang=10,lie=10):
	i=0
	while i i< hang:
		j=0
		while j < lie:
			print("*",end="")
		print()
		i+=1

# 函数的调用处
"""
在函数调用时：
	如果给予实参，那么直接使用实际参数
	如果没有给予实参，那么使用参数默认自带的值
"""
# s_star()
# s_star(3,8)
s_star(4)

 

3.普通形参 + 默认形参

# 函数的定义处
"""默认形参必须跟在普通形参的身后，顺序是一定的"""
def_star(hang,a,b,c,d,lie=10):
	i=0
	while i < hang:
		j=0
		while j < lie:
			print("*",end="")
			j+=1
		print()
		i+=1
		
# 函数的调用处
# s_star(3,3)
s_star(3)
# s_star()  error

　

4.关键字实参

"""关键字实参是对具体的某个参数赋值，具体的顺序可以打乱"""
# 函数的定义处
def s_star(hang,a,b,c,d,lie=10):
	i=0
	while i < hang:
		j=0
		while j < lie:
			print("*",end="")
			j+=1
		ptrint()
		i+=
		
# 函数的调用处
# s_star(hang=4,a=1,=2,c=3,d=4,lie=5)
s_star(c=3,d=4,lie=5,hang=4,a=1,b=2)

 

5.普通实参 + 关键字实参

def s_star(hang,a,b,c,d,lie=10):
	i=0
	while i < hang:
		j=0
		while j < lie:
			print("*",end="")
			j+=1
		print()
		i=1
		
# 函数的调用处
"""关键字实参必须跟在普通实参的身后，顺序是一定的"""
# s_star(5,6,99,c=7,d=8,lie=9)	ok
# s_star(c=7,d=8,lie=9,5,6,99)	error
s_star(5,1,c=2,d=3,lie=10,,,,b=5)	ok
# s_star(5,1,c=2,d=3,lie=10,,,,a=5)	error
s_star(5,1,c=2,d=3,lie=10,,,,b=5)	error

s_star(5,1,c='',d='',lie=10,,,,b=5)	error

 

# ### 区分 默认形参 和关键字实参

# 函数的定义处
def lol131_gameteam(top="王盼盼",middle="刘海柱",bottom="瑶",jungle="钟馗",support="李博伦")
	print("上单选手{}".format(top))
	print("中单选手{}".format(middle))
	print("下单选手{}".format(bottom))
	print("打野选手{}".format(jungle))
	print("辅助选手{}".format(support))
	
# 函数的调用处
lol31_gameteam()
lol31_gameteam(top="牧树人",middle="李亚 ",bottom="温子越",jungle="李博伦",support="孙京华")


"""
默认参数和关键字实参 在写法上一模一样
哟个实在函数的定义处
哟个实在函数的调用处
"""

　

# ### 收集参数

"""
收集参数：
（1）普通收集参数：专门用来收集没人要的普通实参
def func(*args):
code
*args => arguements（参数）
在args这个参数的前面加上一个*表达普通收集参数，形成一个元组
"""

 基本使用

def func(a,b,c,*args):
	print(a,b,c)
	print(args)	# (1,2,3,4,5,6,7,8)
	
func(1,2,3,4,5,6,7,8)

 

计算任意个数的累加和

def func(*args):
	total = 0
	for i in args:
		total += i
	print(total)
	
func(1,2,3,4,6,10,11,100)

 

"""
关键字收集参数：专门用来收集多余的没人要的关键字实参
def func(**kwargs):
code1...
**kwargs => keyword arguements
在kwargs参数前面加上2个**表达关键字收集参数，形成一个字典
"""

基本使用

def func(a=1,b=2,c=3,**kwargs):
	print(a,b,c)
	print(kwargs)	# {'f':1,'g':2,'j':3}
	
func(f=1,g=2,j=3,a=15,b=16,c=17)

 

任意个数字符串的拼接

"""
班长：宋云杰
班花：刘彩霞
班草：刘子涛
吃瓜群众：牧树人，汉库克，嘎嘎嘎
"""

def func(**kwargs):
	print(kwargs)
	# 定义一个字典，存放每一位同学的身份
	dic = {"monitor":"班长","class_flower":"班花","class_grass":"班草"}
	strvar1 = ""
	strvar2 = ""
	
	# 遍历字典中的键值对
	for k,v in kwargs.items():
		print(k,v) # monitor 宋云杰	 class_flower 刘彩霞	class_grass 刘子涛 ... 
		# 判断键是否在字典当中，如果在，获取对应的身份，拼装成字符串
		if i in dic:
			strvar1 += dic[k] + ":" + v+ "\n" # 班长 + ":" + 宋云杰 + '\n'
		else:
			strvar2 += v + ","
			
		# 去掉右边多余的\n和,形成最后的效果
		print(strvar1.strip())
		print("出瓜群众":+strvar2.rstrip(","))
		
func(monitor="宋云杰",clsee_flower="刘彩霞",class_grass="刘子涛",eatgua1="牧树人",eatgua2="燕国彰",eatgau3:"李博伦")
	

 

# ### 命名关键字参数

"""
定义命名关键字参数的两种方式：
（1）def func(a,b,c)c是命名关键字
（2）def func(*args,c,**kwargs)c是命名关键字参数
在函数调用时，必须使用命名关键字参数来进行赋值
"""

定义方式一

def func(a,b,*,d,c):
	print(a,b)
	print(d)
	print(c)

 

定义方式二

def func(*args,c,**kwargs):
	print(args)
	peint(c)
	print(kwargs)
	
func(1,2,3,4,5,6,a=1,b=2,c=100)

 

# ### 关于*和**的使用方法

"""
* 和 ** 在函数的定义处，用来做收集集合，打包
* 和 ** 在函数的调用处，用来做打散操作，解包
"""

def func(a,b,*,c,d):
	print(a,b)
	print(c,d)
	
lst = [1,2]
# *把列表里面的所有元素拿出来，当成参数一个一个赋值给func进行调用
func(*lst,c=3,d=4)

def func(a,b,*,c,d):
	print(a,b)
	print(c,d)
dic = {"c":3,"d":4}
# **把字典里面的元素拿出来，拼接成键=值得参数形式，赋值给func进行调用
func(1,2,**dic,)	# func(c=3,d=4)

# *和**的组合
func(*lst,**dic)
strvar = "abc"
print(*strvar)

 

当所有参数都在一起的时候，按照什么顺序定义呢？
参数定义的顺序：普通参数 -> 默认参数 -> 普通收集参数 -> 命名关键字参数 -> 关键字收集参数
收集到所有的实参：def func(*args,**kwargs)

以上两个函数 打印结果
（一）
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=(),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,{ext:None}

（二）
args = (1,2,3,4)
kw = {'d':99,'x':'#'}
f1(*args,**kw)
'''f1(1,2,3,4,d=99,x="#")'''

（三）
myargs = (1,2,3)
mykw = {'d':88,'x':'#'}
f2(*myargs,**mykw) #a=1,b=2,c=3,d=88,kw={x:#}
'''f2(1,2,3,d=88,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