Python ----- 函数

函数

# ### 函数 : 功能(包裹一部分代码 实现某一个功能 达成某一个目的)
"""
特点:可以反复调用,提高代码的复用性,提高开发效率,便于维护管理
函数基本格式
	函数的定义:
	def 函数名():
		code1
		code2
		
	函数的调用:	
	函数名()
"""

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

# 调用函数
func()

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

"""

"""
驼峰命名法:
	(1) 大驼峰命名法:每个单词的首字符大写 (类:面向对象) 
	mycar => MyCar     mydesk => MyDesk
	(2) 小驼峰命名法:除了第一个单词的首字符小写之外,剩下每个单词首字符大写
	mycar => myCar     mydesk => myDesk
	mycar => my_car    mydesk => my_desk
	symmetric_difference
"""

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

# 函数的调用处
for i in range(10):
	cfb_99()

函数的参数

# ### 函数的参数 (参数:配合函数运算的值)
"""
参数:
	(1)形参:形式参数,在函数的定义处
	(2)实参:实际参数,在函数的调用处
	
形参: 普通形参(位置) , 默认形参 , 普通收集形参 , 命名关键字形参 , 关键字收集形参
实参: 普通实参,关键字实参

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

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

print("<=====>")
# 2.默认形参
# 函数的定义处
"""hang,lie身上有默认值,是默认形参"""
def s_star(hang=10,lie=10):
	i = 0
	while i < hang:
		j = 0
		while j < lie:
			print("*",end="")
			j+=1
		print()
		
		i+=1
		
# 函数的调用处
"""
在函数调用时:
	如果给予实参,那么直接使用实际参数
	如果没有给予实参,那么使用参数默认自带的值 
"""
# s_star()
# s_star(3,8)
s_star(4)
		
print("<=====>")

# 3.普通形参 + 默认形参
# 函数的定义处
"""默认形参必须跟在普通形参的身后,顺序是一定的"""
def s_star(hang,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
		print()
		
		i+=1

# 函数的调用处
# s_star(hang=4,a=1,b=2,c=3,d=4,lie=5)
s_star(c=3,d=4,lie=5,hang=4,a=1,b=2)

print("<=====>")
# 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)
# 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) 

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


# ### 区分 默认形参 和 关键字实参
# 函数的定义处
def lol31_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 => arguments(参数)
	在args这个参数的前面加上一个*表达普通收集参数,形成一个元组
"""

# 基本使用
def func(a,b,c,*args):
	print(a,b,c)
	print(args) # (1,2,3,4,5,5,6,7,8)
	
func(1,2,3,4,5,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)



"""
(2)关键字收集参数 : 专门用来收集多余的没人要的关键字实参
	def func(**kwargs):
		code1...
	**kwargs => keyword arguments
	在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 k in dic:
			strvar1 += dic[k] + ":" + v + "\n" # 班长 + ":" + 宋云杰 + '\n'
		else:
			strvar2 += v + ","
	
	# 去掉右边多余的\n和,形成最后的效果
	print(strvar1.strip())
	print("吃瓜群众:"+ strvar2.rstrip(","))
	


func(monitor="宋云杰",class_flower="刘彩霞",class_grass="刘子涛",eatgua1="牧树人",eatgua2="晏国彰",eatgua3="刘聪")

命名关键字参数

# ### 命名关键字参数
"""
定义命名关键字参数的两种方式:
	(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)
	
func(1,2,d = 3,c=10)

# 定义方式二
def func(*args,c,**kwargs):
	print(args)
	print(c)
	print(kwargs)
	
func(1,2,3,4,5,6,a=1,b=2,d=6,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 )

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

print('------------')
print(*strvar)


# ### 当所有参数都在一起的时候,按照什么顺序定义呢?
# 参数定义的顺序:普通参数 -> 默认参数 -> 普通收集参数 -> 命名关键字参数 -> 关键字收集参数
# 收集到所有的实参: 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,{ext:None}

#(二)
# args = (1, 2, 3, 4)
# kw = {'d': 99, 'x': '#'}
# f1(*args, **kw) # a=1,b=2,c=3,args=(4,),kw={d:99,x:#}
'''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