functions-函数

╰半橙微兮° 2021-09-29 03:12 264阅读 0赞

python  functions
    
    	函数分类：
    		内建函数   max() reversed()
    		库函数     math.ceil()
    
    	定义：
    		def 函数名 (参数列表):
    			
    			函数体(代码块)
    			
    			[return 返回值]
    
    		1) 函数名就是标识符，命名要求一样
    		2) 语句块必须缩进，约定4个空格
    		3) 若没有return语句，隐式会返回一个None
    		4) 定义中的参数列表，形参
    
    	调用:
    		调用时写的参数是实际参数，实实在在传入的值，实参
    
    	callable() 是否可调用 True/False
    
    	函数参数：
    
    		位置参数：
    			def f(x,y,z) 调用使用f(1,3,5)
    			按照顺序传入实参
    		关键字参数：
    			def f(x,y,z) 调用使用f(x=1,y=3,z=5)
    			使用形参的名字，传入实参的方式，顺序可以改变
    
    		f(y=5,z=6,2) #位置参数必须在关键字参数之前传入。
    
    	参数默认值：
    		def add(x = 4, y = 5):
    			return x+y
    	调用：
    -----------------------------------------------------------------
    add(6,10): 6+10 = 16
    
    add(6, y=7): 6+7 = 13
    
    add(x=5): 5+5 = 10
    
    add() :  4+5 = 9
    
    add(y = 7): 4+7 = 11
    
    add(x = 5, 6) #Error (positional argument follows keyword argument:位置参数遵循关键字参数)  位置参数必须在关键字参数之前传入 
    
    add(y = 8, 4) #Error (positional argument follows keyword argument:位置参数遵循关键字参数)  位置参数必须在关键字参数之前传入
    
    add(x = 5, y = 6) 5+6 = 11
    
    add(y = 6, x = 5) 5+5 = 10
    -----------------------------------------------------------------
    	作用：
    		参数的默认值在未传入足够的实参时，对没有给定的参数赋值默认值
    		参数多，不需要用户每次都输入所有的参数，简化调用
    	例：
    		定义一个函数login，参数名为：host 、 port 、 username 、 password
    		
    			def login(host = '127.0.0.1', port='80', username='test', password='test'):
    			
    				print('{}:{}@{}/{}'.format(host, port, username, password))
    			
    		1)login()
    			127.0.0.1:80@test/test  默认 主机名：端口@用户名/密码
    		2)login('127.0.0.1',80,'tom','tom')
    			127.0.0.1:80@tom/tom  位置参数传入
    		3)login('127.0.0.1',username='root')
    			127.0.0.1:80@root/test 指定一个位置参数和关键字参数
    		4)login(port=80, password='test',host='www')
    			www:80@test/test		使用关键字参数传入，没有传入的使用默认值
    	可变参数：
    	1)位置可变
    		def add(*nums):
    			sum = 0
    			for x in nums:
    				sum+=x
    			return sum
    
    		传入一个可迭代对象
    
    		add([1,3,5])   12
    		add((1,3,5))   12
    
    		一个形参可以匹配任意个实参
    
    		在形参前使用* 表示该形参是可变参数，可以接收多个实参
    		生成一个tuple
    
    	2)关键字可变
    		def showconfig(**kwargs):
    			for k,v in kwargs.items():
    				print('{}={}'.format(k,v))
    
    		showconfig(host='localhost', port='80', username='test', password='test')
    		----------------------------
    
    			password=test
    			host=localhost
    			username=test
    			port=80
    		----------------------------
    
    		形参前使用**，表示可接收多个关键字参数
    		生成一个dict
    
    	3)可变参数的混合使用：
    		1.	def showconfig(username,password,**kwargs)
    				for k ,v in kwargs.items():
    					print('{}={}'.format(k,v))
    			>>>showconfig('test','test')
    			>>>test
    			>>>test
    			>>>showconfig('test','test',x=1,y=2)
    			>>>test
    			>>>test
    			>>>x=1
    			>>>y=2
    		2. def showconfig(username,*args,**kwargs):
            		print(username)
             		print(args)
    			    for k, v in kwargs.items():
    			           print('{}={}'.format(k,v))
    			>>>showconfig('test','test','zzz',x=2)
    			>>>test
    			>>>('test','zzz')
    			>>>x=2
    -----------------------------------------------------------------------------------
    上例中，*args和*kwargs是可变参数，*args表示多个无名参数(位置参数)，它是一个tuple；
    **kwargs表示关键字参数，它是一个dict。同时使用*args和**kwargs时，必须将*args写在
    **kwargs前面，否则会出错
    def showconfig (username,**kwargs,*args)
    这是错误的。这样调用 提示语法错误：
    SyntaxError: non-keyword arg after keyword arg
    -----------------------------------------------------------------------------------
    	可变参数分为：位置可变参数和关键字可变参数
    	位置可变参数要在形参前加*
    	关键字可变参数要在形参前加**
    	位置可变参数生成的是tuple，关键字可变参数生成的是dict
    	位置可变参数要放在关键字可变参数前
    
    
    	keyword-only 参数
    
    		如果在一个星号参数后，或者一个位置可变参数后，出现的普通参数变成了keyword-only参数
    
    		keyword-only 后常跟默认值
    
    		def fn(*args,x):
    			print(x)
    			print(args)
    
    		fn(3,5)  args已经截断了所有的位置参数，如果x不使用关键字参数就拿不到实参 所以这里error
    		>>>can't assign to function call  不能分配函数调用
    		fn(3,6,x=1) 
    		>>>1
    		>>>3,6
    
    		def fn(**kwargs,x)  kwargs截断所有的关键字参数，x永远也获取不到值
    
    	keyword-only 第二种形式：
    		def fn(*,x,y):
    			print(x,y)
    
    		fn(x=1,y=2)
    		>>>1 2
    	*后面，形参都变成了keyword-only参数 必须指定关键字传参
    
    
    	可变参数和参数默认值：
    	1.
    		def fn(*args,x=5):
    			print(x)
    			print(args)
    
    		fn()
    		>>> 5
    		>>> ()
    		
    		fn(6)
    		>>>5
    		>>>(6,)
    		
    		fn(x=9)
    		>>>9
    		>>>()
    		
    		fn(1,2,5,x=10)
    		>>>10
    		>>>(1,2,3)
    
    		不指定关键字参数，x使用默认值 位置参数就赋值args
    	2.
    		def fn(y,*args,x=5):
    			print('x={},y={}'.format(x,y))
    			print(args)
    
    		fn()
    		>>>missing 1 required positional argument: 'y'  缺少y参数传值
    
    		fn(6)
    		>>> x=5,y=6
    		>>>()
    
    		fn(x=6)
    		>>>missing 1 required positional argument: 'y'  缺少y参数传值
    
    		fn(1,2,3,x=10)
    		>>>x=10,y=1
    		>>>(2,3)
    
    		fn(y=10,2,3,x=10)
    		>>>positional argument follows keyword argument 位置参数要放在关键字参数前面
    
    		fn(1,2,y=3,x=10)
    		>>>fn() got multiple values for argument 'y'  y被赋值2次
    
    	3.
    		def fn(x=5,*kwargs):
    			print('x={}'.format(x))
    			print(kwargs)
    
    		fn()
    		>>>x=5
    		>>>{}
    
    		fn(6)
    		>>>x = 6
    		>>>{}
    
    		fn(x=9)
    		>>>x=9
    		>>>{}
    
    		fn(y=3,x=10)
    		>>>x=10
    		>>>{'y':3}
    
    		fn(3,y=10)
    		>>>x=3
    		>>>{'y':10}
    
    	函数参数一般顺序：
    		普通参数 -> 缺省参数 -> 可变位置参数 -> keyword-only参数(可带缺省值) -> 可变关键字参数
    
    		def fn(x, y, z=3, *args, m=4, n, **kwargs)
    
    		x，y 普通参数
    		z=3  缺省参数
    		*args 可变位置参数
    		m，n  keyword-only参数
    		**kwargs 可变关键字参数

转载于:https://www.cnblogs.com/hkcs/p/7646646.html