import socket

ser = socket.socket()

ser.bind(("127.0.0.1", 9999))

ser.listen(5)

while True:

    conn, addr = ser.accept()#等待链接阻塞

    conn.sendall(bytes("欢迎链接，请输入：q退出：",encoding="utf-8"))

    while True:

        rev = str(conn.recv(1024),encoding="utf-8")#等待接收

        if rev == "q":

            conn.sendall(bytes("exit", encoding="utf-8"))

            break

        else:

            conn.sendall(bytes("继续输入：",encoding="utf-8"))

    conn.close()

import socket

cli = socket.socket()

cli.connect(("127.0.0.1",9999))

rev = str(cli.recv(1024),encoding="utf-8")

print(rev)

while True:

    inp = input("请输入：")

    cli.sendall(bytes(inp,encoding="utf-8"))

    rev = str(cli.recv(1024),encoding="utf-8")

    if rev =="exit":

        print(rev)

        break

    else:

        print(rev)

cli.close()

import socket

ip_port = ('127.0.0.1',9999)

sk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0)

sk.bind(ip_port)

while True:

    data = sk.recv(1024)

    print data

import socket

ip_port = ('127.0.0.1',9999)

sk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0)

while True:

    inp = raw_input('数据：').strip()

    if inp == 'exit':

        break

    sk.sendto(inp,ip_port)

sk.close()

 UDP Demo

import socket

ip_port = ('127.0.0.1',9999)

sk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0)

sk.bind(ip_port)

while True:

    data = sk.recv(1024)

    print data

import socket

ip_port = ('127.0.0.1',9999)

sk = socket.socket(socket.AF_INET,socket.SOCK_DGRAM,0)

while True:

    inp = raw_input('数据：').strip()

    if inp == 'exit':

        break

    sk.sendto(inp,ip_port)

sk.close()

UDP Demo

select

select最早于1983年出现在4.2BSD中，它通过一个select()系统调用来监视多个文件描述符的数组，当select()返回后，该数组中就绪的文件描述符便会被内核修改标志位，使得进程可以获得这些文件描述符从而进行后续的读写操作。

select目前几乎在所有的平台上支持，其良好跨平台支持也是它的一个优点，事实上从现在看来，这也是它所剩不多的优点之一。

select的一个缺点在于单个进程能够监视的文件描述符的数量存在最大限制，在Linux上一般为1024，不过可以通过修改宏定义甚至重新编译内核的方式提升这一限制。

另外，select()所维护的存储大量文件描述符的数据结构，随着文件描述符数量的增大，其复制的开销也线性增长。同时，由于网络响应时间的延迟使得大量TCP连接处于非活跃状态，但调用select()会对所有socket进行一次线性扫描，所以这也浪费了一定的开销。

poll

poll在1986年诞生于System V Release 3，它和select在本质上没有多大差别，但是poll没有最大文件描述符数量的限制。

poll和select同样存在一个缺点就是，包含大量文件描述符的数组被整体复制于用户态和内核的地址空间之间，而不论这些文件描述符是否就绪，它的开销随着文件描述符数量的增加而线性增大。

另外，select()和poll()将就绪的文件描述符告诉进程后，如果进程没有对其进行IO操作，那么下次调用select()和poll()的时候将再次报告这些文件描述符，所以它们一般不会丢失就绪的消息，这种方式称为水平触发（Level Triggered）。

epoll

直到Linux2.6才出现了由内核直接支持的实现方法，那就是epoll，它几乎具备了之前所说的一切优点，被公认为Linux2.6下性能最好的多路I/O就绪通知方法。

epoll可以同时支持水平触发和边缘触发（Edge Triggered，只告诉进程哪些文件描述符刚刚变为就绪状态，它只说一遍，如果我们没有采取行动，那么它将不会再次告知，这种方式称为边缘触发），理论上边缘触发的性能要更高一些，但是代码实现相当复杂。

epoll同样只告知那些就绪的文件描述符，而且当我们调用epoll_wait()获得就绪文件描述符时，返回的不是实际的描述符，而是一个代表就绪描述符数量的值，你只需要去epoll指定的一个数组中依次取得相应数量的文件描述符即可，这里也使用了内存映射（mmap）技术，这样便彻底省掉了这些文件描述符在系统调用时复制的开销。

另一个本质的改进在于epoll采用基于事件的就绪通知方式。在select/poll中，进程只有在调用一定的方法后，内核才对所有监视的文件描述符进行扫描，而epoll事先通过epoll_ctl()来注册一个文件描述符，一旦基于某个文件描述符就绪时，内核会采用类似callback的回调机制，迅速激活这个文件描述符，当进程调用epoll_wait()时便得到通知。

说明

import socket, 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()

# inputs = [sk1, sk2, sk3, ]

inputs = [sk1, ]

while True:

    #[sk1,sk2,sk3,],select内部自动监听sk1，sk2，sk3两个对象，一旦某个句柄发生变化

    #如果有人连接sk1,或sk2

    #r_list = [sk1，]

    #如果有人第一次连接，sk1发生变化

    #select内部自动监听socket对象，一旦socket变化感知到有新的连接，或者sk1有另外一个人连接变化

    #例如 A：[sk1,A].B 来连接的时候sk1server对象变化了，把B加进去.[sk1,A,B,]

    #r_list=[sk1,],A,B 连接一次后没发送消息

    #B连接后发生消息了，r_list=[B,] 了

    r_list,w_list,e_list = select.select(inputs,[],[],1)

    print("正在监听socketserver对象%d" % len(inputs))

    print(r_list)

    for sk in r_list:

        # conn,address = sk.accept()

        # conn.sendall(bytes("hello",encoding="utf-8"))

        # conn.close()

        #每一个连接对象

        if sk == sk1:

            #表示新用户连接

            conn, address = sk.accept()

            inputs.append(conn)

        else:

            #老用户发消息了

            try:

                data_bytes = sk.recv(1024)

                data_str = str(data_bytes,encoding="utf-8")

                sk.sendall(bytes(data_str+"好",encoding="utf-8"))

            except Exception as ex:

                inputs.remove(sk)

import socket

ip_port = ('127.0.0.1', 8001)

sk = socket.socket()

sk.connect(ip_port)

while True:

    inp = input(">>>")

    sk.sendall(bytes(inp,encoding="utf-8"))

    print(str(sk.recv(1024),encoding="utf-8"))

import socket

import select

# 文件描述符在linux叫法， 文件句柄 在windows叫法

#　内核记录进程的状态，一旦发生变化就内核就会记录，ｌｉｎｕｘ下的一个进程打开的最大文件描述符是６５５３５

    #

    #     一个文件 ： 文件名  权限  属主 属组 等等，我们打开文件名，而内核会追踪这些信息，跟文件的inode的号没关系，

    #   文件描述符： 文件描述符在形式上是一个非负整数，实际上，他是一个索引值，指向内核每一个进程所维护的该进程打开的文件的记录表，当程序打开一个现有文件或者创建一个新文件时，内核向该进程返回一个文件描述符。

    # 内核必须要向追踪进程一样追踪这个文件，而是识别的那些属性，内核中为了追踪当下已经被打开了的文件属性。在linux unix  被称为 文件描述符简写为FD，windows上叫文件句柄

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

# 将三个文件描述符的socket对象加入列表

# inpu_li  = [sk1, sk2, sk3 ]

inpu_li  = [sk1,  ]

while True:

    #  select 内部会自动监听 列表内的sk1 sk2 sk3 的三个对象，一旦这列表的每个文件描述符发生变化也就是链接

    #这里的1 是每次循环到这一句代码， select 就会取内核查看文件句柄是否变化，也就是是否有人来链接监听的三个文件句柄的端口是否有人访问，若果有人访问，就继续下一句代码，否则就继续while

    r_list, w_list, e_list = select.select(inpu_li, [], inpu_li, 1) # 第三个参数是错误列表，

    for sk in r_list:

        conn,address = sk.accept()

        conn.sendall(bytes("hello",encoding="utf-8"))

        print(conn)

    for sk in e_list:

        e_list.remove(sk)

import socket

obj = socket.socket()

obj.connect(("127.0.0.1",8001))

while True:

    content = str(obj.recv(1024),encoding="utf-8")

    print(content)

import socket

obj = socket.socket()

obj.connect(("127.0.0.1",8002))

while True:

    content = str(obj.recv(1024),encoding="utf-8")

    print(content)

import socket

import select

# 文件描述符在linux叫法， 文件句柄 在windows叫法

#　内核记录进程的状态，一旦发生变化就内核就会记录，ｌｉｎｕｘ下的一个进程打开的最大文件描述符是６５５３５

    #

    #     一个文件 ： 文件名  权限  属主 属组 等等，我们打开文件名，而内核会追踪这些信息，跟文件的inode的号没关系，

    #   文件描述符： 文件描述符在形式上是一个非负整数，实际上，他是一个索引值，指向内核每一个进程所维护的该进程打开的文件的记录表，当程序打开一个现有文件或者创建一个新文件时，内核向该进程返回一个文件描述符。

    # 内核必须要向追踪进程一样追踪这个文件，而是识别的那些属性，内核中为了追踪当下已经被打开了的文件属性。在linux unix  被称为 文件描述符简写为FD，windows上叫文件句柄

sk1 = socket.socket()

sk1.bind(("127.0.0.1",9001))

sk1.listen()

# 将三个文件描述符的socket对象加入列表

# inpu_li  = [sk1, sk2, sk3 ]

inpu_li  = [sk1,  ]

while True:

    #  select 内部会自动监听 列表内的sk1 sk2 sk3 的三个对象，一旦这列表的每个文件描述符发生变化也就是链接

    #这里的1 是每次循环到这一句代码， select 就会取内核查看文件句柄是否变化，也就是是否有人来链接监听的三个文件句柄的端口是否有人访问，若果有人访问，就继续下一句代码，否则就继续while

    r_list, w_list, e_list = select.select(inpu_li, [], inpu_li, 1) # 第三个参数是错误列表，

    # c1 链接了，input [sk1 c1 c1- c1-- ]

    # 如果是 新链接 则rlist 为sk1

    # 如果是发消息，则rlist是 内部客户端对象发生变化

    print("正在监听的对象 %s 个" % len(inpu_li))

    print(r_list)

    for sk_or_conn in r_list:

        if sk_or_conn == sk1:

            # 表示有新用户链接了

            conn,address = sk_or_conn.accept()

            inpu_li.append(conn)

        else:

            # 表示有老用户发送消息了

            # 2 版本客户端断开会发送的data为空，故判断data长度为0即可，而3 则是发生异常，故此判断异常来判断客户度是否结束

            try:

                # 客户端发送消息

                data = sk_or_conn.recv(1024)

                data_str = str(data,encoding="utf-8")

                print(data_str)

                sk_or_conn.sendall(bytes(data_str+"好",encoding="utf-8"))

            except Exception as e:

                # 客户端断开链接，移除该客户端对象

                print("del",sk_or_conn)

                inpu_li.remove(sk_or_conn) #移除客户端如果客户端退出的话

    for sk in e_list:

        e_list.remove(sk)

import socket

obj = socket.socket()

obj.connect(("127.0.0.1",9001))

while True:

    inp = input(">>>")

    obj.sendall(bytes(inp,encoding="utf-8"))

    ret = str(obj.recv(1024),encoding="utf-8")

    print(ret)

obj.close()

import SocketServer

class MyServer(SocketServer.BaseRequestHandler):

    def handle(self):

        # print self.request,self.client_address,self.server

        conn = self.request

        conn.sendall('欢迎致电 10086，请输入1xxx,0转人工服务.')

        Flag = True

        while Flag:

            data = conn.recv(1024)

            if data == 'exit':

                Flag = False

            elif data == '':

                conn.sendall('通过可能会被录音.balabala一大推')

            else:

                conn.sendall('请重新输入.')

if __name__ == '__main__':

    server = SocketServer.ThreadingTCPServer(('127.0.0.1',8009),MyServer)

    server.serve_forever()

import socket

ip_port = ('127.0.0.1',8009)

sk = socket.socket()

sk.connect(ip_port)

sk.settimeout(5)

while True:

    data = sk.recv(1024)

    print 'receive:',data

    inp = raw_input('please input:')

    sk.sendall(inp)

    if inp == 'exit':

        break

sk.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

BaseServer

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

TCPServer

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

ThreadingMixIn

class ThreadingTCPServer(ThreadingMixIn, TCPServer): pass

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.BaseRequestHandler

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import SocketServer

class MyServer(SocketServer.BaseRequestHandler):

    def handle(self):

        # print self.request,self.client_address,self.server

        conn = self.request

        conn.sendall('欢迎致电 10086，请输入1xxx,0转人工服务.')

        Flag = True

        while Flag:

            data = conn.recv(1024)

            if data == 'exit':

                Flag = False

            elif data == '':

                conn.sendall('通过可能会被录音.balabala一大推')

            else:

                conn.sendall('请重新输入.')

if __name__ == '__main__':

    server = SocketServer.ThreadingTCPServer(('127.0.0.1',8009),MyServer)

    server.serve_forever()

服务端

#!/usr/bin/env python

# -*- coding:utf-8 -*-

import socket

ip_port = ('127.0.0.1',8009)

sk = socket.socket()

sk.connect(ip_port)

sk.settimeout(5)

while True:

    data = sk.recv(1024)

    print 'receive:',data

    inp = raw_input('please input:')

    sk.sendall(inp)

    if inp == 'exit':

        break

sk.close()

 客户端