编写高质量代码--改善python程序的建议

原文发表在我的 博客主页 ，转载请注明出处！

• 使用简单，它将整个XML文件以树的形式展示，每一个元素的属性以字典的形式表示，非常方便处理
• 内存上消耗明显低于DOM解析，在底层进行了一定的优化，解析工具支持SAX事件驱动
• 支持 XPath 查询，非常方便获取任意节点的值

• pickle.dump(obj, file[, protocol])：序列化数据到一个文件描述符（一个打开的文件、套接字等）。参数obj表示需要序列化的对象，包括布尔、数字、字符串、字节数组、None、列表、元祖、字典和集合等基本数据类型。参数file支持write()方法的文件句柄，可以为真实的文件，也可以是StringIO对象等
• pickle.load(file)：表示把文件中的对象恢复为原来的对象

import cPickle as pickle  my_data =  {"name" : "Python", "type" : "Language", "version" : "2.7.5"}    fp = open("picklefile.dat","wb")  pickle.dump(my_data, fp)  fp.close()    fp = open("picklefile.dat","rb")  out = pickle.load(fp)  fp.close()  print out  print type(out)

pickle拥有良好的特性：

• 接口简单，容易使用
• pickle的存储格式具有通用性，能够被不同平台的python解析器共享
• 支持的数据类型广泛
• pickle模块是可以扩展的
• 能够自动维护对象间的引用，如果一个对象上存在多个引用，pickle后不会改变对象间的引用，并且能够自动处理循环和递归引用

import cpickle as pickle  a = [1, 2]  b = a  b.append(3)  p = pickle.dumps((a, b))  a1, b1 = pickle.loads(p)  print a1, b1  a1.append(4)  print b1

• 使用简单，支持多种数据类型，JSON文档的构成非常简单，仅存在两大数据结构
• 名称/值对的集合
• 值的有序列表
• 存储格式可读性更为友好，容易修改
• JSON支持跨平台跨语言操作，能够轻易被其他语言解析，而pickle只能在python语言中使用，另外相比于pickle，JSON的存储格式更为紧凑，所占空间更小
• 具有较强的扩展性，JSON模块还提供了编码和解码类，以便用户对其默认不支持的序列化类型进行扩展
  * 建议四十四：使用traceback获取栈信息**
  首先来看一个简单的例子：

gList = ['a','b','c','d','e','f','g']  def f():      gList[5]      return g()  def g():      return h()  def h():      del gList[2]      return i()  def i():      gList.append('i')      print gList[7]  if __name__ == '__main__':      try:          f()      except IndexError as ex:          print "Sorry,Exception occured,you accessed an element out of range"          print ex

这个例子比较简单，开发人员也为自己和用户打印出了错误信息，但是如果要debug，怎么才能快速地知道错误发生在哪里呢？traceback模块可以满足这个需求，它会输出完整的栈信息，将上面的代码修改下：

    except IndexError as ex:          print "Sorry,Exception occured,you accessed an element out of range"          print ex          traceback.print_exc()

• logger logger是程序信息输出的接口，分散在不同的代码中，使得程序可以在运行的时候记录相应的信息，根据设置的日志级别或filter来决定哪些信息需要输出，并将这些信息分发到其关联的handler。
• Handler 用来处理信息的输出，可以将信息输出到控制台、文件或者网络。
• Formatter 决定log信息的格式，格式类似于“%( )s”
• Filter 决定哪些信息需要输出

关于logging的使用：

• 尽量为logging取一个名字而不是采用默认，这样挡在不同的模块中使用的时候，其他模块只需要使用一下代码就可以方便地使用同一个logger。

import logging  logging.basicConfig(level = logging.DEBUG)  logger = logging.getLogger(__name__)

• 为了方便地找出问题所在，logging的名字建议以模块或者class来命名
• logging是线程安全的，不支持多进程写入同一个文件
  * 建议四十六：使用threading模块编写多线程程序**
  GIL使得python多线程编程暂时无法充分利用多处理器的优势，对于只含纯python的代码也许并不能提高运行效率，但是在以下情况中，比如等待外部资源返回，为了提高用户体验建立反应灵活的用户界面还是可以使用的。
  python提供了thread和threading两个关于多线程的模块：
• thread模块提供了多线程底层支持模块，以低级原始的方式来处理和控制线程，使用复杂
• threading模块基于thread进行包装，将线程的操作对象化，在语言层面提供了丰富的特性
• threading模块对同步原语的支持更为完善和丰富
• threading模块在主线程和子线程交互上更为友好，看一个例子：

import threading, time,sys  class test(threading.Thread):                       def __init__(self,name,delay):          threading.Thread.__init__(self)          self.name = name          self.delay = delay      def run(self):          print "%s delay for %s" %(self.name,self.delay)          time.sleep(self.delay)          c = 0          while True:                        print "This is thread %s on line %s" %(self.name,c)              c = c + 1               if c == 3:                  print "End of thread %s" % self.name                  break  t1 = test('Thread 1', 2)  t2 = test('Thread 2', 2)  t1.start()  print "Wait t1 to end"  t1.join()  t2.start()  print 'End of main'

• thread模块不支持守护线程，thread模块中主线程退出的时候，所有的子线程不论是否还在工作，都会被强制结束，并且没有任何警告，也没有任何退出前的清理工作，比如：

#coding=utf-8  from thread import start_new_thread  import time  def myfunc(a,delay):          print "I will calculate square of %s after delay for %s" %(a,delay)          time.sleep(delay)          print "calculate begins..."          result = a*a          print result          return result  start_new_thread(myfunc,(2,5))# 同时启动两个线程  start_new_thread(myfunc,(6,8))  time.sleep(1)

主线程没有考虑子线程就退出了，可以用threading解决，如下：

import threading  import time  def myfunc(a,delay):         print "I will calculate square of %s after delay for %s" %(a,delay)         time.sleep(delay)         print "calculate begins..."         result = a*a         print result         return result  t1=threading.Thread(target=myfunc,args=(2,5))  t2=threading.Thread(target=myfunc,args=(6,8))  print t1.isDaemon()  print t2.isDaemon()  t2.setDaemon(True)            t1.start()  t2.start()

#!usr/bin/python  #coding=utf-8  import Queue  import threading  import random  writelock = threading.Lock()        # 创建锁对象用于控制输出  class Producer(threading.Thread):         def __init__(self, q,name):                   super(Producer, self).__init__()                   self.q = q                   self.name = name                   print "Producer "+self.name+" Started"         def run(self):                   while 1:                            if self.q.full():    # 队列满                                print 'Queue is full,producer wait!'                            else:                                value = random.randint(0,10)                                print self.name +" put value: " + str(value)+ "into queue"                                self.q.put((self.name+":"+str(value)))  # 放入队列中    class Consumer(threading.Thread):        # 消费者         def __init__(self, q,name):                   super(Consumer, self).__init__()                   self.q = q                   self.name = name                   print "Consumer "+self.name+" started\n "         def run(self):                   while 1:                            if self.q.empty():      # 队列为空                                  print 'queue is empty,consumer wait!'                            else:                                  value = self.q.get()  # 获取一个元素                                  print self.name +"get value"+\                                           value + " from queue"    if __name__ == "__main__":         q = Queue.Queue(10)         p = Producer(q,"P1")         p.start()         p1 = Producer(q,"P2")         p1.start()         c1 = Consumer(q,"C1")         c1.start()         q.join()

python中的Queue模块提供了三种队列：

• Queue.Queue()：先进先出
• Queue.LifoQueue()：先进后出
• Queue.PriorityQueue()：优先级队列

参考：编写高质量代码--改善python程序的91个建议

</div>