python网络编程 socket

基于TCP协议的套接字编程(socket编程)

什么是Socket呢？我们经常把Socket翻译为套接字，Socket是在应用层和传输层之间的一个抽象层，它把TCP/IP层复杂的操作抽象为几个简单的接口供应用层调用已实现进程在网络中通信。

套接字的分类：
AF_UNIX：用在局域网中
AF_INET：用在互联网中

"""客户端和服务端该如何启动?"""

我们应该先启动服务端，服务端启动起来之后，等待着客户端来连接，然后接收客户端发来的消息，进行通信

TCP协议的套机字编程案例:

简易版

服务端
import socket

# 1
sever = socket.socket()  # 实例化socket对象

# 2
sever.bind(('127.0.0.1', 8000))  # 给对象设置ip和端口

# 3
sever.listen(2)  # 开始监听，并设置监听数量


# 4
sock, addr = sever.accept()  # 等待接收消息 没消息时会卡在这一步
# 5
data = sock.recv(1024)  # 接收到消息后走这一步，括号里面限制了接收的最大数据，字节类型
print(f'客户段发来的消息是{data}')
# 6
sock.send(b'wo shou dao l ni de xiaoxi')  # 向客户端发送消息，必须为字节类型

# 7
sock.close()  # 结束这轮对话

# 8 关闭与这个对象的对话
sever.close()

# 能和一个客户端对象一直发了， 但是不能和第二个客户端对象一直发


客户端

import socket

# 1
client = socket.socket()  # 实例化得到一个socket对象
# 2
client.connect(('127.0.0.1', 8000))  # 连接服务器

# 3
xiao_xi = input('请输入你要传给服务器的信息(仅支持字节类型): ')
client.send(xiao_xi.encode('utf8'))  # 发送消息  要发送字节类型的消息
# 4
data = client.recv(1024)  # 接收服务器发来的消息，并限制了大小
print(f'服务器发来的消息-->{data}')
# 5
client.close()

可以重复发送版

服务端：

while True:
    sock, addr = server.accept()  # 代码走到这里会停住，等待接收客户端发来的消息

    """
    sock：代表的是当前客户端的连接对象
    addr：代表的是客户端的信息（ip+port）
    """
    while True:
        try:
            ###5.真正的取到客户端发来的消息
            data = sock.recv(1024) # 接收的最大数据，字节类型
            if len(data) == 0:
                continue
            print("客户端发来的消息：%s" % data)
            ###6. 服务端个客户端发消息
            sock.send(data.upper())  # 数据类型必须是字节类型
        except ConnectionResetError as e:
            print(e)
            break

    ###7. 断开与客户端之间的连接
    sock.close()

###8. 关机
server.close()



##########################客户端

###2.连接服务端
client.connect(("127.0.0.1", 8000))

while True:
###3. 给服务端发送消息
    # 接收用户输入的消息
    inp_data = input("请输入发送给服务端消息：")
    client.send(inp_data.encode("utf8"))  # 也要发送字节类型

    ###4. 接收一些服务端发来的消息
    data = client.recv(1024)  # 一次接收的最大数据量，字节类型
    print("服务端发来的消息：%s" % data)
    

基于UDP协议的套接字编程

 1 服务端：
 2 import socket
 3 
 4 server = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  # 数据报协议-》UDP
 5 server.bind(('127.0.0.1', 8080))
 6 
 7 while True:
 8     # client_addr：客户端的地址：ip+port
 9 
10     data, client_addr = server.recvfrom(1024)  # 接收客户端发来的消息，1024是字节数
11 
12     print('===>', data, client_addr)
13     server.sendto(data.upper(), client_addr)  # 给客户端发消息
14 
15 server.close()
16 
17 客户端：
18 import socket
19 
20 client = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)  # 数据报协议-》UDP
21 
22 while True:
23     msg = input('>>: ').strip()  # msg=''
24     client.sendto(msg.encode('utf-8'), ('127.0.0.1', 8080))
25     data, server_addr = client.recvfrom(1024)
26     print(data)
27 
28 client.close()

黏包现象

client --------------------------------server
                                    9999
                                    1024
        9999-1024
        
黏包现象：其实就是管道里面的数据没有被完全取出来

TCP的特性：流式协议

"""
    1 当客户端发送的数据量很小并且时间间隔很小的时候,它会把数据打包成一个包一次性发送
    2 当客户端发送的数据量很大，超过服务端设置的值的时候。 可以分多次发送
"""

struct模块

import struct

# 1000  ======> 4
# 1000000 =======> 4
# helloworld ========> 4


"""报头：4个字节"""

# res=struct.pack('i', 1000)

# i:被打包的数据大小是有限制的
# res=struct.pack('q', 100000000000000000000)
# # res=struct.pack('i', 200000000)
# print(len(res))  # 4

# # 解包
# res1=struct.unpack('q', res)[0]
# print(res1)