参考：
python socket通信：https://yq.aliyun.com/articles/40745?spm=5176.100239.blogcont40768.17.FIFTZv
1.socket使用方法
a.在python中使用socket时要iamport socket
b.在使用socket中又服务器端和客户端之分
socket也称作“套接字”，用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过“套接字”向网络发出请求或者应答网络请求。
socket起源于Unix，而Unix/Linux基本哲学之一就是：一切皆文件，即都可以用“打开open—>读写write/read—>关闭close”模式来操作。Socket就是该模式的一个实现，socket即是一种特殊的文件，一些socket函数就是对其进行的操作（读/写IO、打开、关闭）。
可以看下面的图示来形象说明:
服务器：
1、建立一个基于tcp协议的socket类
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
其中AF_INET指定的ipv4的协议，也可以使用AF_INET6指定ipv6的协议，而STREAM是指定面向流的tcp协议。
2、s.bind(‘', 8089))
绑定一个端口号，其中'127.0.0.1'是客户端的ip地址，可以使用’0.0.0.0’来绑定网络中所有的ip，8089是指定的端口，其中端口在小于1024的时候需要有管理员的权限才能绑定。
3、s.listen(5)
开始实行监听参数：代表连接的最大数量
4、sock, addr = s.accept()
接受一个客户端的连接，返回的是一个与客户端保持连接的socket对象以及客户端的ip地址和端口。该方法也会阻塞线程，直到获得客户端的连接。
客户端：
1、s.connect(('127.0.0.1', 80))
连接到服务器，其中'www.baidu.com’也可以是服务器的ip地址。
2、s.send('hello')
发送数据’hello’。TCP连接创建的是双向通道，双方都可以同时给对方发数据。但是谁先发谁后发，怎么协调，要根据具体的协议来决定。
3、s. recv(1024)
接受连接的对方发来的数据。该方法会阻塞当前线程，所以需要一个专门的线程来接受数据。
2.socket 案例
a.socket单线程的阻塞
# 本机实现的单线程非交互式的socket程序
# #### server ###########################################################################################
import socket #导入socket类
HOST ='' #定义侦听本地地址口（多个IP地址情况下），这里表示侦听所有，也可以写成0.0.0.0
PORT = 50007 #Server端开放的服务端口
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) #选择Socket类型和Socket数据包类型
s.bind((HOST, PORT)) #绑定IP地址和端口
s.listen(1) #定义侦听数开始侦听（实际上并没有效果）
conn, addr = s.accept() #定义实例，accept()函数的返回值可以看上面的socket函数说明
print 'Connected by', addr
while 1:
data = conn.recv(1024) #接受套接字的数据
if not data:break #如果没有数据接收，则断开连接
print 'revc:',data #发送接收到的数据
conn.sendall(data) #发送接收到的数据
conn.close() #关闭套接字
# #### client ###########################################################################################
import socket
HOST = '192.168.1.13' #定义目标主机名
PORT = 50007 #定义目标主机开放服务端口号
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) #选择Socket类型和Socket数据包类型
s.connect((HOST, PORT)) #连接到目标主机的socket（套接字）中
s.sendall('Hello, world!') #发送数据
data = s.recv(1024) #接收数据
s.close() #关闭socket
print 'Received', repr(data)
# 单线程+阻塞+交互式socket程序
# #### server：内容同上个例子#######################################################################33######
import socket #导入socket类
HOST ='' #定义侦听本地地址口（多个IP地址情况下），这里表示侦听所有，也可以写成0.0.0.0
PORT = 50007 #Server端开放的服务端口
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM) #选择Socket类型和Socket数据包类型
s.bind((HOST, PORT)) #绑定IP地址和端口
s.listen(1) #定义侦听数开始侦听（实际上并没有效果）
conn, addr = s.accept() #定义实例，accept()函数的返回值可以看上面的socket函数说明
print 'Connected by', addr
while 1:
data = conn.recv(1024) #接受套接字的数据
if not data:break #如果没有数据接收，则断开连接
print 'revc:',data #发送接收到的数据
conn.sendall(data) #发送接收到的数据
conn.close() #关闭套接字
# #### client ##########################################################################################
import socket
HOST = '192.168.1.13'
PORT = 50007
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
while True:
user_input = raw_input('msg to send:').strip() #由User输入要发送的数据
s.sendall(user_input)
data = s.recv(1024)
print 'Received', repr(data)
s.close()
单线程，即数据的串行发送，会导致阻塞，如果要解决这个问题，当然在Server端就需要支持多线程，即数据折并发。
b.socket（多线程聊天程序实例）
该程序实现的是一个相对比较简单的聊天程序，由于是基于控制台实现的，所只设计容许两个人聊天，另外消息的编码的分割符为|。
# 首先建立一个User的数据结构
import socket
class User:
def __init__(self,skt,username='none'):
self.skt=skt
self.username=username
def send_msg(self,msg):
self.skt.send(msg)
def logout(self):
self.skt.close()
# server
import sys
import socket
import threading,time
import User
#global variable
userlist=[]
def hand_user_con(usr):
try:
isNormar=True
while isNormar:
data=usr.skt.recv(1024)
time.sleep(1)
msg=data.split('|')#分析消息
if msg[0]=='login':
print 'user [%s] login' % msg[1]
usr.username=msg[1]
notice_other_usr(usr)
if msg[0]=='talk':
print 'user[%s]to[%s]:%s' % (usr.username,msg[1],msg[2])
send_msg(msg[1],msg[2])#发送消息给目标用户，参数1：目标用户，参数2：消息内容
if msg[0]=='exit':
print 'user [%s] exit' % msg[0]
isNormar=False
usr.close()
userlist.remove(usr)
except:
isNormar=False
#通知其他用户以上的好友
def notice_other_usr(usr):
if(len(userlist)>1):
print 'The two users'
userlist[0].skt.send(("login|%s" % userlist[1].username))
userlist[1].skt.send(("login|%s" % userlist[0].username))
else:
print 'The one users'
def send_msg(username,msg):
for usr in userlist:
if(usr.username==username):
usr.skt.send(msg)
def main():
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.bind(('0.0.0.0',9999))
s.listen(5)
print u'waiting for connection...'
while True:
sock,addr=s.accept()#等待用户连接
user=User.User(sock)
userlist.append(user)
t=threading.Thread(target=hand_user_con,args=(user,));
t.start()
s.close()
if(__name__=="__main__"):
main()
import sys
import socket
import threading,time
#global variable
isNormar=True
other_usr=''
def recieve_msg(username,s):
global isNormar,other_usr
print 'Please waiting other user login...'
s.send('login|%s' %username)
while(isNormar):
data= s.recv(1024)#阻塞线程，接受消息
msg=data.split('|')
if msg[0]=='login':
print u'%s user has already logged in, start to chat' % msg[1]
other_usr=msg[1]
else:
print msg[0]
#程序入口
def main():
global isNormar,other_usr
try:
print 'Please input your name:'
usrname=raw_input()
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.connect(("127.0.0.1",9999))
t=threading.Thread(target=recieve_msg,args=(usrname,s))
t.start()
except:
print 'connection exception'
isNormar=False
finally:
pass
while isNormar:
msg=raw_input()#接受用户输入
if msg=="exit":
isNormar=False
else:
if(other_usr!=''):
s.send("talk|%s|%s" % (other_usr,msg))#编码消息并发送
s.close()
if __name__=="__main__":
main()
c.socketserver模块，实现socket并发
socketserver说明如下图所示：
# SockteServer例子说明
# #### server ####################################
import SocketServer #导入SocketServer，多线程并发由此类实现
class MySockServer(SocketServer.BaseRequestHandler): #定义一个类
def handle(self): #handle(self)方法是必须要定义的，可以看上面的说明
print 'Got a new connection from', self.client_address
while True:
data = self.request.recv(1024) #需要通过self的方法调用数据接收函数
if not data:break
print 'recv:', data
self.request.send(data.upper()) #需要通过self的方法调用数据接收函数
if __name__ == '__main__': #并非一定要用这样的方式，只是建议这样使用
HOST = '' #定义侦听本地地址口（多个IP地址情况下），这里表示侦听所有
PORT = 50007 #Server端开放的服务端口
s = SocketServer.ThreadingTCPServer((HOST, PORT), MySockServer)
#调用SocketServer模块的多线程并发函数
s.serve_forever() #持续接受客户端的连接
# #### client #####################################
import socket
HOST = '192.168.1.13'
PORT = 50007
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
while True:
user_input = raw_input('msg to send:').strip()
s.sendall(user_input)
data = s.recv(1024)
print 'Received', repr(data)
s.close()
d.基于SocketServer多线程的简化SSH程序
# #### server ############################################
import SocketServer
import commands #使用其中的getstatusoutput()函数，让Server端可以识别Client端发送过来的命令并执行
import time #主要使用其中的time.sleep()函数，用来解决Server端发送数据的“连块”问题
class MySockServer(SocketServer.BaseRequestHandler):
def handle(self):
print 'Got a new connection from', self.client_address
while True:
cmd = self.request.recv(1024)
if not cmd:
print 'Last connection with:',self.client_address
break
cmd_result = commands.getstatusoutput(cmd) #获取Client端的指令并执行，返回结果是一个存储两个元素的元组，第一个元素为0表示成功执行，第二个元素则是命令的执行结果
self.request.send(str(len(cmd_result[1]))) #发送命令执行结果的大小长度，Client端要想接收任意大小的执行结果，就需要根据命令执行结果的大小来选择策略，这里需要注意的是，发送的数据是字符串，所以需要作类型转换
time.sleep(0.2) #睡眠0.2s，是为了解决“连块”的问题
self.request.sendall(cmd_result[1]) #发送命令执行结果
if __name__ == '__main__':
HOST = ''
PORT = 50007
s = SocketServer.ThreadingTCPServer((HOST, PORT), MySockServer)
s.serve_forever()
# #### client #######################################
import socket
HOST = '192.168.1.13'
PORT = 50007
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.connect((HOST, PORT))
def data_all(obj, lenth_size):
data = '' #用来存储每一次循环时socket接收的数据，解决socket大概两万多字节的缓冲瓶颈限制
while lenth_size != 0: #如果接收的数据长度不为0，开始执行接收数据处理策略
if lenth_size <= 4096: #这里以4096为单位块，作为每次的数据处理量大小
data_recv = obj.recv(lenth_size) #通过recv()接收数据
lenth_size = 0 #通过这一步的处理，数据全部接收完毕，置lenth_size为0，结束循环，完成数据的接收处理工作
else:
data_recv = obj.recv(4096) #以4096为单位块，一次接收4096的数据量大小
lenth_size -= 4096 #处理完一次4096字节的数据后，将lenth_size减去4096
data += data_recv #判断外层，用本地的data来存储接收到的数据，因为本地的data大小没有限制，所以不存在data饱和无法继续存储数据的问题，但前面socket的recv()函数一次最多只能接收的数据量大小是有限制的，这取决于socket的缓冲区大小，因此data_all函数的作用就是通过使用多次recv()函数，并且每次接收一定量的数据后就进行本地存储，直到把所有的数据都接收完毕
return data
while True:
user_input = raw_input('cmd to send:').strip()
if len(user_input) == 0:continue
s.sendall(user_input)
data_size = int(s.recv(1024)) #得到命令执行结果的大小长度，因为发送过来的数据是字符串，所以这里要作类型转换
print '\033[32;1mdata size:\033[0m',data_size #打印命令执行结果的大小
result = data_all(s, data_size) #通过data_all函数来执行相应的数据接收处理策略
print result #打印命令执行结果
s.close() #关闭套接字
PS：
1.Server端发送数据的“连块”问题，即发送两次数据时，如果发送间隔比较短，socket会把两次发送的数据放在一起来发送，这里通过time.sleep()函数来解决。
2.socket的缓冲区大小问题，即当执行top -bn 3这样执行结果长度大的命令时，socket缓冲区一次是无法存储这么多数据的，所以只能分多次来接收数据，这样就会在Client端带来一定的问题，比如命令执行的不同步等，解决的方法是通过用循环接收的方法来进行本地存储Server端发送的数据。
当然，如果要执行man等查询方面的命令，上面的程序也是无法做到的，所以这里说，这只是一个简版的SSH程序
本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
