python——自定义函数

一、概述

在编写脚本的过程中，对于要重复完成的工作，我们可以提取出来，将其编写为函数，在脚本中使用时，调用即可，在python中，函数必须先声明，然后才能在脚本中使用。使用函数时，只要按照函数定义形式向函数传递必须的参数，就可以调用函数完成所需的功能。

二、自定义函数

2.1 函数声明、调用

在python中使用def可以声明一个函数。完整的函数是由函数名、参数以及函数实现语句组成的，在函数中也用缩进来表示语句属于函数体。
如果函数有返回值，那么需要在函数中使用return语句返回计算结果，声明函数形式一般如下:

de f<函数名>  (参数列表)：
     <函数语句>
     return <返回值>
# 其中参数和返回值不是必须的

简单示例

代码：
def hi ():    #定义一个hi（）函数，这里没有参数，但是需要写一对圆括号。
    print('hello,word !')
    
hi()   #调用函数
print(hi）  # 返回函数在内存中的地址
执行结果：
hello,word !
<function hi at 0x0390F7C8>

以下是一个完整的函数，实现了求一个列表所有整数之和的功能，其中L为所要求和的列表，result是列表中所有整数的和，最后使用return将result的值返回。

代码：
def ListSum(L):
    result = 0
    for i in L:
        result = result + i
    return result

List = [ 1, 2, 3,4 ]
Sum = ListSum( List )
print( Sum )

执行结果：
10

Python的函数比较灵活。与C语言中函数的声明相比，在Python中声明一个函数时，不需要声明函数类型，也不需要声明参数的类型。Python 在实际调用函数的过程中也非常灵活，不需要为不同类型的参数声明多个函数，或在处理不同类型数据的时候调用相应的函数。大部分情况下都可以用同一个函数调用不同的数据类型。

如下所示的函数，其功能是打印参数对象中的所有成员：

代码：
def PrintAll(x):
    for i in x:
        print(i)
        
l = [1, 2, 3, 4]   # 列表
PrintAll(l)
t = ('a', 'b', 'c')   # 元组
PrintAll(t)
d = {'tom': 1, 'anni': 2, 'susi': 3 }   # 字典
PrintAll(d)
执行结果：
1
2
3
4
a
b
c
tom
anni
susi

2.2 参数让函数更有价值

2.2.1 有默认值的参数

在python中，可以在声明函数的时候，预先为参数设置一个默认值。当调用函数时，如果某个参数具有默认值，则可以不向这个函数传递参数，这时，函数将使用事先声明默认的参数值。

def <函数名> (参数 = 默认值):
	 <语句>

以下代码声明了一个函数，用来计算参数的立方值，默认参数为5

代码：
def Cube ( x = 5 ):
    return x ** 3
print(Cube())    # 为传递参数
print(Cube(2))  # 参数为2

执行结果：
125
8

如果一个函数有多个参数，均声明的默认值，在传递参数时仅想向最后一个传递。

代码：
def Cube ( x = 1, y = 2, c = 3 ):
    return x * y +c
print(Cube())         # 结果为5
print(Cube(2))        # 结果为7，传递的是第一个参数
print(Cube(2,3))	  #结果为9传递的第一二个参数
print(Cube( , , 5))   #这样执行结果是错的

这里我们要换一种函数定义的方式

代码：
def Cube ( x , y , c  ):
    if x == None:
        x = 1
    if y == None:
        y = 2
    if c == None:
        c = 3
    return x * y + c

print(Cube(None,None ,4))   # 加入判断

执行结果：
6

2.2.2 参数传递方式

    在Python中，参数值的传递不只是按照声明函数时参数的顺序进行传递的，实际上，Python还提供了另外一种传递参数的方法一按照参 数名传递值。以参数名传递参数时类似于设置参数的默认值。
    使用按参数名传递参数的方式调用函数时,要在调用函数名后的圆括号里为函数的所有参数赋值，赋值的顺序不必按照函数声明时的参数顺序，

代码：
def Cube ( x , y , c  ):
    if x == None:
        x = 1
    if y == None:
        y = 2
    if c == None:
        c = 3
    return x * y + c

print(Cube(y=3,c=3,x=3))   #赋值实现
执行结果：
12

  在python中也可以同时使用按参数顺序传递与按参数名传递两种方式，但是需要注意的是，按顺序传递参数，要位于按参数名传递参数之前，而且不能有重复的情况，否则发生错误。

在有默认参数值的情况下，使用按参数名传递参数十分方便，上面的例子，我们就可以直接用参数名传递。

代码：
def Cube ( x = 1, y = 2, c = 3 ):
    return x * y + c
print (Cube(c=5) )   # 这里x与y使用默认值，c重新被传值
执行结果：
7

2.2.3 传递任意数量的值

在Python中，函数可以具有任意个参数，而不必在声明函数时对所有参数进行定义。使用可变长参数的函数时，其所有参数都保存在一个元组里， 在函数中可以使用for循环来处理。声明函数时，如果在参数名前加上一个星号“*"，则表示该参数是一个可变长参数

代码：
def mylistappend(*list):
    l = []
    for i in list:
        l.extend(i)
    return l

a = [ 1, 2, 3]
b = [ 4, 5, 6]
c = [ 7, 8, 9]
x = mylistappend(a)
y = mylistappend(a,b)
z = mylistappend(a,b,c)
print(x)
print(y)
print(z)
执行结果：
[1, 2, 3]
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

2.2.4 用参数返回计算结果

在C语言中，可以通过在参数中使用指针来达到改变参数值的作用，从而/达到从函数中返回结果的目的。其实，在Python中，还有更简单的实现方法，即在参数中使用可变对象(如列表等),使函数中的结果返回到参数中，从而达到从函数中返回计算结果的目的```

代码：
def ChangeValue1(x):
    x = x + 1
def ChangeValue2(x):
    x[0] = x[0] + 2
a = 1
b = [2]
c = ChangeValue1(a)    
d = ChangeValue2(b)
for i in (a,b,c,d):
    print(i)
执行结果：
1           # a的值为改变，因为a为不可变对象
[4]         # b的值被改变           
None        # 函数未设返回值，所以为空。
None

三、变量的作用域

   在python中，不同的函数可以具有相同的参数名，在函数中已经声明过的函数名，在函数之外也可以使用，而在脚本运行过程中其值并不影响。

代码：
def fun1(x):
    a = [1]    # 在函数内定义一个名为a的列表
    a.append(x)
    print(a)

a = [1,2,3,4]   # 在函数外定义一个名为a的列表
fun1(2)
print(a)
执行结果：
[1, 2]
[1, 2, 3, 4]

• 上述代码中，两个同名的列表之所以值不同，是因为它们处于不同的作用域里。在Python中，作用域可以分为内置作用域、全局作用域和局部作用域。内置作用域是Python预先定义的，全局作用域是所编写的整个脚本，局部作用域是某个函数内部范围。
•   上述代码中，函数中的列表a处于局部作用域中。而函数外的列表a处于全局作用域内。局部作用域内变量的改变并不影响全局作用域内的变量，除非通过引用的形式传递参数。

如果要在函数中使用函数外的变量，则可以在变量名前使用global关键字。

代码：
def fun (x):
    global a
    return a + x
a = 5    # a为全局变量，在fun函数中声明的
print( fun(3) )
a = 2
print( fun(3) )
执行结果：
8           # 5+3
5           # 2+3

四、用lambda声明函数

用lambda表达式来声明函数，是Python中一类比较特殊的声明函数的方式，lambda来源于LISP语言。使用lambda可以声明一个匿名函数。所谓匿名函数是指所声明的函数没有函数名，lambda表达式就是一个简单的函数。使用lambda声明的函数可以返回一个值，在调用函数时，直接使用lambda表达式的返回值。使用lambda声明函数的一般形式如下。
lambda 参数列表：表达式

以下函数定义了一个lambda函数，并调用了这个函数.

代码：
fun = lambda x: x * x - x      # 使用lambda定义一个函数，并返回函数地址
print( fun(3) )    # 返回函数值
print(fun)      # 返回函数地址，fun实际指向了lambda定义的函数地址
执行结果：
6
<function <lambda> at 0x0067F7C8>

lambda适合定义小型函数，与def函数定义不同，使用lambda声明的函数，在函数中仅能包含单一的函数参数表达式，而不能包含其他语句，在lambda中也可以调用其他的函数。

代码：
def show():        # 使用def定义函数
    print('hello world')   
f = lambda:show()   # 在lamdba中调用
f()

def show1(n):
    print('hello'*n)
fn = lambda x : show1(x)    # 在lambda函数中向show传值
fn(2)                   # 调用lambda函数
def userreturn(x):
    return(x*2)
fun = lambda x:userreturn(x)*x   # 在 lambda函数中使用userreturn函数的返回值
print(fun(3))    # 3*2*3