Python学习第八天

SocketServer模块：

SocketServer内部使用 IO多路复用 以及 “多线程” 和 “多进程” ，从而实现并发处理多个客户端请求的Socket服务端。即：每个客户端请求连接到服务器时，Socket服务端都会在服务器端创建一个“线程”或者“进程” 专门负责处理当前客户端的所有请求。

为了好理解，我们先看个例子吧：

import socketserver
class MyTCPHandler(socketserver.BaseRequestHandler):
    def handle(self):
        while True:
            print("New Conn:",self.client_address)
            data=self.request.recv(1024)
            if not data:break
            print("Client Says:",data.decode())
            self.request.send(data)
if __name__=='__main__':
    HOST,PORT="localhost",50007
    server=socketserver.ThreadingTCPServer((HOST,PORT),MyTCPHandler)
    server.serve_forever()

import socket
ip_port=('127.0.0.1',50007)
sk=socket.socket()
sk.connect(ip_port)
while True:
    msg=input(">>:").strip()
    sk.sendall(bytes(msg,'utf-8'))
    server_reply=sk.recv(1024)
    print("Server Reply:",str(server_reply,'utf-8'))
sk.close()

上面例子的效果是 客户端输入什么内容，然后服务器端就会回应什么内容。

 异常处理：

（先看以下内容：）

一、isinstance(obj, cls)

 检查是否obj是否是类 cls 的对象

class Foo(object):
    pass
 
obj = Foo()
 
isinstance(obj, Foo)

二、issubclass(sub, super)

检查sub类是否是 super 类的派生类

class Foo(object):
    pass
 
class Bar(Foo):
    pass
 
issubclass(Bar, Foo)

1、异常基础

在编程过程中为了增加友好性，在程序出现bug时一般不会将错误信息显示给用户，而是显示一个提示的页面。

try:
    pass
except Exception as ex:
    pass

 需求：将用户输入的两个数字相加

while True:
    num1=input('num1')
    num2=input('num2')
    a=range(10)
    try:
        num1=int(num1)
        num2=int(num2)
        result=num1+num2
        a[11]
    except ValueError as e:
        print("Value err:",e)
    except IndexError as e:
        print("Index err:",e)
    except BaseException as e:
        print("出现异常，信息如下：",e)
        print(e)

2、异常种类

python中的异常种类非常多，每个异常专门用于处理某一项异常！！！

dic = ["tutu", 'peony']
try:
    dic[10]
except IndexError, e:
    print e

dic = {'k1':'v1'}
try:
    dic['k20']
except KeyError, e:
    print e

s1 = 'hello'
try:
    int(s1)
except ValueError, e:
    print e

异常类只能用来处理指定的异常情况，如果非指定异常则无法处理。

# 未捕获到异常，程序直接报错
 
s1 = 'hello'
try:
    int(s1)
except IndexError as e:
    print (e)

所以，写程序时需要考虑到try代码块中可能出现的任意异常，可以这样写：

s1 = 'hello'
try:
    int(s1)
except IndexError as e:
    print (e)
except KeyError as e:
    print (e)
except ValueError as e:
    print (e)

万能异常 在python的异常中，有一个万能异常：Exception，他可以捕获任意异常，即：

s1 = 'hello'
try:
    int(s1)
except Exception as e:
    print (e)

虽然有这个万能异常，其他异常也是不可以忽略的！对于特殊处理或提醒的异常需要先定义，最后定义Exception来确保程序正常运行。

s1 = 'hello'
try:
    int(s1)
except KeyError as e:
    print ('键错误')
except IndexError as e:
    print ('索引错误')
except Exception as e:
    print ('错误')

3、异常其他结构

try:
    # 主代码块
    pass
except KeyError as e:
    # 异常时，执行该块
    pass
else:
    # 主代码块执行完，执行该块
    pass
finally:
    # 无论异常与否，最终执行该块
    pass

4、主动触发异常

try:
    raise Exception('错误了。。。')
except Exception as e:
    print (e)

5、自定义异常

class MyException(Exception):
 
    def __init__(self, msg):
        self.message = msg
 
    def __str__(self):
        return self.message
 
try:
    raise MyException('我的异常')
except MyException as e:
    print (e)

6、断言

# assert 条件
 
assert 1 == 1
 
assert 1 == 2

 

class AlexException(Exception):
    def __init__(self,msg):
        self.message==msg
    def __str__(self):
        return self.message
a=1
try:
    assert a==1
except AlexException as e:
    print(e)
else:
    print("hahahh  else")
finally:
    print("no matter right or wrong run this anyway!")

 线程与进程：

线程：线程是操作系统能够进行运算调度的最小单位。它被包含在进程之中，是进程中的实际运作单位。一条线程指的是进程中一个单一顺序的控制流，一个进程中可以并发多个线程，每条线程并行执行不同的任务。

线程有2种调用方式，如下：

import threading
import time
 
def sayhi(num): #定义每个线程要运行的函数
 
    print("running on number:%s" %num)
 
    time.sleep(3)
 
if __name__ == '__main__':
 
    t1 = threading.Thread(target=sayhi,args=(1,)) #生成一个线程实例
    t2 = threading.Thread(target=sayhi,args=(2,)) #生成另一个线程实例
 
    t1.start() #启动线程
    t2.start() #启动另一个线程
 
    print(t1.getName()) #获取线程名
    print(t2.getName())

import threading
import time
 
 
class MyThread(threading.Thread):
    def __init__(self,num):
        threading.Thread.__init__(self)
        self.num = num
 
    def run(self):#定义每个线程要运行的函数
 
        print("running on number:%s" %self.num)
 
        time.sleep(3)
 
if __name__ == '__main__':
 
    t1 = MyThread(1)
    t2 = MyThread(2)
    t1.start()
    t2.start()

更多方法：

• start            线程准备就绪，等待CPU调度
• setName      为线程设置名称
• getName      获取线程名称
• setDaemon   设置为后台线程或前台线程（默认）
                     如果是后台线程，主线程执行过程中，后台线程也在进行，主线程执行完毕后，后台线程不论成功与否，均停止
                      如果是前台线程，主线程执行过程中，前台线程也在进行，主线程执行完毕后，等待前台线程也执行完成后，程序停止
• join              逐个执行每个线程，执行完毕后继续往下执行，该方法使得多线程变得无意义
• run              线程被cpu调度后执行Thread类对象的run方法

请看下面的实例：

import time
import threading
 
def run(n):
 
    print('[%s]------running----\n' % n)
    time.sleep(2)
    print('--done--')
 
def main():
    for i in range(5):
        t = threading.Thread(target=run,args=[i,])
        #time.sleep(1)
        t.start()
        t.join(1)
        print('starting thread', t.getName())
 
 
m = threading.Thread(target=main,args=[])
m.setDaemon(True) #将主线程设置为Daemon线程,它退出时,其它子线程会同时退出,不管是否执行完任务
m.start()
#m.join(timeout=2)
print("---main thread done----")

线程锁

由于线程之间是进行随机调度，并且每个线程可能只执行n条执行之后，CPU接着执行其他线程。所以，可能出现如下问题：

import threading
import time

gl_num = 0

def show(arg):
    global gl_num
    time.sleep(1)
    gl_num +=1
    print (gl_num)

for i in range(10):
    t = threading.Thread(target=show, args=(i,))
    t.start()

print ('main thread stop')

import threading
import time

gl_num = 0

lock = threading.RLock()

def Func():
    lock.acquire()
    global gl_num
    gl_num +=1
    time.sleep(1)
    print(gl_num)
    lock.release()

for i in range(10):
    t = threading.Thread(target=Func)
    t.start()
print ('main thread stop')

 RLock（递归锁）

说白了就是在一个大锁中还要再包含子锁 它的用处是避免两个线程在执行的时候被其他的插在中间执行了，而我们要的结果是它俩一起完成执行不被打扰。

import threading,time
 
def run1():
    print("grab the first part data")
    lock.acquire()
    global num
    num +=1
    lock.release()
    return num
def run2():
    print("grab the second part data")
    lock.acquire()
    global  num2
    num2+=1
    lock.release()
    return num2
def run3():
    lock.acquire()
    res = run1()
    print('--------between run1 and run2-----')
    res2 = run2()
    lock.release()
    print(res,res2)
 
 
if __name__ == '__main__':
 
    num,num2 = 0,0
    lock = threading.RLock()
    for i in range(10):
        t = threading.Thread(target=run3)
        t.start()
 
while threading.active_count() != 1:
    print(threading.active_count())
else:
    print('----all threads done---')
    print(num,num2)

Semaphore(信号量)

互斥锁 同时只允许一个线程更改数据，而Semaphore是同时允许一定数量的线程更改数据 。

import threading,time
 
def run(n):
    semaphore.acquire()
    time.sleep(1)
    print("run the thread: %s\n" %n)
    semaphore.release()
 
if __name__ == '__main__':
 
    num= 0
    semaphore  = threading.BoundedSemaphore(5) #最多允许5个线程同时运行
    for i in range(20):
        t = threading.Thread(target=run,args=(i,))
        t.start()
 
while threading.active_count() != 1:
    pass #print threading.active_count()
else:
    print('----all threads done---')
    print(num)

线程间同步和交互：

通过Event来实现两个或多个线程间的交互，下面是一个红绿灯的例子，即起动一个线程做交通指挥灯，生成几个线程做车辆，车辆行驶按红灯停，绿灯行的规则。

import threading
import random
import time
def light():
    if not event.isSet():
        event.set()#wait就不阻塞#绿灯状态
    count=0
    while True:
        if count<10:
            print('\033[42;1m--green light on---\033[0m')
        elif count<13:
            print('\033[43;1m--yellow light on---\033[0m')
        elif count<20:
            if event.isSet():
                event.clear()
            print('\033[41;1m--green light on---\033[0m')
        else:
            count=0
            event.set()
        time.sleep(1)
        count+=1
def car(n):
    while 1:
        time.sleep(1)
        if event.isSet():#绿灯
            print("car[%s] is running..."%n)
        else:
            print("car [%s] is waiting for the red light..."%n)
            event.wait()
if __name__=='__main__':
    event=threading.Event()
    Light=threading.Thread(target=light)
    Light.start()
    for i in range(3):
        t=threading.Thread(target=car,args=(i,))
        t.start()

多进程： 

from multiprocessing import Process
import time
def f(name):
    time.sleep(2)
    print('hello', name)

if __name__ == '__main__':
    p = Process(target=f, args=('bob',))
    p2 = Process(target=f, args=('bob',))
    p.start()
    p2.start()#该句和上面同步执行
    p.join()

注意：由于进程之间的数据需要各自持有一份，所以创建进程需要的非常大的开销。

下面是一个扩展的例子，可以显示每个进程所涉及的ID：

from multiprocessing import Process
import os

def info(title):
    print(title)
    print('module name:', __name__)
    print('parent process:', os.getppid())
    print('process id:', os.getpid())
    print("\n\n")

def f(name):
    info('\033[31;1mfunction f\033[0m')
    print('hello', name)

if __name__ == '__main__':
    info('\033[32;1mmain process line\033[0m')
    p = Process(target=f, args=('bob',))
    p.start()
    p.join()

进程间通讯　　

不同进程间内存是不共享的，要想实现两个进程间的数据交换，可以用以下方法：

Queues

使用方法跟threading里的queue差不多

from multiprocessing import Process,Queue
def f(q):
    q.put([42,None,'hello'])
if __name__=='__main__':
    que=Queue()
    p=Process(target=f,args=(que,))
    p2=Process(target=f,args=(que,))
    p.start()
    p2.start()
    print('from parent:',que.get())
    print('from parent2:',que.get())
    p.join()

Pipes

from multiprocessing import Process, Pipe
 
def f(conn):
    conn.send([42, None, 'hello'])
    conn.close()
 
if __name__ == '__main__':
    parent_conn, child_conn = Pipe()
    p = Process(target=f, args=(child_conn,))
    p.start()
    print(parent_conn.recv())   # prints "[42, None, 'hello']"
    p.join()

Managers

from multiprocessing import Process, Manager

def f(d, l):
    d[1] = '1'
    d['2'] = 2
    d[0.25] = None
    l.append(1)
    print(l)

if __name__ == '__main__':
    with Manager() as manager:
        d =manager.dict()

        l = manager.list(range(5))
        p_list = []
        for i in range(10):
            p = Process(target=f, args=(d, l))
            p.start()
            p_list.append(p)
        for res in p_list:
            res.join()

        print(d)
        print(l)

进程同步:

from multiprocessing import Process, Lock

def f(l, i):
    l.acquire()
    try:
        print('hello world', i)
    finally:
        l.release()

if __name__ == '__main__':
    lock = Lock()

    for num in range(10):
        Process(target=f, args=(lock, num)).start()

进程池　　

进程池内部维护一个进程序列，当使用时，则去进程池中获取一个进程，如果进程池序列中没有可供使用的进进程，那么程序就会等待，直到进程池中有可用进程为止。

进程池中有两个方法：

from  multiprocessing import Process,Pool
import time
 
def Foo(i):
    time.sleep(2)
    return i+100
 
def Bar(arg):
    print('-->exec done:',arg)
 
pool = Pool(5)
 
for i in range(10):
    pool.apply_async(func=Foo, args=(i,),callback=Bar)
    #pool.apply(func=Foo, args=(i,))
 
print('end')
pool.close()
pool.join()#进程池中进程执行完毕后再关闭，如果注释，那么程序直接关闭。