第五章网络与并发编程(代码片段)

#server端
import socket
sk = socket.socket()    #创建一个socket对象
sk.bind((‘127.0.0.1‘,9000))    #绑定自己的环回地址端口为9000
sk.listen()    #开始接受客户端给我的链接，可以设置最大连接数，如果有人在连接，其余人等待
while True:
    conn,addr = sk.accept()    #阻塞等待被连
    while True:
        msg = input(‘>>>‘)
        connsend(msg.encode(‘utf-8‘))    #给连接端发送一条消息，用utf-8格式
        if msg.upper() ==‘Q‘;
            break
        content = conn.recv(1024).decode(‘utf-8‘)    #阻塞，直到收到连接放发来的消息，一次收不超过1024字节
        if content.upper() == ‘Q‘:break
        print(content)    #打印收到的消息
    conn.close()    #断开连接
sk.close()    #关闭连接

#client端
import socket
sk = socket.socket()
sk.connect((‘serverIP‘,server端口)
while True:
    ret = sk.recv(1024).decode(‘utf-8‘)    #接收发送来的消息
    if ret.ipper() == ‘Q‘:break
    print(ret)    
    msg = input(‘>>>‘)
    sk.send(msg.encode(‘utf-8‘))
    if msg.upper() = ‘Q‘: break
sk.close()

#server端
import socket
sk = socket.socket(type = socket.SOCK_DGRAM)    #定义连接为UDP
sk.bind((‘127.0.0.1‘,9000)
while True:
    msg,client_addr = sk.recvfrom(1024)
    print(msg.decode(‘utf-8‘))
    cpntent = input(‘>>>‘)
    sk.sendto(‘收到‘.encode(‘utf-8‘),client_addr)
sk.close()

#client端
import socket
sk = socket.socket(type = socket.SOCK_DGRAM)
server_addr = (‘127.0.0.1‘,9000)
while True:
    content = input(‘>>>‘)
    if content.upper() == ‘Q‘:break
    sk.sendto(content.encode(‘utf-8‘),server_addr)
    msg = sk.recvfrom(1024)
    if msg.upper() == ‘Q‘ :break
    print(msg.decode(‘utf-8‘))
sk.close()

#server端
import socket
import struck
sk.socket.socket()
sk.bind((‘127.0.0.1‘,9000))
sk.listen()
conn,addr = sk.accept()
msg = ‘Parallel‘
bytes_msg = msg.encode(‘utf-8‘)    #转换成字节码
num = len(bytes_msg)    #计算出字节码的长度
len_bytes = struck.pack(‘i‘,num)    #用struck模块总pack方法将具体长度转成4个字节
conn.send(len_bytes)    #先发送4个字节
conn.send(bytes_msg)    #发送转成字节码的内容
conn.close()
sk.clock()

#client端
import socket
sk = socket.socket()
sk.connect((‘serverIP‘,端口))
num = sk.recv(4)    #先接收4字节
bytes_num = struck.unpack(‘i‘,num)[0]    #把4字节中打包的长度解包，变成要接收数据的具体长度
msg = sk.recv(bytes_num)    #知道具体长度后确定自己要接收多少字节
print(msg.decode(‘utf-8‘))
sk.close

#信息通过字典传输文件
#server端
import os
import json
import socket
sk = socket.socket()
sk.connect((‘127.0.0.1‘,9001))
filename = input(‘请输入文件路径：‘)###输入文件名
filename = os.path.basename(filepath)###从文件名中获取文件路径
filesize = os.path.getsize(filepath)###获取文件大小
dic = ‘filename‘:filename,‘filesize‘:filesize
bytes_dic = json.dumps(dic).encode(‘utf-8‘)
len_dic = len(bytes_dic)
bytes_len = struct.pack(‘i‘,len_dic)
sk.send(bytes_len)###发送字典字节
sk.send(bytes_dic)###发送字典
with open(filepath,‘rb‘) as f:
    content = f.read()###读出文件内容
    sk.send(content)###发送文件内容
conn.close()
sk.close()

#client端
import os
import socket
sk = sk.socket.socket()
sk.bind((‘127.0.0.1‘,900))
sk.listen()
conn,addr = sk.accept()
num = conn.recv(4)###接收4字节
num = struct.unpack(‘i‘,num)[0]###通过接收的4个字节得到文件名长度
str_dic = conn.recv(num).decode(‘utf-8‘)###得到json类型的字典
dic = json.loads(str_dic)
with open(dic[‘file_name‘],‘wb‘) as f:
    conntent = conn.recv(dic[‘filesize‘])
    f.write(content)
conn.close()
sk.close()

#server端
import socketserver
class Myserver(socket.server.BaseRequestHandler):    #固定格式
    def handle(self):    #固定格式
        print(self.request)    #打印conn连接，等同于self.request
        msg = self.request.recv(1024).decode(‘utf-8)
        self.request.send(msg.encode(‘utf-8))    #把收到的消息发送回去
server = socketserver.ThreadingTCPServer((‘127.0.0.1‘,9000),Myserver)    #类名
server.serve_forever()    #相当于accept阻塞等待连接

#client端1
import socket
sk = socket.socket()
sk.connect((serverIP,端口))    #发送信息测试
sk.close()

#client端2
import socket
sk = socket.socket()
sk.connect((serverIP,端口))    #发送信息测试
sk.close()

#server端
import socket
sk = socket.socket()
sk.bind((‘127.0.0.1‘,9000))
sk.setblocking(False)     #设置非阻塞
sk.listen()
conn_l = []
del_l = []
while True:
    try:
        conn,addr = sk.accept()    #此处不再阻塞
        print(conn)
        conn_l.append(conn)
    except BlockingIOError:
        for c in conn_l:
            try:
                msg = c.recv(1024).decode(‘utf-8‘)
                if not msg:
                    del_l.append(c)
                    continue
                print(‘-->‘,[msg])
                c.send(msg.upper().encode(‘utf-8‘))
            except BlockingIOError:pass
        for c in del_l:
            conn_l.remove(c)
        del_l.clear()
sk.close()

#client端1、2
import time
import socket
sk = socket.socket()
sk.connect((‘127.0.0.1‘,9000))
for i in range(30):
    sk.send(b‘wusir‘)
    msg = sk.recv(1024)
    print(msg)
    time.sleep(0.2)
sk.close()

#server端
import os
import hashlib
import socket
def get_md5(secret_key,randseq):
    md5 = hashlib.md5(secret_key)
    md5.update(randseq)
    res = md5.hexdigest()
    return res
def chat(conn):
    while True:
        msg = conn.recv(1024).decode(‘utf-8‘)
        print(msg)
        conn.send(msg.upper().encode(‘utf-8‘))
sk = socket.socket()
sk.bind((‘127.0.0.1‘,9000))
sk.listen()
secret_key = b‘alexsb‘
while True:
    conn,addr = sk.accept()
    randseq = os.urandom(32)
    conn.send(randseq)
    md5code = get_md5(secret_key,randseq)
    ret = conn.recv(32).decode(‘utf-8‘)
    print(ret)
    if ret == md5code:
        print(‘是合法的客户端‘)
        chat(conn)
    else:
        print(‘不是合法的客户端‘)
        conn.close()
sk.close()

#client端
import hashlib
import socket
import time
def get_md5(secret_key,randseq):
    md5 = hashlib.md5(secret_key)
    md5.update(randseq)
    res = md5.hexdigest()
    return res
def chat(sk):
    while True:
        sk.send(b‘hello‘)
        msg = sk.recv(1024).decode(‘utf-8‘)
        print(msg)
        time.sleep(0.5)
sk = socket.socket()
sk.connect((‘127.0.0.1‘,9000))
secret_key = b‘alexsb‘
randseq = sk.recv(32)
md5code = get_md5(secret_key,randseq)
sk.send(md5code.encode(‘utf-8‘))
chat(sk)
sk.close()

#面向函数
from multiprocessing import Process    #进程类Process
def func(i):
    time.sleep(1)
    print(0)
if __name__ == ‘__main__‘:
    Process(target = func).start()
    Process(target = func).start()
    Process(target = func).start()    #三个之间互不影响，同时执行且异步

#在windows中新的子进程需要通过import父进程的代码来完成数据的导入工作，所以有一些内容我们只希望在父进程中完成，就写在__name__ = ‘__main__‘下面

#面向对象
from multiprocessing import Process
class 类名(Process):
    def __init__(self,参数1,参数2)    #需要传参数必须写init和super().__init__()
        self.a = 参数1
        self.b = 参数2
        super().__init__()    #在继承Process类中也有init方法，必须引用过去
    def run(self):    #要在子进程中执行的代码
        pass
if __name__ ==‘__main__‘:
    mp = MyProcess(传参数)
    mp.start()    #开启进程，异步非阻塞
    mp.terminate()    #结束进程   异步非阻塞
    mp.join()    #同步阻塞
    mp.is_live()    #获取当前进程的状态True为运行

import time
from multiprocessing import Process
def son1():
    while True:
        print(‘is alive‘)
        time.sleep(0.5)
if __name__ == ‘__main__‘:
    p = Process(target=son1)
    p.daemon = True    #把p子进程设置成一个守护进程
    p.start()
    p.terminate()    #强制结束一个子进程且为异步非阻塞
    p.is_alive()    #判断一个进程是不是存活

import time
import json
from multiprocessing import Process,Lock
def search_ticket(user):
    with open(‘ticket_count‘) as f:
        dic = json.load(f)
        print(‘%s查询结果  : %s张余票‘%(user,dic[‘count‘]))
def buy_ticket(user,lock):
    with lock:        # lock.acquire()给这段代码加上一把锁
        time.sleep(0.02)
        with open(‘ticket_count‘) as f:
            dic = json.load(f)
        if dic[‘count‘] > 0:
            print(‘%s买到票了‘%(user))
            dic[‘count‘] -= 1
        else:
            print(‘%s没买到票‘ % (user))
        time.sleep(0.02)
        with open(‘ticket_count‘,‘w‘) as f:
            json.dump(dic,f)
                            # lock.release()给这段代码解锁
def task(user, lock):
    search_ticket(user)
    with lock:    #默认做异常处理(推荐)
        buy_ticket(user, lock)
if __name__ == ‘__main__‘:
    lock = Lock()
    for i in range(10):
        p = Process(target=task,args=(‘user%s‘%i,lock))
        p.start()    

from multiprocessing imoprt Queue,Process
def func(exp):
    ret = eval(exp)
    print(ret)
    q.put(ret)
if __name__ ==‘__main__‘:
    q = Queue(5)    #先进先出,规定队列中的数据最多5个,当队列满了,继续传输会阻塞,直到队列有数据被拿走
    Process(target=func,args=(‘1+2+3‘,q)).start()
    print(q.get())    #当没有数据的时候会阻塞直到取出数据

from multiprocessing import Process,Queue
def producer(q,name,food):
    for i in range(10):
        time.sleep(random.random())
        fd = ‘%s%s‘%(food,i)
        q.put(fd)
        print(‘%s生产了一个%s‘%(name,food))
def consumer(q,name,):
    while True:
        food = q.get()
        print(%s吃了%s‘%(name,food))
if __name__==‘__main__‘:
    q = Queue(10)
    Process(target=prodecer,args=(q,‘Parallel‘,‘火锅‘))
    p1.start()
    c1 = Process(target=consumer,args=(q,‘World‘))
    c1.start()
    p1.join()
    q.put(None)    #有几个用户需要输几个q.put(None)