zoukankan      html  css  js  c++  java
  • python select模块

    Python select

    一、前言

      Python的select()方法直接调用操作系统的IO接口,它监控sockets,open files, and pipes(所有带fileno()方法的文件句柄)何时变成readable 和writeable, 或者通信错误,select()使得同时监控多个连接变的简单,并且这比写一个长循环来等待和监控多客户端连接要高效,因为select直接通过操作系统提供的C的网络接口进行操作,而不是通过Python的解释器。

      注意:Using Python’s file objects with select() works for Unix, but is not supported under Windows.

    二、select socket

      接下来通过socket server例子要以了解select 是如何通过单进程实现同时处理多个非阻塞的socket连接的 

           2.1 socket server 开始监听

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    import select
    import socket
    import queue
    import sys
     
    # Create a TCP/IP socket
    server = socket.socket()
    # set noblocking
    server.setblocking(False)
     
    # Bind the socket to the port
    server_address = ('localhost'9999)
    print(sys.stderr, 'starting up on %s port %s' % server_address)
    server.bind(server_address)
     
    # Listen for incoming connections
    server.listen()

      2.2 3个通信列表

      select()方法接收并监控3个通信列表, 第一个是所有的输入的data,就是指外部发过来的数据,第2个是监控和接收所有要发出去的data(outgoing data),第3个监控错误信息,接下来我们需要创建2个列表来包含输入和输出信息来传给select()。 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    import select
    import socket
    import queue
    import sys
     
    # Create a TCP/IP socket
    server = socket.socket()
    # set noblocking
    server.setblocking(False)
     
    # Bind the socket to the port
    server_address = ('localhost'9999)
    print(sys.stderr, 'starting up on %s port %s' % server_address)
    server.bind(server_address)
     
    # Listen for incoming connections
    server.listen()
     
    # 所有连接进来的对象都放在inputs
    inputs = [server, ]  # 自己也要监控,因为server本身也是个对象
     
    # 需要发送数据的对象
    outputs = []

      2.3 添加一个队列

      所有客户端的进来的连接和数据将会被server的主循环程序放在上面的list中处理,我们现在的server端需要等待连接可写(writable)之后才能过来,然后接收数据并返回(因此不是在接收到数据之后就立刻返回),因为每个连接要把输入或输出的数据先缓存到queue里,然后再由select取出来再发出去。

      Connections are added to and removed from these lists by the server main loop. Since this version of the server is going to wait for a socket to become writable before sending any data (instead of immediately sending the reply), each output connection needs a queue to act as a buffer for the data to be sent through it. 

    1
    2
    # 对外发送数据的队列,记录到字典中
    message_queues = {}

      2.4 主循环 

    1
    2
    3
    while True:
        readable, writable, exceptional = select.select(inputs, outputs, inputs)
        # 如果没有任何fd就绪,那程序就会一直阻塞在这里

      当你把inputs,outputs,exceptional(这里跟inputs共用)传给select()后,它返回3个新的list,我们上面将他们分别赋值为readable,writable,exceptional, 所有在readable list中的socket连接代表有数据可接收(recv),所有在writable list中的存放着你可以对其进行发送(send)操作的socket连接,当连接通信出现error时会把error写到exceptional列表中。

       2.5 Readable list

       Readable list 中的socket 可以有3种可能状态,第一种是如果这个socket是main "server" socket,它负责监听客户端的连接,如果这个main server socket出现在readable里,那代表这是server端已经ready来接收一个新的连接进来了,为了让这个main server能同时处理多个连接,在下面的代码里,我们把这个main server的socket设置为非阻塞模式。  

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    for in readable:  # 每一个s就是有个socket
     
        if is server:
            # 别忘记,上面我们server自己也当做一个fd放在了inputs列表里,传给了select,如果这个s是server,代表server这个fd就绪了,
            # 就是有活动了, 什么情况下它才有活动? 当然 是有新连接进来的时候
            # 新连接进来了,接受这个连接
            conn, client_addr = s.accept()
            print("new connection from", client_addr)
            conn.setblocking(0)
            inputs.append(conn)
            # 为了不阻塞整个程序,我们不会立刻在这里开始接收客户端发来的数据, 把它放到inputs里, 下一次loop时,这个新连接
            # 就会被交给select去监听,如果这个连接的客户端发来了数据 ,那这个连接的fd在server端就会变成就续的,select就会把这个连接返回,
            # 返回到readable 列表里,然后你就可以loop readable列表,取出这个连接,开始接收数据了, 下面就是这么干的
             
            message_queues[conn] = queue.Queue() 
            # 接收到客户端的数据后,不立刻返回 ,暂存在队列里,以后发送

      第二种情况是这个socket是已经建立了的连接,它把数据发了过来,这个时候你就可以通过recv()来接收它发过来的数据,然后把接收到的数据放到queue里,这样你就可以把接收到的数据再传回给客户端了。

    1
    2
    3
    4
    5
    6
    7
    8
    else:   # s不是server的话,那就只能是一个 与客户端建立的连接的fd了
        # 客户端的数据过来了,在这接收
        data = s.recv(1024)
        if data:
            print('received [%s] from %s' % (data, s.getpeername()[0]))
            message_queues[s].put(data)  # 收到的数据先放到queue里,一会返回给客户端
            if not in outputs:
                outputs.append(s)  # 为了不影响处理与其它客户端的连接 , 这里不立刻返回数据给客户端

      第三种情况就是这个客户端已经断开了,所以你再通过recv()接收到的数据就为空了,所以这个时候你就可以把这个跟客户端的连接关闭了。

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    else:  # 如果收不到data代表什么呢? 代表客户端断开了
        print("client [%s] closed", s)
     
        if in outputs:
            # 既然客户端都断开了,我就不用再给它返回数据了,
            # 所以这时候如果这个客户端的连接对象还在outputs列表中,就把它删掉
            outputs.remove(s)
     
        inputs.remove(s)  # 这个连接必然在inputs中,也删掉
        s.close()
     
        # 关闭的连接在队列中也删除
        del message_queues[s]

      2.6 writable list

      对于writable list中的socket,也有几种状态,如果这个客户端连接在跟它对应的queue里有数据,就把这个数据取出来再发回给这个客户端,否则就把这个连接从output list中移除,这样下一次循环select()调用时检测到outputs list中没有这个连接,那就会认为这个连接还处于非活动状态 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    for in writable:
        try:
            next_msg = message_queues[s].get_nowait()
        except queue.Empty:
            # 没有数据了,该连接对象队列为空,停止检测
            print('output queue for [%s] is empty' % s.getpeername()[0])
            outputs.remove(s)
         
        else:
            print('send %s to %s' % (next_msg, s.getpeername()[0]))
            s.send(next_msg)

      2.7 exceptional condition

      最后,如果在跟某个socket连接通信过程中出了错误,就把这个连接对象在inputsoutputsmessage_queue中都删除,再把连接关闭掉 

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    for in exceptional:
        print('handling exceptional condition for', s.getpeername()[0])
        # 从inputs中删除
        inputs.remove(s)
        if in outputs:
            outputs.remove(s)
        s.close()
         
        # 删除队列
        del message_queues[s]

      注: getpeername() / getsocketname

        getpeername可以获得服务器的地址信息和端口号,正好和getsockname获得本机地址信息和端口号完全相反

    三、完整事例

      select server  

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92
    93
    94
    95
    # -*- coding: UTF-8 -*-
     
    import select
    import socket
    import queue
    import sys
     
    # Create a TCP/IP socket
    server = socket.socket()
    # set noblocking
    server.setblocking(False)
     
    # Bind the socket to the port
    server_address = ('localhost'9999)
    print(sys.stderr, 'starting up on %s port %s' % server_address)
    server.bind(server_address)
     
    # Listen for incoming connections
    server.listen()
     
    # 所有连接进来的对象都放在inputs
    inputs = [server, ]  # 自己也要监控,因为server本身也是个对象
     
    # 需要发送数据的对象
    outputs = []
     
    # 对外发送数据的队列,记录到字典中
    message_queues = {}
     
    while True:
        readable, writable, exceptional = select.select(inputs, outputs, inputs)
        # 如果没有任何fd就绪,那程序就会一直阻塞在这里
     
        for in readable:  # 每一个s就是有个socket
     
            if is server:
                # 别忘记,上面我们server自己也当做一个fd放在了inputs列表里,传给了select,如果这个s是server,代表server这个fd就绪了,
                # 就是有活动了, 什么情况下它才有活动? 当然 是有新连接进来的时候
                # 新连接进来了,接受这个连接
                conn, client_addr = s.accept()
                print("new connection from", client_addr)
                conn.setblocking(0)
                inputs.append(conn)
                # 为了不阻塞整个程序,我们不会立刻在这里开始接收客户端发来的数据, 把它放到inputs里, 下一次loop时,这个新连接
                # 就会被交给select去监听,如果这个连接的客户端发来了数据 ,那这个连接的fd在server端就会变成就续的,select就会把这个连接返回,
                # 返回到readable 列表里,然后你就可以loop readable列表,取出这个连接,开始接收数据了, 下面就是这么干的
     
                message_queues[conn] = queue.Queue()
                # 接收到客户端的数据后,不立刻返回 ,暂存在队列里,以后发送
     
            else:   # s不是server的话,那就只能是一个 与客户端建立的连接的fd了
                # 客户端的数据过来了,在这接收
                data = s.recv(1024)
                if data:
                    print('received [%s] from %s' % (data, s.getpeername()[0]))
                    message_queues[s].put(data)  # 收到的数据先放到queue里,一会返回给客户端
                    if not in outputs:
                        outputs.append(s)  # 为了不影响处理与其它客户端的连接 , 这里不立刻返回数据给客户端
     
                else:  # 如果收不到data代表什么呢? 代表客户端断开了
                    print("client [%s] closed", s)
     
                    if in outputs:
                        # 既然客户端都断开了,我就不用再给它返回数据了,
                        # 所以这时候如果这个客户端的连接对象还在outputs列表中,就把它删掉
                        outputs.remove(s)
     
                    inputs.remove(s)  # 这个连接必然在inputs中,也删掉
                    s.close()
     
                    # 关闭的连接在队列中也删除
                    del message_queues[s]
     
        for in writable:
            try:
                next_msg = message_queues[s].get_nowait()
            except queue.Empty:
                # 没有数据了,该连接对象队列为空,停止检测
                print('output queue for [%s] is empty' % s.getpeername()[0])
                outputs.remove(s)
     
            else:
                print('send %s to %s' % (next_msg, s.getpeername()[0]))
                s.send(next_msg)
     
        for in exceptional:
            print('handling exceptional condition for', s.getpeername()[0])
            # 从inputs中删除
            inputs.remove(s)
            if in outputs:
                outputs.remove(s)
            s.close()
     
            # 删除队列
            del message_queues[s]

      client

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    # -*- coding: UTF-8 -*-
    import socket
     
    HOST = 'localhost'  # The remote host
    PORT = 9999  # The same port as used by the server
    = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    s.connect((HOST, PORT))
    while True:
        msg = bytes(input(">>:"), encoding="utf8")
        s.sendall(msg)
        data = s.recv(1024)
        # print(data)
     
        print('Received'repr(data))

    python select模块详解

    要理解select.select模块其实主要就是要理解它的参数, 以及其三个返回值。
    select()方法接收并监控3个通信列表, 第一个是所有的输入的data,就是指外部发过来的数据,第2个是监控和接收所有要发出去的data(outgoing data),第3个监控错误信息

    在网上一直在找这个select.select的参数解释, 但实在是没有, 哎...自己硬着头皮分析了一下。
    readable, writable, exceptional = select.select(inputs, outputs, inputs)

    select 函数的参数其实很好理解, 前提是我们对unix 网络编程有了解. select 模型是unix 系统中的网络模型, python 将其封装了,因此我们使用起来就比较方便, 但是面试官就不会这么觉得了(最近被面试逼疯了, 考虑问题都从面试官的角度考虑), 先说下unix 系统中的select 模型吧, 参数原型:
    int select(int maxfdpl, fd_set * readset, fd_set *writeset, fd_set *exceptset, const struct timeval * tiomeout)

    第一个是最大的文件描述符长度
    第二个是监听的可读集合
    第三个是监听的可写集合
    第四个是监听的异常集合
    第五个是时间限制

    对struct fd_set结构体操作的宏
    FD_SETSIZE 容量,指定fd_array数组大小,默认为64,也可自己修改宏
    FD_ZERO(*set) 置空,使数组的元素值都为3435973836,元素个数为0.
    FD_SET(s, *set) 添加,向 struct fd_set结构体添加套接字s
    FD_ISSET(s, *set) 判断,判断s是否为 struct fd_set结构体中的一员
    FD_CLR(s, *set) 删除,从 struct fd_set结构体中删除成员s

    因为此模型主要是在网络中应用, 我们不考虑文件, 设备, 单从套接字来考虑, 可读条件如下:

    可写条件如下:

    我看C 示例的时候, 看的有点懵逼, 应该需要跑一遍代码就好, python 就简单了, 直接调用封装好的select , 其底层处理好了文件描述符的相关读写监听(回头再研究下), 我们在Python 中只需这么写:
    can_read, can_write, _ = select.select(inputs, outputs, None, None)

    第一个参数是我们需要监听可读的套接字, 第二个参数是我们需要监听可写的套接字, 第三个参数使我们需要监听异常的套接字, 第四个则是时间限制设置.

    如果监听的套接字满足了可读可写条件, 那么所返回的can,read 或是 can_write就会有值了, 然后我们就可以利用这些返回值进行随后的操作了。相比较unix 的select模型, 其select函数的返回值是一个整型, 用以判断是否执行成功.

    第一个参数就是服务器端的socket, 第二个是我们在运行过程中存储的客户端的socket, 第三个存储错误信息。
    重点是在返回值, 第一个返回的是可读的list, 第二个存储的是可写的list, 第三个存储的是错误信息的
    list。
    网上所有关于select.select的代码都是差不多的, 但是有些不能运行, 或是不全。我自己重新写了一份能运行的程序, 做了很多注释, 好好看看就能搞懂

    # coding: utf-8
    import select
    import socket
    import Queue
    from time import sleep
    
    
    # Create a TCP/IP
    server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
    server.setblocking(False)
    
    # Bind the socket to the port
    server_address = ('localhost', 8090)
    print ('starting up on %s port %s' % server_address)
    server.bind(server_address)
    
    # Listen for incoming connections
    server.listen(5)
    
    # Sockets from which we expect to read
    inputs = [server]
    
    # Sockets to which we expect to write
    # 处理要发送的消息
    outputs = []
    
    # Outgoing message queues (socket: Queue)
    message_queues = {}
    
    while inputs:
        # Wait for at least one of the sockets to be ready for processing
        print ('waiting for the next event')
        # 开始select 监听, 对input_list 中的服务器端server 进行监听
        # 一旦调用socket的send, recv函数,将会再次调用此模块
        readable, writable, exceptional = select.select(inputs, outputs, inputs)
    
        # Handle inputs
        # 循环判断是否有客户端连接进来, 当有客户端连接进来时select 将触发
        for s in readable:
            # 判断当前触发的是不是服务端对象, 当触发的对象是服务端对象时,说明有新客户端连接进来了
            # 表示有新用户来连接
            if s is server:
                # A "readable" socket is ready to accept a connection
                connection, client_address = s.accept()
                print ('connection from', client_address)
                # this is connection not server
                connection.setblocking(0)
                # 将客户端对象也加入到监听的列表中, 当客户端发送消息时 select 将触发
                inputs.append(connection)
    
                # Give the connection a queue for data we want to send
                # 为连接的客户端单独创建一个消息队列,用来保存客户端发送的消息
                message_queues[connection] = Queue.Queue()
            else:
                # 有老用户发消息, 处理接受
                # 由于客户端连接进来时服务端接收客户端连接请求,将客户端加入到了监听列表中(input_list), 客户端发送消息将触发
                # 所以判断是否是客户端对象触发
                data = s.recv(1024)
                # 客户端未断开
                if data != '':
                    # A readable client socket has data
                    print ('received "%s" from %s' % (data, s.getpeername()))
                    # 将收到的消息放入到相对应的socket客户端的消息队列中
                    message_queues[s].put(data)
                    # Add output channel for response
                    # 将需要进行回复操作socket放到output 列表中, 让select监听
                    if s not in outputs:
                        outputs.append(s)
                else:
                    # 客户端断开了连接, 将客户端的监听从input列表中移除
                    # Interpret empty result as closed connection
                    print ('closing', client_address)
                    # Stop listening for input on the connection
                    if s in outputs:
                        outputs.remove(s)
                    inputs.remove(s)
                    s.close()
    
                    # Remove message queue
                    # 移除对应socket客户端对象的消息队列
                    del message_queues[s]
    
        # Handle outputs
        # 如果现在没有客户端请求, 也没有客户端发送消息时, 开始对发送消息列表进行处理, 是否需要发送消息
        # 存储哪个客户端发送过消息
        for s in writable:
            try:
                # 如果消息队列中有消息,从消息队列中获取要发送的消息
                message_queue = message_queues.get(s)
                send_data = ''
                if message_queue is not None:
                    send_data = message_queue.get_nowait()
                else:
                    # 客户端连接断开了
                    print "has closed "
            except Queue.Empty:
                # 客户端连接断开了
                print "%s" % (s.getpeername())
                outputs.remove(s)
            else:
                # print "sending %s to %s " % (send_data, s.getpeername)
                # print "send something"
                if message_queue is not None:
                    s.send(send_data)
                else:
                    print "has closed "
                # del message_queues[s]
                # writable.remove(s)
                # print "Client %s disconnected" % (client_address)
    
        # # Handle "exceptional conditions"
        # 处理异常的情况
        for s in exceptional:
            print ('exception condition on', s.getpeername())
            # Stop listening for input on the connection
            inputs.remove(s)
            if s in outputs:
                outputs.remove(s)
            s.close()
    
            # Remove message queue
            del message_queues[s]
    
        sleep(1)
    服务端
    # coding: utf-8
    import socket
    
    
    messages = ['This is the message ', 'It will be sent ', 'in parts ', ]
    
    server_address = ('localhost', 8090)
    
    # Create aTCP/IP socket
    
    socks = [socket.socket(socket.AF_INET, socket.SOCK_STREAM), socket.socket(socket.AF_INET,  socket.SOCK_STREAM), ]
    
    # Connect thesocket to the port where the server is listening
    
    print ('connecting to %s port %s' % server_address)
    # 连接到服务器
    for s in socks:
        s.connect(server_address)
    
    for index, message in enumerate(messages):
        # Send messages on both sockets
        for s in socks:
            print ('%s: sending "%s"' % (s.getsockname(), message + str(index)))
            s.send(bytes(message + str(index)).decode('utf-8'))
        # Read responses on both sockets
    
    for s in socks:
        data = s.recv(1024)
        print ('%s: received "%s"' % (s.getsockname(), data))
        if data != "":
            print ('closingsocket', s.getsockname())
            s.close()
    客户端

    浅析python select模块

     

    一、select介绍

    select()的机制中提供一fd_set的数据结构,实际上是一long类型的数组, 每一个数组元素都能与一打开的文件句柄(不管是Socket句柄,还是其他文件或命名管道或设备句柄)建立联系,建立联系的工作由程序员完成, 当调用select()时,由内核根据IO状态修改fd_set的内容,由此来通知执行了select()的进程哪一Socket或文件可读或可写。主要用于Socket通信当中。

    总结:select主要用于socket通信当中,能监视我们需要的文件描述变化。

    二、非阻塞式I/O编程特点

      2.1、如果一个发现I/O有输入,读取的过程中,另外一个也有了输入,这时候不会产生任何反应.这就需要你的程序语句去用到select函数的时候才知道有数据输入。
      2.2、程序去select的时候,如果没有数据输入,程序会一直等待,直到有数据为止,也就是程序中无需循环和sleep。


      Select在Socket编程中还是比较重要的,可是对于初学Socket的人来说都不太爱用Select写程序,他们只是习惯写诸如connect、accept、recv或recvfrom这样的阻塞程序(所谓阻塞方式block,顾名思义,就是进程或是线程执行到这些函数时必须等待某个事件的发生,如果事件没有发生,进程或线程就被阻塞,函数不能立即返回)。


      可是使用Select就可以完成非阻塞(所谓非阻塞方式non-block,就是进程或线程执行此函数时不必非要等待事件的发生,一旦执行肯定返回,以返回值的不同来反映函数的执行情况,如果事件发生则与阻塞方式相同,若事件没有发生,则返回一个代码来告知事件未发生,而进程或线程继续执行,所以效率较高)方式工作的程序,它能够监视我们需要监视的文件描述符的变化情况——读写或是异常。


      返回值:准备就绪的描述符数,若超时则返回0,若出错则返回-1。

    三、示例

    示例1:模拟select,同时监听多个端口

    import socket
    import select
    
    sk1 = socket.socket()
    sk1.bind(('0.0.0.0', 8001))
    sk1.listen()
    
    sk2 = socket.socket()
    sk2.bind(('0.0.0.0', 8002))
    sk2.listen()
    
    sk3 = socket.socket()
    sk3.bind(('0.0.0.0', 8003))
    sk3.listen()
    
    inputs = [sk1, sk2, sk3, ]
    
    while True:
        r_list, w_list, e_list = select.select(inputs,[],inputs,1)
        for sk in r_list:
            # conn表示每一个连接对象
            conn, address = sk.accept()
            conn.sendall(bytes('hello', encoding='utf-8'))
            conn.close()
    
        for sk in e_list:
            inputs.remove(sk)
    
    解释:
        # select内部自动监听sk1,sk2,sk3三个对象,监听三个句柄是否发生变化,把发生变化的元素放入r_list中。
        # 如果有人连接sk1,则r_list = [sk1]
        # 如果有人连接sk1和sk2,则r_list = [sk1,sk2]
        # select中第1个参数表示inputs中发生变化的句柄放入r_list。
        # select中第2个参数表示[]中的值原封不动的传递给w_list。
        # select中第3个参数表示inputs中发生错误的句柄放入e_list。
        # 参数1表示1秒监听一次
         # 当有用户连接时,r_list里面的内容[<socket.socket fd=220, family=AddressFamily.AF_INET, type=SocketKind.SOCK_STREAM, proto=0, laddr=('0.0.0.0', 8001)>]
    服务端s1.py
    import socket
    
    obj = socket.socket()
    obj.connect(('127.0.0.1', 8001))
    
    content = str(obj.recv(1024), encoding='utf-8')
    print(content)
    
    obj.close()
    
    # 客户端c2.py
    import socket
    
    obj = socket.socket()
    obj.connect(('127.0.0.1', 8002))
    
    content = str(obj.recv(1024), encoding='utf-8')
    print(content)
    
    obj.close()
    客户端c1.py

    示例2:IO多路复用--使用socket模拟多线程,并实现读写分离

    #使用socket模拟多线程,使多用户可以同时连接
    import socket
    import select
    
    sk1 = socket.socket()
    sk1.bind(('0.0.0.0', 8001))
    sk1.listen()
    
    inputs = [sk1, ]
    outputs = []
    message_dict = {}
    
    while True:
        r_list, w_list, e_list = select.select(inputs, outputs, 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_dict[conn] = []
            else:
                # 有老用户发消息了
                try:
                    data_bytes = sk1_or_conn.recv(1024)
                except Exception as ex:
                    # 如果用户终止连接
                    inputs.remove(sk1_or_conn)
                else:
                    data_str = str(data_bytes, encoding='utf-8')
                    message_dict[sk1_or_conn].append(data_str)
                    outputs.append(sk1_or_conn)
    
        #w_list中仅仅保存了谁给我发过消息
        for conn in w_list:
            recv_str = message_dict[conn][0]
            del message_dict[conn][0]
            conn.sendall(bytes(recv_str+'', encoding='utf-8'))
            outputs.remove(conn)
    
        for sk in e_list:
    
            inputs.remove(sk)
    服务端s1.py
    import socket
    
    obj = socket.socket()
    obj.connect(('127.0.0.1', 8001))
    
    while True:
        inp = input('>>>')
        obj.sendall(bytes(inp, encoding='utf-8'))
        ret = str(obj.recv(1024),encoding='utf-8')
        print(ret)
    
    obj.close()
    客户端c1.py
    13:32:38
  • 相关阅读:
    ☀【布局】
    _#【CSS3】
    _#minheight
    【其它】引入css
    【css3】url
    鼠标闲置一段时间后自动隐藏
    图解SQLServer2005获取WebService数据
    Oracle字符串字段内的字符排序
    一个c#读取扫雷内存的demo
    sqlserver使用bcp分解字符串
  • 原文地址:https://www.cnblogs.com/leijiangtao/p/11818517.html
Copyright © 2011-2022 走看看