大变小（函数，对象，模块）

def myfun():

　　　　print('hello')

　　myfun()

函数就是对循环内容的打包，为和循环做区别，引入参数

def myfun(name):

　　　　print(name)

　　myfun('abc')　

　　形参name和实参abc 

返回值

def myfun(name):

　　　　return name

　　myfun('abc')　

函数文档

def myfun(name):

　　　　'name是形参'

　　myfun.__doc__或help(myfun)　

关键字参数

def myfun(name):

　　　　print name
　　myfun(name='abc')

默认值参数

def myfun(name='abc'):

　　　　return name

 

可变参数

def myfun(*params):

　　　　print(len(params), params[1])

 

函数与过程：函数有返回值，过程无返回值

变量作用域（变量可见性）：

def discount(price, rate):

　　　　final_price = price*rate
　　　　return final_price
　　#price,rate,final_price 局部变量

　　如果在函数内试图修改全局变量，python会自动创建一个同名局部变量代替

global

count = 5

　　def mycount():

　　　　global count  //修改全局变量
　　　　count = 10

 

内部函数(函数内部创建函数 只能在函数内部被调用)：

def fun1():

　　　　print('fun1被调用')
　　　　def fun2():
　　　　　　print('fun2被调用')
　　　　fun2

闭包(内部函数对外部变量(funX)进行引用，那么funY就是闭包)：

def funX(x):

　　　　def funY(y):

　　　　　　return x*y

　　　　return funY

　　i = funX(8)  #class 'FUNCTION'

　　i(5)　　　　#40
　　funX(8)(5) #40

内部函数修改外部变量

　　python2(容器)

def funX():
    x = [5]
    def funY():
        x[0] *= x[0]
        return x[0]
    return funY()

　　python3(nolocal)

def funX():
    x = 5
    def funY():
        nolocal x
        x *= x
        return x
    return funY()

匿名函数 g = lambda x:2*x   参数:返回值

　　　　 g(5)

　　　　 h = lambad x,y:x+y

过滤器 filter：1list(filter(None,[1,0,True, False])) =>[1,True]

　　　　　　  2list(filter(add,[1,2,3]))

　　　　　　  3list(lambad x:x*2, [1,2,3])

map: list(map(lambda x:x*2,range(10)))

递归：函数调用自己（注意要有结束,效率会低）

def factorial(n):
    if n==1:
        return n
    else:
        return n*factorial(n-1)
def fab(n):
    if n<1:
        print(’error')
        return -1
    if n==1 or n==2
        return 1
    else:
        return fab(n-1)*fab(n-2)

　　汉诺塔：x借助z移到y，y借助x移到z

def hanoi(n,x,y,z):
    if n==1:
        print(x'->'z)
    else:
        hanoi(n-1,x,z,y)
        #n-1从x移到y
        print(x'->'z)
        hanoi(n-1,y,x,z)
        #y上的n-1移到z