函数

1.函数的基本概念

1.函数的基本使用
 定义函数的语法
    def 函数名(参数1,参数2,...):
        ‘‘‘文档描述‘‘‘
        函数体
        return 值
    
 函数的使用必须遵守"先定义,后调用"的原则。
# 在定义阶段只检测语法,不会执行代码
2.函数的类型
	有参函数
    def my_min(x,y):
        res = x if x < y else y
        return res
    无参函数
    def interative():
        user = input(‘user>>>:‘).strip()
        pwd = input(‘passwd>>>:‘).strip()
        return (user,pwd)
    空函数
    def add():
        pass
3.调用函数与函数返回值
  # 语句模式
    func()
  # 表达式形式
	res = func()
  # 函数调用作为参数的形式
	m = func(func())
    
  $return 返回值
return是一个函数结束的标志,函数内可以有多个return，但只执行一次函数就结束了，并把return后定义的值作为本次调用的结果返回。
	
	

2.函数的参数

     1.函数的参数分为形式参数和实际参数,简称形参和实参
    	形参:即在定义函数时,括号内声明的参数。
       	实参:在调用函数,括号内传入的值
            
       # 1.实参
    	def sum(x, y):
            res = x + y
            print res
         sum(4, 5) >>>> 9
      # 2.在调用阶段,实参(值)会赋值给形参(变量名)。在PYTHON中,变量名与值只是单纯的绑定关系,而对于函数来说,这种关系只在函数调用时生效,在调用后结束解除

    2、形参与实参的具体使用
     2.1 位置参数:
      # 1.在定义函数时,按照从左到右的顺序依次定义形参,称为位置形参,按照这种形式定义的形参都必须被传值
     def register(name,age,sex): #定义位置形参：name，age，sex，三者都必须被传值
         print(‘Name:%s Age:%s Sex:%s‘ %(name,age,sex))
	register() #TypeError：缺少3个位置参数 
     register() # 里必须被传值
        # 2.在调用函数时,按照从左到右的顺序依次定义实参，称为位置实参，按照这种形式定义的实参会按照从左到右的顺序与形参一一对应
      def register(name,age,sex): #定义位置形参：name，age，sex，三者都必须被传值
           print(‘Name:%s Age:%s Sex:%s‘ %(name,age,sex))
      register() #TypeError：缺少3个位置参数
    	2.2 关键字参数:
            # 在调用函数时,实参可以是key=value的形式,称之为关键字参数,按照这种形式定义的参数,可以完全不按照从左到右的顺序定义,仍然可以为指定的形参赋值
            >>>register(sex=‘male‘,name=‘wuxie‘,age=18)
          # 实参可以是按位置或者按关键字或者是混合使用,注意的是关键字参数在位置参数后面,且不可以对一个形参重复赋值
        	>>> register(‘wuxie‘,sex=‘male‘,age=18)
         2.3 默认参数
        	# 在定义阶段,就已经为形参赋值,这类参数称之为默认参数
            def register(name,age,sex=‘male‘)
            	print(‘name:%s,age:%s,sex:%s‘ % (name,age,sex))
            ####注意事项#####
            # 1.默认参数必须在位置参数之后
            # 2.默认参数的值仅在函数定义阶段被赋值一次
            # 3.默认参数的值通常应设为不可变类型(整型,字符串,元组)
            
        # 默认参数小案例:
        def func(n,arg[]): # 默认参数的值仅在函数定义阶段被赋值一次
            arg.append(n)
            return arg
        func(1)
        >>>[1]
        func(2)
        >>>[1,2]
        func(3)
        >>>[1,2,3] # 默认参数的值仅在函数定义阶段被赋值一次,所以最后都在一个列表里
        ### 每个数据单独存储,需要讲默认参数设置为不可变类型
        def foo(n,arg=None):    
     		if arg is None:    
         		arg=[]    
     		arg.append(n)    
     		return arg    
        foo(1)    
        [1] 
        foo(2)    
        [2] 
        foo(3)    
        [3]
        
        
       2.4 可变长度的位置参数
    	* 如果我们在形参前＋*,那么我们在调用函数时,如果有溢出的参数,都会被接收,并以元组的形式赋值给形参
        # 例如
        def func(x,y,*z): # 一般讲*后面的变量名设置args
            print(x)
            print(y)
            print(z)
            
        >>> func(1,2,3,4,6) # 3,4,6被打包成元组
        
        # 如果在调用阶段使用*,会讲*后跟的值一一解开
        # 例如
        >>> func(*[3,4,5])
        >>3
        >>4
        >>(5,)
        
        
       2.5 可变长度的关键字参数
    	**  在最后一个形参名前面＋**,溢出的关键字参数,都会别接收以字典的形式保存下来赋值给该形参
       def func(x,**y): # 在最后一个参数前加**,一般这个变量名为kwargs
        	print(x)
            print(y)
            
           
        >>> func(x=1,y=2,z=4)
        >> 1
        >> {‘y‘:2,‘z‘=4}
        
         # 如果在调用阶段使用**,会讲**后跟的值一一解开
         # 例如
       def foo(x,y,z=3):
		print(x)
 		print(y)
		print(z)

	 foo(**{‘x‘:1,‘y‘:2}) #等同于foo(y=2,x=1)
		1
		2
		3
     
     ###综上,所有的参数都可以任意组合使用,注意的时顺序:位置参数,默认参数,*args ,命名关键字,**kwagrs  
        
     ######
    # 可变参数*args与关键字参数kwargs通常是组合在一起使用的，如果一个函数的形参为*args与kwargs，那么代表该函数可以接收任何形式、任意长度的参数
    #### 例如:
	   def index(x,y,z):
        	print(x,y,z)
        def wrapper(*args,**kwargs):
            index(*args,**kwargs)

        wrapper(1,y=2,z=3)   #  1,被*args所接收,关键字实参y=2,z=3 被**kwargs,以字典的形式保存,2.在执行过程中,即index(1,y=2,z=3)
        
        >> 1 2 3  

 

函数参数详解