python函数的5种参数详解,python 方法参数

　　功能的灵活性非常高。除了传统定义的位置参数，它还支持默认参数、关键字参数和变量参数.这样既能应对各种复杂情况，又能简化调用者的代码。

　　位置参数

　　调用函数时，通常根据函数定义的参数位置传递参数。这种参数称为位置参数。

　　考虑以下示例，该函数包含两个参数-name和msg:

　　defgreet(姓名，消息):

　　.打印(你好，{}，{}！。格式(姓名、消息))

　　.很容易称之为：

　　问候(“小马”、“nicetomeetyou”)

　　你好，小马，你好！这里，值是按顺序分配的。由于“Pony”是第一个值，它将被赋给第一个参数名；类似地，“很高兴见到你”将被赋给第二个参数msg。

　　当传递两个值时，该函数会平稳运行。但是如果参数的数量不匹配会发生什么呢？

　　Greet(Pony)#缺少一个参数

　　.

　　type : Greet()missing 1 required positional Argument 3360 msg 显然，解释器会发牢骚。但是对于Python来说，解决这个问题简直是小菜一碟。请继续阅读！

　　默认参数

　　定义函数时，可以使用赋值运算符(=)来指定参数的默认值：

　　defgreet(name，msg=nicetomeetyou):

　　.打印(你好，{}，{}！。格式(姓名、消息))

　　.

　　注意：如果参数没有默认值，则在调用函数时必须为其指定一个值；如果有默认值，则该值在调用时是可选的，如果为其提供了值，默认值将被覆盖。

　　因为name没有默认值，所以必须指定一个值，而msg有默认值，所以该值是可选的：

　　Greet(Pony)#使用默认值

　　你好，小马，你好！

　　Greet(Pony ， givemeahug)#覆盖默认值

　　你好，小马，给我一个拥抱！值得注意的是，函数中的所有参数都可以有默认值，但是一旦默认参数存在，它右边的所有参数也必须有默认值。

　　也就是说，非默认参数不能跟在默认参数后面。例如，将会报告如下所示的错误：

　　defgreet(msg=nicetomeetyou ，name):

　　.打印(

　　#39;Hello,{},{}!'.format(name,msg))

　　...

　　File"<stdin>",line1

　　SyntaxError:non-defaultargumentfollowsdefaultargument关键字参数

　　为方便起见，Python 还允许使用 key = value 形式的关键字参数调用函数：

>>>defgreet(name,msg):
　　...print('Hello,{},{}!'.format(name,msg))
　　...>>>

>>>greet(name='Pony',msg='nicetomeetyou')#按循序传递
　　Hello,Pony,nicetomeetyou!
　　>>>
　　>>>greet(msg='nicetomeetyou',name='Pony')#顺序颠倒也可以
　　Hello,Pony,nicetomeetyou!

>>>greet('Pony',msg='nicetomeetyou')#位置参数与关键字参数混合使用
　　Hello,Pony,nicetomeetyou!

>>>greet(name='Pony',message='nicetomeetyou')#message不存在
　　...
　　TypeError:greet()gotanunexpectedkeywordargument'message'
　　>>>
　　>>>greet(msg='nicetomeetyou','Pony')#关键字参数不能在位置参数之前
　　...
　　SyntaxError:positionalargumentfollowskeywordargument

　　可变参数也被称为不定长参数，顾名思义，就是传入的参数个数是可变的，可以是任意多个（0、1、2 ...）。``

　　包裹位置传递

　　在参数名之前可以添加一个星号（*），在函数内部，所有传入的参数都会被变量 names 收集，最终按照位置将它们合并为一个元组：

>>>defgreet(*names):
　　...print('Hello,',names)
　　...
　　>>>

>>>greet()#没有参数，为空元组
　　Hello,()
　　>>>
　　>>>greet('Pony')
　　Hello,('Pony',)
　　>>>
　　>>>greet('JackMa','Pony')
　　Hello,('JackMa','Pony')

>>>defgreet(msg,*names):
　　...print('Hello,{},{}!'.format(names,msg))
　　...
　　>>>
　　>>>greet('nicetomeetyou','JackMa','Pony')
　　Hello,('JackMa','Pony'),nicetomeetyou!

>>>defgreet(*names,msg):
　　...print('Hello,{},{}!'.format(names,msg))
　　...
　　>>>
　　>>>greet('Pony',msg='nicetomeetyou')#只能被用作关键字参数
　　Hello,('Pony',),nicetomeetyou!
　　>>>
　　>>>greet(msg='nicetomeetyou','Pony')#不能被用作位置参数
　　...
　　SyntaxError:positionalargumentfollowskeywordargument

　　还有一种机制，在参数名之前添加两个星号（**），当这种形式出现时，msgs 将收集所有关键字参数，最终将它们合并为一个字典：

>>>defgreet(**msgs):
　　...print('Hello,',msgs)
　　...>>>

>>>greet()#没有参数，为空字典
　　Hello,{}
　　>>>
　　>>>greet(name='Pony')
　　Hello,{'name':'Pony'}
　　>>>
　　>>>greet(name='Pony',msg='nicetomeetyou')
　　Hello,{'name':'Pony','msg':'nicetomeetyou'}

　　例如，像下面这样，就会报错：

>>>defgreet(**msgs,*name):
　　...
　　SyntaxError:invalidsyntax

　　正如【可变参数】那样，也可在函数调用中使用 * 和 **。只不过在这种情况下，与在函数定义中的语义相反，参数将被解包裹而不是被包裹：

>>>defgreet(name,msg):
　　...print('Hello,{},{}!'.format(name,msg))
　　...
　　>>>

>>>t=('Pony','nicetomeetyou')
　　>>>greet(*t)
　　Hello,Pony,nicetomeetyou!

>>>d={'name':'Pony','msg':'nicetomeetyou'}
　　>>>greet(**d)
　　Hello,Pony,nicetomeetyou!

　　根据上面的介绍，我们不难发现，当这些参数混合使用时，应遵循一个基本的原则：位置参数 -> 默认参数 -> 包裹位置 -> 包裹关键字（定义和调用都应遵循该顺序）。

　　例如，定义一个函数，能够同时向多个人发送多条消息：

>>>defgreet(sender,address='BeiJing',*receivers,**msgs):
　　...print('Hello,Iam{},from{}.'.format(sender,address))
　　...print('-'*30)#华丽的分割线
　　...forrecinreceivers:
　　...forkey,valinmsgs.items():
　　...print('No{}:{},{}!'.format(key,val,rec))
　　...print('-'*30)#华丽的分割线
　　...
　　>>>

>>>greet('Waleon','Xi\'an','JackMa','Pony',one='nicetomeetyou',two='givemeahug')
　　Hello,IamWaleon,fromXi'an.
　　------------------------------
　　Noone:nicetomeetyou,JackMa!
　　Notwo:givemeahug,JackMa!
　　------------------------------
　　Noone:nicetomeetyou,Pony!
　　Notwo:givemeahug,Pony!
　　------------------------------

郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。