add_url_rule(*args, **kwargs)
Connects a URL rule. Works exactly like the route() decorator.
If a view_func is provided it will be registered with the endpoint.
endpoint – the endpoint for the registered URL rule. Flask itself assumes the name of the view function as endpointवास्तव में एक "समापन बिंदु" से क्या अभिप्राय है?
जवाबों:
फ्लास्क का पूरा विचार (और अंतर्निहित Werkzeug पुस्तकालय) URL पथ को कुछ तर्क के लिए मैप करना है जिसे आप चलाएंगे (आमतौर पर, "फ़ंक्शन देखें")। आपका मूल दृष्टिकोण इस तरह परिभाषित किया गया है:
@app.route('/greeting/<name>')
def give_greeting(name):
return 'Hello, {0}!'.format(name)ध्यान दें कि आपके द्वारा निर्दिष्ट फ़ंक्शन (add_url_rule) एक ही लक्ष्य प्राप्त करता है, बस डेकोरेटर नोटेशन का उपयोग किए बिना। इसलिए, निम्नलिखित समान है:
# No "route" decorator here. We will add routing using a different method below.
def give_greeting(name):
return 'Hello, {0}!'.format(name)
app.add_url_rule('/greeting/<name>', 'give_greeting', give_greeting)मान लीजिए कि आपकी वेबसाइट 'www.example.org' पर स्थित है और उपरोक्त दृश्य का उपयोग करती है। उपयोगकर्ता अपने ब्राउज़र में निम्न URL दर्ज करता है:
http://www.example.org/greeting/Markफ्लास्क का काम इस यूआरएल को लेना है, यह पता लगाना कि उपयोगकर्ता क्या करना चाहता है, और इसे संभालने के लिए अपने कई अजगर कार्यों में से एक पर पास करें। यह रास्ता लेता है :
/greeting/Mark... और इसे मार्गों की सूची से मिलाता है। हमारे मामले में, हमने give_greetingफ़ंक्शन पर जाने के लिए इस पथ को परिभाषित किया है।
हालाँकि, यह विशिष्ट तरीका है कि आप एक दृश्य बनाने के बारे में हो सकता है, यह वास्तव में आप से कुछ अतिरिक्त जानकारी सार है। पर्दे के पीछे, फ्लास्क ने URL से सीधे उस दृश्य फ़ंक्शन पर छलांग नहीं लगाई जो इस अनुरोध को संभालना चाहिए। यह बस कहना नहीं है ...
URL (http://www.example.org/greeting/Mark) should be handled by View Function (the function "give_greeting")वास्तव में, यह एक और कदम है, जहां यह URL को एक समापन बिंदु पर मैप करता है:
URL (http://www.example.org/greeting/Mark) should be handled by Endpoint "give_greeting".
Requests to Endpoint "give_greeting" should be handled by View Function "give_greeting"मूल रूप से, "समापन बिंदु" एक पहचानकर्ता है जो यह निर्धारित करने में उपयोग किया जाता है कि आपके कोड की तार्किक इकाई को अनुरोध को क्या संभालना चाहिए । आम तौर पर, एक समापन बिंदु केवल एक दृश्य फ़ंक्शन का नाम है। हालाँकि, आप वास्तव में समापन बिंदु को बदल सकते हैं, जैसा कि निम्नलिखित उदाहरण में किया गया है।
@app.route('/greeting/<name>', endpoint='say_hello')
def give_greeting(name):
return 'Hello, {0}!'.format(name)अब, जब फ्लास्क अनुरोध को रूट करता है, तो तर्क इस तरह दिखता है:
URL (http://www.example.org/greeting/Mark) should be handled by Endpoint "say_hello".
Endpoint "say_hello" should be handled by View Function "give_greeting"समापन बिंदु आमतौर पर "रिवर्स लुकअप" के लिए उपयोग किया जाता है। उदाहरण के लिए, अपने फ्लास्क एप्लिकेशन के एक दृश्य में, आप एक अन्य दृश्य (शायद जब आप साइट के एक क्षेत्र से दूसरे में लिंक कर रहे हैं) का संदर्भ लेना चाहते हैं। URL को हार्ड-कोड करने के बजाय, आप उपयोग कर सकते हैं url_for()। निम्नलिखित मान लें
@app.route('/')
def index():
print url_for('give_greeting', name='Mark') # This will print '/greeting/Mark'
@app.route('/greeting/<name>')
def give_greeting(name):
return 'Hello, {0}!'.format(name)यह लाभप्रद है, क्योंकि अब हम उस संसाधन को संदर्भित करने वाली पंक्ति को बदलने की आवश्यकता के बिना अपने एप्लिकेशन के URL को बदल सकते हैं।
एक सवाल जो सामने आ सकता है वह है: "हमें इस अतिरिक्त परत की आवश्यकता क्यों है?" क्यों एक समापन बिंदु के लिए एक रास्ता है, तो एक दृश्य समारोह के लिए एक समापन बिंदु? सिर्फ उस मध्य कदम को क्यों नहीं छोड़ते?
इसका कारण यह है कि यह इस तरह से अधिक शक्तिशाली है। उदाहरण के लिए, फ्लास्क ब्लूप्रिंट आपके आवेदन को विभिन्न भागों में विभाजित करने की अनुमति देता है। मेरे पास "व्यवस्थापक" नामक ब्लूप्रिंट में मेरे सभी व्यवस्थापक-साइड संसाधन हो सकते हैं, और मेरे सभी उपयोगकर्ता-स्तरीय संसाधन "उपयोगकर्ता" नामक एक समापन बिंदु में हो सकते हैं।
ब्लूप्रिंट आपको नामस्थानों में अलग करने की अनुमति देता है। उदाहरण के लिए...
main.py:
from flask import Flask, Blueprint
from admin import admin
from user import user
app = Flask(__name__)
app.register_blueprint(admin, url_prefix='admin')
app.register_blueprint(user, url_prefix='user')admin.py:
admin = Blueprint('admin', __name__)
@admin.route('/greeting')
def greeting():
return 'Hello, administrative user!'user.py:
user = Blueprint('user', __name__)
@user.route('/greeting')
def greeting():
return 'Hello, lowly normal user!'ध्यान दें कि दोनों ब्लूप्रिंट में, 'ग्रीटिंग' मार्ग एक फ़ंक्शन है जिसे "ग्रीटिंग" कहा जाता है। अगर मैं व्यवस्थापक "ग्रीटिंग" फ़ंक्शन को संदर्भित करना चाहता था, तो मैं सिर्फ "ग्रीटिंग" नहीं कह सकता था क्योंकि उपयोगकर्ता "ग्रीटिंग" फ़ंक्शन भी है। एंडपॉइंट समापन बिंदु के भाग के रूप में ब्लूप्रिंट के नाम को निर्दिष्ट करके एक प्रकार के नेमस्पेसिंग के लिए अनुमति देता है। तो, मैं निम्नलिखित कर सकता है ...
print url_for('admin.greeting') # Prints '/admin/greeting'
print url_for('user.greeting') # Prints '/user/greeting'url_for()फ़ंक्शन में आपका नियम एक्स या वाई कारणों के लिए फ़ंक्शन / वर्ग का नाम बदलकर (किसी ने कोड को फिर से दर्ज किया और अधिक उपयुक्त नाम पाया ...) को तोड़ दिया जा सकता है। फ्लास्क द्वारा स्वतः उत्पन्न एंडपॉइंट्स आपको url के परिवर्तनों को संभालने में मदद करता है। स्पष्ट समापन बिंदु आपको url परिवर्तनों और आपके फ़ंक के नाम परिवर्तनों से निपटने में मदद करता है।
give_greetingइसके स्थान पर नहीं होना चाहिए my_greeting? मैं my_greetingकहीं नहीं देख रहा हूँ ..
एंडपॉइंट वह नाम है जिसका उपयोग url नियमों को रिवर्स-लुकअप करने के लिए किया जाता है url_forऔर यह व्यू फंक्शन के नाम को डिफॉल्ट करता है।
छोटा उदाहरण:
from flask import Flask, url_for
app = Flask(__name__)
# We can use url_for('foo_view') for reverse-lookups in templates or view functions
@app.route('/foo')
def foo_view():
pass
# We now specify the custom endpoint named 'bufar'. url_for('bar_view') will fail!
@app.route('/bar', endpoint='bufar')
def bar_view():
pass
with app.test_request_context('/'):
print url_for('foo_view')
print url_for('bufar')
# url_for('bar_view') will raise werkzeug.routing.BuildError
print url_for('bar_view')
url_forजड़ के लिए कैसे ? मैंने त्रुटिCould not build url for endpoint ''