函数参数python 函数参数的数据类型可以是

Python 的函数是怎么传递参数的

Python 的函数传递参数：

创新互联公司是一家集成都做网站、成都网站制作、网站页面设计、网站优化SEO优化为一体的专业网站设计公司，已为成都等多地近百家企业提供网站建设服务。追求良好的浏览体验,以探求精品塑造与理念升华,设计最适合用户的网站页面。 合作只是第一步，服务才是根本,我们始终坚持讲诚信，负责任的原则，为您进行细心、贴心、认真的服务,与众多客户在蓬勃发展的市场环境中,互促共生。

Python 传参数可以理解为 C 的 const 指针（your_type* const your_variable），它所指向的对象可以被修改产生副作用，但变量本身不能修改指向其他对象。这个和 C++ 的 reference 差不多。

所以如果一定要产生 C 的修改指针指向其他对象的效果，用 list、dict 或其他自定义的 mutable 对象包装是一个办法，但我认为这样是一种不良实践。在 C 语言中用参数输出结果有非常多的理由：

C 语言没有 tuple，不能返回多值，除非声明一个 struct 类型。这种情况下划分 in 参数和 out 参数成为一种惯例

C 语言没有异常机制，返回值一般要保留给 errno

但这些情况在 Python 中都是不存在的

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 函数参数的类型

1. 不同类型的参数简述

#这里先说明python函数调用得语法为：

复制代码

代码如下:

func(positional_args,

keyword_args,

*tuple_grp_nonkw_args,

**dict_grp_kw_args)

#为了方便说明,之后用以下函数进行举例

def test(a,b,c,d,e):

print a,b,c,d,e

举个例子来说明这4种调用方式得区别：

复制代码

代码如下:

#

#positional_args方式

test(1,2,3,4,5)

1 2 3 4 5

#这种调用方式的函数处理等价于

a,b,c,d,e = 1,2,3,4,5

print a,b,c,d,e

#

#keyword_args方式

test(a=1,b=3,c=4,d=2,e=1)

1 3 4 2 1

#这种处理方式得函数处理等价于

a=1

b=3

c=4

d=2

e=1

print a,b,c,d,e

#

#*tuple_grp_nonkw_args方式

x = 1,2,3,4,5

test(*x)

1 2 3 4

5

#这种方式函数处理等价于

复制代码

代码如下:

a,b,c,d,e = x

print

a,b,c,d,e

#特别说明:x也可以为dict类型,x为dick类型时将键传递给函数

y

{'a': 1,

'c': 6, 'b': 2, 'e': 1, 'd': 1}

test(*y)

a c b e d

#

#**dict_grp_kw_args方式

y

{'a': 1, 'c': 6, 'b': 2, 'e': 1, 'd': 1}

test(**y)

1 2 6

1 1

#这种函数处理方式等价于

a = y['a']

b = y['b']

... #c,d,e不再赘述

print

a,b,c,d,e

2.

不同类型参数混用需要注意的一些细节

接下来说明不同参数类型混用的情况,要理解不同参数混用得语法需要理解以下几方面内容.

首先要明白,函数调用使用参数类型必须严格按照顺序,不能随意调换顺序,否则会报错. 如 (a=1,2,3,4,5)会引发错误,;

(*x,2,3)也会被当成非法.

其次,函数对不同方式处理的顺序也是按照上述的类型顺序.因为#keyword_args方式和**dict_grp_kw_args方式对参数一一指定,所以无所谓顺序.所以只需要考虑顺序赋值(positional_args)和列表赋值(*tuple_grp_nonkw_args)的顺序.因此,可以简单理解为只有#positional_args方式,#*tuple_grp_nonkw_args方式有逻辑先后顺序的.

最后,参数是不允许多次赋值的.

举个例子说明,顺序赋值(positional_args)和列表赋值(*tuple_grp_nonkw_args)的逻辑先后关系:

复制代码

代码如下:

#只有在顺序赋值,列表赋值在结果上存在罗辑先后关系

#正确的例子1

x =

{3,4,5}

test(1,2,*x)

1 2 3 4 5

#正确的例子2

test(1,e=2,*x)

1 3 4 5 2

#错误的例子

test(1,b=2,*x)

Traceback (most recent call

last):

File "stdin", line 1, in module

TypeError: test()

got multiple values for keyword argument 'b'

#正确的例子1,处理等价于

a,b = 1,2 #顺序参数

c,d,e = x #列表参数

print a,b,c,d,e

#正确的例子2,处理等价于

a = 1 #顺序参数

e = 2 #关键字参数

b,c,d = x #列表参数

#错误的例子,处理等价于

a = 1 #顺序参数

b = 2 #关键字参数

b,c,d = x

#列表参数

#这里由于b多次赋值导致异常,可见只有顺序参数和列表参数存在罗辑先后关系

函数声明区别

理解了函数调用中不同类型参数得区别之后,再来理解函数声明中不同参数得区别就简单很多了.

1. 函数声明中的参数类型说明

函数声明只有3种类型, arg, *arg , **arg 他们得作用和函数调用刚好相反.

调用时*tuple_grp_nonkw_args将列表转换为顺序参数,而声明中的*arg的作用是将顺序赋值(positional_args)转换为列表.

调用时**dict_grp_kw_args将字典转换为关键字参数,而声明中**arg则反过来将关键字参数(keyword_args)转换为字典.

特别提醒：*arg

和 **arg可以为空值.

以下举例说明上述规则:

复制代码

代码如下:

#arg, *arg和**arg作用举例

def

test2(a,*b,**c):

print a,b,c

#

#*arg 和

**arg可以不传递参数

test2(1)

1 () {}

#arg必须传递参数

test2()

Traceback (most recent call last):

File "stdin", line 1,

in module

TypeError: test2() takes at least 1 argument (0 given)

#

#*arg将顺positional_args转换为列表

test2(1,2,[1,2],{'a':1,'b':2})

1 (2, [1, 2], {'a': 1, 'b': 2})

{}

#该处理等价于

a = 1 #arg参数处理

b = 2,[1,2],{'a':1,'b':2} #*arg参数处理

c =

dict() #**arg参数处理

print a,b,c

#

#**arg将keyword_args转换为字典

test2(1,2,3,d={1:2,3:4}, c=12, b=1)

1 (2, 3) {'c': 12, 'b': 1, 'd': {1: 2, 3:

4}}

#该处理等价于

a = 1 #arg参数处理

b= 2,3 #*arg参数处理

#**arg参数处理

c =

dict()

c['d'] = {1:2, 3:4}

c['c'] = 12

c['b'] = 1

print

a,b,c

2. 处理顺序问题

函数总是先处理arg类型参数,再处理*arg和**arg类型的参数.

因为*arg和**arg针对的调用参数类型不同,所以不需要考虑他们得顺序.

复制代码

代码如下:

def test2(a,*b,**c):

print

a,b,c

test2(1, b=[1,2,3], c={1:2, 3:4},a=1)

Traceback (most

recent call last):

File "stdin", line 1, in

module

TypeError: test2() got multiple values for keyword argument

'a'

#这里会报错得原因是,总是先处理arg类型得参数

#该函数调用等价于

#处理arg类型参数:

a = 1

a = 1

#多次赋值,导致异常

#处理其他类型参数

...

print a,b,c

def foo(x,y):

... def bar():

... print

x,y

... return bar

...

#查看func_closure的引用信息

a =

[1,2]

b = foo(a,0)

b.func_closure[0].cell_contents

[1, 2]

b.func_closure[1].cell_contents

b()

[1, 2] 0

#可变对象仍然能被修改

a.append(3)

b.func_closure[0].cell_contents

[1, 2, 3]

b()

[1, 2, 3] 0

python怎么查看函数有什么参数

Python中查看函数参数有四种方式：

1. F(arg1,arg2,…)

这是最常见的定义方式，一个函数可以定义任意个参数，每个参数间用逗号分割，用这种方式定义的函数在调用的的时候也必须在函数名后的小括号里提供个数相等的值（实际参数），而且顺序必须相同，也就是说在这种调用方式中，形参和实参的个数必须一致，而且必须一一对应，也就是说第一个形参对应这第一个实参。例如：

代码如下:

def a(x,y):print x,y

调用该函数，a(1,2)则x取1，y取2，形参与实参相对应，如果a(1)或者a(1,2,3)则会报错。

2. F(arg1,arg2=value2,…)

这种方式就是第一种的改进版，提供了默认值，例如：

代码如下:

def a(x,y=3):print x,y

调用该函数，a(1,2)同样还是x取1，y取2，但是如果a(1)，则不会报错了，这个时候x还是1，y则为默认的3。上面这俩种方式，还可以更换参数位置，比如a(y=4,x=3)用这种形式也是可以的。

3. F(*arg1)

上面两种方式是有多少个形参，就传进去多少个实参，但有时候会不确定有多少个参数，则此时第三种方式就比较有用，它以一个*加上形参名的方式来表示这个函数的实参个数不定，可能为0个也可能为n个。注意一点是，不管有多少个，在函数内部都被存放在以形参名为标识符的元组中。

代码如下:

def a(*x):print x

a(1,2,3)

(1, 2, 3)

a(x=1,y=2,z=3)

Traceback (most recent call last):

File "stdin", line 1, in module

TypeError: a() got an unexpected keyword argument 'x'

4. F(**arg1)

形参名前加两个*表示，参数在函数内部将被存放在以形式名为标识符的dictionary中，这时调用函数的方法则需要采用arg1=value1,arg2=value2这样的形式。

代码如下:

def a(**x):print x

a(x=1,y=2,z=3)

{'y': 2, 'x': 1, 'z': 3} #存放在字典中

a(1,2,3) #这种调用则报错

Traceback (most recent call last):

File "stdin", line 1, in module

TypeError: a() takes exactly 0 arguments (3 given)

python中函数的参数怎么写

*代表的是参数个数不确定的情况；

带一个星号（*）参数的函数传人的参数存储为一个元组（tuple）；

而带两个星号（*）参数的函数传人的参数则存储为一个字典（dict）；

由于传入的参数个数不定，所以当与普通参数一同使用时，必须把带星号的参数放在最后。