Python自定义函数

python系统中自带的一些函数就叫做内建函数，比如：dir()、type()等等，不需要我们自己编写。

还有一种是第三方函数，就是其它程序员编好的一些函数，共享给大家使用。

内建函数和第三方函数这两种都是拿来就可以直接使用的。

那么我们自己编写的方便自己工作学习用的函数，就叫做自定义函数了。

 

一、自定义函数

使用函数可以降低编程难度，通常将一个复杂的大问题分解成一系列的小问题，也避免重复劳作，提高效率。

函数的定义和调用：

In [2]: def fun(): # 定义
...: print("Hello World")
...:

In [3]: fun() # 调用
Hello World

在自定义函数过程中，需要注意以下事项。
1、def开头，代表定义函数
2、def和函数名中间要敲一个空格
3、之后是函数名，这个名字用户自己起的，方便自己使用就好
4、函数名后跟圆括号()，代表定义的是函数，里边可加参数
5、圆括号()后一定要加冒号: 这个很重要，不要忘记了
6、代码块部分，是由语句组成，要有缩进
7、函数要有返回值return

我们通过一个例子来了解自定义函数。

#!/usr/local/python3/bin/python

def fun():
sth=input("Please input something : ")
'''判断变量是否为纯数字'''
try: # 捕获异常
if type(int(sth)) ==type(1): # 如果满足条件
print("{} is a number.".format(sth))
except ValueError: # 只有try捕获异常，出现错误时，才知晓except的内容
print("{} is not a number.".format(sth))

fun() # 在未调用定义的函数之前，该脚本是不会运行并返回相应的值的

 

二、函数参数

刚刚我们定义的函数是没有添加任何参数的，现在我们试着将函数加上参数。

函数可以分为形式参数和实际参数。

在定义函数时，函数名后面括号中的变量名称叫做“形式参数”，简称“形参”。

在调用函数时，函数名后面括号中的变量名称叫做“实际参数”，简称“实参”。

形式参数可以通过以下类型来调用函数 -

• 必需参数
• 关键字参数
• 默认参数
• 可变长度参数

2.1 必需参数

我们试着定义一个带参数的函数。

In [7]: def fun(x,y):
...: print(x+y)
...:

当我们直接调用这个函数时，不输入参数直接调用函数是不行的，会出现如下情况。

In [8]: fun()
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-8-69e6a439c52d> in <module>()
----> 1 fun()

TypeError: fun() takes exactly 2 arguments (0 given)

多添加参数或者少添加参数也都是不成功的。

In [10]: fun(1,3,3)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-10-1bfd7224bcad> in <module>()
----> 1 fun(1,3,3)

TypeError: fun() takes exactly 2 arguments (3 given)


In [11]: fun(1)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-11-aa8e3633d0ce> in <module>()
----> 1 fun(1)

TypeError: fun() takes exactly 2 arguments (1 given)

我们需要给定函数的两个参数，对应 x 值与 y 值，则会得到函数该有的结果。

In [9]: fun(1,3)
4

如果我们现在想要获取脚本的参数，应该怎样做呢？我们可以使用“sys.argv”来获取参数。

[root@izj6cdhdoq5a5z7lfkmaeaz ~]# cat numfun.py
#!/usr/local/python3/bin/python
import sys

print(sys.argv)

这样我们就能看到传入的参数被输出成一个列表，如果我们想要取得传入的某个参数的值的话，就可以使用如下表示。

[root@izj6cdhdoq5a5z7lfkmaeaz ~]# cat numfun.py
#!/usr/local/python3/bin/python
import sys
print(sys.argv[1]) # 获取下标为1的参数值

[root@izj6cdhdoq5a5z7lfkmaeaz ~]# python numfun.py 1 2
1

一般我们定义一个函数都采用第二个英文词首字母大写的格式，如下所示。

[root@izj6cdhdoq5a5z7lfkmaeaz ~]# cat numfun.py
#!/usr/local/python3/bin/python
import sys

def isNum(s): # 定义一个参数
for i in s:
if i in '0123456789':
pass
else:
print("{} is not a number.".format(s))
sys.exit() # 不是数字就可以退出
else:
print("{} is a number.".format(s))

isNum(sys.argv[1])

这样我们运行之后返回的结果如下。

[root@izj6cdhdoq5a5z7lfkmaeaz ~]# python numfun.py 1123
1123 is a number.

[root@izj6cdhdoq5a5z7lfkmaeaz ~]# python numfun.py weqe
weqe is not a number.

 

2.2 关键字参数

关键字参数与函数调用有关。 在函数调用中使用关键字参数时，调用者通过参数名称来标识参数。

这允许跳过参数或将其置于无序状态，因为Python解释器能够使用提供的关键字将值与参数进行匹配。还可以通过以下方式对 printme( ) 函数进行关键字调用。

#!/usr/bin/python3
#coding=utf-8

# Function definition is here
def printme( str ):
"This prints a passed string into this function"
print (str)
return

# Now you can call printme function
printme( str = "My string")

执行以上代码会直接返回结果。

My string

 

2.3 默认参数

如果在该参数的函数调用中没有提供值，则默认参数是一个假设为默认值的参数。 

如果我们定义两个参数，一个是可变的，一个是不变的，如下所示。

In [14]: def fun(x,y=100): #定义形参
....: print(x+y)
....:

当我们传入两个参数时，该函数输出值为两参数相加的和，当只传入一个参数时，那么则与默认的参数相加得出和，如下所示。

In [15]: fun(2,3)
5

In [16]: fun(2)
102

如果我们直接定义形参，不传入任何值时，也会直接运行默认的形参值。

In [17]: def fun(x=200,y=100):
print(x+y)
....:

In [18]: fun()
300

 

2.4 可变长度参数

在定义函数时，可能需要处理更多参数的函数。这些参数被称为可变长度参数，并且不像要求的和默认的参数那样在函数定义中命名。

具有非关键字变量参数的函数的语法如下：

def functionname([formal_args,] *var_args_tuple ):
"function_docstring"
function_suite
return [expression]

星号 (*) 放在保存所有非关键字变量参数值的变量名之前。 如果在函数调用期间没有指定额外的参数，则此元组保持为空。以下是一个简单的例子 -

#!/usr/bin/python3
#coding=utf-8

# Function definition is here
def printinfo( arg1, *vartuple ):
"This prints a variable passed arguments"
print ("Output is: ", arg1)
for var in vartuple:
print (var, )
return

# Now you can call printinfo function
printinfo( 10 )
printinfo( 70, 60, 50 )

在执行以上代码后，会得到如下结果。

Output is: 10
Output is: 70
60
50

 

三、匿名函数

这些函数被称为匿名的，因为它们没有使用 def 关键字以标准方式声明。可以使用 lambda 关键字创建小型匿名函数。

lambda 表单可以接受任意数量的参数，但只能以表达式的形式返回一个值。它们不能包含命令或多个表达式。

匿名函数不能直接调用打印，因为 lambda 需要一个表达式。

lambda 函数有自己的本地命名空间，不能访问其参数列表和全局命名空间中的变量。

虽然 lambdas 是一个单行版本的函数，但它们并不等同于C 或 C++ 中的内联语句，其目的是通过传递函数来进行堆栈分配。

我们定义一个简单的函数可以使用如下所示的脚本。

In [14]: def fun(x,y):
....: return x*y
....:

In [15]: fun(2,3)
Out[15]: 6

但是我们使用匿名函数的话，就会变得更加简洁。

In [17]: r=lambda x,y:x*y

In [18]: r(2,3)
Out[18]: 6

使用匿名函数有很多优点，例如：

1、使用Python写一些脚本时，使用lambda可以省去定义函数的过程，让代码更加精简

2、对于一些抽象的，不会被别的地方再重复使用的函数，有时候很难给函数命名，使用lambda则不需要考虑命名的问题

3、使用lambda在某些时候能让代码更容易理解

 

lambda语句中，冒号前是参数，可以有很多个，逗号隔开，冒号右边则是返回值。

lambda语句构建的其实是一个函数对象。

 

我们也可以使用“reduce”来直接在函数加入参数，下面两张表示方法都能实现1到100相加的和，但是下面第二种方法看上去更加简洁。

In [20]: def add(x,y):
....: return(x+y)
....:
In [21]: reduce(add,range(1,101))
Out[21]: 5050



In [26]: reduce(lambda x, y:x+y, range(1,101))
Out[26]: 5050

我们也可以来实现1到5的阶乘，如下所示：

In [27]: reduce(lambda x, y:x*y, range(1,6))
Out[27]: 120

In [28]: 5*4*3*2*1
Out[28]: 120

 

return [expression] 语句退出一个函数，可选地将一个表达式传回给调用者。没有参数的return语句与return None相同。

 

参考资料：

1. ​​http://www.iplaypy.com/jichu/function.html​​

2. ​​http://www.runoob.com/python3/python3-function.html​​