Python Language
कुप्पी

परिचय

वाक्य - विन्यास

• @ app.route ("/ urlpath", विधियाँ = ["GET", "POST", "DELETE", "PUTS", "HEAD", "विकल्प"])
• @ app.route ("/ urlpath / <param>", तरीके = ["GET", "POST", "DELETE", "PUTS", "HEAD", "विकल्प"])

मूल बातें

निम्नलिखित उदाहरण एक मूल सर्वर का एक उदाहरण है:

# Imports the Flask class
from flask import Flask
# Creates an app and checks if its the main or imported
app = Flask(__name__)

# Specifies what URL triggers hello_world()
@app.route('/')
# The function run on the index route
def hello_world():
    # Returns the text to be displayed
    return "Hello World!"

# If this script isn't an import
if __name__ == "__main__":
    # Run the app until stopped
    app.run()

इस स्क्रिप्ट को चलाने (स्थापित सभी सही निर्भरताओं के साथ) को एक स्थानीय सर्वर शुरू करना चाहिए। मेजबान 127.0.0.1 जिसे आमतौर पर लोकलहोस्ट के रूप में जाना जाता है। डिफ़ॉल्ट रूप से यह सर्वर पोर्ट 5000 पर चलता है। अपने वेबसर्वर तक पहुँचने के लिए, एक वेब ब्राउज़र खोलें और URL localhost:5000 या 127.0.0.1:5000 (कोई अंतर नहीं)। वर्तमान में, केवल आपका कंप्यूटर ही वेबसर्वर का उपयोग कर सकता है।

app.run() में तीन पैरामीटर हैं, होस्ट , पोर्ट और डीबग । होस्ट डिफ़ॉल्ट रूप से 127.0.0.1 , लेकिन इसे 0.0.0.0 पर सेट करने से URL में आपके निजी आईपी पते का उपयोग करके आपके नेटवर्क पर किसी भी डिवाइस से आपके वेब सर्वर को पहुंच प्राप्त होगी। पोर्ट डिफ़ॉल्ट रूप से 5000 है, लेकिन यदि पैरामीटर 80 पोर्ट पर सेट है, तो उपयोगकर्ताओं को पोर्ट नंबर निर्दिष्ट करने की आवश्यकता नहीं होगी क्योंकि ब्राउज़र डिफ़ॉल्ट रूप से पोर्ट 80 का उपयोग करते हैं। डिबग विकल्प के रूप में, विकास प्रक्रिया के दौरान (उत्पादन में कभी नहीं) यह इस पैरामीटर को True पर सेट करने में मदद करता है, क्योंकि आपके फ्लास्क प्रोजेक्ट में किए गए बदलावों के दौरान आपका सर्वर फिर से शुरू हो जाएगा।

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=80, debug=True)

रूटिंग यूआरएल

फ्लास्क के साथ, URL रूटिंग पारंपरिक रूप से डेकोरेटर्स का उपयोग करके किया जाता है। इन डेकोरेटर्स का उपयोग स्टैटिक रूटिंग के लिए किया जा सकता है, साथ ही मापदंडों के साथ यूआरएल को भी रूट किया जा सकता है। निम्नलिखित उदाहरण के लिए, इस फ्लास्क स्क्रिप्ट की वेबसाइट www.example.com चला रही है।

@app.route("/")
def index():
    return "You went to www.example.com"

@app.route("/about")
def about():
    return "You went to www.example.com/about"

@app.route("/users/guido-van-rossum")
    return "You went to www.example.com/guido-van-rossum"

उस अंतिम मार्ग के साथ, आप देख सकते हैं कि एक URL जिसमें यूजर्स / / और प्रोफाइल नाम है, हम एक प्रोफाइल वापस कर सकते हैं। चूँकि यह हर उपयोगकर्ता के लिए एक @app.route() शामिल करने के लिए बहुत ही अयोग्य और गड़बड़ होगा, फ्लास्क URL से पैरामीटर लेने की पेशकश करता है:

@app.route("/users/<username>")
def profile(username):
    return "Welcome to the profile of " + username

cities = ["OMAHA", "MELBOURNE", "NEPAL", "STUTTGART", "LIMA", "CAIRO", "SHANGHAI"]

@app.route("/stores/locations/<city>")
def storefronts(city):
    if city in cities:
        return "Yes! We are located in " + city
    else:
        return "No. We are not located in " + city

HTTP तरीके

HTTP के दो सबसे सामान्य तरीके GET और POST हैं । फ्लास्क इस्तेमाल किए गए HTTP विधि पर निर्भर एक ही यूआरएल से अलग कोड चला सकते हैं। उदाहरण के लिए, खातों के साथ एक वेब सेवा में, साइन इन पेज और साइन इन प्रक्रिया को एक ही URL के माध्यम से रूट करना सबसे सुविधाजनक है। एक GET अनुरोध, वही जो आपके ब्राउज़र में URL खोलते समय किया जाता है, लॉगिन फ़ॉर्म दिखाना चाहिए, जबकि POST अनुरोध (लॉगिन डेटा ले जाने) को अलग से संसाधित किया जाना चाहिए। DELETE और PUT HTTP विधि को संभालने के लिए एक मार्ग भी बनाया गया है।

@app.route("/login", methods=["GET"])
def login_form():
    return "This is the login form"
@app.route("/login", methods=["POST"])
def login_auth():
    return "Processing your data"
@app.route("/login", methods=["DELETE", "PUT"])
def deny():
    return "This method is not allowed"

कोड को थोड़ा सरल करने के लिए, हम फ्लास्क से request पैकेज को आयात कर सकते हैं।

from flask import request

@app.route("/login", methods=["GET", "POST", "DELETE", "PUT"])
def login():
    if request.method == "DELETE" or request.method == "PUT":
        return "This method is not allowed"
    elif request.method == "GET":
        return "This is the login forum"
    elif request.method == "POST":
        return "Processing your data"

POST अनुरोध से डेटा प्राप्त करने के लिए, हमें request पैकेज का उपयोग करना चाहिए:

from flask import request
@app.route("/login", methods=["GET", "POST", "DELETE", "PUT"])
def login():
    if request.method == "DELETE" or request.method == "PUT":
        return "This method is not allowed"
    elif request.method == "GET":
        return "This is the login forum"
    elif request.method == "POST":
        return "Username was " + request.form["username"] + " and password was " + request.form["password"]

फ़ाइलें और टेम्पलेट

हमारे HTML मार्कअप को रिटर्न स्टेटमेंट में टाइप करने के बजाय, हम render_template() फ़ंक्शन का उपयोग कर सकते हैं:

from flask import Flask
from flask import render_template
app = Flask(__name__)

@app.route("/about")
def about():
    return render_template("about-us.html")

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=80, debug=True)

यह हमारे टेम्पलेट फ़ाइल का उपयोग about-us.html करेगा। यह सुनिश्चित करने के लिए कि हमारा आवेदन इस फाइल को पा सके, हमें अपनी निर्देशिका को निम्नलिखित प्रारूप में व्यवस्थित करना चाहिए:

- application.py
/templates
    - about-us.html
    - login-form.html
/static
    /styles
        - about-style.css
        - login-style.css
    /scripts
        - about-script.js
        - login-script.js

सबसे महत्वपूर्ण बात, HTML में इन फ़ाइलों के संदर्भ इस तरह दिखना चाहिए:

<link rel="stylesheet" type="text/css", href="{{url_for('static', filename='styles/about-style.css')}}">

जो स्थैतिक फ़ोल्डर के तहत स्टाइल फ़ोल्डर में about-style.css देखने के लिए एप्लिकेशन को निर्देशित करेगा। पथ का एक ही प्रारूप छवियों, शैलियों, लिपियों या फ़ाइलों के सभी संदर्भों पर लागू होता है।

जिंजा अस्थायी

Meteor.js के समान, फ्लास्क फ्रंट एंड टेंपलेटिंग सेवाओं के साथ अच्छी तरह से एकीकृत होता है। फ्लास्क डिफ़ॉल्ट जिनजा टेंपलेटिंग द्वारा उपयोग करता है। टेम्पलेट HTML फ़ाइल में कोड के छोटे स्निपेट का उपयोग करने की अनुमति देते हैं जैसे कि सशर्त या लूप।

जब हम किसी टेम्प्लेट को रेंडर करते हैं, तो टेम्प्लेट फ़ाइल नाम से परे कोई भी पैरामीटर HTML टेम्प्लेटिंग सेवा में पारित हो जाता है। निम्नलिखित मार्ग एचटीएमएल में उपयोगकर्ता नाम और सम्मिलित तिथि (एक समारोह में कहीं और से) पारित करेगा।

@app.route("/users/<username>)
def profile(username):
    joinedDate = get_joined_date(username) # This function's code is irrelevant
    awards = get_awards(username) # This function's code is irrelevant
    # The joinDate is a string and awards is an array of strings
    return render_template("profile.html", username=username, joinDate=joinDate, awards=awards)

जब यह टेम्प्लेट प्रस्तुत किया जाता है, तो यह render_template() फ़ंक्शन से इसके पास दिए गए चर का उपयोग कर सकता है। यहाँ profile.html की सामग्री हैं profile.html

<!DOCTYPE html>
<html>
    <head>
        # if username
            <title>Profile of {{ username }}</title>
        # else
            <title>No User Found</title>
        # endif
    <head>
    <body>
        {% if username %}
            <h1>{{ username }} joined on the date {{ date }}</h1>
            {% if len(awards) > 0 %}
                <h3>{{ username }} has the following awards:</h3>
                <ul>
                {% for award in awards %}
                    <li>{{award}}</li>
                {% endfor %}
                </ul>
            {% else %}
                <h3>{{ username }} has no awards</h3>
            {% endif %}
        {% else %}
            <h1>No user was found under that username</h1>
        {% endif %}
        {# This is a comment and doesn't affect the output #}
    </body>
</html>

निम्नलिखित व्याख्याओं का उपयोग विभिन्न व्याख्याओं के लिए किया जाता है:

• {% ... %} एक कथन को दर्शाता है
• {{ ... }} एक अभिव्यक्ति को दर्शाता है जहां एक टेम्पलेट आउटपुट होता है
• {# ... #} एक टिप्पणी को दर्शाता है (टेम्पलेट आउटपुट में शामिल नहीं)
• {# ... ## अर्थ है कि शेष रेखा को एक कथन के रूप में समझा जाना चाहिए

अनुरोध वस्तु

request ऑब्जेक्ट रूट के लिए किए गए अनुरोध पर जानकारी प्रदान करता है। इस ऑब्जेक्ट का उपयोग करने के लिए, इसे फ्लास्क मॉड्यूल से आयात किया जाना चाहिए:

from flask import request

URL पैरामीटर

पिछले उदाहरणों में request.method और request.form का उपयोग किया गया था, हालाँकि हम URL पैरामीटर में कुंजियों / मानों के शब्दकोश को पुनः प्राप्त करने के लिए request.args संपत्ति का भी उपयोग कर सकते हैं।

@app.route("/api/users/<username>")
def user_api(username):
    try:
        token = request.args.get("key")
        if key == "pA55w0Rd":
            if isUser(username): # The code of this method is irrelevant
                joined = joinDate(username) # The code of this method is irrelevant
                return "User " + username + " joined on " + joined
            else:
                return "User not found"
        else:
            return "Incorrect key"
    # If there is no key parameter
    except KeyError:
        return "No key provided"

इस संदर्भ में सही तरीके से प्रमाणित करने के लिए, निम्नलिखित URL की आवश्यकता होगी (उपयोगकर्ता नाम को किसी भी उपयोगकर्ता नाम के साथ प्रतिस्थापित करें:

www.example.com/api/users/guido-van-rossum?key=pa55w0Rd

फ़ाइल अपलोड

यदि कोई फ़ाइल अपलोड POST अनुरोध में सबमिट किए गए फॉर्म का हिस्सा था, तो request ऑब्जेक्ट का उपयोग करके फ़ाइलों को संभाला जा सकता है:

@app.route("/upload", methods=["POST"])
def upload_file():
    f = request.files["wordlist-upload"]
    f.save("/var/www/uploads/" + f.filename) # Store with the original filename

कुकीज़

अनुरोध में URL पैरामीटर के समान एक शब्दकोश में कुकीज़ भी शामिल हो सकते हैं।

@app.route("/home")
def home():
    try:
        username = request.cookies.get("username")
        return "Your stored username is " + username
    except KeyError:
        return "No username cookies was found")