Python def函数的定义、使用及参数传递实现代码
投稿：mdxy-dxy
字体：[ ] 类型：转载 时间：
Python编程中对于某些需要重复调用的程序，可以使用函数进行定义，在Python中使用def用来定义函数，这里简单分享下， 方便学习python的朋友
Python编程中对于某些需要重复调用的程序，可以使用函数进行定义，基本形式为：
def 函数名(参数1, 参数2, ……, 参数N):
执行语句函数名为调用的表示名，参数则是传入的参数，可以更具需要定义，也可以没有。
# 例1：简单的函数使用
# coding=gb2312
# 定义函数
def hello():
print 'hello python!'
# 调用函数
&&& hello python!
函数可以带参数和返回值，参数将按从左到右的匹配，参数可设置默认值，当使用函数时没给相应的参数时，会按照默认值进行赋值。
# 例2：累加计算值
# coding=gb2312
# 定义函数
def myadd(a=1,b=100):
result = 0
while i &= b:
# 默认值为1+2+3+……+100
result += i
return result
# 打印1+2+……+10
print myadd(1,10)
print myadd()
# 使用默认参数1，100
print myadd(50)
# a赋值50，b使用默认值
Python 函数的参数传递时，值得注意的是参数传入时若为变量会被当作临时赋值给参数变量，如果是对象则会被引用。
# coding=gb2312
def testpara(p1,p2):
p2.append('hello')
# 定义一数组对像
# 给变量a赋值
testpara(a,l) # 变量a与对象数组l作为参数传入
# 打印运行参数后的值
for v in l: # 打印数组对象的成员
# 调用函数后a变量并未被复值
# 而对象l数组则增加成员hello
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具python传递参数方式小结
作者：走向星辰大海
字体：[ ] 类型：转载 时间：
这篇文章主要介绍了python传递参数方式,实例总结了Python常用的参数传递方式,具有一定参考借鉴价值,需要的朋友可以参考下
本文实例总结了python传递参数方式。分享给大家供大家参考。具体分析如下：
当形参如*arg时表示传入数组，当形参如**args时表示传入字典。
def myprint(*commends,**map):
for comm in commends:
print comm
for key in map.keys():
print key,map[key]
myprint("hello","word",username="tian",name="wei")
username tian
python中定义一个函数，可以通过正常的只传入值或key-value的方法调用。但是如果第一个时参数传入的是key-value的方法，那么后面的必须都是key-value方法，如果第一个不是，那么后面的可以根据情况再传入值就可以了。
例子如下：
def parrot(voltage="fff",state='a stiff',action='voom',type='Norwegian Blue'):
print "-- This parrot wouldn't", action,
print "if you put", voltage, "volts through it."
print "-- Lovely plumage, the", type
print "-- It's", state, "!"
parrot(1000)#可以
parrot(action = 'VOOOOOM', voltage = 1000000)
#可以，都是key-value方法
parrot('a thousand', state = 'pushing up the daisies')
#可以，第一个实参为直接传入法，后面无所谓了
parrot('a million', 'bereft of life', 'jump')
#可以，都是传值，而且由于形参都有默认值，则按顺序一个个替换
parrot(voltage="33","ff","abc")
# 不可以，第一个为Key-value传值法，以后的都必须是
Python新手入门，在python中函式定义主要有四种方式：
① F(arg1,arg2,...)，最常见的定义方式，一个函式可以定义任何个参数，每个参数间用逗号分割，用这种参数在调用的时候必须在函式名后面的小括号中提供个数相等的值（实参），并且顺序必须相同，形参与实参一一对应
def a(x,y):
调用a函式，a(1,2)则x=1,y=2，如果a(1)或者a(1,2,3)则会出错
② F(arg1,arg2=value2,...agrN=valueN)，则将为函式提供默认值。
def a(x,y=3):
调用该函式，a(1,2)则x=1,y=2，如果a(1)不会导致错误，此时x=1,y=3,y值将使用默认值，a(y=4,x=2)同理
可变参数：
③ F(*arg1),以一个*加形参的方式来表示函式的实参个数不确定，参数个数&=0，采用这样的方式定义函式，在函式内部将以实参名的方式构建一个元组（tuple）
def a(*x):
# 定义一个名为x的元组
def a(*t):
&&&a(1,2,3)
遍历该元组（计算总和）的一种方式，此时r定义为一元组：
def y(*r):
for t in r:
④ F(**arg)形参名前加2个**表示在函式内部将被存放在以形参名为标识符的dictionary，这时调用将使用arg1=value1，arg2=value2...
def a(**b):
&&&a(x=1,y=2)
{'y':2,'x':1}
#注意遍历返回的顺序与形参位置顺序相反
&&&a(1,2) #error
可通过以下方式来获取预期键值对，如果形参是未定义'y'的键，将返回None
def a(**x):
print x.get('y')
&&&a(x=1,y=2)
&&&a(x=1,b=2)
Python参数调用过程按照以上四种方法优先级依次降低。
①方式解析，然后是②中的arg=value方式，再分别按照③&④优先级传参
这是自己第一份通过Blog整理的学习笔记，希望对自己，对浏览至此的各位朋友有所帮助，以上函式命名不符合规范，仅用于简单标识说明，使用python 2.6.2
希望本文所述对大家的Python程序设计有所帮助。
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具数组合并 python将两个数组合并成一个数组的两种方法 - 为程序员服务
为程序员服务
python将两个数组合并成一个数组的两种方法
c1 = [&Red&,&Green&,&Blue&]
c2 = [&Orange&,&Yellow&,&Indigo&]
c1.extend(c2)
assert c1 == [&Red&,&Green&,&Blue&,&Orange&,&Yellow&,&Indigo&]
下面使用+号操作符
c1 = [&Red&,&Green&,&Blue&]
c2 = [&Orange&,&Yellow&,&Indigo&]
c3 = c1 + c2
assert c3 == [&Red&,&Green&,&Blue&,&Orange&,&Yellow&,&Indigo&]
您可能的代码
相关聚客文章
荣誉：1685
相关专栏文章Python数据分析（七）：利用数组进行高效的数据处理
Python数据分析（七）：利用数组进行高效的数据处理
NumPy数组可以将许多数据处理任务表述为简洁的数组表达式，否则需要编写循环。用数组表达式代替循环的做法，通常被称为矢量化。通常矢量化数组运算要比等价的纯Python方式快上一两个数量级，尤其是各种数值计算。假设我们想要在一组值（网格型）上计算函数sqrt(x^2 + y^2)。np.meshgrid()函数接受两个一维数组，并产生两个二维矩阵，对应于两个数组中所有的(x, y)对。将条件逻辑表述为数组运算np.where()函数是三元表达式 x if condition else y的矢量化版本。假设我们有一个布尔数组和两个值数组：这有一些问题。第一，它对大数组的处理速度不是很快；第二，无法用于多维数组。若使用np.where()，则可以将该功能写得非常简洁。np.where()的第二个和第三个参数不必是数组，也可以是标量值。where()通常用于根据另一个数组产生一个新的数组。np.where()可以表述更加复杂的逻辑。数学和统计方法用于布尔型数组的方法在使用基本统计方法时，布尔值会被强制转换为1和0，因此sum经常被用来对布尔型数据中的True值计数。另外还有两个方法any()和all()，它们对布尔型数组非常有用。any()用于测试数组中是否存在一个或多个True，而all()则检查数组中所有制是否都是True，两个方法均返回布尔值结果。这两个方法也可用于非布尔型数组，所有非0元素均会被当作True。排序与Python内置的列表类型一样，NumPy数组也可以通过sort方法就地排序（会对原数组进行操作）。多维数组可以在任何一个轴向上进行排序，只需将轴编号传给sort即可。请点击此处输入图片描顶级方法np.sort()返回的是数组的已排序副本，而就地排序则会修改数组本身。计算数组分位数最简单的方法是对其进行排序，然后取特定位置的值：唯一化以及其他的集合逻辑。NumPy提供了一些针对一维ndarray()的基本集合运算，最常用的可能要数np.unique()了，它用于找出数组中的唯一值并返回已排序的结果。拿跟np.unique()等价的纯Python代码对比一下：另一个函数np.in1d()用于测试一个数组中的值在另一个数组中的成员资格，返回一个布尔型数组：
本文仅代表作者观点，不代表百度立场。系作者授权百家号发表，未经许可不得转载。
百家号 最近更新：
简介: 分享一些最新的新技术
作者最新文章博客访问： 1153962
博文数量： 160
博客积分： 3730
博客等级： 上尉
技术积分： 3661
注册时间：
减肥，运动，学习，进步...
IT168企业级官微
微信号：IT168qiye
系统架构师大会
微信号：SACC2013
分类： Python/Ruby
Python中函数的参数传递问题，函数参数的传递往往是一个难以理解的概念，记得在C语言中有一个经典的例子如下所示：
int swap(int a,int b)
&&&&int temp;
&&&&temp = a;
&&&&a = b;
&&&&b = temp;
&&&&return 0;
int a = 10,b = 20;
printf("Before Swap a = %d, b = %d\n",a,b);
swap(a,b);
printf("After Swap a= %d,b = %d\n",a,b);
我想这是大部分学过C语言的人都会遇到的一段代码，printf过后两个变量的值并没有发生改变，这是为什么呢？必然知道这是因为C语言的参数是采用值传递的形式，存在形参与实参的区别，也就是将实参的值复制给形参，在函数内部操作的都只是形参的内容，并不改变实参的值，所以变量在操作过后并没有发生改变。通常采用的方法是传递指针的形式，为什么传递指针又可以解决问题呢？这是因为传递的指针是指上就是一个地址值，也就是说形参和实参都指向了一段内存区域，在函数内部对内存区域的内容进行改变，这样就会影响到实参指向的内存区域，这样就实现了内存中数据的修改，进而实现数据的交换操作，这也是C语言中指针的经典操作之一。
但是到Python以后，我发现与C语言存在较大的差别，Python中万物皆对象，没有指针等特性使得我有些难以理解。Python万物皆对象的特征让我逐渐有了一定的理解。首先说明一下万物皆对象的问题。
&&& IntNum = 10
&&& Num1 = IntNum
&&& id(IntNum),id(Num1)
&&& Num2 = 10
&&& id(IntNum),id(Num1),id(Num2)
&&& intNum = 20
&&& Num1 = 30
&&& Num2 = 40
&&& id(IntNum),id(Num1),id(Num2)
这段代码主要是同id(object)判断了变量的ID号，这个ID号实质上也就表明了变量指向的对象（我这样认为的）。
IntNum&= 10，是指IntNum这个变量实质上是指向了一个int类型的对象10，同时Num1 = IntNum则表示Num1这个变量也指向10这个对象。同样Num2 = 10也表明了指向10这个int对象，可以通过id()判断。具体的实现原理是采用了一种叫做引用计数的技术完成的，这是解释器的实现，与使用者关系并不大。因此可以将左值看做变量，就如同10是对象，而IntNum就是对象的引用，是一个变量。变量赋值给变量相当于同一对象引用计数器增加1，而并不重新分配对象。
同样IntNum = 20，则是指重新分配一个对象20，让IntNum指向这个对象，这时10这个对象的引用计数器要减1，因为IntNum不在引用10这个对象啦。
前面单一元素的对象还比较容易理解，但是下面这个的对象就不一定能够理解啦。
&&& list1 = [1,2,3,4,5]
&&& list2 = [1,2,3,4,6]
&&& id(list1),id(list2)
&&& list1[4]=6
[1, 2, 3, 4, 6]
&&& id(list1),id(list2)
&&& dict1 = {'a':1,'b':2,'c':3,'d':4}
&&& dict2 = {'a':1,'b':2,'c':3,'d':5}
&&& id(dict1),id(dict2)
&&& dict1['d'] = 5
{'a': 1, 'c': 3, 'b': 2, 'd': 5}
{'a': 1, 'c': 3, 'b': 2, 'd': 5}
&&& id(dict1),id(dict2)
(, )上面的代码中我主要分析了列表和字典这两种Python中包含对对象的数据类型，我还是通过简单的id()操作判断指向的对象是否发生改变。
从结果可以看见，对于列表而言，当改变了列表中某一个局部对象后，列表的地址并没有改变，这样对象的id也就不能改变了。说明列表局部内容是可以修改的，但是列表对象的ID号(存储地址)不会发生改变。同样对于字典类型的数据也可以知道，让dict1、dict2分别指向两个字典对象，这两个字典对象的id号存在差别，当修改其中一个的内容使两个字典的内容一样，这时候判断ID，仍然是不同的，说明字典的也是可以修改的。
比如dict1['d']=5是指，原来‘d’指向的对象是4，这时候重新分配一个对象5，让‘d’指向这个对象5。这时候并不改变字典变量dict1的值(已分配字典对象的地址)。
综合上述，Python中的变量是一个对象的引用，变量于变量之间的赋值是对同一个对象的引用，当变量重新赋值对象时，指将这个变量指向一个新分配的对象。这是和C语言中的变量存在差别。但是Python中的变量有点类似C语言中的指针，指向的是一个对象，或者一段内存空间，这段内存空间的内容是可以修改的（这也是为什么对列表或者字典的某一个子对象进行修改并不改变字典或者列表的ID号），但是内存的起始地址是不能改变的，指针变量之间的赋值相当于两个指针变量指向同一块内存区域，在Python中就相当于同一个对象。因此可以认为Python中的变量相当于C语言中的指针变量。
接下来分析函数中的参数传递问题：由于在Python中函数的参数传递是值传递，同时也存在局部和全局的问题，这和C语言中的函数也存在一定的相似性。
函数的定义形式如下：
def function(args):
&&&&function_block
参数传递过程中存在两个规则：
1、通过引用将参数复制到局部作用域的对象中，意味着被用来访问函数参数的变量于提高给函数的对象无关，因为存在一个复制问题，这和C语言是相同的。而且修改局部对象不会改变原始数据。
2、可以在适当位置修改可变对象。可变对象主要就是列表和字典，这个适当位置实质上就是前面分析的局部子对象的修改不会改变字典对象或者列表对象的ID，也就是存储位置（这是我暂且这么称呼吧）。
通过两个实例说明，第一个还是交换问题：
&&& def modifier(number,string,list):
&&&&number = 5
&&&&string = 'GoodBye'
&&&&list = [4,5,6]
&&&&print "Inside:", number,string,list
&&& num = 10
&&& string = 'Hello'
&&& list = [1,2,3]
&&& print 'Before:', num, string, list
Before: 10 Hello [1, 2, 3]
&&& modifier(num,string,list)
Inside: 5 GoodBye [4, 5, 6]
&&& print 'After:', num, string, list
After: 10 Hello [1, 2, 3]
从上面的结果可以看出来数据交换前后数据并没有发生改变，虽然在函数局部区域对传递进来的参数进行了相应的修改，但是仍然不能改变实参对象的内容。这和C语言中的操作非常相似，因为传递进来的三个指针在函数内部进行了相关的修改，相当于三个指针分别指向了不同的对象（存储区域），但是这三个指针都是局部指针并不改变实际的指针，所以交换前后实参指向的对象并没有发生改变。说明如果在函数内部对参数重新赋值新的对象，这并不会改变实参的对象。这就是函数的第一个规则。
对于不可变的对象，是不可能进行修改的，但是对于可变的对象（字典、列表），局部区域的值倒是可以改变的，这和前面分析的一样，看以参看下面的例子。
&&& def modifier(list,dict):
&&&&list[0] = 10
&&&&dict['a'] = 10
&&&&print 'Inside list = %s, dict = %s' %(list,dict)
&&& dict = {'a':1,'b':2,'c':3}
&&& list = [1,2,3,4,5]
&&& print 'Before list = %s, dict = %s' %(list,dict)
Before list = [1, 2, 3, 4, 5], dict = {'a': 1, 'c': 3, 'b': 2}
&&& modifier(list,dict)
Inside list = [10, 2, 3, 4, 5], dict = {'a': 10, 'c': 3, 'b': 2}
&&& print 'After list = %s, dict = %s' %(list,dict)
After list = [10, 2, 3, 4, 5], dict = {'a': 10, 'c': 3, 'b': 2}
从上面的结果可以看出来，在函数内部修改列表、字典的局部对象或者说没有对传递进来的列表、字典变量重新赋值对象，而是修改变量的局部内容，这时候就会导致外部实参指向对象内容的修改，这就相当于在C语言中对指针指向的内存区域进行修改，这样的修改必然会导致实参指向区域内容的改变。这是函数规则的第二条，适当的位置指的是对对象进行修改，而不是重现分配一个对象，重现分配一个对象不会影响实参，而对对象的修改必然影响实参。
在C语言中返回多对象时必然会引入指针的操作，因为对指针的修改实质上会反映到实参，这样就实现了数据的返回操作。而在Python中采用元组的形式返回多个值。但是知道了函数参数的传递特性，我们完全可以采用函数的参数实现一些基本的操作，就比如刚开始讨论的交换问题，如下所示：
&&& def swap(list):
&&&&temp = list[0]
&&&&list[0] = list[1]
&&&&list[1] = temp
&&& list = [10,20]
&&& swap(list)
从上面的实验结果可知实现了数据的交换问题，这仅仅是为了说明利用参数计算的一些可能性，在实际中怎么运用我也是新手。
阅读(22957) | 评论(0) | 转发(1) |
相关热门文章
给主人留下些什么吧！~~
请登录后评论。