本文介绍了Python中网络编程的基础知识，包括TCP/IP协议的工作原理、socket编程的具体实现、并发处理客户端请求的方法，以及如何利用struct和subprocess模块进行数据处理。
struct模块
import struct
#帮我们把数字转成固定长度的bytes类型
res=struct.pack('i',123123)
print(res,len(res))
res1=struct.unpack('i',res)
print(res1[0])subprocess 模块
import subprocess
obj = subprocess.Popen('dir',shell = True,
stdout = subprocess.PIPE, # 正确的结果
stderr = subprocess.PIPE, # 错误的结果
)
print(obj.stderr.read().decode('gbk'))客户服务端：
基于TCP(建链接，慢但安全)
服务端
import subprocess
import struct
import json
from socket import *
server=socket(AF_INET,SOCK_STREAM)
server.bind(('127.0.0.1',8086))
# print(server)
server.listen(5)
while True:
conn,addr=server.accept()
# print(conn)
print(addr)
while True:
try:
cmd=conn.recv(8096)
if not cmd:break #针对linux
#执行命令
cmd=cmd.decode('utf-8')
#调用模块，执行命令，并且收集命令的执行结果，而不是打印
obj = subprocess.Popen(cmd, shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,)# )
stdout=obj.stdout.read()
stderr=obj.stderr.read()
# 1：先制作报头，报头里放：数据大小, md5, 文件
header_dic = {
'total_size':len(stdout)+len(stderr),
'md5': 'xxxxxxxxxxxxxxxxxxx',
'filename': 'xxxxx',
'xxxxx':'123123'
}
header_json = json.dumps(header_dic)
header_bytes = header_json.encode('utf-8')
header_size = struct.pack('i', len(header_bytes))
# 2: 先发报头的长度
conn.send(header_size)
# 3：先发报头
conn.send(header_bytes)
# 4：再发送真实数据
conn.send(stdout)
conn.send(stderr)
except ConnectionResetError:
break
conn.close()
#
server.close()
客户端
import struct
import json
from socket import *
client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8084))
while True:
cmd=input('>>: ').strip()
if not cmd:continue
client.send(cmd.encode('utf-8'))
# 1:先收报头长度
obj = client.recv(4)
header_size = struct.unpack('i', obj)[0]
# 2：先收报头，解出报头内容
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:循环收完整数据
recv_size=0
res=b''
while recv_size < total_size:
recv_data=client.recv(1024)
res+=recv_data
recv_size+=len(recv_data)
print(res.decode('gbk'))
client.close()最简单的套接字(经典)：
客户端
from socket import *
client = socket(AF_INET, SOCK_STREAM)
client.connect(('127.0.0.1', 8080)) # ## 也需要选地址的
while True:
msg = input('>>:').strip()
if not msg: continue
client.send(msg.encode('utf-8'))
data = client.recv(1024)
print(data.decode('utf-8'))
client.close()服务端
from socket import *
server = socket(AF_INET, SOCK_STREAM)
server.bind(('127.0.0.1', 8080))
server.listen(5)
while True:
conn, addr = server.accept()
print(addr) # ##输出客户端地址。
while True:
try:
data = conn.recv(1024)
if not data: break # ## 没接收到就退出。
conn.send(data.upper())
except ConnectionResetError:
break
conn.close()
server.close()udp：
DUP(快，不安全):
# 服务端：
from socket import *
server = socket(AF_INET,SOCK_DGRAM)
server.bind(('127.0.0.1',8080))
while True:
data,client_addr = server.recvfrom(1024)
print('客户端：',data) # 客户端：b'客户端输入的内容'
server.sendto(data.upper(),client_addr)
# 客户端：
from socket import *
client = socket(AF_INET,SOCK_DGRAM)
while True:
msg = input('>>:').strip()
client.sendto(msg.encode('utf-8'),('127.0.0.1',8080))
data,server_addr = client.recvfrom(1024)
print(data.decode('utf-8'))
实现了并发：
服务端：
from socket import *
from multiprocessing import Process
def server(ip,port):
server = socket(AF_INET, SOCK_STREAM)
server.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)
server.bind((ip,port))
server.listen(5)
while True:
conn, addr = server.accept()
print(addr)
# communicate(conn)
p = Process(target=communicate, args=(conn,))
p.start()
server.close()
def communicate(conn):
while True:
try:
data=conn.recv(1024)
if not data:break
conn.send(data.upper())
except ConnectionResetError:
break
conn.close()
if __name__ == '__main__':
server('127.0.0.1', 8090)
客户端：
from socket import *
client=socket(AF_INET,SOCK_STREAM)
client.connect(('127.0.0.1',8090))
while True:
msg=input('>>: ').strip()
if not msg:continue
client.send(msg.encode('utf-8'))
data=client.recv(1024)
print(data.decode('utf-8'))
client.close()小结：
一、
1、网络=物理连接介质+互联网协议
2、OSI七层：应，表，会，传（tcp/udp），网（ip），数（ethernet），物
3、tcp三次握手建立连接，四次挥手断开连接
connet()--------->accept()
4、ip+port：标识全世界范围内独一无二的一个应用程序
server.bind((ip,port))
5、C/S
Client：ip+port会随意变
Server：
一定要绑定ip+port
应该支持并发连接
服务端一旦开启一直运行到世界末日
今日内容：
坑：recv(1024)
粘包问题：自定义应用层协议
TCP：流式协议
二、TCP协议的Nagle算法
把数据量较小并且时间间隔比较短的包合成一个包发送
1 什么是进程？
进程是一个抽象的概念，进程即正在执行的过程，进程的概念起源于操作系统，
进程的创建，调度管理都归操作系统管
2 操作系统的作用？
1、管理硬件，把复杂丑陋的硬件接口封装成良好的接口给用户使用
2、进程的创建，调度管理都归操作系统管
3 多道技术？
产生背景：针对单核下实现并发
核心：
1、空间上复用（多个进程的内存空间是互相隔离的）
2、时间上复用（复用cpu的时间，）
4 开启进程
from multiprocessing import Process
import time
def task(name):
print('%s is running' %name)
time.sleep(2)
if __name__ == '__main__': #在windows系统下，开子进程的代码必须写到这一行下面
p=Process(target=task,args=('egon',))
p.start() #只是在给操作系统发了一个信号，让操作系统去开进程（申请内存+拷贝父进程的地址空间）
print('主')①tasklist 查看当前运行的进程
②tasklist | findstr python 过滤python
③taskill 全干掉 例 taskill python
④copy path 拷贝路径 然后将路径在 cmd里执行 就会运行其文件
⑤os.getpid 查看当前进程的id号
⑥os.getppid 查看当前父进程的id号
⑦一个进程运行两遍是两个进程，进程号也会变
⑧p.submit # 往进程池里扔结果(异步)
⑨p.shutdown(wait=True)
# 相当于 pool.close() pool.join() 关门+等
了解：
1.p1 = Process(target=task,args=('sunv',))
p1.start()
p1.name() # 查看p1的名字(默认)，也可自己设置:
p1 = Process(target=task,args=('sunv',)，name='ppp')
p1.pid() # 查看 和 os模块下的 getpid 一样的
2.p1.is_alive() 查看是否活着返回bool值。
例：p1.join() # 把进程干死
print(p1.is_alive()) # False
例：（诡异，不要用！！）
p1.terminate() # 把进程干死（只把儿子干死，若有孙子就会出现孤儿进程）
print(p1.is_alive()) # True11.提交/调用任务的方式有两种：
同步调用：提交/调用一个任务，然后就在原地等到他完成拿到结果，后再执行
异步调用：提交/调用一个任务，不在原地等，直接执行下边的代码，结果？
12.提交任务的方式如果是同步的话，会导致程序的运行变成串行
异步：并发的效果
用进程池来实现并发的套接字通信
线程进程的区别：
1、线程的创建开销小于进程，创建速度快
2、同一进程下的多个线程共享该进程的地址空间
3、该控制线程的周期代表进程的周期(主线程死，进程死)
①主进程等子进程是为了给其收尸；主线程等子线程，是因为线程全部完成，进程才算完成(主线程结束，进程结束)。
②子线程、主线程的getpid 相同，都是 进程的 id号。它们的ppid 是pycharm的id号。
子进程的ppid 是 父进程的 id。
③进程池 默认 cpu的核数
线程池 默认 cpu核数 的 5 倍异步函数的回调：
异步函数的参数是单一的，是它所绑定下载任务的返回值。
爱情陷阱 --- 谭咏麟
扫一扫
1852
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
