1.不同的协议在同一条网线上传递（传递的都是数据流）
    1.send 发
    2.receive 收
2.OSI七层协议
    应用层
    表示层
    会话层
    传输层
    网络层 ip
    数据链路层 mac
    物理层
    传输层：数据通信需要规则：
    TCP/IP : 三次握手 、四次断开  syn   syn+ack   ack
    UDP
3. 一台电脑上可开辟的端口数为：65535 port
    nginx:80    mysql:3306
4.模拟通信
    发送端：
    import socket ： 因为socket封装了所有的上层协议，所以在使用时，需要指明要使用的协议
    socket.TCP/IP   （声明协议类型）
    connect(a.ip,  a.port)  建立链接，链接对方的ip以及端口号
    socket.send(hello)  发送数据
    rece()  接收数据
    socket.close()  关闭链接
    接收端:    注意，先要有接收端（服务端），再有发送端
    import socket
    socket.TCP/IP   （声明协议类型）
    listen(0.0.0.0, 3306)   监听（术语）：因为一台机器有多个网卡，所以要先声明自己的网卡（0.0.0.0表示选择所有网卡），再声明自己的端口号
    waiting()   等待接收数据
    reve()  接收数据
    send()  发送数据
    服务器端不需要关闭，等待其他程序来连

简单的服务器-客户端

# -*- coding:utf8 -*-
# 客户端
import socket
client = socket.socket()    # 声明socket协议类型，同时生成socket链接对象
client.connect(("localhost", 6996))     # 连接服务器的ip和端口号
client.send("hello你好".encode(encoding="utf8"))   # 在python3中，发送的数据都是二进制数据流，所以需要将字符串转化为二进制
data = client.recv(1024)    # 接收服务器端发送过来的数据，大小上线为1024字节
print(data.decode())
client.close()

client

# -*- coding:utf8 -*-
# 服务器端
import socket
server = socket.socket()    # 声明socket协议类型，同时生成socket链接对象
server.bind(("localhost", 6996))    # 绑定需要监听的 网卡ip 和 端口号
server.listen()     # 监听
print("我要开始等电话了")
"""
等待电话打进来
conn:就是客户端连接进来，服务器端为其生成的一个链接实例
addr:客户端ip
"""
conn, addr = server.accept()
print(conn, addr)
print("电话来了")
data = conn.recv(1024)  # 1024为接收客户端发送过来数据的上限为1024字节
print("reve", data.decode())
conn.send(data.upper())  # 发送数据给客户端
server.close()  # 关闭服务器端

server

上面的代码的有一个问题， 就是SocketServer.py运行起来后， 接收了一次客户端的data就退出了。。。， 但实际场景中，一个连接建立起来后，可能要进行多次往返的通信。

 

优化后的服务器-客户端

 光只是简单的发消息、收消息没意思，干点正事，可以做一个极简版的ssh，就是客户端连接上服务器后，让服务器执行命令，并返回结果给客户端。

import os
import socket
server = socket.socket()
server.bind(("localhost", 6996))
server.listen(5)  # 设置客户端连接上限
while True:
    print("等待连接")
    conn, addr = server.accept()
    while True:
        data_1 = conn.recv(1024)
        if not data_1:
            print("客户端断开了...", conn.getpeername())
            break  # 这里断开就会再次回到第一次外层的loop
        data_2 = os.popen(data_1.decode()).read()
        conn.send(str((len(data_2.encode()))).encode()) # 提醒客户端将会发送数据的长度
        conn.send(data_2.encode())
        print("已将消息发送给：", conn.getpeername())
server.close()

服务器端

import socket
client = socket.socket()
client.connect(("localhost", 6996))
while True:
    str_input = input("请输入命令").strip()
    if len(str_input) == 0: continue
    client.send(str_input.encode())
    data_len = client.recv(1024)
    pd_len = 0
    data_1 = b""
    while pd_len < int(data_len):
        data = client.recv(1024)
        data_1 += data
        pd_len += len(data)
    print(pd_len, data_len)
    print(data_1.decode())

client.close()

客户端

粘包：

• 如果出现粘包问题（通知客户端长度的数据和需要发送给客户端的数据，被缓冲池统一处理发送给了客户端），只需要在发送这两个数据中间，在进行一次交互就可以了（例如：客户端：发送我准备好接收数据了，服务器端：接收到反馈后，给客户端发送数据）

Socket中的方法：

sk.bind(address) 必会

　　s.bind(address) 将套接字绑定到地址。address地址的格式取决于地址族。在AF_INET下，以元组（host,port）的形式表示地址。

sk.listen(backlog) 必会

　　开始监听传入连接。backlog指定在拒绝连接之前，可以挂起的最大连接数量。

      backlog等于5，表示内核已经接到了连接请求，但服务器还没有调用accept进行处理的连接个数最大为5
      这个值不能无限大，因为要在内核中维护连接队列

sk.setblocking(bool) 必会

　　是否阻塞（默认True），如果设置False，那么accept和recv时一旦无数据，则报错。

sk.accept() 必会

　　接受连接并返回（conn,address）,其中conn是新的套接字对象，可以用来接收和发送数据。address是连接客户端的地址。

　　接收TCP 客户的连接（阻塞式）等待连接的到来

sk.connect(address) 必会

　　连接到address处的套接字。一般，address的格式为元组（hostname,port）,如果连接出错，返回socket.error错误。

sk.connect_ex(address)

　　同上，只不过会有返回值，连接成功时返回 0 ，连接失败时候返回编码，例如：10061

sk.close() 必会

　　关闭套接字

sk.recv(bufsize[,flag]) 必会

　　接受套接字的数据。数据以字符串形式返回，bufsize指定最多可以接收的数量。flag提供有关消息的其他信息，通常可以忽略。

sk.recvfrom(bufsize[.flag])

　　与recv()类似，但返回值是（data,address）。其中data是包含接收数据的字符串，address是发送数据的套接字地址。

sk.send(string[,flag]) 必会

　　将string中的数据发送到连接的套接字。返回值是要发送的字节数量，该数量可能小于string的字节大小。即：可能未将指定内容全部发送。

sk.sendall(string[,flag]) 必会

　　将string中的数据发送到连接的套接字，但在返回之前会尝试发送所有数据。成功返回None，失败则抛出异常。

      内部通过递归调用send，将所有内容发送出去。

sk.sendto(string[,flag],address)

　　将数据发送到套接字，address是形式为（ipaddr，port）的元组，指定远程地址。返回值是发送的字节数。该函数主要用于UDP协议。

sk.settimeout(timeout) 必会

　　设置套接字操作的超时期，timeout是一个浮点数，单位是秒。值为None表示没有超时期。一般，超时期应该在刚创建套接字时设置，因为它们可能用于连接的操作（如 client 连接最多等待5s ）

sk.getpeername()  必会

　　返回连接套接字的远程地址。返回值通常是元组（ipaddr,port）。

sk.getsockname() 

　　返回套接字自己的地址。通常是一个元组(ipaddr,port)

SocketServer实现并发：

第一步:　你必须自己创建一个请求处理类，并且这个类要进程BaseRequestHandler,并且还要重写父类中的Handler()方法
第二步:　你必须实例化TCPServer，并且传递server ip 和 你上面创建的请求处理类 给这个TCPServer
第三步:　server．randler_reques()只处理一个请求（所以一般不用）
        server．serve_forever()处理多个一个请求，永远执行
第四步： 关闭服务器 server.close()

# -*- coding:UTF-8 -*-
import socketserver
# 创建请求类
class MySocketServer(socketserver.BaseRequestHandler):
    # 与客户端所有的交互都重写在这个方法中
    def handle(self) :
        while True:
            try:
                # 在Python3中客户端断开链接，服务器端会抛出异常
                self.data = self.request.recv(1024).strip()
                print("客户端地址为：{}".format(self.client_address[0]))
                print(self.data.decode())
                self.request.send(self.data.upper())
            except ConnectionResetError as reason:
                print(reason)
                break

if __name__ == "__main__":
    HOST, PORK = "localhost", 999
    # 这句代码可以实现服务器与客户端的一对一，但是不能一对多
    #server = socketserver.TCPServer((HOST, PORK), MySocketServer)
    # 把代码改为下面的代码，则可以实现，一对多
    server = socketserver.ThreadingTCPServer((HOST, PORK), MySocketServer)
    server.serve_forever()
    server.server_close()

多并发服务器端

# # -*- coding:utf8 -*-
# 客户端
import socket
client = socket.socket()    # 声明socket协议类型，同时生成socket链接对象
client.connect(("localhost", 999))     # 连接服务器的ip和端口号
while True:
    a = input("请输入")
    client.send(a.encode(encoding="utf8"))   # 在python3中，发送的数据都是二进制数据流，所以需要将字符串转化为二进制
    data = client.recv(1024)    # 接收服务器端发送过来的数据，大小上线为1024字节
    print(data.decode())
client.close()

客户端