python函数批量传参 python函数传入多个参数

Python函数传参的几个注意点 def test(x = None, y = None, z = None):
if x == None:
x = 1
if y == None:
y = 2
if z == None:
z = 3
return xyz
print(test(None, None, 4))
python怎么给函数传参函数参数传递机制问题在本质上是调用函数(过程)和被调用函数(过程)在调用发生时进行通信的方法问题 。基本的参数传递机制有两
种:值传递和引用传递 。
推荐:Python教程
值传递(passl-by-value)过程中,被调函数的形式参数作为被调函数的局部变量处理,即在堆栈中开辟了内存空间以存放由主调函数放
进来的实参的值,从而成为了实参的一个副本 。值传递的特点是被调函数对形式参数的任何操作都是作为局部变量进行 , 不会影响主调函
数的实参变量的值 。
引用传递(pass-by-reference)过程中,被调函数的形式参数虽然也作为局部变量在堆栈中开辟了内存空间,但是这时存放的是由主调函
数放进来的实参变量的地址 。被调函数对形参的任何操作都被处理成间接寻址 , 即通过堆栈中存放的地址访问主调函数中的实参变量 。正
因为如此 , 被调函数对形参做的任何操作都影响了主调函数中的实参变量 。
更多技术请关注Python视频教程 。
python怎么向类中的函数传递参数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 xy",这里定义的函数addOn,可以用addOn(1,2)的形式调用 , 意味着形参x将取值1,主将取值2 。addOn(1,2,3)和addOn (1)都是错误的形式 。
第2种方式比第1种方式,在定义的时候已经给各个形参定义了默认值 。因此,在调用这种函数时,如果没有给对应的形式参数传递实参,那么这个形参就将使用默认值 。比如:“def addOn(x=3,y=5): return xy”,那么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)等的方式调用 。
上面说了四种函数形式定义的方式以及python函数批量传参他们的调用方式,是分开说的,其实这四种方式可以组合在一起形成复杂多样的形参定义形式 。在定义或调用这种函数时 , 要遵循以下规则:
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 的函数是怎么传递参数的对象vs变量
在python中,类型属于对象,变量是没有类型的,这正是python的语言特性,也是吸引着很多pythoner的一点 。所有的变量都可以理解是内存中一个对象的“引用”,或者,也可以看似c中void*的感觉 。所以,希望大家在看到一个python变量的时候,把变量和真正的内存对象分开 。
类型是属于对象的 , 而不是变量 。
这样,很多问题就容易思考了 。
例如:
对象vs变量
12
nfoo = 1#一个指向int数据类型的nfoo(再次提醒,nfoo没有类型)lstFoo = [1]#一个指向list类型的lstFoo,这个list中包含一个整数1
可更改(mutable)与不可更改(immutable)对象
对应于上一个概念,就必须引出另了另一概念,这就是可更改(mutable)对象与不可更改(immutable)对象 。
对于python比较熟悉的人们都应该了解这个事实,在python中,strings, tuples, 和numbers是不可更改的对象,而list,dict等则是可以修改的对象 。那么,这些所谓的可改变和不可改变影响着什么呢?
可更改vs不可更改
12345
nfoo = 1nfoo = 2lstFoo = [1]lstFoo[0] = 2
代码第2行中,内存中原始的1对象因为不能改变,于是被“抛弃”,另nfoo指向一个新的int对象,其值为2
代码第5行中 , 更改list中第一个元素的值 , 因为list是可改变的,所以,第一个元素变更为2 。其实应该说,lstFoo指向一个包含一个对象的数组 。赋值所发生的事情,是有一个新int对象被指定给lstFoo所指向的数组对象的第一个元素,但是对于lstFoo本身来说,所指向的数组对象并没有变化,只是数组对象的内容发生变化了 。这个看似void*的变量所指向的对象仍旧是刚刚的那个有一个int对象的list 。
如下图所示:
Python的函数参数传递:传值?引用?
对于变量(与对象相对的概念) , 其实 , python函数参数传递可以理解为就是变量传值操作,用C的方式理解,就是对void*赋值 。如果这个变量的值不变,我们看似就是引用,如果这个变量的值改变,我们看着像是在赋值 。有点晕是吧,我们仍旧据个例子 。
不可变对象参数调用
12345
def ChangeInt( a ):a = 10nfoo = 2 ChangeInt(nfoo)print nfoo #结果是2
这时发生了什么 , 有一个int对象2 , 和指向它的变量nfoo,当传递给ChangeInt的时候,按照传值的方式 , 复制了变量nfoo的值,这样,a就是nfoo指向同一个Int对象了,函数中a=10的时候,发生什么?(还记得我上面讲到的那些概念么),int是不能更改的对象 , 于是 , 做了一个新的int对象,另a指向它(但是此时,被变量nfoo指向的对象,没有发生变化),于是在外面的感觉就是函数没有改变nfoo的值,看起来像C中的传值方式 。
可变对象参数调用
12345
def ChangeList( a ):a[0] = 10lstFoo = [2]ChangeList(lstFoo )print nfoo #结果是[10]
当传递给ChangeList的时候,变量仍旧按照“传值”的方式,复制了变量lstFoo 的值,于是a和lstFoo 指向同一个对象,但是,list是可以改变的对象 , 对a[0]的操作,就是对lstFoo指向的对象的内容的操作 , 于是,这时的a[0] = 10,就是更改了lstFoo 指向的对象的第一个元素,所以,再次输出lstFoo 时,显示[10],内容被改变了,看起来,像C中的按引用传递 。
Python 的函数是怎么传递参数的?首先你要明白python函数批量传参,Python的函数传递方式是赋值,而赋值是通过建立变量与对象的关联实现的 。
对于你的代码python函数批量传参:
执行 d = 2时,你在__main__里创建了d,并让它指向2这个整型对象 。
执行函数add(d)过程中:
d被传递给add()函数后,在函数内部,num也指向了__main__中的2
但执行num = num10之后,新建了对象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
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函数传入多个参数】关于python函数批量传参和python函数传入多个参数的介绍到此就结束了 , 不知道你从中找到你需要的信息了吗 ?如果你还想了解更多这方面的信息 , 记得收藏关注本站 。

    推荐阅读