day16

def test():
    print('test')
def test1():
    print('test1')
    return test#注意，这样return一个函数。
res = test1()#res接收到了test函数的地址，所以res就代表了test
res()#所以直接执行res()就相当于运行了test函数
print(res())#由于test()没有指定返回值，故返回None
##启示：函数格式 test() 启示是test的函数地址+()构成的。
result:
test1
test
test#由于执行的事print(res()) 所以又调用了一次res() 所以又输出一次test
None

###################################
name='faker'
def faker():
    name='is'
    def sb():
        name='sb'
        print(name)
    return sb
a = faker()#接受sb函数的地址 
a()#所以执行这句就相当于在执行sb函数（跟之前把执行语句卸载外层函数中并没有什么区别，都是调用内存地址进行执行）

result:
sb
####################################


####################################
name='faker'
def faker():
    name='is'
    def sb():
        #name='sb'
        print(name)
    return sb
a = faker()
a()
result:
is
####################################

####################################
name='faker'
def faker():
    #name='is'
    def sb():
        #name='sb'
        print(name)
    return sb
a = faker()
a()

result:
faker
####################################

####################################
name='faker'
def faker():
    #name='is'
    def sb():
        #name='sb'
        print(name)
    return sb
faker()()#注意这种调用方式

result:
faker
####################################

#所以说 我们要记得，函数定义和函数执行是两回事儿。函数作用域和定义有关，和在哪调用没有一毛钱关系。
返回值可以是一个函数名。


#####匿名函数
lambda x:x+1##语法结构
## lambda 参数:返回值
#相当于
def clac(x):
    return x+1
##
func = lambda x:x+1#这么去用  用匿名函数就没有任何意义了。这只是演示匿名函数是个什么玩意儿。
print(func(1))

lambda通常是跟其它函数联用。#逻辑很简单的才用匿名函数
lambda a,b,c:x+y+z

#利用lambda返回多个返回值：
lambda a,b,c:(a+1,b+1,c+1)#把后面搞成一个元组的形式。

-面向过程编程#代码繁琐，可读性强
-函数式编程#代码精简，可读性差 python并不是严格的函数式编程语言。
    函数式=编程语言定义的函数+数学意义的函数
    1、函数式编程不允许用变量来保存状态，不可以修改变量值
    2、尾递归调用优化
        return foo()#尾递归调用
        return foo()+1 #非尾递归调用
    3、尾调用：在函数的最后一步调用另一个函数（最后一步并不等同于最后一行）

    map函数
        map() 会根据提供的函数对指定序列做映射。第一个参数 function 以参数序列中的每一个元素调用 function 函数，返回包含每次 function 函数返回值的新列表。
        map(function, iterable, ...)

        num_l = [1,2,3]
        def map_test(func,array):#map方法就是这个逻辑
            ret = []
            for i in num_l:
                res = func(i)
                ret.append(res)
            return ret
        ret = map_test(lambda x:x+1,num_l)
        print(ret)
        result:
        [2, 3, 4]

        #真正的map函数
        num_l = [1,2,3]
        ret = map(lambda x:x+1（处理逻辑==函数名）,num_l（可迭代对象）)#一个迭代器，迭代器只能迭代一次 可以用for循环进行迭代 第一个参数不一定要是匿名函数，也可以是有名的函数的
        print(list(ret))
        result:
        [2, 3, 4]

    filter函数
    sb = ['sb_faker','sb_bangji','ma_sb_ta','faker']
    res = []
    for i in sb:
        if i.find('sb') == -1:
            res.append(i)
    print(res)
    result:
    ['faker']

    l = [1,2,3]
    所以，map(str,l)#是完全可以的。
    ####正式的filter函数
    filter(lambda n:n.endswith('sb')（处理逻辑==函数）,num_l（可迭代对象）) 返回的东西和map是一样一样的。
    把它强转为list即可。
    filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
    该接收两个参数，第一个为函数，第二个为序列，序列的每个元素作为参数传递给函数进行判断，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。
    filter(function, iterable)


    #reduce()函数
    from functools import reduce
    reduce(function(处理逻辑), iterable（待处理序列）,[initializer（可选的初始值）])
    reduce() 函数会对参数序列中元素进行累积。

    函数将一个数据集合（链表，元组等）中的所有数据进行下列操作：用传给reduce中的函数 function（有两个参数）先对集合中的第 1、2 个元素进行操作，得到的结果再与第三个数据用 function 函数运算，最后得到一个结果。

总结：
    map()处理序列中的每个元素，得到的结果是一个迭代器，该迭代器元素个数与位置与原来的一样。
    map_demo:
    map_test = [1,2,3]
    res = map(lambda x:x*2,map_test)
    res = list(res)
    print(res)
    result:
    [2, 4, 6]
    filter()遍历序列中的每个元素，判断每个元素，得到bool值，如果是True,则留在迭代器中。
    filter_demo:
    filter_demo = ['sb1','2sb','4sb5','2b']
    res = filter(lambda x:x.find('sb')==-1,filter_demo)
    res = list(res)
    print(res)
    result:
    ['2b']

    reduce()处理一个序列，把序列进行合并操作。注意，reduce返回的直接是一个值，而不是迭代器。
    reduce_demo:
    from functools import reduce
    reduce_test = [1,2,3,4,5]
    res1 = reduce(lambda x,y:x*y,reduce_test)
    print('res1=',res1)
    res2 = reduce(lambda x,y:x*y,reduce_test,10)#10为初始值
    print('res2=',res2)
    result:
    res1= 120
    res2= 1200

-面向对象编程

内置函数：
    abs(数字)#取绝对值。
    all(可迭代序列)#会把所有元素的bool值进行bool与运算。序列所有的元素都为True，结果才是True.注意，如果可迭代序列为空，则返回True.一定要注意参数是可迭代序列。
    any(可迭代序列)#会把所有元素的bool值进行bool或运算。有真就返回True.注意，如果可迭代序列为空，则返回False.总之，一切都跟all对着干。
    bin(整数)#将数字转化成二进制，带前导0b
    bool(object)#判断一个对象是True还是False
    bytes(对象名,encoding='utf-8等等')#通过编码方式编码成二进制
    变量.decode('utf-8')#通过utf-8方式解码。
    chr(97)#按照ascii表进行转换  这样会输出'a'
    dir(对象名)#获取对象中的全部方法
    divmod(被除数,除数)#结果为元组(商,余数) 用来做分页功能很好用
    eval(str)#执行一个字符串表达式，并返回表达式的值（去掉外侧的字符串标记，并返回运算后的值）
        name = '1+3'
        print(eval(name))
    hash(对象)#可hash的数据类型即不可变数据类型。1、不管你传进来的东西有多长，我运算出来的结果长度都一样。2、不能根据hash的结果反推原来的值。3、如果某个东西的hash没有改变，证明这个东西本身也没有被改变过。
    help(对象名)#对象中的方法怎么用。
    hex(数字)#编码为16进制。
    oct(数字)#编码为8进制。
    isinstance(obj,data type)#如果匹配，返回True，如果不匹配，返回False.
    globals()#返回全部的全局变量组成的字典
    locals()#返回全部的局部变量组成的字典
    max(可迭代对象)#返回可迭代对象中最大的东西，可以是ascii，也可以是别的。当然啦，要求是同类型的才能比较。
    min(可迭代对象)#作用和max是反着的。