python学习（七）——函数、变量、递归、作用域、匿名函数、函数式编程

一、函数 def

def test(x):   #形参
    '''
    x++
    :param x: 整形数字
    :return: 返回值
    '''
    x+=1
    return x

c = test(a)   #实参

1、位置参数与关键字参数

def test(x,y,z):#x=1,y=2,z=3
    print(x)
    print(y)
    print(z)

# 位置参数，必须一一对应，缺一不行多一也不行
test(1,2,3)

# 关键字参数，无须一一对应，缺一不行多一也不行
test(y=1,x=3,z=4)

#位置参数必须在关键字参数左边
test(1,y=2,3)#报错
test(1,3,y=2)#报错
test(1,3,z=2)
test(1,3,z=2,y=4)#报错
test(z=2,1,3)#报错

2、可变长参数

#参数组：**字典 *列表
def test(x,*args):
    print(x)
    print(args)


# test(1)
# test(1,2,3,4,5)
# test(1,{'name':'alex'})
# test(1,['x','y','z'])
# test(1,*['x','y','z'])
# test(1,*('x','y','z'))

# def test(x,**kwargs):
#     print(x)
#     print(kwargs)
# test(1,y=2,z=3)
# test(1,1,2,2,2,2,2,y=2,z=3)
# test(1,y=2,z=3,z=3)#会报错 ：一个参数不能传两个值

def test(x,*args,**kwargs):
    print(x)
    print(args,args[-1])
    print(kwargs,kwargs.get('y'))
# test(1,1,2,1,1,11,1,x=1,y=2,z=3) #报错
# test(1,1,2,1,1,11,1,y=2,z=3)

二、全局变量与局部变量

全局变量：没有缩进，顶格定义

局部变量：在子程序中定义的

1、global - 引用全局变量

NAME = "杠娘"

def t1():
    global NAME
    print(NAME)   # 杠娘


def t2():
    global NAME
    NAME = "小东北"
    print(NAME)   # 小东北--将全局变量改成小东北

def t3():
    print(NAME)   # 小东北


######## 全局变量变量名大写
######## 局部变量变量名小写


# 优先读取局部变量，能读取全局变量，无法对全局变量重新赋值 NAME=“fff”，
#     但是对于可变类型，可以对内部元素进行操作
# 如果函数中有global关键字，变量本质上就是全局的那个变量，可读取可赋值 NAME=“fff”


# 如果函数的内容无global关键字，
#   - 有声明局部变量
NAME = ["产品经理","廖波湿"]
def qupengfei():
    NAME = "自己"
    print('我要搞', NAME)
qupengfei()

#   - 无声明局部变量
NAME = ["产品经理","廖波湿"]
def qupengfei():
    NAME.append('XXOO')
    print('我要搞', NAME)
qupengfei()


# 如果函数的内容有global关键字
#   - 有声明局部变量
        # NAME = ["产品经理","廖波湿"]
        # def qupengfei():
        #     global NAME
        #     NAME = "自己"
        #     print('我要搞', NAME)
        # qupengfei()
        # 错误示例
        # NAME = ["产品经理","廖波湿"]
        # def qupengfei():
        #     NAME = "自己"
        #     global NAME
        #     print('我要搞', NAME)
        # qupengfei()
#   - 无声明局部变量
        # NAME = ["产品经理","廖波湿"]
        # def qupengfei():
        #     global NAME
        #     NAME = ["阿毛"]
        #     NAME.append('XXOO')
        #     print('我要搞', NAME)
        # qupengfei()

2、嵌套

name = "刚娘"
def weihou():
    name = "陈卓"
    def weiweihou():
        global name           
        name = "冷静"    #刚娘-冷静

    weiweihou()
    print(name)

print(name)
weihou()
print(name)

#刚娘
#陈卓
#冷静

3、nonlocal：指定上一级

name = "刚娘"

def weihou():
    name = "陈卓"
    def weiweihou():
        nonlocal name   # nonlocal，指定上一级变量，如果没有就继续往上直到找到为止
        name = "冷静"   # 陈卓-冷静

    weiweihou()
    print(name)

print(name)
weihou()
print(name)

#刚娘
#冷静
#刚娘

三、前向引用（风湿理论：函数即变量）

先声明再调用

四、函数递归

1、必须有明确的结束条件

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

3、递归效率不高，递归层次过多会导致栈溢出

五、函数作用域

def foo():
    name='lhf'
    def bar():
        name='wupeiqi'
        print(name)
        def tt():
            print(name)
        return tt
    return bar

# bar=foo()
# tt=bar()
# print(tt)
# tt()
r1 = foo()
r2 = r1()  # tt
r3 = r2()
foo()()()

六、匿名函数（lambda）

func = lambda x:x+1
print(func(10))

#--------原函数实现--------#
name='alex' #name='alex_sb'
def change_name(x):
    return name+'_sb'

res=change_name(name)
print(res)


#--------匿名函数实现--------#
func=lambda x:x+'_sb'
res=func(name)
print('匿名函数的运行结果',res)

func=lambda x,y,z:x+y+z
print(func(1,2,3))

七、函数式编程

1、面向过程：按照固定的流程一步步解决问题

2、函数式：函数式=编程语言定义的函数+数学意义的函数

不用变量保存状态，不修改变量

（1）高阶函数

# 高阶函数：把函数当作参数传给另外一个函数

# 1、函数接收的参数是一个函数名  
# 2、返回值中包含函数
def foo(n): #n=bar
    print(n)

def bar(name):
    print('my name is %s' %name)  #不是

# foo(bar)  #是高阶函数
# foo(bar())
foo(bar('alex'))

#返回值中包含函数
def bar():
    print('from bar')  #是
def foo():             
    print('from foo') 
    return bar         #是
n=foo()
n()
def hanle():
    print('from handle')
    return hanle       #是
h=hanle()
h()



def test1():
    print('from test1')
def test2():
    print('from handle')
    return test1()

（2）尾递归调用：在最后一步进行调用

3、面向对象