函数

1 函数的定义：它是指将一组语句的集合通过一个名字来封装，要想执行这个函数，只需要调用函数名即可。

2 特性：减少重复代码、是程序变得可扩展、使程序变得易维护。

3 语法定义：

def function1():#函数名
    print("Hello I'm peng.liu")

function1()#调用

4 函数参数。（函数先定义，后使用）

　　函数的参数分为形参和实参。

　　形参：它只有在被调用时，才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参。

　　实参：它可以是常量、变量、表达式，函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值。

def axl(x,y):#x、y 为形参
    res= x + y
    return res

c = axl(x,y) x,y为实参
print(c)

　　正常情况下，给函数传参数要按顺序，不想按顺序就可以用关键参数，只需要指定参数名即可。关键字参数必须放在位置参数后面

def test(x,y):
    print(x)
    print(y)
test(y=2,x=1) # 关键字参数传参
test(1,2)#位置参数传参

　　上面传的是固定参数，现在说说非固定参数。

　　如果函数在定义时不确定用户想传入多少个参数，就可以使用非固定参数.

　　*args 把N个位置参数转变为一个元组。

def stu_register(name,age,*args): # *args 会把多个传入的参数变成一个元组形式
    print(name,age,args)
 
stu_register("peng.liu",27)
#输出
#peng.liu 27 () #后面这个()就是args,只是因为没传值,所以为空
 
stu_register("***",32,"CN","Python")
#输出
# *** 32 ('CN', 'Python')

　　还有一个**kwargs，把N个关键字参数转化为一个字典，且可以使用kwargs['key']来获得当前值。

def stu_register(name,age,*args,**kwargs): # *kwargs 会把多个传入的参数变成一个dict形式
    print(name,age,args,kwargs)
 
stu_register("Alex",22)
#输出
#lisi 22 () {}#后面这个{}就是kwargs,只是因为没传值,所以为空
 
stu_register("Jack",32,"CN","Python",sex="Male",province="ShanDong")#此时传参数直接传入一个**{“sex”:"Male",“province”:"shangdong"}
#输出
# Jack 32 ('CN', 'Python') {'province': 'ShanDong', 'sex': 'Male'}

　　非固定参数的作用：预留传参个数，以便扩展。注意：规范写法是：*args、**kwargs，它们放在参数的最后面。

5 变量：它分为局部变量和全局变量。

　　在子程序（函数）中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。

　　全局变量作用域是整个程序，且在头部声明，局部变量作用域是定义该变量的子程序。

　　当全局变量与局部变量同名时：在定义局部变量的子程序内，局部变量起作用；在其他地方全局变量起作用。

　　如果想将全局变量改成局部变量，则需要在函数中声明global 变量,最好不要在函数中修改全局变量。

　　在函数中，除了整数、字符串外，列表、字典、集合、类都可以进行修改。

6 返回值

　　要想获取函数的执行结果，可以用return语句把结果返回

　　注：1 函数在执行过程中只要遇到return语句，就会停止执行并返回结果，可以理解为return语句代表着函数的结束。

　　　　2 如果未在函数中指定return,那这个函数的返回值为none

　　　　3 返回值可以为任何类型且可以为函数

7 递归函数

　　在函数内部，可以调动其他函数。如果一个函数在内部调用其本身，这个函数就叫递归函数。

　　最大递归次数为999次。

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

　　堆栈扫盲http://www.cnblogs.com/lln7777/archive/2012/03/14/2396164.html

　　递归例子：二分查找。

data = [1, 3, 6, 7, 9, 12, 14, 16, 17, 18, 20, 21, 22, 23, 30, 32, 33, 35]
 
def binary_search(dataset,find_num):
    print(dataset)
 
    if len(dataset) >1:
        mid = int(len(dataset)/2)
        if dataset[mid] == find_num:  #find it
            print("找到数字",dataset[mid])
        elif dataset[mid] > find_num :# 找的数在mid左面
            print("\033[31;1m找的数在mid[%s]左面\033[0m" % dataset[mid])
            return binary_search(dataset[0:mid], find_num)
        else:# 找的数在mid右面
            print("\033[32;1m找的数在mid[%s]右面\033[0m" % dataset[mid])
            return binary_search(dataset[mid+1:],find_num)
    else:
        if dataset[0] == find_num:  #find it
            print("找到数字啦",dataset[0])
        else:
            print("没的分了,要找的数字[%s]不在列表里" % find_num)
 
 
binary_search(data,66)

8 函数式编程介绍（可以忽略）

　　函数式编程更接近数学计算。它是一种抽象程度很高的编程范式，纯粹的函数式编程语言编写的函数没有变量，因此，任意一个函数，只要输入是确定，输出就是确定的，这种纯函数我们称之为没有副作用。

　　python对函数式编程提供部分支持，由于python允许使用变量，因此，python不是纯函数式编程语言。　　

8 高阶函数

　　变量可以指向函数，函数的结果能接受变量，那么一个函数就可以接收另一个函数作为参数，这种函数就称之为高阶函数。

def add(x,y,f):  # 将abc 传入函数，在函数中使用
    return f(x)+f(y)
res = add(3,-6,abs)   
print res

9 匿名函数(高阶函数)

　　lambda 参数列表：return[表达式]变量

　　由于lambda返回的是函数对象（构建的是一个函数对象），所以需要定义一个变量去接受。

　　特点：1 使用lambda可以省去定义函数的过程，让代码更加精简

　　　　   2 对于一些抽象的，不会被别的地方重复使用的函数，可以使用lambda函数不考虑函数名问题。

　　　　　3 匿名函数中，只能写一个表达式，不用谢return,返回值就是表达式的结果。

　　匿名函数一般与map、reduce配合使用。

　　map()的函数接收两个参数，一个是函数，一个是序列，map将传入的函数依次作用到序列的每个元素，并把结果作为新的list返回

def f(x):
    return x*x
a = map(f,[1,2,3,4,5,6,7,8])
print(a)

#输出
[1, 4, 9, 16, 25, 36, 49, 64]

10 reduce（）把一个函数作用在一个序列上，这个函数接收两个参数，把结果继续和序列下一个元素做累积计算

def add(x,y)
    return x+y
reduce(add,[1,3,5,7,9])
#输出
25

 11 filter() 对序列中的元素进行筛选，最终获取符合条件的序列。

>>>b = [11,22,33]
>>>c = filter(lambda arg:arg> 22,b)
#输出
[33]