माइक्रोस्कोप के तहत Django

अगर अर्टिओम मालेशेव ( प्रूफिट404 ) की रिपोर्ट के अनुसार, वे एक फिल्म बनाएंगे, तो निर्देशक क्वेंटिन टारनटिनो होंगे - उन्होंने पहले से ही एक फिल्म बनाई है जो जांगो के बारे में, वह दूसरी शूटिंग भी करेंगे। प्रतिक्रिया के अंतिम बाइट के लिए HTTP अनुरोध के पहले बाइट से Django आंतरिक तंत्र के जीवन से सभी विवरण। पार्सर रूपों का अतिरिक्त रूप, SQL का एक्शन-पैक्ड संकलन, HTML के लिए टेम्पलेट इंजन के कार्यान्वयन का विशेष प्रभाव। कनेक्शन पूल का प्रबंधन कौन और कैसे कर रहा है? यह सब WSGI वस्तुओं के प्रसंस्करण के कालानुक्रमिक क्रम में है। देश के सभी स्क्रीनों पर - डिकोडिंग "Django अंडर माइक्रोस्कोप"।



स्पीकर के बारे में: एरीटोम मालिशेव सूखी पायथन परियोजना के संस्थापक और Django चैनल संस्करण 1.0 के मुख्य डेवलपर हैं। वह 5 साल से पायथन लिख रहा है और उसने निज़नी नोवगोरोड में पायथन रैन्टस की बैठकों को आयोजित करने में मदद की है। PROOFIT404 उपनाम के तहत Artyom आपसे परिचित हो सकता है। रिपोर्ट की प्रस्तुति यहां संग्रहीत है ।


एक बार, हमने Django के पुराने संस्करण को लॉन्च किया। तब वह डरावनी और उदास लग रही थी।



उन्होंने देखा कि self_check पास हो गया है, हमने सब कुछ सही ढंग से स्थापित किया, सब कुछ काम किया और अब आप कोड लिख सकते हैं। यह सब हासिल करने के लिए, हमें django-admin runserver ।

 $ django-admin runserver Performing system checks… System check identified no issues (0 silenced). You have unapplied migrations; your app may not work properly until they are applied. Run 'python manage.py migrate1 to apply them. August 21, 2018 - 15:50:53 Django version 2.1, using settings 'mysite.settings' Starting development server at http://127.0.0.1:8000/Quit the server with CONTROL-C. 

प्रक्रिया शुरू होती है, HTTP अनुरोधों को संसाधित करता है और सभी जादू अंदर होता है और सभी कोड जो हम उपयोगकर्ताओं को एक साइट के रूप में दिखाना चाहते हैं, निष्पादित होते हैं।

स्थापना

django-admin सिस्टम पर दिखाई देता है जब हम Django का उपयोग कर स्थापित करते हैं, उदाहरण के लिए, पाइप, पैकेज मैनेजर ।

 $ pip install Django # setup.py from setuptools import find_packages, setup setup( name='Django', entry_points={ 'console_scripts': [ 'django-admin = django.core.management:execute_from_command_line' ] }, ) 

entry_points setuptools प्रकट होता है, जो कार्य execute_from_command_line करने के लिए execute_from_command_line करता execute_from_command_line फ़ंक्शन। यह फ़ंक्शन किसी भी मौजूदा प्रक्रिया के लिए Django के साथ किसी भी ऑपरेशन के लिए एक प्रवेश बिंदु है।

बूटस्ट्रैप

एक फंक्शन के अंदर क्या होता है? बूटस्ट्रैप , जिसे दो पुनरावृत्तियों में विभाजित किया गया है।

 # django.core.management django.setup(). 

सेटिंग्स कॉन्फ़िगर करें

पहला कॉन्फिग रीडिंग है :

 import django.conf.global_settings import_module(os.environ["DJANGO_SETTINGS_MODULE"]) 

डिफ़ॉल्ट सेटिंग्स global_settings , फिर पर्यावरण चर से हम global_settings साथ मॉड्यूल को खोजने का प्रयास करते हैं, जिसे उपयोगकर्ता ने लिखा था। इन सेटिंग्स को एक नाम स्थान में जोड़ा जाता है।

जो कोई भी Django में लिखता है, कम से कम "हैलो, दुनिया" जानता है कि INSTALLED_APPS - जहां हम उपयोगकर्ता कोड लिखते हैं।

ऐप्स आबाद करें

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

 for entry in settings.INSTALLED_APPS: cfg = AppConfig.create(entry) cfg.import_models() 

यह मॉडल के लिए, व्यवस्थापक पैनल के लिए, किसी भी चीज़ के लिए - डेटाबेस से कनेक्ट किए बिना, कुछ सुपर जटिल और विशिष्ट बिना न्यूनतम शुद्धता की जांच है। इस स्तर पर, Django को अभी तक नहीं पता है कि आपने किस कमांड को निष्पादित करने के लिए कहा है, अर्थात, runserver या shell से migrate को भेद नहीं करता है।

फिर हम खुद को एक मॉड्यूल में पाते हैं जो कमांड लाइन के तर्कों द्वारा अनुमान लगाने की कोशिश करता है कि हम किस कमांड को निष्पादित करना चाहते हैं और किस एप्लिकेशन में निहित है।

प्रबंधन की कमान

 # django.core.management subcommand = sys.argv[1] app_name = find(pkgutils.iter_modules(settings.INSTALLED_APPS)) module = import_module( '%s.management.commands.%s' % (app_name, subcommand) ) cmd = module.Command() cmd.run_from_argv(self.argv) 

इस स्थिति में, रनस्वर मॉड्यूल में एक अंतर्निहित django.core.management.commands.runserver मॉड्यूल होगा। मॉड्यूल को आयात करने के बाद, कन्वेंशन द्वारा, ग्लोबल क्लास Command को अंदर बुलाया जाता है, Command से कहा जाता है, और हम कहते हैं: " मैंने आपको पाया, यहां आपके पास कमांड लाइन तर्क हैं कि उपयोगकर्ता पास हो गया, उनके साथ कुछ करें ।"

इसके बाद, हम रनसर्वर मॉड्यूल पर जाते हैं और देखते हैं कि Django "regexp और स्टिक" से बना है , जिसके बारे में मैं आज विस्तार से बात करूंगा:

 # django.core.management.commands.runserver naiveip_re = re.compile(r"""^(?: (?P<addr> (?P<ipv4>\d{1,3}(?:\.\d{1,3}){3}) | # IPv4 address (?P<ipv6>\[[a-fA-F0-9:]+\]) | # IPv6 address (?P<fqdn>[a-zA-Z0-9-]+(?:\.[a-zA-Z0-9-]+)*) # FQDN ):)?(?P<port>\d+)$""", re.X) 

आदेश

डेढ़ स्क्रीन नीचे स्क्रॉल करें - अंत में हम सर्वर शुरू करने वाली हमारी टीम की परिभाषा में आते हैं।

 # django.core.management.commands.runserver class Command(BaseCommand): def handle(self, *args, **options): httpd = WSGIServer(*args, **options) handler = WSGIHandler() httpd.set_app(handler) httpd.serve_forever() 

BaseCommand कमांड लाइन तर्कों के लिए संचालन का एक न्यूनतम सेट करता है, जिसके परिणामस्वरूप *args और **options कार्यों को कॉल करने के लिए तर्क **options हैं। हम देखते हैं कि WSGI सर्वर का उदाहरण यहां बनाया जा रहा है, इस WSGI सर्वर में वैश्विक WSGIHandler स्थापित है - यह बिल्कुल God Object Django है । हम कह सकते हैं कि यह रूपरेखा का एकमात्र उदाहरण है। इंस्टेंस पर सर्वर विश्व स्तर पर - set application माध्यम से set application और कहता है: "इवेंट लूप में स्पिन करें, अनुरोध निष्पादित करें।"

हमेशा कहीं न कहीं एक इवेंट लूप होता है और एक प्रोग्रामर जो उसे टास्क देता है।

WSGI सर्वर

WSGIHandler क्या है? WSGI एक इंटरफ़ेस है जो आपको HTTP अनुरोधों को न्यूनतम स्तर के अमूर्त रूप से संसाधित करने की अनुमति देता है, और फ़ंक्शन के रूप में कुछ दिखता है।

WSGI हैंडलर

 # django.core.handlers.wsgi class WSGIHandler: def __call__(self, environ, start_response): signals.request_started.send() request = WSGIRequest(environ) response = self.get_response(request) start_response(response.status, response.headers) return response 

उदाहरण के लिए, यहां यह एक वर्ग का एक उदाहरण है जिसमें एक call परिभाषित है। वह अपने शब्दकोश प्रविष्टि का इंतजार करता है, जिसमें हेडर को बाइट्स और एक फ़ाइल-हैंडलर के रूप में प्रस्तुत किया जाएगा। अनुरोध की <body> पढ़ने के लिए हैंडलर की आवश्यकता होती है। सर्वर स्वयं भी कॉलबैक start_response देता है ताकि हम एक बंडल में response.headers , हेडर और उसके हेडर, उदाहरण के लिए, स्थिति भेज सकें।

इसके अलावा, हम रिस्पांस ऑब्जेक्ट के माध्यम से सर्वर को रिस्पॉन्स बॉडी पास कर सकते हैं। प्रतिक्रिया एक जनरेटर है जिसे आप ओवररेट कर सकते हैं।

WSGI के लिए लिखे गए सभी सर्वर - Gunicorn, uWSGI, वेट्रेस, इस इंटरफ़ेस पर काम करते हैं और विनिमेय हैं। अब हम विकास के लिए एक सर्वर पर विचार कर रहे हैं, लेकिन कोई भी सर्वर इस बिंदु पर आता है कि Django में यह एनसाइट और कॉलबैक के माध्यम से दस्तक देता है।

ईश्वर वस्तु के अंदर क्या है?

Django के अंदर इस ग्लोबल गॉड ऑब्जेक्ट फ़ंक्शन के अंदर क्या होता है?

• अनुरोध।
• MIDDLEWARES।
• देखने का अनुरोध अनुरोध
• दृश्य - अंदर देखने के लिए उपयोगकर्ता कोड प्रसंस्करण।
• फार्म - रूपों के साथ काम करते हैं।
• ORM।
• खाका।
• प्रतिक्रिया।

Django से हम जो भी मशीनरी चाहते हैं, वह एक ही फ़ंक्शन के भीतर होती है, जो पूरे ढांचे में फैली हुई है।

प्रार्थना

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

 # django.core.handlers.wsgi class WSGIRequest(HttpRequest): @cached_property def GET(self): return QueryDict(self.environ['QUERY_STRING']) @property def POST(self): self._load_post_and_files() return self._post @cached_property def COOKIES(self): return parse_cookie(self.environ['HTTP_COOKIE']) 

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

आगे अनुरोध मिडलवेयर को मिलता है।

Middlewares

मिडिलवेयर एक आवरण है जो अन्य कार्यों को एक डेकोरेटर की तरह लपेटता है। मिडलवेयर का नियंत्रण छोड़ने से पहले, कॉल विधि में हम एक प्रतिक्रिया देते हैं या पहले से ही लिपटे मिडलवेयर को कॉल करते हैं।

यह वही है जो प्रोग्रामर के दृष्टिकोण से मिडिलवेयर जैसा दिखता है।

सेटिंग

 # settings.py MIDDLEWARE = [ 'django.middleware.security.SecurityMiddleware', 'django.middleware.csrf.CsrfViewMiddleware', 'django.contrib.sessions.middleware.SessionMiddleware', 'django.contrib.auth.middleware.AuthenticationMiddleware', ] 

परिभाषित करें

 class Middleware: def __init__(self, get_response=None): self.get_response = get_response def __call__(self, request): return self.get_response(request) 

Django के दृष्टिकोण से, बिचौलिये एक तरह के ढेर की तरह दिखते हैं:

 # django.core.handlers.base def load_middleware(self): handler = convert_exception_to_response(self._get_response) for middleware_path in reversed(settings.MIDDLEWARE): middleware = import_string(middleware_path) instance = middleware(handler) handler = convert_exception_to_response(instance) self._middleware_chain = handler 

लागू करें

 def get_response(self, request): set_urlconf(settings.ROOT_URLCONF) response = self._middleware_chain(request) return response 

हम प्रारंभिक get_response फ़ंक्शन get_response हैं, इसे एक हैंडलर में लपेटते हैं, जो अनुवाद करेगा, उदाहरण के लिए, permission error और सही HTTP कोड में not found error । हम सूची से ही मिडलवेयर में सब कुछ लपेटते हैं। बिचौलियों का ढेर बढ़ता है, और प्रत्येक अगले पिछले एक को लपेटता है। यह एक परियोजना में सभी विचारों के सज्जाकार के एक ही ढेर को लागू करने के समान है, केवल केंद्रीय रूप से। परियोजना के अनुसार अपने हाथों से चारों ओर घूमने और रैपर की व्यवस्था करने की आवश्यकता नहीं है, सब कुछ सुविधाजनक और तार्किक है।

हम बिचौलियों के 7 हलकों से गुजरे, हमारा अनुरोध बच गया और इसे देखते हुए इसे संसाधित करने का निर्णय लिया गया। इसके अलावा, हम रूटिंग मॉड्यूल पर जाते हैं।

रूटिंग

यह वह जगह है जहां हम तय करते हैं कि किस हैंडलर को किसी विशेष अनुरोध के लिए कॉल करना है। और यह हल है:

• url पर आधारित;
• WSGI विनिर्देश में, जहाँ request.path_info कहा जाता है।

 # django.core.handlers.base def _get_response(self, request): resolver = get_resolver() view, args, kwargs = resolver.resolve(request.path_info) response = view(request, *args, **kwargs) return response 

यूआरएल

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

 # urls.py urlpatterns = [ path('articles/2003/', views.special_case_2003), path('articles/<int:year>/', views.year_archive), path('articles/<int:year>/<int:month>/', views.month_archive) ] 

रिज़ॉल्वर

यह वही है जो रिज़ॉल्वर दिखता है:

 # django.urls.resolvers _PATH_RE = re.compile( r'<(?:(?P<converter>[^>:]+):)?(?P<parameter>\w+)>' ) def resolve(self, path): for pattern in self.url_patterns: match = pattern.search(path) if match: return ResolverMatch( self.resolve(match[0]) ) raise Resolver404({'path': path}) 

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

यह विशेषता है कि संकल्प विधि की पुनरावृत्ति की गहराई हमेशा उन तर्कों की संख्या के बराबर होती है जिनके साथ दृश्य कहा जाता है। अगर कुछ गलत हुआ और हमें कोई विशिष्ट url नहीं मिला, तो त्रुटि नहीं मिली।

फिर हम अंत में देखने में आते हैं - प्रोग्रामर ने जो कोड लिखा था।

राय

अपने सरलतम निरूपण में, यह एक ऐसा कार्य है जो प्रतिक्रिया से अनुरोध देता है, लेकिन इसके अंदर हम तार्किक कार्य करते हैं: "यदि, किसी दिन," - तो कई दोहराए जाने वाले कार्य। Django हमें एक वर्ग आधारित दृश्य प्रदान करता है जहां आप विशिष्ट विवरण निर्दिष्ट कर सकते हैं, और सभी व्यवहार को वर्ग द्वारा सही प्रारूप में व्याख्या किया जाएगा।

 # django.views.generic.edit class ContactView(FormView): template_name = 'contact.html' form_class = ContactForm success_url = '/thanks/' 

विधि फ्लोचार्ट

 self.dispatch() self.post() self.get_form() self.form_valid() self.render_to_response() 

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

प्रपत्र

फॉर्म को सॉकेट से पढ़ा जाना चाहिए इससे पहले कि यह Django दृश्य में हो - उसी फ़ाइल हैंडलर के माध्यम से जो WSGI- पर्यावरण में निहित है। फॉर्म-डेटा एक बाइट स्ट्रीम है, जिसमें विभाजकों का वर्णन किया गया है - हम इन ब्लॉकों को पढ़ सकते हैं और उनमें से कुछ बना सकते हैं। यह एक कुंजी-मूल्य पत्राचार हो सकता है, यदि यह एक फ़ील्ड है, एक फ़ाइल का हिस्सा है, तो फिर से कुछ फ़ील्ड - सब कुछ मिश्रित है।

 Content-Type: multipart/form-data;boundary="boundary" --boundary name="field1" value1 --boundary name="field2"; value2 

पार्सर

पार्सर में 3 भाग होते हैं।

बंक स्ट्रीम से अपेक्षित रीडिंग बनाने वाला चंक इटरेटर एक इटरेटर में बदल जाता है जो boundaries निर्माण कर सकता boundaries । यह गारंटी देता है कि अगर कुछ वापस आता है, तो यह सीमा होगी। यह आवश्यक है ताकि पार्सर के अंदर कनेक्शन की स्थिति को स्टोर करने के लिए आवश्यक न हो, सॉकेट से पढ़ें या डेटा प्रोसेसिंग के तर्क को कम करने के लिए न पढ़ें।

इसके बाद, जनरेटर LazyStream में लपेटता है, जो फिर से एक ऑब्जेक्ट फ़ाइल बनाता है, लेकिन अपेक्षित रीडिंग के साथ। तो पार्सर पहले से ही बाइट के टुकड़ों के माध्यम से चल सकता है और उनसे एक कुंजी-मूल्य का निर्माण कर सकता है।

यहां फ़ील्ड और डेटा हमेशा स्ट्रिंग्स रहेंगे । यदि हमें आईएसओ प्रारूप में एक डेटाटाइम मिला है, तो Django फॉर्म (जिसे प्रोग्रामर द्वारा लिखा गया था), कुछ क्षेत्रों का उपयोग करके प्राप्त करेगा, उदाहरण के लिए, टाइमस्टैम्प।

 # django.http.multipartparser self._post = QueryDict(mutable=True) stream = LazyStream(ChunkIter(self._input_data)) for field, data in Parser(stream): self._post.append(field, force_text(data)) 

आगे फॉर्म, सबसे अधिक संभावना है, खुद को एक डेटाबेस में सहेजना चाहता है, और यहां Django ORM शुरू होता है।

ORM

ORM के लिए ऐसे DSL अनुरोधों के माध्यम से लगभग निष्पादित किया जाता है:

 # models.py Entry.objects.exclude( pub_date__gt=date(2005, 1, 3), headline='Hello', ) 

कुंजियों का उपयोग करके, आप समान एसक्यूएल एक्सप्रेशन एकत्र कर सकते हैं:

 SELECT * WHERE NOT (pub_date > '2005-1-3' AND headline = 'Hello') 

यह कैसा चल रहा है?

क्वेरीसमूह

exclude विधि में हुड के नीचे एक Query ऑब्जेक्ट है। ऑब्जेक्ट फ़ंक्शन के लिए तर्क दिया जाता है, और यह ऑब्जेक्ट की पदानुक्रम बनाता है, जिनमें से प्रत्येक स्ट्रिंग के रूप में SQL क्वेरी के एक अलग टुकड़े में खुद को बदल सकता है।

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

 # django.db.models.query sql.Query(Entry).where.add( ~Q( Q(F('pub_date') > date(2005, 1, 3)) & Q(headline='Hello') ) ) 

संकलक

 # django.db.models.expressions class Q(tree.Node): AND = 'AND' OR = 'OR' def as_sql(self, compiler, connection): return self.template % self.field.get_lookup('gt') 

उत्पादन

 >>> Q(headline='Hello') # headline = 'Hello' >>> F('pub_date') # pub_date >>> F('pub_date') > date(2005, 1, 3) # pub_date > '2005-1-3' >>> Q(...) & Q(...) # ... AND ... >>> ~Q(...) # NOT … 

एक छोटा हेल्पर-कंपाइलर इस विधि से पास किया जाता है, जो पोस्टग्रेजेक्यूएल से MySQL बोली को अलग कर सकता है और एक विशेष डेटाबेस की बोली में उपयोग की जाने वाली सिंटैक्टिक चीनी को सही ढंग से व्यवस्थित कर सकता है।

DB रूटिंग

जब हम SQL क्वेरी प्राप्त करते हैं, तो मॉडल DB रूटिंग पर दस्तक देता है और पूछता है कि यह किस डेटाबेस में है। 99% मामलों में यह डिफ़ॉल्ट डेटाबेस होगा, शेष 1% में - किसी प्रकार का अपना।

 # django.db.utils class ConnectionRouter: def db_for_read(self, model, **hints): if model._meta.app_label == 'auth': return 'auth_db' 

एक विशिष्ट लायब्रेरी इंटरफ़ेस, जैसे कि पायथन MySQL या Psycopg2 से डेटाबेस ड्राइवर को रैप करना, एक सार्वभौमिक ऑब्जेक्ट बनाता है जो Django के साथ काम कर सकता है। वहाँ कर्सर के लिए एक आवरण है, लेनदेन के लिए एक आवरण है।

कनेक्टिंग पूल

 # django.db.backends.base.base class BaseDatabaseWrapper: def commit(self): self.validate_thread_sharing() self.validate_no_atomic_block() with self.wrap_database_errors: return self.connection.commit() 

इस विशेष कनेक्शन में, हम सॉकेट के लिए अनुरोध भेजते हैं जो डेटाबेस पर दस्तक दे रहा है और निष्पादन की प्रतीक्षा कर रहा है। लायब्रेरी के रैपर डेटाबेस से रिकॉर्ड के रूप में मानव प्रतिक्रिया पढ़ेंगे, और Django पायथन प्रकारों में इस डेटा से मॉडल उदाहरण एकत्र करता है। यह एक जटिल पुनरावृत्ति नहीं है।

हमने डेटाबेस में कुछ लिखा, कुछ पढ़ा, और HTML पृष्ठ का उपयोग करके उपयोगकर्ता को इसके बारे में बताने का निर्णय लिया। ऐसा करने के लिए, Django में एक समुदाय-नापसंद टेम्पलेट भाषा है जो प्रोग्रामिंग भाषा की तरह कुछ दिखती है, केवल एक HTML फ़ाइल में।

खाका

 from django.template.loader import render_to_string render_to_string('my_template.html', {'entries': ...}) 

कोड

 <ul> {% for entry in entries %} <li>{{ entry.name }}</li> {% endfor %} </ul> 

पार्सर

 # django.template.base BLOCK_TAG_START = '{%' BLOCK_TAG_END = '%}' VARIABLE_TAG_START = '{{' VARIABLE_TAG_END = '}}' COMMENT_TAG_START = '{#' COMMENT_TAG_END = '#}' tag_re = (re.compile('(%s.*?%s|%s.*?%s|%s.*?%s)' % (re.escape(BLOCK_TAG_START), re.escape(BLOCK_TAG_END), re.escape(VARIABLE_TAG_START), re.escape(VARIABLE_TAG_END), re.escape(COMMENT_TAG_START), re.escape(COMMENT_TAG_END)))) 

आश्चर्य - पुन: rexxp। केवल अंत में एक अल्पविराम होना चाहिए, और सूची बहुत नीचे जाएगी। यह शायद इस परियोजना में मैंने देखा सबसे कठिन regexp है।

lexer

टेम्पलेट हैंडलर और दुभाषिया बहुत सरल हैं। एक लेक्सर है जो पाठ को छोटे टोकन की सूची में अनुवाद करने के लिए regexp का उपयोग करता है।

 # django.template.base def tokenize(self): for bit in tag_re.split(template_string): lineno += bit.count('\n') yield bit 

हम टोकन की सूची पर पुनरावृति करते हैं, देखो: “तुम कौन हो? आपको एक टैग नोड में लपेटें। " उदाहरण के लिए, यदि यह कुछ की शुरुआत है, if या उसके for , टैग हैंडलर उपयुक्त हैंडलर ले जाएगा। हैंडलर के लिए खुद को फिर से पार्सर बताता है: "मुझे समापन टैग के नीचे टोकन की एक सूची पढ़ें।"

ऑपरेशन फिर से पार्सर के पास जाता है।

नोड, टैग और पार्सर पारस्परिक रूप से पुनरावर्ती चीजें हैं, और पुनरावृत्ति की गहराई आमतौर पर टैग द्वारा टेम्पलेट के नेस्टिंग के बराबर होती है।

पार्सर

 def parse(): while tokens: token = tokens.pop() if token.startswith(BLOCK_TAG_START): yield TagNode(token) elif token.startswith(VARIABLE_TAG_START): ... 

टैग हैंडलर हमें एक विशिष्ट नोड देता है, उदाहरण के लिए, लूप के लिए, जिसके लिए render विधि दिखाई देती है।

पाश के लिए

 # django.template.defaulttags @register.tag('for') def do_for(parser, token): args = token.split_contents() body = parser.parse(until=['endfor']) return ForNode(args, body) 

नोड के लिए

 class ForNode(Node): def render(self, context): with context.push(): for i in self.args: yield self.body.render(context) 

render विधि एक रेंडर ट्री है। प्रत्येक ऊपरी नोड एक बेटी नोड पर जा सकती है, उसे रेंडर करने के लिए कह सकती है। प्रोग्रामर का उपयोग इस टेम्प्लेट में कुछ चर दिखाने के लिए किया जाता है। यह context माध्यम से किया जाता context - इसे एक नियमित शब्दकोश के रूप में प्रस्तुत किया जाता है। जब हम एक टैग दर्ज करते हैं, तो एक गुंजाइश का अनुकरण करने के लिए शब्दकोशों का एक ढेर है। उदाहरण के लिए, यदि context स्वयं लूप के for कुछ अन्य टैग को बदल for है, तो जब हम लूप से बाहर निकलते हैं तो परिवर्तन वापस आ जाएंगे। यह सुविधाजनक है क्योंकि जब सब कुछ वैश्विक है, तो काम करना मुश्किल है।

प्रतिक्रिया

अंत में हमें एचटीटीपी प्रतिक्रिया के साथ हमारी लाइन मिली:

नमस्ते विश्व!

हम उपयोगकर्ता को लाइन दे सकते हैं।

• इस प्रतिक्रिया को दृश्य से वापस करें।
• सूचियों मध्यवार देखें।
• Middlewares इस प्रतिक्रिया को संशोधित, पूरक और बेहतर बनाता है।
• WSGIHandler के अंदर प्रतिक्रिया शुरू होने लगती है, आंशिक रूप से सॉकेट को लिखा जाता है, और ब्राउज़र को हमारे सर्वर से प्रतिक्रिया मिलती है।

सभी प्रसिद्ध स्टार्टअप जो कि Django में लिखे गए थे, जैसे कि Bitbucket या Instagram, ने एक छोटे से चक्र के साथ शुरू किया जो कि हर प्रोग्रामर के माध्यम से चला गया।

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

5 अप्रैल को आर्टीम मालिशेव और 23 अन्य महान वक्ता हमें फिर से मास्को पायथन कॉन्फ ++ सम्मेलन में पायथन विषय पर विचार और चर्चा के लिए बहुत सारे भोजन देंगे। अनुसूची का अध्ययन करें और पायथन का उपयोग करके विभिन्न प्रकार की समस्याओं को हल करने में अनुभव के आदान-प्रदान में शामिल हों।