python函数参数灰了 python中函数参数

python 形参没有被定义？？？感觉遇到鬼了。。。

一、前言

创新互联建站主营景洪网站建设的网络公司,主营网站建设方案,成都app软件开发公司,景洪h5微信平台小程序开发搭建,景洪网站营销推广欢迎景洪等地区企业咨询

在python中，函数参数的定义和传递有以下几种方式：

语法

意义  

def func(name)

普通参数，可以根据位置匹配，也可以根据key来匹配  

def func(name=value)

默认参数，当参数没有传递时，使用默认值

def func(*iteratable)

将所有剩下的未匹配的参数收集至一个tuple中

def func(**dictionary)

将剩下未匹配的参数收集值一个dict中

def func(*, name)

必须使用key来匹配参数

def func(*other, name)

必须使用key来匹配参数

func(value)

函数调用，参数值按传递的参数顺序匹配  

func(name=value)

函数调用，参数值根据key来匹配  

func(*iteratable)

函数调用，将iteratable容器中的参数展开，按位置匹配对应的函数参数  

func(**dictionary)

函数调用，将dict中的参数展开，按key值来匹配对应的函数参数  

在python中，参数可以按照顺序传递，在调用函数时，参数的值按照传递的顺序，从左到右依次匹配。并且还可以给参数传递默认值，这都很好理解，因为在C、C++、Java等许多语言中，函数的参数传递都是按照这种方法来传递的。

但python的参数定义和传递除了按照顺序传递以及可以给默认值外，它还有其它的一些特点，在进一步讲解之前，首先说明python中函数调用中参数匹配的顺序：

按照顺序，给没有key的参数赋值，意味着传递参数时，需按顺序匹配的参数必须出现在按key匹配的参数之前；

给按照key匹配的参数赋值；

将多余的按照顺序匹配但未匹配的参数值归入*name的tuple中；

将多余未匹配上的按照key进行匹配的参数值归入**name的dict对象中；

将为匹配上的且具有默认值的参数赋默认值

二、按key匹配参数

对于C、C++这种语言，在调用函数时，系统会首先将函数地址压入堆栈，其次按参数的从右往左的顺序，一次压入堆栈。因此，C、C++这种语言它们只支持按顺序匹配形参。而python的做法不同，参数除了可以按顺序匹配，还可以按照参数名称来匹配。如：

def func(name, age):

print(name, age)

对于这个函数，以下的调用时等价的：

func('rechar', 27)    #按顺序匹配

func(name = 'rechar', age = 27)    #按参数名称匹配，在运行时告诉系统参数name的值为‘rechar’，age的值为27

func(age = 27, name = 'rechar')    #按参数名称匹配

func('rechar', age = 27)    #name是按顺序匹配，age按名称匹配

在python中，当按照参数名称进行匹配参数是，参数传递的顺序是可以任意的，不要求按照函数定义中参数的顺序进行传递。在使用名称匹配时，如果需要混合使用按顺序匹配规则，则按顺序匹配的参数必须出现在按key匹配的参数前，否则会报错：

func(name = 'rechar', 27)

以上调用会报如下错误：

三、函数定义中的”*name“

python在给按顺序匹配和按key匹配的参数赋完值后，如果发现调用者传入的参数仍有未匹配上的会发生什么情况呢？看一下下面的例子：

func('rechar', 27, 32)

运行时我们看到如下错误：

Traceback (most recent call last):

File "E:\tmp\tt.py", line 5, in module

func('rechar', 27, 32)

TypeError: func() takes 2 positional arguments but 3 were given

哦，python会抱怨我们传递的参数太多了。那如果确实在一些情况下，我们无法保证传递的参数数量一定和函数需要的参数数相等怎么办呢？这是就是*iterable这种参数该登场的时候了，假如在定义函数定义是，我们增加了一个参数，这个参数以一个”*“开始，那么这个参数实际上是一个tuple类型。假如传递的参数比需要的多，那那些多余的参数会被放入这个tuple中。例如，

def func(name, age, *other):

print(name, age, other)

那么,

func('rechar', 27, 32)

这个调用的输出如下：

rechar 27 (32,)

四、函数定义中的”**name“

python在将所有未匹配上的非按名称匹配的参数装入参数中的tuple之后，假如还有未匹配上的按名称匹配的参数那情况会怎样呢？首先来看一下下面的示例：

def func(name, age):

print(name, age)

func(name = 'rechar', age = 27, pay='1800')

执行时，python又抱怨了：

Traceback (most recent call last):

File "E:\tmp\tt.py", line 5, in module

func(name = 'rechar', age = 27, pay='1800')

TypeError: func() got an unexpected keyword argument 'pay'

它说func这个函数没有名称为”pay“的参数，这种情况或许出现在我们函数重构之后，原来函数时有这个参数的。而这个函数调用可能在别处没有被修改。假设即使给了”pay“这个参数，程序的正确性不受影响，没错，这就是”**name“参数的用武之地了。

假如在函数定义中，给函数增加一个以”**“开头的参数，那么这个参数实际上是一个dict对象，它会将参数调用中所有没有被匹配的按名称传递的参数都放入这个dict中。例如，

def func(name, age,**other):

print(name, age, other)

func(name = 'rechar', age = 27, pay='1800')

那么运行结果输出，

rechar 27 {'pay': '1800'}

看到了吧，这里的other就将没有匹配的”pay=‘1800’“收入囊中了。

五、规定调用必须按名称匹配

当我们在定义函数时，如果第一个参数就是”*name“参数，那么可想而知，我们无法使用按顺序匹配的方式传递，因为所有的按顺序传递的参数值最终的归宿都会是这里的tuple当中。而为了给后续的参数传递值，我们只能使用按名称匹配的方法。

六、”**“参数只能出现在最后一个形参之后

想想为什么?其实很好理解，因为出现在”**“形参之后的形参，无论使用按顺序传递还是按名称传递，最终都无法到达参数值真正应该需要到的地方。所以python规定，如果需要”**“参数，那它必须是最后一个形参。否则python会报语法错误。

七、函数调用中的”*“

在表格中我们看到了有func(*iteratable)的调用，这个调用的意思是，iteratable必须是一个可迭代的容器，比如list、tuple；作为参数传递值，它最终传递到函数时，不是以一个整体出现，而是将其中的元素按照顺序传递的方式，一次赋值给函数的形参。例如，

li = ['rechar', 27]

func(*li)

这个函数调用与

func('rechar', 27)

是等价的。

八、函数调用中的”**“

知道”*“在函数调用中的效果之后，也就很好理解”**“的作用了。它是将传递进来的dict对象分解，每一个元素对应一个按名称传递的参数，根据其中的key对参数进行赋值。

python无法输出结果？

python函数参数为None的时候，比如 def req(self, b=None)，是因为这个函数是一个封装函数，在没有调用他的时候他的参数需要加上None。如果不加None值，不调用函数他会报错。 一般会用在封装类或者框架里。比如说框架一般会有一个总的调用函数，总的调用函数启动，这次没有获取到值，执行到req函数时无法给req函数参数，那如果没有参数req函数就会报错。一般会报：‘req() missing 1 required positional argument: 'b'’但是如果参数为None就不会报错。如果程序执行到req参数传递成功的话，参数就不会是None了。 所以None是一个防止报错的机制。

python 函数参数类型

python 的函数参数类型分为4种：

1.位置参数：调用函数时根据函数定义的参数位置来传递参数，位置参数也可以叫做必要参数，函数调用时必须要传的参数。

当参数满足函数必要参数传参的条件，函数能够正常执行：

add(1,2) #两个参数的顺序必须一一对应，且少一个参数都不可以

当我们运行上面的程序,输出:

当函数需要两个必要参数，但是调用函数只给了一个参数时，程序会抛出异常

add(1)

当我们运行上面的程序,输出：

当函数需要两个必要参数，但是调用函数只给了三个参数时，程序会抛出异常

add(1,2,3)

当我们运行上面的程序,输出

2.关键字参数：用于函数调用，通过“键-值”形式加以指定。可以让函数更加清晰、容易使用，同时也清除了参数的顺序需求。

add(1,2) # 这种方式传参，必须按顺序传参：x对应1，y对应:2

add(y=2,x=1) #以关健字方式传入参数（可以不按顺序）

正确的调用方式

add(x=1, y=2)

add(y=2, x=1)

add(1, y=2)

以上调用方式都是允许的，能够正常执行

错误的调用方式

add(x=1, 2)

add(y=2, 1)

以上调用都会抛出SyntaxError 异常

上面例子可以看出：有位置参数时，位置参数必须在关键字参数的前面，但关键字参数之间不存在先后顺序的

3.默认参数：用于定义函数，为参数提供默认值，调用函数时可传可不传该默认参数的值，所有位置参数必须出现在默认参数前，包括函数定义和调用，有多个默认参数时，调用的时候，既可以按顺序提供默认参数，也可以不按顺序提供部分默认参数。当不按顺序提供部分默认参数时，需要把参数名写上

默认参数的函数定义

上面示例第一个是正确的定义位置参数的方式，第二个是错误的，因为位置参数在前，默认参数在后

def add1(x=1,y) 的定义会抛出如下异常

默认参数的函数调用

注意：定义默认参数默认参数最好不要定义为可变对象，容易掉坑

不可变对象：该对象所指向的内存中的值不能被改变，int,string,float,tuple

可变对象，该对象所指向的内存中的值可以被改变，dict,list

这里只要理解一下这个概念就行或者自行百度，后续会写相关的专题文章讲解

举一个简单示例

4.可变参数区别:定义函数时，有时候我们不确定调用的时候会多少个参数,j就可以使用可变参数

可变参数主要有两类：

*args: (positional argument) 允许任意数量的可选位置参数(参数),将被分配给一个元组, 参数名前带*，args只是约定俗成的变量名，可以替换其他名称

**kwargs：(keyword argument) 允许任意数量的可选关键字参数，,将被分配给一个字典，参数名前带**，kwargs只是约定俗成的变量名，可以替换其他名称

*args 的用法

args 是用来传递一个非键值对的可变数量的参数列表给函数

语法是使用 符号的数量可变的参数; 按照惯例,通常是使用arg这个单词，args相当于一个变量名，可以自己定义的

在上面的程序中,我们使用* args作为一个可变长度参数列表传递给add()函数。 在函数中,我们有一个循环实现传递的参数计算和输出结果。

还可以直接传递列表或者数组的方式传递参数,以数组或者列表方式传递参数名前面加（*） 号

理解* * kwargs

**kwargs 允许你将不定长度的键值对, 作为参数传递给函数，这些关键字参数在函数内部自动组装为一个dict

下篇详细讲解 *args, **kwargs 的参数传递和使用敬请关注

Python的函数参数总结

import math

a = abs

print(a(-1))

n1 = 255

print(str(hex(n1)))

def my_abs(x):

# 增加了参数的检查

if not isinstance(x, (int, float)):

raise TypeError('bad operand type')

if x = 0:

return x

else:

return -x

print(my_abs(-3))

def nop():

pass

if n1 = 255:

pass

def move(x, y, step, angle=0):

nx = x + step * math.cos(angle)

ny = y - step * math.sin(angle)

return nx, ny

x, y = move(100, 100, 60, math.pi / 6)

print(x, y)

tup = move(100, 100, 60, math.pi / 6)

print(tup)

print(isinstance(tup, tuple))

def quadratic(a, b, c):

k = b * b - 4 * a * c

# print(k)

# print(math.sqrt(k))

if k 0:

print('This is no result!')

return None

elif k == 0:

x1 = -(b / 2 * a)

x2 = x1

return x1, x2

else:

x1 = (-b + math.sqrt(k)) / (2 * a)

x2 = (-b - math.sqrt(k)) / (2 * a)

return x1, x2

print(quadratic(2, 3, 1))

def power(x, n=2):

s = 1

while n 0:

n = n - 1

s = s * x

return s

print(power(2))

print(power(2, 3))

def enroll(name, gender, age=8, city='BeiJing'):

print('name:', name)

print('gender:', gender)

print('age:', age)

print('city:', city)

enroll('elder', 'F')

enroll('android', 'B', 9)

enroll('pythone', '6', city='AnShan')

def add_end(L=[]):

L.append('end')

return L

print(add_end())

print(add_end())

print(add_end())

def add_end_none(L=None):

if L is None:

L = []

L.append('END')

return L

print(add_end_none())

print(add_end_none())

print(add_end_none())

def calc(*nums):

sum = 0

for n in nums:

sum = sum + n * n

return sum

print(calc(1, 2, 3))

print(calc())

l = [1, 2, 3, 4]

print(calc(*l))

def foo(x, y):

print('x is %s' % x)

print('y is %s' % y)

foo(1, 2)

foo(y=1, x=2)

def person(name, age, **kv):

print('name:', name, 'age:', age, 'other:', kv)

person('Elder', '8')

person('Android', '9', city='BeiJing', Edu='人民大学')

extra = {'city': 'Beijing', 'job': 'Engineer'}

person('Jack', 24, **extra)

def person2(name, age, *, city, job):

print(name, age, city, job)

person2('Pthon', 8, city='BeiJing', job='Android Engineer')

def person3(name, age, *other, city='BeiJing', job='Android Engineer'):

print(name, age, other, city, job)

person3('Php', 18, 'test', 1, 2, 3)

person3('Php2', 28, 'test', 1, 2, 3, city='ShangHai', job='Pyhton Engineer')

def test2(a, b, c=0, *args, key=None, **kw):

print('a =', a, 'b =', b, 'c =', c, 'args =', args, 'key=', key, 'kw =', kw)

test2(1, 2, 3, 'a', 'b', 'c', key='key', other='extra')

args = (1, 2, 3, 4)

kw = {'d': 99, 'x': '#'}

test2(*args, **kw)

新闻标题：python函数参数灰了 python中函数参数
文章路径：http://cdiso.cn/article/doehoji.html