python函数调用的参数传递

python的函数参数传递是"引用传递（地址传递）"。

网站建设哪家好，找成都创新互联！专注于网页设计、网站建设、微信开发、小程序设计、集团企业网站建设等服务项目。为回馈新老客户创新互联还提供了新华免费建站欢迎大家使用！

python中赋值语句的过程（x = 1）：先申请一段内存分配给一个整型对象来存储数据1，然后让变量x去指向这个对象，实际上就是指向这段内存（这里有点和C语言中的指针类似）。

在Python中，会为每个层次生成一个符号表，里层能调用外层中的变量，而外层不能调用里层中的变量，并且当外层和里层有同名变量时，外层变量会被里层变量屏蔽掉。函数  调用  会为函数局部变量生成一个新的符号表。

局部变量：作用于该函数内部，一旦函数执行完成，该变量就被回收。

全局变量：它是在函数外部定义的，作用域是整个文件。全局变量可以直接在函数里面应用，但是如果要在函数内部改变全局变量，必须使用global关键字进行声明。

注意 ：默认值在函数  定义  作用域被解析

在定义函数时，就已经执行力它的局部变量

python中不可变类型是共享内存地址的：把相同的两个不可变类型数据赋给两个不同变量a，b，a，b在内存中的地址是一样的。

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怎么向类中的函数传递参数

Python中函数参数的传递是通过“赋值”来传递的。但这条规则只回答了函数参数传递的“战略问题”，并没有回答“战术问题”，也就说没有回答怎么赋值的问题。函数参数的使用可以分为两个方面，一是函数参数如何定义，二是函数在调用时的参数如何解析的。而后者又是由前者决定的。函数参数的定义有四种形式：

1. F(arg1,arg2,...)

2. F(arg2=value,arg3=value...)

3. F(*arg1)

4. F(**arg1)

第1 种方式是最“传统”的方式：一个函数可以定义不限个数参数，参数（形式参数）放在跟在函数名后面的小括号中，各个参数之间以逗号隔开。用这种方式定义的函数在调用的时候也必须在函数名后的小括号中提供相等个数的值（实际参数），不能多也不能少，而且顺序还必须相同。也就是说形参和实参的个数必须一致，而且想给形参1的值必须是实参中的第一位，形参与实参之间是一一对应的关系，即“形参1=实参1 形参2=实参2...”。很明显这是一种非常不灵活的形式。比如："def addOn(x,y): return x + y"，这里定义的函数addOn，可以用addOn(1,2)的形式调用，意味着形参x将取值1,主将取值2。addOn(1,2,3)和addOn (1)都是错误的形式。

第2种方式比第1种方式，在定义的时候已经给各个形参定义了默认值。因此，在调用这种函数时，如果没有给对应的形式参数传递实参，那么这个形参就将使用默认值。比如：“def addOn(x=3,y=5): return x + y”，那么addOn(6,5)的调用形式表示形参x取值6，y取值5。此外，addOn(7)这个形式也是可以的，表示形参x取值7，y取默认值5。这时候会出现一个问题，如果想让x取默认值，用实参给y赋值怎么办？前面两种调用形式明显就不行了，这时就要用到Python中函数调用方法的另一大绝招 ──关健字赋值法。可以用addOn(y=6)，这时表示x取默认值3，而y取值6。这种方式通过指定形式参数可以实现可以对形式参数进行“精确攻击”，一个副带的功能是可以不必遵守形式参数的前后顺序，比如：addOn(y=4,x=6)，这也是可以的。这种通过形式参数进行定点赋值的方式对于用第1种方式定义的函数也是适用的。

上面两种方式定义的形式参数的个数都是固定的，比如定义函数的时候如果定义了5个形参，那么在调用的时候最多也只能给它传递5个实参。但是在实际编程中并不能总是确定一个函数会有多少个参数。第3种方式就是用来应对这种情况的。它以一个*加上形参名的方式表示，这个函数实际参数是不一定的，可以是零个，也可以是N个。不管是多少个，在函数内部都被存放在以形参名为标识符的tuple中。比如：

对这个函数的调用addOn() addOn(2) addOn(3,4,5,6)等等都是可以的。

与第3种方式类似，形参名前面加了两个*表示，参数在函数内部将被存放在以形式名为标识符的dictionary中。这时候调用函数必须采用key1=value1、key2=value2...的形式。比如：

1. def addOn(**arg):

2. sum = 0

3. if len(arg) == 0: return 0

4. else:

5. for x in arg.itervalues():

6. sum += x

7. return sum

那么对这个函数的调用可以用addOn()或诸如addOn(x=4,y=5,k=6)等的方式调用。

上面说了四种函数形式定义的方式以及他们的调用方式，是分开说的，其实这四种方式可以组合在一起形成复杂多样的形参定义形式。在定义或调用这种函数时，要遵循以下规则：

1. arg=value必须在arg后

2. *arg必须在arg=value后

3. **arg必须在*arg后

在函数调用过程中，形参赋值的过程是这样的：

首先按顺序把“arg”这种形式的实参给对应的形参

第二，把“arg=value”这种形式的实参赋值给形式

第三，把多出来的“arg”这种形式的实参组成一个tuple给带一个星号的形参

第四，把多出来的“key=value”这种形式的实参转为一个dictionary给带两个星号的形参。

例子：

1. def test(x,y=5,*a,**b):

2. print x,y,a,b

就这么一个简单函数，来看看下面对这个函数调用会产生什么结果：

test(1) === 1 5 () {}

test(1,2) === 1 2 () {}

test(1,2,3) === 1 2 (3,) {}

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

test(x=1) === 1 5 () {}

test(x=1,y=1) === 1 1 () {}

test(x=1,y=1,a=1) === 1 1 () {'a':1}

test(x=1,y=1,a=1,b=1) === 1 1 () {'a':1,'b':1}

test(1,y=1) === 1 1 () {}

test(1,2,y=1) === 出错，说y给赋了多个值

test(1,2,3,4,a=1) === 1 2 (3,4) {'a':1}

test(1,2,3,4,k=1,t=2,o=3) === 1 2 (3,4) {'k':1,'t':2,'o':3}

python怎么给函数传参

函数参数传递机制问题在本质上是调用函数（过程）和被调用函数（过程）在调用发生时进行通信的方法问题。基本的参数传递机制有两

种：值传递和引用传递。

推荐：Python教程

值传递（passl-by-value）过程中，被调函数的形式参数作为被调函数的局部变量处理，即在堆栈中开辟了内存空间以存放由主调函数放

进来的实参的值，从而成为了实参的一个副本。值传递的特点是被调函数对形式参数的任何操作都是作为局部变量进行，不会影响主调函

数的实参变量的值。

引用传递(pass-by-reference)过程中，被调函数的形式参数虽然也作为局部变量在堆栈中开辟了内存空间，但是这时存放的是由主调函

数放进来的实参变量的地址。被调函数对形参的任何操作都被处理成间接寻址，即通过堆栈中存放的地址访问主调函数中的实参变量。正

因为如此，被调函数对形参做的任何操作都影响了主调函数中的实参变量。

更多技术请关注Python视频教程。

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

标准形式是 func(*args, **kwargs)

args及kwargs是Python函数接受的可变参数

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

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

示例代码：

def foo(*args,**kwargs):

print 'args=',args

print 'kwargs=',kwargs

print '**********************'

if __name__=='__main__':

foo(1,2,3)

foo(a=1,b=2,c=3)

foo(1,2,3,a=1,b=2,c=3)

foo(1,'b','c',a=1,b='b',c='c')

运行结果：

args= (1, 2, 3)

kwargs= {}

**********************

args= ()

kwargs= {'a': 1, 'c': 3, 'b': 2}

**********************

args= (1, 2, 3)

kwargs= {'a': 1, 'c': 3, 'b': 2}

**********************

args= (1, 'b', 'c')

kwargs= {'a': 1, 'c': 'c', 'b': 'b'}

**********************

Python中函数参数传递问题

对于可变参数默认是引用传值, 但是不能去修改它的指向, 一旦修改就是按值传递.

# coding=utf-8

def f(a):

a = [0]

print(a)

if __name__ == '__main__':

a = [1, 2, 3]

f(a)

print(a)

上面的代码对a重新赋值, 试图改变a的指向, 那么这时的a就是一个新的局部变量, 而非全局变量a

像a[0] = 100, a.append(0)的操作不会触发上述规则, 和你的输出一样

新闻标题：python函数间传参 python的传参
分享链接：http://kswjz.com/article/hjsgci.html