python中socket

1. python 如何建立socket长连接

#coding=gbk
'''''
socket 给网络发送http请求

连接成功后，发送http的get请求，所搜索功能

'''
import socket
import sys
import time
if __name__=='__main__':
#创建套接字
try :
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
except socket.eorror,e:
print 'socket false:%s'%e
print 'socket ...'

#连接网络ip
try :
sock.connect(('220.181.111.148',80))
except socket.error,e:
print 'connect false %s'%e
sock.close()
print 'connect ...'

#发送网络首页面请求并且保持连接
try :
print 'send start...'
str='GET / HTTP/1.1\r\nHost:www..com\r\nConnection:keep-alive\r\n\r\n'
sock.send(str)
except socket.eorror,e:
print 'send false'
sock.close()

data=''
data = sock.recv(1024)
while (1): '''''如何判断数据接收完毕，在发送http 最前端,
包含发送数据文件大小属性Content-Length，
用字符匹配方式取得文件大小,
同过大小判断是否接收完毕。
'''
print data
beg = data.find('Content-Length:',0,len(data))
end = data.find('Content-Type:',0,len(data))
print beg
print end
if(beg == end):
print 'connecting closed'
break
num = long(data[beg+16:end-2])
print num
nums = 0
while (1):
data=sock.recv(1024)
print data
nums +=len(data)
if(nums >= num):
break
word = raw_input('please input your word----->')
str='''''GET /s?wd=''' + word + ''''' HTTP/1.1
Host:www..com
Connection: Keep-Alive

'''
print str
sock.send(str)
data = ''
data = sock.recv(1024)
sock.close()
print data

2. python获取当前socket连接状态，是连接还是断开。

socket建立连接后，你可以在上面加一个超时，如果超时异常出现就是断开了。
另外可以用select(inlist,writelist,errorlist,timeout)的办法，去轮询它。超过比如60秒，就认为它超时。
在操作系统层面，你可以用netstat
找到这个socket连接，看它的TCP状态。如果到了CLOSE_WAIT,
TIME_WAIT，就是对方或者是自己关闭了。
如果是FIN2.。。。SEN。。或者是SYN_XXX就是还是连接或者是发送状态中。
通常这些状态在操作系统的TCP协议里都设置有超时。如果超时过了，它自己会关闭。然后变成WAIT状态。

3. Python socket 如何实现广播单播切换

#三个线程：#线程1：产生递增的数字，转成字符串放到队列中#线程2：监听端口，将产生的连接放到列表中#线程3：从队列中取出数字，遍历连接列表，发送到所有客户端#线程1：产生递增的数字，转成字符串放到队列中classProcer(threading.Thread):

def__init__(self,work_queue):
super().__init__()#必须调用
self.work_queue=work_queue

defrun(self):
#print("Beginproce...")
num=1
whileTrue:
self.work_queue.put(str(num))
num=num+1
time.sleep(1)#暂停1秒#线程2：监听端口，将产生的连接放到列表中classSocketServer(threading.Thread):

def__init__(self,socket_list):
super().__init__()
self.socket_list=socket_list

defrun(self):
sock=socket.socket()
sock.bind(('',9090))
sock.listen(5)
print("Startlisten...")
whileTrue:
conn,addr=sock.accept()
print("Connectby",addr)
self.socket_list.append((conn,addr))#线程3：从队列中取出数字，遍历连接列表，发送到所有客户端classPrinter(threading.Thread):

def__init__(self,work_queue,socket_list):
super().__init__()#必须调用
self.work_queue=work_queue
self.socket_list=socket_list

defrun(self):
whileTrue:
num=self.work_queue.get()#当队列为空时，会阻塞，直到有数据
forsock,addrinself.socket_list:#遍历保存连接的列表
print("Send",num,"To",addr)
try:
sock.sendall(bytes(num+'
','utf-8'))#把字符串转换成字节数组发送
except:
print("Disconnectby",addr)#如果连接断开，发送会失败
self.socket_list.remove((sock,addr))#从列表中删除断开的连接defmain():
work_queue=queue.Queue()
socket_list=[]#为了更安全可靠，从多线程访问列表时应该加锁，
#这里做了简化，因为列表的增加删除操作基本上可以认为是线程安全的

socket_server=SocketServer(socket_list)
socket_server.daemon=True
socket_server.start()

printer=Printer(work_queue,socket_list)
printer.daemon=True#当主线程退出时子线程也退出
printer.start()

procer=Procer(work_queue)
procer.daemon=True#当主线程退出时子线程也退出
procer.start()

time.sleep(1)#这里要暂停一下，否则执行下一条语句时，会因队列为空而直接返回
work_queue.join()#主线程会停在这里，直到所有数字被get()，并且task_done()，因为没有调用task_done()，所在这里会一直阻塞，直到用户按^Cif__name__=='__main__':
main()

4. python如何使用socket来传输对象

importsocket
importstruct

sock=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
sock.connect(('localhost',10000))

values=(1,'ab',2.7)
packer=struct.Struct('I2sf')
packed_data=packer.pack(*values)

try:
sock.sendall(packed_data)
finally:
sock.close()

有个模块叫struct，可以自定义结构体，可以这样发送代码。

try:
importcPickleaspickle
except:
importpickle

classAA():
defa(self):
print"123"

ddd=AA()
data=pickle.mps(ddd)

还有个模块叫pickle，可以打包任何python对象，打包的结果也可以拿到套接字里发。

5. python怎么建立socket服务端

socket服务器再细分可分为多种了，tcp,udp,websocket，都是调用socket模块，但是具体实现起来有一点细微的差别

先给出一个tcp和udp通过socket协议实现的聊天室的例子

python聊天室(python2.7版本)：

都是分别运行server.py和client.py，就可以进行通讯了。

TCP版本：

socket-tcp-server.py（服务端）:

#-*-encoding:utf-8-*-
#socket.getaddrinfo(host,port,family=0,socktype=0,proto=0,flags=0)
#根据给定的参数host/port，相应的转换成一个包含用于创建socket对象的五元组，
#参数host为域名，以字符串形式给出代表一个IPV4/IPV6地址或者None.
#参数port如果字符串形式就代表一个服务名，比如“http”"ftp""email"等，或者为数字，或者为None
#参数family为地主族，可以为AF_INET，AF_INET6，AF_UNIX.
#参数socktype可以为SOCK_STREAM(TCP)或者SOCK_DGRAM(UDP)
#参数proto通常为0可以直接忽略
#参数flags为AI_*的组合，比如AI_NUMERICHOST，它会影响函数的返回值
#附注：给参数host,port传递None时建立在C基础，通过传递NULL。
#该函数返回一个五元组(family,socktype,proto,canonname,sockaddr)，同时第五个参数sockaddr也是一个二元组(address,port)
#更多的方法及链接请访问
#Echoserverprogram
fromsocketimport*
importsys
importthreading
fromtimeimportctime
fromtimeimportlocaltime
importtraceback
importtime
importsubprocess
reload(sys)
sys.setdefaultencoding("utf8")


HOST='127.0.0.1'
PORT=8555#设置侦听端口
BUFSIZ=1024

classTcpServer():
def__init__(self):
self.ADDR=(HOST,PORT)
try:
self.sock=socket(AF_INET,SOCK_STREAM)
print'%disopen'%PORT

self.sock.bind(self.ADDR)
self.sock.listen(5)
#设置退出条件
self.STOP_CHAT=False

#所有监听的客户端
self.clients={}
self.thrs={}
self.stops=[]

exceptException,e:
print"%disdown"%PORT
returnFalse

defIsOpen(ip,port):

s=socket(AF_INET,SOCK_STREAM)
try:
s.connect((ip,int(port)))
#s.shutdown(2)
#利用shutdown()函数使socket双向数据传输变为单向数据传输。shutdown()需要一个单独的参数，
#该参数表示s了如何关闭socket。具体为：0表示禁止将来读；1表示禁止将来写；2表示禁止将来读和写。
print'%disopen'%port
returnTrue
except:
print'%disdown'%port
returnFalse

deflisten_client(self):
whilenotself.STOP_CHAT:
print(u'等待接入，侦听端口:%d'%(PORT))
self.tcpClientSock,self.addr=self.sock.accept()
print(u'接受连接，客户端地址：',self.addr)
address=self.addr
#将建立的clientsocket链接放到列表self.clients中
self.clients[address]=self.tcpClientSock
#分别将每个建立的链接放入进程中，接收且分发消息
self.thrs[address]=threading.Thread(target=self.readmsg,args=[address])
self.thrs[address].start()
time.sleep(0.5)defreadmsg(self,address):
#如果地址不存在，则返回False
ifaddressnotinself.clients:
returnFalse
#得到发送消息的clientsocket
client=self.clients[address]
whileTrue:
try:
#获取到消息内容data
data=client.recv(BUFSIZ)
except:
print(e)
self.close_client(address)
break
ifnotdata:
break
#python3使用bytes，所以要进行编码
#s='%s发送给我的信息是:[%s]%s'%(addr[0],ctime(),data.decode('utf8'))
#对日期进行一下格式化
ISOTIMEFORMAT='%Y-%m-%d%X'
stime=time.strftime(ISOTIMEFORMAT,localtime())
s=u'%s发送给我的信息是:%s'%(str(address),data.decode('utf8'))
#将获得的消息分发给链接中的clientsocket
forkinself.clients:
self.clients[k].send(s.encode('utf8'))
self.clients[k].sendall('sendall:'+s.encode('utf8'))
printstr(k)
print([stime],':',data.decode('utf8'))
#如果输入quit(忽略大小写),则程序退出
STOP_CHAT=(data.decode('utf8').upper()=="QUIT")
ifSTOP_CHAT:
print"quit"
self.close_client(address)
print"alreadyquit"
break

defclose_client(self,address):
try:
client=self.clients.pop(address)
self.stops.append(address)
client.close()
forkinself.clients:
self.clients[k].send(str(address)+u"已经离开了")
except:
pass
print(str(address)+u'已经退出')


if__name__=='__main__':
tserver=TcpServer()
tserver.listen_client()

——————————华丽的分割线——————————

socket-tcp-client.py（客户端）：

#-*-encoding:utf-8-*-
fromsocketimport*
importsys
importthreading
importtime
reload(sys)
sys.setdefaultencoding("utf8")


#测试，连接本机
HOST='127.0.0.1'
#设置侦听端口
PORT=8555
BUFSIZ=1024

classTcpClient:

ADDR=(HOST,PORT)
def__init__(self):
self.HOST=HOST
self.PORT=PORT
self.BUFSIZ=BUFSIZ
#创建socket连接
self.client=socket(AF_INET,SOCK_STREAM)
self.client.connect(self.ADDR)
#起一个线程，监听接收的信息
self.trecv=threading.Thread(target=self.recvmsg)
self.trecv.start()

defsendmsg(self):
#循环发送聊天消息，如果socket连接存在则一直循环，发送quit时关闭链接
whileself.client.connect_ex(self.ADDR):
data=raw_input('>:')
ifnotdata:
break
self.client.send(data.encode('utf8'))
print(u'发送信息到%s：%s'%(self.HOST,data))
ifdata.upper()=="QUIT":
self.client.close()
printu"已关闭"
break
defrecvmsg(self):
#接收消息，如果链接一直存在，则持续监听接收消息
try:
whileself.client.connect_ex(self.ADDR):
data=self.client.recv(self.BUFSIZ)
print(u'从%s收到信息：%s'%(self.HOST,data.decode('utf8')))
exceptException,e:
printstr(e)

if__name__=='__main__':
client=TcpClient()
client.sendmsg()

UDP版本：

socket-udp-server.py

#-*-coding:utf8-*-

importsys
importtime
importtraceback
importthreading
reload(sys)
sys.setdefaultencoding('utf-8')

importsocket
importtraceback

HOST="127.0.0.1"
PORT=9555
CHECK_PERIOD=20
CHECK_TIMEOUT=15

classUdpServer(object):
def__init__(self):
self.clients=[]
self.beats={}
self.ADDR=(HOST,PORT)
try:
self.sock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
self.sock.bind(self.ADDR)#绑定同一个域名下的所有机器
self.beattrs=threading.Thread(target=self.checkheartbeat)
self.beattrs.start()
exceptException,e:
traceback.print_exc()
returnFalse

deflisten_client(self):
whileTrue:
time.sleep(0.5)
print"hohohohohoo"
try:
recvData,address=self.sock.recvfrom(2048)
ifnotrecvData:
self.close_client(address)
break
ifaddressinself.clients:
senddata=u"%s发送给我的信息是:%s"%(str(address),recvData.decode('utf8'))
ifrecvData.upper()=="QUIT":
self.close_client(address)
ifrecvData=="HEARTBEAT":
self.heartbeat(address)
continue
else:
self.clients.append(address)
senddata=u"%s发送给我的信息是:%s"%(str(address),u'进入了聊天室')
forcinself.clients:
try:
self.sock.sendto(senddata,c)
exceptException,e:
printstr(e)
self.close_client(c)
exceptException,e:
#traceback.print_exc()
printstr(e)
pass

defheartbeat(self,address):
self.beats[address]=time.time()

defcheckheartbeat(self):

whileTrue:
print"checkheartbeat"
printself.beats
try:
forcinself.clients:
printtime.time()
printself.beats[c]
ifself.beats[c]+CHECK_TIMEOUT<time.time():
printu"%s心跳超时，连接已经断开"%str(c)
self.close_client(c)
else:
printu"checkp%s,没有断开"%str(c)
exceptException,e:
traceback.print_exc()
printstr(e)
pass
time.sleep(CHECK_PERIOD)

defclose_client(self,address):
try:
ifaddressinself.clients:
self.clients.remove(address)
ifself.beats.has_key(address):
delself.beats[address]
printself.clients
forcinself.clients:
self.sock.sendto(u'%s已经离开了'%str(address),c)
print(str(address)+u'已经退出')
exceptException,e:
printstr(e)
raise

if__name__=="__main__":
udpServer=UdpServer()
udpServer.listen_client()

——————————华丽的分割线——————————
socket-udp-client.py:
#-*-coding:utf8-*-

importsys
importthreading
importtime
reload(sys)
sys.setdefaultencoding('utf-8')

importsocket

HOST="127.0.0.1"
PORT=9555
#BEAT_PORT=43278
BEAT_PERIOD=5


classUdpClient(object):
def__init__(self):
self.clientsock=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
self.HOST=HOST
self.ADDR=(HOST,PORT)
self.clientsock.sendto(u'请求建立链接',self.ADDR)
self.recvtrs=threading.Thread(target=self.recvmsg)
self.recvtrs.start()
self.hearttrs=threading.Thread(target=self.heartbeat)
self.hearttrs.start()

defsendmsg(self):
whileTrue:
data=raw_input(">:")
ifnotdata:
break
self.clientsock.sendto(data.encode('utf-8'),self.ADDR)
ifdata.upper()=='QUIT':
self.clientsock.close()
break

defheartbeat(self):
whileTrue:
self.clientsock.sendto('HEARTBEAT',self.ADDR)
time.sleep(BEAT_PERIOD)

defrecvmsg(self):
whileTrue:
recvData,addr=self.clientsock.recvfrom(1024)
ifnotrecvData:
break
print(u'从%s收到信息：%s'%(self.HOST,recvData.decode('utf8')))if__name__=="__main__":
udpClient=UdpClient()
udpClient.sendmsg()

6. 请教一个关于python socket的问题

比较简单的方法就是存储一个字典列表，每次一个链接把对象都保存到对象中，同时对象中存储对方IP。每次client连接过来，先判断列表中IP是否超限， 如果不超限 允许连接 把对象和IP存储到列表中。 如果超限 不允许连接 遍历列表中所有IP，如果IP和连接IP相同，对象断开即可，同时从列表中删除

7. python的socket为什么无法检测连接状态

tcp的实现要求极度高效，发生断开事件，系统只是记录状态，不会主动通知应用程序的。 可以通过一些api查询到socket的状态变化，然后判断是不是断开了。比如用select, epoll, kqueue之类的事件分发器。话说，如果客户端通过发送FIN包正常断开连接（拔网线什么的算异常），python的socket会变得可读，并且recv会返回None。

8. 怎么理解 Python 中的 socket 工作原理

没有区别。首先都是用socket类中的成员函数socket创建一个socket对象，这个对象有一个句柄（socket.socket的返回值，也可以理解为套接字文件指针），在socket类中有数据AF_INET成员和SOCK_STREAM成员，所以第一种形式实际上是将socket对象自身的

9. python socket如何连接到华为云服务器

这篇文章主要介绍了python使用socket连接远程服务器的方法,涉及Python中socket通信的基本技巧,具有一定参考借鉴价值,需要的朋友可以参考下
本文实例讲述了python使用socket连接远程服务器的方法。分享给大家供大家参考。具体如下：
import socket
print "Creating socket...",
s = socket.socket(socket.AF_INET,socket.SOCK_STREAM)
print "done."
print "Looking up port number...",
port = socket.getservbyname('http', 'tcp')
print "done."
print "Connecting to remote host on port %d..." % port,
s.connect(("www.jb51.net", port))
print "done."