16python学习 作用域 匿名函数 map filter reduce内置函数

http://www.cnblogs.com/linhaifeng/articles/6113086.html#_label11

# 函数的作用域只跟函数声明时定义的作用域有关，跟函数的调用位置无任何关

name = 'alex'
def foo():
    name='linhaifeng'
    def bar():
        # name='wupeiqi'
        print(name)
    return bar      #返回的是地址
a=foo()           
print(a)                #打印内存地址
a() #bar()         #执行bar（）函数
结果 

<function foo.<locals>.bar at 0x00000000028C98C8>
linhaifeng

name='alex'
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()
以上几个等效于foo()()()  

匿名函数

# lambda x:x+1
# 关键字 lambda 等效于x是形参，x+1是返回值表达式

def calc(x):
    return x+1

res=calc(10)
print(res)
print(calc)

print(lambda x:x+1)     # 打印出来是地址
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)


name='alex' #修改成name='alex_sb'
     # 关键字+形参+子代码       加载完直接释放掉，想要保存下来就要弄个名字
func=lambda x:x+'_sb'
res=func(name)
print('匿名函数的运行结果',res)

name1='alex'
name2='sbalex'
name1='supersbalex'
def test(x,y,z):
    return x+1,y+1       #-----> 返回会自动加括号变成元祖形式 (x+1,y+1)

print(test(1,2,3))              #等效于print
lambda x,y,z:(x+1,y+1,z+1)     #返回多个值要自己加上元祖的括号

编程的方法论 流派

• 面向过程：根据业务逻辑从上到下一步步写垒代码
• 函数式：将某功能代码封装到函数中，日后便无需重复编写，仅调用函数即可 了解一下
• 面向对象：对函数进行分类和封装，让开发“更快更好更强...”

https://blog.csdn.net/letunihao/article/details/51232359

高阶函数 
1。函数接收的参数是一个函数名  2#返回值中包含函数
把函数当作参数传给另外一个函数，也就是函数接收的参数是一个函数名
def foo(n): #n=bar
    print(n)

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

foo(bar)                 #输出地址
foo(bar('ddd'))          #输出        my name is ddd         None


返回值中包含函数
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()          #h是函数地址，h()是执行函数


def test1():
    print('from test1')
def test2():
    print('from handle')
    return test1()        #这里是return test1（）的返回值

1不可变：不用变量保存状态，不修改变量

2函数即变量

函数名可以当参数传递，返回值可以是函数名

3尾调用方法解决问题

在函数的最后一步调用进入另外一个函数（最后一行不一定是函数的最后一步 例如if语句中），

最后一步状态不用保存在堆栈中

注意，这个不是尾调用

def bar(n):
    return n
def foo(x) :
    return  bar(x)+1        #这里是先执行bar(x)后的值再加1,最后一步不是调用其他函数

map函数

num_l=[1,2,10,5,3,7]
num1_l=[1,2,10,5,4,9]
得到列表值的平方

def map_test(array):
    ret=[]
    for i in array:
        ret.append(i**2)
    return ret

ret=map_test(num_l)
rett=map_test(num1_l)
print(ret)
print(rett)

num_l=[1,2,10,5,3,7]
#lambda x:x+1
def add_one(x):         #先定义好处理逻辑的函数
    return x+1

lambda x:x-1
def reduce_one(x):
    return x-1

#lambda x:x**2
def pf(x):
    return x**2

def map_test(func,array):     #把处理列表的逻辑处理函数和列表一起传给函数
    ret=[]
    for i in num_l:
        res=func(i)         #add_one(i)
        ret.append(res)
    return ret
print(map_test(add_one,num_l))       #把处理列表的逻辑处理函数和列表一起传给函数
print(map_test(lambda x:x+1,num_l))    #写成匿名函数的形式，就不用先声明定义逻辑函数

print(map_test(reduce_one,num_l))
print(map_test(lambda x:x-1,num_l))

print(map_test(pf,num_l))
print(map_test(lambda x:x**2,num_l))



终极版本

def map_test(func,array): #func=lambda x:x+1    arrary=[1,2,10,5,3,7]
    ret=[]
    for i in array:
        res=func(i) #add_one(i)
        ret.append(res)
    return ret

print(map_test(lambda x:x+1,num_l))

内置函数map
res=map(lambda x:x+1,num_l)      #一个逻辑函数，+可迭代对象  将对象for循环给函数，
                                # 最后得到结果也是可迭代对象可以加list变成列表
print('内置函数map，处理结果',res) # res打印出来的是地址
for i in res:
    print(i)
print(list(res))      #以列表的形式显示
print('传的是有名字的函数',list(map(reduce_one,num_l)))


msg='linhaifeng'
print(list(map(lambda x:x.upper(),msg)))
#结果['L', 'I', 'N', 'H', 'A', 'I', 'F', 'E', 'N', 'G']  内部for循环变成一个一个

filter函数

movie_people=['sb_alex','sb_wupeiqi','linhaifeng','sb_yuanhao']  # 过滤掉开头sb的人

def filter_test(array):
    ret=[]
    for p in array:
        if not p.startswith('sb'):        #取反逻辑用not
               ret.append(p)
    return ret

res=filter_test(movie_people)
print(res)


movie_people=['alex_sb','wupeiqi_sb','linhaifeng','yuanhao_sb']
def sb_show(n):
    return n.endswith('sb')

def filter_test(func,array):       #处理的函数也是传进来的
    ret=[]
    for p in array:
        if not func(p):
               ret.append(p)
    return ret

res=filter_test(sb_show,movie_people)
print(res)

终极版本
movie_people=['alex_sb','wupeiqi_sb','linhaifeng','yuanhao_sb']
def sb_show(n):
    return n.endswith('sb')
--->lambda n:n.endswith('sb')

def filter_test(func,array):
    ret=[]
    for p in array:
        if not func(p):
               ret.append(p)
    return ret

res=filter_test(lambda n:n.endswith('sb'),movie_people)
print(res)

filter函数         
第一个参数也是一个函数，有名或者匿名函数都可以，
第二个参数可以是列表，字符串 ，字典等可迭代对象
将第二个参数可迭代对象for循环的方式传给第一个函数处理，
以True 

保留以列表形式保存 False 去掉  ，注意可以在函数上取反not

movie_people=['alex_sb','wupeiqi_sb','linhaifeng','yuanhao_sb']
print(filter(lambda n:not n.endswith('sb'),movie_people))
打印出来的是一个内存地址，要list才能显示

res=filter(lambda n:not n.endswith('sb'),movie_people)
print(list(res))


print(list(filter(lambda n:not n.endswith('sb'),movie_people)))

reduce函数

from functools import reduce   #先导入模块才能用reduce


num_l=[1,2,3,100]

res=0
for num in num_l:
    res+=num

print(res)

num_l=[1,2,3,100]
def reduce_test(array):
    res=0
    for num in array:
        res+=num
    return res

print(reduce_test(num_l))


num_l=[1,2,3,100]

def multi(x,y):
    return x*y
lambda x,y:x*y

def reduce_test(func,array):
    res=array.pop(0)
    for num in array:
        res=func(res,num)
    return res

print(reduce_test(lambda x,y:x*y,num_l))

num_l=[1,2,3,100]
def reduce_test(func,array,init=None):
    if init is None:
        res=array.pop(0)
    else:
        res=init
    for num in array:
        res=func(res,num)
    return res

print(reduce_test(lambda x,y:x*y,num_l,100))


#reduce函数
from functools import reduce       #先导入模块才能用reduce
num_l=[1,2,3,100]
print(reduce(lambda x,y:x+y,num_l,1))#函数，对象，初始值1
print(reduce(lambda x,y:x+y,num_l))

小结

## map()处理序列中的每个元素，得到的结果是一个‘列表’，该‘列表’元素个数及位置顺序与原来一样


#filter遍历序列中的每个元素，判断每个元素得到布尔值， 如果是True则留下来，
# 把列表中的值筛选一遍得到另一个列表

people=[
    {'name':'alex','age':1000},
    {'name':'wupei','age':10000},
    {'name':'yuanhao','age':9000},
    {'name':'linhaifeng','age':18},
]
print(list(filter(lambda p:p['age']<=18,people)))


#reduce:处理一个序列，然后把序列进行合并操作  得到一个值

from functools import reduce
print(reduce(lambda x,y:x+y,range(100),100))
print(reduce(lambda x,y:x+y,range(1,101)))

内置函数

print(abs(-1))  #取绝对值
print(abs(1))

print(all([1,2,'1']))     #后边跟一个序列，把序列中每一个元素拿出来做布尔运算 所有True才为真，
print(all([1,2,'1','']))       #只能给一个参数序列
print(all(''))            #if the iterable is empty, return True.

print(any([0,'']))    #f
print(any([0,'',1]))


print(bin(3))     # 十进制转二进制   ob11

空，None，0的布尔值为False，其余都为True
print(bool(''))
print(bool(None))
print(bool(0))

name='你好'
print(bytes(name,encoding='utf-8'))  # 输出编码b'\xe4\xbd\xa0\xe5\xa5\xbd' ，一个中文字符用utf8表示用3个字节，把字符串做编码
print(bytes(name,encoding='utf-8').decode('utf-8'))    #decode('utf-8')用utf8做解码    输出 你好

print(bytes(name,encoding='gbk'))               #gbk一个中文两个字节
print(bytes(name,encoding='gbk').decode('gbk'))     #编码，解码要同一种

print(bytes(name,encoding='ascii'))     #ascii不能编码中文

print(chr(46))

print(dir(dict))       #打印某一个对象内置的方法

print(divmod(10,3))        #10除以3取商得余，以元祖形式  用来分页功能，分第几页第几条

加   enumerate

dic={'name':'alex'}        #字典转换str
dic_str=str(dic)
print(dic_str)        #输出{'name': 'alex'}这个是str的形式，并不是字典
d1=eval(dic_str)           #1把字符串中的数据结构提取出来
print(d1['name'])          #  输出  alex

可hash的数据类型即不可变数据类型，不可hash的数据类型即可变数据类型 ，
检验前后数据的hash值是否改变，验证数据是否被更改
print(hash('12sdfdsaf3123123sdfasdfasdfasdfasdfasdfasdfasdfasfasfdasdf'))
print(hash('12sdfdsaf31231asdfasdfsadfsadfasdfasdf23'))

name='alex'
print(hash(name))
print(hash(name))


print('--->before',hash(name))       # 检验前后数据的hash值是否改变，验证数据是否被更改
name='sb'
print('=-=>after',hash(name))     #输出   --->before -2837957294456996021
                                   #       =-=>after 3576902207639659919


print(help(all))       #打印函数的用法

print(bin(10))#10进制->2进制
print(hex(12))#10进制->16进制
print(oct(12))#10进制->8进制



print(isinstance(1,int))   #判断对象的类型是否正确
print(isinstance('abc',str))
print(isinstance([],list))
print(isinstance({},dict))
print(isinstance({1,2},set))

name='哈哈哈哈哈哈哈哈哈哈哈哈哈哈啊哈粥少陈'
print(globals())    #打印全局变量
print(__file__)      #打印在对应全局变量下的地址

def test():
    age='1111111111111111111111111111111111111111111111111111111111111'
    # print(globals())
    print(locals())       #打印当前级别的局部变量

test()


l=[1,3,100,-1,2]
print(max(l))
print(min(l))