Pythonic

• 1.format字符串：

  语法

  它通过{}和:来代替%。

  “映射”示例

  通过位置

  1 2 3 4 5 6

  In [1]:'{0},{1}'.format('kzc',18) Out[1]:'kzc,18' In [2]:'{},{}'.format('kzc',18) Out[2]:'kzc,18' In [3]:'{1},{0},{1}'.format('kzc',18) Out[3]:'18,kzc,18'

  字符串的format函数可以接受不限个参数，位置可以不按顺序，可以不用或者用多次，不过2.6不能为空{}，2.7才可以。

  通过关键字参数

  1 2	In [5]:'{name},{age}'.format(age=18,name='kzc') Out[5]:'kzc,18'

  通过对象属性

  1 2 3 4 5	classPerson:   def__init__(self,name,age):     self.name,self.age= name,age     def__str__(self):       return'This guy is {self.name},is {self.age} old'.format(self=self)
  1 2	In [2]:str(Person('kzc',18)) Out[2]:'This guy is kzc,is 18 old'

  通过下标

  1 2 3

  In [7]: p=['kzc',18] In [8]:'{0[0]},{0[1]}'.format(p) Out[8]:'kzc,18'

  有了这些便捷的“映射”方式，我们就有了偷懒利器。基本的python知识告诉我们，list和tuple可以通过“打散”成普通参数给函数，而dict可以打散成关键字参数给函数（通过和*）。所以可以轻松的传个list/tuple/dict给format函数。非常灵活。

  格式限定符

  它有着丰富的的“格式限定符”（语法是{}中带:号），比如：

  填充与对齐

  填充常跟对齐一起使用

  ^、<、>分别是居中、左对齐、右对齐，后面带宽度

  :号后面带填充的字符，只能是一个字符，不指定的话默认是用空格填充

  比如

  1 2 3 4 5 6

  In [15]:'{:>8}'.format('189') Out[15]:'   189' In [16]:'{:0>8}'.format('189') Out[16]:'00000189' In [17]:'{:a>8}'.format('189') Out[17]:'aaaaa189'

  精度与类型f

  精度常跟类型f一起使用

  1 2	In [44]:'{:.2f}'.format(321.33345) Out[44]:'321.33'

  其中.2表示长度为2的精度，f表示float类型。

  其他类型

  主要就是进制了，b、d、o、x分别是二进制、十进制、八进制、十六进制。

  1 2 3 4 5 6 7 8

  In [54]:'{:b}'.format(17) Out[54]:'10001' In [55]:'{:d}'.format(17) Out[55]:'17' In [56]:'{:o}'.format(17) Out[56]:'21' In [57]:'{:x}'.format(17) Out[57]:'11'

  用，号还能用来做金额的千位分隔符。

  1 2	In [47]:'{:,}'.format(1234567890) Out[47]:'1,234,567,890'

   

  2.用两个元素之间有对应关系的list构造一个dict：

  运用zip可以非常简单的实现：

   

  Python代码  

  1. names = ['jianpx', 'yue']  
  2. ages = [23, 40]  
  3. m = dict(zip(names,ages))  

   

   zip的使用可以help(zip)或者查看官方文档。

   

  3.  交换两个值：

  在其他语言可能要一个临时变量和三句话：

  temp = a

  a = b

  b = tem

  但是在python，一句就ok了，而且不需要临时变量：

  a,b = b,a

  右边的b,a其实可以理解成一个tuple。

   

  4.数量多的字符串相连用join：

  python字符串效率问题之一就是在连接字符串的时候使用‘+’号，例如 s = 's1' + 's2' + 's3' + ...+'sN'，总共将N个字符串连接起来，但是使用+号的话，python需要申请N-1次内存空间，然后进行字符串拷贝。原因是字符串对象PyStringObject在python当中是不可变对象，所以每当需要合并两个字符串的时候，就要重新申请一个新的内存空间（大小为两个字符串长度之和）来给这个合并之后的新字符串，然后进行拷贝。所以用+号效率非常低。建议在连接字符串的时候使用字符串本身的方法join（list），这个方法能提高效率，原因是它只是申请了一次内存空间，因为它可以遍历list中的元素计算出总共需要申请的内存空间的大小，一次申请完。所以上面的例子可以写成s = ''.join(['s1','s2',....,'sN'])

   

  例子是：

   

  Python代码  

  1. #以前是这样写的  
  2. fruits = ['apple', 'banana']  
  3. result = ''  
  4. for f in fruits:  
  5.     result += f  
  6.   
  7. #现在可以这样：  
  8. fruits = ['apple', 'banana']  
  9. result = ''.join(fruits)  

   

  5.判断一个key是否在一个dict里面：

  以前很经常犯的一个mistake是这样做：

   

  Python代码  

  1. if key in dict_example:  
  2.     do something  

   现在要这样写，就不用使用in操作了。

   

  Python代码  

  1. if dict_example.has_key(key):  
  2.     do something  

   

  6.去掉list中的重复元素：

   

  Python代码  

  1. old_list = [1,1,1,3,4]  
  2. new_list = list(set(old_list))  

   

  7.如果对两个都没有重复元素的列表对象，要判断某个元素是否在列表里面的话，当这个列表很大的时候，用set会比list

  的性能要好，因为对于list，本身允许重复元素存在，所以它不是用hash实现的，但是set不一样，它不允许重复元素，看了python源代码，从set的实现源码setobject.c中查找key的函数

  static setentry *

  set_lookkey(PySetObject *so, PyObject *key, register long hash)    

  的接口可以看出它真的使用hash去实现的。   

  所以对于in操作，set的实现是计算这个元素的hash值然后判断，理论上可以达到O(1)

   

   

  8.读文件操作：

  以前是这样写的：

   

  Python代码  

  1. #默认文件存在，不处理Exception的情况  
  2. f = open('filename', 'r')  
  3. while 1:  
  4.     line = f.readline()  
  5.     if not line:  
  6.         break  
  7.     print line  
  8.   
  9. if f:  
  10.     f.close()  

   

  用with关键字可以这样简写了，

   

  Python代码  

  1. from __future__ import with_statement  
  2. with open('filename','r') as f:  
  3.     for line in f:  
  4.         print line  

  具体关于with的可以参考我的这篇文章：http://jianpx.iteye.com/blog/505469

   

  9.  输出数组的index和值：

  以前是要这样写的：

   

  Python代码  

  1. l = [1,3,4]  
  2. for i in xrange(len(l)):  
  3.     print '%d, %d' % (i , l[i])  

  现在可以用enumerate函数帮助你简写：

  Java代码  

  1. l = [1,3, 4]  
  2. for index, value in enumerate(l):  
  3.     print '%d, %d' % (index, value)  

   

  10.  关于使用map、filter、reduce的例子网上很多，这里不细说了，它们的使用也是pythonic的examples

   

  11.分隔一个字符串，去里面的元素，但是空白字符串不要：

  例如， names = 'jianpx, yy, mm, , kk'

   

  Python代码  

  1. names = 'jianpx, mm, yy, , kk'  
  2. name_list = names.split(',')  
  3. result = []  
  4. for name in name_list:  
  5.     if name:  
  6.         result.append(name)  

   

  现在是这样写的：

   

  Python代码  

  1. names = 'jianpx, yy, mm, , kk'  
  2. result = [name for name in names.split(',') if name.strip()]  

   

  12.模拟c语言中的  a?b:c

  在python里面可以这样做：

   

  Python代码  

  1. return_value = True if a == 1 else False  

   从而代替了这样的代码：

   

  Python代码  

  1. if a == 1:  
  2.     return_value = True  
  3. else   
  4.     return_value = False  

   

  13用Decorator抽离公用代码或者解耦

  例如要对一个函数做cache，对一个操作限制权限，如果需求随时可能变化，就是说有可能不需要做cache或者不需要做权限的时候，你如果把实现放到这些函数体里面，那么这时你必须把这些代码删除，而且要很小心。但是如果你用Decorator去做的话， 只要删除函数头顶上的@那一行就可以了。Django经常用这种方法做权限控制。

  熟悉decorator的应该都很容易理解。

    

  14. 如何将list的元素倒序并且生成到新的list呢？ 看到一个用list的slice做到的 :

   

  Python代码  

  1. a = [1,2,3,4]  
  2. c = 'abcdef'  
  3. aa= a[::-1]  
  4. cc = c[::-1]  

   

   如果不用生成新的list，直接调用a.reverse()就得了。但是字符串类型没有reverse的方法.

  关于list的slice特性， 其实也许很多人平时只是用list[start:end] 这样的， 这个意思是从start开始，每个元素都放到新

  的list里面， 直到end。但是其实还可以每个N个元素才取一次的， 这种情况要3个参数: list[start:end:step]

  step就是间隔了。

   

   

  15.   a = [i for i in xrange(5)]  和  a = (i for i in xrange(5))虽然看上去是一样都生成了5个元素，但是

  前者是一个list对象， 如果遍历的话 for item in a就会一下子返回全部元素然后再遍历， 而后者是个Generator，

  用for item in a遍历是每次只是返回一个元素， 这样的好处是省内存（在list很大的情况下）。

   

   

  16. python的all函数可以简化逻辑表达式很多”与“的时候的写法，比如：

  a, b, c = True, False, True

  if a and b and c:

  return True

  else:

  return False

  可以简化成:

  return all([a, b, c])

  由此可以看到all函数的作用是判断当且仅当参数里面都为真的时候返回真， 否则返回假。