Python基础17 嵌套函数 函数类型和Lambda表达式 三大基础函数 filter() map() reduce()

#函数

#嵌套函数
#和C语言不一样的是，Python可以在函数里面定义函数(这就很魔幻)
#那我们来尝试一下

def get_shuju(a,b,ord):
    
    def add_sj(a,b):
        return a+b

    def qiuyu(a,b):
        return a%b

    def chengfa(a,b):
        return a*b
    if(ord==1):
        return add_sj(a,b)
    if(ord==2):
        return qiuyu(a,b)
    if(ord==3):
        return chengfa(a,b)
#这里我们就定义了一个函数
#而且在函数中我们还定义了多个函数进行嵌套
print(get_shuju(10,52,2))
#我们这里就可以算出数据的值
#可以正常调用在get_shuju函数的定义的函数
#那这个函数是否符合作用范围呢？
#是否和全局变量和局部变量有一样的性质呢？

#chengfa(10,2)
#我们在函数内定义的函数，在这个函数外是没有办法调用的
#那么我们再定义一个全局变量的函数是否会对局部变量函数生效吗？

def test_2():
    print("全局变量")
    return 0

def test ():
    def test_2():
        print("局部函数")
        return 0
    test_2()
    return 0

#这样就建立了两个test_2函数
#一个是就全局而言，一个是就函数test而言的
test_2()
test()
#这样就看到了，这里test_2的全局变量并没有覆盖掉test中的test_2
#依旧符合翔龙斗不过地头蛇的基本定理
def test_3 ():
    global test_2
    test_2()
    return 0
#我们也可以通过添加global声明来调用全局的函数test_2
test_3()

'''
def test_4():
    def test_2():
        print("局部函数")
        return 0
    global test_2
    test_2()
    return 0
'''
#但是我们发现，这里在定义了局部函数test_2以后，又声明global来调用test_2是会冲突的
#会直接报错的。
'''
def test_4():
    global test_2
    test_2()
        def test_2():
        print("局部函数")
        return 0
    return 0
'''
def test_4():
    global test_2
    def test_2():
        print("我改变了吗？")
        return 0
    test_2()    
    return 0

test_4()
test_2()
#而根据上面的几个代码的测试我们发现
#我们也可以通过先声明这里使用global 的 test_2
#然后再定义函数test_2是可以的
#但是要注意，如果你这么做了，那么你就改变了全局变量中的test_2函数的内容了

print("////////////////////////////////////")

#函数类型
#函数和变量一样也是有类型的
#Python创建了一个函数类型function
#任何一个函数都有函数类型，函数调用的时候就产生了函数类型实例
#也就是函数对象
#函数类型实例与其他类型实例在使用场合上没有区别

def function_0(a,b):
    c=a+b
    return c
#我们先建立一个函数

f1=function_0(10,20)
print(type(f1))
#我们看到这里的类型并不是function，而是int

def function_1(c):
    def add(a,b):
        return a+b
    def add_2(a,b):
        return a+a+b+b
    if c>0:
        return add
    else:
        return add_2 
f2=function_1(10)
f3=function_1(-10)
print(type(f2))
print(type(f3))
#这里返还的数据类型就是function类型
#而当我们上述设置了f2和f3的时候
#f2和f3其实就不是原来的简单变量了
#它变成了function函数类型
#储存的是不同c值的function_1函数的运算
#而这里不同c值的情况对应的是不同的局部函数add
#而add函数也是要收录数据的
#那么我们就可以直接使用f2和f3来做对应c值情况下的a,b的数据收录

print("c>0:10+20={0}".format(f2(10,20)))
print("c<0:10+20+10+20={0}".format(f3(10,20)))
#运行结果完全正确

print("////////////////////////////")

#Lambda表达式
#Lambda表达式本质上是一种匿名函数
#匿名函数也是函数，有函数类型，可以创建函数对象
#格式
#lambda 参数列表:Lambda体
def shuju_2(c):
    if(c>0):
        return lambda a,b:a+b
    else:
        return lambda a,b:a-b
    return 0
#这里我们就建立了一个含有lambda表达式的代码
f4=shuju_2(2)
print(f4(10,10))
print(type(f4))
#函数类型变成了Lambda
#数据可以正常输出
#注意
#Lambda只能处理一些简单的数据
#而且它不是一个代码块，不能包含多条语句，只能填写一条语句
#语句会计算出一个值然后返还给Lambda表达式，但是不需要用return返还

print("////////////////////")

#三大基础函数
#filter()
#它可以对迭代对象的元素进行过滤
#基本格式
#filter(function,iterable)
#function是一个函数，参数iterable是一个可迭代对象
#在使用filter()的时候，会遍历iterable，然后元素被一个一个传入function中进行判断
#function函数返还布尔值，如果是True就会保存，False就被过滤

name =["茄子","大司马","海鸥"]
print(name)
name_filter=filter(lambda n : n.startswith('茄'),name)
print(name_filter)
#<filter object at 0x0000018739034790>
#返还值是这个，为什么呢？
print(type(name_filter))
#我们这里就看出来了，name_filter的数据类型是filter
#那我们需要将其转换成list类型才能输出
print(list(name_filter))
#我们要注意这里用list()来转变，filter本身就是一个可迭代类型
#就不需要加上[] ()这样转变了
#startswith可以过滤多要求的数据吗？
#我们来测试一下
name_filter_2=filter(lambda n : n.startswith('茄'and '大'),name)
print(tuple(name_filter_2))
#但是这里就只输出了'大司马'
name_filter_3=filter(lambda n : n.startswith('茄'and '大'),name)
print(list(name_filter_3))
#还是只输出了大司马
name_filter_3=filter(lambda n : n.startswith('茄'or '大'),name)
print(list(name_filter_3))
#我们由此得出结论
#它并不会过滤多要求的元素
#并且如果写的and他会以后面那个作为判断标准
#如果写or就会以前面的作为判断标准
name_filter_3=filter(lambda n : n.startswith('茄'and '大'or'海'and'蛇'),name)
print(list(name_filter_3))

print("///////////////////////////")

#map()
#映射操作使用map()函数，它可以对迭代对象的元素进行变化
#基本格式
#map(function,iterable)
name_2=["JOJO","Dio","Gaiya"]
name_map=map(lambda n:n.lower(),name_2)
print(list(name_map ))
#这里name_2的所有的字符串的字母都变成小写了

#但是这里要特别注意
#Python这里是不支持流式操作的
#就是不同意他在这里链式使用
#举例

name_filter_4=filter(lambda n:n.startswith("J"),name_2)
#这样jojo就被保留了
#这时候如果我们想进行流式操作
name_map_2=map(lambda n:n.lower,name_filter_4)
print(list(name_map_2))
#[<built-in method lower of str object at 0x000001C368D3A570>]
#这是因为我们这个时候的name_filter_4还是filter类型

name_filter_4=filter(lambda n:n.startswith("J"),name_2)
print(list(name_filter_4))
name_map_2=map(lambda n:n.lower(),name_filter_4)
print(list(name_map_2))
#但是这里我们输出的数据就变成了[]
#这说明这里流式操作时有问题

#那我们只能把它写到一个式子里面去了
name_map_3=map(lambda n:n.lower(),filter(lambda n:n.startswith("J"),name_2))
print(list(name_map_3))
#这样就完成了
#要注意的是，虽然规定了function只能写一条语句，但是我们可以在后面iterable里操作

print("////////////////////////////")

#reduce()
#聚合操作会将多个数据整合成数据然后输出单个数据
#最基础的就是归纳函数reduce()
#基本格式
#reduce(function,iterable,initializer)
#initializer表示初始值

import functools
#调用functools模块
aaa=(1,2,3,4,5)
aaa_reduce=functools.reduce(lambda i,acc:acc+i,aaa)
print(aaa_reduce)
#这么我们就算出了aaa中间的数据
#先用lambda生成出两个变量，然后做加法，iterable则是aaa来传递参数
aaa_reduce_2=functools.reduce(lambda i,acc:acc+i,aaa,100)
print(aaa_reduce_2)
#而最后一位就是初始值
aaa_reduce_2=functools.reduce(lambda i,acc:acc*i,aaa,100)
print(aaa_reduce_2)
#这说明如果是初始值
#第一次的运算操作将会从它开始运算

#而我们知道
#字符串也是可迭代变量
#那是不是也可以进行操作呢？

bbb="卡面来打！kuga!"
bbb_reduce=functools.reduce(lambda i,j :i+j,bbb)
print(bbb_reduce)
#数据没有变化
#因为这里只有一个数据
bbb_2=("A",1,2)
#bbb_2_reduce=functools.reduce(lambda i,j :i+j,bbb_2)
#print(bbb_2_reduce)
#TypeError: can only concatenate str (not "int") to str
#报错显示不能让int和str一起连接计算
bbb_3=("A","B","C")
bbb_3_reduce=functools.reduce(lambda i,j :i+j,bbb_3)
print(bbb_3_reduce)
#这里我们就看到它将三个单独的字符串做了加法运算
#字符串的加法就是直接链接在一起


#官方解释：
#将两个参数的 function 从左至右积累地应用到 iterable 的条目，以便将该可迭代对象缩减为单一的值。
# 例如，reduce(lambda x, y: x+y, [1, 2, 3, 4, 5]) 是计算 ((((1+2)+3)+4)+5) 的值。 
# 左边的参数 x 是积累值而右边的参数 y 则是来自 iterable 的更新值。 
# 如果存在可选项 initializer，它会被放在参与计算的可迭代对象的条目之前，并在可迭代对象为空时作为默认值。 
# 如果没有给出 initializer 并且 iterable 仅包含一个条目，则将返回第一项。