前言
Python有着许多非常有意思的有别于别的高级语言的语法和处理方式，这些特别的变成技巧能够实现更少的代码量，更清晰的语法结构和更高的效率。
软件环境
- 系统
- UbuntuKylin 14.04
- 软件
- Python 2.7.3
- IPython 4.0.0
列表推导式
列表推导式是一种轻量级的循环，是一种利用列表爱创建新的列表的方法。
基本语法格式：
[expr for variable in listName]
- 1
- 1
Example:
In [18]: [x**2 for x in range(10)]
Out[18]: [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
- 1
- 2
- 1
- 2
上面例子中使用 List[0,1,2,..,9]和列表推导式生成了一个新的List[0,1,4,..,81]，这还只是一个最基本的用法。
获取被一个数整除的数：
In [20]: [x for x in range(100) if x %5 == 0]
Out[20]: [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]
- 1
- 2
- 1
- 2
在推导式中可以使用if判断语句，相当于下面的语句块：
In [21]: newList = []
In [22]: for x in range(100):
....: if x % 5 == 0:
....: newList.append(x)
....:
In [23]: newList
Out[23]: [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50, 55, 60, 65, 70, 75, 80, 85, 90, 95]
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
相比较，列表推导式能够更加简洁的实现同一样的功能。
求素数：
素数：即质数，简单来说就是不能被(2～N-1)之中任何一个整数整除的数N。其实N只需不被(2～N/2)之间的任何一个整数整除即可为素数，甚至可以将范围缩小到(2~sqrt(N))，以此来提高效率，当然处理的方法会需要改变。
下面是一个使用列表扩展式实现的例子：
[x for x in range(2,100) if not [y for y in range(2,int(x/2+1)) if x % y == 0]]
- 1
- 1
等效于：
primes = []
for x in range(2,100): #1不是素数
li = [] #临时的List对象，只在for语句块中有效
for y in range(2,x/2+1): #因为在range()中，所以要+1补足
if x % y == 0:
li.append(x)
if not li: #如果临时的li中为空，表示N为素数
primes.append(x)
print primes
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
当li=[]时，表示N在(2～x/2+1)范围内没有被任何一个数整除，即N为素数，append到primes中。
再介绍一种写法：
noprimes = []
for i in range(2,8):
for j in range(i*2,100,i):
noprimes.append(j)
set(noprimes)
primes = []
for x in range(2,100):
if x not in noprimes:
primes.append(x)
print primes
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
这种方法利用了反推的思路，先通过[2~7]的倍数来找出noprimes，在判断N是否在noprimes中。若不在即N为素数。
扩展式的写法：
noprimes = set(j for i in range(2,8) for j in range(i*2, 100,i))
primes = [x for x in range(2,100) if x not in noprimes]
- 1
- 2
- 1
- 2
可以看出扩展式并不仅是List的专属，序列类型(Tuple、dictionary)和set集合类型都可以使用扩展式。而且如上面的例子，因为我们要频繁的去确定一个值是否存在，且元素是唯一的，所以可以选择set扩展式(set集合能更快的查找属性参数)，来提高运行速度。所以，根据具体条件，充分的利用数据结构的特性来选择一个合适的扩展式类型可以有效的提高程序执行效率。
嵌套列表降维：
In [143]: nestLi = [[1,2,3],[4,5,6],[7,8,9]]
In [144]: newLi = [x for para in nestLi for x in para]
In [145]: newLi
Out[145]: [1, 2, 3, 4, 5, 6, 7, 8, 9]
- 1
- 2
- 3
- 4
- 5
- 6
- 1
- 2
- 3
- 4
- 5
- 6
等效于
newLi = []
nestLi = [[1,2,3],[4,5,6],[7,8,9]]
for para in nestLi:
for x in para:
newLi.append(x)
print newLi
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 1
- 2
- 3
- 4
- 5
- 6
- 7
字典的默认值
使用D.get()函数实现。
D.get(k[,d]) -> D[k] if k in D, else d. d defaults to None.
In [153]: dic = {'name':'JMilk','age':23}
In [154]: dic['city'] = dic.get('city','BJ')
In [155]: dic
Out[155]: {'age': 23, 'city': 'BJ', 'name': 'JMilk'}
- 1
- 2
- 3
- 4
- 5
- 6
- 1
- 2
- 3
- 4
- 5
- 6
当一个key(city) not in dict(dic)时，D.get()函数会加入’city’并且使用默认值’BJ’。反之，就不会改变key映射的value。
for…else语句
In [173]: pycat test.py
for x in xrange(5):
if x == 5:
print 'I can find 5!'
else:
print 'I cannot find 5!'
In [174]: run test.py
I cannot find 5!
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
在Python不仅是if语句可以配合使用else语句，for、while语句也可以使用。else语句用来处理跳出上个语句块后的情况，有了else，我们可以不用繁复的去设置状态变量来检查是否程序流是否有重上一个语句块跳出，简单方便。这是Python重视使用真值表应用的一个体现。
交换两个变量的值
In [1]: value1 = 1
In [2]: value2 = 2
In [3]: value1,value2 = value2,value1
In [4]: value1,value2
Out[4]: (2, 1)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
别的语言就会需要一个设置中间变量来完成变量值的交换。
链式比较
In [30]: value1 < value2 < 3
Out[30]: True
- 1
- 2
- 1
- 2
可以使用任意的算术比较运算符
真值测试
Python真值表在运算符详解篇已经有过了介绍，传送门：http://blog.csdn.net/jmilk/article/details/48666475
In [36]: name = 'Jmilk'
In [37]: dic = {'age': 23, 'name': 'Jmilk'}
In [38]: li = ['Hi','Jmilk']
In [39]: if name and dic and li:
....: print 'All True!'
....:
All True!
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
在if语句中，能够写入任意对象，且会直接根据真值表(非0，非空容器类型对象的值为True)来判断其真假，而不一定需要写入判断的条件。
序列类型元素反转
In [51]: str
Out[51]: 'Hello JMilk!'
In [52]: li
Out[52]: ['Hi', 'Jmilk']
In [53]: tup = ('hello','world!')
In [54]: str[::-1]
Out[54]: '!kliMJ olleH'
In [55]: li[::-1]
Out[55]: ['Jmilk', 'Hi']
In [56]: tup[::-1]
Out[56]: ('world!', 'hello')
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
这样做的效率会更高，且进行回文检时，只需要inport == inport[::-1]就可以完成。
回文：正读和反读都相同的字符序列
连接字符串和列表
在Python只需要使用String.join()方法就可以实现将字符串插入到列表的每个元素之间，再返回一个新的字符串。
In [70]: str = ' '
In [71]: li
Out[71]: ['Hi', 'Jmilk']
In [72]: str.join(li)
Out[72]: 'Hi Jmilk'
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 1
- 2
- 3
- 4
- 5
- 6
- 7
Python一切皆对象的思想，造就了非常多的针对数据类型的内建函数。
内置算术函数
Python除了有大量的模块之外，还有着丰富的内置函数。
求和：
In [1]: num = [1,2,3]
In [2]: sum(num)
Out[2]: 6
- 1
- 2
- 3
- 4
- 1
- 2
- 3
- 4
最大值：
In [3]: max(num)
Out[3]: 3
- 1
- 2
- 1
- 2
最小值：
In [4]: min(num)
Out[4]: 1
- 1
- 2
- 1
- 2
乘积：
In [84]: from operator import mul
In [85]: reduce(mul,range(1,5),1)
Out[85]: 24
- 1
- 2
- 3
- 4
- 1
- 2
- 3
- 4
短短的一条语句就能实现1*2*3*4，而且这些简短的语句拥有着更高的执行效率。
求绝对值：
In [1]: a = -100
In [2]: abs(a)
Out[2]: 100
- 1
- 2
- 3
- 4
- 1
- 2
- 3
- 4
求商、余数：
In [6]: divmod(10,3)
Out[6]: (3, 1) #商==3;余数==1
- 1
- 2
- 1
- 2
求平方：
In [11]: pow(2,4)
Out[11]: 16 #相当于 2**4
In [12]: pow(2,4,5)
Out[12]: 1 #相当于 2**4%5
- 1
- 2
- 3
- 4
- 5
- 1
- 2
- 3
- 4
- 5
求浮点数：
In [14]: round(1)
Out[14]: 1.0
- 1
- 2
- 1
- 2
利用zip()来创建键值对
zip(seq1 [, seq2 […]]) -> [(seq1[0], seq2[0] …), (…)]
将两个序列参数，转换成Tuple和List的组合。
In [175]: keys = ['Name', 'Sex', 'Age']
In [176]: values = ['Tim', 'Male', 23]
In [177]: zip(keys, values)
Out[177]: [('Name', 'Tim'), ('Sex', 'Male'), ('Age', 23)]
In [178]: dict(zip(keys,values))
Out[178]: {'Age': 23, 'Name': 'Tim', 'Sex': 'Male'}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
最后
利用本篇介绍的一些Python的特性，能使程序 写法更加简练、高效和更少的代码量。
转载：http://blog.csdn.net/jmilk/article/details/49657569
