socket套接字
作者：互联网
socket套接字
简介
Socket并不属于TCP/IP协议簇，它只是一个编程接口，即对TCP/IP的封装和应用，简单理解TCP/IP看看作一
个函数，而Socket用来进行调用，Socket可在网络中对两个程序建立通信通道，Socket可分为两个基本模块，一个
服务端一个客户端，链接后进行通信。
网络编程
常见的套接字对象方法和属性
创建TCP服务端
import socket
server = socket.socket() # 创建一个socket对象（server）
server.bind(('192.168.1.8', 8080)) # 给socket对象（server）绑定ip和端口号（以元组的形式）
server.listen(5) # 设置半连接池,最低为0
sock, addr = server.accept() # 接收客户端连接，获得sock连接 和 addr客户端地址。
data = sock.recv(1024) # 获取客户端发送的消息
print(data.decode('utf8')) # 打印接收到的数据，由于传输的时候是二进制所以需要进行解码
sock.send('你好'.encode('utf8')) # 服务端发送消息给客户端
sock.close() # 断开服务端到客户端的连接
server.close() # 关闭服务端
创建一个TCP客户端
import socket
client = socket.socket() # 创建一个socket对象（client）
client.connect(('192.168.1.8', 8080)) # 根据ip和端口连接服务端（元组的形式）,主动发起连接
msg = input('要发送的消息: ').strip() # 获取要发送给服务端的消息
client.send(msg.encode('utf8')) # 将消息先编码后在发送给服务端
data = client.recv(1024) # 获取服务端发送的消息
print(data.decode('utf8')) # 打印接收到的数据，由于传输的时候是二进制所以需要进行解码
client.close() # 断开连接,关闭客户端
在重启服务器的时候可能会遇到的BUG(mac居多)，windows频率较少
解决办法
import socket
from socket import SOL_SOCKET,SO_REUSEADDR（导入对应的包）
server = socket.socket() # 创建一个socket对象（server）
# -------------------------------------
# 加上它就可以防止重启报错了(注意位置)
# -------------------------------------
server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
server.bind(('192.168.1.8', 8080)) # 给socket对象（server）绑定ip和端口号（以元组的形式）
server.listen(5) # 设置半连接池,最低为0
sock, addr = server.accept() # 接收客户端连接，获得sock连接 和 addr客户端地址。
data = sock.recv(1024) # 获取客户端发送的消息
print(data.decode('utf8')) # 打印接收到的数据，由于传输的时候是二进制所以需要进行解码
sock.send('你好'.encode('utf8')) # 服务端发送消息给客户端
sock.close() # 断开服务端到客户端的连接
server.close() # 关闭服务端
通信循环
linux、mac断开链接时不会报错，会一直返回空(b‘’)
服务端
import socket
from socket import SOL_SOCKET,SO_REUSEADDR
server = socket.socket() # 创建一个socket对象（server）
# -------------------------------------
# 加上他就可以防止重启报错了(注意位置)
# -------------------------------------
server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
server.bind(('192.168.1.8', 8080)) # 给socket对象（server）绑定ip和端口号（以元组的形式）
server.listen(5) # 设置半连接池,最低为0
sock, addr = server.accept() # 接收客户端连接，获得sock连接 和 addr客户端地址。
while True:
data = sock.recv(1024) # 获取客户端发送的消息
print(data.decode('utf8')) # 打印接收到的数据，由于传输的时候是二进制所以需要进行解码
msg = input('要发送的消息: ').strip()
sock.send(msg.encode('utf8')) # 服务端发送消息给客户端
# sock.close() # 断开服务端到客户端的连接
# server.close() # 关闭服务端
客户端
import socket
client = socket.socket() # 创建一个socket对象（client）
client.connect(('192.168.1.8', 8080)) # 根据ip和端口连接服务端（元组的形式）,主动发起连接
while True:
msg = input('要发送的消息: ').strip() # 获取要发送给服务端的消息
if len(msg) == 0: continue # 避免消息为空时，造成双方等待
client.send(msg.encode('utf8')) # 将消息先编码后在发送给服务端
data = client.recv(1024) # 获取服务端发送的消息
print(data.decode('utf8')) # 打印接收到的数据，由于传输的时候是二进制所以需要进行解码
client.close() # 断开连接,关闭客户端
链接循环
"""
如果是windows 客户端异常退出之后服务端会直接报错
处理方式
异常处理
如果是mac或linux 服务端会接收到一个空消息
处理方式
len判断
"""
客户端如果异常断开 服务端代码应该重新回到accept等待新的客人
import socket
from socket import SOL_SOCKET, SO_REUSEADDR
server = socket.socket() # 创建一个socket对象（server）
# -------------------------------------
# 加上他就可以防止重启报错了(注意位置)
# -------------------------------------
server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
server.bind(('192.168.1.8', 8080)) # 给socket对象（server）绑定ip和端口号（以元组的形式）
server.listen(5) # 设置半连接池,最低为0
while True:
sock, addr = server.accept() # 接收客户端连接，获得sock连接 和 addr客户端地址。
while True:
try:
data = sock.recv(1024) # 获取客户端发送的消息
print(data.decode('utf8')) # 打印接收到的数据，由于传输的时候是二进制所以需要进行解码
msg = input('要发送的消息: ').strip()
sock.send(msg.encode('utf8')) # 服务端发送消息给客户端
except BaseException:
break # 客户端如果异常断开 服务端代码应该重新回到accept等待新的客人
# sock.close() # 断开服务端到客户端的连接
# server.close() # 关闭服务端
半连接池，允许等待的最大个数
1.什么是半连接池：当服务器在响应了客户端的第一次请求后会进入等待状态，会等客户端发送的ack信息，这时候这个连接就称之为半连接
2.半连接池其实就是一个容器，系统会自动将半连接放入这个容器中，可以避免半连接过多而保证资源耗光
3.产生半连接的两种情况：
客户端无法返回ACK信息
服务器来不及处理客户端的连接请求
设置的最大等待人数 >>>: 节省资源 提高效率
server.listen(5)指定5个等待席位
黏包问题
多次发送被并为一次
# TCP协议的特点
会将数据量比较小并且时间间隔比较短的数据整合到一起发送
并且还会受制于recv括号内的数字大小(核心问题!!!)
流式协议:跟水流一样不间断
黏包现象只发生在tcp协议中
1.从表面上看，黏包问题主要是因为发送方和接收方的缓存机制、tcp协议面向流通信的特点
2.实际上，主要还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的
粘包是接收长度没对上导致的
控制recv接收的字节数与之对应(你发多少字节我收多少字节)
在很多情况下并不知道数据的长度，服务端不能写死
"""
问题产生的原因其实是因为recv括号内我们不知道即将要接收的数据到底多大
如果每次接收的数据我们都能够精确的知道它的大小 那么肯定不会出现黏包
"""
思路一如果在不知道数据有多长的情况下就会出现意外，那么我们可以先传一个固定长度的数据过去告诉他
真实数据有多长，就可以对应着收了
struct模块
该模块可以把一个类型，如数字，转成固定长度的bytes
这里利用struct模块模块的struct.pack() struct.unpack() 方法来实现打包(将真实数据长度变
为固定长度的数字)解包(将该数字解压出打包前真实数据的长度)
pack unpack模式参数对照表(standard size 转换后的长度)
i 模式的范围：-2147483648 <= number <= 2147483647
在传真实数据之前还想要传一些描述性信息
如果在传输数据之前还想要传一些描述性信息，那么就得在中间再加一步了(传个电影，我告诉你电影名，
大小，大致情节，演员等信息，你再选择要不要),前面的方法就不适用了
粘包问题解决思路
服务器端
先制作一个发送给客户端的字典
制作字典的报头
发送字典的报头
发送字典
再发真实数据
客户端
先接收字典的报头
解析拿到字典的数据长度
接收字典
从字典中获取真实数据的长度
循环获取真实数据
ps:为什么要多加一个字典
pack打包的数据长度(的长度)有限，字典再打包会很小(长度值也会变很小)(120左右)
可以携带更多的描述信息
模板
服务端
import socket
from socket import SOL_SOCKET, SO_REUSEADDR
import os
import json
import struct
server = socket.socket() # 创建一个socket对象（server）
# -------------------------------------
# 加上他就可以防止重启报错了(注意位置)
# -------------------------------------
server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
server.bind(('127.0.0.1', 9000)) # 给socket对象（server）绑定ip和端口号（以元组的形式）
server.listen(5) # 设置半连接池,最低为0
sock, addr = server.accept() # 接收客户端连接，获得sock连接 和 addr客户端地址。
# 1.先制作一个字典(可以放入一些描述性的信息)
data_dict = {
'file_name': '11.jpg',
'file_title': '壁纸',
'file_size': os.path.getsize(r'D:\pythonproject\test\11.jpg') # 可以改为自己的文件地址
}
# 2.制作字典报头
data_dict_json_str = json.dumps(data_dict) # 转化成字符串
data_dict_json_str_bytes = data_dict_json_str.encode('utf8') # 将字符串编码
data_dict_package = struct.pack('i', len(data_dict_json_str_bytes)) # 以i模式打包,打包成4个字节
# 3.发送报头
sock.send(data_dict_package) # 服务端将字典发送给客户端
# 4.发送字典
sock.send(data_dict_json_str_bytes)
# 5.发送真实数据
with open(r'D:\pythonproject\test\11.jpg', 'rb') as f:
for i in f:
sock.send(i)
print('发送完成')
客户端
import socket
import struct
import json
client = socket.socket() # 创建一个socket对象（client）
client.connect(('127.0.0.1', 9000)) # 根据ip和端口连接服务端（元组的形式）,主动发起连接
# 1.先接收字典的报头
data_dict_package = client.recv(4)
# 2.解析拿到字典的数据长度
data_dict_len = struct.unpack('i', data_dict_package)[0]
# 3.接收字典数据
data_dict = client.recv(data_dict_len)
data_dict = data_dict.decode('utf8')
data = json.loads(data_dict)
# 4.循环接收文件数据 不要一次性接收
recv_size = 0
with open('12.jpg', 'wb') as f:
while recv_size < data.get('file_size'):
write_data = client.recv(1024)
recv_size += len(write_data)
f.write(write_data)
今日作业
项目下载
可以实现上传文件（上传到项目的shipin文件中，可以更改）和下载文件（默认下载在桌面，下载时会从项目的shipin文件中进行下载）
编写一个cs架构的软件
就两个功能
一个视频下载:从服务端下载视频
一个视频上传:从客户端上传视频
服务端
import socket
import json
import os
import sys
import struct
from socket import SOL_SOCKET, SO_REUSEADDR
sys.path.append(os.path.dirname(__file__))
shipin_path = os.path.join(os.path.dirname(__file__), 'shipin')
if not os.path.exists(shipin_path):
os.makedirs(shipin_path)
server = socket.socket()
server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
server.bind(('127.0.0.1', 8001))
server.listen(5)
while True:
sock, addr = server.accept()
while True:
try:
print('连接成功')
msg = sock.recv(1024)
msg = msg.decode('utf8')
msg1, name = msg.split(' ')
if msg1 == '下载':
if name not in os.listdir(shipin_path): sock.send('文件不存在'.encode('utf8'))
data_dict = {
'file_name': name,
'file_size': os.path.getsize(os.path.join(shipin_path, name))
}
data_dict_json = json.dumps(data_dict)
data_dict_json_bytes = data_dict_json.encode('utf8')
data_dict_json_bytes_package = struct.pack('i', len(data_dict_json_bytes))
sock.send(data_dict_json_bytes_package)
sock.send(data_dict_json_bytes)
with open(os.path.join(shipin_path, name), 'rb') as f:
for i in f:
sock.send(i)
print('发送完成')
else:
print('上传')
data_dict_package = sock.recv(4)
data_dict_len = struct.unpack('i', data_dict_package)[0]
data_dict = sock.recv(data_dict_len)
data = json.loads(data_dict)
recv_size = 0
with open(os.path.join(shipin_path, data.get('file_name')), 'wb') as f:
while recv_size < data.get('file_size'):
write_data = sock.recv(1024)
recv_size += len(write_data)
f.write(write_data)
print('上传完成')
except ConnectionRefusedError:
print('操作失败')
客户端
import socket
import json
import os
import struct
client = socket.socket()
client.connect(('127.0.0.1', 8001))
while True:
msg = input('''格式：上传/下载 文件名（下载 文件名 指定地址(默认桌面)）
(上传 地址（绝对地址）))''').strip()
if msg.split(' ')[0] == '下载':
client.send(msg.encode('utf8'))
data_dict_package = client.recv(4)
data_dict_len = struct.unpack('i', data_dict_package)[0]
data_dict = client.recv(data_dict_len)
data = json.loads(data_dict)
recv_size = 0
if msg.split(' ') == 3:
addr = msg.split(' ')[-1]
else:
addr = os.path.join(os.path.expanduser('~'),"Desktop") # 动态获取当前电脑桌面路径
print(addr)
with open(os.path.join(addr,data.get('file_name')), 'wb') as f:
while recv_size < data.get('file_size'):
write_data = client.recv(1024)
recv_size += len(write_data)
f.write(write_data)
print('下载完成')
elif msg.split(' ')[0] == '上传':
client.send(msg.encode('utf8'))
path = msg.split(' ')[1]
name = path.split(os.sep)[-1]
print(path,name,sep=' ')
data_dict = {
'file_name': name,
'file_size': os.path.getsize(path)
}
data_dict_json = json.dumps(data_dict)
data_dict_json_bytes = data_dict_json.encode('utf8')
data_dict_json_bytes_package = struct.pack('i', len(data_dict_json_bytes))
client.send(data_dict_json_bytes_package)
client.send(data_dict_json_bytes)
with open(path, 'rb') as f:
for i in f:
client.send(i)
print('上传成功')
标签：socket,sock,server,dict,接字,data,客户端 来源： https://www.cnblogs.com/chunyouqudongwuyuan/p/16150690.html