पायथन शुरुआती लोगों के लिए

प्रस्तावना

2010 में वापस, मेरे लिए, मैंने पायथन में सॉकेट्स के बारे में शुरुआती लेख लिखा। अब यह ब्लॉग गुमनामी में डूब गया है, लेकिन यह लेख मुझे उपयोगी नहीं लगा। मुझे एक फ्लैश ड्राइव पर लेख एक तुला दस्तावेज़ में मिला, इसलिए यह क्रॉस-पोस्ट नहीं है, कॉपी-पेस्ट नहीं है - यह इंटरनेट पर कहीं नहीं है।

यह क्या है

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

क्लाइंट और सर्वर सॉकेट हैं। यह अनुमान लगाना आसान है कि क्या है। सर्वर सॉकेट एक विशिष्ट पोर्ट पर सुनता है, जबकि क्लाइंट सॉकेट सर्वर से कनेक्ट होता है। कनेक्शन स्थापित हो जाने के बाद, डेटा विनिमय शुरू होता है।


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

एक सफल कनेक्शन के बाद, सर्वर और क्लाइंट जानकारी का आदान-प्रदान करना शुरू करते हैं। उदाहरण के लिए, सर्वर एक कमांड दर्ज करने के लिए ग्रीटिंग और एक प्रांप्ट भेजता है। क्लाइंट, बदले में, कमांड में प्रवेश करता है, सर्वर इसका विश्लेषण करता है, आवश्यक संचालन करता है और क्लाइंट को परिणाम देता है।

सर्वर

अब दो फाइलें बनाएं - एक सर्वर के लिए और एक क्लाइंट के लिए।

अजगर सॉकेट के साथ काम करने के लिए सॉकेट मॉड्यूल का उपयोग करता है:

import socket 

सबसे पहले, हमें एक सॉकेट बनाने की आवश्यकता है:

 sock = socket.socket() 

यहां कुछ खास नहीं है और यह हिस्सा क्लाइंट और सर्वर सॉकेट दोनों के लिए सामान्य है। आगे हम सर्वर के लिए कोड लिखेंगे। यह काफी तार्किक है - अगर कनेक्ट करने के लिए कहीं नहीं है तो हमें क्लाइंट एप्लिकेशन क्यों लिखना चाहिए :)

अब हमें अपने सर्वर के लिए होस्ट और पोर्ट को निर्धारित करने की आवश्यकता है। मेजबान के लिए - हम लाइन को खाली छोड़ देंगे ताकि हमारा सर्वर सभी इंटरफेस के लिए सुलभ हो। और किसी भी पोर्ट को शून्य से 65535 तक ले जाएं। यह ध्यान दिया जाना चाहिए कि संख्या 0 - 1023 के साथ बंदरगाहों को सुनने वाले अधिकांश ऑपरेटिंग सिस्टम में विशेष विशेषाधिकार की आवश्यकता होती है। मैंने पोर्ट 9090 को चुना। अब हम अपने सॉकेट को दिए गए होस्ट और पोर्ट के साथ बाइंड विधि का उपयोग करके कनेक्ट करेंगे, जिसमें टपल को प्रेषित किया जाता है, पहला तत्व (या शून्य, यदि हम शून्य से गिनते हैं) होस्ट है, और दूसरा पोर्ट है।

 sock.bind(('', 9090)) 

अब हम कनेक्शन स्वीकार करने के लिए पूरी तरह तैयार हैं। सुनो पद्धति का उपयोग करते हुए, हम इस सॉकेट के लिए सुनना शुरू करते हैं। विधि एक तर्क लेती है - कतार में कनेक्शन की अधिकतम संख्या। हम अपनी जंगली कल्पना को रोकते हैं और खिड़कियों के साथ हॉल को याद करते हैं। तो यह पैरामीटर कतार के आकार को निर्धारित करता है। यदि यह एक पर सेट है, और कोई व्यक्ति, जाहिर है, बहुत ही कम है, फिर भी पीठ को समायोजित करने की कोशिश कर रहा है, तो वे इसे भेज देंगे :) इसे एक पर स्थापित करें:

 sock.listen(1) 

खैर, आखिरकार, हम स्वीकार पद्धति का उपयोग करके कनेक्शन को स्वीकार कर सकते हैं, जो दो तत्वों के साथ एक टपल लौटाता है: एक नया सॉकेट और एक ग्राहक पता। यह सॉकेट है जिसका उपयोग क्लाइंट को डेटा प्राप्त करने और भेजने के लिए किया जाएगा।

 conn, addr = sock.accept() 

वह सब है। अब हमने ग्राहक के साथ संचार स्थापित किया है और हम उसके साथ "संवाद" कर सकते हैं। क्योंकि हम वास्तव में यह नहीं जान सकते कि ग्राहक हमें किन और किन संस्करणों में भेजेगा, तब हम उससे छोटे हिस्से में डेटा प्राप्त करेंगे। डेटा प्राप्त करने के लिए आपको recv विधि का उपयोग करने की आवश्यकता होती है, जो तर्क के रूप में पढ़ने के लिए बाइट्स की संख्या लेता है। हम 1024 बाइट्स (या 1 केबी) के भागों में पढ़ेंगे:

 while True: data = conn.recv(1024) if not data: break conn.send(data.upper()) 

जैसा कि हमने क्लाइंट के साथ संवाद करने के लिए कहा था, हम सॉकेट का उपयोग करते हैं, जिसे स्वीकार पद्धति के परिणामस्वरूप प्राप्त किया गया था। एक अनंत लूप में, हम recv विधि का उपयोग करके 1024 बाइट डेटा प्राप्त करते हैं। यदि अधिक डेटा नहीं है, तो यह विधि कुछ भी नहीं लौटाती है। इस प्रकार, हम ग्राहक से कोई भी डेटा प्राप्त कर सकते हैं।

हमारे उदाहरण में, स्पष्टता के लिए, हम प्राप्त आंकड़ों के साथ कुछ करेंगे और इसे ग्राहक को वापस भेजेंगे। उदाहरण के लिए, स्ट्रिंग्स पर ऊपरी विधि का उपयोग करके, क्लाइंट को ऊपरी मामले में एक स्ट्रिंग लौटाएं।

अब आप कनेक्शन बंद कर सकते हैं:

 conn.close() 

दरअसल सर्वर तैयार है। यह कनेक्शन को स्वीकार करता है, क्लाइंट से डेटा प्राप्त करता है, उन्हें अपरकेस में एक स्ट्रिंग के रूप में देता है, और कनेक्शन को बंद कर देता है। सब कुछ सरल है :) परिणामस्वरूप, आपके पास निम्नलिखित होना चाहिए:

 #!/usr/bin/env python # -*- coding: utf-8 -*- import socket sock = socket.socket() sock.bind(('', 9090)) sock.listen(1) conn, addr = sock.accept() print 'connected:', addr while True: data = conn.recv(1024) if not data: break conn.send(data.upper()) conn.close() 

ग्राहक

मुझे लगता है कि अब यह आसान हो जाएगा। और क्लाइंट एप्लिकेशन स्वयं सरल है - हमें एक सॉकेट बनाने, सर्वर से कनेक्ट करने, उसे डेटा भेजने, डेटा प्राप्त करने और कनेक्शन बंद करने की आवश्यकता है। यह सब इस तरह किया जाता है:

 #!/usr/bin/env python # -*- coding: utf-8 -*- import socket sock = socket.socket() sock.connect(('localhost', 9090)) sock.send('hello, world!') data = sock.recv(1024) sock.close() print data 

मुझे लगता है कि सब कुछ स्पष्ट है, क्योंकि सब कुछ पहले से ही हल किया गया था। यहां केवल नई चीज कनेक्ट विधि है, जिसके साथ हम सर्वर से जुड़ते हैं। अगला, हम 1024 बाइट डेटा पढ़ते हैं और सॉकेट बंद करते हैं।