A. 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') 的结果会是
而不是期望的
B. python 定义函数
python 定义函数：
在Python中，可以定义包含若干参数的函数，这里有几种可用的形式，也可以混合使用：
1. 默认参数
最常用的一种形式是为一个或多个参数指定默认值。
>>> def ask_ok(prompt,retries=4,complaint='Yes or no Please!'):
while True:
ok=input(prompt)
if ok in ('y','ye','yes'):
return True
if ok in ('n','no','nop','nope'):
return False
retries=retries-1
if retries<0:
raise IOError('refusenik user')
print(complaint)
这个函数可以通过几种方式调用：
只提供强制参数
>>> ask_ok('Do you really want to quit?')
Do you really want to quit?yes
True
提供一个可选参数
>>> ask_ok('OK to overwrite the file',2)
OK to overwrite the fileNo
Yes or no Please!
OK to overwrite the fileno
False
提供所有的参数
>>> ask_ok('OK to overwrite the file?',2,'Come on, only yes or no!')
OK to overwrite the file? test
Come on, only yes or no!
OK to overwrite the file?yes
True
2. 关键字参数
函数同样可以使用keyword=value形式通过关键字参数调用
>>> def parrot(voltage,state='a stiff',action='voom',type='Norwegian Blue'):
print("--This parrot wouldn't", action, end=' ')
print("if you put",voltage,"volts through it.")
print("--Lovely plumage, the",type)
print("--It's",state,"!")
>>> parrot(1000)
--This parrot wouldn't voom if you put 1000 volts through it.
--Lovely plumage, the Norwegian Blue
--It's a stiff !
>>> parrot(action="vooooom",voltage=1000000)
--This parrot wouldn't vooooom if you put 1000000 volts through it.
--Lovely plumage, the Norwegian Blue
--It's a stiff !
>>> parrot('a thousand',state='pushing up the daisies')
--This parrot wouldn't voom if you put a thousand volts through it.
--Lovely plumage, the Norwegian Blue
--It's pushing up the daisies !
但是以下的调用方式是错误的：
>>> parrot(voltage=5, 'dead')
SyntaxError: non-keyword arg after keyword arg
>>> parrot()
Traceback (most recent call last):
File "<pyshell#57>", line 1, in <mole>
parrot()
TypeError: parrot() missing 1 required positional argument: 'voltage'
>>> parrot(110, voltage=220)
Traceback (most recent call last):
File "<pyshell#58>", line 1, in <mole>
parrot(110, voltage=220)
TypeError: parrot() got multiple values for argument 'voltage'
>>> parrot(actor='John')
Traceback (most recent call last):
File "<pyshell#59>", line 1, in <mole>
parrot(actor='John')
TypeError: parrot() got an unexpected keyword argument 'actor'
>>> parrot(voltage=100,action='voom',action='voooooom')
SyntaxError: keyword argument repeated
Python的函数定义中有两种特殊的情况，即出现*，**的形式。
*用来传递任意个无名字参数，这些参数会以一个元组的形式访问
**用来传递任意个有名字的参数，这些参数用字典来访问
（*name必须出现在**name之前）
>>> def cheeseshop1(kind,*arguments,**keywords):
print("--Do you have any",kind,"?")
print("--I'm sorry, we're all out of",kind)
for arg in arguments:
print(arg)
print("-"*40)
keys=sorted(keywords.keys())
for kw in keys:
print(kw,":",keywords[kw])
>>> cheeseshop1("Limbuger","It's very runny, sir.","It's really very, very runny, sir.",shopkeeper="Michael Palin",client="John",sketch="Cheese Shop Sketch")
--Do you have any Limbuger ?
--I'm sorry, we're all out of Limbuger
It's very runny, sir.
It's really very, very runny, sir.
----------------------------------------
client : John
shopkeeper : Michael Palin
sketch : Cheese Shop Sketch
>>>
3. 可变参数列表
最常用的选择是指明一个函数可以使用任意数目的参数调用。这些参数被包装进一个元组，在可变数目的参数前，可以有零个或多个普通的参数
通常，这些可变的参数在形参列表的最后定义，因为他们会收集传递给函数的所有剩下的输入参数。任何出现在*args参数之后的形参只能是“关键字参数”
>>> def contact(*args,sep='/'):
return sep.join(args)
>>> contact("earth","mars","venus")
'earth/mars/venus'
4. 拆分参数列表
当参数是一个列表或元组，但函数需要分开的位置参数时，就需要拆分参数
调用函数时使用*操作符将参数从列表或元组中拆分出来
>>> list(range(3,6))
[3, 4, 5]
>>> args=[3,6]
>>> list(range(*args))
[3, 4, 5]
>>>
以此类推，字典可以使用**操作符拆分成关键字参数
>>> def parrot(voltage,state='a stiff',action='voom'):
print("--This parrot wouldn't", action,end=' ')
print("if you put",voltage,"volts through it.",end=' ')
print("E's", state,"!")
>>> d={"voltage":"four million","state":"bleedin' demised","action":"VOOM"}
>>> parrot(**d)
--This parrot wouldn't VOOM if you put four million volts through it. E's bleedin' demised !
5. Lambda
在Python中使用lambda来创建匿名函数，而用def创建的是有名称的。
python lambda会创建一个函数对象，但不会把这个函数对象赋给一个标识符，而def则会把函数对象赋值给一个变量
python lambda它只是一个表达式，而def则是一个语句
>>> def make_incrementor(n):
return lambda x:x+n
>>> f=make_incrementor(42)
>>> f(0)
42
>>> f(2)
44
>>> g=lambda x:x*2
>>> print(g(3))
6
>>> m=lambda x,y,z:(x-y)*z
>>> print(m(3,1,2))
4
6. 文档字符串
关于文档字符串内容和格式的约定：
第一行应该总是关于对象用途的摘要，以大写字母开头，并且以句号结束
如果文档字符串包含多行，第二行应该是空行
>>> def my_function():
"""Do nothing, but document it.
No, really, it doesn't do anything.
"""
pass
>>> print(my_function.__doc__)
Do nothing, but document it.
No, really, it doesn't do anything.
C. 简单谈谈Python中函数的可变参数
简单谈谈Python中函数的可变参数
在Python中定义函数，可以用必选参数、默认参数、可变参数和关键字参数，这4种参数都可以一起使用，或者只用其中某些，但是请注意，参数定义的顺序必须是：必选参数、默认参数、可变参数和关键字参数。
可变参数( * )
可变参数，顾名思义，它的参数是可变的，比如列表、字典等。如果我们需要函数处理可变数量参数的时候，就可以使用可变参数。
我们在查看很多Python源码时，经常会看到 某函数(*参数1, **参数2)这样的函数定义，这个*参数和**参数就是可变参数，一时会让人有点费解。其实只要把函数可变参数的定义搞清楚了，就不难理解了。
当我们不知道需要用几个参数来定义函数的时候，可变参数就可以大展手脚了。
在Python里，带 * 的参数就是用来接受可变数量参数的。
如果一个函数定义如下：
def functionTest(*args):
....
....
....
调用时我们可以的这样调用：
functionTest(1)
或者
functionTest(1,2)
或者
functionTest(1,2,3)
后面可以传入多个参数。
看段实例代码，观察下*是怎么具体应用的吧：
def get_sum(*numbers):
sum = 0
for n in numbers:
sum += n
return sum
#在这里写下你的代码来调用get_sum来求5个数字的和，并输出这个结果
print (get_sum(1,2,3,4,5))
结果会是什么呢？大家可以自己动手操作起来看下，以就是关于Python中函数可变参数的全部内容，希望这篇文章对大家学习或使用python能有所帮助
D. python 函数参数 是什么意思
Python 函数定义以及参数传递
1.函数定义
#形如def func(args...):
doSomething123
以关键字def 开头，后面是函数名和参数下面是函数处理过程。
举例：
def add( a, b ):
return a+b12
参数可以设定默认值，如：
def add( a, b=10 ): #注意：默认值参数只会运算一次
return a+b12
默认值参数只会运算一次是什么意思？
def func( a, b=[] ): #b的默认值指向一个空的列表，每次不带默认值都会指向这块内存
b.append(a) return b
print(func(1))#向默认的空列表里加入元素1 ，默认列表里已经是[1]print(func(2))#向默认的列表里加入元素2,默认列表里已经是[1,2]print(func(3,[]))#向b指向的空列表里加入元素1 ，默认列表里还是[1,2]print(func(4))#向默认的列表里加入元素4,默认列表里已经是[1,2,4]'''
结果：
[1]
[1, 2]
[3]
[1, 2, 4]
'''12345678910111213141516
这下明白为什么默认参数只计算一次了吧，函数参数不传递时默认值总是指向固定的内存空间，就是第一次计算的空间。
2.参数传递
def func(a, b):
print('a=%d, b=%d' % (a,b) )12
在使用函数时可以如下方式,结果都是相同的
func(10,20) #不使用参数名，需要按参数顺序传递func(a=10,b=20) #使用参数名可以不按顺序传递func(b=20,a=10)#结果：a=10, b=20a=10, b=20a=10, b=201234567
如果函数定义形式如下方式：
def func(*args): #这种定义会把传递的参数包成元组
print(args,type(args))
func(10,20)#结果：#(10, 20) <class 'tuple'>1234567
举一个和上述过程相反的例子：
def func(a,b):
print('a=%d, b=%d' % (a,b) )
a = (10, 20)
func(*a) #在调用函数使用`*`则会把元组解包成单个变量按顺序传入函数#结果：a=10, b=20123456
总结：*号在定义函数参数时，传入函数的参数会转换成元组，如果 *号在调用时则会把元组解包成单个元素。
另一种定义：
def func(**kw):#使用**定义参数会把传入参数包装成字典dict
print(kw, type(kw) )
func(a=10,b=20)#这种函数在使用时必须指定参数值，使用key=value这种形式#结果：{'b': 20, 'a': 10} <class 'dict'>12345
相反的例子：
def func(a,b):
print('a=%d, b=%d' % (a,b) )
d = {'a':10, 'b':20 }
func(**d) #在调用时使用**会把字典解包成变量传入函数。12345
def func(*args, **kw):#这种形式的定义代表可以接受任意类型的参数
print(args,kw )12
总结：**号在定义函数参数时，传入函数的参数会转换成字典，如果 **号在调用时则会把字典解包成单个元素。
lambda表达式
lambda表达式就是一种简单的函数
形如 f = lambda 参数1，参数2： 返回的计算值
例如：
add = lambda x,y: x+y
print(add(1,2))'''
结果：3
'''12345
E. Python 的函数是怎么传递参数的
首先你要明白，Python的函数传递方式是赋值，而赋值是通过建立变量与对象的关联实现的。
对于你的代码：
执行 d = 2时，你在__main__里创建了d，并让它指向2这个整型对象。
执行函数add(d)过程中：
d被传递给add()函数后，在函数内部，num也指向了__main__中的2
但执行num = num + 10之后，新建了对象12，并让num指向了这个新对象——12。
如果你明白函数中的局部变量与__main__中变量的区别，那么很显然，在__main__中，d仍在指着2这个对象，它没有改变。因此，你打印d时得到了2。
如果你想让输出为12，最简洁的办法是：
在函数add()里增加return num
调用函数时使用d = add(d)
代码如下：
def add(num):
num += 10
return num
d = 2
d = add(d)
print d
F. 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与位置参数和默认参数混用：
超复杂混合参数混用记：
总结：
位置参数：
调用函数时所传参数的位置必须与定义函数时参数的位置相同
关键字参数：
使用关键字参数会指定参数值赋给哪个形参，调用时所传参数的位置可以任意
*位置参数：可接受任意数量的位置参数(元组)；只能作为最后一个位置参数出现，其后参数均为关键字参数
**关键字参数：可接受任意数量的关键字参数(字典)；只能作为最后一个参数出现