Python高阶函数及sorted函数原理

def counter(base):
    def inc(step=1):
        nonlocal base
        base += step # base = base + step ,使用局部变量，但是此没有base局部变量，需要使用nonlocal base，申明为不是本地变量向外找，则形成闭包
        return base
    return inc

f = counter(10)

print(f())

#输出 
11

f1 = inc(5)
f2 = inc(5)
f1 is f2,f1 == f2,id(f1),id(f2) #函数内容无法比较,会转换成比较内存地址，即转换成f1 is f2

结果都是False 
‘‘‘
f1,f2都是指向内部函数inc,每次调用counter函数执行都需要创建栈针、压栈、将函数值返回弹出栈顶，之后counter函数消亡，但存在闭包f1记录了inc函数的内存地址，每次都是全新的函数调用,
所以f1 f2内存地址不一样，函数之间无法比较内容，会隐式转换成比较内存地址即 f1 == f2 --> f1 is f2  
‘‘‘

#No 1 升序打印
def sort(iterable,*, key=None, reverse=False):
    newlist = []
    for x in iterable:
        for i,y in enumerate(newlist):
            if x < y:  #只要将此<于号，换成大于号则是倒序打印
                newlist.insert(i,x)
                break
        else:
            newlist.append(x)
    return newlist

print(sort([1,9,8,5]))
#[1,5,8,9]

def sort(iterable,*, key=None, reverse=False):
    newlist = []
    for x in iterable:
        for i,y in enumerate(newlist):
            compare = x > y if reverse else x < y #默认值是false 走的是 x<y
            if compare:
                newlist.insert(i,x)
                break
        else:
            newlist.append(x)
    return newlist
print(sort([1,9,8,5],reverse=True))
#[9,8,5,1]

def sort(iterable,*, key=None, reverse=False):
    newlist = []
    for x in iterable:
        cx = key(x) if key else x
        for i,y in enumerate(newlist):
            cy = key(y) if key else y
            compare = cx > cy if reverse else cx < cy
            if compare:
                newlist.insert(i,x)
                break
        else:
            newlist.append(x)
    return newlist
#print(sort([1,9,8,5,‘a‘],key=str))
print(sort([1,9,8,5,‘a‘],key=lambda x : str(x)))

sorted([1,9,8,5,‘a‘],key=str) #报错，不同类型无法比较

sorted([1,9,8,5,‘a‘],key=str)

sorted([1,9,8,5,‘a‘],key=lambda x : str(x))

sorted([1,9,8,5,‘a‘],key=lambda x : int(x,16) if isinstance(x,str) else x)
sorted([1,9,8,5,‘a‘],key=lambda x : ord(‘a‘) if isinstance(x,str) else x)

list(filter(lambda x : x%3 !=0 ,range(5)))
[1,2,4]

list(filter(lambda x : x%3 ==0 ,range(5)))
[0,3]

list(filter(None,range(5))) #如果filter第一个参数为None，则按照元素本身等效TRUE of false ,false 则过滤掉
[1,2,3,4]

list(filter(None,range(-1,2))) #如果filter第一个参数为None，则按照元素本身等效TRUE of false ,false 则过滤掉
[-1,1,2]


list(filter(lambda x : None,range(5))) #不管写什么都给返回None，则全部过滤
[]

list(map(lambda x : 2 ,range(5))) #按照指定的函数进行映射，则x不管给什么值都是返回2
[2, 2, 2, 2, 2]

list(map(lambda x : 6-x ,range(5))) 
[6, 5, 4, 3, 2]

list(map(lambda x,y: (x,y),‘abced‘ ,range(5)))
[(‘a‘, 0), (‘b‘, 1), (‘c‘, 2), (‘e‘, 3), (‘d‘, 4)]


dict(map(lambda x : x, zip(‘abced‘ ,range(5))))  # 等效 dict(zip(‘abced‘ ,range(5)))

{‘a‘: 0, ‘b‘: 1, ‘c‘: 2, ‘e‘: 3, ‘d‘: 4}

#但是使用map能对原有元素进行变形比较方便，如下所示：
dict(map(lambda x : (x[0],str(x[1])), zip(‘abced‘ ,range(5))))