Python学习笔记5(函数)

[摘要]本文详细介绍python中的函数，以及与之相关的参数和作用域的概念，并介绍递归的概念以及在程序中的应用。

函数定义

定义函数要用函数定义语句def。如下：

def hello(name):
    return 'Hello,'+name+'!'
    pass
print(hello('Gumy'))

在看一个例子，这个例子产生一个费波拉契数列。

def fibs(num):
    result=[0,1]
    for i in range(num-2):
        result.append(result[-2]+result[-1])
    return result
print(fibs(10))
print(fibs(20))

return语句很重要，他是用来返回函数返回值的语句，函数可以返回0个，一个，或者更多的返回值。利用元组可以实现多个值的返回。（还记得元组吗？它的形式是：（。，。，。，。）！！！！，[。，。，。，。]序列！！！！{。：。，。：。，。：。}字典！！！！，‘lalalalalla’字符串！！！！）

文档化函数

如果想要给函数写文档，让其他使用该函数的人理解该函数的使用方法，可以加入注释。另外的一个方法是直接写上字符串。这类字符串在其他地方可能会特别有用，比如在def语句、模块、类语句后面等。这种字符串称为文档字符串。

def square(x):
    'calculate the square of x.'
    return x*x
help(square)

没有返回值的函数

没有返回值的函数不返回任何东西，这样的函数又叫过程。如下：

def test():
    print('This is sun.')
    return
    print('This is moon.')
x=test()
print(x)
#运行结果
This is sun.
None
[Finished in 0.133s]

参数

函数的关键就是参数的传递，一方面是调用函数将参数传入，被调用函数接受参数的过程，另一方面是被调用函数将函数结果（返回值）返回给调用函数的过程。

写在def语句函数名后面的变量通常叫做函数的形参，而调用函数的时候提供的值是实参，或称为参数。

在函数内部对参数作出修改，并不会影响外部该参量的值。如下：

def exam(name):
    name='Mr.Gumy'
    return name
name='Mr.Entity'
aa=exam(name)
print(aa)
print(name)
#运行结果
Mr.Gumy
Mr.Entity

参数储存在局部作用域里。

位置参数和关键字参数

Python中的参数主要有两类，一类常用的是位置参数。也就是说参数在参数列表中的位置很重要，调用时要按照位置排列。另外一种是关键字参数，可以不按照位置排列，这种方式在程序较大，参数比较多的情况下很有用。

位置参数的例子：

def hello(na,nb):
    print('%s,%s'%(na,nb))

hello('hello','word')
hello('word','hello')

# 结果：
hello,word
word,hello
[Finished in 0.1s]

有些时候（尤其是参数较多的时候），参数的顺序很难记住。为了让事情更简单些，可以提供参数的名字。这类使用参数名提供的参数叫做关键字参数。在这种情况下调用函数时参数的位置和顺序不再重要，重要的是参数名和值一定要对应。

def hello(na='Hello',nb='word'):
    print('%s,%s'%(na,nb))

hello(na='hello',nb='word')
hello(nb='word',na='hello')

# 结果
hello,word
hello,word
[Finished in 0.1s]

关键字参数的重要用途是：

提供了参数的默认值。
明晰了各参数的含义，是程序更易读懂。

位置参数和关键字参数可以联合使用：

def hello(name,na='Hello',nb='good morning',nc='!'):
    print('%s,%s,%s,%s'%(na,name,nb,nc))

hello('Bob',nb='You gays')
hello('Bob',nb='word',na='hello')
hello('Gumy')
hello('Gumy','Hello','Good evening','>>>>>')

# 结果
Hello,Bob,You gays,!
hello,Bob,word,!
Hello,Gumy,good morning,!
Hello,Gumy,Good evening,>>>>>
[Finished in 0.1s]

任意数量参数

用户可以给函数提供任意多的参数。利用*或者**来完成参数的收集，就可以实现任意多参数的提供。其中*将参数收集起来变成元组来使用，对应于位置参数，**将参数整理成为字典，对应于关键字参数。

对于一般参数：

def function(title,*params):
    print(title)
    print(params)

function('params',1,2,3,4,5,6)
# 结果
params
(1, 2, 3, 4, 5, 6)
[Finished in 0.1s]

对于关键字参数：

def function(**params):
    print(params)

function(na=1,nb=2)
# 结果
{'na': 1, 'nb': 2}
[Finished in 0.1s]

两者联合使用：

def function(title,**params):
    print(title+':')
    print(params)

function('title',na=1,nb=2)
# 结果
title:
{'na': 1, 'nb': 2}
[Finished in 0.1s]

def function(x,y,z=1,*na,**nb):
    print(x,y,z)
    print(na)
    print(nb)

function(1,2,3,4,5,6,7,8,9,num1=1,num2=2)
print()
function(1,2)

# 结果
1 2 3
(4, 5, 6, 7, 8, 9)
{'num1': 1, 'num2': 2}

1 2 1
()
{}
[Finished in 0.1s]

作用域

每一个变量名都对应一个值，这种名-值对应类似于内置的字典，这种看不见的字典叫做命名空间，或者作用域，除了全局作用于之外，每个函数调用都会创建一个新的作用域。

函数内的变量被称为局部变量。局部变量只在当前环境中起作用，不会影响到当前环境之外的其他变量。参数的工作原理类似于局部变量，所以用全局变量的名字作为参数也是可行的。要注意变量屏蔽效应：当局部变量和全局变量同名时，如果直接应用该变量，系统会自动匹配局部变量的值，而把全局变量屏蔽掉。如果要在当前环境中引用全局变量，可以使用global语句:gilobals()[‘parameter’]获取。

函数可以嵌套，也即函数在定义的时候调用另外一个已有的函数，因此作用域也存在嵌套现象。函数还可以调用它自身，这叫做函数的递归调用。

递归

递归就是调用自身。直接给出几个经典的例子。

例1：阶乘的定义：

def factorial(n):
    if n==1:
        return 1
    else:
        return n*factorial(n-1)

print(factorial(10))
# 结果
3628800
[Finished in 0.1s]

例2：幂的计算：pow(x,n)

def pow(x,n):
    if n==1:
        return x
    else:
        return x*pow(x,n-1)

print(pow(3,3))
# 结果
27
[Finished in 0.2s]

例3：二分法查找

def search(sequence,num,lower=0,upper=None):
    if upper is None:upper=len(sequence)-1
    if lower==upper:
        assert num==sequence[upper]
        return upper
    else:
        middle=(lower+upper)//2
        if num>sequence[middle]:
            return search(sequence,number,lower=middle+1,upper=upper)
        else:
            return search(sequence,number,lower=lower,upper=middle)

seq=[34,67,8,123,4,100,95]
seq.sort()
print(seq)
print(search(seq,34))
print(search(seq,100))