python入门（九）

函数

函数是由函数名、参数和函数体组成，格式如下

def 函数名 （形式参数）：
   函数体
   return 返回值

def是系统关键字，之后的文章会系统讲一下，这里只要知道这个是用来定义函数的

例如，我们定义一个求两个数的和的函数：

def add(a,b):
    c=a+b
    return c

#这里的 def 和 return 是绿色的，也就是系统关键字
#这里函数名是add（英语是求和的意思）
#然后有两个形式参数，a和b
#函数体部分执行的是 c = a +b
#最后函数返回的是 c 的值
#这就完成了一个求和函数的定义


函数的调用

函数的调用很简单，我们只要根据函数的定义形式

将实际计算时的参数值传进去就行（也可能没有参数）

函数调用格式：

函数名（实际参数）

    add(1,2)

    3

    add(3,4)

    #这里的 add（3,4） 就是函数调用

    #实际参数分别是 3 和 4

    #当函数调用发生时，才开始执行函数的内容

    #即给 a 赋值为 3 ， b 赋值为 4

    #然后计算出 c = 7

    #最后返回 c 的值 7

    7


函数调用 写的参数是实际参数（‘实际’体现在参数是实际执行函数使用的）

函数定义 写的参数是形式参数（‘形式’体现在他只是个格式和形式，真正函数执行时候还是先看实际参数）

参数的传递

函数调用时候，是将实际参数传递给形式参数

函数参数的传递方法有很多

1.参数按照位置顺序传递

刚才的add函数就是这种，按顺序，3传递给a，4传递给b2.参数按赋值传递

def mino(a,b):
    c=a-b
    return c

mino(3,4)  #位置传递

-1

mino(b=3,a=4) #参数赋值传递
1


2.参数按照默认值传递

有时候，可以在函数定义里给函数形参设定一个默认值, 当函数实参没有传递值进来，就使用默认值

def mino2(a,b=3):
    c=a-b
    return c

mino2(5,1)

4
mino2(5)

2


这里在定义函数时候，给形参 b 设置了默认值 3

然后调用函数时候，只传递了一个参数值 5

则python默认将 4 传递给 a，因为在定义时候给 b 设定了默认值 3

当然，当传入的参数是两个时候，则覆盖掉默认值，即不使用定义时候的默认参数值

3 （难点）元组类型的变长度参数传递

我们写个打印输出的函数

def dayin(a,b):
    print(a,b)

dayin('1',2)
1 2


如果我们要打印三个数怎么办？

def dayin(a,b,c):
    print(a,b,c)

dayin(12,3,4)

12 3 4


如果我们要打印1000个数呢???

我们可以定义一个变长参数，即这个参数代表的数字可长可短我们可以在

参数前面加一个星号 *  ，表示这个参数是可变长参数

当其他参数赋值完毕时候，剩下的参数依次赋值给这个可变长参数

def dayin(a,*b):
    print(a,b)

dayin(2,3,4)

2 (3, 4)


但是，注意到没有，这里的 b 是元组 （3,4）

所以你执意要打印出，可以提前修改函数的打印功能

def dayin(a,*b):
    print(a,end=' ')
    for i in b:
        print(i,end=' ')

dayin(2,3,4)

2 3 4 



dayin(1,2,3,4,5,6,78,8)

1 2 3 4 5 6 78 8 


4.（难点）字典类型的变长度参数传递  ##一个*号 代表元组，两个**号代表字典

我们可以在参数前面加两个星号 **  ，表示这个参数是可变长参数

但是形式是  实参名=字典值的方式传递

def dayin2(a,*b,**c):
    print(a,b,c)

dayin2('q','w',r=3)

q ('w',) {'r': 3}


注意到，字典类型变长参数传递一定是赋值形式传递进去的

当然，元组和字典形式变长参数也可能用不到，例如：

dayin2(1)

1 () {}


这样，打印出的就是空元祖和空字典啦~

如果你执意要实现那种打印形式，我们就改一下函数：

def dayin2(a,*b,**c):
    print(a,end=' ')
    for i in b:
        print(i,end=' ')
    for i in c:
        print(i ,end=' ')

dayin2('q','w',r=3)

q w r 

def dayin2(a,*b,**c):
    print(a,end=' ')
    for i in b:
        print(i,end=' ')
    for i in c:
        print(c[i] ,end=' ')

dayin2('q','w',r=3)

q w 3 

dayin2(1,2,r=3)

1 2 3 


继续完善

def dayin2(a,*b,**c):
    print(a,end=' ')
    if len(b)!=0:
        for i in b:
            print(i,end=' ')
    if len(c)!=0:
        for i in c:
            print(c[i] ,end=' ')

dayin2(1,2,r=3)

1 2 3 




dayin2(1,2,4,5,r=3,www='df')

1 2 4 5 3 df 




注意，可变参数的位置一般写在最后，不能乱了顺序，否则会报错！！！

dayin2(1,2,4,www='df',5,r=3)

  File '', line 1
    dayin2(1,2,4,www='df',5,r=3)
                         ^
SyntaxError: positional argument follows keyword argument


无返回值的函数

上面所有的函数都是有返回值的函数，如果没有返回值会怎样呢？

这个可以有！

def add():
    a=1
    b=2
    print(a+b)

add()

3


函数中变量的作用域

变量的作用域就是在程序中能对这个变量操作的区域范围

有点像初高中学的函数的定义域

Python允许同名变量的出现

让我们看个例子：

a=0
def dayin_out():
    a=1
    print(a)
    def dayin_inner():
        a=2
        print(a)

dayin_out()  ##只是调用了外层函数，并没有调用内层的dayin_inner函数

1

dayin_inner()  ##说明不可以直接调用内层函数，必须要先调用外层函数，接着才能调用内层函数

---------------------------------------------------------------------------


NameError                                 Traceback (most recent call last)


<>66-08f16c71accf> in module>()
----> 1 dayin_inner()  ##说明不可以直接调用内层函数，必须要先调用外层函数，接着才能调用内层函数


NameError: name 'dayin_inner' is not defined

a=0
def dayin_out():
    a=1
    print(a)
    def dayin_inner():
        a=2
    print('inner=% d'% a)    ###### print函数体实际上还是针对的外层的dayin_out函数，内层并没有调用


dayin_out()

1
inner= 1

a=0
def dayin_out():
    a=1
    print(a)
    def dayin_inner():
        a=2
        print('inner=% d'% a)
    dayin_inner() #######这一行代码的意思就是激活内层函数

dayin_out()

1
inner= 2


这里有三个a，第一个a是在函数外面，我们称之为全局变量（即它的作用域是全局的）

当然，与之相对的，第二个和第三个a就成为局部变量

而且这个dayin_inner( ) 函数是被嵌套在 dayin_outer( ) 中的

值为 1 的 a 的作用范围是dayin_outer( )外层函数中

值为 2 的 a 的作用范围是dayin_outer( )内层函数中

当我们要使用变量时候，实行的是最近的区域搜索赋值

a=0
def dayin_out():
    a=1
    print(a)
    def dayin_inner():
        a=2
        print('inner=% d'% a)
    dayin_inner() #######这一行代码的意思就是激活内层函数
print(a)

0

dayin_out()

1
inner= 2


我们修改一下程序：

a=0
def dayin_out():
    #a=1
    print(a)
    def dayin_inner():
        a=2
        print('inner=% d'% a)
    dayin_inner() #######这一行代码的意思就是激活内层函数
print(a)
dayin_out()

0
0
inner= 2


当我们把 a = 1 注释掉

则外层函数打印 a 的时候，取的全局变量

因为内层函数的作用域只在内层函数中，不能延伸到外层函数

我们再改一下程序：

a=0
def dayin_out():
    a=1
    print(a)
    def dayin_inner():
       # a=2
        print('inner=% d'% a)
    dayin_inner() #######这一行代码的意思就是激活内层函数
print(a)
dayin_out()

0
1
inner= 1


把内层函数里的 a 注释掉

则内层函数使用的 a 是外层函数定义的 a

因为，外层函数距离内层函数比全局变量距离内层函数更近

如果外层函数没有定义 a ，则会去取全局变量

a=0
def dayin_out():
    #a=1
    print(a)
    def dayin_inner():
       # a=2
        print('inner=% d'% a)
    dayin_inner() #######这一行代码的意思就是激活内层函数
print(a)
dayin_out()

0
0
inner= 0


注意：不要将变量的作用域和变量重复赋值覆盖搞混

我们看个例子：

a=0
a=5
def dayin_out():
    a=1
    print(a)
    def dayin_inner():
        a=2
        print('inner=% d'% a)
    dayin_inner() #######这一行代码的意思就是激活内层函数
print(a)
dayin_out()

5
1
inner= 2


注意这里全局变量只有一个 a

他的值是 5，因为 0 被覆盖了

匿名函数

匿名函数，匿名指的是我们不知道这个函数的名字

当我们使用时候，用lambda来声明匿名函数

这种匿名函数是没有名字的，是临时使用的格式：

函数对象名 = lambda 形式参数：表达式我们演示一下看看：

def add(a,b):
    c=a+b
    return c   
add(1,3)

4

func=lambda x,y:x+y
func(1,2)

3
func(2,3)
5


这里用匿名函数代替了add（）函数的功能

x，y是形式参数

x+y是函数体内容

匿名函数也可以有条件分支语句：

返回x和y中较大值

find_max=lambda x,y:x if x>y else y

find_max(3,4)
4


小建议：当函数较为复杂时，不建议匿名函数，不太好写而且结构难理解

函数的递归

递归指的是一种直接或者间接调用自身的算法

它的本质是将问题分解为同类型的子问题

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

shulie(1)

1

shulie(2)

2

shulie(8)

128


有个经典的Fibonacci数列问题

这个数列具有这样的特点：前两项均为1，从第三项起，每一项都是其前两项的和

即F0=F1=1，当n＞1时，Fn+2=Fn+1+Fn。

可以写成下面的函数

def Fn(n):
    if n==0:
        return 0
    elif n==1:
        return 1
    else:
        return Fn(n-1) + Fn(n-2)

Fn(40)

102334155
Fn(10)

Fn(50)
12586269025