Python Language
Kolba

Wprowadzenie

Składnia

• @ app.route („/ urlpath”, metody = [„GET”, „POST”, „DELETE”, „PUTS”, „HEAD”, „OPTIONS”])
• @ app.route ("/ urlpath / <param>", metody = [„GET”, „POST”, „DELETE”, „PUTS”, „HEAD”, „OPTIONS”])

Podstawy

Poniższy przykład jest przykładem podstawowego serwera:

# 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()

Uruchomienie tego skryptu (z zainstalowanymi wszystkimi właściwymi zależnościami) powinno uruchomić serwer lokalny. Host to 127.0.0.1 powszechnie znany jako localhost . Ten serwer domyślnie działa na porcie 5000 . Aby uzyskać dostęp do serwera, otwórz przeglądarkę internetową i wprowadź adres URL localhost:5000 lub 127.0.0.1:5000 (bez różnicy). Obecnie tylko twój komputer może uzyskać dostęp do serwera.

app.run() ma trzy parametry: host , port i debugowanie . Host jest domyślnie 127.0.0.1 , ale ustawienie tej wartości na 0.0.0.0 sprawi, że twój serwer będzie dostępny z dowolnego urządzenia w sieci, używając twojego prywatnego adresu IP w adresie URL. port ma domyślnie 5000, ale jeśli parametr jest ustawiony na port 80 , użytkownicy nie będą musieli określać numeru portu, ponieważ przeglądarki domyślnie używają portu 80. Jeśli chodzi o opcję debugowania, podczas procesu programowania (nigdy nie produkcyjnego) pomaga ustawić ten parametr na True, ponieważ serwer uruchomi się ponownie po zmianach wprowadzonych w projekcie Flask.

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

Adresy URL routingu

W Flask routing adresów URL odbywa się tradycyjnie przy użyciu dekoratorów. Tych dekoratorów można używać do routingu statycznego, a także do routingu adresów URL z parametrami. W poniższym przykładzie wyobraź sobie, że ten skrypt Flask prowadzi witrynę 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"

W przypadku tej ostatniej trasy możesz zobaczyć, że podając adres URL z opcją / users / i nazwą profilu, możemy zwrócić profil. Ponieważ dołączenie @app.route() dla każdego użytkownika byłoby okropnie nieefektywne i niechlujne, Flask oferuje pobranie parametrów z adresu 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

Metody HTTP

Dwie najpopularniejsze metody HTTP to GET i POST . Flask może uruchamiać inny kod z tego samego adresu URL w zależności od użytej metody HTTP. Na przykład w usłudze internetowej z kontami najwygodniej jest kierować stronę logowania i proces logowania przez ten sam adres URL. Żądanie GET, takie samo, jak w przypadku otwarcia adresu URL w przeglądarce, powinno zawierać formularz logowania, natomiast żądanie POST (zawierające dane logowania) powinno być przetwarzane osobno. Trasa jest również tworzona w celu obsługi metody DELETE i 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"

Aby nieco uprościć kod, możemy zaimportować pakiet request z kolby.

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"

Aby pobrać dane z żądania POST, musimy użyć pakietu 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"]

Pliki i szablony

Zamiast wpisywać nasz znacznik HTML w instrukcjach return, możemy użyć funkcji 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)

Spowoduje to użycie naszego pliku szablonu about-us.html . Aby nasza aplikacja mogła znaleźć ten plik, musimy zorganizować nasz katalog w następującym formacie:

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

Co najważniejsze, odwołania do tych plików w kodzie HTML muszą wyglądać następująco:

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

co spowoduje, że aplikacja wyszuka about-style.css w folderze styles w folderze statycznym. Ten sam format ścieżki dotyczy wszystkich odniesień do obrazów, stylów, skryptów lub plików.

Jinja Templating

Podobnie jak Meteor.js, Flask dobrze integruje się z usługami szablonów front-end. Flask używa domyślnie szablonów Jinja. Szablony pozwalają na użycie małych fragmentów kodu w pliku HTML, takich jak warunkowe lub pętle.

Kiedy renderujemy szablon, wszelkie parametry poza nazwą pliku szablonu są przekazywane do usługi szablonów HTML. Następująca trasa przekaże nazwę użytkownika i datę dołączenia (z funkcji gdzie indziej) do kodu 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)

Kiedy ten szablon jest renderowany, może używać zmiennych przekazywanych do niego z funkcji render_template() . Oto zawartość 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>

Do różnych interpretacji używane są następujące ograniczniki:

• {% ... %} oznacza instrukcję
• {{ ... }} oznacza wyrażenie, w którym wyprowadzany jest szablon
• {# ... #} oznacza komentarz (nieuwzględniony w szablonie wyjściowym)
• {# ... ## oznacza, że resztę linii należy interpretować jako instrukcję

Obiekt żądania

Obiekt request zawiera informacje o żądaniu złożonym na trasie. Aby wykorzystać ten obiekt, należy go zaimportować z modułu kolby:

from flask import request

Parametry URL

W poprzednich przykładach użyto request.method i request.form , jednak możemy również użyć właściwości request.args aby pobrać słownik kluczy / wartości w parametrach URL.

@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"

Aby poprawnie uwierzytelnić się w tym kontekście, potrzebny będzie następujący adres URL (zastąpienie nazwy użytkownika dowolną nazwą użytkownika:

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

Przesyłanie plików

Jeśli przesłanie pliku było częścią przesłanego formularza w żądaniu POST, pliki można przetwarzać za pomocą obiektu 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

Ciasteczka

Żądanie może również zawierać pliki cookie w słowniku podobnym do parametrów adresu 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")