函数式编程
编程方法论：
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', '', '']
#找出年龄最大的人
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_()以字符串类型导入模块名