pythonsocket例子

⑴ python socket 編程疑問

你的例子沒問題啊
while 1:
這一段就是一個infinite loop阿
只要client（就是瀏覽器）和server（就是你的程序）仍然有通信，while循環就不結束

所以你看到的就是卡住的效果，其實是因為server一直等著接收client發的數據

所以只有你強制關掉server程序，這個while循環才退出。

通常，如果你要發送很長的請求到server，是需要某種方法表示出你的數據的長度，一種是Unique End-of-string Identifier （就是字元串結束標記，在數據尾部），一種是 Size Indicator（在數據開始時告訴server你的數據有多長）

建議你仔細看下相關的文檔或書拉，這里很難解釋清楚。

推薦Python網路編程基礎：
http://www.douban.com/subject/2137490/
英文版可以從我的網盤下：
http://dl.getdropbox.com/u/308058/book/Foundations%20of%20Python%20Network%20Programming.djvu

⑵ 如何增加Python打開的socket數目

首先服務端這邊的實現如下：

import socket, traceback
host = '' # Bind to all interfaces
port = 51500
# Step1: 創建socket對象
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# Step2: 設置socket選項(可選)
s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
# Step3: 綁定到某一個埠
s.bind((host, port))
# Step4: 監聽該埠上的連接
while 1:
try:
message, address = s.recvfrom(8192)
print "Got data from ", address
s.sendto("Data is received succeefully.", address)
except (KeyboardInterrupt, SystemExit):
print "raise"
raise
except :
print "traceback"
traceback.print_exc()

其中，host置為空，意思是可以綁定到所有的介面和地址，無論是哪個客戶端的請求，只要是綁定到了同樣的埠，那麼伺服器就可以監聽到這個請求。
在tcp連接中，監聽客戶端的請求需要用到listen或accept函數，並有一個專門的socket和遠程極其連接。
接著使我們的客戶端實現：

import socket, sys
# Step1: 輸入host和port信息
host = raw_input('please input host name: ')
textport = raw_input('please input textport: ')
# Step2: 創建socket對象
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
try:
port = int(textport)
except ValueError:
port = socket.getservbyname(textport, 'udp')
# Step3: 打開socket連接
s.connect((host, port))
# Step4: 發送數據
print "Enter data to transmit: "
data = sys.stdin.readline().strip()
s.sendall(data)
# Step5: 接收伺服器發過來的數據
print "Looking for replies; press Ctrl-C or Ctrl-Break to stop"
while 1:
buf = s.recv(2048)
if not len(buf):
break
sys.stdout.write(buf)

這個例子就是這么簡單，實現起來和C語言版的差不多。看來，只要是了解socket編程的，用不同的語言實現也會相差無幾。

⑶ python socket客戶端怎麼實現斷線重連 求代碼示範 謝謝

斷線重連不是問題，問題是如何判斷斷線。

判斷斷線一般通過異常處理，當然也可以傻瓜式的只要有操作就重連。

下面是一個只要沒有成功連接就重連的簡單實現

importsocket
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
whileTrue:
try:
s.connect(('127.0.0.1',80))
break
except:
print('retry...')
continue
print('connected.')
s.close()

⑷ 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."

⑸ 關於Python中socket問題。

HOST='localhost'#如果要兩台電腦遠程通訊，這里應該綁定什麼？

所謂host，就是主機地址。本地使用 'localhost' 會被映射為 '127.0.0.1'的，也就是本機。
不同主機相互通信呢？直接使用 區域網地址即可。比如 (本機)192.168.1.2 (其他電腦)192.168.1.3 然後本機做主機：HOST='192.168.1.2'

換句話說：客戶端的機器 必須能夠連接 主機。 在(其他電腦) "ping 192.168.1.2" 必須能ping通。
那麼 不在同一個區域網的怎麼辦？那就必須使用 外網IP了，或者域名。或者使用類似「花生殼」等軟體，進行主機映射也可以

⑹ 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()

⑺ python中使用socket編程，如何能夠通過UDP傳遞一個列表類型的數據

Python中的 list 或者 dict 都可以轉成JSON字元串來發送，接收後再轉回來。

首先

importjson

然後，把 list 或 dict 轉成 JSON

json_string=json.mps(list_or_dict)

如果你用的是Python3，這里的 json_string 會是 str 類型（即Python2的unicode類型），可能需要編碼一下：

if type(json_string) == six.text_type:

json_string = json_string.encode('UTF-8')

用socket發送過去，例如

s.sendto(json_string,address)

對方用socket接收，例如

json_string,addr=s.recvfrom(2048)

把JSON轉成 list 或 dict

list_or_dict=json.loads(json_string)

下面是個完整的例子：

client.py

#!/usr/bin/envpython
#-*-coding:UTF-8-*-

importsocket
importjson
importsix

address=('127.0.0.1',31500)
s=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
mylist=[1,2,3,4,5,6,7,8,9,10]
json_string=json.mps(mylist)
iftype(json_string)==six.text_type:
json_string=json_string.encode('UTF-8')
s.sendto(json_string,address)
s.close()

server.py

#!/usr/bin/envpython
#-*-coding:UTF-8-*-

importsocket
importjson

address=('127.0.0.1',31500)
s=socket.socket(socket.AF_INET,socket.SOCK_DGRAM)
s.bind(address)
json_string,addr=s.recvfrom(2048)
mylist=json.loads(json_string)
print(mylist)
s.close()

請先運行server.py，再運行client.py

⑻ python-socketio 文檔翻譯

教程： https://tutorialedge.net/python/python-socket-io-tutorial/

python-socketio 原文地址 ，在google瀏覽器中可以翻譯為中文去使用。

首先要搞明白幾個問題：

說明
1）第一種room是每一個單獨的客戶端都有的。（通過 session ID 可以找到）
2）第二種是應用程序自己創建的。
在下面這個方法中，如果省略掉room參數，將會自動發送給所有的連接了的客戶端。

譯文：

Python-socketio實現了一個Python Socket.IO 服務，這個服務可以單獨運行也可以綜合於一個web項目中。下面是一些它的特徵：

什麼是Socket.IO?

Socket.IO是一個基於事件的雙向通訊的傳輸協議（一般是web瀏覽器），和一個服務端。原始的客戶端和服務端組件實現是通過JavaScript寫的。

入門指南

可以使用 pip 安裝Socket.IO:

下面是一個使用 aiohttp 框架（只支持Python 3.5+）實現非同步IO的 Socket.IO server 簡單的例子：

下面是一個類似的例子，但是使用的Flask和Eventlet的例子，兼容Python2.7和3.3+：

客戶端應用必須引入 socket.io-client 庫（1.3.5版本以及以上，越高越好）。

每次客戶端連接到伺服器的連接事件處理程序調用sid(會話ID)分配給連接和WSGI環境字典。

每次客戶端連接到服務端的 conenct 事件都是由sid(session ID)分配到連接和WSGI環境字典調用的。服務端可以檢查身份認證或者其他的頭部信息去決定是否這個客戶端允許被連接。要想拒絕一個客戶端的連接，這個處理器必須返回 False 。

當客戶端發送發送一個事件給服務端，相應的事件處理器會被 sid 和這個信息調用，可以是單個或者多個參數。這個應用可以定義盡量多的如果被需要的可以被事件處理器關聯的事件。一個事件可以通過一個名稱簡單定義。

當一個客戶端連接中斷了， disconnect 事件就被調用，允許應用去執行清理工作。

服務端

Socket.IO 服務端是 socketio.Server 類的實例，他們可以被一個WSGI適用應用程序使用 socketio.Middleware 去合並：

使用 socketio.Server.on() 方法來注冊服務端的事件處理器：

對於非同步服務端來說，事件處理器可以是常規方法，或者是協程：

聊天室

因為Socket.IO是一個雙向的協議，服務端可以在任意時間發送消息給任意的連接到的客戶端。為了讓它方便去將客戶端定位到組中，應用程序可以將客戶端放入到聊天室中去，然後將消息定位到整個聊天室中。

當客戶端第一次連接，他們是被分配到他們自己的聊天室中，這個聊天是是以session ID（sid 參數會傳遞給所有的事件處理器）命名的。應用可以通過 socketio.Server.enter_room() 和 socketio.Server.leave_room() 自由地去創建聊天室和管理客戶端。客戶端可以在盡量多的房間里，也可以根據需求盡量頻繁地被拉入拉出聊天室。當他們的連接不在特別的時候，單獨的聊天室將會分配給她它們，應用程序可以自由地增加和移除客戶端從聊天室中，盡管它只要這樣做就會失去定位獨立客戶端的能力。

socketio.Server.emit() 方法會獲得一個事件名稱，一個可能是 str ， bytes ， list ， dict 或者 tuple 類型的消息載體。當發送一個 tuple ，在其中的元素必須是上面的其他類型。元組中的元素將會被傳遞給客戶端的回調函數為多個參數。定位一個個人客戶端，客戶端的 sid 將會被給一個聊天室（假設這個應用沒有修改這些初始的聊天室）。定位所有的連接的客戶端們，這個聊天室參數將會被觸發。

通常在聊天室中當廣播一個消息到一個用戶組的時候，發送者是否接受他自己的消息是可選的。 soicketio.Server.emit() 方法提供了一個可選的 skip_sid 參數去指定一個想在廣播中跳過的客戶端。

Response

當一個客戶端發送一個事件給服務端，它可以選擇提供一個回調方法，當服務端返回一個響應的時候會被觸發。服務端可以便捷地從相應的事件處理器返回它從而提供一個響應。

事件處理器可以返回一個單獨的值，一個帶多個值的元組。這個在客戶端的回調函數將會調用這些返回的值。

Callbacks
回調

服務端可以請求一個響應通過發送一個事件給客戶端。 socketio.Server.emit() 方法有一個可選的 callback 參數能夠被設置為可回調的。當這個參數被傳遞之後，當客戶端返回相應的時候，這個可回調的方法將會被請求。

當廣播給多個客戶端的時候使用回調函數是不被推薦的，因為回調方法將會被只執行一次。

Namespace
命名空間

Socket.IO 協議支持多個邏輯性連接，所有的多路復用都是在相同的物理連接上。客戶端可以通過給每個連接指定不同的 namespace 從而開多個連接。一個命名空間是由 主機名+埠+路徑名稱構成的。比如，連接到 http://example.com:8000/chat 將會開一個連接到命名空間 /chat 。

由於分離的不同的session ID（ sid s），不同的事件處理器，不同的聊天室，每一個命名空間都是獨立的。應用程序使用多個命名空間從而來區分命名空間，是非常重要的。可以參考 socketio.Server 類。

當 namespace 參數被觸發了，比如設置為 None 或者 / ， 那麼一個默認的命名空間將會被使用。

Class-Based Namespaces

作為一個基於裝飾器的事件處理器的代替，這個屬於一個命名空間事件處理器可以被創建為 socketio.Namesapce 的子類：

對於基於非同步io的服務端，域名空間必須繼承與 socketio.AsyncNamespace ， 也可以定義普通的方法或者協程作為事件處理器：

當使用基於類的命名空間的時候，任何被服務端接受的事件將會被分派到一個被事件名稱命名的方法中作為方法名稱（with the on_pfrefix ）。比如：事件 my_event 將會被一個名叫 on_my_event 的方法處理。

⑼ python怎樣建立socket伺服器

下面的例子是多線程實現的socket伺服器：

import socketimport threadingclass ThreadedServer(object):
def __init__(self, host, port):
self.host = host
self.port = port
self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.sock.bind((self.host, self.port))

def listen(self):
self.sock.listen(5)
while True:
client, address = self.sock.accept()
client.settimeout(60)
threading.Thread(target = self.listenToClient,args = (client,address)).start()

def listenToClient(self, client, address):
size = 1024
while True:
try:
data = client.recv(size)
if data:
# Set the response to echo back the recieved data
response = data
client.send(response)
else:
raise error('Client disconnected')
except:
client.close()
return Falseif __name__ == "__main__":
while True:
port_num = input("Port? ")
try:
port_num = int(port_num)
break
except ValueError:
pass

ThreadedServer('',port_num).listen()