函数参数的使用

内容概要

  • 一、形参与实参的介绍
  • 二、形参与实参的具体使用
    • 位置参数
    • 关键字参数
    • 默认参数
    • 位置形参与默认形参的混合使用
    • 可变长度的参数
      • 定义
      • 可变长度的位置参数
      • 可变长度的关键字参数
      • 混用 * ,**
    • 命名关键字参数
    • 组合使用

内容详细

  • 一、形参与实参的介绍

    # 形参:在定义函数阶段的参数称之为形式参数,简称形参,相当于 变量名
    def func(x,y):
        print(x,y)
    
    # 实参:在调用函数阶段定义的参数称之为实际参数,简称实参,相当于 变量值
    func(1,2)
    
    # 形参与实参的关系
    	‘‘‘
    	1.在函数调用阶段,实参(变量值)会绑定给形参(变量名)# 准确来说其实是实参的内存地	     	址绑定给了形参
    	2.这种绑定关系只能在函数体内使用
    	3.形参与实参的绑定关系在函数调用的时候生效,在函数结束调用的时候接触绑定
    	‘‘‘
        
    # 实参是传入的值,但值可以是以下形式:
    	# 形式一:
        	func(1,2)
        # 形式二:
            a = 1
            b = 2
            func(a,b)
        # 形式三:
        	func(func(1,2),func(2,3))
            func(int(‘1‘),2)
        # 总结:只要最终结果都为值,就可以
    
  • 二、形参与实参的具体使用

    • 位置参数

      # 位置参数:按照顺序从左到右的顺序依次定义的参数称之为位置参数
      	# 1.位置形参:在函数定义阶段,按照从左到右的顺序直接定义的‘变量名‘
          	# 特点:必须被传值,多一个不行,少一个不行
          	def func(x,y):
                  print(x,y)
               func(1,2,3) # 报错
               func(1) # 报错
           # 2.位置实参:在函数定义阶段,按照从左到右的顺序直接定义的‘变量值‘,
          	 # 特点:按照顺序与实参一一对应
              func(1,2) # 1 2
              func(2,1) # 2 1
      
      
    • 关键字参数

      # 在函数调用的阶段,按照key=value的形式传入的值
      # 特点:指名道姓给某个形参传值,可以完全不按照顾顺序传值
      def func(x,y):
          print(x,y)
      func(y=1,x=2)
      
    • 默认参数

      # 在定义函数阶段,就已经被赋值的形参,称之为默认参数
      # 特点:在调用阶段可以不用为其赋值
      def func(x,y=3):
          print(x,y)
      func(1)  # 1 3
      func(1,2) # 1 2
      
      def func(name,age,gender=‘男‘):
      	print(name,age,gender)
      func(‘ycc‘,27)
      func(‘monkey‘,30,‘女‘)
      func(‘haha‘,29)
      func(‘xixi‘,28)
      
    • 位置形参与默认形参的混合使用

      # 1.位置形参必须在默认形参的左边
      	def func(x,y=2):
              pass
          def func(y=2,x):  # 报错 SyntaxError
              pass
          
      # 2.默认参数的值是在函数定义阶段被赋值的,准确的说是被赋予的值的内存地址
      	# eg1: 
      	m = 2  # 是不可变类型
          def func(x,y=m):  # y被赋值的其实是2的内存地址
              print(x,y)
          m = 333
          func(1)  # 1 2
          
          # eg2:
          # 虽然默认参数的值可以被指定为任意类型的数据,但是不推荐使用可变类型
          # 因为函数最理想的状态:函数的调用只跟函数本身有关系,不受外界代码的影响
          m = [111,]  # 是可变类型
          def func(x,y=m):
              print(x,y)
          m.append(222)
          # 如果这行代码上下还有一万行代码,那么如果在出现append(),
          # 最后函数调用时,你就不能预知道结果,那么默认参数将显得没有意义
          # func(1) # 1 [111,222]
          
          # eg3:
          def func(name,hobby,hobbies=[]):
              hobbies.append(hobby)
              print(‘%s的爱好是%s‘%(name,hobbies))
              func(‘ycc‘,‘play‘)  # ycc的爱好是[‘play‘]
              func(‘xixi‘,‘read‘)  # xixi的爱好是[‘play‘, ‘read‘]
              func(‘haha‘,‘rap‘)  # haha的爱好是[‘play‘, ‘read‘, ‘rap‘]
      	
          # eg4:因为默认参数不推荐使用可变类型,因此可使用下面的方法
          def func(name,hobby,hobbies=None):
              if hobbies is None:
                  hobbies = []
                  hobbies.append(hobby)
                  print(‘%s的爱好是%s‘%(name,hobbies))
                  func(‘ycc‘,‘play‘)  # ycc的爱好是[‘play‘]
                  func(‘xixi‘,‘read‘)  # xixi的爱好是[‘read‘]
                  func(‘haha‘,‘rap‘)  # haha的爱好是[‘rap‘]
      
      	    
          
      
    • 可变长度的参数(*与**的用法)

      • 定义

        # 可变长度是指在调用函数时,传入的值(实参)的个数不固定
        # 而参数是用来为形参赋值的,所以对应着,针对溢出的实参,必须要有对应的形参来接受
        
      • 可变长度的位置参数

        # 可变长度的位置参数:格式:*形参名
        # 用来接受溢出的位置实参,溢出的位置实参被*保存成元组的格式然后赋值紧跟其后的形参
        # (1)形参中带*,*后跟的可以是任意名字,但是约定成应该是args
        	def func(x,y,*args):  # args = (3,4,5,6)
                print(x,y,args)
            func(1,2,3,4,5,6)
            # eg:求和
            def my_sum(*args):
                res = 0
                for item in args:
                    res += item
                 return res
            res = my_sum(1,2,3,4)
            print(res)
            
        # (2)实参中带*,*后的值被打散成位置实参
        	def func(x,y,z):
                print(x,y,z)
            func(*[1,2,3])  # 1 2 3
            func(*{‘name‘:‘ycc‘,‘age‘:27,‘hobbies‘:[‘play‘,]}) # name age hobbies
            
        # (3)形参实参中都带*
        	 def func(x, y, *args):
                 print(x, y, args)
             func(1, 2, 3, 4, 5, 4)  # 1 2 (3, 4, 5, 4)
             func(1, 2, [3, 4, 5, 4])  # 1 2 ([3, 4, 5, 4],)
             func(1, 2, *[3, 4, 5, 4])  # 1 2 (3, 4, 5, 4)
        
      • 可变长度的关键字参数(格式:**变量名)

        # 用来接受溢出的关键字实参,
        # 溢出的关键字实参会被**保存成字典的格式然后赋值紧跟其后的形参
        # (1)**后跟的可以是任意名字,但是约定成应该是kwargs
             def func(x,y,**kwargs):
                 print(x,y,kwargs)  # 1 2 {‘a‘: 3, ‘b‘: 4, ‘c‘: 4}
             func(1,y=2,a=3,b=4,c=4)
            
        # (2)**可用在实参中(**后跟的只能是字典),实参中带**,**后的值打散成关键字实参
             def func(x,y,z):
                 print(x,y,z)
             func(**{‘x‘:‘ycc‘,‘y‘:27,‘z‘:[‘play‘,]})  # ycc 27 [‘play‘]
             func(**{‘x‘:‘ycc‘,‘a‘:27,‘z‘:[‘play‘,]})  # 报错
        # (3)形参实参中都带**
             def func(x, y, **args):
                 print(x, y, args)
             func(**{‘x‘:‘ycc‘,‘y‘:27,‘z‘:[‘play‘,],‘k‘:111})  
             # ycc 27 {‘z‘: [‘play‘], ‘k‘: 111}
        
      • 混用 * ,**

        # *必须在**前
            def func(*args,**kwargs):
                print(args,kwargs)
            func(1,2,3,4,5,4,x=1,y=2,z=3,c=4)  
            # # (1, 2, 3, 4, 5, 4) {‘x‘: 1, ‘y‘: 2, ‘z‘: 3, ‘c‘: 4}
            
            def index(x,y,z):
                print(x,y,z)
            def wrapper(*args,**kwargs):
                index(*args,**kwargs)
            wrapper(1,z=2,y=3)
            # 分析:首先将实参传值给形参:*args = (1,)  **kwargs = {‘y‘:3,‘z‘:2}
            # 第二步:这里是直接把wrapper(*args,**kwargs)中的形参给到了index(*args, 		**kwargs)的实参,
            # 即index(*(1,),**{‘y‘:3,‘z‘:2}),这里再次将其打散,然后绑定给x,y,z
        
    • 命名关键字参数

      # 命名关键字参数:在定义函数时,*后定义的参数,如下所示,称为命名关键字参数
      # (1).命名关键字的参数必须按照key:value的形式为其传值
           def func(x, y, *, a, b):
               print(x, y, a, b)
           func(1, 2, a=3, b=4)
          
      # (2)
           def func(x, y, *, a=3, b):
               print(x, y, a, b)
           func(1, 2, b=4)
          # 前面有讲到默认参数要在位置形参之后,否则会报语法错误,这里要注意,a=3,b  都是 		命名关键字参数,不要混淆。
      
    • 组合使用

      # 形参混合使用顺序:位置形参,默认形参,*args,命名关键字形参,**kwargs
           def func(x,y=2,*args,z,**kwargs):
               print(x)
               print(y)
               print(args)
               print(z)
               print(kwargs)
      
      # 实参混合使用的顺序
           def func(x, y, z, a, b, c):
               print(x)
               print(y)
               print(z)
               print(a)
               print(b)
               print(c)
           func(1,y=2,*[3,4],**{‘b‘:5,‘c‘:4})
          # 报错,实参传值给形参的时候有*一定要先将其打散
          # 打散后,func(1,y=2,3,4,b=5,c=4),y=2时关键字参数,应该在位置参数后,所以报错
          # # 以下两种顺序皆可
          # func(1, *[3, 4], a=2, **{‘b‘: 5, ‘ycc‘: 4})
          # func(1, *[3, 4], **{‘b‘: 5, ‘ycc‘: 4}, a=2)
      

函数参数的使用

上一篇:leetcode 53. 最大子序和


下一篇:1045