对于pythonsocket编程的初探

import socket
import sys

HOST = "127.0.0.1" 
PORT = 10000 
s = None
for res in socket.getaddrinfo(HOST, PORT, socket.AF_UNSPEC,
 socket.SOCK_STREAM, 0, socket.AI_PASSIVE):
 af, socktype, proto, canonname, sa = res
 try:
 s = socket.socket(af, socktype, proto)
 except socket.error as msg:
 s = None
 continue
 try:
 s.bind(sa)
 s.listen(5)
 except socket.error as msg:
 s.close()
 s = None
 continue
 break
if s is None:
 print 'could not open socket'
 sys.exit(1)
conn, addr = s.accept()
print 'Connected by', addr
while 1:
 data = conn.recv(1024)
 if not data: break
 conn.send(data)
conn.close()

s = socket.socket(af, socktype, proto)

s.bind(sa)

s.listen(5)

conn, addr = s.accept()

 data = conn.recv(1024) # 接收数据, 这里指定一次最多接收的字符数量为1024
 conn.send(data) # 发送数据

for res in socket.getaddrinfo(HOST, PORT, socket.AF_UNSPEC, socket.SOCK_STREAM):
 af, socktype, proto, canonname, sa = res
 try:
 s = socket.socket(af, socktype, proto)
 except socket.error as msg:
 s = None
 continue
 try:
 s.connect(sa)
 except socket.error as msg:
 s.close()
 s = None
 continue
 break
if s is None:
 print 'could not open socket'
 sys.exit(1)
s.sendall('Hello, world')
data = s.recv(1024)
s.close()
print 'Received', repr(data)

socket.sendto(string, flags, address)
socket.recvfrom(bufsize[, flags]) #返回(string, address)，string是返回的数据，address是发送方的socket地址

import SocketServer

class MyTCPHandler(SocketServer.StreamRequestHandler):
 """创建请求处理类，重写handle方法。此外也可以重写setup()和finish()来做一些请求处理前和处理后的一些工作"""
 def handle(self):
 # self.request is the TCP socket connected to the client
 self.data = self.request.recv(1024).strip()
 print "{} wrote:".format(self.client_address[0])
 print self.data
 # just send back the same data, but upper-cased
 self.request.sendall(self.data.upper())

if __name__ == "__main__":
 HOST, PORT = "localhost", 10000

 server = SocketServer.TCPServer((HOST, PORT), MyTCPHandler)

 # Activate the server; this will keep running until you
 # interrupt the program with Ctrl-C
 # server.shutdown()
 server.serve_forever() # 一直循环接收请求
 # server.handle_request() # 只处理一次请求就退出

def serve_forever(self, poll_interval=0.5):
 """Handle one request at a time until shutdown.

 Polls for shutdown every poll_interval seconds. Ignores
 self.timeout. If you need to do periodic tasks, do them in
 another thread.
 """
 self.__is_shut_down.clear()
 try:
 while not self.__shutdown_request:
 # XXX: Consider using another file descriptor or
 # connecting to the socket to wake this up instead of
 # polling. Polling reduces our responsiveness to a
 # shutdown request and wastes cpu at all other times.
 r, w, e = _eintr_retry(select.select, [self], [], [],
 poll_interval)
 if self in r:
 self._handle_request_noblock()
 finally:
 self.__shutdown_request = False
 self.__is_shut_down.set()

class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
 pass

def process_request(self, request, client_address):
 """Start a new thread to process the request."""
 t = threading.Thread(target = self.process_request_thread,
 args = (request, client_address))
 t.daemon = self.daemon_threads
 t.start()

import socket
import threading
import SocketServer

class ThreadedTCPRequestHandler(SocketServer.BaseRequestHandler):

 def handle(self):
 data = self.request.recv(1024)
 cur_thread = threading.current_thread()
 response = "{}: {}".format(cur_thread.name, data)
 self.request.sendall(response)

class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
 pass

def client(ip, port, message):
 sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 sock.connect((ip, port))
 try:
 sock.sendall(message)
 response = sock.recv(1024)
 print "Received: {}".format(response)
 finally:
 sock.close()

if __name__ == "__main__":
 # Port 0 means to select an arbitrary unused port
 HOST, PORT = "localhost", 0

 server = ThreadedTCPServer((HOST, PORT), ThreadedTCPRequestHandler)
 ip, port = server.server_address

 # Start a thread with the server -- that thread will then start one
 # more thread for each request
 server_thread = threading.Thread(target=server.serve_forever)
 # Exit the server thread when the main thread terminates
 server_thread.daemon = True
 server_thread.start()
 print "Server loop running in thread:", server_thread.name

 client(ip, port, "Hello World 1")
 client(ip, port, "Hello World 2")
 client(ip, port, "Hello World 3")

 server.shutdown()
 server.server_close()