python实现socket网络编程笔记，TCP/IP协议相关知识

朴灿烈づ我的快乐病毒、 2023-02-13 03:55 1阅读 0赞

学到啥记啥，有点乱。。。

### python网络编程 ###

*  一、UDP
 *   *  1、IP地址和端口
     *  2、udp收发数据
     *  3、udp聊天器
 *  二、TCP
 *   *  1、tcp简介
     *  2、tcp客户端
     *  3、tcp服务器
     *  4、tcp注意点
     *  5、案例：文件下载器
 *  三、多任务-线程
 *   *  1. 一个demo
     *  2. 多线程
     *  3.线程共享全局变量
     *   *  （1）多线程之间是共享全局变量的
         *  （2）多线程共享全局变量，args参数
     *  4、多线程可能遇到的问题
     *  5、同步和互斥锁
     *   *  （1）同步
         *  （2） 互斥锁
         *  （3）死锁
     *  6、案例：多任务版本UDP聊天器
 *  四、多任务-进程
 *   *  1、进程
     *  2、进程和线程对比（重点）
     *  3、进程间通信-queue
     *  4、进程池Pool
     *  5、多任务文件夹拷贝
 *  五、多任务-协程
 *   *  1、迭代器
     *  2、迭代器应用：实现斐波那契数列
     *  3、生成器
     *   *  （1）创建生成器
         *  （2）send方式
     *  4、使用生成器完成多任务
     *  5、使用greenlet和gevent完成多任务
     *  6、案例：图片下载器
     *  7、进程线程协程对比
 *  六、正则表达式
 *   *  1、匹配单个字符
     *  2、匹配多个字符
     *  3、举例
     *  4、匹配分组
     *  5、re模块的高级用法
 *  七、HTTP协议
 *   *  1、http协议
     *  2、长连接和短连接
     *  3、案例：返回固定页面的http服务器
 *  八、单进程、单线程、非堵塞实现并发
 *  九、epoll

# 一、UDP #

## 1、IP地址和端口 ##

*  私有ip：不在公网中使用的  
    10.0.0.0~10.255.255.255  
    172.16.0.0~172.31.255.255  
    192.168.0.0~192.168.255.255
 *  127.0.0.1~127.255.255.255用于回路测试  
    如：127.0.0.1可以代表本地ip地址
 *  ip地址和端口号共同标志一个主机上的某个进程（0-1024是知名端口），端口就像一个房子的门，是出入房子的必经之路。
 *  一个电脑上不同进程的端口号不允许相同

## 2、udp收发数据 ##

在虚拟机中发送数据给netassist网络调试助手，centOS是发送者。  
**（1）发送一个简单的byte数据**  
![在这里插入图片描述][20200527130559226.png]  
协议类型选择udp，端口号和ip地址如图所示。注意，可以先ping一下看看网络是否能通，否则数据发送不了。出现了这个问题的话，可以把网络设置成用桥接模式。

import socket
    def main():
        #创建一个udp套接字
        udp_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
        #可以使用套接字收发数据,b表示是byte类型，要加上，不能发字符串
        udp_socket.sendto(b"hahaha",("xxx.xxx.xxx.xxx",8080))#ip,端口
        udp_socket.close()
    if __name__ =="__main__":
        main()

![在这里插入图片描述][20200527130517259.png]  
可以直接在pycharm里面run，也可以在终端输入`python3 p1.py #p1是文件名`(后者要cd到文件所在路径去）  
`总结：1、创建套接字 2、使用套接字收发数据 3、关闭套接字`

**（2）循环发送任意数据，并且可以退出**

import socket
    def main():
        #创建一个udp套接字
        while True:
            udp_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
            #可以使用套接字收发数据,b表示是byte类型
            send_data=input("请输入要发送的数据： ")
            #如果输入的数据是exit，那么退出
            if send_data=="exit":
                break
               #utf8编码
            udp_socket.sendto(send_data.encode("utf-8"),("192.168.245.1",8080))
    
        udp_socket.close()
    if __name__ =="__main__":
        main()

每次发送，端口都是不一样的，因为没有绑定，分配的动态端口（1024-65535）  
绑定端口：

import socket
    def main():
        #创建一个udp套接字
        udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        #绑定本地信息,元组
        udp_socket.bind(("",8899))
        while True:
            #可以使用套接字收发数据,b表示是byte类型
            send_data=input("请输入要发送的数据： ")
            #如果输入的数据是exit，那么退出
            if send_data=="exit":
                break
               #utf8编码
            udp_socket.sendto(send_data.encode("utf-8"),("192.168.245.1",8080))
    
        udp_socket.close()
    if __name__ =="__main__":
        main()

注意bind括号内信息是个元组  
![在这里插入图片描述][2020052716092173.png]  
一个端口同一时刻只能被一个进程使用

**（3）循环接收，解析数据信息**

import socket
    def main():
        #1.创建一个udp套接字
        udp_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
        #2.绑定本地的信息
        local_addr=('192.168.xxx.xxx',7788)
        udp_socket.bind(local_addr)
        while True:
            #3.接受数据,recv_data中存储的是一个元组(接受数据，(发送方ip，端口))
            recv_data=udp_socket.recvfrom(1024) #1024表示本次接受的最大字节数
    
            recv_msg=recv_data[0]  # 信息
            send_addr=recv_data[1]  # 发送方信息
            #4.打印接受到的数据
            print(recv_data)
            print("%s:%s"%(str(send_addr),recv_msg.decode("gbk")))
        #5.关闭套接字
        udp_socket.close()
    
    if __name__ =="__main__":
        main()

recvfrom在没有数据到来时会堵塞在那个位置  
![在这里插入图片描述][20200527154442611.png]  
![在这里插入图片描述][20200527154545568.png]  
要让centos的防火墙可以通过netassist，或者直接先关掉非防火墙，才能成功收到数据！

## 3、udp聊天器 ##

> 1、获取键盘数据，并发送给对方  
> 2、接收数据并显示  
> 3、并且功能数据进行选择以上的2个功能调用

import socket
    
    
    def send_msg(udp_socket):
        '''发送消息'''
        # 获取对方的ip
        dest_ip = input('请输入对方的ip：')
        dest_port = int(input('请输入对方的端口号：'))
        # 从键盘获取数据
        send_data = input("请输入要发送的数据： ")
        udp_socket.sendto(send_data.encode("utf-8"), (dest_ip, dest_port))
    
    def recv_msg(udp_socket):
        '''接收数据'''
        recv_data = udp_socket.recvfrom(1024)
        print("%s:%s" % (str(recv_data[1]), recv_data[0].decode("utf-8")))
    
    
    def main():
        #创建一个udp套接字
        udp_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
        #绑定信息
        udp_socket.bind(('',8899))
    
        #循环来处理事情，包括发送和接收数据
        while True:
            print("聊天器...")
            print("1:发送消息 2：接收消息 0：退出")
            op=int(input("请输入功能："))
    
            if op==1:
                # 发送
                send_msg(udp_socket)
            elif op==2:
                # 接收
                recv_msg(udp_socket)
            elif op==0:
                break
            else:print("输入有误")
    
        #关闭套接字
        udp_socket.close()
    
    if __name__ =="__main__":
        main()

socket套接字是全双工，只是程序里还没有体现出来  
这个程序，如果先不输入2，发送多次消息，再选择2，一直可以选择2，一直有打印输出消息。这是因为发送的消息先被缓存了。

# 二、TCP #

## 1、tcp简介 ##

*  udp通信，在通信开始之前，不需要建立相关连接，只需要发送数据即可，类似于生活中“写信”。
 *  TCP类似于“打电话”，是面向连接的，通信双方必须先建立连接才能进行数据的传输。完成数据交换后，双方必须断开此链接，以释放系统资源。
 *  这种连接是一对一的，不适用于广播的应用程序，基于广播的应用程序应该使用UDP协议

可靠传输：

> 1）采用发送应答机制  
> TCP发送的每个报文段都必须得到接收方的应答才认为是传输成功  
> 2）超时重传  
> ①发送端发送一个报文后就启动一个定时器，如果在定时时间段内没有收到应答就重新发送这个报文段。  
> ②TCP为了保证不丢包，就给每个包一个序号，同时序号也保证了传送到接收端实体的包的按序接收，然后接收端实体对已成功收到的包发挥一个相应的确认（ACK）；如果发送端实体在合理的往返时延（RTT）内未搜到确认，对应的数据包就会被认为丢失，进行重传  
> 3）错误校验  
> TCP用一个校验和函数来检验数据是否有错误，在发送和接收时都要计算校验和  
> 4）流量控制和阻塞管理  
> 流量控制用来避免主机发送的过快而接收方来不及收下

## 2、tcp客户端 ##

TCP严格区分客服端和服务器，客户端比服务器要简单很多，流程少。tcp客户端一般不绑定。

import socket
    def main():
        #1.创建tcp套接字
        tcp_socket=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
        
        #2.连接服务器
        server_ip=input("请输入要链接的服务器的ip：")
        server_port=int(input("请输入要连接的端口号："))
        server_addr=(server_ip,server_port)
        tcp_socket.connect(server_addr)
        #tcp_socket.connect(("192.168.245.1",7788))
        #直接用上面这句也可以
        
        #3.发送数据/接收数据
        send_data=input("请输入要发送的数据：")
        tcp_socket.send(send_data.encode("utf-8"))
    
        #4.关闭套接字
        tcp_socket.close()
    
    if __name__ =="__main__":
        main()

![在这里插入图片描述][20200527195803438.png]  
![在这里插入图片描述][20200527195847786.png]

## 3、tcp服务器 ##

**（1）简单的服务器功能**  
完成一个tcp服务器的功能，需要的流程如下（类比生活中打电话）：

> 1、socket创建一个套接字（买手机）  
> 2、bind绑定ip和port（插手机卡）  
> 3、listen使套接字变为可以被动连接（设计手机为正常接听状态，即能够响铃）  
> 4、accep等待客户端的链接（等别人打电话）  
> 5、recv/send接收发送数据

*  没有客户端发送数据时，输出“----1------”，阻塞在这一步，等客户端发数据来了，再解堵塞。
 *  第一步tcp服务器创建的这个套接字是专门用来监听的，负责用来等待新的客户端连接。accept( ) 会返回一个新的套接字给客户端，专门用来通信，服务于客户端
 *  服务器肯定是比客户端先运行

recv和recvfrom的区别：recvfrom还有发送端的信息也一起发来  
![在这里插入图片描述][20200527203328508.png]  
![在这里插入图片描述][20200527203420303.png]**（2）循环为多个客户端服务**

import socket
    def main():
        #1.创建套接字
        tcp_server_socket=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    
        #2.绑定本地信息
        tcp_server_socket.bind(("",7890))
    
        #3.让默认的套接字由主动变被动（因为创建套接字是去连接别人，而不是让别人来连接你）
        tcp_server_socket.listen(128)
    
        while True:
            print("等待一个新的客户端的到来...")
            #4.等待客户端的连接 accept返回一个元组
            new_client_socket,client_addr=tcp_server_socket.accept()
    
            print("一个新的客户端到来：%s" % str(client_addr))
    
            #接受客户端发来的请求
            recv_data=new_client_socket.recv(1024)
            print("客户端发送来的数据是：%s" % recv_data.decode("utf-8"))
    
            #回送一部分数据给客户端
            new_client_socket.send("hahaha ok".encode("utf-8"))
    
            #关闭套接字，不会再为这个客户端服务
            new_client_socket.close()
            print("已经服务完毕")
            
        #如果将监听套接字关闭了，就不能再等待新的客户端的到来，即accept就会失效
        tcp_server_socket.close()
    
    if __name__ =="__main__":
        main()

netassist一连接就会print一个新的客户端到来，一发送数据就会显示下面几行  
![在这里插入图片描述][20200527215513770.png]  
![在这里插入图片描述][20200527215601181.png]  
**（3）循环为多个客户端服务，并且多次服务一个客户端**

import socket
    def main():
        #1.创建套接字
        tcp_server_socket=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    
        #2.绑定本地信息
        tcp_server_socket.bind(("",7890))
    
        #3.让默认的套接字由主动变被动（因为创建套接字是去连接别人，而不是让别人来连接你）
        tcp_server_socket.listen(128)
    
        #这个while循环为多个客户端服务
        while True:
            print("等待一个新的客户端的到来...")
            #4.等待客户端的连接 accept返回一个元组
            new_client_socket,client_addr=tcp_server_socket.accept()
    
            print("一个新的客户端到来：%s" % str(client_addr))
    
            #这个while循环为一个客户端服务多次
            while True:
                #接受客户端发来的请求
                recv_data=new_client_socket.recv(1024)
                print("客户端发送来的数据是：%s" % recv_data.decode("utf-8"))
    
                #如果recv解堵塞，有两种可能
                #1.客户端发送了数据来
                #2.客户端调用了close,recv——data为空
                if recv_data:
                    #回送一部分数据给客户端
                    new_client_socket.send("hahaha ok".encode("utf-8"))
                else: break
    
            #关闭套接字，不会再为这个客户端服务
            new_client_socket.close()
            print("已经为这个客户端服务完毕")
    
        # 如果将监听套接字关闭了，就不能再等待新的客户端的到来，即accept就会失效
        tcp_server_socket.close()
    
    if __name__ =="__main__":
        main()

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ_size_16_color_FFFFFF_t_70]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ_size_16_color_FFFFFF_t_70 1]

## 4、tcp注意点 ##

*  tcp服务器一般情况下都需要绑定，否则客户端找不到这个服务器
 *  tcp客户端一般不绑定，因为是主动连接服务器，所以只要确定好服务器的ip，port等信息就好，本地客户端可以随机
 *  tcp服务器中通过listen可以将socket创建出来的套接字由主动变被动，这是做tcp服务器时必须要做的
 *  当客户端要连接服务器时，就要用connect进行连接，udp是不需要连接的而是直接发送，但tcp必须线连接，只有连接成功才能通信
 *  当一个tcp客户端连接服务器时，服务器端就会有一个新的套接字，这个套接字用来标记这个客户端，单独为这个客户端服务
 *  listen后的套接字是被动套接字，用来接收新的客户端的连接请求的，而accept返回的新套接字是标记这个新客户端的
 *  关闭listen后的套接字意味着被动套接字关闭了，会导致新的客户端不能链接服务器，但是之前已经成功链接的客户端正常通信
 *  关闭accept返回的套接字意味着这个客户端已经服务完毕
 *  当客户端的套接字调用close之后，服务器会解recv堵塞，并且返回的长度为0，因此服务器可以通过返回的数据长度来区别客户端是否已经下线

> UDP: socket -> bind -> sendto.recvfrom -> close  
> TCP: socket -> cnnect -> send/recv -> close（客户端）  
> socket -> bind -> listen -> accept -> recv/send -> close（服务器）

## 5、案例：文件下载器 ##

（1）客户端实现

import socket
    def main():
        #1.创建套接字
        tcp_socket=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    
        #2.获取服务器的ip,port
        dest_ip=input("请输入下载服务器的ip：")
        dest_port=int(input("请输入下载服务器的port："))
    
        #3.链接服务器
        tcp_socket.connect((dest_ip,dest_port))
    
        #4.获取下载的文件名字
        download_file_name=input("请输入要下载的文件名字：")
    
        #5.将文件名字发送到服务器
        tcp_socket.send(download_file_name.encode("utf-8"))
    
        #6.接收文件中的数据:1M
        recv_data=tcp_socket.recv(1024*1024)
    
        #7.保存接收的数据到一个文件中
        #用with的前提是open能够打开
        if recv_data:
    	    with open("[]"+download_file_name,"wb") as f:
    	        f.write(recv_data)
    
        #8.关闭套接字
        tcp_socket.close()
    
    if __name__ =="__main__":
        main()

（2）服务器实现

import socket
    
    def send_file_2_client(new_client_socket,client_addr):
        # 1.接收客户端发来要下载的文件名
        file_name = new_client_socket.recv(1024).decode("utf-8")
        print("客户端(%s)要下载的文件是：%s" % (str(client_addr), file_name))
    
        file_content=None
        #2.打开这个文件，读取数据
        try:
            f=open(file_name,"rb")
            file_content=f.read()
            f.close()
        except Exception as ret:
            print("没有要下载的文件(%s)" % file_name)
    
        # 3.发送文件的数据给客户端
        if file_content:
            #new_client_socket.send("文件数据...ok".encode("utf-8"))
            new_client_socket.send(file_content)
    
    def main():
        #1.创建套接字
        tcp_server_socket=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    
        #2.绑定本地信息
        tcp_server_socket.bind(("",7890))
    
        #3.让默认的套接字由主动变被动（因为创建套接字是去连接别人，而不是让别人来连接你）
        tcp_server_socket.listen(128)
    
        while True:
            #4.等待客户端的连接 accept返回一个元组
            new_client_socket,client_addr=tcp_server_socket.accept()
    
            #5.调用发送文件函数，完成为客户端服务
            send_file_2_client(new_client_socket, client_addr)
    
            #关闭套接字
            new_client_socket.close()
        tcp_server_socket.close()
    
    if __name__ =="__main__":
        main()

# 三、多任务-线程 #

*  并行：真的多任务
 *  并发：假的多任务（其实在一个时刻只执行了一个，但切换速度快，让你感觉是多个任务在同时执行）任务数多于内核数

## 1. 一个demo ##

import time
    import threading
    
    def sing():
        '''唱歌 5秒钟'''
        for i in range(5):
            print("正在唱歌...")
            time.sleep(1)
    
    
    def dance():
        '''跳舞 5秒钟'''
        for i in range(5):
            print("正在跳舞...")
            time.sleep(1)
    
    
    def main():
        t1=threading.Thread(target=sing)#记住没有括号，不是在调用函数
        t2=threading.Thread(target=dance)
        t1.start()
        t2.start()
    
    if __name__ =="__main__":
        main()

## 2. 多线程 ##

（1）让某些线程先执行

import time
    import threading
    
    def test1():
        for i in range(5):
            print("test1-----%d" % i)
            time.sleep(1)
    
    
    def test2():
        for i in range(5):
            print("test2----%d" % i)
            time.sleep(1)
    
    
    def main():
        t1=threading.Thread(target=test1)
        t2=threading.Thread(target=test2)
        
        t1.start()
        time.sleep(1)
        print("------1-------")
        
        t2.start()
        time.sleep(1)
        print("------2-------")
        print(threading.enumerate())
    
    if __name__ =="__main__":
        main()

![在这里插入图片描述][20200528113042107.png]  
enumerate显示的线程数：

[<_MainThread(MainThread, started 140646841353792)>, <Thread(Thread-1, started daemon 140646722881280)>, <Thread(Thread-2, started daemon 140646714488576)>]

（2）循环查看线程数

import time
    import threading
    
    def test1():
        for i in range(5):
            print("test1-----%d" % i)
            time.sleep(1)
        #如果创建子线程时执行的函数结束了，意味着这个子线程结束
    
    def test2():
        for i in range(8):
            print("test2----%d" % i)
            time.sleep(1)
    
    
    def main():
        t1=threading.Thread(target=test1)
        t2=threading.Thread(target=test2)
    
        t1.start()
        t2.start()
    
        while True:
            print(threading.enumerate())
            if len(threading.enumerate())<=1:
                break
            time.sleep(1)#1s打印一次
    
    if __name__ =="__main__":
        main()

当调用thread的时候，不会创建线程；当调用thread创建出来的实例对象的start方法时，才会创建线程，并让这个线程开始运行

## 3.线程共享全局变量 ##

### （1）多线程之间是共享全局变量的 ###

import threading,time
    
    #定义一个全局变量
    g_num=100
    
    def test1():
        global g_num
        g_num+=1
        print("----in test1  g_num=%d" % g_num)
    
    def test2():
        #如果子线程2打印出来是101，就说明2个线程共享全局变量
        print("----in test2  g_num=%d" % g_num)
    
    def main():
        t1=threading.Thread(target=test1)
        t2=threading.Thread(target=test2)
    
        t1.start()
        time.sleep(1)
    
        t2.start()
        time.sleep(1)
    
    if __name__=="__main__":
        main()

![在这里插入图片描述][20200528172014298.png]

### （2）多线程共享全局变量，args参数 ###

import threading,time
    
    def test1(temp):
        temp.append(33)
        print("----in test1  g_nums=%s" % str(temp))
    
    def test2(temp):
        print("----in test2  g_nums=%s" % str(temp))
    
    g_nums=[11,22]
    
    
    def main():
        #target指定将来这个线程去哪个函数执行代码
        #args指定将来调用函数的时候传递什么数据过去,是个元组所以加逗号
        t1=threading.Thread(target=test1,args=(g_nums,))
        t2=threading.Thread(target=test2,args=(g_nums,))
    
        t1.start()
        time.sleep(1)
    
        t2.start()
        time.sleep(1)
    
        print("-----in main Thread g_nums= %s" % str(g_nums))
    
    if __name__=="__main__":
        main()

![在这里插入图片描述][20200528172506198.png]  
在这个例子中，两个线程对全局变量操作，因为是一个写一个读，所以不会出现问题

## 4、多线程可能遇到的问题 ##

import threading,time
    
    #定义一个全局变量
    g_num=0
    
    def test1(num):
        global g_num
        for i in range(num):
            g_num+=1
        print("----in test1  g_num=%d" % g_num)
    
    def test2(num):
        global g_num
        for i in range(num):
            g_num+=1
        print("----in test2  g_num=%d" % g_num)
    
    def main():
        t1=threading.Thread(target=test1,args=(1000000,))
        t2=threading.Thread(target=test2,args=(1000000,))
    
        t1.start()
        t2.start()
    
        #延时，等待上面的线程执行完毕
        time.sleep(2)
        print("in main thread g_num=%d" % g_num)
    
    if __name__=="__main__":
        main()

两个进程一起写，出现了资源竞争。`g_num+=1`在执行时会解析成很多句话：  
①获取g\_num的值；  
②g\_num值+1；  
③把新的值存储到g\_num  
![在这里插入图片描述][20200528200711263.png]

## 5、同步和互斥锁 ##

### （1）同步 ###

同步就是协同步调，按预定的先后次序进行运行。如：你说完，我再说。这里的同步千万不要理解成那个同时进行，应是指协同、协助、互相配合。线程同步是指多线程通过特定的设置（如互斥量，事件对象，临界区）来控制线程之间的执行顺序（即所谓的同步）也可以说是在线程之间通过同步建立起执行顺序的关系，如果没有同步，那线程之间是各自运行各自的！

### （2） 互斥锁 ###

（1）多个线程几乎同时修改某一个共享数据的时候，需要进行同步控制。线程同步能够保证多个线程安全访问竞争资源，最简单的同步机制是引入互斥锁

（2）互斥锁为资源引入一个状态：锁定/非锁定  
（3）某个线程要更改共享数据时，先将其锁定，此时资源的状态为锁定，其他线程不能更改，直到该线程释放资源，将资源的状态变成“非锁定”，其他的线程才能再次锁定该资源。互斥锁保证了每次只有一个线程进行写入操作，从而保证多线程情况下数据的正确性

#创建锁
    mutex=threading.Lock()
    
    #锁定
    mutex.acquire()
    
    #释放
    mutex.release()

（1）使用互斥锁解决资源竞争的问题

import threading,time
    
    #定义一个全局变量
    g_num=0
    
    def test1(num):
        global g_num
        #上锁，如果之前没有被上锁，那么上锁成功
        #如果之前已经上锁了，则会堵塞，知道这个锁被解开位置
        mutex.acquire()
        for i in range(num):
            g_num+=1
        #解锁
        mutex.release()
        print("----in test1  g_num=%d" % g_num)
    
    def test2(num):
        global g_num
        mutex.acquire()
        for i in range(num):
            g_num+=1
        mutex.release()
        print("----in test2  g_num=%d" % g_num)
    
    #创建一个互斥锁，默认是没有上锁的
    mutex=threading.Lock()
    
    
    def main():
        t1=threading.Thread(target=test1,args=(1000000,))
        t2=threading.Thread(target=test2,args=(1000000,))
    
        t1.start()
        t2.start()
    
        #延时，等待上面的线程执行完毕
        time.sleep(1)
        print("in main thread g_num=%d" % g_num)
    
    if __name__=="__main__":
        main()

### （3）死锁 ###

*  在线程间共享多个资源的时候，如果两个线程分别占有一部分资源并且同时等待对方的资源，就会造成死锁
 *  避免死锁：  
    ①程序设计时尽量避免（银行家算法）  
    ②添加超时时间等

**银行家算法**  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ_size_16_color_FFFFFF_t_70 2]  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ_size_16_color_FFFFFF_t_70 3]

## 6、案例：多任务版本UDP聊天器 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ_size_16_color_FFFFFF_t_70 4]

import socket
    import threading
    
    def recv_msg(udp_socket):
        # 接收数据
        while True:
            recv_data = udp_socket.recvfrom(1024)
            print(recv_data)
    
    
    def send_msg(udp_socket,dest_ip,dest_port):
        # 发送数据
        while True:
            send_data = input("请输入要发送的数据：")
            udp_socket.sendto(send_data.encode("utf-8"), (dest_ip, dest_port))
    
    def main():
        '''完成udp聊天器的整体控制'''
        #1.创建套接字
        udp_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
    
        #2.绑定本地信息
        udp_socket.bind(('',7890))
    
        #3.获取对方的ip
        dest_ip=input("请输入对方的ip：")
        dest_port=int(input("请输入对方的端口号："))
    
        #4.创建2个线程去执行相应的功能
        t_recv=threading.Thread(target=recv_msg,args=(udp_socket,))
        t_send=threading.Thread(target=send_msg,args=(udp_socket,dest_ip,dest_port))
    
        t_send.start()
        t_recv.start()
    
    
    if __name__=="__main__":
        main()

# 四、多任务-进程 #

## 1、进程 ##

通俗的理解，没运行的时候是程序，程序运行起来就是进程。进程和程序一个大区别就是，程序没资源（网卡、内存…）进程是拥有资源的，是进行资源分配的基本单位。  
工作中，任务数往往大于cpu的内核数，即有一些任务正在执行，另一些人物正在等待cpu进行执行，因此导致了不同的状态  
![在这里插入图片描述][20200529221916460.png]

import time
    import multiprocessing
    
    def test1():
        while True:
            print("----1------")
            time.sleep(1)
    
    
    def test2():
        while True:
            print("----2------")
            time.sleep(1)
    
    
    def main():
        p1=multiprocessing.Process(target=test1)
        p2=multiprocessing.Process(target=test2)
    
        p1.start()
        p2.start()
    
    if __name__=="__main__":
        main()

进程也能完成多任务，但耗费的资源比较大。用Process时，子进程会复制父进程的一些资源。

## 2、进程和线程对比（重点） ##

（1）功能

*  进程：能够完成多任务，比如在一台电脑上同时运行多个qq
 *  线程：能够完成多任务，比如一个qq中的多个聊天窗口

一个进程里至少有一个主线程，进程是一个资源分配的单位，线程是一个资源调度的基本单位，执行程序是线程在执行。

（2）定义

*  进程是系统进行资源分配和调度的基本单位，它是比进程更小的能独立运行的基本单位。
 *  线程自己基本上不拥有系统资源，只拥有一点在运行中必不可少的资源（比如程序计数器，一组寄存器和栈），但是它可与同属一个进程的其他线程共享进程所拥有的的全部资源  
    （3）区别
 *  一个程序至少有一个进程，一个进程至少有一个线程
 *  线程的划分尺度小于进程，资源比进程少，使得多线程程序的并发性高
 *  进程在执行过程中拥有独立的内存单元，而多个线程共享内存，从而很大地提高了程序的运行效率
 *  线程不能独立运行，必须依存于进程中

（可以将进程理解为工厂里的一条流水线，而其中的线程就是这条流水线上的工人）

## 3、进程间通信-queue ##

import multiprocessing
    
    def download_from_web(q):
        '''下载数据'''
        #模拟从网上下载的数据
        data=[11,22,33,44]
        #向队列中写入数据
        for tmp in data:
            q.put(tmp)
    
        print("---下载器已经下载完数据并且存入到队列中---")
    
    
    def analysis_data(q):
        '''数据处理'''
        waiting_analysis=list()
        #从队列中获取数据
        while (not q.empty()):
            data=q.get()
            waiting_analysis.append(data)
    
        #模拟数据处理
        print(waiting_analysis)
    
    def main():
        #1.创建一个队列
        q=multiprocessing.Queue()
    
        #2.创建多个进程，将队列的引用当做实参传递到里面
        p1=multiprocessing.Process(target=download_from_web,args=(q,))
        p2=multiprocessing.Process(target=analysis_data,args=(q,))
        p1.start()
        p2.start()
    
    if __name__=="__main__":
        main()

## 4、进程池Pool ##

当要创建的子进程数量不多时，可以利用，multiprocessing中的Process动态生成多个进程，但如果是上百甚至上千个目标，手动去创建进程的工作量巨大，此时就可以用到multiprocessing模块提供的Pool方法。  
初始化Pool时，可以指定一个最大进程数，当有新的请求提交到Pool中时，如果池还没有满，那么就会创建一个新的进程用来执行该请求；但如果池中的进程数已经达到指定的最大值，那么该请求就会等待，直到池中有进程结束，才会用之前的进程来执行新的任务。

内置方法：

*  apply 从进程池里取一个进程并同步执行
 *  apply\_async 从进程池里取出一个进程并异步执行
 *  terminate 立刻关闭进程池
 *  close 等待所有进程结束才关闭线程池
 *  join在进程中可以阻塞主进程的执行, 直到等待子线程全部完成之后, 才继续运行主线程后面的代码，必须在close或terminete之后

（ ①同步是指一个进程在执行某个请求的时候，必须要到收到对方返回的信息才继续执行下去；②异步是指进程在执行某个请求时，不管其他的进程的状态，这个进程就执行后续操作；当有消息返回时系统会通知进程进行处理，这样可以提高执行的效率）

from multiprocessing import Pool
    import os,time,random
    
    def worker(msg):
        t_start=time.time()
        print("%s开始执行，进程号为%d" % (msg,os.getpid()))
        #random.random()随机生成0-1之间的浮点数
        time.sleep(random.random()*2)
        t_stop=time.time()
        print(msg,"执行完毕，耗时%0.2f" % (t_stop-t_start))
    
    def main():
        po=Pool(3)
        for i in range(0,10):
            #Pool.apply_async(要调用的目标，(传递给目标的参数元组))
            #每次循环将会用空闲出来的子进程去调用目标
            po.apply_async(worker,(i,))
    
        print("-----start------")
        po.close()  #关闭进程池，关闭后不再接受新的请求
        po.join() #等待po中所有子进程执行完成，必须放在close后
        print("-----end-----")
    
    if __name__=="__main__":
        main()

运行结果：

-----start------
    0开始执行，进程号为8908
    1开始执行，进程号为15608
    2开始执行，进程号为18844
    2 执行完毕，耗时0.02
    3开始执行，进程号为18844
    3 执行完毕，耗时0.03
    4开始执行，进程号为18844
    1 执行完毕，耗时0.21
    5开始执行，进程号为15608
    5 执行完毕，耗时0.08
    6开始执行，进程号为15608
    4 执行完毕，耗时0.36
    7开始执行，进程号为18844
    0 执行完毕，耗时0.58
    8开始执行，进程号为8908
    8 执行完毕，耗时0.31
    9开始执行，进程号为8908
    6 执行完毕，耗时1.16
    7 执行完毕，耗时1.17
    9 执行完毕，耗时1.97
    -----end-----

## 5、多任务文件夹拷贝 ##

多任务拷贝，可以显示拷贝进度

import multiprocessing
    import os
    
    
    def copy_file(q,file_name,old_fold_name,new_fold_name):
        '''完成文件的复制'''
        #print("====模拟copy文件：从%s--->到%s,文件名是%s" % (old_fold_name,new_fold_name,file_name))
        old_f=open(old_fold_name+"/"+file_name,"rb")
        content=old_f.read()
        old_f.close()
    
        new_f=open(new_fold_name+"/"+file_name,"wb")
        new_f.write(content)
        new_f.close()
    
        #如果拷贝完文件，就向队列中写入一个消息，表示已完成
        q.put(file_name)
    
    def main():
        # 1.获取用户要拷贝的文件夹的名字
        old_fold_name=input("请输入要copy的文件夹的名字：")
    
        #2.创建一个新的文件夹
        try:
            new_fold_name =old_fold_name+"[复制]"
            os.mkdir(new_fold_name)
        except:
            pass
    
        #3.获取文件夹所有待copy文件夹的名字 listdir()
        file_names=os.listdir(old_fold_name)
        print(file_names)
    
        #4.创建进程池，主进程负责往进程池添加任务
        po=multiprocessing.Pool(5)
    
        #5.创建一个队列
        q=multiprocessing.Manager().Queue()
    
        #6.向进程池中添加copy文件的任务
        for file_name in file_names:
            po.apply_async(copy_file,args=(q,file_name,old_fold_name,new_fold_name))
    
        #复制原文件夹的文件 到新文件夹中的文件去
        po.close()
        #po.join()
        all_file_num=len(file_names)
        copy_ok_num=0
        while True:
            file_name=q.get()
            print("已经完成copy:%s" % file_name)
            print("\r拷贝的进度为：%.2f %%" % (copy_ok_num*100/all_file_num),end="")
            copy_ok_num+=1
            if copy_ok_num>=all_file_num:
                break
    
    if __name__=="__main__":
        main()

# 五、多任务-协程 #

## 1、迭代器 ##

一个类要满足可以迭代，需要有\_\_iter\_\_方法。要称为迭代器，这个\_\_iter\_\_方法的返回值是一个有\_\_next\_\_方法和\_\_iter\_\_方法的对象。（是迭代器一定可以迭代，但，可以迭代不一定是迭代器）

迭代器实现

from collections import Iterable
    from  collections import  Iterator
    
    class Classmate(object):
        def __init__(self):
            self.names=list()
    
        def add(self,name):
            self.names.append(name)
    
        def __iter__(self):
            #如果想要一个对象成为一个可迭代对象，即可以使用for，则必须实现__iter__方法
            # 返回一个对象的引用，这个对象必须有iter和next,返回的这个东西叫迭代器
            return ClassIterator(self)
    
    class ClassIterator(object):
        def __init__(self,obje):
            self.obj=obje
            self.curnum=0
    
        def __iter__(self):
            pass
    
        def __next__(self):
            if self.curnum<len(self.obj.names):
                ret=self.obj.names[self.curnum]
                self.curnum+=1
                return ret
            else:
                raise StopIteration
    
    classmate=Classmate()
    classmate.add("老王")
    classmate.add("王二")
    classmate.add("张三")
    
    print("判断classmate是否是可以迭代的对象：",isinstance(classmate,Iterable))
    classmate_iter=iter(classmate)
    print("判断classmate_iter是否是迭代器：",isinstance(classmate_iter,Iterator))
    
    for name in classmate:
        print(name)

如果一个程序需要大量的值，我们用一个列表去存储，啥时候用，啥时候取，没有问题，但是需要占用大量的内存空间。迭代器不用占大量空间，去存储值，而是存储怎么生成这些值的方式，需要的时候生成，因此只占用一小部分空间。

## 2、迭代器应用：实现斐波那契数列 ##

from collections import Iterable
    from collections import  Iterator
    
    class Fibonacci(object):
        def __init__(self,number):
            self.num=number
            self.curnum=0
            self.a=0
            self.b=1
    
        def __iter__(self):
            return self
    
        def __next__(self):
            if self.curnum<self.num:
                ret=self.a
                self.a,self.b=self.b,self.a+self.b
                self.curnum+=1
                return ret
            else:
                raise StopIteration
    
    fib=Fibonacci(10)
    for num in fib:
        print(num)

\-------------并不是只有for循环能接收可迭代对象------------------  
除了for循环能接收可迭代对象外，list，tuple等也能接收

li=list(FibIteraor(15))
    print(li)
    tp=tuple(FibIteraor(6))
    print(tp)

## 3、生成器 ##

利用迭代器，我们可以在每次迭代获取数据（通过next() ）方法时按照特定的规律进行生产，但是我们在实现一个迭代器时，关于当前迭代到的状态要我们自己记录，进而才能根据当前状态生成下一个数据。为了达到当前记录状态，并配合next函数进行迭代使用，我们可以采用更简便的语法，即生成器。**生成器是一类特殊的迭代器。**

### （1）创建生成器 ###

创建方法一：  
`nums=(x*2 for x in range(10) ) #返回一个生成器`  
创建方法二：定义函数（如果一个函数中有yield语句，那它就是一个生成器的模板。调用时不是调用函数，而是创建一个生成器对象）

def create_num(num):
        a,b=0,1
        curnum=0
        while curnum<num:
            yield a
            a,b=b,a+b
            curnum+=1
        return "ok..."
    
    obj=create_num(10)
    #for num in obj:
    #    print(num)
    while True:
        try:
            ret=next(obj)
            print(ret)
        except Exception as ret:
            print(ret.value) #存储的就是上面函数的返回值ok
            break

### （2）send方式 ###

def create_num(num):
        a,b=0,1
        curnum=0
        while curnum<num:
            ret=yield a
            print("-----",ret)
            a,b=b,a+b
            curnum+=1
    
    obj=create_num(10)
    ret=next(obj)
    print(ret)
    
    ret=obj.send("hahaha")#这个send的值给yield a的返回值，赋值给ret
    print(ret)

## 4、使用生成器完成多任务 ##

import  time
    
    def task1():
        while True:
            print("------1------")
            time.sleep(1)
            yield
    
    
    def task2():
        while True:
            print("------2------")
            time.sleep(1)
            yield
    
    
    def main():
        t1=task1()
        t2=task2()
        while True:
            next(t1)
            next(t2)
    
    if __name__=="__main__":
        main()

这是并发，是假的多任务  
协程比线程占的资源还少

## 5、使用greenlet和gevent完成多任务 ##

（1）greenlet  
使用如下命令安装greenlet模块  
`sudo pip3 install greenlet`

from greenlet import greenlet
    import time
    
    def test1():
        while True:
            print("----A-----")
            gr2.switch()
            time.sleep(1)
    
    def test2():
        while True:
            print("----B-----")
            gr1.switch()
            time.sleep(1)
    
    gr1=greenlet(test1)
    gr2=greenlet(test2)
    
    gr1.switch()

是单线程，只是让程序暂停了去执行另一个任务  
（2）gevent  
gevent为我们自动切换协程，就保证总有greenlet在运行，而不是等待I/O。  
gevent遇到延时操作就切换到其他任务去执行，从而实现多任务。（这就是协程的核心，把延时利用起来去做其他事情）

import gevent
    import time
    from gevent import monkey
    
    monkey.patch_all()  #把延时的操作都换成gevent里面的延时，不用大量修改代码
    
    def f(n):
        for i in range(n):
            print(gevent.getcurrent(),i)
            time.sleep(1)
    
    g1=gevent.spawn(f,5)
    g2=gevent.spawn(f,5)
    g3=gevent.spawn(f,5)
    
    g1.join()
    g2.join()
    g3.join()

协程依赖于线程，线程依赖于进程

## 6、案例：图片下载器 ##

import urllib.request
    import gevent
    from gevent import monkey
    
    monkey.patch_all()
    
    def download(img_name,img_url):
        req=urllib.request.urlopen(img_url)
        img_content=req.read()
    
        with open(img_name,"wb") as f:#下载到1.png里面
            f.write(img_content)
    
    def main():
        gevent.joinall([
            gevent.spawn(download,"1.png",'https://img-blog.csdnimg.cn/20200527130559226.png'),
            gevent.spawn(download,"2.png",'https://img-blog.csdnimg.cn/20200528113042107.png')
        ])
    
    
    if __name__=="__main__":
        main()

## 7、进程线程协程对比 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ_size_16_color_FFFFFF_t_0]

# 六、正则表达式 #

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ_size_16_color_FFFFFF_t_0 1]

## 1、匹配单个字符 ##

import re
    
    #匹配：不管输入速度与激情几，都能匹配出来
    #一个\d只能代表一个数字
    #match(要求用户输入的，用户输入的)
    ret=re.match(r"速度与激情\d","速度与激情2")
    print(ret.group()) #显示用户输入的到底是几
    
    #\d是匹配0-9，如果想限制在1-8?
    ret=re.match(r"速度与激情[12345678]","速度与激情1")
    #或者写为[1-8]，如果是123678可以写为[1-36-8]
    print(ret)
    #这时输入9就没有返回值，会有异常
    print(ret.group())
    
    
    #如果要匹配字母，可以直接放中括号
    ret=re.match(r"速度与激情[1-8a-z]","速度与激情e")
    print(ret.group())
    
    ret=re.match(r"速度与激情[1-8a-zA-Z]","速度与激情E")
    print(ret.group())
    
    #\w匹配，等价于0-9,a-z,A-Z,_(下划线)，还支持中文，范围很广，慎用
    ret=re.match(r"速度与激情\w","速度与激情E")
    print(ret.group())
    
    #\s 空白字符，即空格
    ret=re.match(r"速度与激情\s\d","速度与激情 2")
    print(ret.group())
    
    # .，类似于linux的*,匹配任意一个字符，除了\n
    ret=re.match(r"速度与激情.","速度与激情e")
    print(ret.group())

## 2、匹配多个字符 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ_size_16_color_FFFFFF_t_0 2]

import re
    
    #{1,2}匹配前面那一位（紧挨的）为1-2个数字
    #比如如果\d换成字母‘a'的话，就是a为1-2位
    ret=re.match(r"速度与激情\d{1,2}","速度与激情12")
    print(ret.group())
    #{1,2}限制前面那一位为1个、2个或者3数字
    ret=re.match(r"速度与激情\d{1,3}","速度与激情132")
    print(ret.group())
    
    #必须有11位数字
    #ret=re.match(r"速度与激情\d{11}","0123456A7891")
    #不行，有字母
    #print(ret.group())
    
    
    #?前面的东西可有可无
    ret=re.match(r"021-?\d{8}","02112345678")
    print(ret.group())
    #-前面的数字可以是3位或者4位数
    ret=re.match(r"\d{3,4}-?\d{8}","0796-12345678")
    print(ret.group())
    
    ret=re.match(r"\d{3,4}-?\d{7,8}","0796-12345678")
    print(ret.group())

import re
    
    html_content='''fdsf
    anwsdkvnfkvn
    sdvcdsmvkldjf
    whejfka'''
    
    # .意味着任意字符，*表示这个字符可以有任意个
    ret=re.match(r".*",html_content)
    print(ret.group())
    #.不能匹配换行,所以只能匹配到第一行fdsf
    
    #也可以匹配空
    ret=re.match(r".*","")
    print(ret.group())
    
    #能匹配到\n
    ret=re.match(r".*",html_content,re.S)
    print(ret.group())
    
    ret=re.match(r".+","bmdsnvlck")
    print(ret.group())
    #不可以匹配空
    ret=re.match(r".+","")
    print(ret.group())

## 3、举例 ##

**（1）匹配变量名是否有效**

import re
    
    names=["name1","_name","2_name","_name_","name#!"]
    
    for name in names:
        # []判断第一位，+表示至少有一个[\w]即[a-zA-Z0-9_]，后面*表示这些可有可无
    	ret=re.match("[a-zA-Z_]+[\w]*",name)
        if ret:
            print("变量名 %s 符合要求" % ret.group())
        else:
            print("变量名 %s 非法" % name)

最后一个name\#！通过正则取出来的是name，判断时只判断开头，不判断结尾，所以取到name符合要求就拿出来了，因此，加上“$”符号，要求判断完时，到字符串结尾

ret=re.match("[a-zA-Z_]+[\w]*$",name)

python的match判断是默认从开头开始判断，一般要在判断开始前加一个 ^，所以从头到尾判断，写成如下：

ret=re.match("^[a-zA-Z_]+[\w]*$",name)

**（2）匹配邮箱地址**  
匹配出163邮箱的地址，且@符号之前有4-20位，例如hello@163.com

import re
    
    email=input("请输入一个邮箱地址：")
    # .前面加\，转义
    ret=re.match(r"[\w]{4,20}@163\.com$",email)
    if ret:
        print("%s 符合要求" % email)
    else:
        print("%s 不符合要求" % email)

## 4、匹配分组 ##

（1）如果上面的举例要也能匹配126邮箱

ret=re.match(r"[\w]{4,20}@(163|126)\.com$",email)

如果只想取某一部分特别的数据出来，比如只想知道是163还是126邮箱，或者只想提取@前面的

ret=re.match(r"([\w]{4,20})@(163|126)\.com$","jacky@126.com")
    print(ret.group(1)) #提取jacky
    print(ret.group(2)) #提取126

（2）匹配一个html字符串

#<>前后标签要一致
    html_str="<h1>hahahaha</h1>"
    # \1 表示取的是分组的第一组里面的值，也就是前面是h1的话，后面也要是h1
    ret=re.match(r"<(\w*)>.*</\1>",html_str)
    print(ret.group())

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ_size_16_color_FFFFFF_t_0 3]  
上面的可以改成：

#给分组起别名叫p1，p2
    ret=re.match(r"<(?P<p1>\w*)><(?P<p2>\w*)>.*</(?P=p2)></(?P=p1)>",html_str)

一般用 \\1 ， \\2就够了

## 5、re模块的高级用法 ##

（1）search  
search不会从头开始匹配（match是默认从头开始）

ret=re.search(r"\d+","阅读次数为999")
    print(ret.group())
    
    #search找到第一个匹配的就返回，不会再往下找,以下错误
    ret=re.search(r"\d+","阅读次数为999,点赞数为100")
    print(ret.group(1))
    
    #加了^就从头开始找，以下错误，因为开头不是数字
    ret=re.search(r"^\d+","阅读次数为999,点赞数为100")
    print(ret.group(1))

（2）findall  
findall直接返回一个列表，不用group

ret=re.findall(r"\d+","python=999,c=7890,c++=1234")
    print(ret)
    
    #输出['999', '7890', '1234']

（3）sub 将匹配到的数据进行替换

ret=re.sub(r"\d+","555","python=999,c++=1024")
    print(ret)
    #输出python=555,c++=555

中间部分也可以是一个函数的返回对象

# 七、HTTP协议 #

## 1、http协议 ##

在web应用中，服务器把网页传给浏览器，实际上就是把网页的HTML代码发送给浏览器，让浏览器显示出来。而浏览器和服务器之间的传输协议是HTTP（超文本传输协议），所以：

*  HTML是一种用来定义网页的文本，可以编写网页
 *  HTTP是在网络上传输HTML的协议，用于浏览器和服务器的通信
 *  HTTP是基于TCP的  
    在网络调试助手里面，输入如下：127.0.0.1是本地环回地址，也就是自己的浏览器向自己电脑  
    ![在这里插入图片描述][20200602145433653.png]  
    浏览器一直在等待服务器给它返回数据（服务器就是这个本机的网络调试助手）  
    ![在这里插入图片描述][20200602145606793.png]  
    浏览器向服务器发送的请求格式如下（浏览器想向服务器要什么）：

GET / HTTP/1.1
    Host: 127.0.0.1:8080
    Connection: keep-alive  //长链接
    Upgrade-Insecure-Requests: 1
    User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) /Chrome/81.0.4044.92 Safari/537.36   //客户端浏览器版本
    Accept:text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8,application/signed-exchange;v=b3;q=0.9   //浏览器可以接收什么样的数据
    Sec-Fetch-Site: none
    Sec-Fetch-Mode: navigate
    Sec-Fetch-User: ?1
    Sec-Fetch-Dest: document
    Accept-Encoding: gzip, deflate, br
    Accept-Language: zh-CN,zh;q=0.9

![在这里插入图片描述][20200602153315704.png]  
服务器回复，浏览器会显示如下界面：  
![在这里插入图片描述][20200602153401695.png]  
下面以以访问百度为例，服务器给浏览器回送的header如下（谷歌访问百度，右键–检查—network，response header旁边的view parsed）：

HTTP/1.1 200 OK    //200 状态码，这个必须得有
    Bdpagetype: 1 
    Bdqid: 0xaee93ef9000c9488
    Cache-Control: private   //缓存是私有的
    Connection: keep-alive
    Content-Encoding: gzip   //可以接受的编码格式
    Content-Type: text/html;charset=utf-8
    Date: Tue, 02 Jun 2020 07:09:34 GMT
    Expires: Tue, 02 Jun 2020 07:09:18 GMT
    Server: BWS/1.1   //百度私有的服务器
    Set-Cookie: BDSVRTM=0; path=/     
    
    //浏览器向服务器请求数据时，服务器会检查是否有cookie值。如果没有，就会set cookie给你设一个值。客户端浏览器解析到这个值时，就把它放到自己的缓存。下次再访问这个网站，就会提交这个值，服务器就有了一定的参考数据，根据cookie追踪用户。
    
    Set-Cookie: BD_HOME=1; path=/
    Set-Cookie: H_PS_PSSID=31724_1466_21103_31660_31463_31714_30824_26350_22157; path=/; domain=.baidu.com
    Strict-Transport-Security: max-age=172800
    Traceid: 1591081774046232193012603674271341646984
    X-Ua-Compatible: IE=Edge,chrome=1
    Transfer-Encoding: chunked

这是header，还有body

## 2、长连接和短连接 ##

短连接的步骤：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ_size_16_color_FFFFFF_t_0 4]  
长连接的步骤：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ_size_16_color_FFFFFF_t_0 5]  
如果服务时间很长，用长连接（HTTP1.1）  
如果只是把一个短数据给客户端，用短连接（HTTP1.0）  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ_size_16_color_FFFFFF_t_0 6]

## 3、案例：返回固定页面的http服务器 ##

import socket
    
    def service_client(new_socket):
        '''为这个客户端返回数据'''
    
        #1.接收浏览器发送的请求，即http请求
        #GET / HTTP/1.1
        #......
        request=new_socket.recv(1024)
        print(request)
    
        #2.返回http格式的数据给浏览器
        #①准备发送给浏览器的数据-----header
        response="HTTP/1.1 200 OK\r\n"  #\r\n换行
        response+="\r\n"  #一个空行
        #②准备发送给浏览器的数据-----body
        response+="<h1>what day is it today</h1>"
        new_socket.send(response.encode("utf-8"))  #send必须发送字节类型的数据
    
        #关闭套接字
        new_socket.close()
    
    
    def main():
        #1.创建套接字
        tcp_server=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    
        #2.绑定
        tcp_server.bind(("",7890))
    
        #3.变为监听套接字
        tcp_server.listen(128)
    
        while True:
            #4.等待新客户端的连接
            new_socket,client_addr=tcp_server.accept()
    
            #5.为这个客户端服务
            service_client(new_socket)
    
        #关闭监听套接字
        tcp_server.close()
    
    
    if __name__=="__main__":
        main()

![在这里插入图片描述][20200602160432288.png]

# 八、单进程、单线程、非堵塞实现并发 #

㘝不是多进程/线程/非堵塞，那么在没有客户端到来或者客户端没有发送数据时，会堵塞，不能实现多任务。如果用非堵塞的话，可以解决。

import socket
    import time
    
    tcp_server_socket=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
    tcp_server_socket.bind(("",7890))
    tcp_server_socket.listen(128)
    tcp_server_socket.setblocking(False)#设置套接字为非堵塞的方式
    
    client_socket_list=list()
    
    while True:
        time.sleep(1) #这个只是为了方便观察一下，debug，实现的时候可以抹去
    
        try:
            new_socket,addr=tcp_server_socket.accept()
        except Exception as ret:
            print("------没有新的客户端到来------")
        else:
            print("----没产生异常，意味着来了一个新的客户端----")
            new_socket.setblocking(False)#设置套接字为非堵塞的方式
            client_socket_list.append(new_socket)
    
        for client_socket in client_socket_list:
            try:
                recv_data=client_socket.recv(1024)
            except Exception as ret:
                print("----这个客户端没有发送数据----")
            else:
                print("没有异常")
                print(recv_data)
                if recv_data:
                    print("----这个客户端发送来了数据----")
                else:
                    #对方调用close导致了recv返回
                    client_socket.close()
                    #从列表里去除，防止列表过大
                    client_socket_list.remove(client_socket)

这是并发，不是并行  
如果要改写成长连接，可以规定Content Length，不关闭套接字

response_body=html_content
    
    response_header="HTTP/1.1 200 OK\r\n"
    response_header+="Content-Length:%d\r\n" % len(response_body)
    response_header+="\r\n"
    
    response=response_header.encode("utf-8")+response_body
    
    new_socket.send(response)

# 九、epoll #

epoll是在2.6内核中提出的，是之前的select和poll的增强版本。相对于select和poll来说，epoll更加灵活，没有描述符限制。epoll使用一个文件描述符管理多个描述符，将用户关系的文件描述符的事件存放到内核的一个事件表中，这样在用户空间和内核空间的copy只需一次。

假设有这样一个需求场景：有10万+的客户端与一个进程保持着 TCP连接，而每一时刻只有几十个或几百个TCP连接是活跃的，与服务器有 TCP包的交互，在每一时刻，进程只需要处理这100万连接中的一小部分连接。如何才能高效地处理这种场景呢？

有一种做法是这样的，进程想要获取客户端状态的时候，首先让操作系统收集那些 TCP连接上有事件发生，这个时候肯定要告诉操作系统要检查的 10万+个连接；然后操作系统找出这些连接中有事件发生的几百个连接，然后告诉进程，由进程针对这些有数据的连接进行进一步的处理。实际上，这就是 select或者 poll事件驱动方式的做法。

这样的做法就会有个非常明显的缺陷，在进程收集有事件的连接时，其实需要检查的大部分连接中是没有事件发生的。而且在每次收集事件时，都把这10万+连接的传给操作系统（这首先就是用户态内存到内核态内存的大量复制），然后操作系统遍历进程发送过来的连接一个个的进行遍历，查看哪些连接上有事件发生，哪些没有。这些复制传递、遍历会是巨大的资源浪费，当然也会有性能上的影响。

*  **select和epoll最大的区别就是**：  
    select只是告诉你一定数目的流有事件了，至于哪个流有事件，还得你一个一个地去轮询，而epoll会把发生的事件告诉你，通过发生的事件，就自然而然定位到哪个流了。
 *  **epoll高效的本质**：  
    1.减少用户态和内核态之间的文件句柄拷贝；  
    2.减少对可读可写文件句柄的遍历  
    [epoll详解][epoll]

[20200527130559226.png]: https://img-blog.csdnimg.cn/20200527130559226.png
[20200527130517259.png]: https://img-blog.csdnimg.cn/20200527130517259.png
[2020052716092173.png]: https://img-blog.csdnimg.cn/2020052716092173.png
[20200527154442611.png]: https://img-blog.csdnimg.cn/20200527154442611.png
[20200527154545568.png]: https://img-blog.csdnimg.cn/20200527154545568.png
[20200527195803438.png]: https://img-blog.csdnimg.cn/20200527195803438.png
[20200527195847786.png]: https://img-blog.csdnimg.cn/20200527195847786.png
[20200527203328508.png]: https://img-blog.csdnimg.cn/20200527203328508.png
[20200527203420303.png]: https://img-blog.csdnimg.cn/20200527203420303.png
[20200527215513770.png]: https://img-blog.csdnimg.cn/20200527215513770.png
[20200527215601181.png]: https://img-blog.csdnimg.cn/20200527215601181.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200527221659157.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2020052722172569.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ==,size_16,color_FFFFFF,t_70
[20200528113042107.png]: https://img-blog.csdnimg.cn/20200528113042107.png
[20200528172014298.png]: https://img-blog.csdnimg.cn/20200528172014298.png
[20200528172506198.png]: https://img-blog.csdnimg.cn/20200528172506198.png
[20200528200711263.png]: https://img-blog.csdnimg.cn/20200528200711263.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20200528221630522.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ_size_16_color_FFFFFF_t_70 3]: https://img-blog.csdnimg.cn/20200528221711715.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ==,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ_size_16_color_FFFFFF_t_70 4]: https://img-blog.csdnimg.cn/20200528222150289.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ==,size_16,color_FFFFFF,t_70
[20200529221916460.png]: https://img-blog.csdnimg.cn/20200529221916460.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ_size_16_color_FFFFFF_t_0]: https://img-blog.csdnimg.cn/20200601215658321.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ==,size_16,color_FFFFFF,t_0
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ_size_16_color_FFFFFF_t_0 1]: https://img-blog.csdnimg.cn/20200601221041754.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ==,size_16,color_FFFFFF,t_0
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ_size_16_color_FFFFFF_t_0 2]: https://img-blog.csdnimg.cn/20200601224652782.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ==,size_16,color_FFFFFF,t_0
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ_size_16_color_FFFFFF_t_0 3]: https://img-blog.csdnimg.cn/20200602135913305.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ==,size_16,color_FFFFFF,t_0
[20200602145433653.png]: https://img-blog.csdnimg.cn/20200602145433653.png
[20200602145606793.png]: https://img-blog.csdnimg.cn/20200602145606793.png
[20200602153315704.png]: https://img-blog.csdnimg.cn/20200602153315704.png
[20200602153401695.png]: https://img-blog.csdnimg.cn/20200602153401695.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ_size_16_color_FFFFFF_t_0 4]: https://img-blog.csdnimg.cn/20200603164711184.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ==,size_16,color_FFFFFF,t_0
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ_size_16_color_FFFFFF_t_0 5]: https://img-blog.csdnimg.cn/20200603164758920.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ==,size_16,color_FFFFFF,t_0
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ_size_16_color_FFFFFF_t_0 6]: https://img-blog.csdnimg.cn/20200603165736187.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2Zhbm55b29uYQ==,size_16,color_FFFFFF,t_0
[20200602160432288.png]: https://img-blog.csdnimg.cn/20200602160432288.png
[epoll]: https://blog.csdn.net/xiajun07061225/article/details/9250579