Python教程11-14

11.进程和线程

11.1.多进程

Unix/Linux fork()

在Win中使用进程

from multiprocessing import process

p = Process(target=run_proc, args=('test',)) #run_proc是一个函数

#传入执行函数和函数的参数,创子进程

p.start() #子进程启动

p.join() #等待子进程结束后继续运行,用于同步

Pool

启用大量子进程,用进程池

p=Pool()

for i in range(5):

p.apply_async(long_time_task, args=(i,))

p.close() #调用后不能继续添加新的Process,在join()前必须调用

p.join() #等待所有子进程执行完毕

#Pool的默认大小是4,同时执行4个进程

p=Pool(5) #调整默认大小

进程间通信

multiprocessing模块包装了底层的机制，提供了Queue、Pipes来交换数据。

q = Queue() # 父进程创建Queue，并传给各个子进程：

pw = Process(target=write, args=(q,)) #创建子进程

..

q.put(value) #写数据

value=q.get(True) #读数据

11.2.多线程

thread和threading #基本使用threading

import threading

t=threading.Thread(target=loop,name='test') #创建线程 name:线程名字

t.start() #启动线程

t.join() #等待线程执行完毕

threading.current.thread().name #返回线程的实例

lock

多进程中同一个变量，各自有一份拷贝存在于每个进程中,互不影响

多线程中，所有变量都由所有线程共享，

所以要在线程中加锁

lock=threading.Lock()

lock.acquire() #获取锁

try: #通过 try/finally 使得锁必然可以释放

...

finally:

lock.release() #释放锁

multiprocessing.cpu_count() #返回CPU个数

11.3.ThreadLocal

线程使用局部变量间的通信

lock-school=threading.local() #创建全局ThreadLocal对象

def name1():

local_school.student = name #线程1写数据

name2()

def name2():

local_school.student #线程2访问数据

12.正则表达式 re

r"ABC\\-001" #使用 r 前缀不用*虑转义

"ABC\\-001" 输出 ABC\-001

re.match(r"正则表达式",str) #判断匹配,成功返回Match对象,否则返回None

re.split(r'\s+','a b c ') #切分字符,返回列表[]

12.1.分组

m = re.match(r'^(\d{3})-(\d{3,8})$', '010-12345') #匹配成功后返回分组 ()内数据

m.group() #返回列表

group(0) #原始字符串

group(1) (2) #表示第一个/第二个子串

12.2.贪婪匹配

默认是贪婪匹配,尽可能多的字符

>>> re.match(r'^(\d+)(0*)$', '102300').groups()

('102300', '')

#加个?就可以让\d+采用非贪婪匹配：

>>> re.match(r'^(\d+?)(0*)$', '102300').groups()

('1023', '00')

编译

re_telephone = re.compile(r'^(\d{3})-(\d{3,8})$') #预编译(接下来重复使用时就不需要编译这个步骤了)

>>> re_telephone.match('010-12345').groups() #匹配

('010', '12345')

13.常用内建模块

13.1.collections 集合类

namedtuple #可以用属性引用元素

from collections import namedtuple #导入

#使用第一个参数是namedtuple的名称

第二个参数是元素

Point = namedtuple('Point', ['x', 'y'])

p=point(1,2) #调用namedtuple

print p.x,p.y #用属性引用元素

输出---

1 2

deque #实现list的快速插入删除

from collections import deque

q = deque(['a', 'b', 'c']) #创建deque

q.append('x') #在最后添加

appendleft() #左边添加

q.pop() #删除最后

popleft() #删除第一个

defaultdict #在Key不存在时返回默认值

from collections import defaultdict

dd=defaultdict(lambda: 'N/A') #创建dict

dd['key1'] = 'abc' #创建 key1并赋值

print dd['key1'],dd['key2'] # key2不存在

输出-----

abc N/A #返回设置的内容

OrderedDict #按照插入顺序给 Dict排序

from collections import OrderedDict

d=OrderdDict(['a':1,'c':2,'b':3])

print d

输出-----

OrderedDict([('a', 1), ('c', 2), ('b', 3)]) #输出输入顺序

Counter 简单计数器

#统计字符出现个数

from collections import Counter

c=Counter()

for ch in 'programming':

c[ch] +=1

print c

输出-----

Counter({'g': 2, 'm': 2, 'r': 2, 'a': 1, 'i': 1, 'o': 1, 'n': 1, 'p': 1})

13.2.base64

用64个字符来表示任意二进制数据的方法

['A', 'B', 'C', ... 'a', 'b', 'c', ... '0', '1', ... '+', '/']

import base64

print base64.b64encode('binary') 编码

print base64.b64decode('YmluYXJ5') 解码

输出-----

YmluYXJ5

binary

出现字符+和/,URL中就不能直接作为参数

把字符+和/分别变成-和_ "url safe"的base64编码

'abcd++//' #原输出字符

base64.urlsafe_b64encode('i\xb7\x1d\xfb\xef\xff')

'abcd--__' #urlsafe 输出字符

13.3.struct

二进制数据类型的转换

13.4.hashlib

摘要算法:把任意长度的数据转换为一个长度固定的数据串

MD5:

import hashlib

md5 = hashlib.md5()

md5.update('how to use md5 in python hashlib?')

print md5.hexdigest()

输出-----

d26a53750bc40b38b65a520292f69306

SHA1:

import hashlib

sha1 = hashlib.sha1()

sha1.update('how to use sha1 in python hashlib?')

print sha1.hexdigest()

输出-----

2c76b57293ce30acef38d98f6046927161b46a44

比SHA1更安全的算法是SHA256和SHA512，不过越安全的算法越慢，而且摘要长度更长

13.5.itertools

用于操作迭代对象的函数

count() #创建一个无限的迭代器

eg:

import itertools

n = itertools.count(1)

for x in n: #打印出自然数序列

print x

cycle() 传入的一个序列无限重复下去：

cs = itertools.cycle('ABC') # 注意字符串也是序列的一种

repeat() 负责把一个元素无限重复下去,第二个参数限定次数

ns = itertools.repeat('A', 10)

takewhile() 根据条件判断截取数列

ns = itertools.takewhile(lambda x: x <= 10, n)

#打印出 1到 10

迭代器操作函数

chain() 把一组迭代对象串联起来，形成一个更大的迭代器：

for c in itertools.chain('ABC', 'XYZ'):

print c

# 迭代效果：'A' 'B' 'C' 'X' 'Y' 'Z'

groupby() 把迭代器中相邻的重复元素挑出来放在一起：

for key, group in itertools.groupby('AAABBBCCAAA'):

print key,list(group)

# 输出-----

A ['A', 'A', 'A']

B ['B', 'B', 'B']

C ['C', 'C']

A ['A', 'A', 'A']

挑选规则是通过函数完成的,作用于函数的两个元素返回的值相等这两个元素就被认为是在一组的，

# 忽略大小写分组

for key, group in itertools.groupby('AaaBBbcCAAa', lambda c: c.upper()):

imap()/map()

map()返回list,调用map()时，已经计算完毕

map(lambda x: x*x, [1, 2, 3])

imap()返回一个迭代对象,调用imap()时，并没有进行任何计算：

r = itertools.imap(lambda x: x*x, [1, 2, 3])

用for循环对r进行迭代

for x in r:

能够实现惰性计算的函数就可以处理无限序列：

ifilter()

是filter()的惰性实现

14.图形界面

图形界面的第三方库 Tk,wxWidgets,Qt,GTK

Python自带的库是支持Tk的Tkinter

14.1.Tkinter

from Tkinter import * #导入

class Application(Frame): #继承Frame

def __init__(self, master=None):

Frame.__init__(self, master)

self.pack() #包装,显示

self.createWidgets() #调用函数

def createWidgets(self):

#标签

self.helloLabel = Label(self, text='Hello, world!')

self.helloLabel.pack()

#按钮, 文本/命令(函数)

self.quitButton = Button(self, text='Quit', command=self.quit)

self.quitButton.pack()

#实例化

app = Application()

# 设置窗口标题:

app.master.title('Hello World')

# 主消息循环:

app.mainloop()

Label #显示文本

Button #按钮

Entry #输入框

self.nameInput = Entry(self) #创建输入框

name = self.nameInput.get() #取得输入框数据