02_套接字编程(socket抽象层)
1.套接字概述
1.套接概述: 套接是进行网络通信的一种手段(socket)
2.套接字分类:
流式套接字(SOCK_STREAM): 传输层基于tcp协议进行通信
数据报套接字(SOCK_DEGAM): 传输层基于udp协议进行通信
原始套接字(SOCK_RAW): 访问底层协议的套接字
3.TCP与UDP通讯模型流程图: https://www.processon.com/view/link/5ef43bfd1e0853263742690b
4.套接字属性和方法
import socket s = socket.socket() # 默认会创建流式套接字 # 功能: 获取套接字的描述符
# 描述符: 每一个IO操作系统都会分配一个不同的整数与之对应,该整数极为此IO操作的描述符
s.fileno() #
print(s.fileon()) # # 获取套接字类型
s.type # <SocketKind.SOCK_STREAM: 1>
print(s.type) # SocketKind.SOCK_STREAM # 获取套接字绑定的地址
s.getsockname() # ('0.0.0.0', 0)
s.bind(("127.0.0.1", 7890))
print(s.getsockname()) # ('127.0.0.1', 7890) # 使用accept生成的套接字调用,获取该套接字对应的客户端的地址,在一个服务器有多个客户端连接时常会用到这个方法
s.listen(128)
conn, addr = s.accept() # 阻塞时需要找一个用户连接
conn.getpeername() # ('127.0.0.1', 53519)
print(conn.getpeername()) # ('127.0.0.1', 53519) # s.setsockopt(level, optname, value) 设置套接字选项
# 参数 level: 定义的选项类型,常用选项(IPPROTO_TCP,IPPROTO_IP,SOL_SOCKET)
# 参数 optname: 根据level选项确定的子选项
# 参数 value: 根据子选项设置的值
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) # 设置端口重用
s.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1) # 设置套接字允许接收广播 # s.getsockopt(level, optname) 获取套接字选项
# 参数 level: 定义的选项类型,常用选项(IPPROTO_TCP,IPPROTO_IP,SOL_SOCKET)
# 参数 optname: 根据level选项确定的子选项
# 返回值: 返回根据子选项设置的值
s.getsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR) # # 面向锁的套接字方法
s.setblocking() # 设置套接字阻塞与非阻塞模式,参数默认为True表示阻塞
s.settimeout() # 设置阻塞套接字操作的超时时间
s.gettimeout() # 获取阻塞套接字操作的超时时间 # 面向文件的套接字函数
s.fileno() # 套接字的文件描述符
s.makefile() # 创建一个与该套接字相关的文件
2.TCP流式套接字
1.TCP服务端流程
1.创建套接字
sockfd = socket(socket_family=AF_INET, socket_type=SOCK_STERAM, proto=0) # 创建套接字并返回套接字对象
参数:
socket_family: 选择地址族种类AF_INET(UNIX)
socket_type: 套接字类型 流式(SOCK_STREAM),数据报(SOCK_DGRAM)
proto: 子协议类型,tcp和udp都没有用到自协议因此默认为0
2.绑定IP和端口号
sockfd.bind(("", 7890)) # 绑定IP和端口号
参数: 类型为元组('127.0.0.1', 7890) # 第一项是字符串形式的IP,第二项是端口号
3.让套接字具有监听功能
sockfd.listen(n) # 使套接字变为监听套接字,同时创建监听队列
参数: n监听队列大小,一般设置为128
4.等待客户端连接
new_socket, client_addr = socket.accept() # 阻塞等待客户端连接
返回值: 类型为元祖(new_socket, client_addr)
第一项: 返回一个新的套接字用来和客户端通信
第二项: 返回连接的客户端的地址
5.消息的收发
接收: new_socket.recv(buffer) # 接收消息
参数: 一次接收消息的大小, 即一次收多少字节
返回值: 接收到的内容, 类型为字节
发送: new_socket.send(data) # 发送消息,当没有接收端的时候send操作会导致管道破裂(broken pipe)
参数: 发送的内容(bytes), 类型为字节
返回值: 发送了多少个字节
6.关闭套接字
new_socket.close() # 关闭为客户端服务的套接字
sockfd.close() # 关闭监听套接字
2.TCP客户端流程
1.创建流式套接字: sockfd = socket(socket_family=AF_INET, socket_type=SOCK_STREAM, proto=0)
2.发起连接请求
sockfd.connect(('127.0.0.1', 7890)) # 发起连接请求
参数(元组): 第一项是服务器的IP,第二项是服务器的PORT
3.收发消息: sockfd.recv() sockfd.send()
4.关闭套接字: sockfd.close()
3.TCP服务端-通讯示例
import socket def main():
# 创建数据流套接字
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 设置端口重用
tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 绑定端口
tcp_server_socket.bind(("", 7890))
# 让默认的套接字由主动变为被动监听 listen
tcp_server_socket.listen(128) # 循环目的: 多次调用accept等待客户端连接,为多个客服端服务
while True:
print("等待一个新的客户端的到来...")
new_client_socket, client_addr = tcp_server_socket.accept()
print("客户端' %s '已经到来" % str(client_addr))
# 循环目的: 为同一个客服端服务多次
while True:
# 接收客户端发送过来的请求
recv_data = new_client_socket.recv(1024) # recv解堵塞的两种方式: 1.客户端发送过来数据,2.客户端调用了close
if recv_data:
print("客户端' %s '发送过来的请求是: %s" % (str(client_addr), recv_data.decode("utf-8")))
# 回送数据给客户端表示响应客户端的请求
send_data = "----ok----Request accepted"
new_client_socket.send(send_data.encode("utf-8"))
else:
break # 关闭accept返回的套接字
new_client_socket.close()
print("已经为 %s 客户端已经服务完毕" % str(client_addr))
# 关闭监听套接字
tcp_server_socket.close() if __name__ == "__main__":
main()
4.TCP客户端-通讯示例
import socket def main():
# 创建数据流套接字
tcp_client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 连接服务器
server_ip = input("请输入要连接的服务器的ip:")
serve_port = int(input("请输入要连接的服务器的port:"))
server_addr = (server_ip, serve_port)
tcp_client_socket.connect(server_addr) # 连接失败会报错
# s = tcp_client_socket.connect_ex(server_addr) # 有返回值,如果连接失败不会报错,会返回错误的编码
# 发送数据
send_data = input("请输入要发生的数据:")
tcp_client_socket.send(send_data.encode("utf-8"))
# 接收服务器发送过来的数据
recv_data = tcp_client_socket.recv(1024)
print("接收到的数据为:%s" % recv_data.decode("utf-8"))
# 关闭套接字
tcp_client_socket.close() if __name__ == "__main__":
main()
5.TCP服务端-文件下载示例
import socket def send_file_client(nwe_client_socket, client_addr):
# 1.接收客户端发送过来的需要下载的文件名
file_name = nwe_client_socket.recv(1024).decode("utf-8")
print("客户端 %s 要下载的文件是:%s" % (str(client_addr), file_name))
# 2.打开文件读取数据
file_content = None
try:
f = open(file_name, "rb")
file_content = f.read()
f.close()
except Exception as ret:
print("没有要下载的文件%s" % file_name)
# 3.发送文件的数据给客户端
if file_content:
nwe_client_socket.send(file_content) def main():
# 创建套接字
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 设置端口重用
tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 绑定本地信息
local_addr = ("", 7890)
tcp_server_socket.bind(local_addr)
# 开启监听
tcp_server_socket.listen(128)
while True:
# 等待用户连接
nwe_client_socket, client_addr = tcp_server_socket.accept()
# 调用发送文件函数,完成为客户端服务
send_file_client(nwe_client_socket, client_addr) # 关闭套接字
nwe_client_socket.close()
# 关闭监听套接字
tcp_server_socket.close() if __name__ == "__main__":
main()
6.TCP客户端-文件下载示例
import socket def main():
# 创建套接字
tcp_client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 连接服务器
dest_ip = input("请输入下载服务器的ip:")
dest_port = int(input("请输入下载服务器的port:"))
dest_addr = (dest_ip, dest_port)
tcp_client_socket.connect(dest_addr)
# 获取要下载的文件名
download_file_name = input("请输入要下载的文件名:")
# 发送要下载的文件名
tcp_client_socket.send(download_file_name.encode("utf-8"))
# 接收文件数据
recv_data = tcp_client_socket.recv(1024) # 一次接收1k数据
# 打开文件写入数据
if recv_data:
with open("[new]" + download_file_name, "wb") as f:
f.write(recv_data)
# 关闭套接字
tcp_client_socket.close() if __name__ == "__main__":
main()
7.TCP粘包现象
1.发送接收缓冲区
发送和接收消息均放到缓存区再进行处理
当recv接收消息一次接收不完的时候下次会继续接收,当recv阻塞时,如果客户端断开则recv立即返回空字符串
2.TCP粘包概述:
1.TCP中数据以数据流的方式发送接收,每次发送的数据间没有边界,在接收时可能造成数据的粘连即为粘包
2.合包机制造成数据混乱: nagle算法将多次连续发送且间隔较小的数据进行打包成一个数据传输
3.拆包机制造成数据混乱: 在发送端因为受到数据链路层网卡的MTU限制,会将大的超过MTU限制的数据进行拆分成多个小的数据包进行传输
当传输到目标主机的操作系统层时,会将多个小的数据包合并成原本的数据包
3.粘包如何处理方案:
1.每次发送消息和结束位置加标志,每次收到消息按结束标准切割
2.发送的消息添加结构描述,例如加一个包头,包头里记录 name:大小, password: 大小
3.当连续发送的时每次发送有一个短暂延迟sleep(0.1)
4.tcp粘包参考链接: https://www.cnblogs.com/LY-C/p/9120992.html
8.TCP服务端-粘包现象验证
import socket def main():
# 创建数据流套接字
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 绑定端口
tcp_server_socket.bind(("", 7890))
# 让默认的套接字由主动变为被动监听 listen
tcp_server_socket.listen(128)
# 等待客户端连接
new_client_socket, client_addr = tcp_server_socket.accept()
print("客户%s端已连接" % str(client_addr)) # 循环目的: 为同一个客服端服务多次
while True:
# 接收客户端发送过来的请求
recv_data = new_client_socket.recv(1024)
# recv解堵塞的两种方式: 1.客户端发送过来数据,2.客户端调用了close
if not recv_data:
break # 客户端是先遍历["Coco", "1355656****", "Coco@xxx.com", "xx省xx市xx区xxx"]列表,再分了4次发送用户信息的数据
# 但是此时服务端收到的数据却是连续的: Coco1355656****Coco@xxx.comxx省xx市xx区xxx
print("客户端' %s '发送过来的请求是: %s" % (str(client_addr), recv_data.decode("utf-8")))
# 回送数据给客户端表示响应客户端的请求
send_data = "----ok----Request accepted"
new_client_socket.send(send_data.encode("utf-8")) # 关闭accept返回的套接字
new_client_socket.close()
print("已经为 %s 客户端已经服务完毕" % str(client_addr))
# 关闭监听套接字
tcp_server_socket.close() if __name__ == "__main__":
main()
9.TCP客户端-粘包现象验证
import socket
import time def main():
# 创建数据流套接字
tcp_client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 连接服务器
server_addr = ("", 7890)
tcp_client_socket.connect(server_addr)
# 发送数据
user_info = ["Coco", "1355656****", "Coco@xxx.com", "xx省xx市xx区xxx"]
for i in user_info:
tcp_client_socket.send(str(i).encode("utf-8"))
# 发送时添加延时可以解决粘包现象
# time.sleep(0.1)
# 接收服务器发送过来的数据
recv_data = tcp_client_socket.recv(1024)
print("接收到的数据为:%s" % recv_data.decode("utf-8"))
# 关闭套接字
tcp_client_socket.close() if __name__ == "__main__":
main()
10.TCP服务端-大文件上传
import socket
import json
import struct def main():
# 创建数据流套接字
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 设置端口重用
tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 绑定端口
tcp_server_socket.bind(("", 7890))
# 让默认的套接字由主动变为被动监听 listen
tcp_server_socket.listen(128) # 循环目的: 多次调用accept等待客户端连接,为多个客服端服务
while True:
print("等待一个新的客户端的到来...")
new_client_socket, client_addr = tcp_server_socket.accept()
print("客户端' %s '已经到来" % str(client_addr)) # 接收客户端发送过来的请求
b_len_dic = new_client_socket.recv(4) print(b_len_dic)
len_dic = struct.unpack("i", b_len_dic)[0] # unpack得到一个元祖,取下标0的位置获取到int类型的字典长度
recv_data = new_client_socket.recv(len_dic).decode("utf-8") # new_client_socket.send(b"OK") # 向客户端发送文件准备就绪标识,同时也避免接收数据过快产生粘包 recv_dic = json.loads(recv_data)
if recv_dic["opt"] == "upload":
filename = "副本" + recv_dic["filename"]
with open(filename, "ab") as f:
while recv_dic["filesize"]:
content = new_client_socket.recv(1024)
f.write(content)
recv_dic["filesize"] -= len(content)
elif recv_dic["opt"] == "download":
pass # 关闭accept返回的套接字
new_client_socket.close()
print("已经为 %s 客户端已经服务完毕" % str(client_addr))
# 关闭监听套接字
tcp_server_socket.close() if __name__ == "__main__":
main()
11.TCP客户端-大文件上传
import socket
import os
import json
import struct def main():
# 创建数据流套接字
tcp_client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 连接服务器
server_ip = input("请输入要连接的服务器的ip:")
serve_port = int(input("请输入要连接的服务器的port:"))
server_addr = (server_ip, serve_port)
tcp_client_socket.connect(server_addr) # 连接失败会报错
# s = tcp_client_socket.connect_ex(server_addr) # 有返回值,如果连接失败不会报错,会返回错误的编码 menu = {"": "upload", "": "download"}
for i in menu:
print(i, menu[i])
num = input("请输入功能选项: ")
if num == "":
send_dic = {"opt": menu.get(num), "filename": None, "filesize": None}
file_path = input("请输入一个绝对路径: ") # 要上传文件的绝对路径
filename = os.path.basename(file_path) # 获取要上传文件的文件名
filesize = os.path.getsize(file_path) # 获取文件大小 send_dic["filename"] = filename
send_dic["filesize"] = filesize
send_data = json.dumps(send_dic) len_dic = len(send_data) # 获取字典长度,是一个int数据类型,可能是30,也可能是120
b_len_dic = struct.pack("i", len_dic) # 加字典长度打包成一个4位的bytes类型
# 将bytes类型的字典长度 + bytes类型的字典内容,一起发送给服务器
tcp_client_socket.send(b_len_dic + send_data.encode("utf-8")) # tcp_client_socket.recv(1024) # 1.向服务器确认是否可以上传文件;2.避免与下列代码的send过快造成粘包 with open(file_path, "rb") as f:
while filesize:
content = f.read(1024)
tcp_client_socket.send(content)
filesize -= len(content) # 发送数据
tcp_client_socket.send(send_data.encode("utf-8"))
elif num == "":
pass # 关闭套接字
tcp_client_socket.close() if __name__ == "__main__":
main()
12.TCP服务端-身份加密验证
import socket
import os
import hmac def main():
# 创建数据流套接字
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 设置端口重用
tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 绑定端口
tcp_server_socket.bind(("", 7890))
# 让默认的套接字由主动变为被动监听 listen
tcp_server_socket.listen(128) # 循环目的: 多次调用accept等待客户端连接,为多个客服端服务
while True:
print("等待一个新的客户端的到来...")
new_client_socket, client_addr = tcp_server_socket.accept()
print("客户端' %s '已经到来" % str(client_addr)) sor = b"hmy" # 服务器加盐
r_str = os.urandom(16) # 随机一个16位长度的bytes类型数据
new_client_socket.send(r_str) # md5加密
md5_obj = hmac.new(sor, r_str)
result = md5_obj.digest() # 接收客户端发送过来的密文与服务器的密文对比
recv_msg = new_client_socket.recv(1024)
if recv_msg == result:
new_client_socket.send(b"success")
else:
new_client_socket.send(b"failed") # 关闭accept返回的套接字
new_client_socket.close()
print("已经为 %s 客户端已经服务完毕" % str(client_addr))
# 关闭监听套接字
tcp_server_socket.close() if __name__ == "__main__":
main()
13.TCP客户端-身份加密验证
import socket
import hmac def main():
# 创建数据流套接字
tcp_client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 连接服务器
server_ip = input("请输入要连接的服务器的ip:")
serve_port = int(input("请输入要连接的服务器的port:"))
server_addr = (server_ip, serve_port)
tcp_client_socket.connect(server_addr) # 连接失败会报错
# s = tcp_client_socket.connect_ex(server_addr) # 有返回值,如果连接失败不会报错,会返回错误的编码 sor = b"hmy" # 客户端加盐
r_str = tcp_client_socket.recv(1024) # md5加密
md5_obj = hmac.new(sor, r_str)
result = md5_obj.digest()
# 向服务器发送验证密文
tcp_client_socket.send(result) # 接收验证结果
recv_msg = tcp_client_socket.recv(1024)
print(recv_msg) # 关闭套接字
tcp_client_socket.close() if __name__ == "__main__":
main()
14.TCP服务端-切换目录
import socket
import os def send_data(new_client_socket, path):
"""你给我一个目录,我把目录发给client"""
lis_dir = os.listdir(path)
str_dir = '--'.join(lis_dir)
new_client_socket.send(str_dir.encode('utf-8')) def main():
# 创建数据流套接字
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 设置端口重用
tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 绑定端口
tcp_server_socket.bind(("", 7890))
# 让默认的套接字由主动变为被动监听 listen
tcp_server_socket.listen(128) # 循环目的: 多次调用accept等待客户端连接,为多个客服端服务
while True:
print("等待一个新的客户端的到来...")
new_client_socket, client_addr = tcp_server_socket.accept()
print("客户端' %s '已经到来" % str(client_addr)) abs_path = new_client_socket.recv(1024).decode('utf-8') # 获取用户输入的绝对路径
current_dir = abs_path + '/' # 以下再处理,都要根据当前路径去处理,无论是返回上一层,还是进入下一层
send_data(new_client_socket, current_dir) # 把用户输入的路径下的所有文件及文件夹返回给客户端 while True:
# 测试输入: /Users/tangxuecheng
cmd = new_client_socket.recv(1024).decode('utf-8')
if cmd == '..':
current_dir = current_dir.split('/')[:-2]
current_dir = '/'.join(current_dir) + '/'
# if 如果当前是根目录:
# 就返回给客户端告诉说没有上一层了
send_data(new_client_socket, current_dir)
else:
filename = cmd.split(' ')[1] # 获取用户输入的文件名字
current_dir += filename + '/' # 将文件名字添加到当前路径下,组成一个完整的新路径
if os.path.isdir(current_dir): # 如果客户输入的文件名字是一个文件夹
send_data(new_client_socket, current_dir)
else: # 如果不是一个文件夹
new_client_socket.send(b'not a folder') # 关闭accept返回的套接字
new_client_socket.close()
print("已经为 %s 客户端已经服务完毕" % str(client_addr))
# 关闭监听套接字
tcp_server_socket.close() if __name__ == "__main__":
main()
15.TCP客户端-切换目录
import socket def main():
# 创建数据流套接字
tcp_client_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 连接服务器
server_ip = input("请输入要连接的服务器的ip:")
serve_port = int(input("请输入要连接的服务器的port:"))
server_addr = (server_ip, serve_port)
tcp_client_socket.connect(server_addr) # 连接失败会报错
# s = tcp_client_socket.connect_ex(server_addr) # 有返回值,如果连接失败不会报错,会返回错误的编码 # 测试输入: /Users/tangxuecheng
abs_path = input('请输入您的根目录:')
tcp_client_socket.send(abs_path.encode('utf-8'))
current_dir = tcp_client_socket.recv(1024).decode('utf-8')
print(current_dir.split('--')) while True:
cmd = input('请输入>>>')
# cd + 文件夹 ..
if cmd == '..':
tcp_client_socket.send(cmd.encode('utf-8'))
current_dir = tcp_client_socket.recv(1024).decode('utf-8')
print(current_dir.split('--'))
if cmd == 'cd':
filename = input('请输入一个文件夹名：')
tcp_client_socket.send((cmd + ' ' + filename).encode('utf-8'))
current_dir = tcp_client_socket.recv(1024).decode('utf-8')
print(current_dir.split('--')) # 关闭套接字
tcp_client_socket.close() if __name__ == "__main__":
main()
16.TCP应用-web静态服务器
# html文件夹网盘链接: https://pan.baidu.com/s/1wbZ92KLstff3GurLV_C0lg 密码: hp9o
# 下载完命令行解压后放到程序的同级路径下,解压命令: tar -zxvf 06_html.tar.gz -C ./
import socket def client_handle(client_socket):
# 接收客户端发送过来的请求数据
request = client_socket.recv(2048)
request_handles = request.splitlines()
for line in request_handles:
print(line)
try:
f = open("./html/index.html", "r")
except IOError:
# 找不到文件时返回404错误
response = "HTTP/1.1 404 not found\r\n"
response += "\r\n"
response += "sorry file not found"
else:
# 找到文件时读取文件内容
response = "HTTP/1.1 200 OK\r\n"
response += "\r\n"
for line in f:
response += line
finally:
# 向浏览器返回信息
client_socket.send(response.encode())
# 关闭客户端套接字
client_socket.close() def main():
# 1.创建套接字
tcp_server_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
# 2.设置端口重用
tcp_server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 4.允许局域网内用户访问
local_addr = ("0.0.0.0", 7890)
tcp_server_socket.bind(local_addr)
# 5.监听
tcp_server_socket.listen(128)
# 5.循环服务
while True:
# 客户端连接
client_socket, client_addr = tcp_server_socket.accept()
# 为客户端服务
client_handle(client_socket) # 6.关闭监听套接字
tcp_server_socket.close() if __name__ == "__main__":
main()
3.UDP数据报套接字
1.UDP套接字使用流程
1.创建数据报套接字
sockfd = socket(AF_INET,SOCK_DGRAM)
参数: AF_INET表示ipv4,SOCK_DGRAM表示数据报套接字
2.绑定服务端地址: sockfd.bind("127.0.0.1", 7890)
3.收发消息
接收消息(recvfrom)
data, addr = sockfd.recvfrom(buffersize) # 一次接收一个数据包,如果是数据包一次没有接收完则会丢失没有接收的内容
参数: 每次最多接收消息的大小(字节)
返回值:
data: 接收到的消息
addr: 消息发送者的地址
发送消息(sendto)
sockfd.sendto(data, addr) # 发送消息
参数:
data:要发送的消息
addr: 发送给某个主机的地址
返回值: 发送消息的字节数
4.关闭套接字: sockfd.close()
2.UDP应用-发送消息
import socket def main():
# 创建一个udp套接字
udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# 指定接消息收方的地址
dest_addr = ("", 7788) while True:
# 从键盘上获取数据
send_data = input("请输入要发送的数据:")
# 如果输入的数据是exit则退出程序
if send_data.lower() == "exit":
break
# 使用套接字收发数据
# udp_socket.sendto(b"hello world!", ("169.254.119.158", 8080))
udp_socket.sendto(send_data.encode("utf-8"), dest_addr) # 关闭套接字
udp_socket.close() if __name__ == "__main__":
main()
3.UDP应用-接收消息
import socket def main():
# 1.创建套接字
udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# 2.绑定本地信息
local_addr = ("", 7788)
udp_socket.bind(local_addr)
# 3.接收数据
while True:
recv_data = udp_socket.recvfrom(1024) # 1024表示本次接收的最大字节数
# 4.打印接收的数据
# recv_data这个变量中存储的是一个元祖(接收到的数据, (发送方的ip, port))
recv_msg = recv_data[0] # 第1个元素是对方发送的数据,类型为字节
recv_addr = recv_data[1] # 第2个元素是对方的ip和端口,类型为元祖
print(type(recv_msg), type(recv_addr)) # <class 'bytes'> <class 'tuple'> # 功能扩展: 含有敏感词汇消息在输出时进行颜色标识
color_dic = {"用户名": "\033[32m", "密码": "\033[33m", "验证": "\033[0;32;40m"}
msg = recv_msg.decode("utf-8")
for i in color_dic:
if i in msg:
color = color_dic[i]
print("%s%s:%s\033[0m" % (color, str(recv_addr), msg))
break
else:
print("%s:%s" % (str(recv_addr), msg)) # ('127.0.0.1', 61804):Tom你好吗?
# 5.关闭套接字
udp_socket.close() if __name__ == "__main__":
main()
4.UDP应用-实现广播的设置
1.将广播接收端套和发送端的接字属性设置为允许接收广播
2.将广播发送端的地址设置为发送给局域网所有终端: ("192.168.0.255", 7890) 或 ("", 7890)
3.广播风暴: 在一个网络中大量发送广播会占用大量带宽,解决方案是组播
5.UDP应用-广播接收端
# broadcast_recv.py
import socket def main():
# 1.创建套接字
udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# 2.设置套接字允许接收广播
udp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
# 3.设置端口重用
udp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# 4.固定接收端的端口号
local_addr = ("", 7890)
udp_socket.bind(local_addr)
# 5.接收数据
while True:
try:
recv_msg, recv_addr = udp_socket.recvfrom(1024) # 1024表示本次接收的最大字节数
# 6.打印接收的数据
# print(type(recv_msg), type(recv_addr)) # <class 'bytes'> <class 'tuple'>
print("从广播{}获取消息: {}".format(str(recv_addr), recv_msg.decode("utf-8"))) # 7.回送消息
udp_socket.sendto(b"ok", recv_addr)
except (KeyboardInterrupt, SyntaxError): # control + c 终止程序或者语法错误时捕获异常
raise
except Exception as e:
print(e) # 8.关闭套接字
udp_socket.close() if __name__ == "__main__":
main()
6.UDP应用-广播发送端
# broadcast_send.py
import socket
import time def main():
# 1.创建一个udp套接字
udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# 2.设置套接字允许接收广播
udp_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
# 3.设置发送广播的地址
# dest_addr = ("192.168.0.255", 7890) # 这种写法也可以
dest_addr = ("<broadcast>", 7890) # 将消息发送给局域网所有终端 while True:
time.sleep(1) # 每隔1秒发送一次广播
# 使用套接字收发数据
udp_socket.sendto("开始广播了...".encode("utf-8"), dest_addr)
recv_msg, recv_addr = udp_socket.recvfrom(1024) # 1024表示本次接收的最大字节数
print("从接收端{}获取消息: {}".format(str(recv_addr), recv_msg.decode("utf-8"))) # 关闭套接字
udp_socket.close() if __name__ == "__main__":
main()
7.函数实现-UDP聊天器
import socket def send_msg(udp_socket):
"""获取键盘数据,并将其发送给对方"""
# 1. 从键盘输入数据
msg = input("\n请输入要发送的数据:")
# 2. 输入对方的ip地址
dest_ip = input("\n请输入对方的ip地址:")
# 3. 输入对方的port
dest_port = int(input("\n请输入对方的port:"))
# 4. 发送数据
udp_socket.sendto(msg.encode("utf-8"), (dest_ip, dest_port)) def recv_msg(udp_socket):
"""接收数据并显示"""
# 1. 接收数据
recv_msg = udp_socket.recvfrom(1024)
# recv_msg, recv_ip = udp_socket.recvfrom(1024)
# 2. 解码
recv_ip = recv_msg[1]
recv_msg = recv_msg[0].decode("utf-8")
# 3. 显示接收到的数据
print(">>>%s:%s" % (str(recv_ip), recv_msg)) def main():
# 1. 创建套接字
udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# 2. 绑定本地信息
udp_socket.bind(("", 7788))
while True:
# 3. 选择功能
print("="*30)
print("1:发送消息")
print("2:接收消息")
print("0:退出系统")
print("="*30)
op_num = input("请输入要操作的功能序号:") # 4. 根据选择调用相应的函数
if op_num == "":
send_msg(udp_socket)
elif op_num == "":
recv_msg(udp_socket)
elif op_num == "":
break
else:
print("输入有误,请重新输入...")
# 5.关闭套接字
udp_socket.close() if __name__ == "__main__":
main()
8.对象实现-UDP聊天器
import socket
class UdpSocket:
def __init__(self):
# 1. 创建套接字
self.udp_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# 2. 绑定本地信息
self.udp_socket.bind(("", 7788))
# 发送消息
def send_msg(self):
"""获取键盘数据,并将其发送给对方"""
# 1. 从键盘输入数据
msg = input("\n请输入要发送的数据:")
# 2. 输入对方的ip地址
dest_ip = input("\n请输入对方的ip地址:")
# 3. 输入对方的port
dest_port = int(input("\n请输入对方的port:"))
# 4. 发送数据
self.udp_socket.sendto(msg.encode("utf-8"), (dest_ip, dest_port))
# 接收消息
def recv_msg(self):
"""接收数据并显示"""
# 1. 接收数据
recv_msg = self.udp_socket.recvfrom(1024)
# recv_msg, recv_ip = self.udp_socket.recvfrom(1024)
# 2. 解码
recv_ip = recv_msg[1]
recv_msg = recv_msg[0].decode("utf-8")
# 3. 显示接收到的数据
print(">>>%s:%s" % (str(recv_ip), recv_msg))
# 功能选择
def start_menu(self):
while True:
print("="*30)
print("1:发送消息")
print("2:接收消息")
print("0:退出系统")
print("="*30)
op_num = input("请输入要操作的功能序号:")
# 4. 根据选择调用相应的函数
if op_num == "":
self.send_msg()
elif op_num == "":
self.recv_msg()
elif op_num == "":
break
else:
print("输入有误,请重新输入...")
# 关闭套接字
def __del__(self):
print("%s对象已回收" % self)
self.udp_socket.close()
def main():
# 实例化一个udp聊天器对象
udp_chat = UdpSocket()
# 启动聊天器
udp_chat.start_menu()
if __name__ == "__main__":
main()
9.自定义socket类
import socket class MySocket(socket.socket):
"""自定义MySocket类继承自socket模块中的socket""" def __init__(self, encoding="utf-8"):
# 调用父类中的初始化方法
super().__init__(type=socket.SOCK_DGRAM)
# 自定义默认的编码格式
self.encoding = encoding def my_sendto(self, send_msg, send_addr):
return self.sendto(send_msg.encode(self.encoding), send_addr) def my_recvfrom(self, num):
recv_msg, recv_addr = self.recvfrom(num)
return recv_msg.decode(self.encoding), recv_addr
10.UDP收发数据包
1.UDP不会发生粘包现象
2.UDP收发数据包大小取舍
udp协议本身对一次收发消息数据大小限制是: 65535 - ip包头(20) - udp包头(8) = 65507
在数据链路层网卡的MTU一般为1500的限制,所以在链路层收发数据包大小限制为: 1500 - ip包头(20) - udp包头(8) = 1472
3.UDP收发数据包大小结论
接收数据包: recvfrom(num) # num < 65507
发送数据包: sendto(num)
num > 65507 # 报错
1472 < num < 65507 # 在数据链路层拆包发送,然而udp本身就是不可靠协议
# 所以一旦拆包后,造成的多个小数据包在网络传输中,如果丢失任意一个,那么此次数据传输失败
num < 1472 # 是比较理想的状态
4.本地套接字
1.Linux下常用文件辨识(ls -lh 第一个用来辨识文件类型)
d: 文件夹
-: 普通文件
l: 链接文件
s: 套接字文件,是一个虚拟文件且大小在显示上永远为0,存在的意义是在Linux/Unix下提供本地进程间通信的一种方式
p: 管道文件
2.UNIX本地套接字使用流程
服务端流程
1.创建本地套接字: unix_socket = socket(AF_UNIX, SOCK_STREAM)
2.绑定套接字文件: unix_socket.bind("./unix_socket_test")
3.监听: unix_socket.listen(128)
4.等待客户端连接: new_client_socket, client_addr = unix_socket.accept()
4.接收连接: recv_data = unix_socket.recv(1024)
5.收发消息: new_client_socket.send()
6.关闭客户端套接字: new_client_socket.close()
8.关闭本地套接字: unix_socket.close()
客户端流程
1.创建本地套接字: unix_client_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
2.连接本地套接字文件: unix_client_socket.connect(unix_server_address)
3.发送消息: unix_client_socket.send()
4.接收消息: recv_data = unix_client_socket.recv(1024)
5.关闭套接字: unix_client_socket.close()
3.UNIX应用-客户端
import socket
import sys
import traceback def main():
try:
# 创建unix本地套接字
unix_client_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
# 文件已经被服务端创建,且和服务端使用的是同一个socket文件
unix_server_address = "./unix_socket_test"
# 连接本地套接字文件
unix_client_socket.connect(unix_server_address)
except socket.error:
traceback.print_exc()
sys.exit(1)
while True:
# 发送数据
send_data = input("请输入要发生的数据:")
if send_data:
unix_client_socket.sendall(send_data.encode("utf-8"))
# 接收服务器发送过来的数据
recv_data = unix_client_socket.recv(1024)
print("接收到的数据为:%s" % recv_data.decode("utf-8"))
else:
break
# 关闭套接字
unix_client_socket.close() if __name__ == "__main__":
main()
4.UNIX应用-服务端
import socket
import os def main():
# 确定那个文件作为通讯文件
unix_server_address = "./unix_socket_test"
# 判断通讯文件是否存在,如果存在则删除文件
if os.path.exists(unix_server_address):
os.unlink(unix_server_address) # 创建一个unix本地套接字
unix_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
# 绑定本地套接字文件
unix_socket.bind(unix_server_address)
# 监听
unix_socket.listen(128) # 循环目的: 多次调用accept等待客户端连接,为多个客服端服务
while True:
print("等待一个新的客户端的到来...")
new_client_socket, client_addr = unix_socket.accept()
print("客户端' %s '已经到来" % str(client_addr))
# 循环目的: 为同一个客服端服务多次
while True:
# 接收客户端发送过来的请求
recv_data = new_client_socket.recv(1024) # recv解堵塞的两种方式: 1.客户端发送过来数据,2.客户端调用了close
if recv_data:
print("客户端' %s '发送过来的请求是: %s" % (str(client_addr), recv_data.decode("utf-8")))
# 回送数据给客户端表示响应客户端的请求
send_data = "----ok----Request accepted"
new_client_socket.send(send_data.encode("utf-8"))
else:
break
# 5.关闭客户端套接字
new_client_socket.close() # 关闭本地套接字
unix_socket.close() if __name__ == "__main__":
main()
5.TCP和UDP区别
1.TCP传输数据使用字节流方式传输,UDP是数据包
2.TCP会产生粘包现象,UDP不会
3.TCP对网络条件要求高,UDP不需要
4.TCP编程可以保证传输的可靠性,UDP不保证
5.TCP使用listen和accept,UDP不需要
6.收发消息
TCP使用recv send sendall # sendall用法和send一样,只是返回值不同,成功返回None, 失败则产生异常
UDP使用recvfrom sendto
02_套接字编程(socket抽象层)的更多相关文章
- Android网络编程系列 一 Socket抽象层
在<Android网络编程>系列文章中,前面已经将Java的通信底层大致的描述了,在我们了解了TCP/IP通信族架构及其原理,接下来我们就开始来了解基于tcp/ip协议层的Socket抽 ...
- 《Python》网络编程之客户端/服务端框架、套接字（socket）初使用
一.软件开发的机构 我们了解的涉及到两个程序之间通讯的应用大致可以分为两种: 第一种是应用类:QQ.微信.网盘等这一类是属于需要安装的桌面应用 第二种是web类:比如百度.知乎.博客园等使用浏览器访问 ...
- 基于TCP协议的socket套接字编程
目录 一.什么是Scoket 二.套接字发展史及分类 2.1 基于文件类型的套接字家族 2.2 基于网络类型的套接字家族 三.套接字工作流程 3.1 服务端套接字函数 3.2 客户端套接字函数 3.3 ...
- Linux Socket 原始套接字编程
对于linux网络编程来说,可以简单的分为标准套接字编程和原始套接字编程,标准套接字主要就是应用层数据的传输,原始套接字则是可以获得不止是应用层的其他层不同协议的数据.与标准套接字相区别的主要是要开发 ...
- Python套接字编程（1）——socket模块与套接字编程
在Python网络编程系列,我们主要学习以下内容: 1. socket模块与基本套接字编程 2. socket模块的其他网络编程功能 3. SocketServer模块与简单并发服务器 4. 异步编程 ...
- Linux之socket套接字编程20160704
介绍套接字之前,我们先看一下传输层的协议TCP与UDP: TCP协议与UDP协议的区别 首先咱们弄清楚,TCP协议和UCP协议与TCP/IP协议的联系,很多人犯糊涂了,一直都是说TCP/IP协议与UD ...
- 网络编程之网络架构及其演变过程、互联网与互联网的组成、OSI七层协议、socket抽象层
目录 网络架构及其演变过程 单机架构 CS架构 BS架构 BS架构和CS架构的区别 C/S架构的优缺点: B/S架构的优缺点: 互联网与互联网的组成 互联网的组成(教科书版) 互联网的组成(科普版) ...
- day31 socket套接字编程
为什么要有套接字编程? 在上节课的学习中,我们学习了OSI七层协议,但是如果每次进行编程时我们都需要一层一层的将各种协议使用在我们的程序中,这样编写程序实在是太麻烦了,所以为了让程序的编写更加的简单, ...
- socket套接字编程 HTTP协议
socket套接字编程 套接字介绍 1. 套接字 : 实现网络编程进行数据传输的一种技术手段 2. Python实现套接字编程:import socket 3. 套接字分类 >流式套接 ...
随机推荐
- 13、Visitor 访问者模式 访问数据结构并处理数据 行为型设计模式
1.模式的定义与特点 访问者(Visitor)模式的定义:将作用于某种数据结构中的各元素的操作分离出来封装成独立的类,使其在不改变数据结构的前提下可以添加作用于这些元素的新的操作,为数据结构中的每个元 ...
- VMware启动CentOS出错，提示"该虚拟机似乎正在使用中"
今天在使用VMware启动CentOS时,出现如下图1错误提示: 当点击“确定”按钮时,出现如下图2错误提示: 无奈,只能点击图1 中的“取消”按钮,进行问题的跟踪.分析.经过核实,发现上述问题是由于 ...
- Ubuntu18.04安装Nautilus-actions自定义文件管理器鼠标右键列表
sudo add-apt-repository ppa:daniel-marynicz/filemanager-actions #需要添加源 sudo apt-get install filemana ...
- 《Java从入门到失业》第二章：Java环境（一）：Java SE安装
从这一章开始,终于我们可以开始正式进入Java世界了.前面我们提到过,Java分三个版本,我们这里只讨论Java SE. 2.1Java SE安装 所谓工欲善其事,必先利其器.第一步,我们当然是要下载 ...
- java多线程：线程同步synchronized（不同步的问题、队列与锁），死锁的产生和解决
0.不同步的问题 并发的线程不安全问题: 多个线程同时操作同一个对象,如果控制不好,就会产生问题,叫做线程不安全. 我们来看三个比较经典的案例来说明线程不安全的问题. 0.1 订票问题 例如前面说过的 ...
- css实现网页缩放时固定定位的盒子与版心一同缩放
在网页设计过程中我们可能会出现这种情况:设置好一个固定定位的盒子,但是当网页缩放时固定定位的盒子与网页的版心分离 这是因为css定位中的固定定位是以页面为参照进行定位的,而不是以版心盒子为参照,那么我 ...
- nohup 命令的使用
nohup 命令的使用 1. nohup简介 nohup 命令运行由 Command参数和任何相关的 Arg参数指定的命令,忽略所有挂断(SIGHUP)信号.在注销后使用 nohup 命令运行后台中的 ...
- GridBagConstraints详解
名称 作用 默认值 常量 位置 gridx 行(x)的第一个单元格 0并且为非负数 RELATIVE(相对的) 紧跟前一个组件的后面 gridy 列(y)的第一个单元格 0并且为非负数 RELATIV ...
- 6.oracle用户管理口令
一.使用profile管理用户口令概述:profile是口令限制,资源限制的命令集合,当建立数据库时,oracle会自动建立名称为default的profile.当建立用户没有指定profile选项时 ...
- 鼠标放上时显示隐藏的div或者其他代码的“jquery”的三种写法和“JavaScript”的一种写法
<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8&quo ...