PyQt के लिए MVC पैटर्न लागू करना

सभी को शुभ दिन!
यह लेख दो-संख्या जोड़ कार्यक्रम के उदाहरण का उपयोग करते हुए, PyQt का उपयोग करने वाले अनुप्रयोगों के लिए MVC डिज़ाइन पैटर्न के कार्यान्वयन का वर्णन करता है। पैटर्न के कार्यान्वयन का वर्णन करने के अलावा, एप्लिकेशन बनाने की प्रक्रिया का विवरण प्रदान किया गया है।

0 परिचय

एमवीसी - एक डिज़ाइन पैटर्न जो आपको कार्यों के डेटा मॉडल, प्रस्तुति और प्रसंस्करण को प्रभावी ढंग से अलग करने की अनुमति देता है। MVC में तीन डिज़ाइन पैटर्न शामिल हैं: पर्यवेक्षक , रणनीति और लेआउट । लेख एरिक फ्रीमैन की पुस्तक डिज़ाइन पैटर्न में वर्णित एक सक्रिय मॉडल के साथ क्लासिक एमवीसी योजना पर चर्चा करता है।

आगे के काम के लिए आपको आवश्यकता होगी:

• अजगर 3.2
• PyQt 4.9.1
• आईडीई (मैंने PyCharm 2.0.2 का इस्तेमाल किया)

1 परियोजना संरचना

चलो SimpleMVC प्रोजेक्ट को कॉल करें। ताकि कार्य इतना तुच्छ नहीं लगता है, हम ए और बी नहीं , बल्कि सी और डी जोड़ते हैं । परियोजना में चार मॉड्यूल शामिल हैं। मॉडल , नियंत्रक और दृश्य मॉड्यूल क्रमशः मॉडल , नियंत्रक और दृश्य के कार्यान्वयन का प्रतिनिधित्व करते हैं। यूटिलिटी मॉड्यूल में सहायक वर्ग होते हैं। Main.pyw फ़ाइल को एप्लिकेशन को चलाने के लिए डिज़ाइन किया गया है।

  SimpleMVC \
     नियंत्रक \
         __init__.py
         CplusDController.py
     मॉडल \
         __init__.py
         CplusDModel.py
     उपयोगिता \
         __init__.py
         CplusDMeta.py
         CplusDObserver.py
     देखें
         __init__.py
         CplusDView.py
         MainWindow.py
         MainWindow.ui
     main.pyw 

2 एक मॉडल बनाना

मॉडल (सबसे पहले!) आवेदन तर्क के लिए जिम्मेदार है। CplusDModel का कार्य दो संख्याओं का जोड़ है। CplusDModel.py फ़ाइल:

class CplusDModel: """  CplusDModel     .      c, d   .   ,       .    ,    . """ def __init__( self ): self._mC = 0 self._mD = 0 self._mSum = 0 self._mObservers = [] #   @property def c( self ): return self._mC @property def d( self ): return self._mD @property def sum( self ): return self._mSum @c.setter def c( self, value ): self._mC = value self._mSum = self._mC + self._mD self.notifyObservers() @d.setter def d( self, value ): self._mD = value self._mSum = self._mC + self._mD self.notifyObservers() def addObserver( self, inObserver ): self._mObservers.append( inObserver ) def removeObserver( self, inObserver ): self._mObservers.remove( inObserver ) def notifyObservers( self ): for x in self._mObservers: x.modelIsChanged() 

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

 from abc import ABCMeta, abstractmethod class CplusDObserver( metaclass = ABCMeta ): """     . """ @abstractmethod def modelIsChanged( self ): """         . """ pass 

बेशक, "बहुत लचीला अजगर" आपको एक सार सुपरक्लास के बिना बिल्कुल भी करने या मुश्किल NotImplementedError () अपवाद का उपयोग करने की अनुमति देता है। मेरी राय में, यह एप्लिकेशन आर्किटेक्चर को प्रतिकूल रूप से प्रभावित कर सकता है।
मैं ध्यान देना चाहूंगा कि PyQt का उपयोग करके, हम स्लॉट-सिग्नल मॉडल का उपयोग कर सकते हैं। इस स्थिति में, जब स्थिति बदलती है, तो मॉडल द्वारा एक संकेत भेजा जाएगा जो सभी जुड़े पर्यवेक्षकों को प्राप्त करने में सक्षम होगा। यह दृष्टिकोण कम सार्वभौमिक लगता है - शायद भविष्य में आप किसी अन्य पुस्तकालय का उपयोग करना चाहेंगे।
अधिक जटिल प्रणालियों में, पर्यवेक्षक पैटर्न (पंजीकरण, विलोपन और पर्यवेक्षकों की अधिसूचना) को लागू करने वाले कार्यात्मक को एक अलग सार वर्ग में परिवर्तित किया जा सकता है। वास्तुकला के आधार पर, वर्ग अमूर्त नहीं हो सकता है।

3 एक दृश्य बनाएँ

एक दृश्य ग्राफिकल घटकों का एक संयोजन है और एक लिंकर पैटर्न को लागू करता है। एक दृश्य बनाने के लिए, हम दृश्य संपादक डिजाइनर का उपयोग करेंगे, जो कि PyQt के साथ शामिल है। मेनविंडो पर आधारित एक फॉर्म बनाएँ। आकार संरचना:

  मेनविंडो - QMainWindow
     CentralWidget - QWidget
         lbl_equal - QLabel
         lbl_plus - QLabel
         le_c - QLineEdit
         le_d - QLineEdit
         le_result - QLineEdit 

रूप की उपस्थिति:



प्रपत्र का पूर्वावलोकन करने के लिए, Ctrl + R का उपयोग करें। MainWindow.ui नाम के तहत दृश्य निर्देशिका में फ़ाइल सहेजें। अब हम इसके आधार पर MainWindow.py फ़ाइल जनरेट करेंगे। ऐसा करने के लिए, pyuic4.bat (... \ Python32 \ Lib \ साइट-संकुल \ PyQt4) का उपयोग करें। का पालन करें:

  pyuic4.bat ... \ SimpleMVC \ View \ MainWindow.ui -o ... \ SimpleMVC \ View \ MainWindow.py 

"..." के बजाय आपको प्रोजेक्ट के साथ निर्देशिका में पथ जोड़ना होगा। उदाहरण के लिए, पूरा रास्ता इस तरह दिख सकता है:

  D: \ Projects \ PythonProjects \ SimpleMVC \ View \ MainWindow.ui 

यदि कोई संसाधन फ़ाइल प्रोजेक्ट में मौजूद है, तो उसे कनवर्ट करने के लिए, आपको pyrcc4.exe (... \ Python32 \ Lib \ साइट-संकुल \ PyQt4) का उपयोग करने की आवश्यकता है। पायथन 3.x के लिए, आपको -py3 ध्वज को पास करना होगा:

  pyrcc4.exe -o ... \ SimpleMVC \ View \ MainWindow_rc.py -py3 ... \ SimpleMVC \ View \ MainWindow_rc.qrc 

"_Rc" पर ध्यान दें। तथ्य यह है कि अगर कोई संसाधन फ़ाइल हमारे फॉर्म से जुड़ी थी, तो pyuic4.bat स्वचालित रूप से फ़ाइल के अंत में जोड़ देगा:

 import MainWindow_rc 

अब आपको व्यू क्लास बनाने की जरूरत है। एमवीसी वास्तुकला के अनुसार, दृश्य एक पर्यवेक्षक होना चाहिए। CplusDView.py फ़ाइल:

 from PyQt4.QtGui import QMainWindow, QDoubleValidator from PyQt4.QtCore import SIGNAL from Utility.CplusDObserver import CplusDObserver from Utility.CplusDMeta import CplusDMeta from View.MainWindow import Ui_MainWindow class CplusDView( QMainWindow, CplusDObserver, metaclass = CplusDMeta ): """      CplusDModel. """ def __init__( self, inController, inModel, parent = None ): """       . """ super( QMainWindow, self ).__init__( parent ) self.mController = inController self.mModel = inModel #    self.ui = Ui_MainWindow() self.ui.setupUi( self ) #      self.mModel.addObserver( self ) #      self.ui.le_c.setValidator( QDoubleValidator() ) self.ui.le_d.setValidator( QDoubleValidator() ) #        self.connect( self.ui.le_c, SIGNAL( "editingFinished()" ), self.mController.setC ) self.connect( self.ui.le_d, SIGNAL( "editingFinished()" ), self.mController.setD ) def modelIsChanged( self ): """     .     . """ sum = str( self.mModel.sum ) self.ui.le_result.setText( sum ) 

ध्यान दें कि दृश्य दो वर्गों का वंशज है: QMainWindow और CplusDObserver । दोनों वर्ग अलग-अलग मेटाक्लासेस का उपयोग करते हैं। इसलिए, CplusDView वर्ग के लिए, आपको एक मेटाक्लस सेट करना होगा जो QMainWindow और CplusDObserver द्वारा उपयोग किए जाने वाले मेटाक्लासेस को इनहेरिट करेगा। इस मामले में, यह CplusDMeta है । CplusDMeta.py फ़ाइल:

 """   ,    . pyqtWrapperType -      Qt. ABCMeta -     . CplusDMeta -   . """ from PyQt4.QtCore import pyqtWrapperType from abc import ABCMeta class CplusDMeta( pyqtWrapperType, ABCMeta ): pass 

4 एक नियंत्रक बनाना

नियंत्रक पैटर्न रणनीति को लागू करता है। नियंत्रक अपने कार्यों को नियंत्रित करने के लिए दृश्य से जोड़ता है। इस मामले में, नियंत्रक का कार्यान्वयन बहुत तुच्छ है। CplusDController.py फ़ाइल:

 from View.CplusDView import CplusDview class CplusDController(): """  CplusDController   .     . """ def __init__( self, inModel ): """     .     . """ self.mModel = inModel self.mView = CplusDview( self, self.mModel ) self.mView.show() def setC( self ): """        C,    c . """ c = self.mView.ui.le_c.text() self.mModel.c = float( c ) def setD( self ): """        D,    d . """ d = self.mView.ui.le_d.text() self.mModel.d = float( d ) 

5 घटकों का कनेक्शन

यह सभी घटकों को संयोजित करने और कार्यक्रम की जांच करने के लिए बनी हुई है। मेनहोम फ़ाइल:

 import sys from PyQt4.QtGui import QApplication from Model.CplusDModel import CplusDModel from Controller.CplusDController import CplusDController def main(): app = QApplication( sys.argv ) #   model = CplusDModel() #         controller = CplusDController( model ) app.exec() if __name__ == '__main__': sys.exit( main() ) 

आपका ध्यान के लिए धन्यवाद!

---

स्रोत कोड