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 s in readable:  # 每一个s就是有个socket
 
    if s 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 s 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 s 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 s 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连接通信过程中出了错误，就把这个连接对象在inputs\outputs\message_queue中都删除，再把连接关闭掉　

1
2
3
4
5
6
7
8
9
10
for s in exceptional:
    print('handling exceptional condition for', s.getpeername()[0])
    # 从inputs中删除
    inputs.remove(s)
    if s 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 s in readable:  # 每一个s就是有个socket
 
        if s 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 s not in outputs:
                    outputs.append(s)  # 为了不影响处理与其它客户端的连接 , 这里不立刻返回数据给客户端
 
            else:  # 如果收不到data代表什么呢? 代表客户端断开了
                print("client [%s] closed", s)
 
                if s in outputs:
                    # 既然客户端都断开了，我就不用再给它返回数据了，
                    # 所以这时候如果这个客户端的连接对象还在outputs列表中，就把它删掉
                    outputs.remove(s)
 
                inputs.remove(s)  # 这个连接必然在inputs中，也删掉
                s.close()
 
                # 关闭的连接在队列中也删除
                del message_queues[s]
 
    for s 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 s in exceptional:
        print('handling exceptional condition for', s.getpeername()[0])
        # 从inputs中删除
        inputs.remove(s)
        if s 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
s = 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

python select模块的更多相关文章

  1. python select模块详解

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

  2. Python select模块学习

    select 是常用的异步socket 处理方法 一般用法: # iwtd,owtd,ewtd 分别为需要异步处理的读socket队列, 写socket队列(一般不用), 和错误socket队列, 返 ...

  3. python成长之路【第十篇】：浅析python select模块

    一.select介绍 select()的机制中提供一fd_set的数据结构,实际上是一long类型的数组, 每一个数组元素都能与一打开的文件句柄(不管是Socket句柄,还是其他文件或命名管道或设备句 ...

  4. python中的select模块

    介绍: Python中的select模块专注于I/O多路复用,提供了select  poll  epoll三个方法(其中后两个在Linux中可用,windows仅支持select),另外也提供了kqu ...

  5. python select.select模块通信全过程详解

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

  6. Python自动化开发 - select模块

    介绍: IO-多路复用:监听多个socker对象是否有变化,包括可读.可写.发送错误 Python中的select模块专注于I/O多路复用,提供了select poll epoll三个方法(其中后两个 ...

  7. 深入理解python中的select模块

    简介 Python中的select模块专注于I/O多路复用,提供了select  poll  epoll三个方法(其中后两个在Linux中可用,windows仅支持select),另外也提供了kque ...

  8. python下的select模块使用 以及epoll与select、poll的区别

    python下的select模块使用 以及epoll与select.poll的区别 先说epoll与select.poll的区别(总结) 整理http://www.zhihu.com/question ...

  9. python学习之-- IO多路复用 select模块

    python I/O多路复用包括3个模块,上一篇已经说过概念,这里我使用的是select模块实现一个ftp并发 服务器端核心代码: import socket,select import queue, ...

随机推荐

  1. 用一个N点复序列的FFT同时计算两个N点实序列离散傅里叶变换

    一.功能 用一个\(N\)点复序列快速傅立叶变换算法来同时计算两个\(N\)点实序列的离散傅立叶变换. 二.方法简介 假设\(x(n)\)与\(y(n)\)都是长度为\(N\)的实序列,为计算其离散傅 ...

  2. Kafka的性能分析

    都说Kafka的吞吐量很大,但是我一直不直到Kafka为何有如此大的吞吐量.最近在看Kafka权威指南,陆陆续续得到了如下结论: 1.分区:Kafka支持分区,这样就支持多个生产者和多个消费者同时请求 ...

  3. Linux Backup: Hard Disk Clone with "dd"

      Most of Windows users may know "Norton Ghost". Norton Ghost is a backup software for har ...

  4. 如何利用while语句根据用户输入要求打印菱形图案

    需求:如何利用while语句根据用户输入要求打印菱形图案 diamond.py代码如下: x=int(input('Please input number: ')) i=1 j=1 while i&l ...

  5. Ubuntu系统---“NVIDIA 驱动+CUDA+cuDNN ”之后 OpenCV安装

    Ubuntu系统---“NVIDIA 驱动+CUDA+cuDNN ”之后 OpenCV安装 目录: 一.OpenCV安装包下载 二.cmake安装 三.OpenCV安装 正文 一.OpenCV安装包下 ...

  6. 什么是调整后的R方

    当给模型增加自变量时,复决定系数也随之逐步增大,当自变量足够多时总会得到模型拟合良好,而实际却可能并非如此.于是考虑对R2进行调整,记为Ra2,称调整后复决定系数.R2＝SSR/SST=1-SSE/S ...

  7. .NET 推荐博客

    燎原之星的博客 农码一生博文索引 http://www.cnblogs.com/zhaopei/p/Indexes.html 那些年搞不懂的术语.概念:协变.逆变.不变体 http://www.cnb ...

  8. JMeter学习之元件的作用域与执行顺序

    1.元件的作用域 JMeter中共有8类可被执行的元件(测试计划与线程组不属于元件),这些元件中,取样器是典型的不与其它元件发生交互作用的元件,逻辑控制器只对其子节点的取样器有效,而其它元件(conf ...

  9. ajax 页面无刷新

    <!-- 使用原生Ajax 和 $.ajax 实现局部刷新的过程 --><!-- 封装通用XMLHttpRequest对象 --><!DOCTYPE html>&l ...

  10. PHP mysqli_commit() 函数

    关闭自动提交,做一些查询,然后提交查询: <?php // 假定数据库用户名:root,密码:123456,数据库:RUNOOB $con=mysqli_connect("localh ...