python可变参数函数

㈠ 在python中,函数定义为def+vfun(a,**b):……,则可变参数b的类型是

在函数的参数列表里，参数名前带两个"*"的参数是字典类型。vfun函数的调用里，a后的参数都必须使用关键字传参，它们作为键值对存到字典b

㈡ python 函数变量 参数怎么使用

刚学用Python的时候，特别是看一些库的源码时，经常会看到func(*args, **kwargs)这样的函数定义，这个*和**让人有点费解。其实只要把函数参数定义搞清楚了，就不难理解了。
先说说函数定义，我们都知道，下面的代码定义了一个函数funcA
def funcA():
pass

显然，函数funcA没有参数（同时啥也不干:D）。
下面这个函数funcB就有两个参数了，
def funcB(a, b):
print a
print b
调用的时候，我们需要使用函数名，加上圆括号扩起来的参数列表，比如 funcB(100, 99)，执行结果是：
100
99
很明显，参数的顺序和个数要和函数定义中一致，如果执行funcB(100)，Python会报错的：
TypeError: funcB() takes exactly 2 arguments (1 given)
我们可以在函数定义中使用参数默认值，比如
def funcC(a, b=0):
print a
print b
在函数funcC的定义中，参数b有默认值，是一个可选参数，如果我们调用funcC(100)，b会自动赋值为0。
OK，目前为止，我们要定义一个函数的时候，必须要预先定义这个函数需要多少个参数（或者说可以接受多少个参数）。一般情况下这是没问题的，但是也有在定义函数的时候，不能知道参数个数的情况（想一想C语言里的printf函数），在Python里，带*的参数就是用来接受可变数量参数的。看一个例子
def funcD(a, b, *c):
print a
print b
print "length of c is: %d " % len(c)
print c
调用funcD(1, 2, 3, 4, 5, 6)结果是
1
2
length of c is: 4
(3, 4, 5, 6)
我们看到，前面两个参数被a、b接受了，剩下的4个参数，全部被c接受了，c在这里是一个tuple。我们在调用funcD的时候，至少要传递2个参数，2个以上的参数，都放到c里了，如果只有两个参数，那么c就是一个empty tuple。
好了，一颗星我们弄清楚了，下面轮到两颗星。
上面的例子里，调用函数的时候，传递的参数都是根据位置来跟函数定义里的参数表匹配的，比如funcB(100, 99)和funcB(99, 100)的执行结果是不一样的。在Python里，还支持一种用关键字参数(keyword argument)调用函数的办法，也就是在调用函数的时候，明确指定参数值付给那个形参。比如还是上面的funcB(a, b)，我们通过这两种方式调用
funcB(a=100, b=99)
和
funcB(b=99, a=100)
结果跟funcB(100, 99)都是一样的，因为我们在使用关键字参数调用的时候，指定了把100赋值给a，99赋值给b。也就是说，关键字参数可以让我们在调用函数的时候打乱参数传递的顺序！
另外，在函数调用中，可以混合使用基于位置匹配的参数和关键字参数，前题是先给出固定位置的参数，比如
def funcE(a, b, c):
print a
print b
print c
调用funcE(100, 99, 98)和调用funcE(100, c=98, b=99)的结果是一样的。
好了，经过以上铺垫，两颗星总算可以出场了：
如果一个函数定义中的最后一个形参有 ** （双星号）前缀,所有正常形参之外的其他的关键字参数都将被放置在一个字典中传递给函数，比如：
def funcF(a, **b):
print a
for x in b:
print x + ": " + str(b[x])
调用funcF(100, c='你好', b=200)，执行结果
100
c: 你好
b: 200
大家可以看到，b是一个dict对象实例，它接受了关键字参数b和c。

㈢ python可变参数求和

在Python函数中，还可以定义可变参数。顾名思义，可变参数就是传入的参数个数是可变的，可以是1个、2个到任意个，还可以是0个。

我们以数学题为例子，给定一组数字a，b，c……，请计算a^2 + b^2 + c^2 + ……。
def calc(*numbers):
sum = 0
for n in numbers:
sum = sum + n * n
return sum
定义可变参数和定义一个list或tuple参数相比，仅仅在参数前面加了一个*号。在函数内部，参数numbers接收到的是一个tuple，因此，函数代码完全不变。但是，调用该函数时，可以传入任意个参数，包括0个参数：

>>> calc(1, 2)
5
>>> calc()
0

㈣ python 可变参数函数 怎么做加法

函数add应该这样定义：
每个=表示一个空格
def add(*a):
====s=0
====for b in a:
========s+=b
====return s

㈤ Python的函数和参数

parameter 是函数定义的参数形式
argument 是函数调用时传入的参数实体。

对于函数调用的传参模式，一般有两种：

此外，

也是关键字传参

python的函数参数定义一般来说有五种: 位置和关键字参数混合 ， 仅位置参数 ， 仅关键字参数 ， 可变位置参数 ， 可变关键字参数 。其中仅位置参数的方式仅仅是一个概念，python语法中暂时没有这样的设计。
通常我们见到的函数是位置和关键字混合的方式。

既可以用关键字又可以用位置调用

或

这种方式的定义只能使用关键字传参的模式

f(*some_list) 与 f(arg1, arg2, ...) （其中some_list = [arg1, arg2, ...]）是等价的

网络模块request的request方法的设计
多数的可选参数被设计成可变关键字参数

有多种方法能够为函数定义输出：

非常晦涩

如果使用可变对象作为函数的默认参数，会导致默认参数在所有的函数调用中被共享。
例子1：

addItem方法的data设计了一个默认参数，使用不当会造成默认参数被共享。
python里面，函数的默认参数被存在__default__属性中，这是一个元组类型
例子2：

在例子1中，默认参数是一个列表，它是mutable的数据类型，当它写进 __defauts__属性中时，函数addItem的操作并不会改变它的id，相当于 __defauts__只是保存了data的引用，对于它的内存数据并不关心，每次调用addItem，都可以修改 addItem.__defauts__中的数据，它是一个共享数据。
如果默认参数是一个imutable类型，情况将会不一样,你无法改变默认参数第一次存入的值。

例子1中，连续调用addItem('world') 的结果会是

而不是期望的

㈥ Python编程题：编写函数，利用可变参数计算一组数的最大值

一行即可，排下序，取最后一个即可~
def maxnum(*nums):
return sorted(nums)[-1]

print(maxnum(-1, 34, -9, 56))#56
print(maxnum(1, 4, 6, 95, 3, 78))#95

㈦ python中定义函数时如何书写可变参数和默认参数

参数名前面加*是可变位置参数，

加**是可变关键字参数；

参数名=默认值可以用来为参数指定默认值。

下面是一个例子：

#/使前面的参数成为仅仅是位置参数

def f(a=1,b=2,/,c=3,*args,**kwargs):print(a,b,c,*args,kwargs)

def f2(a=1,b=2,c=3,*args,**kwargs):print(a,b,c,*args,kwargs)

#*使后面的参数成为仅仅是关键字参数

def f3(a=1,b=2,*,c=3,d=4):print(a,b,c,d)

#/使前面的参数成为仅仅是位置参数

def f4(a=1,b=2,/,c=3,d=4):print(a,b,c,d)

f()

f(11,22)

#f(a=11,b=22)

f(c=666)

f(1,2,3,4,5,x=5,y=6)

f2()

f2(a=11,b=22)

f2(c=888)

f2("a","b","c",1,2,p="ok")

f3(1001,2222)

f3(a=1001)

f3(111,c=333,d=444)

f3(6,6,c=6,d=6)

#f3(6,6,6,6)

f4(1001,2222)

#f4(1001,b=2222)

f4(1001)

#f4(a=1001)

f4(111,c=333,d=444)

f4(1,2,3,4)

运行结果截图如下：

㈧ python-函数可变参数类型

python中的函数，大多需要配置参数，以下是几种函数的参数类型：

1.必备参数：以正确的顺序、个数传入函数。调用时的参数情况要和声明时一样。最常用的情况。

def tplink(a,b):

    c=a+b+b

    return c 

tplink(4,2)

2.关键字参数:使用关键字参数允许函数调用时参数的顺序和声明时不一致，因为python解析器会在调用函数时，用参数名匹配参数值。

def tplink(age1,age2):

    ageall=age1+age2+age2

    return ageall

tplink(age2=4,age1=2)

3.默认参数：默认某个参数的取值

def tplink(age1,age2=5):

ageall=age1+age2+age2

return ageall

tplink(age1=4)

4.不定长参数：在声明时并不确定 调用时的参数数量。这种情况，可以用不定长参数进行解决，具体操作是在参数名前用*。

但不能和 关键字参数并用。一般在正常参数arg之后。

*args、**kwargs的定义：

这两个都是python中的不定长参数，又称为可变参数。

*args 表示任何多个无名参数，它是一个 tuple ；

**kwargs 表示关键字参数，它是一个dict。

同时使用 * args和 ** kwargs 时，必须 * args参数列要在 ** kwargs前。且都在arg之后。

函数在调用时，会根据顺序，看是否放进 *args 或者 **kwargs中。

具体可根据实际情况使用，可以 更方便灵活的接收信息。

㈨ python 带可变参数的装饰器怎么用

装饰器本身是用来是为一个函数是实现新的功能，并且不改变原函数的代码以及调用方式。

遇到这样一种问题：

众多函数调用了你写的装饰器，但客户有需求说，我想实现我可以随之控制装饰器是否生效。

那你就不可能在得到命令的时候去原函数头部去做删除和添加装饰器调用的命令。这是就可以用到带参数的装饰器，定义一个开关，调用装饰器的时候，把这个装饰器的开关参数给传递进去，这样当开关打开的时候装饰器生效，关闭的时候则只执行原函数的代码。

举例：开关参数为True的时候执行过程：

F=True#step1装饰器的开关变量
defouter(flag):#step2
defwrapper(func):#step4
definner(*args,**kwargs):#stpe6
ifflag:#step9
print('before')#step10
ret=func(*args,**kwargs)#step11执行原函数
print('after')#step13
else:
ret=func(*args,**kwargs)
print('123')
returnret#step14
returninner#step7
returnwrapper#step5

@outer(F)#先执行step3：outer(True)这个函数，然后step6：@wrapper#此处把开关参数传递给装饰器函数
defhahaha():
pass#step12
hahaha()#step8相当于inner()

开关参数为False的时候执行过程：

F=False#stpe1装饰器的开关变量
defouter(flag):#step2
defwrapper(func):#step4
definner(*args,**kwargs):#stpe6
ifflag:#step9
print('before')
ret=func(*args,**kwargs)
print('after')
else:
ret=func(*args,**kwargs)#step10执行原函数
print('123')#step12
returnret#step13
returninner#step7
returnwrapper#step5

㈩ Python的位置参数、默认参数、关键字参数、可变参数区别

对于python函数参数，对于初学者可能就是进入了迷宫，尽管我也是初学者，简单总结一下。
说参数之前，先讲一下两个packing（包裹）和unpacking（解包裹）：

输出：

我总结不了这个概念，只能帮大家到这了

一、位置参数和关键字参数：

调用函数时根据函数定义的参数位置来传递参数。

注意：
有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序的

二、默认参数：
用于定义函数，为参数提供默认值，调用函数时可传可不传该默认参数的值（注意：所有位置参数必须出现在默认参数前，包括函数定义和调用）

三、可变参数：

定义函数时，有时候我们不确定调用的时候会传递多少个参数(不传参也可以)。此时，可用包裹(packing)位置参数，或者包裹关键字参数，来进行参数传递，会显得非常方便。

1、包裹位置传递

我们传进的所有参数都会被args变量收集，它会根据传进参数的位置合并为一个元组(tuple)，args是元组类型，这就是包位置传递。

2、包裹关键字传递

kargs是一个字典(dict)，收集所有关键字参数

四、解包裹参数：

*args 和 **kargs ，也可以在函数调用的时候使用，称之为解包(unpacking)

1、在传递元组时，让元组的每一个元素对应一个位置参数

2、在传递词典字典时，让词典的每个键值对作为一个关键字参数传递给函数

五、位置参数、默认参数、可变参数的混合使用

1、基本原则是：先位置参数，默认参数，包裹位置，包裹关键字(定义和调用都应遵循)

2、Python中 *args 和 **kwargs 的区别

先看个demo：

输出结果：

分析一下：可以看到，这两个是[Python]中的可变参数。 *args 表示任何多个无名参数，它是一个tuple； **kwargs 表示关键字参数，它是一个dict。并且同时使用 *args 和 **kwargs 时，必须 *args 参数列要在 **kwargs 前，否则会报语法错误！！！

还有个小应用场景：创建字典

其实python中就带有dict类，使用dict(a=1,b=2,c=3)即可创建一个字典了。

*args：
重点在*，后面的args相当于一个变量名，可以自己定义的。它的本质就是将标准调用剩下的值集中转变为元组。

从形参的角度：

从实参的角度：

从不同角度看**kwargs：

**kwargs与位置参数和默认参数混用：

超复杂混合参数混用记：

总结：

位置参数：

调用函数时所传参数的位置必须与定义函数时参数的位置相同

关键字参数：

使用关键字参数会指定参数值赋给哪个形参，调用时所传参数的位置可以任意

*位置参数：可接受任意数量的位置参数(元组)；只能作为最后一个位置参数出现，其后参数均为关键字参数

**关键字参数：可接受任意数量的关键字参数(字典)；只能作为最后一个参数出现