Python基础21-网络编程

# IP协议：

规定网络地址的协议叫ip协议，它定义的地址称之为ip地址，广泛采用的v4版本即ipv4，它规定网络地址由32位2进制表示
范围0.0.0.0-255.255.255.255
一个ip地址通常写成四段十进制数，例：172.16.10.1

# ip地址分成两部分（点分十进制）

网络部分：标识子网
主机部分：标识主机
注意：单纯的ip地址段只是标识了ip地址的种类，从网络部分或主机部分都无法辨识一个ip所处的子网

例：172.16.10.1与172.16.10.2并不能确定二者处于同一子网

# 子网掩码

所谓”子网掩码”，就是表示子网络特征的一个参数。它在形式上等同于IP地址，也是一个32位二进制数字，它的网络部分全部为1，主机部分全部为0。比如，IP地址172.16.10.1，如果已知网络部分是前24位，主机部分是后8位，那么子网络掩码就是11111111.11111111.11111111.00000000，写成十进制就是255.255.255.0。

 

知道”子网掩码”，我们就能判断，任意两个IP地址是否处在同一个子网络。方法是将两个IP地址与子网掩码分别进行AND运算（两个数位都为1，运算结果为1，否则为0），然后比较结果是否相同，如果是的话，就表明它们在同一个子网络中，否则就不是。

 

比如，已知IP地址172.16.10.1和172.16.10.2的子网掩码都是255.255.255.0，请问它们是否在同一个子网络？两者与子网掩码分别进行AND运算，

172.16.10.1：10101100.00010000.00001010.000000001

255255.255.255.0:11111111.11111111.11111111.00000000

AND运算得网络地址结果：10101100.00010000.00001010.000000001->172.16.10.0
AND运算又叫做"按位与"运算，符号："&"，在编程术语中表示一种运算方法，不可逆

172.16.10.2：10101100.00010000.00001010.000000010

255255.255.255.0:11111111.11111111.11111111.00000000

AND运算得网络地址结果：10101100.00010000.00001010.000000001->172.16.10.0

结果都是172.16.10.0，因此它们在同一个子网络。

总结一下，IP协议的作用主要有两个，一个是为每一台计算机分配IP地址，另一个是确定哪些地址在同一个子网络

# ip数据包

ip数据包也分为head和data部分，无须为ip包定义单独的栏位，直接放入以太网包的data部分

head：长度为20到60字节

data：最长为65,515字节。

而以太网数据包的”数据”部分，最长只有1500字节。因此，如果IP数据包超过了1500字节，它就需要分割成几个以太网数据包，分开发送了。

# ARP协议（Address Resolution Protocol）

arp协议由来：计算机通信基本靠吼，即广播的方式，所有上层的包到最后都要封装上以太网头，然后通过以太网协议发送，在谈及以太网协议时候，我门了解到

通信是基于mac的广播方式实现，计算机在发包时，获取自身的mac是容易的，如何获取目标主机的mac，就需要通过arp协议

arp协议功能：广播的方式发送数据包，获取目标主机的mac地址

 

协议工作方式：每台主机ip都是已知的

例如：主机172.16.10.10/24访问172.16.10.11/24

服务端套接字函数
s.bind()    绑定(主机,端口号)到套接字
s.listen()  开始TCP监听
s.accept()  被动接受TCP客户的连接,(阻塞式)等待连接的到来

客户端套接字函数
s.connect()     主动初始化TCP服务器连接
s.connect_ex()  connect()函数的扩展版本,出错时返回出错码,而不是抛出异常

公共用途的套接字函数
s.recv()            接收TCP数据
s.send()            发送TCP数据(send在待发送数据量大于己端缓存区剩余空间时,数据丢失,不会发完)
s.sendall()         发送完整的TCP数据(本质就是循环调用send,sendall在待发送数据量大于己端缓存区剩余空间时,数据不丢失,循环调用send直到发完)
s.recvfrom()        接收UDP数据
s.sendto()          发送UDP数据
s.getpeername()     连接到当前套接字的远端的地址
s.getsockname()     当前套接字的地址
s.getsockopt()      返回指定套接字的参数
s.setsockopt()      设置指定套接字的参数
s.close()           关闭套接字

面向锁的套接字方法
s.setblocking()     设置套接字的阻塞与非阻塞模式
s.settimeout()      设置阻塞套接字操作的超时时间
s.gettimeout()      得到阻塞套接字操作的超时时间

面向文件的套接字的函数
s.fileno()          套接字的文件描述符
s.makefile()        创建一个与该套接字相关的文件

## 服务端
import socket

# 1.买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)  #SOCK_STREAM 就是 TCP 协议，TCP协议又叫流式协议。。SOCK_DGRAM是udp协议
print(phone)

import socket

# 1.买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)  #SOCK_STREAM 就是 TCP 协议，TCP协议又叫流式协议。。SOCK_DGRAM是udp协议
print(phone)

# 2.插手机卡
phone.bind(('127.0.0.1',3306))

import socket

# 1.买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)  #SOCK_STREAM 就是 TCP 协议，TCP协议又叫流式协议。。SOCK_DGRAM是udp协议
print(phone)

# 2.插手机卡
phone.bind(('127.0.0.1',3306))

# 3.开机(半连接池，最大请求数为5)
phone.listen(5)

import socket

# 1.买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)  #SOCK_STREAM 就是 TCP 协议，TCP协议又叫流式协议。。SOCK_DGRAM是udp协议

# 2.插手机卡
phone.bind(('127.0.0.1',3306))

# 3.开机(半连接池，最大请求数为5)
phone.listen(5)

# 4.等待电话请求
conn,client_addr=phone.accept()#套接字对象(返回元组的双向链接套接字对象，存放客户端ip和端口的小元组)
print(conn)
print(client_addr)

import socket

# 1.买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)  #SOCK_STREAM 就是 TCP 协议，TCP协议又叫流式协议。。SOCK_DGRAM是udp协议

# 2.打电话
phone.connect(('127.0.0.1',3306))

import socket

# 1.买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)  #SOCK_STREAM 就是 TCP 协议，TCP协议又叫流式协议。。SOCK_DGRAM是udp协议

# 2.插手机卡
phone.bind(('127.0.0.1',3306))

# 3.开机(半连接池，最大请求数为5)
phone.listen(5)

# 4.等待电话请求
conn,client_addr=phone.accept()
print(conn)
print(client_addr)

# 5.收\发消息
data=conn.recv(1024) #1024接收的最大字节数
print('收到客户的数据：',data)
conn.send(data.upper()) #收到数据之后，回消息给客户端

# 6.挂电话，断开链接
conn.close()

# 7.再次回收资源：关机
phone.close()

import socket

# 1.买手机
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)  #SOCK_STREAM 就是 TCP 协议，TCP协议又叫流式协议。。SOCK_DGRAM是udp协议

# 2.打电话
phone.connect(('127.0.0.1',3306))

# 3.发\收消息
phone.send('hello'.encode('utf-8')) # 只能发送bytes类型
data=phone.recv(1024)
print('收到服务端的消息：',data)

# 4.挂电话(断开链接)
phone.close()

## 服务端必须满足至少三点条件：
# 1.绑定一个固定的ip和port
# 2.一直对外提供服务，稳定运行
# 3.能够支持并发

from socket import *

server=socket(AF_INET,SOCK_STREAM)
server.bind(('127.0.0.1',8888))
server.listen(5)
conn,client_addr=server.accept()
data=conn.recv(1024)
print('接收到客户端数据：',data)
conn.send(data.upper())
conn.close()
server.close()

from socket import *

client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8888))

client.send('hello'.encode('utf-8'))
data=client.recv(1024)
print(data)

client.close()

from socket import *

client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8888))

while True:
    client.send('hello'.encode('utf-8'))
    data=client.recv(1024)
    print(data)

client.close()

## 服务端必须满足至少三点条件：
# 1.绑定一个固定的ip和port
# 2.一直对外提供服务，稳定运行
# 3.能够支持并发

from socket import *

server=socket(AF_INET,SOCK_STREAM)
server.bind(('127.0.0.1',8888))
server.listen(5)
conn,client_addr=server.accept()

while True:
    data=conn.recv(1024)
    conn.send(data.upper())

conn.close()
server.close()

from socket import *

client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8888))

# 通信循环
while True:
    msg=input('>>>: ').strip()
    client.send(msg.encode('utf-8'))
    data=client.recv(1024)
    print(data)

client.close()

## 服务端必须满足至少三点条件：
# 1.绑定一个固定的ip和port
# 2.一直对外提供服务，稳定运行
# 3.能够支持并发

from socket import *

server = socket(AF_INET, SOCK_STREAM)
server.bind(('127.0.0.1', 8888))
server.listen(5)


conn, client_addr = server.accept()

while True:
    try:  # 处理windows的客户端连接bug
        data = conn.recv(1024)
        if len(data) == 0: break  # 解决 linux 系统bug
        conn.send(data.upper())
    except ConnectionResetError:
        break

conn.close()
server.close()

## 服务端必须满足至少三点条件：
# 1.绑定一个固定的ip和port
# 2.一直对外提供服务，稳定运行
# 3.能够支持并发

from socket import *

server = socket(AF_INET, SOCK_STREAM)
server.bind(('127.0.0.1', 8888))
server.listen(5)

while True: #链接+通信循环
    conn, client_addr = server.accept()

    while True:  #通信循环
        try:  # 处理windows的客户端连接bug
            data = conn.recv(1024)
            if len(data) == 0: break  # 解决 linux 系统bug
            conn.send(data.upper())
        except ConnectionResetError:
            break

    conn.close()
server.close()

from socket import *

client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8888))

# 通信循环
while True:
    msg=input('>>>: ').strip()
    if len(msg) == 0:continue
    client.send(msg.encode('utf-8'))
    data=client.recv(1024)
    print(data)

client.close()

from socket import *

client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8080))

# 通信循环
while True:
    cmd=input('请输入要执行的linux命令: ').strip()
    if len(cmd) == 0:continue
    client.send(cmd.encode('utf-8'))
    cmd_res=client.recv(1024)
    print(cmd_res.decode('utf-8'))

client.close()

## 服务端必须满足至少三点条件：
# 1.绑定一个固定的ip和port
# 2.一直对外提供服务，稳定运行
# 3.能够支持并发

from socket import *
import subprocess

server = socket(AF_INET, SOCK_STREAM)
server.bind(('127.0.0.1', 8080))
server.listen(5)

while True: #链接+通信循环
    conn, client_addr = server.accept()

    while True:  #通信循环
        try:  # 处理windows的客户端连接bug
            cmd = conn.recv(1024)
            if len(cmd) == 0: break # 解决 linux 系统bug
            res = subprocess.Popen(cmd.decode('utf-8'), stdout=subprocess.PIPE, shell=True, stderr=subprocess.PIPE)
            stdout=res.stdout.read()
            stderr=res.stderr.read()
            conn.send(stdout+stderr)
        except ConnectionResetError:
            break

    conn.close()
server.close()

from socket import *
import subprocess

server = socket(AF_INET, SOCK_STREAM)
server.bind(('127.0.0.1', 8081))
server.listen(5)

conn,_=server.accept()
data1=conn.recv(5)
print('第一次收: ',data1)

data2=conn.recv(5)
print('第二次收: ',data2)

data3=conn.recv(3)
print('第三次收: ',data3)

from socket import *

client = socket(AF_INET, SOCK_STREAM)
client.connect(('127.0.0.1', 8081))

# tcp协议会将数据量较小且发送时间间隔较短的数据合并成一个数据报发送
client.send(b'hello')
client.send(b'world')
client.send(zls')

import struct

obj1=struct.pack('i',133211)
print(obj1,len(obj1))

res1 = struct.unpack('i',obj1)
print(res1[0])

## 关于struct的详细用法
import struct
import binascii
import ctypes

values1 = (1, 'abc'.encode('utf-8'), 2.7)
values2 = ('defg'.encode('utf-8'),101)
s1 = struct.Struct('I3sf')
s2 = struct.Struct('4sI')

print(s1.size,s2.size)
prebuffer=ctypes.create_string_buffer(s1.size+s2.size)
print('Before : ',binascii.hexlify(prebuffer))
# t=binascii.hexlify('asdfaf'.encode('utf-8'))
# print(t)


s1.pack_into(prebuffer,0,*values1)
s2.pack_into(prebuffer,s1.size,*values2)

print('After pack',binascii.hexlify(prebuffer))
print(s1.unpack_from(prebuffer,0))
print(s2.unpack_from(prebuffer,s1.size))

s3=struct.Struct('ii')
s3.pack_into(prebuffer,0,123,123)
print('After pack',binascii.hexlify(prebuffer))
print(s3.unpack_from(prebuffer,0))

# 服务端必须满足至少三点:
# 1. 绑定一个固定的ip和port
# 2. 一直对外提供服务,稳定运行
# 3. 能够支持并发
from socket import *
import subprocess
import struct

server = socket(AF_INET, SOCK_STREAM)
server.bind(('127.0.0.1', 8081))
server.listen(5)

# 链接循环
while True:
    conn, client_addr = server.accept()
    print(client_addr)

    # 通信循环
    while True:
        try:
            cmd = conn.recv(1024) #cmd=b'dir'
            if len(cmd) == 0: break  # 针对linux系统
            obj=subprocess.Popen(cmd.decode('utf-8'),
                             shell=True,
                             stdout=subprocess.PIPE,
                             stderr=subprocess.PIPE
                             )
            stdout=obj.stdout.read()
            stderr=obj.stderr.read()
            # 1. 先制作固定长度的报头
            header=struct.pack('i',len(stdout) + len(stderr))
            # 2. 再发送报头
            conn.send(header)
            # 3. 最后发送真实的数据
            conn.send(stdout)
            conn.send(stderr)
        except ConnectionResetError:
            break

    conn.close()

server.close()

from socket import *
import struct

client = socket(AF_INET, SOCK_STREAM)
client.connect(('127.0.0.1', 8081))

# 通信循环
while True:
    cmd=input('>>: ').strip()
    if len(cmd) == 0:continue
    client.send(cmd.encode('utf-8'))
    #1. 先收报头,从报头里解出数据的长度
    header=client.recv(4)
    total_size=struct.unpack('i',header)[0]
    #2. 接收真正的数据
    cmd_res=b''
    recv_size=0
    while recv_size < total_size:
        data=client.recv(1024)
        recv_size+=len(data)
        cmd_res+=data

    print(cmd_res.decode('gbk'))

client.close()

import struct
import json

header_dic={
                'filename':'a.txt',
                'md5':'asdfasdf123123x1',
                'total_size':123123111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111123
            }

header_json=json.dumps(header_dic)
# print(header_json)
header_bytes=header_json.encode('utf-8')
print(len(header_bytes))

from socket import *
import struct
import json

client = socket(AF_INET, SOCK_STREAM)
client.connect(('127.0.0.1', 8081))

# 通信循环
while True:
    cmd=input('>>: ').strip()
    if len(cmd) == 0:continue
    client.send(cmd.encode('utf-8'))
    #1. 先收4bytes,解出报头的长度
    header_size=struct.unpack('i',client.recv(4))[0]

    #2. 再接收报头,拿到header_dic
    header_bytes=client.recv(header_size)
    header_json=header_bytes.decode('utf-8')
    header_dic=json.loads(header_json)
    print(header_dic)
    total_size=header_dic['total_size']

    #3. 接收真正的数据
    cmd_res=b''
    recv_size=0
    while recv_size < total_size:
        data=client.recv(1024)
        recv_size+=len(data)
        cmd_res+=data

    print(cmd_res.decode('gbk'))

client.close()

# 服务端必须满足至少三点:
# 1. 绑定一个固定的ip和port
# 2. 一直对外提供服务,稳定运行
# 3. 能够支持并发
from socket import *
import subprocess
import struct
import json

server = socket(AF_INET, SOCK_STREAM)
server.bind(('127.0.0.1', 8081))
server.listen(5)

# 链接循环
while True:
    conn, client_addr = server.accept()
    print(client_addr)

    # 通信循环
    while True:
        try:
            cmd = conn.recv(1024)  # cmd=b'dir'
            if len(cmd) == 0: break  # 针对linux系统
            obj = subprocess.Popen(cmd.decode('utf-8'),
                                   shell=True,
                                   stdout=subprocess.PIPE,
                                   stderr=subprocess.PIPE
                                   )
            stdout = obj.stdout.read()
            stderr = obj.stderr.read()
            # 1. 先制作报头
            header_dic = {
                'filename': 'a.txt',
                'md5': 'asdfasdf123123x1',
                'total_size': len(stdout) + len(stderr)
            }
            header_json = json.dumps(header_dic)
            header_bytes = header_json.encode('utf-8')

            # 2. 先发送4个bytes(包含报头的长度)
            conn.send(struct.pack('i', len(header_bytes)))
            # 3  再发送报头
            conn.send(header_bytes)

            # 4. 最后发送真实的数据
            conn.send(stdout)
            conn.send(stderr)
        except ConnectionResetError:
            break

    conn.close()

server.close()

import socketserver
import struct
import json
import os
class FtpServer(socketserver.BaseRequestHandler):
    coding='utf-8'
    server_dir='file_upload'
    max_packet_size=1024
    BASE_DIR=os.path.dirname(os.path.abspath(__file__))
    def handle(self):
        print(self.request)
        while True:
            data=self.request.recv(4)
            data_len=struct.unpack('i',data)[0]
            head_json=self.request.recv(data_len).decode(self.coding)
            head_dic=json.loads(head_json)
            # print(head_dic)
            cmd=head_dic['cmd']
            if hasattr(self,cmd):
                func=getattr(self,cmd)
                func(head_dic)
    def put(self,args):
        file_path = os.path.normpath(os.path.join(
            self.BASE_DIR,
            self.server_dir,
            args['filename']
        ))

        filesize = args['filesize']
        recv_size = 0
        print('----->', file_path)
        with open(file_path, 'wb') as f:
            while recv_size < filesize:
                recv_data = self.request.recv(self.max_packet_size)
                f.write(recv_data)
                recv_size += len(recv_data)
                print('recvsize:%s filesize:%s' % (recv_size, filesize))


ftpserver=socketserver.ThreadingTCPServer(('127.0.0.1',8080),FtpServer)
ftpserver.serve_forever()

import socket
import struct
import json
import os



class MYTCPClient:
    address_family = socket.AF_INET

    socket_type = socket.SOCK_STREAM

    allow_reuse_address = False

    max_packet_size = 8192

    coding='utf-8'

    request_queue_size = 5

    def __init__(self, server_address, connect=True):
        self.server_address=server_address
        self.socket = socket.socket(self.address_family,
                                    self.socket_type)
        if connect:
            try:
                self.client_connect()
            except:
                self.client_close()
                raise

    def client_connect(self):
        self.socket.connect(self.server_address)

    def client_close(self):
        self.socket.close()

    def run(self):
        while True:
            inp=input(">>: ").strip()
            if not inp:continue
            l=inp.split()
            cmd=l[0]
            if hasattr(self,cmd):
                func=getattr(self,cmd)
                func(l)


    def put(self,args):
        cmd=args[0]
        filename=args[1]
        if not os.path.isfile(filename):
            print('file:%s is not exists' %filename)
            return
        else:
            filesize=os.path.getsize(filename)

        head_dic={'cmd':cmd,'filename':os.path.basename(filename),'filesize':filesize}
        print(head_dic)
        head_json=json.dumps(head_dic)
        head_json_bytes=bytes(head_json,encoding=self.coding)

        head_struct=struct.pack('i',len(head_json_bytes))
        self.socket.send(head_struct)
        self.socket.send(head_json_bytes)
        send_size=0
        with open(filename,'rb') as f:
            for line in f:
                self.socket.send(line)
                send_size+=len(line)
                print(send_size)
            else:
                print('upload successful')




client=MYTCPClient(('127.0.0.1',8080))

client.run()

import socket

server=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
server.bind(('127.0.0.1',8080))
## TCP协议应该写：server.listen(5)，但是udp协议不需要链接
## TCP协议应该写：erver.accept()，建立双向链接，但是udp协议没有，所以也不写

while True:
    data=server.recvfrom(1024)
    print(data)

import socket

client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
## TCP协议应该写：client.connect(('127.0.0.1',8080)) 但是udp协议没有链接

while True:
    msg=input('>>:').strip()
    client.sendto(msg.encode('utf-8'),('127.0.0.1',8080))

import socket

server=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
server.bind(('127.0.0.1',8080))
## TCP协议应该写：server.listen(5)，但是udp协议不需要链接
## TCP协议应该写：erver.accept()，建立双向链接，但是udp协议没有，所以也不写

while True:
    data,client_addr=server.recvfrom(1024)
    print(data)
    server.sendto(data.upper(),client_addr)

import socket

client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
## TCP协议应该写：client.connect(('127.0.0.1',8080)) 但是udp协议没有链接

while True:
    msg=input('>>:').strip()
    client.sendto(msg.encode('utf-8'),('127.0.0.1',8080))
    data,server_addr=client.recvfrom(1024)
    print(data)

## 服务端
import socket

server=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
server.bind(('127.0.0.1',8080))
## TCP协议应该写：server.listen(5)，但是udp协议不需要链接
## TCP协议应该写：server.accept()，建立双向链接，但是udp协议没有，所以也不写

print(server.recvfrom(1024))
print(server.recvfrom(1024))
print(server.recvfrom(1024))


## 客户端
import socket

client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
## TCP协议应该写：client.connect(('127.0.0.1',8080)) 但是udp协议没有链接

client.sendto(b'hello',('127.0.0.1',8080))
client.sendto(b'world',('127.0.0.1',8080))
client.sendto(b'zls',('127.0.0.1',8080))

## 服务端
import socket
ip_port=('127.0.0.1',8081)
udp_server_sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM) #买手机
udp_server_sock.bind(ip_port)

while True:
    qq_msg,addr=udp_server_sock.recvfrom(1024)
    print('来自[%s:%s]的一条消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],qq_msg.decode('utf-8')))
    back_msg=input('回复消息: ').strip()

    udp_server_sock.sendto(back_msg.encode('utf-8'),addr)


## 客户端1
import socket
BUFSIZE=1024
udp_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

qq_name_dic={
    '虞姬':('127.0.0.1',8081),
    '韩信':('127.0.0.1',8081),
    '甄姬':('127.0.0.1',8081),
    '武大郎':('127.0.0.1',8081),
}


while True:
    qq_name=input('请选择聊天对象: ').strip()
    while True:
        msg=input('请输入消息,回车发送: ').strip()
        if msg == 'quit':break
        if not msg or not qq_name or qq_name not in qq_name_dic:continue
        udp_client_socket.sendto(msg.encode('utf-8'),qq_name_dic[qq_name])

        back_msg,addr=udp_client_socket.recvfrom(BUFSIZE)
        print('来自[%s:%s]的一条消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],back_msg.decode('utf-8')))

udp_client_socket.close()

## 客户端2
import socket
BUFSIZE=1024
udp_client_socket=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)

qq_name_dic={
    '虞姬':('127.0.0.1',8081),
    '韩信':('127.0.0.1',8081),
    '甄姬':('127.0.0.1',8081),
    '武大郎':('127.0.0.1',8081),
}


while True:
    qq_name=input('请选择聊天对象: ').strip()
    while True:
        msg=input('请输入消息,回车发送: ').strip()
        if msg == 'quit':break
        if not msg or not qq_name or qq_name not in qq_name_dic:continue
        udp_client_socket.sendto(msg.encode('utf-8'),qq_name_dic[qq_name])

        back_msg,addr=udp_client_socket.recvfrom(BUFSIZE)
        print('来自[%s:%s]的一条消息:\033[1;44m%s\033[0m' %(addr[0],addr[1],back_msg.decode('utf-8')))

udp_client_socket.close()

import socketserver

## 自定义的类，只能来处理通信循环
class MyTCPHandler(socketserver.BaseRequestHandler):
    def handle(self):
        print(self.client_address)
        pass

if __name__ == '__main__':
    server=socketserver.ThreadingTCPServer(('127.0.0.1',8081),MyTCPHandler)## 创建线程
    server.serve_forever()   ## 链接循环

### 服务端
###  思路，一个人站门口不停的建链接，然后造完链接就起一个线程，去做该做的事情

import socketserver

## 自定义的类，只能来处理通信循环
class MyTCPHandler(socketserver.BaseRequestHandler):
    def handle(self):
        while True:  # 通信循环
            try:  # 处理windows的客户端连接bug
                data = self.request.recv(1024)
                if len(data) == 0: break  # 解决 linux 系统bug
                print('--->接收到客户端消息',data)
                self.request.send(data.upper())
            except ConnectionResetError:
                break
        self.request.close()

if __name__ == '__main__':
    server=socketserver.ThreadingTCPServer(('127.0.0.1',8081),MyTCPHandler)## 创建线程
    server.serve_forever()   ## 链接循环

### 客户端
from socket import *

client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8081))

# 通信循环
while True:
    msg=input('>>>: ').strip()
    client.send(msg.encode('utf-8'))
    data=client.recv(1024)
    print(data)

client.close()

### 服务端
import socketserver

class MyUDPHandler(socketserver.BaseRequestHandler):
    def handle(self):
        print(self.request)

if __name__ == '__main__':
    server=socketserver.ForkingUDPServer(('127.0.0.1',8080),MyUDPHandler)
    server.serve_forever()


### 客户端
import socket

client=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
## TCP协议应该写：client.connect(('127.0.0.1',8080)) 但是udp协议没有链接

while True:
    client.sendto(b'hello',('127.0.0.1',8080))
    data,server_addr=client.recvfrom(1024)
    print(data)

### 服务端，添加一个通信循环

import socketserver
import socketserver

class MyUDPHandler(socketserver.BaseRequestHandler):
    def handle(self):
        print(self.request)
        data,sock=self.request
        self.request[1].sendto(data.upper(),self.client_address)

if __name__ == '__main__':
    server=socketserver.ForkingUDPServer(('127.0.0.1',8080),MyUDPHandler)
    server.serve_forever()