pythonsocketntohl

① python socket半雙工聊天怎麼運行

#coding=utf-8
importsocket#載入socket模塊
fromtimeimportctime#載入time模塊ctime類

HOST=''#設置主機IP，為空則表示本機上所有的網卡ip。
PORT=3300#設置埠號
BUSIZ=1024#設置數據緩沖區，1KB
ADDR=(HOST,PORT)

defcloseTCnt():#
TCntSock.close()
print"Sessionclosing.."

TSerSock=socket.socket(socket.AF_INET,socket.SOCK_STREAM)#創建一個TCPsokcet
TSerSock.bind(ADDR)#綁定TCPsocket的地址和埠
TSerSock.listen(1)#只接收一個請求，如後續後其他請求則會被拒絕
try:
whileTrue:
print'Waittingforconnection...'
(TCntSock,cntAddr)=TSerSock.accept()#TSerSock.accept返回一個(conn,addr)的元組。conn是一個socket對象，而addr是客戶端IP地址和埠
print'...connectionfrom:',cntAddr

try:

whileTrue:
rData=TCntSock.recv(BUSIZ)#接收客戶端信息
ifnotrData:
continue
elifrData=='quit':#當收到『quit』後關閉TCntSock並等待下一次鏈接
break
else:
print'From[%s]%s
%s'%(cntAddr[0],ctime(),rData)


whileTrue:
sData=raw_input('I:>')
ifnotsData:
continue
else:
TCntSock.send('From[%s]%s
%s'%
(cntAddr[0],ctime(),sData))#發送伺服器信息。
break

exceptsocket.error,detail:#發生錯誤是關閉TCntSock,輸出錯誤信息並等待下一次鏈接
printdetail
closeTCnt()

finally:
TSerSock.close()

#coding=utf-8
importsocket
HOST='localhost'#設置要鏈接的主機的IP
PORT=3300#設置要鏈接的主機埠號
BUFSIZ=1024#設置緩沖區大小，設定為1K
ADDR=(HOST,PORT)
tryCon=0

defTCnt():
tcpCliSock=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
whileTrue:
try:
tcpCliSock.connect(ADDR)#與服務端鏈接
except:
printu"正在嘗試連接遠程主機"
tryCon+=1
iftryCon==3:
printu"無法連接上遠程主機，請稍後再試"
exit()
else:
break
printu'登陸成功（通訊結束請輸入"quit"退出）
'

try:
whileTrue:
data=raw_input('I:>')
ifnotdata:
continue
elifdata=='quit':#通知服務端工作完成
tcpCliSock.send(data)
break
else:
tcpCliSock.send(data)

whileTrue:
data=tcpCliSock.recv(BUFSIZ)

ifnotdata:
continue
else:
printdata
break
exceptsocket.error,e:
print"Sessionclosing"
printe
tcpCliSock.close()

if__name__=="__main__":
TCnt()

② 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無法連接到本地 提示Connection refused

如果您安裝了最新的軟體包v1.8.1

在發行說明中有一些說你需要chmod一個啟動器文件

chmod +x /Users/_ENTER YOUR USERNAME_/Library/Application

Support/Sublime Text

3/Packages/OmniSharp/PrebuiltOmniSharpServer/omnisharp

④ 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對象，打包的結果也可以拿到套接字里發。

⑤ python 判斷是ipv6還是ipv4 inet

ipv4與ipv6地址如何轉換的python解決辦法

ipv4與ipv6地址如何轉換的python解決辦法。要想知道ipv4與ipv6地址轉換的問題，首先要了解它的概念。

ipv4與ipv6地址是什麼簡單的來說一下：
IPv4：是互聯網協議的第四版,同時也是第一個被廣泛使用，構成現今互聯網技術的基石的協議；
IPv6：是互聯網工程任務組設計的用於替代現行版本IPv4的下一代IP協議；
目前IP協議的版本號是IPv4，它的下一個版本就是IPv6。

ipv4與ipv6地址如何轉換的python解決辦法，源碼如下：（需要用到twisted.python.compat及struct和python socket方法）

import struct,socket
#import twisted.python.compat #導入twisted.python.compat 更方便

# ipv4數字地址
def ipv4_to_string(ipv4):
ipv4_n = socket.htonl(ipv4)
data = struct.pack('I', ipv4_n)
ipv4_string = socket.inet_ntop(socket.AF_INET, data)
return ipv4_string

def ipv4_from_string(ipv4_string):
data = socket.inet_pton(socket.AF_INET, ipv4_string)
ipv4_n = struct.unpack('I', data)
ipv4 = socket.ntohl(ipv4_n[0])
return ipv4

def ipv4_readable2int(ipv4):
return int(ipv4)

def ipv4_int2readable(ipv4):
return str(ipv4)

# ipv6用四個整數(tuple或用,分開的字元串)表示
def ipv6_to_string(ipv6):
ipv6_n = (socket.htonl(ipv6[0]),
socket.htonl(ipv6[1]),
socket.htonl(ipv6[2]),
socket.htonl(ipv6[3]))
data = struct.pack('IIII', ipv6_n[0], ipv6_n[1], ipv6_n[2], ipv6_n[3])
ipv6_string = socket.inet_ntop(socket.AF_INET6, data)

return ipv6_string

def ipv6_from_string(ipv6_string):
data = socket.inet_pton(socket.AF_INET6, ipv6_string)
ipv6_n = struct.unpack('IIII', data)
ipv6 = (socket.ntohl(ipv6_n[0]),
socket.ntohl(ipv6_n[1]),
socket.ntohl(ipv6_n[2]),
socket.ntohl(ipv6_n[3]))

return ipv6

def ipv6_tuple2readable(ipv6):
return str(ipv6[0]) + ',' + str(ipv6[1]) + ',' + str(ipv6[2]) + ',' + str(ipv6[3])

def ipv6_readable2tuple(ipv6):
return tuple(ipv6.split(','))

#win32 下實現 inet_pton 和 inet_ntop
def inet_ntop(family, ipstr):
if family== socket.AF_INET:
return socket.inet_ntoa(ipstr)
elif family== socket.AF_INET6:
v6addr = ':'.join(('%02X%02X' % (ord(i), ord(j)))
for i,j in zip(ipstr[::2], ipstr[1::2]))
return v6addr

#www.iplaypy.com

def inet_pton(family, addr):
if family== socket.AF_INET:
return socket.inet_aton(addr)

elif family== socket.AF_INET6:
if '.' in addr: # a v4 addr
v4addr = addr[addr.rindex(':')+1:]
v4addr = socket.inet_aton(v4addr)
v4addr = map(lambda x: ('%02X' % ord(x)), v4addr)
v4addr.insert(2, ':')
newaddr = addr[:addr.rindex(':')+1] + ''.join(v4addr)
return inet_pton(family, newaddr)
dbyts = [0]* 8 # 8 groups
grps = addr.split(':')

for i,v in enumerate(grps):
if v:
dbyts[i] = int(v, 16)
else:
for j, w in enumerate(grps[::-1]):
if w:
dbyts[7-j] = int(w, 16)
else:
break
break
return ''.join( (chr(i//256) + chr(i%256)) for i in dbyts)

else:
raise RuntimeError("What family?")

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

⑦ 請問下python網路編程的位元組序怎麼處理

多謝樓上的，不是這么處理的python發送的都是二進制的string串，對數字類型的數據可以使用struct模塊來實現，具體例子如下：struct.pack('>l',
3)這里是輸出一個整數3，>表示使用網路位元組序，l表示數據類型

⑧ Python中 socket 和 Queue有什麼區別

socket（計算機專業術語）：網路上的兩個程序通過一個雙向的通信連接實現數據的交換，這個連接的一端稱為一個socket。建立網路通信連接至少要一對埠號(socket)。socket本質是編程介面(API)，對TCP/IP的封裝，TCP/IP也要提供可供程序員做網路開發所用的介面，這就是Socket編程介面；HTTP是轎車，提供了封裝或者顯示數據的具體形式；Socket是發動機，提供了網路通信的能力。
queue（線性表）：隊列是一種特殊的線性表，是一種先進先出（FIFO）的數據結構。它只允許在表的前端（front）進行刪除操作，而在表的後端（rear）進行插入操作。進行插入操作的端稱為隊尾，進行刪除操作的端稱為隊頭。隊列中沒有元素時，稱為空隊列。而其在C++中的應用語法：queue類是為程序員提供了一個隊列的功能的容器適配器，具體而言，一個FIFO（先入先出）的數據結構；在頭文件<queue>中定義（在程序開頭輸入#include <queue>，切記不可寫為#include <queue.h>）。
望採納

⑨ Python 之 Socket編程(TCP/UDP)

socket(family,type[,protocal]) 使用給定的地址族、套接字類型、協議編號（默認為0）來創建套接字。

有效的埠號： 0～ 65535
但是小於1024的埠號基本上都預留給了操作系統
POSIX兼容系統(如Linux、Mac OS X等)，在/etc/services文件中找到這些預留埠與的列表

面向連接的通信提供序列化、可靠的和不重復的數據交付，而沒有記錄邊界。意味著每條消息都可以拆分多個片段，並且每個消息片段都能到達目的地，然後將它們按順序組合在一起,最後將完整的信息傳遞給等待的應用程序。
實現方式(TCP)：
傳輸控制協議（TCP）， 創建TCP必須使用SOCK_STREAM作為套接字類型
因為這些套接字（AF_INET）的網路版本使用網際網路協議(IP)來搜尋網路中的IP,
所以整個系統通常結合這兩種協議(TCP/IP)來進行網路間數據通信。

數據報類型的套接字, 即在通信開始之前並不需要建議連接,當然也無法保證它的順序性、可靠性或重復性
實現方式(UDP)
用戶數據包協議（UDP), 創建UDP必須使用SOCK_DGRAM (datagram)作為套接字類型
它也使用網際網路來尋找網路中主機，所以是UDP和IP的組合名字UDP/IP

注意點:
1）TCP發送數據時，已建立好TCP連接，所以不需要指定地址。UDP是面向無連接的，每次發送要指定是發給誰。
2）服務端與客戶端不能直接發送列表，元組，字典。需要字元串化repr(data)。

TCP的優點： 可靠，穩定 TCP的可靠體現在TCP在傳遞數據之前，會有三次握手來建立連接，而且在數據傳遞時，有確認、窗口、重傳、擁塞控制機制，在數據傳完後，還會斷開連接用來節約系統資源。

TCP的缺點： 慢，效率低，佔用系統資源高，易被攻擊 TCP在傳遞數據之前，要先建連接，這會消耗時間，而且在數據傳遞時，確認機制、重傳機制、擁塞控制機制等都會消耗大量的時間，而且要在每台設備上維護所有的傳輸連接，事實上，每個連接都會佔用系統的CPU、內存等硬體資源。 而且，因為TCP有確認機制、三次握手機制，這些也導致TCP容易被人利用，實現DOS、DDOS、CC等攻擊。

什麼時候應該使用TCP : 當對網路通訊質量有要求的時候，比如：整個數據要准確無誤的傳遞給對方，這往往用於一些要求可靠的應用，比如HTTP、HTTPS、FTP等傳輸文件的協議，POP、SMTP等郵件傳輸的協議。 在日常生活中，常見使用TCP協議的應用如下： 瀏覽器，用的HTTP FlashFXP，用的FTP Outlook，用的POP、SMTP Putty，用的Telnet、SSH QQ文件傳輸.

UDP的優點： 快，比TCP稍安全 UDP沒有TCP的握手、確認、窗口、重傳、擁塞控制等機制，UDP是一個無狀態的傳輸協議，所以它在傳遞數據時非常快。沒有TCP的這些機制，UDP較TCP被攻擊者利用的漏洞就要少一些。但UDP也是無法避免攻擊的，比如：UDP Flood攻擊……

UDP的缺點： 不可靠，不穩定 因為UDP沒有TCP那些可靠的機制，在數據傳遞時，如果網路質量不好，就會很容易丟包。

什麼時候應該使用UDP： 當對網路通訊質量要求不高的時候，要求網路通訊速度能盡量的快，這時就可以使用UDP。 比如，日常生活中，常見使用UDP協議的應用如下： QQ語音 QQ視頻 TFTP ……

⑩ python使用socket發送數據，沒有響應。

因為我不知道你的 SMGP_CLIENT 和你的GETREQUSTPACKET 怎麼實現的 我貼一下 發送數據的代碼吧 有問題你吧詳細的代碼貼上我看看

import socket

mysocket=socket.socket(socket.AF_INET,socket.SOCK_STREAM)

mysocket.connect(("192.168.5.30",80))

BUFFER_SIZE = 1024

buff="aaaaaaaaaaaa"

mysocket.send(buff)

print (mysocket.recv(BUFFER_SIZE))

mysocket.close()

因為是給 伺服器的80埠發數據 所以得到的返回值肯定是 無法找到頁面