pythonsendsendall

㈠ 如何用python編寫一個聊天室

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

暫時先給出兩種版本的,tcp+udp

都是分別運行server.py和client.py，就可以進行通訊了。

別外還有websocket版本，這個是有web界面的和基本web服務的，如果需要的話，我會把基本的代碼貼一版上來。

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程序中發郵件

通過命令行發送郵件，功能強大
python ./mail -s $server -f $from -t $to -u $user -p $pass -S "$subject" -m "${mail_msg}" -F $file
Python 發送郵件可以添加附件：
#!/usr/bin/python
from email.MIMEText import MIMEText
from email.MIMEMultipart import MIMEMultipart
from email.MIMEBase import MIMEBase
from email import Utils, Encoders
import mimetypes, sys,smtplib,socket,getopt
class SendMail:
def __init__(self,smtp_server,from_addr,to_addr,user,passwd):
self.mailserver=smtp_server
self.from_addr=from_addr
self.to_addr=to_addr
self.username=user
self.password=passwd
def attachment(self,filename):
fd=open(filename,'rb')
filename=filename.split('/')
mimetype,mimeencoding=mimetypes.guess_type(filename[-1])
if (mimeencoding is None) or (mimetype is None):
mimetype='application/octet-stream'
maintype,subtype=mimetype.split('/')
if maintype=='text':
retval=MIMEText(fd.read(), _subtype=subtype, _charset='utf-8')
else:
retval=MIMEBase(maintype,subtype)
retval.set_payload(fd.read())
Encoders.encode_base64(retval)
retval.add_header('Content-Disposition','attachment',filename=filename[-1])
fd.close()
return retval
def msginfo(self,msg,subject,filename):
# message = """Hello, ALL
#This is test message.
#--Anonymous"""
message=msg
msg=MIMEMultipart()
msg['To'] = self.to_addr
msg['From'] = 'sa <'+self.from_addr+'>'
msg['Date'] = Utils.formatdate(localtime=1)
msg['Message-ID'] = Utils.make_msgid()
if subject:
msg['Subject'] = subject
if message:
body=MIMEText(message,_subtype='plain')
msg.attach(body)
#for filename in sys.argv[1:]:
if filename:
msg.attach(self.attachment(filename))
return msg.as_string()
def send(self,msg=None,subject=None,filename=None):
try:
s=smtplib.SMTP(self.mailserver)
try:
s.login(self.username,self.password)
except smtplib.SMTPException,e:
print "Authentication failed:",e
sys.exit(1)
s.sendmail(self.from_addr,self.to_addr.split(','),self.msginfo(msg,subject,filename))
except (socket.gaierror,socket.error,socket.herror,smtplib.SMTPException),e:
print "*** Your message may not have been sent!"
print e
sys.exit(2)
else:
print "Message successfully sent to %d recipient(s)" %len(self.to_addr)
if __name__=='__main__':
def usage():
print """Useage:%s [-h] -s <SMTP Server> -f <FROM_ADDRESS> -t <TO_ADDRESS> -u <USER_NAME> -p <PASSWORD> [-S <MAIL_SUBJECT> -m <MAIL_MESSAGE> -F <ATTACHMENT>]
Mandatory arguments to long options are mandatory for short options too.
-f, --from= Sets the name of the "from" person (i.e., the envelope sender of the mail).
-t, --to= Addressee's address. -t "[email protected],[email protected]".
-u, --user= Login SMTP server username.
-p, --pass= Login SMTP server password.
-S, --subject= Mail subject.
-m, --msg= Mail message.-m "msg, ......."
-F, --file= Attachment file name.

-h, --help Help documen.
""" %sys.argv[0]
sys.exit(3)
try:
options,args=getopt.getopt(sys.argv[1:],"hs:f:t:u:p:S:m:F:","--help --server= --from= --to= --user= --pass= --subject= --msg= --file=",)
except getopt.GetoptError:
usage()
sys.exit(3)

server=None
from_addr=None
to_addr=None
username=None
password=None
subject=None
filename=None
msg=None
for name,value in options:
if name in ("-h","--help"):
usage()
if name in ("-s","--server"):
server=value
if name in ("-f","--from"):
from_addr=value
if name in ("-t","--to"):
to_addr=value
if name in ("-u","--user"):
username=value
if name in ("-p","--pass"):
password=value
if name in ("-S","--subject"):
subject=value
if name in ("-m","--msg"):
msg=value
if name in ("-F","--file"):
filename=value
if server and from_addr and to_addr and username and password:
test=SendMail(server,from_addr,to_addr,username,password)
test.send(msg,subject,filename)
else:
usage()

㈢ 如何使用python立即發送http請求參數

1 首先安裝requests這個模塊，方法是 輸入pip install requests。當然你要裝好pip這個包管理器。

2 然後
import requests
url = " " # 這里是你的url
your_param = {'Refer':"sina_index"} # 這里是你要發送的請求參數！， 它在url後邊加上 ??Refer=sina_index這樣子的東東

result = requests.get(url, param = your_param) # 發送請求，如果url是http://s.weibo.com/weibo/s 那麼 這句話的的效果就是 http://s.weibo.com/weibo/s?Refer=sina_index
result_final = result.text #這樣你就獲取到了你發送的這個URL + 參數 之後的結果

全部手打的，採納唄。

㈣ 關於python socket的問題。。

1. 代碼問題

先鎖定問題出處，client端還是server端：

client端：client端試試用sendall發送

server端：試試用telnet連接server端，多次輸入數據，檢查server端是否能受到。

建議貼出client和server代碼。

2. 其它問題

一般默認設置下TCP鏈接不會在5秒內中斷。如果排除了代碼問題，那麼抓包看數據是否正常發送和接收。關掉防火牆再試。如果server和client不在一起，考慮路由上的所有節點。

㈤ 有關python聊天程序

代碼簡單，直接看代碼吧:

復制代碼代碼如下:

import socket
import threading
import re
#import Tkinter

def ser():
s=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
s.bind(('',33333))
s.listen(1)
conn,addr=s.accept()
while True:
print '[%s:%d] send a message to me: %s'%(addr[0],addr[1],conn.recv(1024))
s.close()
def clt():
c=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
ip_pattern=re.compile(r'^(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])\.(\d{1,2}|1\d\d|2[0-4]\d|25[0-5])$')
while True:
ip=raw_input('Input the Server\'s IPv4 address:')
ip_match=ip_pattern.match(ip)
if ip_match:
break
c.connect((ip,33333))
while True:
sms=raw_input('Input the message you want to send:')
c.sendall(sms)
c.close()
if __name__=="__main__":
ser=threading.Thread(target=ser)
clt=threading.Thread(target=clt)
ser.start()
clt.start()
ser.join()
clt.join()

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

㈦ python3 socket的send方法如何發送數據

用如下代碼：

name='bruce'
s.send(b'hihi'+name.encode())

要把name變成二進制才能拼接

望採納

㈧ linux python socket怎麼去除

原因是server端關掉了tcp連接，給client發送FIN信號，client的tcp層回了ACK，然後它的socket狀態就處於close_wait狀態。

實驗：

Python中，socket在send之前處於close_wait狀態，那麼該send不會報錯，並且執行完之後socket就closed了。再繼續調用send就會報錯。

推理：

說明python的socket.send在發送數據之前會檢查socket的狀態，如果處於close_wait，就執行close(socket)（應用層感覺不到哦），然後正常退出。所以再次send時，會拋出異常。

為什麼會一直處close_wait狀態？

當socket處於close_wait時，必須由應用層調用close(socket)，發送FIN給server端才能變為LAST_ACK，接收到server端回應的ACK後，才變為CLOSED。如果應用層不調用close()，那麼socket會一直處於close_wait。[1]

如果我在python中不斷循環去調用socket.sendall()，那麼在socket變為close_wait後，通過socket.sendall()也會關閉socket，為什麼它還是一直處在close_wait狀態呢？

原因在於當sendall(data)的data比較大，在data被發送一半時，連接被server端斷掉了。那麼sendall(data)會一直卡在那，也就不會執行到sendall的開始處，去判斷socket狀態，確定是否關閉socket了。

簡單而言，就是socket在變為close_wait之後，根本沒有調用sendall()去關閉socket。

㈨ python怎麼安裝sendmail

Python已經被移植在許多平台上（經過改動使它能夠工作在不同平台上）。

您需要下載適用於您使用平台的二進制代碼，然後安裝Python。

如果您平台的二進制代碼是不可用的，你需要使用C編譯器手動編譯源代碼。

編譯的源代碼，功能上有更多的選擇性， 為python安裝提供了更多的靈活性。。。