Python自定义函数的创建、调用和函数的参数详解
转载 & & 作者：
这篇文章主要介绍了Python自定义函数的创建、调用和函数的参数、变量作用域等常见问题,需要的朋友可以参考下
函数是组织好的，可重复使用的，用来实现单一，或相关联功能的代码段。函数能提高应用的模块性，和代码的重复利用率。你已经知道Python提供了许多内建函数，比如print()。但你也可以自己创见函数，这被叫做用户自定义函数。一、定义一个函数你可以定义一个由自己想要功能的函数，以下是简单的规则：
1.函数代码块以def关键词开头，后接函数标识符名称和圆括号()。2.任何传入参数和自变量必须放在圆括号中间。圆括号之间可以用于定义参数。3.函数的第一行语句可以选择性地使用文档字符串—用于存放函数说明。4.函数内容以冒号起始，并且缩进。5.Return[expression]结束函数，选择性地返回一个值给调用方。不带表达式的return相当于返回 None。
语法 代码如下:def functionname( parameters ):&& "函数_文档字符串"&& function_suite&& return [expression]默认情况下，参数值和参数名称是按函数声明中定义的的顺序匹配起来的。
以下为一个简单的Python函数，它将一个字符串作为传入参数，再打印到标准显示设备上。 代码如下:def printme( str ):&& "打印传入的字符串到标准显示设备上"&& print str&& return
二、函数调用定义一个函数只给了函数一个名称，指定了函数里包含的参数，和代码块结构。这个函数的基本结构完成以后，你可以通过另一个函数调用执行，也可以直接从Python提示符执行。
如下实例调用了printme（）函数： 代码如下:#!/usr/bin/python# Function definition is heredef printme( str ):&& "打印任何传入的字符串"&&&&# Now you can call printme functionprintme("我要调用用户自定义函数!");printme("再次调用同一函数");#以上实例输出结果：
#我要调用用户自定义函数!#再次调用同一函数
三、按值传递参数和按引用传递参数所有参数（自变量）在Python里都是按引用传递。如果你在函数里修改了参数，那么在调用这个函数的函数里，原始的参数也被改变了。例如： 代码如下:#!/usr/bin/python# 可写函数说明def changeme( mylist ):&& "修改传入的列表"&& mylist.append([1,2,3,4]);&& print "函数内取值: ", mylist&& return# 调用changeme函数mylist = [10,20,30];changeme( mylist );print "函数外取值: ", mylist#传入函数的和在末尾添加新内容的对象用的是同一个引用。故输出结果如下：
#函数内取值:& [10, 20, 30, [1, 2, 3, 4]]#函数外取值:& [10, 20, 30, [1, 2, 3, 4]]
四、函数的参数Python函数可以使用的参数类型：
1.必备参数2.命名参数3.缺省参数4.不定长参数
1、必备参数
必备参数须以正确的顺序传入函数。调用时的数量必须和声明时的一样。调用printme()函数，你必须传入一个参数，不然会出现语法错误： 代码如下:#!/usr/bin/python#可写函数说明def printme( str ):&& "打印任何传入的字符串"&&&&#调用printme函数printme();#以上实例输出结果：
#Traceback (most recent call last):#& File "test.py", line 11, in &module&#&&& printme();#TypeError: printme() takes exactly 1 argument (0 given)
2、命名参数
命名参数和函数调用关系紧密，调用方用参数的命名确定传入的参数值。你可以跳过不传的参数或者乱序传参，因为Python解释器能够用参数名匹配参数值。用命名参数调用printme()函数： 代码如下:#!/usr/bin/python#可写函数说明def printme( str ):&& "打印任何传入的字符串"&&&&#调用printme函数printme( str = "My string");#以上实例输出结果：
#My string下例能将命名参数顺序不重要展示得更清楚： 代码如下:#!/usr/bin/python#可写函数说明def printinfo( name, age ):&& "打印任何传入的字符串"&& print "Name: ",&& print "Age ",&&#调用printinfo函数printinfo( age=50, name="miki" );#以上实例输出结果：
#Name:& miki#Age& 50
3、缺省参数
调用函数时，缺省参数的值如果没有传入，则被认为是默认值。下例会打印默认的age，如果age没有被传入： 代码如下:#!/usr/bin/python#可写函数说明def printinfo( name, age = 35 ):&& "打印任何传入的字符串"&& print "Name: ",&& print "Age ",&&#调用printinfo函数printinfo( age=50, name="miki" );printinfo( name="miki" );#以上实例输出结果：
#Name:& miki#Age& 50#Name:& miki#Age& 35
4、不定长参数
你可能需要一个函数能处理比当初声明时更多的参数。这些参数叫做不定长参数，和上述2种参数不同，声明时不会命名。基本语法如下： 代码如下:def functionname([formal_args,] *var_args_tuple ):&& "函数_文档字符串"&& function_suite&& return [expression]加了星号（*）的变量名会存放所有未命名的变量参数。选择不多传参数也可。如下实例： 代码如下:#!/usr/bin/python# 可写函数说明def printinfo( arg1, *vartuple ):&& "打印任何传入的参数"&& print "输出: "&& print arg1&& for var in vartuple:&&&&& print var&&# 调用printinfo 函数printinfo( 10 );printinfo( 70, 60, 50 );#以上实例输出结果：
#输出:#10#输出:#70#60#50
五、匿名函数用lambda关键词能创建小型匿名函数。这种函数得名于省略了用def声明函数的标准步骤。
Lambda函数能接收任何数量的参数但只能返回一个表达式的值，同时只能不能包含命令或多个表达式。匿名函数不能直接调用print，因为lambda需要一个表达式。lambda函数拥有自己的名字空间，且不能访问自有参数列表之外或全局名字空间里的参数。虽然lambda函数看起来只能写一行，却不等同于C或C++的内联函数，后者的目的是调用小函数时不占用栈内存从而增加运行效率。语法
lambda函数的语法只包含一个语句，如下： 代码如下:lambda [arg1 [,arg2,.....argn]]:expression如下实例： 代码如下:#!/usr/bin/python#可写函数说明sum = lambda arg1, arg2: arg1 + arg2;#调用sum函数print "Value of total : ", sum( 10, 20 )print "Value of total : ", sum( 20, 20 )#以上实例输出结果：
#Value of total :& 30#Value of total :& 40
六、关于return语句return语句[表达式]退出函数，选择性地向调用方返回一个表达式。不带参数值的return语句返回None。之前的例子都没有示范如何返回数值，下例便告诉你怎么做： 代码如下:#!/usr/bin/python# 可写函数说明def sum( arg1, arg2 ):&& # 返回2个参数的和."&& total = arg1 + arg2&& print "Inside the function : ", total&&# 调用sum函数total = sum( 10, 20 );print "Outside the function : ", total #以上实例输出结果：
#Inside the function :& 30#Outside the function :& 30
七、变量作用域一个程序的所有的变量并不是在哪个位置都可以访问的。访问权限决定于这个变量是在哪里赋值的。
变量的作用域决定了在哪一部分程序你可以访问哪个特定的变量名称。两种最基本的变量作用域如下：1.全局变量2.局部变量
八、变量和局部变量定义在函数内部的变量拥有一个局部作用域，定义在函数外的拥有全局作用域。
局部变量只能在其被声明的函数内部访问，而全局变量可以在整个程序范围内访问。调用函数时，所有在函数内声明的变量名称都将被加入到作用域中。如下实例： 代码如下:#!/usr/bin/pythontotal = 0; # This is global variable.# 可写函数说明def sum( arg1, arg2 ):&& #返回2个参数的和."&& total = arg1 + arg2; # total在这里是局部变量.&& print "Inside the function local total : ", total&&#调用sum函数sum( 10, 20 );print "Outside the function global total : ", total #以上实例输出结果：
#Inside the function local total :& 30#Outside the function global total :& 0
您可能感兴趣的文章:
大家感兴趣的内容
12345678910
最近更新的内容
常用在线小工具为什么Python编程时要自己定义函数再用？ - 知乎8被浏览311分享邀请回答url = r"http://elder.com/query.json?&question=tooyoung
jsonStr = urllib.request.urlopen(url).read().decode("utf-8")
data = json.loads(jsonStr)
answer = data["eldertellyou"]
过了一会儿，有另一个question需要查询怎么办呢？把上面的代码再写一遍？复制过来？假设我们姿势水平不够高，经常查询不同的question，复制粘贴了一百遍，分散在每个文件中。每次都要打开原文件来复制粘贴也真是够麻烦的。这是其一更可怕的是，有一天我们发现这段解析的代码需要改进，比如把「啊」、「呀」、「吼啊」这种语气词全截掉。这时你需要打开每一个文件，把粘贴这段代码的每一个地方都挨个修改一次，工作量大又容易犯错。这是其二但是有些人身经百战，这种情况见得多了，一开始就把它写成一个函数，供程序调用。每次调用只需要一行代码，是不是比你写N行或者复制N行高多了？修改起来也非常方便 ，改一个地方就搞定。我不是编程工作者，见得也不多，只看过Java和Python相关的入门书籍，里面讲到面向对象编程的时候，都把这些基础姿势讲清楚了。还是要认真看书学习一个。1添加评论分享收藏感谢收起0添加评论分享收藏感谢收起Python 里为什么函数可以返回一个函数内部定义的函数？ - 知乎602被浏览<strong class="NumberBoard-itemValue" title="5分享邀请回答alist = [1, 2, 3]
时，你就创建了一个列表对象，并且用alist这个变量引用它：当然你也可以自己定义一个类:class House(object):
def __init__(self, area, city):
self.area = area
self.city = city
def sell(self, price):
#other code
return price
然后创建一个类的对象：house = House(200, 'Shanghai')
OK，你立马就在上海有了一套200平米的房子，它有一些属性(area, city)，和一些方法(__init__, self)：2. 函数是第一类对象和list, tuple, dict以及用House创建的对象一样，当你定义一个函数时，函数也是对象：def func(a, b):
return a+b
在全局域，函数对象被函数名引用着，它接收两个参数a和b，计算这两个参数的和作为返回值。所谓第一类对象，意思是可以用标识符给对象命名，并且对象可以被当作数据处理，例如赋值、作为参数传递给函数，或者作为返回值return 等因此，你完全可以用其他变量名引用这个函数对象：add = func
这样，你就可以像调用func(1, 2)一样，通过新的引用调用函数了：print func(1, 2)
print add(1, 2)
#the same as func(1, 2)
或者将函数对象作为参数，传递给另一个函数：def caller_func(f):
return f(1, 2)
if __name__ == "__main__":
print caller_func(func)
可以看到，函数对象func作为参数传递给caller_func函数，传参过程类似于一个赋值操作f=func；于是func函数对象，被caller_func函数作用域中的局部变量f引用，f实际指向了函数func；cc当执行return f(1, 2)的时候，相当于执行了return func(1, 2)；因此输出结果为3。3. 函数对象 vs 函数调用无论是把函数赋值给新的标识符，还是作为参数传递给新的函数，针对的都是函数对象本身，而不是函数的调用。用一个更加简单，但从外观上看，更容易产生混淆的例子来说明这个问题。例如定义了下面这个函数：def func():
return "hello,world"
然后分别执行两次赋值：ref1 = func
#将函数对象赋值给ref1
ref2 = func()
#调用函数，将函数的返回值("hello,world"字符串)赋值给ref2
很多初学者会混淆这两种赋值，通过Python内建的type函数，可以查看一下这两次赋值的结果：In [4]: type(ref1)
Out[4]: function
In [5]: type(ref2)
Out[5]: str
可以看到，ref1引用了函数对象本身，而ref2则引用了函数的返回值。通过内建的callable函数，可以进一步验证ref1是可调用的，而ref2是不可调用的：In [9]: callable(ref1)
Out[9]: True
In [10]: callable(ref2)
Out[10]: False
传参的效果与之类似。4. 闭包&LEGB法则所谓闭包，就是将组成函数的语句和这些语句的执行环境打包在一起时，得到的对象听上去的确有些复杂，还是用一个栗子来帮助理解一下。假设我们在foo.py模块中做了如下定义：#foo.py
filename = "foo.py"
def call_func(f):
return f()
#如前面介绍的，f引用一个函数对象，然后调用它
在另一个func.py模块中，写下了这样的代码：#func.py
import foo
#导入foo.py
filename = "func.py"
def show_filename():
return "filename: %s" % filename
if __name__ == "__main__":
print foo.call_func(show_filename)
#注意：实际发生调用的位置，是在foo.call_func函数中
当我们用python func.py命令执行func.py时输出结果为：chiyu@chiyu-PC:~$ python func.py
filename:func.py
很显然show_filename()函数使用的filename变量的值，是在与它相同环境(func.py模块)中定义的那个。尽管foo.py模块中也定义了同名的filename变量，而且实际调用show_filename的位置也是在foo.py的call_func内部。而对于嵌套函数，这一机制则会表现的更加明显：闭包将会捕捉内层函数执行所需的整个环境：#enclosed.py
import foo
def wrapper():
filename = "enclosed.py"
def show_filename():
return "filename: %s" % filename
print foo.call_func(show_filename)
#输出：filename: enclosed.py
实际上，每一个函数对象，都有一个指向了该函数定义时所在全局名称空间的__globals__属性：#show_filename inside wrapper
#show_filename.__globals__
'__builtins__': &module '__builtin__' (built-in)&,
#内建作用域环境
'__file__': 'enclosed.py',
'wrapper': &function wrapper at 0x7f&,
#直接外围环境
'__package__': None,
'__name__': '__main__',
'foo': &module 'foo' from '/home/chiyu/foo.pyc'&,
'__doc__': None
当代码执行到show_filename中的return "filename: %s" % filename语句时，解析器按照下面的顺序查找filename变量：Local - 本地函数(show_filename)内部，通过任何方式赋值的，而且没有被global关键字声明为全局变量的filename变量；Enclosing - 直接外围空间(上层函数wrapper)的本地作用域，查找filename变量(如果有多层嵌套，则由内而外逐层查找，直至最外层的函数)；Global - 全局空间(模块enclosed.py)，在模块顶层赋值的filename变量；Builtin - 内置模块(__builtin__)中预定义的变量名中查找filename变量；在任何一层先找到了符合要求的filename变量，则不再向更外层查找。如果直到Builtin层仍然没有找到符合要求的变量，则抛出NameError异常。这就是变量名解析的：LEGB法则。总结：闭包最重要的使用价值在于：封存函数执行的上下文环境；闭包在其捕捉的执行环境(def语句块所在上下文)中，也遵循LEGB规则逐层查找，直至找到符合要求的变量，或者抛出异常。5. 装饰器&语法糖(syntax sugar)那么闭包和装饰器又有什么关系呢？上文提到闭包的重要特性：封存上下文，这一特性可以巧妙的被用于现有函数的包装，从而为现有函数更加功能。而这就是装饰器。还是举个例子，代码如下：#alist = [1, 2, 3, ..., 100]
--& 1+2+3+...+100 = 5050
def lazy_sum():
return reduce(lambda x, y: x+y, alist)
我们定义了一个函数lazy_sum，作用是对alist中的所有元素求和后返回。alist假设为1到100的整数列表：alist = range(1, 101)
但是出于某种原因，我并不想马上返回计算结果，而是在之后的某个地方，通过显示的调用输出结果。于是我用一个wrapper函数对其进行包装：def wrapper():
alist = range(1, 101)
def lazy_sum():
return reduce(lambda x, y: x+y, alist)
return lazy_sum
lazy_sum = wrapper()
#wrapper() 返回的是lazy_sum函数对象
if __name__
== "__main__":
lazy_sum()
这是一个典型的Lazy Evaluation的例子。我们知道，一般情况下，局部变量在函数返回时，就会被垃圾回收器回收，而不能再被使用。但是这里的alist却没有，它随着lazy_sum函数对象的返回被一并返回了(这个说法不准确，实际是包含在了lazy_sum的执行环境中，通过__globals__)，从而延长了生命周期。当在if语句块中调用lazy_sum()的时候，解析器会从上下文中(这里是Enclosing层的wrapper函数的局部作用域中)找到alist列表，计算结果，返回5050。当你需要动态的给已定义的函数增加功能时，比如：参数检查，类似的原理就变得很有用：def add(a, b):
return a+b
这是很简单的一个函数：计算a+b的和返回，但我们知道Python是 动态类型+强类型 的语言，你并不能保证用户传入的参数a和b一定是两个整型，他有可能传入了一个整型和一个字符串类型的值：In [2]: add(1, 2)
In [3]: add(1.2, 3.45)
Out[3]: 4.65
In [4]: add(5, 'hello')
---------------------------------------------------------------------------
Traceback (most recent call last)
/home/chiyu/&ipython-input-4-f2f9e8aa5eae& in &module&()
----& 1 add(5, 'hello')
/home/chiyu/&ipython-input-1-02b3d3d6caec& in add(a, b)
1 def add(a, b):
return a+b
TypeError: unsupported operand type(s) for +: 'int' and 'str'
于是，解析器无情的抛出了一个TypeError异常。动态类型：在运行期间确定变量的类型，python确定一个变量的类型是在你第一次给他赋值的时候；强类型：有强制的类型定义，你有一个整数，除非显示的类型转换，否则绝不能将它当作一个字符串(例如直接尝试将一个整型和一个字符串做+运算)；因此，为了更加优雅的使用add函数，我们需要在执行+运算前，对a和b进行参数检查。这时候装饰器就显得非常有用：import logging
logging.basicConfig(level = logging.INFO)
def add(a, b):
return a + b
def checkParams(fn):
def wrapper(a, b):
if isinstance(a, (int, float)) and isinstance(b, (int, float)):
#检查参数a和b是否都为整型或浮点型
return fn(a, b)
#是则调用fn(a, b)返回计算结果
#否则通过logging记录错误信息，并友好退出
logging.warning("variable 'a' and 'b' cannot be added")
return wrapper
#fn引用add，被封存在闭包的执行环境中返回
if __name__ == "__main__":
#将add函数对象传入，fn指向add
#等号左侧的add，指向checkParams的返回值wrapper
add = checkParams(add)
add(3, 'hello')
#经过类型检查，不会计算结果，而是记录日志并退出
注意checkParams函数：首先看参数fn，当我们调用checkParams(add)的时候，它将成为函数对象add的一个本地(Local)引用；在checkParams内部，我们定义了一个wrapper函数，添加了参数类型检查的功能，然后调用了fn(a, b)，根据LEGB法则，解释器将搜索几个作用域，并最终在(Enclosing层)checkParams函数的本地作用域中找到fn；注意最后的return wrapper，这将创建一个闭包，fn变量(add函数对象的一个引用)将会封存在闭包的执行环境中，不会随着checkParams的返回而被回收；当调用add = checkParams(add)时，add指向了新的wrapper对象，它添加了参数检查和记录日志的功能，同时又能够通过封存的fn，继续调用原始的add进行+运算。因此调用add(3, 'hello')将不会返回计算结果，而是打印出日志：chiyu@chiyu-PC:~$ python func.py
WARNING:root:variable 'a' and 'b' cannot be added
有人觉得add = checkParams(add)这样的写法未免太过麻烦，于是python提供了一种更优雅的写法，被称为语法糖：@checkParams
def add(a, b):
return a + b
这只是一种写法上的优化，解释器仍然会将它转化为add = checkParams(add)来执行。6. 回归问题def addspam(fn):
def new(*args):
print "spam,spam,spam"
return fn(*args)
return new
def useful(a,b):
print a**2+b**2
首先看第二段代码：@addspam装饰器，相当于执行了useful = addspam(useful)。在这里题主有一个理解误区：传递给addspam的参数，是useful这个函数对象本身，而不是它的一个调用结果；再回到addspam函数体：return new 返回一个闭包，fn被封存在闭包的执行环境中，不会随着addspam函数的返回被回收；而fn此时是useful的一个引用，当执行return fn(*args)时，实际相当于执行了return useful(*args)；最后附上一张代码执行过程中的引用关系图，希望能帮助你理解：80265 条评论分享收藏感谢收起9添加评论分享收藏感谢收起Python 编程，应该养成哪些好的习惯？ - 知乎<strong class="NumberBoard-itemValue" title="被浏览<strong class="NumberBoard-itemValue" title="8分享邀请回答weixin.qq.com/r/D0zH35LE_s_Frda89xkd (二维码自动识别)11913 条评论分享收藏感谢收起34955 条评论分享收藏感谢收起}