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 "<ipython-input-44-d5f9a291294b>", 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)<ipython-input-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
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