• 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+ "
    " # 班长 + ":" + 宋云杰 + '
    '
    		else:
    			strvar2 += v + ","
    			
    		# 去掉右边多余的
    和,形成最后的效果
    		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
    

      

  • 相关阅读:
    .NETCore_初探
    .NETCore_生成实体
    架构碎屑
    Helper
    26.【转载】挖洞技巧:绕过短信&邮箱轰炸限制以及后续
    25.【转载】挖洞技巧:支付漏洞之总结
    24.【转载】挖洞技巧:信息泄露之总结
    5.Windows应急响应:挖矿病毒
    4.Windows应急响应:勒索病毒
    3.Windows应急响应:蠕虫病毒
  • 原文地址:https://www.cnblogs.com/liya1014/p/13350342.html
Copyright © 2020-2023  润新知