1、TCP编程
2、SocketServer模块
3、Twisted框架
4、UDP编程
1、TCP编程——TCP是面向连接的，其一般的设计如下：
# encoding:utf-8
‘‘‘
Created on 2014-6-20
@author: Administrator
‘‘‘
from socket import socket, AF_INET, SOCK_STREAM
import time
import threading
class SockServer(object):
def __init__(self, port):
self.HOST = "localhost"
self.PORT = port
self.SOCK = (self.HOST, self.PORT)
self.BUF = 1024
self._init()
def _init(self):
self.sock_server = socket(AF_INET, SOCK_STREAM)
self.sock_server.bind(self.SOCK)
self.sock_server.listen(100)
def __thread_process(self, sock_client, client_addr):
print "connected :", sock_client.getpeername()
while True:
data = sock_client.recv(self.BUF)
if not data:
continue
elif data == "bye":
print "<< %s" % data
break
else:
sock_client.send(‘[%s] %s‘ % (time.ctime(), data))
print "%s << %s: %s" % (sock_client.getsockname(), client_addr, data)
sock_client.close()
"""多线程并发服务器"""
def process(self):
while True:
print "waiting for connection..."
(sock_client, client_addr) = self.sock_server.accept()
threading.Thread(target=self.__thread_process, args=(sock_client, client_addr)).start()
def __del__(self):
self.sock_server.close()
if __name__ == "__main__":
port = 12345
server = SockServer(port)
server.process()
客户端一般设计：
# encoding:utf-8
‘‘‘
Created on 2014-6-20
@author: Administrator
‘‘‘
from socket import socket, AF_INET, SOCK_STREAM
class SockClient(object):
def __init__(self, ip, port):
self.IP = ip
self.PORT = port
self.SOCK = (ip, port)
self.BUF = 1024
self._init()
def _init(self):
self.sock_client = socket(AF_INET, SOCK_STREAM)
def process(self):
print "connecting server..."
self.sock_client.connect(self.SOCK)
while True:
data = raw_input(">>")
self.sock_client.send(data)
if data.strip() == "bye":
break
recv_data = self.sock_client.recv(self.BUF)
if not recv_data:
print "no recv!"
else:
print recv_data
def __del__(self):
self.sock_client.close()
if __name__ == "__main__":
ip = "localhost"
port = 12345
client = SockClient(ip, port)
client.process()
2、SocketServer模块——用于简化实现网络编程客户端与服务器所需要的大量样板代码。
2.1 创建一个SocketServerTCP服务器：
# encoding:utf-8
‘‘‘
Created on 2014-6-23
@author: Administrator
‘‘‘
from time import ctime
from SocketServer import TCPServer, StreamRequestHandler
"""
SocketServer 的请求处理器默认行为时接收连接，得到请求，然后关闭连接，这使得我们不能
在程序运行时，一直保持连接状态，而是每次发送数据到服务器的时候创建一个新的套接字
"""
class MyRequestHandle(StreamRequestHandler):
"""
客户端有消息发来时，handle函数会被调用
"""
def handle(self):
print "...connecting from :", self.client_address
self.wfile.write(‘[%s] %s‘ % (ctime(), self.rfile.readline()))
if __name__ == "__main__":
ip = "localhost"
port = 12345
tcpServ = TCPServer((ip, port), MyRequestHandle)
print "waiting for connection..."
tcpServ.serve_forever()
说明：
1、这里的主要工作是从SocketServer的StreamRequestHandler类派生出一个子类，并重写handle()函数。
在有客户端消息近来的时候，handle()函数就会被调用，如上是一个使用SocketServer模块的回射服务器例子。
2、SocketServer的请求处理器的默认行为时接收连接，得到请求，然后关闭连接，这使得我们不能再程序运行时，一致保持连接状态，
而是每次发送数据到服务器的时候都要创建一个新的套接字。
2.2 创建一个SocketServerTCP客户端：
# encoding:utf-8
‘‘‘
Created on 2014-6-23
@author: Administrator
‘‘‘
from socket import socket, AF_INET, SOCK_STREAM
class SocketClient(object):
def handle(self, ADDR):
BUF = 1024
while True:
self.client = socket(AF_INET, SOCK_STREAM)
self.client.connect(ADDR)
data = raw_input(">>")
if not data:
break
self.client.send("%s\r\n" % data) #服务端使用的是readline，为了保持一致，发送添加了换行
rcv_data = self.client.recv(BUF)
if not rcv_data:
break
else:
print rcv_data.strip()
self.client.close()
self.client.close()
if __name__ == "__main__":
ip = "localhost"
port = 12345
client = SocketClient()
client.handle((ip, port))
说明：
1、本例子是针对使用SocketServer的服务端的例子，其中send（）函数需要添加”\r\n”换行符，对应于服务器端的readline()函数
2、发送数据之后，断开连接，因为SocketServer的默认行为使得不能再程序运行时，一致保持连接状态
运行结果：
服务端：
客户端：
3、Twisted框架
简介——Twisted是一个完全事件驱动的网络框架，允许使用和开发完全异步的网络应用程序和协议。
3.1 安装Twisted扩展（Windows）
下载：Twisted和zope
http://twistedmatrix.com/trac/wiki/Downloads
安装Twisted扩展（Linux）
命令：easy_install twisted
eclipse pydev添加twisted模块：
系统已经安装twisted模块，导入twisted，引用其中的方法时，出现如下情况：
解决方法是：
在Eclipse的Window—Preferences—PyDev—Interpreter-Python 窗口下的Forced Buildins添加twisted
即可正常引用twisted包
3.2 Twisted服务端：
# encoding:utf-8
‘‘‘
Created on 2014-6-23
@author: Administrator
‘‘‘
from twisted.internet import reactor, protocol
from time import ctime
"""
Twisted 是一个完全事件驱动的网络框架，允许使用和开发完全异步的网络应用程序和协议
"""
class TwistedServer(protocol.Protocol):
"""
重写connectionMade函数，该函数在有客户端连接时被调用
"""
def connectionMade(self):
client = self.client = self.transport.getPeer().host
print "...connected from ", client, ":", self.transport.getPeer().port
"""
该函数在客户端通过网络发送数据过来时被调用
"""
def dataReceived(self, data):
self.transport.write("[%s] %s" % (ctime(), data))
if __name__ == "__main__":
port = 12345
factory = protocol.Factory()
factory.protocol = TwistedServer
print "waiting for connection..."
reactor.listenTCP(port, factory)
reactor.run()
说明：
Twistede服务端从Protocol类派生子类，然后重写connectionMade()函数，这个函数在有客户端连接的时候被调用，dataReceived（）函数，这个函数在客户端
通过网络发送数据过来的时候被调用，reactor把数据当成参数传到这个函数中
3.3 Twisted客户端
# encoding:utf-8
‘‘‘
Created on 2014-6-23
@author: Administrator
‘‘‘
from twisted.internet import protocol, reactor
class TwistedClient(protocol.Protocol):
def _senddata(self):
data = raw_input(">>")
if data:
print "...sending %s..." % data
self.transport.write(data)
else:
self.transport.loseConnection()
#连接建立之后，调用自定义_senddata函数
def connectionMade(self):
self._senddata()
def dataReceived(self, data):
print data
self._senddata()
class TClientFactory(protocol.ClientFactory):
protocol = TwistedClient
clientConnectionLost = clientConnectionFailed = lambda self, connector, reason:reactor.stop()
if __name__ == "__main__":
host = "localhost"
port = 12345
reactor.connectTCP(host, port, TClientFactory())
reactor.run()
说明：
Twisted客户端也从Protocol派生子类，重写connectionMade()和dataReceived()函数，当用户没有任何输入时（参考如上代码中_senddata()函数中else部分），连接结束，结束时，调用loseConnection关闭套接字，这时工厂的clientConnectionLost函数会被调用，同时reactor就被关闭，脚本执行就结束了，由于某些原因，clientConnectionFailed()被调用时，reactor也会被关闭。
4. UDP 编程
UDP是无连接的，服务器一般设计如下：
4.1 服务器端编程
# encoding:utf-8
‘‘‘
Created on 2014-6-20
@author: Administrator
‘‘‘
from socket import socket, AF_INET, SOCK_DGRAM
from time import ctime
class DgramServer(object):
def __init__(self, port):
self.HOST = "localhost"
self.PORT = port
self.SOCK = (self.HOST, self.PORT)
self.BUF = 1024
self._init()
def _init(self):
self.dgram_server = socket(AF_INET, SOCK_DGRAM)
self.dgram_server.bind(self.SOCK)
def process(self):
print "waiting for message..."
while True:
data, addr = self.dgram_server.recvfrom(self.BUF)
print "<<",addr, ":%s " % data
if data == "bye":
break
self.dgram_server.sendto("[%s,%s]" % (ctime(), data), addr)
def __del__(self):
self.dgram_server.close()
if __name__ == "__main__":
port = 12345
dgram = DgramServer(port)
dgram.process()
注意：
UDP服务端，recvfrom会返回连接的地址
4.2 客户端编程
# encoding:utf-8
‘‘‘
Created on 2014-6-20
@author: Administrator
‘‘‘
from socket import socket, AF_INET, SOCK_DGRAM
class DgramClient(object):
def __init__(self, ip, port):
self.HOST = ip
self.PORT = port
self.SOCK = (self.HOST, self.PORT)
self.BUF = 1024
self._init()
def _init(self):
self.dgram_client = socket(AF_INET, SOCK_DGRAM)
def process(self):
while True:
data = raw_input("<<")
self.dgram_client.sendto(data, self.SOCK)
if data == "bye":
break
recv_data, dgram = self.dgram_client.recvfrom(self.BUF)
if not recv_data:
print "no recv"
else:
print ">>", dgram, ":%s" % recv_data
def __del__(self):
self.dgram_client.close()
if __name__ == "__main__":
ip = "localhost"
port = 12345
dgram = DgramClient(ip, port)
dgram.process()
运行结果：
服务端：
客户端1：
客户端2：
【Python】网络编程
时间： 2024-12-05 18:10:06