python 2.6 与2.4的区别：

考虑到稳定性，公司一直使用的是rhel5自带的版本python2.4.3.不久前,rhel5也将它的自带版本升级为python2.6.4版本了。

python最大的缺点在于服务器上有2.4和2.6+版本区别有些常用的东西需要2.6支持而rh6以下的linux都是带2.4的导致某些处理shell跨机通用性比python好 

于是我浏览了下2.6版本的手册中的“what’s new”这一章节，选取了一部分在2.4中没有见到的语法和模块，或者同事之前用到比较少的模块，到公司培训室给同事讲了一下。以下为我将讲解的东西整理成了一份文字版本的。

 

—        条件表达式 语法

—        x = true_value if condition else false_value

—        注意：需要有else语句

—        例子

—             x = 2 if 2 < 3 else 1

—            类似c和php中的三目运算符

 

字符串格式化

—        2.4中  “%s 500wan %s” %  (222, 444)

—        2.6中新增

—        “{id}:{name}” .format(id =‘es427’,name =’xxx’)

 

 

—        2.4中只能try…except 或 try…finally

—        2.6则支持 try…except…finally或者try…except…else…finally

 

       With语句

—        它是某些try…finally的简便替代用法

—        例子

—        import sys

—        fp = open("ifelse.py")

—        print 'fp is',fp

—        with fp:

—            print fp.read()

—        print 'fp is',fp

如果使用try…finally

—        #这里的with语句相当于

—        fp2 = open("ifelse.py")

—        try:

—            #do sth

—            fp2.read()

—        finally:

—            fp2.close()

—        With后面跟的对象需要有__enter__方法和 __exit__方法

—        例如刚才的fp 文件对象就有 __enter__ 和 __exit__

—        还可以使用的有theading的Lock对象和一些数据库连接等等。

—        总之紧接在with后面的语句需要有__enter__ 方法 和 __exit__

—        with这一行语句开始的时候会自动调用对象的__enter__方法

—        整个with块语句执行完毕后会自动调用__exit__语句

—        例如：

—        lock_object = threading.Lock()

—        with lock_object:    #这里实际执行了lock_object.acquire()

—             print ‘do something’

—        #with语句结束，自动调用lock_object.release()

 

生成唯一值的模块uuid

—        它有uuid() uuid2() uuid3() uuid4()

—        >>> print uuid.uuid4()

—        8d0ad84b-3535-4028-8eca-c7e86dc22316

 

一个高性能的存储容器collections

—        其中Queue内部存储数据采用的deque

—        deque对象            类似list 但不提供slice切片操作

—        namedtuple对象   类似 tuple

—        Defaultdict对象     类似 dict

 

优先级队列 后进先出队列

import Queue

Fq = Queue.Queue() 跟2.4是一样的

Pq = Queue.PriorityQueue() 优先级队列

Lq = Queue.LifoQueue() 后进先出队列

 

优先级队列存数据

Pq.put(2)  先把2放进去

Pq.put(1)  然后把1放进去

Pq.get()   

Pq.get()   这时候1会先出来 然后是2

 

Pq.put(  ( 3, [a,b,c])  )  

Pq.put(  (1,[d,2,3.4,a]))

Pq.get()   (1,[d,2,3.4,a]) 会先出来

 

multiprocessing 模块

—        更高级的多进程模块

—        仿threading模块

—        提供跟threading类似的操作

—        更便利的进程间通信接口

—        它是非常庞大,非常有用的一个模块

 

子进程的新建和开启

 

Python代码  

1. #coding=gbk  
2. ''''' 
3. 使用Process创建和开启子进程 
4. '''  
5. from multiprocessing import Process  
6. import os  
7. from time import sleep  
8.   
9. def f(name):  
10.     print 'hello mypid is ',os.getpid()  
11.     print 'my parent pid is',os.getppid()  
12.     sleep(30)  
13.     print 'done' ,os.getpid()  
14.   
15.   
16. if __name__ == '__main__':  
17.     print 'i am parent pid is',os.getpid()  
18.     p = Process(target = f, args=('guozw',) )  
19.     p.start()#帮你隐藏了底层的fork调用细节  
20.     p.join() #等待子进程结束,隐藏系统调用wait或waitpid的细节  

 

 

 

Multiprocessing提供的进程间通信方法

进程间通信之Queue

 

 

Python代码  

1. #coding=gbk  
2. ''''' 
3. 进程间通信之Queue 
4. '''  
5. #coding=gbk  
6. from multiprocessing import Process, Queue  
7. import os  
8. import time  
9. from time import sleep  
10. import random  
11.   
12. def  a():  
13.     '''''该函数会单独在一个进程中执行'''  
14.     print 'my pid is',os.getpid()  
15.     print 'my parent pid is',os.getppid()  
16.     sleep(5)  
17.     print  theQueue.get(0)  
18.     print  theQueue.get(0)  
19.     print  theQueue.get(0)  
20.     print 'pid %s done'%(os.getpid())  
21.   
22.   
23. def  b():  
24.     '''''该函数会单独在一个进程中执行'''  
25.     print 'my pid is',os.getpid()  
26.     print 'my parent pid is',os.getppid()  
27.     sleep(3)  
28.     print theQueue.get(0)  
29.     print  theQueue.get(0)  
30.     print  theQueue.get(0)  
31.     print 'pid %s done'%(os.getpid())  
32.   
33. theQueue = Queue() #创建进程间通信的队列    
34. for i in range(1,6):  
35.     theQueue.put(random.randint(1,30000000000)) #主进程向队列中写入  
36. print theQueue.qsize()  
37. ppa = Process( target = a ) #创建a进程  
38. ppb = Process( target = b)  #创建b进程  
39. ppa.start() #创建a进程  
40. ppb.start() #创建b进程  
41. ppa.join()  #等待a进程结束  
42. ppb.join()  #等待b进程结束  

 

 

 进程间通信之Pipe

 

Python代码  

1. #coding=gbk  
2. from multiprocessing import Process, Pipe  
3. import os  
4.   
5. def f(conn):  
6.     '''''会单独在一个进程中执行的一个函数'''  
7.     print 'my pid is',os.getpid()  
8.     conn.send( ['the data of sending']) #在向管道中发送数据  
9.     conn.close()                        #关闭管道的一端  
10.   
11.   
12. if __name__ == '__main__':  
13.     parent_conn, child_conn = Pipe()  
14.     p = Process(target = f, args=(child_conn,))   
15.     p.start()  
16.     print 'hereis parent',parent_conn.recv()  
17.     p.join()  

 

 

 

 进程间通信之共享内存

Python代码  

1. #coding=gbk  
2. ''''' 
3. 进程间通信之共享内存 
4. '''  
5. from multiprocessing import Process, Value, Array  
6. from time import sleep  
7.   
8. def f(n,a):  
9.     #设置修改了主进程的变量 n 和 a  
10.     n.value = 333  
11.     for i in range(len(a)):  
12.         a[i] = -a[i]  
13.     sleep(20)  
14.   
15.   
16. num = Value('d',0.0)  #初始化共享变量num=0.0  
17. arr = Array('i',range(5)) #初始化共享变量arr=[1,2,3,4]  
18.   
19. p = Process( target = f, args = ( num, arr)) #创建子进程  
20. p.start()  #运行子进程  
21. p.join()   #等待子进程结束  
22.   
23.   
24. #子进程修改后num.value = 333, arr = [-1, -2,-3,-4]  
25. print num.value  
26. print arr[:]  

 

multiprocessing还有很多非常有用的模块。具体参考手册。