六剑客
一行搞定六剑客：三个函数：map filter reduce + lambda 切片 推导列表
python最有特点的一行代码，所有代码均可以借用一行代码（目标）
1.map（函数，列表或者字符串）#字符串或者列表中每个字符或每个元素都带入函数运算
1.map函数：
输出结果为列表
1）列表元素的map运算，
>>> map(s,[1,2,3])
[2, 3, 4]
2）字符串元素的map运算，函数用lambda实现
>>> map(lambda x:x.upper(),"abc")
[‘A‘, ‘B‘, ‘C‘]
3）函数自定义，应用自定义函数套用将列表或字符串中每个元素输出，
实例：自定义函数map
>>> def uppercase(s):
... if s>=‘A‘ and s<=‘Z‘:
... return s
... else:
... return ""
...
>>> print "".join(map(uppercase,"AABBabAN"))
AABBAN
实例：使用map函数，将一个字符串中的小写字母删除掉，例如：“AABBaabb”,
结果返回"AABB"
def delete_lowercase(s):
if s>=‘a‘ and s<="z":
return ""
else:
return s
print "".join(map(delete_lowercase,"AABBaabb"))
>>> "".join([i for i in map(lambda x:(re.match(r"[ACDEFGHIJKLMNOPQRSTUVWXYZ]*",x).group()),"asdASD") if i!=""])
‘ASD‘、
2.filter 两个参数（自定义函数名，列表）对列表中的元素过滤后输出
filter实例：
>>> def uppercase(s):
... if s>=‘A‘ and s<=‘Z‘:
... return s
... else:
... return ""
...
>>> print "".join(map(uppercase,"AABBabAN"))
AABBAN
>>> print "".join(filter(uppercase,"AABBabFN"))
AABBFN
>>>
实例：
filter(lambda x:x in string.uppercase,"AAaaSSBB")
reduce(lambda x,y:x+y,range(1,101))
3、reduce （函数名，列表）将列表中的元素逐一累计
累加
>>> print reduce(lambda x,y:x+y,range(1,101))
5050
阶乘
>>> print reduce(lambda x,y:x*y,range(1,5))
24
>>> print reduce(lambda x,y:x*y,range(1,7))
720
实例：
list_a=[1,1,1,3,5,6,8]
func=lambda x,y:x if y in x else x + [y]
print reduce(func,[[],]+list_a)
4.lambda函数，变量：运算表达式：将变量按运算表达式运算后输出
语法：变量：运算表达式 如 x:x+1
引用： 函数名（变量赋值） a(1)
>>> a=lambda x:x+1
>>> a(4)
5
>>> a=lambda x,y,z:(x+y)*z
>>> a(1,1,4)
8
>>> a=lambda x:s*x
>>> s=1
>>> a(5)
两个参数lambda函数
import string
fp = open("e:\\1.txt","w")
content=map(lambda x,y:x+","+str(y)+"\n",list(string.lowercase),range(1,27))
fp.writelines(content)
list_a=[1,1,1,3,5,6,8]
func=lambda x,y:x if y in x else x + [y]
print reduce(func,[[],]+list_a)
5.推导列表 结果表达式+范围+条件
[str(a)*i for i in range(1,times+1)]
实例：将列表中的每个元素变为重复字符串，如1 变为 a 2变为 aa 3变为aaa
a=int(raw_input("input a value:"))
times=int(raw_input("input count times:"))
print u"总和为：",eval("+".join([str(a)*i for i in range(1,times+1)]))
字符串转换后 用+合并 并用eval 转为求和
列表推导式是Python基础，好用，而又非常重要的功能，也是最受欢迎的Python特性之一，可以说掌握它是成为合格Python程序员的基本标准。本质上可以把列表推导式理解成一种集合了变换和筛选功能的函数，通过这个函数把一个列表转换成另一个列表。注意是另一个新列表，原列表保持不变。
看示例：
（1）对列表中的每项元素进行立方运算（变换功能）
a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
b = [x ** 3 for x in a]
print(a)
print(b)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[1, 8, 27, 64, 125, 216, 343, 512, 729, 1000]
（2）对列表中为偶数的元素进行立方运算（带筛选条件的变换功能）
a= [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
b = [x ** 3 for x in a if x % 2 == 0]
print(b)
[8, 64, 216, 512, 1000]
从结果上可以看出有筛选条件的话是先筛选再变换，即先筛掉不满足条件的元素，再进行变换运算。可以同时加多个筛选条件，如对大于5的且是偶数的元素进行立方运算，示例如下：
a= [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
b = [x ** 3 for x in a if x % 2 == 0 if x > 5]
print(b)
[216, 512, 1000]
（3）与zip结合
将a，b两个列表中相对应得值组合起来，形成一个新列表。例如包含x坐标的列表与y坐标的列表形成相对应的点坐标[x, y]列表。
a= [-1, -2, -3, -4, -5, -6, -7, -8, -9, -10]
b = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
xy = [[x, y] for x, y in zip(a, b)]
print(xy)
[[-1, 1], [-2, 2], [-3, 3], [-4, 4], [-5, 5], [-6, 6], [-7, 7], [-8, 8], [-9, 9], [-10, 10]]
（4）支持多层for循环
将一个嵌套列表转换成一个一维列表。
a= [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
b = [j for i in a for j in i]
print(b)
[1, 2, 3, 4, 5, 6, 7, 8, 9]
Python中还有字典推导式、集合推导式等，与列表推导式使用方式大致相同。
列表推导式的使用非常广泛，从实际使用经验来看，列表推导式使用的频率是非常高的，也是相当好用的。而对于列表推导式的多层for循环，尤其是3层以上的或带复杂筛选条件的，牺牲了较多的可读性，直接用多个普通for循环方式实现就可以了，毕竟方便的实现功能是第一位的，多几行代码就多几行吧。
实例：杨辉三角：
#coding=utf-8
def yhtriangle(n):
l=[1]
print l
while n>0:
l=[1]+[x+y for x,y in zip(l[:],l[1:])]+[1]
n-=1
print l
yhtriangle(10)
6、切片
切片语法如下：
s[begin : end : stride]
与简单切片语法相比，扩展切片只是增加了第3个参数，即步长参数（英文资料中通常称为"stride"或"step"）。
扩展切片语法引入的"stride"参数是个需要特别注意的参数，因为它的正/负取值将会影响切片操作对源序列s的访问方向，而这正是本文开始那几个示例可能引起Python新手困惑的原因。
其实规则很简单，说穿不值一文钱：
1) 当stride参数为正值（positive）时，表明切片操作从左至右（即正向）访问源序列s的元素，此时，若begin和end参数有缺省，则Python解释器默认将其设置为None。如s[0 : : 1]会被解释器当作s[0 : None : 1]，此时，end实际取值要大于其有效索引范围的上限值，以保证切片操作能访问到源序列s从begin开始的所有元素（从左向右）。
2) 当stride参数为负值（negative）时，表明切片操作从右至左（即逆向）访问源序列s的元素，此时，若begin和end参数有缺省，则Python解释器默认将其设置为None。如s[-1 : : -1]会被解释器当作s[-1 : None : -1]，此时，end实际取值要小于其有效索引范围的下限值，已保证切片操作能访问到源序列s从begin开始的所有元素（逆向，从右向左）。
3) 无论stride参数取正值还是负值，切片表达式的begin和end索引值需要保证在切片操作的访问方向上，从begin到end之间有元素，这样切片操作才能保证返回非空集。
s[4,8,1]
切片实例：
import os
os.system("ls -al > a.txt")
with open("a.txt") as fp:
for i in fp:
if "1.py" in i:
print i.split()[-2]#倒数第二位
break
>>> l=[1,2,3,4,5,6]
>>> l[:]
[1, 2, 3, 4, 5, 6]
>>> l[1:]
[2, 3, 4, 5, 6]
l[:]
l[1:]