一。基本语法

127.0.0.1     是本地回环地址

客户端                                                                                                                                                                          服务端

import socket                                                                                                                                                               import socket

client=socket.socket()                                                                                                                                                  server=socket.socket()         #买手机
ip_port=('127.0.0.1',8088)                                                                                                                                            ip_port=('127.0.0.1',8088)

client.connect(ip_port)   #连接的是一个元组,所以提前写好需要输入的IP和port                                                        server.bind(ip_port)             #插电话卡  注意括号内是一个小元组,避免出错,先将Ip_port先写在外面

                                                   server.listen(5)                    #监听状态   5是半连接池

                                                  conn,addr=server.accept()   #建立通信,已完成三次握手

client.secd(b'hello boy!')                                                   data=conn.recv (1024)        #   和客户端对照者写,move right   必须是一个输入,一个接受,否则就会出现双方都在输入/输出状态,就会出现阻塞现象

                                  print(data)

data=client.recv(1024)                                         conn.send(b'hihihihihi')                                       

print(data)                                              conn.close()

client.close()    #一次通信结束                                     server.close()

二。通信循环

上面我们已经可以实现两个计算机之间的相互通信,但是只是一次通信,如果要多次通信,就得多次输入,我们前面学过的可以多次输入的有什么?while循环

客户端                                                                                                                                                                          服务端

import socket                                                                                                                                                               import socket

client=socket.socket()                                                                                                                                                  server=socket.socket()         #买手机
ip_port=('127.0.0.1',8088)                                                                                                                                            ip_port=('127.0.0.1',8088)

client.connect(ip_port)   #连接的是一个元组,所以提前写好需要输入的IP和port                                                        server.bind(ip_port)             #插电话卡  注意括号内是一个小元组,避免出错,先将Ip_port先写在外面

                                                   server.listen(5)                    #监听状态   5是半连接池

                                                  conn,addr=server.accept()   #建立通信,已完成三次握手

while True:                                             while True:

  client.send(b'hello boy!')                                                     data=conn.recv (1024)

                                      print(data)

  data=client.recv(1024)                                           conn.send(b'hihihihihi')                                       

  print(data)                                              

                                                   conn.close()

client.close()    #一次通信结束                                     server.close()

三。链接循环

通信循环也已经实现了两台计算机之间的多次信息交流,但是发现只能一次服务一个客户端,但是服务端的特点是24小时不间断的提供服务,并且是提供给多个用户,地址也是不变的,那么如何实现提供多个服务给用户呢?链接循环走起来!

客户端                                                                                                                                                                          服务端

import socket                                                                                                                                                               import socket

client=socket.socket()                                                                                                                                                  server=socket.socket()         #买手机
ip_port=('127.0.0.1',8088)                                                                                                                                            ip_port=('127.0.0.1',8088)

client.connect(ip_port)   #连接的是一个元组,所以提前写好需要输入的IP和port                                                        server.bind(ip_port)             #插电话卡  注意括号内是一个小元组,避免出错,先将Ip_port先写在外面

                                                   server.listen(5)                    #监听状态   5是半连接池

                                              while True:   #这里就可以实现多个客户服务,所以得将建立连接信息放到第一个while里面     我们发现最多只可以打开6个客户端,一旦超过就报错

                                                   这是因为半连接池是5,就相当于只提供了5个凳子,先服务第一个用户,外面可以由5个人在 等,但是再来一个就报错!

                                                  conn,addr=server.accept()   #建立通信,已完成三次握手

while True:                                             while True:

  client.send(b'hello boy!')                                                     data=conn.recv (1024)

                                      print(data)

  data=client.recv(1024)                                           conn.send(b'hihihihihi')                                       

  print(data)                                              

                                                   conn.close()

client.close()    #一次通信结束                                     server.close()

四。异常处理

实际生活中:

1,用户提前中断了通道,会发现服务端直接报错,所以要对这个进行异常捕获

2.网络信号不好导致的问题

3.tcp协议是流的传输,输入信息不可以是空

客户端                                                                                                                                                                          服务端

import socket                                                                                                                                                               import socket

client=socket.socket()                                                                                                                                                  server=socket.socket()         #买手机
ip_port=('127.0.0.1',8088)                                                                                                                                            ip_port=('127.0.0.1',8088)

client.connect(ip_port)   #连接的是一个元组,所以提前写好需要输入的IP和port                                                        server.bind(ip_port)             #插电话卡  注意括号内是一个小元组,避免出错,先将Ip_port先写在外面

                                                   server.listen(5)                    #监听状态   5是半连接池

                                              while True:

                                                  conn,addr=server.accept()   #建立通信,已完成三次握手

while True: 

  msg=input('>>>:').encode('utf-8') 

  if len(msg)==0:continue                                        while True:

                                                     try:

  client.send(msg)                                                          data=conn.recv (1024)

                                                        if len(data)==0:break   #针对mac 和Linux系统,需要自己再加一步

                                        print(data)

  data=client.recv(1024)                                             conn.send(b'hihihihihi')                                       

  print(data)                                               except ConnectionRaseError:break

                                                   conn.close()

client.close()    #一次通信结束                                     server.close()

五。粘包问题

发现当自己输入的是task list之类的东西时,然后再次输入dir但是还是接收的是task list的信息,就是粘包,两个数据粘在了一起,解决方式

1.将recv的值改大,但是不是根本性的解决方式,因为你不知道用户传入的东西是多大,所以不推荐

2.将我们要传的东西先打包成固定大小,对方接受以后解包,看到大小,然后再根据大小来接受我们要传的东西(看下面总结)

总结:

发送消息端:

1.先发报头    2.在发字典(序列化成字符串)       3.再发你的真实数据

接收消息端:

1.先收4个长度的报头   2.解包拿到字典数据长度    3.接收字典(反序列化)获取字典里面的所有信息         4.接收真实数据

用到的模块分别是struck(pack,unpack),subprocess(标准输出stdout和错误流stderr)  json(序列化dumps和反序列化loads)   以及socket

客户端

import socket
import json
import struct
client=socket.socket()
ip_port=('127.0.0.1',8099)
client.connect(ip_port) while True:
msg=input('>>>:').strip().encode('utf-8')
if len(msg)==0:continue
client.send(msg)
head=client.recv(4) #head就是4
#对这个报头进行解包,获取真实数据的长度
head_len=struct.unpack('i',head)[0]
head_dic=json.loads(client.recv(head_len).decode('utf-8')) #反序列化
print(head_dic) total_size=head_dic['len'] #一定要由索引0
# unpack拿出来的是一个小元组
print(total_size) #如果发送内容过大,怎么做,循环接收值 recv_size=0
res=b''
while recv_size<total_size: #对需要的数据进行循环接受
data=client.recv(1024)
res+=data
recv_size+=len(data) #len(data)真实收到的数据,所以是data,不是1024
print(res.decode('gbk')) 服务端:
#服务端给用户端发送一个字典的内容
import socket
import struct
import json
import subprocess server=socket.socket() ip_port=('127.0.0.1',8099) server.bind(ip_port) server.listen(5) while True: conn,addr=server.accept() while True:
try:
data=conn.recv(1024)
if len(data)==0:break
print(data)
order=subprocess.Popen(data.decode('utf-8'),
shell=True,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE
) stdout=order.stdout.read()
stderr=order.stderr.read()
#传过来的真实长度
print(len(stderr+stdout))
#传字典
head_dic = {
'file_name': 'cls.txt',
'len': len(stdout + stderr)
}
#字典序列化
head_bytes=json.dumps(head_dic).encode('utf-8') #制作报头
head=struct.pack('i',len(head_bytes)) #将需要发送给客户端的打包成4个字节 conn.send(head) #head=4想拿到一些描述,传个字典 conn.send(head_bytes)
conn.send(stderr+stdout)
except ConnectionResetError:break

socket基本语法和粘包的更多相关文章

  1. day8---多线程socket 编程,tcp粘包处理

    复习下socket 编程的步骤: 服务端:   1 声明socket 实例 server = socket.socket()  #括号里不写  默认地址簇使用AF_INET  即 IPv4       ...

  2. c# Socket通讯中关于粘包,半包的处理,加分割符

    using System; using System.Collections.Generic; using System.Text; using System.Net.Sockets; using S ...

  3. python socket网络编程之粘包问题详解

    一,粘包问题详情 1,只有TCP有粘包现象,UDP永远不会粘包 你的程序实际上无权直接操作网卡的,你操作网卡都是通过操作系统给用户程序暴露出来的接口,那每次你的程序要给远程发数据时,其实是先把数据从用 ...

  4. Python开发【socket篇】解决粘包

    客户端 import os import json import struct import socket sk = socket.socket() sk.connect(('127.0.0.1',8 ...

  5. 11.1、socket连接中的粘包、精确传输问题

    粘包: 发生原因: 当调用send的时候,数据并不是即时发给客户端的.而是放到了系统的socket发送缓冲区里,等缓冲区满了.或者数据等待超时了,数据才会发送,所以有时候发送太快的话,前一份数据还没有 ...

  6. 6.2 socket 流协议与粘包

    TCP IP协议是流协议,对上层协议来讲是没有边界的,主机A发送两个消息M1和M2,如下图所示: 主机A发送了M1和M2,主机B在接收时有4种情况: 1.先收了M1,又收了M2 2.M1.M2一起收到 ...

  7. day08 多线程socket 编程,tcp粘包处理

    复习下socket 编程的步骤: 服务端:   1 声明socket 实例 server = socket.socket()  #括号里不写  默认地址簇使用AF_INET  即 IPv4       ...

  8. socket基于TCP(粘包现象和处理)

    目录 6socket套接字 7基于TCP协议的socket简单的网络通信 AF_UNIX AF_INET(应用最广泛的一个) 报错类型 单一 链接+循环通信 远程命令 9.tcp 实例:远程执行命令 ...

  9. python笔记8 socket(TCP) subprocess模块 粘包现象 struct模块 基于UDP的套接字协议

    socket 基于tcp协议socket 服务端 import socket phone = socket.socket(socket.AF_INET, socket.SOCK_STREAM) # 买 ...

随机推荐

  1. MatterTrack Route Of Network Traffic :: Matter

    Python 1.1 基础 while语句 字符串边缘填充 列出文件夹中的指定文件类型 All Combinations For A List Of Objects Apply Operations ...

  2. 醉酒驾驶VS睡眠不足,哪个更危险

    在全球范围内,睡眠不足驾驶每年导致成千上万起交通事故,醉酒驾驶就更不用说了.毫无疑问,两种情况下都不应该驾车,都有危险.睡眠不足和醉酒驾驶相对来说哪个更危险呢? 如果要问哪一个"好" ...

  3. Seata-一站式分布式事务解决方案

    Fescar 2019 年 1 月,阿里巴巴中间件团队发起了开源项目 Fescar(Fast & EaSy Commit And Rollback),和社区一起共建开源分布式事务解决方案. F ...

  4. 修改 Cucumber HTML 报告

    后台服务是 JSON-RPC 风格的,所以 Scenario 都是这样的 Scenario: login successful When I set request body from "f ...

  5. ndarray数组的索引和切片

    索引:获取数组中特定位置元素的过程 切片:获取数组元素子集的过程 import numpy as np 一维数组 一维数组的索引和切片与python中的列表类似 索引:若元素个数为n,则索引下标可表示 ...

  6. React之mockjs+sass+生命周期函数

    mdn W3C标准网站 运行sass cnpm i -D node-sass-chokidar npm-run-all rem单位设置 <script> //rem单位设置 documen ...

  7. 小白自学机器学习----3.令人头秃的pytorch安装 (No module named 'tools.nnwrap' 错误)

    tensorflow 刚刚会写基础的模块了,今天找到研究方向的代码是pytorch实现的 总是看到这句话,人生苦短,我用pytorch 看来pytorch应该比tensorflow好学,但是!! py ...

  8. Ubuntu pppoe宽带拨号相关问题

    因为可视化界面没有相关设置,因此采用终端命令的方法. 测试环境:Ubuntu 18.0.4 pppoe的配置:$ sudo pppoeconf 然后进入此界面进行一系列宽带拨号的设置. 联网:$ su ...

  9. C#小游戏—钢铁侠VS太空侵略者

    身为漫威迷,最近又把<钢铁侠>和<复仇者联盟>系列又重温了一遍,真的是印证了那句话:“读书百遍,其意自现”.看电影一个道理,每看一遍,都有不懂的感受~ 不知道大伙是不是也有同样 ...

  10. 有史以来最全的CMD命令

    说在前面的话: 本篇是博主通过网上查找整理而成的,且都是亲测可以的一些cmd命令,可以说是很齐全了,当然,如果有不可以运行的代码,欢迎大家留言指出,我会不断完善的,谢谢. CMD作用: 掌握一些基本的 ...