函数基础

函数：函数是指将一组语句的集合通过一个名字(函数名)封装起来。要想执行这个函数，只需调用其函数名即可。
特性：
1.减少重复代码
2.程序变得可扩展
3.程序变得易维护
----------------------------------

1.1.参数：

  1.形参    
  2.实参     
  3.位置参数   
  4.默认参数：必须放在位置参数后面 - 形参 
  5.关键参数：必须放到位置参数后面 - 实参
  6.非固定参数--元组形式的 
  7.非固定参数--字典形式的    

    def fun1(x,*args,**kwargs): 
        print(x,args,kwargs)

    fun1(2,3,4,5,name='alice',age=12)
    fun1(2,*(3,4,5),name='alice',age=12)

    2 (3, 4, 5) {'name': 'alice', 'age': 12}

1.2.返回值：

  未指定      返回 None      
  return x 
  return x,y  默认返回一个元组（x,y） 
  return (x,y)                （x,y）
  return [x,y]                 [x,y]

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

2.局部变量 全局变量 

age = 12
def fun1(x,y):
    # global age
    age = 13
    return age, x+y

def func2():
    print(age)

res = fun1(1,2)
print(res)

name = (1,2,3,[2,3])
def fun1():
    name[3][0]=33
    print(name)

fun1()
print(name)
(1, 2, 3, [33, 3])
(1, 2, 3, [33, 3])

总结：局部不能修改全局变量，除非加上global
         全局变量如果是列表，字典，元组里面包含列表，整体不能修改，但是单个元素可修改
         函数调用是在内存的栈中，先进后出，函数调用完毕，自动释放内存

堆栈参考：http://www.cnblogs.com/lln7777/archive/2012/03/14/2396164.html

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

3.嵌套函数：

   函数内部可以再次定义函数 
   执行需要被调用

4.作用域： 

   python中一个函数就是一个作用域（JavaScript）,局部变量放置在其作用域中
   代码定义完成后，作用域已经生成，作用域链向上查找，函数名是可以当成返回值的

5.匿名函数：

作用：
   1.节省代码量
   2.看着高级

z = lambda x,y:x*y
print(z,z(2,3))

z = lambda x, y: x*y if x < y else x/y
print(z, z(10, 2))

data = list(range(10))
print(data)
print(list(map(lambda x: x*x, data)))

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

6.高阶函数：

  满足任意一个条件，即是高阶函数：
    1.接受一个或多个函数作为输入
    2.return返回另外一个函数

def func(x,y):
    return x+y

def calc(x):
    return x

f = calc(func)
print(f(2,3))

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

7.递归： 

用途：函数里面自己调用自己，不知道什么时候能结束这个循环，循环不用for while，用函数实现循环
特点：函数里面自己调用自己；递归执行过程一层一层进，一层一层出。

def calc(n):
    n = int(n /2)
    if n > 0:
        return calc(n)
    else:
        return n
    
print(calc(10))

def calc(n,count):
    print(n,count)
    if count < 5:
        return calc(n/2,count+1)
    else:
        return n

res = calc(188,1)
print('res=',res)

188 1
94.0 2
47.0 3
23.5 4
11.75 5
res= 11.75

递归总结：
1.必须有一个明确的结束条件
2.每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3.递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈stack这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧，由于栈的大小不是无限的，所以，递归调用的过多，会导致栈溢出。）