一：map():映射
map()函数在python2和python3中是区别的
python2中的定义：映射后，返回一个列表
>>> help(map)
Help on built-in function map in module __builtin__:
map(...)
map(function, sequence[, sequence, ...]) -> list
Return a list of the results of applying the function to the items of
the argument sequence(s). If more than one sequence is given, the
function is called with an argument list consisting of the corresponding
item of each sequence, substituting None for missing values when not all
sequences have the same length. If the function is None, return a list of
the items of the sequence (or a list of tuples if more than one sequence)
python3中的定义：映射后，返回一个迭代器，
>>> help(map)
Help on class map in module builtins:
class map(object)
| map(func, *iterables) --> map object
|
| Make an iterator that computes the function using arguments from
| each of the iterables. Stops when the shortest iterable is exhausted.
map()有两个参数，一个函数，一个序列,序列中每一个元素都会做为参数传给前边的函数，然后生成新的对象（python2中是list，python3中是iterator），第二个参数必须用一个序列：元祖，列表，字符串
python2中的map():
>>> map(str,[1,2,3,4])
['1', '2', '3', '4']
python3中的map():
搭配lambda函数
>>> map(lambda x:x.upper(),"abc")
['A', 'B', 'C']
map()函数搭配lambda传多个参数
python2:
例子：2个list,[1,2,3][4,5,6],合并为[(1, 4), (2, 5), (3, 6)]
>>> a=[1,2,3]
>>> b=[4,5,6]
>>> map(lambda x,y:(x,y),a,b)
[(1, 4), (2, 5), (3, 6)]
python3:
>>> map(lambda x,y:(x,y),a,b)
<map object at 0x000001FF1FFAEEF0>
>>> type(map(lambda x,y:(x,y),a,b))
<class 'map'>
>>> list(map(lambda x,y:(x,y),a,b))
[(1, 4), (2, 5), (3, 6)]
也可以自己定义函数
map()传多个参数（序列）时，每次取元素进行map时，是在每个序列的相同位置取值，
然后作为一个元祖传给参数前边的函数的，所以用这个原理，把函数设置None,也可以生成题中的结果,由此也能看到map函数在取值时的逻辑
>>> map(None,list1,list2)
[(1, 4), (2, 5), (3, 6)]
或者用zip()函数也可以，zip()函数在python2和python3中也是有区别的
python2中的zip()：
>>> zip(a,b)
[(1, 4), (2, 5), (3, 6)]
python3中的zip()：
>>> a = [1,2,3]
>>> b = [4,5,6]
>>> zip(a,b)
<zip object at 0x000001FF1FFA2D48>
>>> type(zip(a,b))
<class 'zip'>
>>> list(zip(a,b))
[(1, 4), (2, 5), (3, 6)]
二：lambda匿名函数
lambda语句被用来创建新的函数对象，并且在运行时返回它们。
Python使用lambda关键字来创建匿名函数。这种函数得名于省略了用def声明函数的标准步骤。
lambda只是一个表达式，函数体比def简单很多
lambda的主体是一个表达式，而不是一个代码块。仅仅能在lambda表达式中封装有限的逻辑进去。
#如下边例子，x,y,z相当于匿名函数中的参数，x+y+z是函数体，匿名函数的定义赋值给了a，a就是一个函数，可以用a()来调用这个函数
>>> a=lambda x,y,z:x+y+z
>>> a(1,2,3)
6
三：filter()
filter和map的区别是，filter保留函数返回为true的值，不返回的不显示
map是保留返回的结果，无论返回的是啥，filter会把不满足true条件的结果忽略掉
例子：删除字符串中的小写字母
#encoding=utf-8
def delete_lowercase(s):
if s>='a' and s<='z':
return ""
else:
return s
print map(delete_lowercase,"AABBaabb")
print "".join(map(delete_lowercase,"AABBaabb"))
结果：
D:>python test.py
['A', 'A', 'B', 'B', '', '', '', '']
AABB
保留数字中大于5的位
#-*-coding:utf-8-
def func(n):
if int(n)>5:
return n
print filter(func,"123467")
#只要return的是True，就会保留
结果：
D:>python test.py
67
或者一行搞定
>>> filter(lambda x:int(x)>=5,"12345678")
'5678'
filter()根据参数中的序列，返回相同形式的序列，列表返回列表，字符串返回字符串
或者一行搞定
>>> filter(lambda x:int(x)>=5,"12345678")
'5678'
>>> filter(lambda x:int(x)>=5,list("12345678"))
['5', '6', '7', '8']
>>> filter(lambda x:int(x)>=5,"12345678")
'5678'
>>> filter(lambda x:int(x)>=5,tuple("12345678"))
('5', '6', '7', '8')
python3:
>>> filter(lambda x:int(x)>5, "12346789")
<filter object at 0x000001BB7FE7EE48>
>>> list(filter(lambda x:int(x)>5, "12346789"))
['6', '7', '8', '9']
>>> tuple("12345678")
('1', '2', '3', '4', '5', '6', '7', '8')
四：推导列表
>>> [i for i in range(10)]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
相当于把for循环中每次循环得到的数作为一个列表的一个元素，知道所有循环执行结束
各个元素生成的过程相当于以下两句得到的：
for i in range(10):
print i
>>> [i for i in range(10) if i !=5]
[0, 1, 2, 3, 4, 6, 7, 8, 9]
练习：a=[[1,2,3],[4,5,6]]用推导列表生成[[1, 4], [2, 5], [3, 6]]
[[j[i] for j in a] for i in range(3)]
结果：
[[1, 4], [2, 5], [3, 6]]
以上推导列表过程转换成for循环：最外层的for也对应转换成for循环的最外层
>>> for i in range(3):
... print "
**************"
... for j in a:
... print j[i],
...
结果中有三个元素，每个元素又是包含2个元素的列表，这个元素是执行一次for循环得到的值
拆解过程：
每执行一次完整的循环，生成两个数，这个两个数会以列表的形式作为最后结果列表的一个元素，
也就是说，推导列表的每一步生成的结果会以列表的形式存在，包括最终的结果
>>> for i in range(3):
... print "
**************"
... for j in a:
... print j[i],
...。、，
**************
1 4
**************
2 5
**************
3 6
五：reduce()累计操作
Reduce()累计操作，要搭配函数来执行
>>> reduce(lambda x,y:x+y,[1,2,3,4])
10
第一次x=1,y=2, x+y=3,之后x+y的结果3赋值给x，y为3
第二次x=3,y=3,x+y=6,之后x+y的结果6赋值给x，y为4
第三次x=3,y=4,x+y=10
>>> 1:1+2 2:3+3 3:6+4
>>> reduce(lambda x,y:x+y,range(1,101))
5050
>>> reduce(lambda x,y:x+y,[1,2,3])
6
X=1,y=2
结果3传给x
y从第二次开始存结果
reduce(lambda x,y:x+y+y,[1,2,3])
x=1,y=2,y=2
x=5,y=3,y=3
x+y+y=5+3+3=11
x是5就对了
>>> reduce(lambda x,y:x+x+y,[1,2,3])
x=1,x=1,y=2
x+x+y=1+1+2=4
x=4,x=4,y=3
x+x+y=4+4+3=11
>>> reduce(lambda x,y:x+x+y,['1','2','3'])
x=1,x=1,y=2
x=’112’,x=’112’,y=’3’
x+x+y='1121123'
六：切片，就是数列的切片，比较基本也比较常用
>>> [1,2,3,4,5][3:5]
[4, 5]
练习：用map，lambda，推到列表，正则，join，去掉字符串中的小写字母
>>> import re
>>> "".join([i for i in map(lambda x:(re.match(r"[A-Z]*",x).group()),"abcABC") if i !=""])
'ABC'
拆解过程：
>>> [i for i in map(lambda x:(re.match(r"[A-Z]*",x).group()),"abcABC") if i !=""]
['A', 'B', 'C']
>>> [i for i in range(10)]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> [i for i in range(10) if i !=5]
[0, 1, 2, 3, 4, 6, 7, 8, 9]
>>> map(lambda x:(re.match(r"[A-Z]*",x).group()),"abcABC")
['', '', '', 'A', 'B', 'C']
>>> lambda x:(re.match(r"[A-Z]*",x).group())("abcABC")
<function <lambda> at 0x00000000054EDB38>
>>> re.match(r"[A-Z]*","ABC").group()
'ABC'
练习：统计字符串中一共有几个数字
s="sdfa45ads46723"
#lambda
>>> filter(lambda x:x.isdigit(),list(s))
['4', '5', '4', '6', '7', '2', '3']
>>> len(filter(lambda x:x.isdigit(),list(s)))
7
>>> reduce(lambda x,y:x+y,map(lambda x:x.isdigit(),list("sdfa45ads46723")))
7
>>> reduce(lambda x,y:x+y,map(lambda x:len(x),filter(lambda x:x.isdigit(),[i for i in s][::-1])))
7