1、Socket
socket起源於Unix，而Unix/Linux基本哲學之一就是“一切皆文件”，對於文件用【打開】【讀寫】【關閉】模式來操作。socket就是該模式的一個實現，socket即是一種特殊的文件，一些socket函數就是對其進行的操作（讀/寫IO、打開、關閉）
基本上，Socket 是任何一種計算機網絡通訊中最基礎的內容。例如當你在瀏覽器地址欄中輸入 http://www.cnblogs.com/ 時，你會打開一個套接字，然後連接到 http://www.cnblogs.com/ 並讀取響應的頁面然後然後顯示出來。而其他一些聊天客戶端如 gtalk 和 skype 也是類似。任何網絡通訊都是通過 Socket 來完成的。

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

2.3 socket編程思路

TCP服務端：
（1）創建套接字，綁定套接字到本地IP與端口

# socket.socket(socket.AF_INET,socket.SOCK_STREAM) , server.bind()

（2）開始監聽連接

# server.listen()

（3）進入循環，不斷接受客戶端的連接請求

# server.accept()

（4）然後接收傳來的數據，並發送給對方數據

# server.recv() , server.sendall()

（5）傳輸完畢後，關閉套接字

# server.close()

TCP客戶端:
（1）創建套接字，連接遠端地址

# socket.socket(socket.AF_INET,socket.SOCK_STREAM) , client.connect()

（2）連接後發送數據和接收數據

# client.sendall(), client.recv()

（3）傳輸完畢後，關閉套接字

# client.close()

Socket編程之服務端代碼：

import socket            # socket模塊
import commands     # 執行系統命令模塊
HOST=‘127.0.0.1‘
PORT=50007
server = socket.socket(socket.AF_INET,socket.SOCK_STREAM)   # 定義socket類型，網絡通信，TCP
server.bind((HOST,PORT))   # 套接字綁定的IP與端口
server.listen(1)           # 開始TCP監聽，1為最大等待連接數據
while True:
    conn,addr=server.accept()   # 接受TCP連接，並返回新的套接字與IP地址
    print‘Connected by‘,addr    # 輸出客戶端的IP地址
    while True:
        data=conn.recv(1024)    # 把接收的數據實例化
        # commands.getstatusoutput執行系統命令（即shell命令），返回兩個結果，第一個是狀態，成功則為0，第二個是執行成功或失敗的輸出信息
        cmd_status,cmd_result=commands.getstatusoutput(data)
        # 如果輸出結果長度為0，則告訴客戶端完成。此用法針對於創建文件或目錄，創建成功不會有輸出信息
        if len(cmd_result.strip()) ==0:
            conn.sendall(‘Done.‘)
        else:
    conn.sendall(cmd_result)   # 否則就把結果發給對端（即客戶端）
conn.close()     # 關閉連接

Socket編程之客戶端代碼：

import socket
HOST=‘127.0.0.1‘
PORT=50007
client=socket.socket(socket.AF_INET,socket.SOCK_STREAM)      # 定義socket類型，網絡通信，TCP
client.connect((HOST,PORT))       # 要連接的IP與端口
while 1:
       cmd=raw_input("Please input cmd:")       # 與人交互，輸入命令
       client.sendall(cmd)        # 把命令發送給對端
       data=client.recv(1024)     # 把接收的數據定義為變量
        print(data)               # 輸出變量
client.close()   # 關閉連接

3、程序缺限
這是一個簡單的socket通信，裏面存在一些bug
問題1. 在客戶端輸入回車，會掛死。
問題2. 客戶端斷開後，服務器端會提示異常報錯。
問題3. 服務端返回的數據大於1024，客戶端顯示不全，出現粘包問題。
問題4. 單進程，如果多個客戶端連接，要排隊，前一個斷開，後一個客戶端才能通信。
不想把代碼寫的太復雜，簡單的說下解決方案：
問題1. 在客戶端上判斷輸入為空，要求重新輸入。
問題2. 添加異常處理
問題3. 在客戶端上循環接收，直到接收完。但有沒有完客戶端是不知道的，需要服務端發一個結束符；或者是定制報頭（比較好的方法）。
問題4. 在服務端導入SocketServer模塊，使得每建立一個連接，就新創建一個線程。實現多個客戶端與服務端通信。

後期會針對上面問題單獨處理寫出總結

4、I/O多路復用
I/O（input/output），即輸入/輸出端口。每個設備都會有一個專用的I/O地址，用來處理自己的輸入輸出信息首先什麽是I/O？

I/O分為磁盤io和網絡io，這裏說的是網絡io
IO多路復用:
I/O多路復用指：通過一種機制，可以監視多個描述符(socket)，一旦某個描述符就緒（一般是讀就緒或者寫就緒），能夠通知程序進行相應的讀寫操作。
Linux
Linux中的 select，poll，epoll 都是IO多路復用的機制。
Linux下網絡I/O使用socket套接字來通信，普通I/O模型只能監聽一個socket，而I/O多路復用可同時監聽多個socket.
I/O多路復用避免阻塞在io上，原本為多進程或多線程來接收多個連接的消息變為單進程或單線程保存多個socket的狀態後輪詢處理.
Python
Python中有一個select模塊，其中提供了：select、poll、epoll三個方法，分別調用系統的 select，poll，epoll 從而實現IO多路復用。

Windows Python提供： select
Mac Python提供： select
Linux Python提供： select、poll、epoll

對於select模塊操作的方法：
句柄列表11, 句柄列表22, 句柄列表33 = select.select(句柄序列1, 句柄序列2, 句柄序列3, 超時時間)
參數： 可接受四個參數（前三個必須）
返回值：三個列表
select方法用來監視文件句柄，如果句柄發生變化，則獲取該句柄。
1. 當 參數1 序列中的句柄發生可讀時（accetp和read），則獲取發生變化的句柄並添加到 返回值1 序列中
2. 當 參數2 序列中含有句柄時，則將該序列中所有的句柄添加到 返回值2 序列中
3. 當 參數3 序列中的句柄發生錯誤時，則將該發生錯誤的句柄添加到 返回值3 序列中
4. 當 超時時間 未設置，則select會一直阻塞，直到監聽的句柄發生變化
5. 當 超時時間 ＝ 1時，那麽如果監聽的句柄均無任何變化，則select會阻塞 1 秒，之後返回三個空列表，如果監聽的句柄有變化，則直接執行。

import socket
import select
sk1 = socket.socket()
sk1.bind(("127.0.0.1",8001))
sk1.listen()
sk2 = socket.socket()
sk2.bind(("127.0.0.1",8002))
sk2.listen()
sk3 = socket.socket()
sk3.bind(("127.0.0.1",8003))
sk3.listen()
li = [sk1,sk2,sk3]
while True:
    r_list,w_list,e_list = select.select(li,[],[],1) # r_list可變化的
    for line in r_list: 
        conn,address = line.accept()
        conn.sendall(bytes("Hello World !",encoding="utf-8"))

服務端

sk1 = socket.socket()
sk1.bind(("127.0.0.1",8001))
sk1.listen()
inpu = [sk1,]
while True:
    r_list,w_list,e_list = select.select(inpu,[],[],1)
    for sk in r_list:
        if sk == sk1:
            conn,address = sk.accept()
            inpu.append(conn)
        else:
            try:
                ret = str(sk.recv(1024),encoding="utf-8")
                sk.sendall(bytes(ret+"hao",encoding="utf-8"))
            except Exception as ex:
                inpu.remove(sk)

客戶端

import socket
obj = socket.socket()
obj.connect((‘127.0.0.1‘,8001))
while True:
    inp = input("Please(q\退出):\n>>>")
    obj.sendall(bytes(inp,encoding="utf-8"))
    if inp == "q":
        break
    ret = str(obj.recv(1024),encoding="utf-8")
    print(ret)

服務端

import socket
sk1 = socket.socket()
sk1.bind(("127.0.0.1",8001))
sk1.listen()
inputs = [sk1]
import select
message_dic = {}
outputs = []
while True:
    r_list, w_list, e_list = select.select(inputs,[],inputs,1)
    print("正在監聽的socket對象%d" % len(inputs))
    print(r_list)
    for sk1_or_conn in r_list:
        if sk1_or_conn == sk1:
            conn,address = sk1_or_conn.accept()
            inputs.append(conn)
            message_dic[conn] = []
        else:
            try:
                data_bytes = sk1_or_conn.recv(1024)
                data_str = str(data_bytes,encoding="utf-8")
                sk1_or_conn.sendall(bytes(data_str+"好",encoding="utf-8"))
            except Exception as ex:
                inputs.remove(sk1_or_conn)
            else:
                data_str = str(data_bytes,encoding="utf-8")
                message_dic[sk1_or_conn].append(data_str)
                outputs.append(sk1_or_conn)
        for conn in w_list:
            recv_str = message_dic[conn][0]
            del message_dic[conn][0]
            conn.sendall(bytes(recv_str+"好",encoding="utf-8"))
        for sk in e_list:
            inputs.remove(sk)

客戶端

import socket
obj = socket.socket()
obj.connect((‘127.0.0.1‘,8001))
while True:
    inp = input("Please(q\退出):\n>>>")
    obj.sendall(bytes(inp,encoding="utf-8"))
    if inp == "q":
        break
    ret = str(obj.recv(1024),encoding="utf-8")
    print(ret)

5、socketserver
SocketServer內部使用 IO多路復用 以及 “多線程” 和 “多進程” ，從而實現並發處理多個客戶端請求的Socket服務端。即：每個客戶端請求連接到服務器時，Socket服務端都會在服務器是創建一個“線程”或者“進程” 專門負責處理當前客戶端的所有請求。
5.1 ThreadingTCPServer
ThreadingTCPServer實現的Soket服務器內部會為每個client創建一個 “線程”，該線程用來和客戶端進行交互。
ThreadingTCPServer基礎
使用ThreadingTCPServer:

• 創建一個繼承自 SocketServer.BaseRequestHandler 的類

• 類中必須定義一個名稱為 handle 的方法

• 啟動ThreadingTCPServer

import  socketserver
class Myserver(socketserver.BaseRequestHandler):
    def handle(self):
        conn = self.request
        conn.sendall(bytes("你好，我是機器人",encoding="utf-8"))
        while True:
            ret_bytes = conn.recv(1024)
            ret_str = str(ret_bytes,encoding="utf-8")
            if ret_str == "q":
                break
            conn.sendall(bytes(ret_str+"你好我好大家好",encoding="utf-8"))
if __name__ == "__main__":
    server = socketserver.ThreadingTCPServer(("127.0.0.1",8080),Myserver)
    server.serve_forever()

import socket
obj = socket.socket()
obj.connect(("127.0.0.1",8080))
ret_bytes = obj.recv(1024)
ret_str = str(ret_bytes,encoding="utf-8")
print(ret_str)
while True:
    inp = input("你好請問您有什麽問題？ \n >>>")
    if inp == "q":
        obj.sendall(bytes(inp,encoding="utf-8"))
        break
    else:
        obj.sendall(bytes(inp, encoding="utf-8"))
        ret_bytes = obj.recv(1024)
        ret_str = str(ret_bytes,encoding="utf-8")
        print(ret_str)

2、ThreadingTCPServer源碼剖析
內部調用流程為：

• 啟動服務端程序

• 執行 TCPServer.__init__ 方法，創建服務端Socket對象並綁定 IP 和 端口

• 執行 BaseServer.__init__ 方法，將自定義的繼承自SocketServer.BaseRequestHandler 的類
  

• MyRequestHandle賦值給 self.RequestHandlerClass

• 執行 BaseServer.server_forever 方法，While 循環一直監聽是否有客戶端請求到達 ...

• 當客戶端連接到達服務器

• 執行 ThreadingMixIn.process_request 方法，創建一個 “線程” 用來處理請求

• 執行 ThreadingMixIn.process_request_thread 方法

• 執行 BaseServer.finish_request 方法，執行 self.RequestHandlerClass() 即：執行 自定義
  

• MyRequestHandler 的構造方法（自動調用基類BaseRequestHandler的構造方法，在該構造方法中又會調用 MyRequestHandler的handle方法）

例如：

服務端

import socketserver
class MyTcphandler(socketserver.BaseRequestHandler):
    def handle(self):
        print("建立的鏈接：",self.request)
        print("客戶端信息：%s:%s" % (self.client_address[0], self.client_address[1]))
        while True: #通信循環
            try:
                client_data=self.request.recv(1024)
                if not client_data: continue  # 針對Linux的空
                self.request.send(client_data.upper())
            except Exception:  # 針對Windows的空
                break
if __name__ == ‘__main__‘:
    #取代鏈接循環
    server=socketserver.ThreadingTCPServer((‘127.0.0.1‘,8080),MyTcphandler)
    server.serve_forever()

客戶端

import socket
phone=socket.socket(socket.AF_INET,socket.SOCK_STREAM)
phone.connect((‘127.0.0.1‘,8080))

while True:
    msg=input(‘>>: ‘).strip()
    if not msg:continue
    phone.send(msg.encode(‘utf-8‘))
    server_data=phone.recv(1024)
    print(server_data.decode(‘utf-8‘))

phone.close()

相對應的源碼如下：

class BaseServer:
    """Base class for server classes.
    Methods for the caller:
    - __init__(server_address, RequestHandlerClass)
    - serve_forever(poll_interval=0.5)
    - shutdown()
    - handle_request()  # if you do not use serve_forever()
    - fileno() -> int   # for select()
    Methods that may be overridden:
    - server_bind()
    - server_activate()
    - get_request() -> request, client_address
    - handle_timeout()
    - verify_request(request, client_address)
    - server_close()
    - process_request(request, client_address)
    - shutdown_request(request)
    - close_request(request)
    - handle_error()

    Methods for derived classes:

    - finish_request(request, client_address)

    Class variables that may be overridden by derived classes or
    instances:

    - timeout
    - address_family
    - socket_type
    - allow_reuse_address

    Instance variables:

    - RequestHandlerClass
    - socket

    """

    timeout = None

    def __init__(self, server_address, RequestHandlerClass):
        """Constructor.  May be extended, do not override."""
        self.server_address = server_address
        self.RequestHandlerClass = RequestHandlerClass
        self.__is_shut_down = threading.Event()
        self.__shutdown_request = False

    def server_activate(self):
        """Called by constructor to activate the server.

        May be overridden.

        """
        pass

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

    def shutdown(self):
        """Stops the serve_forever loop.

        Blocks until the loop has finished. This must be called while
        serve_forever() is running in another thread, or it will
        deadlock.
        """
        self.__shutdown_request = True
        self.__is_shut_down.wait()

    # The distinction between handling, getting, processing and
    # finishing a request is fairly arbitrary.  Remember:
    #
    # - handle_request() is the top-level call.  It calls
    #   select, get_request(), verify_request() and process_request()
    # - get_request() is different for stream or datagram sockets
    # - process_request() is the place that may fork a new process
    #   or create a new thread to finish the request
    # - finish_request() instantiates the request handler class;
    #   this constructor will handle the request all by itself

    def handle_request(self):
        """Handle one request, possibly blocking.

        Respects self.timeout.
        """
        # Support people who used socket.settimeout() to escape
        # handle_request before self.timeout was available.
        timeout = self.socket.gettimeout()
        if timeout is None:
            timeout = self.timeout
        elif self.timeout is not None:
            timeout = min(timeout, self.timeout)
        fd_sets = _eintr_retry(select.select, [self], [], [], timeout)
        if not fd_sets[0]:
            self.handle_timeout()
            return
        self._handle_request_noblock()

    def _handle_request_noblock(self):
        """Handle one request, without blocking.

        I assume that select.select has returned that the socket is
        readable before this function was called, so there should be
        no risk of blocking in get_request().
        """
        try:
            request, client_address = self.get_request()
        except socket.error:
            return
        if self.verify_request(request, client_address):
            try:
                self.process_request(request, client_address)
            except:
                self.handle_error(request, client_address)
                self.shutdown_request(request)

    def handle_timeout(self):
        """Called if no new request arrives within self.timeout.

        Overridden by ForkingMixIn.
        """
        pass

    def verify_request(self, request, client_address):
        """Verify the request.  May be overridden.

        Return True if we should proceed with this request.

        """
        return True

    def process_request(self, request, client_address):
        """Call finish_request.

        Overridden by ForkingMixIn and ThreadingMixIn.

        """
        self.finish_request(request, client_address)
        self.shutdown_request(request)

    def server_close(self):
        """Called to clean-up the server.

        May be overridden.

        """
        pass

    def finish_request(self, request, client_address):
        """Finish one request by instantiating RequestHandlerClass."""
        self.RequestHandlerClass(request, client_address, self)

    def shutdown_request(self, request):
        """Called to shutdown and close an individual request."""
        self.close_request(request)

    def close_request(self, request):
        """Called to clean up an individual request."""
        pass

    def handle_error(self, request, client_address):
        """Handle an error gracefully.  May be overridden.

        The default is to print a traceback and continue.

        """
        print ‘-‘*40
        print ‘Exception happened during processing of request from‘,
        print client_address
        import traceback
        traceback.print_exc() # XXX But this goes to stderr!
        print ‘-‘*40



class TCPServer(BaseServer):

    """Base class for various socket-based server classes.

    Defaults to synchronous IP stream (i.e., TCP).

    Methods for the caller:

    - __init__(server_address, RequestHandlerClass, bind_and_activate=True)
    - serve_forever(poll_interval=0.5)
    - shutdown()
    - handle_request()  # if you don‘t use serve_forever()
    - fileno() -> int   # for select()

    Methods that may be overridden:

    - server_bind()
    - server_activate()
    - get_request() -> request, client_address
    - handle_timeout()
    - verify_request(request, client_address)
    - process_request(request, client_address)
    - shutdown_request(request)
    - close_request(request)
    - handle_error()

    Methods for derived classes:

    - finish_request(request, client_address)

    Class variables that may be overridden by derived classes or
    instances:

    - timeout
    - address_family
    - socket_type
    - request_queue_size (only for stream sockets)
    - allow_reuse_address

    Instance variables:

    - server_address
    - RequestHandlerClass
    - socket

    """

    address_family = socket.AF_INET

    socket_type = socket.SOCK_STREAM

    request_queue_size = 5

    allow_reuse_address = False

    def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True):
        """Constructor.  May be extended, do not override."""
        BaseServer.__init__(self, server_address, RequestHandlerClass)
        self.socket = socket.socket(self.address_family,
                                    self.socket_type)
        if bind_and_activate:
            try:
                self.server_bind()
                self.server_activate()
            except:
                self.server_close()
                raise

    def server_bind(self):
        """Called by constructor to bind the socket.

        May be overridden.

        """
        if self.allow_reuse_address:
            self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
        self.socket.bind(self.server_address)
        self.server_address = self.socket.getsockname()

    def server_activate(self):
        """Called by constructor to activate the server.

        May be overridden.

        """
        self.socket.listen(self.request_queue_size)

    def server_close(self):
        """Called to clean-up the server.

        May be overridden.

        """
        self.socket.close()

    def fileno(self):
        """Return socket file number.

        Interface required by select().

        """
        return self.socket.fileno()

    def get_request(self):
        """Get the request and client address from the socket.

        May be overridden.

        """
        return self.socket.accept()

    def shutdown_request(self, request):
        """Called to shutdown and close an individual request."""
        try:
            #explicitly shutdown.  socket.close() merely releases
            #the socket and waits for GC to perform the actual close.
            request.shutdown(socket.SHUT_WR)
        except socket.error:
            pass #some platforms may raise ENOTCONN here
        self.close_request(request)

    def close_request(self, request):
        """Called to clean up an individual request."""
        request.close()

class ThreadingMixIn:
    """Mix-in class to handle each request in a new thread."""

    # Decides how threads will act upon termination of the
    # main process
    daemon_threads = False

    def process_request_thread(self, request, client_address):
        """Same as in BaseServer but as a thread.

        In addition, exception handling is done here.

        """
        try:
            self.finish_request(request, client_address)
            self.shutdown_request(request)
        except:
            self.handle_error(request, client_address)
            self.shutdown_request(request)

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

class BaseRequestHandler:

    """Base class for request handler classes.

    This class is instantiated for each request to be handled.  The
    constructor sets the instance variables request, client_address
    and server, and then calls the handle() method.  To implement a
    specific service, all you need to do is to derive a class which
    defines a handle() method.

    The handle() method can find the request as self.request, the
    client address as self.client_address, and the server (in case it
    needs access to per-server information) as self.server.  Since a
    separate instance is created for each request, the handle() method
    can define arbitrary other instance variariables.

    """

    def __init__(self, request, client_address, server):
        self.request = request
        self.client_address = client_address
        self.server = server
        self.setup()
        try:
            self.handle()
        finally:
            self.finish()

    def setup(self):
        pass

    def handle(self):
        pass

    def finish(self):
        pass

SocketServer的ThreadingTCPServer之所以可以同時處理請求得益於 select 和 Threading 兩個東西，其實本質上就是在服務器端為每一個客戶端創建一個線程，當前線程用來處理對應客戶端的請求，所以，可以支持同時n個客戶端鏈接（長連接）。

本文出自 “炫維” 博客，轉載請與作者聯系！

python自動化運維之Socket網絡編程