python学习之路-基础篇-函数-day03

大纲
1.定义
2.使用函数的优势
3.return返回值详解
4.参数表详解
5.局部变量和全局变量
6.递归
7.高阶函数
一.函数的基本语法和特性
1.定义一个函数三要素
1)使用关键字def
2)参数表
3)返回值return
python中参数表和返回值不是必须要写的，是一个可选项
以下就是一个函数的简单模型：

def test(num):
    print("test")
    return 0

2.使用函数有哪些好处？
1)提高代码的可复用性
2)提高代码的可扩展性
3)可以根据自己的需求进行自定义函数，使代码模块化
3.return返回值详解：
1)不写return,默认隐式返回值是None
2)返回一个参数，比如return 0 返回值是0
3)返回参数个数大于1，返回的就是一个tuple，比如
return 1，“hello”，[1,2]，返回值是（1,“hello”,[1,2]）
为什么函数需要有返回值呢？为了返回函数的执行结果，方便后面程序的调用哦
return返回值的作用：(1)结束函数(2)返回某个对象
4.参数表详解：
1)关键参数和位置参数

def test(x,y):
    print(x)
    print(y)
test(1,2)  #传入的实际参数和形参一一对应--位置参数
test(y=1,x=2) #这种就是关键参数
test(y=1,2)   #SyntaxError: non-keyword arg after keyword arg这种写法就是错误的，y已经有了位置参数2了，所以就不可以在赋值关键参数y=1
# 总结关键参数不可以写在位置参数的前面
test(1,2,3)#TypeError: test() takes exactly 2 positional arguments (3 given)
test(1)#TypeError: test() takes exactly 2 positional arguments (1 given)
#总结：传入的实参个数要和形参个数一致
def test(x,y=1):#这里关键参数也不可以写在位置参数前面
    print(x)
    print(y)
test(1)
#默认参数，调用的时候默认参数不是必须传递

2)当实际参数的个数我们并不确定时，那么我们怎么去定义它的形参呢？
这里我们就要用到参数组的概念了，一次可以传入多个参数

def test(*args):
    print(args)
test(1,2,3,4)  #(1, 2, 3, 4)
test(*[1,2,3,4])#(1, 2, 3, 4)
def test(x,*args):
    print(x)   #1
    print(args)#(2, 3, 4)
test(1,2,3,4)
#得到的结果都是元祖形式

3)怎样传入字典呢？

def test(**kwargs):
    print(kwargs)
    print(kwargs["name"]) #coco
test(name="coco",age=8)#{'age': 8, 'name': 'coco'}
a=test(**{"name":"coco","age":8})#{'age': 8, 'name': 'coco'}

5.局部变量和全局变量，作用域问题
字符串，元祖是不可以修改的，列表，字段集合均可修改

#实例一
age=[12,25,36,44]#全局变量
def change_age():
    age[0]=11#修改全局变量
    print(age)#[11, 25, 36, 44]
change_age()
print(age)#[11, 25, 36, 44]
#实例二
name="coco"
def change_name():
    name="niko"
    print(name,"is 12 years old")#niko is 12 years old
change_name()
print(name,"is 12 years old")#coco is 12 years old
#实例三
x=6#全局变量
def f():
    print(x)
    x=5   #x=5是局部变量
f()
#UnboundLocalError: local variable 'x' referenced before assignment
#首先在局部寻找x,未声明就使用报错，改为
x=6#全局变量
def f():
    global x
    print(x)
    x=5   #x=5是局部变量
f()#结果  6
#实例四
def outer():
    count=10#不是全局变量
    def inner():
        count=20
        print(count)#20
    inner()
    print(count)#10
outer()
def outer():
    count=10#不是全局变量，嵌套
    def inner():
        nonlocal count
        count=20
        print(count)#20
    inner()
    print(count)#20
    #global必须在全局作用域，不可以用在嵌套作用域，当嵌套作用域的值要修改必须加上nonlocal
outer()
#实例五
age=0#全局变量
def change_age():
    #局部不声明也不修改可以正常使用
    print(age)
change_age()#0
#实例六
age=0#全局变量
def change_age():
    #***局部对全局变量要修改，必须声明global***
    global age
    age+=1
    print(age)
change_age()#1

6.递归
递归的概念：在一个函数的内部可以调用这个函数本身就是递归。
递归的缺点：效率不高，调用越多，容易栈溢出
那么递归的产生需要什么条件呢？
1）必须有明确的结束条件
2）每次进入更深一层，问题的规模要比上次的减少
递归函数实例1—阶乘

#方法一
def foo(n):
    ret=1
    for i in range(1,n+1):
        ret=ret*i
    return ret
print(foo(5))
#方法二
def foo1(n):
    if n==1:
        return 1
    else:
        return n*foo1(n-1)
print(foo1(5))

递归函数实例2—斐波那契

#方法一：
def fibo(n):
    before = 0
    after = 1
    for i in range(1,n-1):
        ret=before+after
        before=after
        after=ret
    return ret
print(fibo(5))

#方法二：
def fibo(n):
    if n==1:
        return 0
    elif n==2:
        return 1
    elif n==3:
        return 1
    else:
        return fibo(n-1)+fibo(n-2)
print(fibo(6))

7.高阶函数
概念：变量可以指向函数，函数本身也可以赋值给变量，那么一个函数可以接受另一个函数作为参数
也就是说（把函数作为参数传入，这样的函数称为高阶函数，函数式编程就是指这种高度抽象的编程范式）
举例：

def add(x, y, f):
    return f(x) + f(y)
print(add(5,-7,abs))#abs是取绝对值的意思，结果为12
#详解：x=5,y=-7,f=abs现在把x和y的值传给abs
#等价于abs(5)+abs(-7)