पायथन के चुनिंदा मॉड्यूल में चयन() फ़ंक्शन वास्तव में कैसे काम करता है?

Question

मैं पायथन में नेटवर्क-उन्मुख एप्लिकेशन लिखने पर काम कर रहा हूं। मैंने पहले ब्लॉकिंग सॉकेट का उपयोग करने पर काम किया था, लेकिन आवश्यकता और अवधारणाओं की बेहतर समझ के बाद, मैं गैर-अवरुद्ध सॉकेट और इस प्रकार एक ईवेंट-संचालित सर्वर का उपयोग करके एप्लिकेशन लिखना चाहता हूं।

मैं समझता हूं कि पाइथन में चुनिंदा मॉड्यूल में फ़ंक्शंस का उपयोग आसानी से देखने के लिए किया जाता है कि कौन सा सॉकेट हमें और बहुत आगे करता है। कि ओर मैं मूल रूप से एक घटना पर ही आधारित सर्वर के उदाहरण के एक जोड़े के माध्यम से फ्लिप करने की कोशिश कर रहा था और मैं भर में यह एक आया था:

""" 
An echo server that uses select to handle multiple clients at a time. 
Entering any line of input at the terminal will exit the server. 
""" 

import select 
import socket 
import sys 

host = '' 
port = 50000 
backlog = 5 
size = 1024 
server = socket.socket(socket.AF_INET, socket.SOCK_STREAM) 
server.bind((host,port)) 
server.listen(backlog) 
input = [server,sys.stdin] 
running = 1 
while running: 
    inputready,outputready,exceptready = select.select(input,[],[]) 

    for s in inputready: 

     if s == server: 
      # handle the server socket 
      client, address = server.accept() 
      input.append(client) 

     elif s == sys.stdin: 
      # handle standard input 
      junk = sys.stdin.readline() 
      running = 0 

     else: 
      # handle all other sockets 
      data = s.recv(size) 
      if data: 
       s.send(data) 
      else: 
       s.close() 
       input.remove(s) 
server.close() 

भागों है कि मुझे समझ में नहीं लगता था निम्नलिखित हैं:

कोड स्निपेट inputready,outputready,exceptready = select.select(input,[],[]) में, मेरा मानना ​​है कि select() फ़ंक्शन इनपुट, आउटपुट और असाधारण स्थितियों के लिए प्रतीक्षा करने योग्य वस्तुओं की तीन संभावित रिक्त सूचियां देता है। तो यह समझ में आता है कि select() फ़ंक्शन का पहला तर्क सर्वर सॉकेट और stdin युक्त सूची है। हालांकि, जहां मुझे भ्रम का सामना करना पड़ता है, वह कोड के else ब्लॉक में है।

चूंकि हम इनपुट पहले से सॉकेट की सूची में फॉर-लूपिंग कर रहे हैं, यह स्पष्ट है कि select() फ़ंक्शन क्लाइंट सॉकेट का चयन करेगा जो पढ़ने के लिए तैयार है। हालांकि, recv() का उपयोग करके डेटा पढ़ने के बाद और पता लगाएं कि सॉकेट ने वास्तव में डेटा भेजा है, हम इसे वापस ग्राहक को गूंजना चाहते हैं। मेरा सवाल यह है कि हम इस सॉकेट को select() फ़ंक्शन कॉल के दूसरे तर्क के रूप में पारित सूची में जोड़ने के बिना कैसे लिख सकते हैं? मतलब, हम send() को नए सॉकेट पर सीधे select() के साथ एक लिखने योग्य सॉकेट के रूप में 'पंजीकरण' किए बिना कैसे कॉल कर सकते हैं?

इसके अलावा, हम केवल पढ़ने के लिए तैयार सॉकेट पर लूप क्यों करते हैं (इस मामले में इनपुट पहले से ही)? क्या आउटपुट सूची में लूप करना जरूरी नहीं है यह देखने के लिए कि कौन से सॉकेट लिखे जाने के लिए तैयार हैं? जाहिर है, मुझे यहां कुछ याद आ रहा है।

यह वास्तव में उपयोगी होगा अगर कोई select() फ़ंक्शन या अच्छे दस्तावेज़ों के लिए काम करने के लिए थोड़ा अधिक विस्तृत फैशन में समझा सकता है।

धन्यवाद।

Answer 1

शायद कोड का स्निपेट सिर्फ एक साधारण उदाहरण है और इसलिए यह संपूर्ण नहीं है। आप प्रत्येक सॉकेट में लिखने और पढ़ने के लिए स्वतंत्र हैं, भले ही चयन आपको यह न बताए कि वे तैयार हैं। लेकिन, ज़ाहिर है, अगर आप ऐसा करते हैं तो आप यह सुनिश्चित नहीं कर सकते कि आपका प्रेषण() ब्लॉक नहीं होगा। तो, हाँ, लिखने के संचालन के लिए भी चयन पर भरोसा करना सबसे अच्छा अभ्यास होगा। ऐसे कई अन्य फ़ंक्शन भी हैं जिनका एक समान उद्देश्य है और कई मामलों में वे बेहतर होते हैं (उदा। epoll), लेकिन वे सभी प्लेटफ़ॉर्म पर उपलब्ध नहीं हैं। चयन के बारे में जानकारी, एपोल & अन्य फ़ंक्शंस लिनक्स मैन पेजों में मिल सकते हैं।

हालांकि अजगर में वहाँ कई कनेक्शन को संभालने के लिए इस्तेमाल किया कई अच्छा पुस्तकालय हैं, इनमें से कुछ हैं: Twisted और gevent