函数式编程
编程方法论：
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_()以字符串类型导入模块名
