python_08 函数式编程、高阶函数、map、filter、reduce函数、内置函数

函数式编程

编程方法论：

1.面向过程

找到解决问题的入口，按照一个固定的流程去模拟解决问题的流程

（1）.搜索目标，用户输入（配偶要求），按照要求到数据结构内检索合适的任务

（2）表白，表白成功进入3，否则返回1

（3）恋爱，恋爱成功进入4，否则返回1

（4）见家长，同意进入5，否则返回1

（5）结婚

2.函数式编程

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

　　通俗来讲，函数式就是用编程语言去实现数学函数。这种函数内对象的永恒不变的，要么参数就是函数，要么返回值是函数，没有for和while循环，所有的循环都由递归去实现，无变量的赋值（即不用变量去保存状态），无赋值即不改变。

高阶函数：

　　函数接收的参数是一个函数名 或 返回值中包含函数

#把函数当作参数传给另外一个函数
def foo(n):
    print(n)

def bar(n):
    print("my name is %s."%n)

foo(bar)
#foo(bar()) ##报错
foo(bar('alex'))

>>><function bar at 0x0000016DB13372F0>
>>>my name is alex.
None

#返回值中包含函数
def bar():
    print('from bar')

def foo():
    print('from foo')
    return bar
v=foo()
v()

>>>from foo
>>>from bar

 尾递归：

 

map函数：在原有列表中对元素加工，返回列表

#获取列表中每个值的平方、自减一、自加一等逻辑
num_l=[1,2,10,5,3,7]
# v=[]
# for i in num_l:
#     v.append(i**2)
# print(v)
def add_one(n):
    return n+1

def substract_one(n):
    return n-1

def pf_one(n):
    return n**2

#方法一：自己写逻辑
def map_test0(array):
    v=[]
    for i in num_l:
        v.append(i ** 2)
    return v
print(map_test0(num_l))

>>>[1, 4, 100, 25, 9, 49]

#####################
#方法二：利用函数调用逻辑
def map_test1(func,array):
    v=[]
    for i in array:
        v.append(func(i))
    return v
print(map_test1(add_one,num_l))
print(map_test1(lambda x:x+1,num_l))#匿名函数调用逻辑

>>>[2, 3, 11, 6, 4, 8]
>>>[2, 3, 11, 6, 4, 8]

print(map_test1(substract_one,num_l))
print(map_test1(lambda x:x-1,num_l))

>>>[0, 1, 9, 4, 2, 6]
>>>[0, 1, 9, 4, 2, 6]

print(map_test1(pf_one,num_l))
print(map_test1(lambda x:x**2,num_l))

>>>[1, 4, 100, 25, 9, 49]
>>>[1, 4, 100, 25, 9, 49]

map()方法：

#方法三：python内置方法map()相当于map_test1()的逻辑,但返回值为可迭代对象，需添加到列表中
v=map(lambda x:x+1,num_l)
print(list(v))

>>>[2, 3, 11, 6, 4, 8]

#练习，将字符串转换成大写
msg='renjingyue'
v=map(lambda x:x.upper(),msg)
print(list(v))

>>>['R', 'E', 'N', 'J', 'I', 'N', 'G', 'Y', 'U', 'E']

 filter()函数：在原有列表中筛选，获得新的列表

#过滤开头是sb的人
movie_people=['sb_alex','sb_linhaifeng','gangniang']

def filter_test(l):
    r=[]
    for p in l:
        if  not p.startswith('sb'):
            r.append(p)
    return r

print(filter_test(movie_people))

>>>['gangniang']

#进阶版：
def filter_test1(func,l):
    r=[]
    for p in l :
        if not func(p):
            r.append(p)
    return r
print(filter_test1(lambda x:x.endswith('g'),movie_people))

>>>['sb_alex']

#############
#filter内置函数,lambda返回True则添加进列表
print(list(filter(lambda x:x.endswith('g'),movie_people)))

>>>['sb_linhaifeng', 'gangniang']

 

reduce()内置函数：将原有列表中元素压缩，获得一个值

#将列表元素相乘或相加，初始值为变量
num_l=[1,2,3,100]

def add(a,b):
    return a+b

def multi(a,b):
    return a*b

def reduce_test(func,array,init=None):
    if init is None:
        r=array.pop(0)
    else:
        r=init
    for num in array:
        r=func(r,num)
    return r

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

>>>600
>>>600

reduce()用法：

from functools import reduce

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

>>>600

总结：

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

filter():遍历序列中的每个元素，判断每个元素得到布尔值，如果True则留下来

#例：过滤掉年纪超过100岁的人
people=[
    {'name':'alex','age':1000},
    {'name':'wupei','age':10000},
    {'name':'ayua','age':9000},
    {'name':'rjy','age':18},
]

def filter_1(dic):
    l=[]
    for i in dic:
        if  dic['age']<=100:
            l.append(i)
    return l


print(list(filter(filter_1,people)))

print(list(filter(lambda d:d['age']<=100,people)))

>>>[{'name': 'rjy', 'age': 18}]
>>>[{'name': 'rjy', 'age': 18}]

reduce():处理一个序列，将序列进行所需求的（可定义的）合并操作

from functools import reduce
#计算0到100，初始值为0
print(reduce(lambda x,y:x+y,range(0,101)))
#计算0到100，初始值为100
print(reduce(lambda x,y:x+y,range(0,101),100))

>>>5050
>>>5150

 内置函数：

http://www.runoob.com/python/python-built-in-functions.html

abs()：取绝对值

all()：将序列中每个元素作bool运算，全真则为真，若迭代对象为空则为空

any()：将序列中每个元素作bool运算，有一个为真则为真

bin()：将数字转换为二进制

bool()：判断bool值，空，False，0都为False

bytearray()：

bytes()：将字符串转化为字节的形式   

　　　　print(bytes('你好'，encoding='utf-8'))    

　　　　 print(bytes('你好'，encoding='utf-8').decode('utf-8'))

chr()：获取ascii表中内容

　　　　chr(46)   >>>.

dict(): 函数用于创建一个字典

>>>dict()                        # 创建空字典
{}
>>> dict(a='a', b='b', t='t')     # 传入关键字
{'a': 'a', 'b': 'b', 't': 't'}
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))   # 映射函数方式来构造字典
{'three': 3, 'two': 2, 'one': 1} 
>>> dict([('one', 1), ('two', 2), ('three', 3)])    # 可迭代对象方式来构造字典
{'three': 3, 'two': 2, 'one': 1}

dir()：获取每个对象下有哪些方法
divmod()：10/3的结果3余1

print(divmod(10,3))

>>>(3,1)

 enumerate()：enumerate() 函数用于将一个可遍历的数据对象(如列表、元组或字符串)组合为一个索引序列，同时列出数据和数据下标，一般用在 for 循环当中。

>>>seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))       # 下标从 1 开始
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]


#####################
>>>i = 0
>>> seq = ['one', 'two', 'three']
>>> for element in seq:
...     print i, seq[i]
...     i +=1
... 
0 one
1 two
2 three
#####################
>>>seq = ['one', 'two', 'three']
>>> for i, element in enumerate(seq):
...     print i, element
... 
0 one
1 two
2 three

eval()：1.提取字符串中的数据结构，2.用来执行一个字符串表达式，并返回表达式的值。

hash():用于获取取一个对象（字符串或者数值等）的哈希值，可hash的数据类型即不可变数据类型，不可hash的数据类型即可变数据类型。哈希值对同一个变量在一次程序运行中的值是一样的，hash值的长度固定。
help()：查看方法帮助。

hex():10进制转换成16进制

oct()：10进制转换成8进制

isinstance()：判断一个对象是不是所输入类型isinstance(1,int)

globals()：获取全部全局变量

locals()：获取当前局部变量

zip()：拉链，函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。返回的是列表的地址，需加list()返回列表

p={'name':'alex','age':18,'gender':'male'}
print(list(zip(p.keys(),p.values())))

>>>[('name', 'alex'), ('age', 18), ('gender', 'male')]


print(list(zip(['a','bv'],'wers')))

>>>[('a', 'w'), ('bv', 'e')]

max()：获取最大值,传入的数据类型需为可迭代类型

1.max函数处理的是可迭代对象，相当于一个for循环取出每个元素进行比较，注意：不同类型不能进行比较

2.每个元素间进行比较，是从每个元素的第一个位置依次比较，如果这一个位置分出大小，后面的都不需要比较了，直接得出这两个元素的大小

age_dic={'alex_age':18,'wpq':20,'zas':25,'lhf':10}

#默认比较字典的key
print(max(age_dic))

print(max(age_dic.values()))

# zip(age_dic.values(),age_dic.keys())
print(max(zip(age_dic.values(),age_dic.keys())))


>>>zas
>>>25
>>>(25, 'zas')

l1=[
    (6,'a',),
    (9,'c',),
    (3,'a',),
    (5,'a',)
]
print(max(l1))

>>>(9, 'c')

#不同类型数据无法比较大小，相同类型数据相当于遍历每个元素的大小
#找到第一个元素最大后不继续比较大小了
l2=['a10','b12','c10']
print(list(max(l2)))

>>>['c', '1', '0']

#找出年龄最大的人
people=[
    {'name':'alex','age':1000},
    {'name':'wupei','age':10000},
    {'name':'ayua','age':9000},
    {'name':'rjy','age':18},
]

print(max(people,key=lambda dic:dic['age']))

>>>{'name': 'wupei', 'age': 10000}

min()：获取最小值，与max()类似

ord()：传入一个字符，返回字符在ascii码表中的位置

pow()：

print(pow(2,3))  # 2**3
print(pow(3,3,2)) # 3**3%2取余

>>>8
>>>1

reversed()：反转序列元素

round()：四舍五入
slice()：定义切片

l='hello'
s1=slice(3,5)
s2=slice(1,4,2)
print(l[s1])
print(l[s2])

>>>lo
>>>el

sorted()：排序，本质是比较大小，不同类型不能比较

#找出年龄最大的人
people=[
    {'name':'alex','age':1000},
    {'name':'wupei','age':10000},
    {'name':'ayua','age':9000},
    {'name':'rjy','age':18},
]

print(sorted(people,key=lambda dic:dic['age']))

name_dic={'alex':1000,'wp':200,'oo':20}
print(sorted(name_dic))
print(sorted(name_dic.keys()))
print(sorted(name_dic.values()))

print(sorted(name_dic,key=lambda key:name_dic[key]))

print(sorted(zip(name_dic.values(),name_dic.keys())))

>>>['alex', 'oo', 'wp']
>>>['alex', 'oo', 'wp']
>>>[20, 200, 1000]
>>>['oo', 'wp', 'alex']
>>>[(20, 'oo'), (200, 'wp'), (1000, 'alex')]

import==》sys操作系统==》调用_import_()

_import_()以字符串类型导入模块名