函数

函数的定义：

def fun():
     print()
包括关键字def  关键字后面跟着是函数名 括号的用处是加形参 下一行的缩进是函数体 python中的缩进作用是让python进行识别

函数的参数：函数定义时括号里面的是形参，当函数调用的时候是实参。

形参：当函数被调用的时候接受实参，只有在函数被调用的时候才分配内存空间。

实参：实际参数，调用函数时传给函数的参数，可以是常量，变量，表达式，函数，传给形参

区别：形参是虚拟的，不占用内存空间，.形参变量只有在被调用时才分配内存单元，实参是一个变量，占用内存空间，数据传送单向，实参传给形参，不能形参传给实参

• 必备参数

  def people(name, age, ):
      print('name:%s ' 'age:%d '%(name,age),)
  people('kun',23)　
  要一一对应

• 关键字参数

  def people(name, age, ):
      print('name:%s ' 'age:%d '%(name,age),)
  people(age=23,name='kun',)
  位置可以随意调换　

• 默认参数

def people(name, age,sex='male' ):
    print('name:%s ' 'age:%d ' 'sex:%s'%(name,age,sex),)
people(age=23,name='kun',)
如果没有默认参数对应的实参的话，默认就是形参上的值，有的话就是自己实参对应的值

• 不定长参数

  *args 和 **kwargs
  *args用与非键值对的
  **kwargs用于键值对
  
  def add(*args):
      print(args)
      sum = 0
      for i in args:
          sum +=i
      print(sum)
  
  
  def people(**kwargs):
      print(kwargs)
      for i in kwargs:
          print('%s:%s'%(i,kwargs[i]))
  

  　　

返回值

要想获取函数的执行结果，就可以用return语句把结果返回一般我们的输出都是print
注意:
函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束
如果未在函数中指定return,那这个函数的返回值为None 
如果有多个返回值，则作为一个元组返回

高阶函数

• 有多个输入
• 返回的最少是一个函数

作用域

python作用域分四种情况

• local
• enclosing
• global
• built_in

优先情况L>E>G>B

x = int(2.9)  # int built-in

g_count = 0  # global
def outer():
    o_count = 1  # enclosing
    def inner():
        i_count = 2  # local
        print(o_count)
    # print(i_count) 找不到
    inner() 
outer()

global关键字

当内部作用域想修改外部作用域的变量时，就要用到global和nonlocal关键字了，当修改的变量是在全局作用域（global作用域）上的，就要使用global先声明一下，global改变全局变量代码如下：

count =10
def fun():
    global count
    print(count)
    count=50
    print(count)
fun()
#结果10 50

nonlocal关键字：更改嵌套作用域

def outer():
    count=10
    def inner():
        nonlocal count
        count=20
        print(count)
    inner()
    print(count)
outer()
#结果 20 20

小结

1. 作用域查找顺序 local>enclosing>global>built_in
2. 只有模块，类，函数能引入新的作用域
3. 对于一个变量，内部作用域先声明就会覆盖外部变量，不声明直接使用，就会使用外部作用域的变量；
4. 内部作用域要修改外部作用域变量的值时，全局变量要使用global关键字，嵌套作用域变量要使用nonlocal关键字。nonlocal是python3新增的关键字，有了这个 关键字，就能完美的实现闭包了

递归函数：调用自身的函数

#实现阶乘
def multiply(n):
    if n == 1:
        return 1
    else:
        return n*multiply(n-1)
print(multiply(5))

#斐波那契数列0 1 1 2 3 5 8 13
def fbn(n):
    if  n<2:
        return n
    else:
        return fbn(n-1)+fbn(n-2)
print(fbn(5))

递归函数的优点:    是定义简单，逻辑清晰。理论上，所有的递归函数都可以写成循环的方式，但循环的逻辑不如递归清晰。

递归特性:

1. 必须有一个明确的结束条件

2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少

3. 递归效率不高，递归层次过多会导致栈溢出(在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返     回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出。)

python内置函数

1.filter(function, sequence)：过滤函数

str = ('a','b','c')
def fun(s):
    if s!='a':
        return s
f = filter(fun,str)
for i in f:
    print(i)#b c

2.map(function, sequence) 

def add(x,y):
    x+=2
    y+=3
    return x,y
ret = map(add,range(10),range(10))
print(list(ret))#

map也支持多个sequence

3.reduce(function, sequence, starting_value)：顺序迭代调用

from functools import reduce
def add(x,y):
    return x+y
ret = reduce(add,(1,2,3))
print(ret)
#对一个序列进行迭代计算

4.lambda匿名函数的命名规则，用lamdba 关键字标识，冒号（：）左侧表示函数接收的参数（a,b） ,冒号（：）右侧表示函数的返回值（a+b）创建时不需要命名

#普通函数
def add(a,b):
    return a + b
 
print add(2,3)
 
  
#匿名函数
add = lambda a,b : a + b
print add(2,3)

三 函数式编程有什么好处呢？

1）代码简洁，易懂。
2）无副作用